refactor: replace logger with prefixed logger in API files

AGENTS.md

···
+# Repository Guidelines
+
+## Project Structure & Modules
+- `apps/web`: Vite + React 19 frontend (sources under `src/`, static assets in `public/`).
+- `apps/api`: Hono-based API server (entry `src/index.ts`, routes in `src/routes/`).
+- `packages/*`: Shared code (`helpers`, `data`, `types`, `indexer`, `config`).
+- `script/*`: Maintenance utilities (e.g., sorting `package.json`, cleaning branches).
+- Tooling: PNPM workspaces (`pnpm-workspace.yaml`), Biome config (`biome.json`), Husky hooks (`.husky/`).
+
+## Build, Test, and Development
+- Root dev: `pnpm dev` — run all workspaces in watch mode.
+- Root build: `pnpm build` — build all workspaces in parallel.
+- Web app: `pnpm -F @hey/web dev` (preview: `pnpm -F @hey/web start`, build: `pnpm -F @hey/web build`).
+- API: `pnpm -F @hey/api dev` (typecheck: `pnpm -F @hey/api typecheck`).
+- Lint/format: `pnpm biome:check` (auto-fix: `pnpm biome:fix`).
+- Types: `pnpm typecheck` — TypeScript across the monorepo.
+- Node & PM: Node 20 (`.nvmrc`), PNPM 10 (see `package.json#packageManager`).
+
+## Coding Style & Naming
+- Language: TypeScript (strict, shared configs in `packages/config`).
+- Formatting: Biome controls style; no trailing commas; spaces for indentation.
+- Imports: Use workspace packages (`@hey/*`) and web alias `@/*` to `apps/web/src`.
+- Files: React components `PascalCase.tsx`; helpers/stores `camelCase.ts`.
+- Keep modules small, colocate domain helpers with their feature when practical.
+
+## Testing Guidelines
+- Current status: no formal unit tests present. Enforce quality via `biome` and `tsc`.
+- If adding tests, prefer Vitest for web and lightweight integration tests for API.
+- Naming: `*.test.ts` or `*.test.tsx`, colocated with the code or under `__tests__/`.
+- Run with a future `pnpm test` script at root or per package.
+
+## Commit & Pull Requests
+- Commits: imperative mood, concise subject; optional scope like `web:`, `api:`, `helpers:`.
+- Include rationale and references (e.g., `Closes #123`).
+- PRs: clear description, screenshots for UI changes, reproduction steps for fixes, and env notes.
+- CI hooks: pre-commit runs `biome` and type checks; ensure both pass locally before pushing.
+
+## Security & Configuration
+- Copy `.env.example` to `.env` in `apps/web` and `apps/api`. Never commit secrets.
+- Validate envs at startup; keep keys minimal and documented near usage.

apps/api/src/index.ts

···
 import { serve } from "@hono/node-server";
 import "dotenv/config";
 import { Status } from "@hey/data/enums";
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import { Hono } from "hono";
 import authContext from "./context/authContext";
 import authMiddleware from "./middlewares/authMiddleware";
···
 import ping from "./routes/ping";
 import startDiscordWebhookWorker from "./workers/discordWebhook";
 
+const log = withPrefix("[API]");
+
 const app = new Hono();
 
-// Context
 app.use(cors);
 app.use(authContext);
 
-// Routes
 app.get("/ping", ping);
 app.route("/lens", lensRouter);
 app.route("/cron", cronRouter);
···
 );
 
 serve({ fetch: app.fetch, port: 4784 }, (info) => {
-  logger.info(`Server running on port ${info.port}`);
+  log.info(`Server running on port ${info.port}`);
 });
 
-// Start Discord webhook worker if Redis + webhook envs are configured
 if (
   process.env.REDIS_URL &&
   (process.env.EVENTS_DISCORD_WEBHOOK_URL ||
     process.env.PAGEVIEWS_DISCORD_WEBHOOK_URL)
 ) {
-  // Fire and forget
   void startDiscordWebhookWorker();
 } else {
-  logger.warn("Discord worker not started: missing Redis or webhook envs");
+  log.warn("Discord worker not started: missing Redis or webhook envs");
 }

apps/api/src/middlewares/authMiddleware.ts

···
 import { LENS_API_URL } from "@hey/data/constants";
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import type { Context, Next } from "hono";
 import { createRemoteJWKSet, jwtVerify } from "jose";
 
 const jwksUri = `${LENS_API_URL.replace("/graphql", "")}/.well-known/jwks.json`;
-// Cache the JWKS for 12 hours
 const JWKS = createRemoteJWKSet(new URL(jwksUri), {
   cacheMaxAge: 60 * 60 * 12
 });
···
 const unauthorized = (c: Context) => c.body("Unauthorized", 401);
 
 const authMiddleware = async (c: Context, next: Next) => {
+  const log = withPrefix("[API]");
   const token = c.get("token");
 
   if (!token) {
-    logger.warn("missing token");
+    log.warn("missing token");
     return unauthorized(c);
   }
 
   try {
     await jwtVerify(token, JWKS);
   } catch {
-    logger.warn("invalid token");
+    log.warn("invalid token");
     return unauthorized(c);
   }
 

apps/api/src/pageview.ts

···
 import { Status } from "@hey/data/enums";
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import type { Context } from "hono";
 import enqueueDiscordWebhook from "./utils/discordQueue";
 import getIpData from "./utils/getIpData";
+
+const log = withPrefix("[API]");
 
 interface PageviewBody {
   path?: string;
···
     };
     await enqueueDiscordWebhook(item);
   } catch (err) {
-    logger.error("Failed to enqueue pageview webhook", err as Error);
+    log.error("Failed to enqueue pageview webhook", err as Error);
   }
 
   return ctx.json({ data: { ok: true }, status: Status.Success });

apps/api/src/posts.ts

···
 import { Status } from "@hey/data/enums";
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import type { Context } from "hono";
 import enqueueDiscordWebhook from "./utils/discordQueue";
+
+const log = withPrefix("[API]");
 
 interface PostsBody {
   slug?: string;
···
 
     await enqueueDiscordWebhook(item);
   } catch (err) {
-    logger.error("Failed to enqueue post webhook", err as Error);
+    log.error("Failed to enqueue post webhook", err as Error);
   }
 
   return ctx.json({ data: { ok: true }, status: Status.Success });

apps/api/src/routes/cron/removeExpiredSubscribers/index.ts

···
 import { PERMISSIONS } from "@hey/data/constants";
 import { Status } from "@hey/data/enums";
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import type { Context } from "hono";
 import handleApiError from "@/utils/handleApiError";
 import lensPg from "@/utils/lensPg";
···
       });
     }
 
-    // Run the removal operation in the background without awaiting
+    const log = withPrefix("[API]");
     const membersToRemove = addresses.map((addr) => ({
       account: addr,
       customParams: [],
···
         functionName: "removeMembers"
       })
       .then((hash) => {
-        logger.info("Expired subscribers removal completed", {
+        log.info("Expired subscribers removal completed", {
           count: addresses.length,
           hash
         });
       })
       .catch((error) => {
-        logger.error("Expired subscribers removal failed:", error);
+        log.error("Expired subscribers removal failed:", error);
       });
 
     return ctx.json({

apps/api/src/utils/discordQueue.ts

···
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import { DISCORD_QUEUE_KEY, getRedis } from "./redis";
 
 export interface DiscordQueueItemBase {
···
 export const enqueueDiscordWebhook = async (
   item: DiscordQueueItem
 ): Promise<void> => {
+  const log = withPrefix("[API]");
   try {
     const redis = getRedis();
     await redis.rpush(DISCORD_QUEUE_KEY, JSON.stringify(item));
-    logger.info(`Enqueued discord webhook: ${item.kind}`);
+    log.info(`Enqueued discord webhook: ${item.kind}`);
   } catch (err) {
-    logger.error("Failed to enqueue discord webhook", err as Error);
+    log.error("Failed to enqueue discord webhook", err as Error);
   }
 };
 

apps/api/src/utils/handleApiError.ts

···
 import { Status } from "@hey/data/enums";
 import { ERRORS } from "@hey/data/errors";
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import type { Context } from "hono";
 import ApiError from "@/utils/apiError";
 
 const handleApiError = (ctx: Context, error?: unknown): Response => {
-  logger.error(error);
+  const log = withPrefix("[API]");
+  log.error(error);
 
   if (error instanceof ApiError) {
     ctx.status(error.statusCode);

apps/api/src/utils/lensPg.ts

···
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import dotenv from "dotenv";
 import type { IDatabase, IFormatting, IHelpers, IMain } from "pg-promise";
 import pgPromise from "pg-promise";
···
   ): InitializeDbResult {
     const pgp = pgPromise({
       error: (error: unknown) => {
+        const log = withPrefix("[API]");
         const errorMessage =
           error instanceof Error ? error.message : String(error);
-        logger.error(`LENS POSTGRES ERROR WITH TRACE: ${errorMessage}`);
+        log.error(`LENS POSTGRES ERROR WITH TRACE: ${errorMessage}`);
       }
     });
 

apps/api/src/utils/redis.ts

···
   redisClient = new IORedis(url);
   return redisClient;
 };
-
-export default getRedis;

apps/api/src/utils/syncAddressesToGuild.ts

···
 import { createGuildClient, createSigner } from "@guildxyz/sdk";
 import { Status } from "@hey/data/enums";
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import signer from "./signer";
 
 const guildClient = createGuildClient("heyxyz");
···
   requirementId: number;
   roleId: number;
 }) => {
-  // Run the sync operation in the background without awaiting
+  const log = withPrefix("[API]");
   requirementClient
     .update(
       7465,
···
       signerFunction
     )
     .then(() => {
-      logger.info("Guild sync completed");
+      log.info("Guild sync completed");
     })
     .catch((error) => {
-      logger.error("Guild sync failed:", error);
+      log.error("Guild sync failed:", error);
     });
 
   return {

apps/api/src/workers/discordWebhook.ts

···
-import logger from "@hey/helpers/logger";
+import { withPrefix } from "@hey/helpers/logger";
 import type IORedis from "ioredis";
 import type {
   DiscordQueueItem,
···
   PostQueueItem
 } from "../utils/discordQueue";
 import { DISCORD_QUEUE_KEY, getRedis } from "../utils/redis";
+
+const log = withPrefix("[Worker]");
 
 const sleep = (ms: number): Promise<void> =>
   new Promise((res) => setTimeout(res, ms));
···
     if (!item || !("kind" in item)) return null;
     return item;
   } catch (e) {
-    logger.error("Failed to parse queue item", e as Error);
+    log.error("Failed to parse queue item", e as Error);
     return null;
   }
 };
···
   }
 
   if (!webhookUrl) {
-    logger.warn(`Skipping ${item.kind} webhook: missing webhook URL env`);
+    log.warn(`Skipping ${item.kind} webhook: missing webhook URL env`);
     return;
   }
 
···
   try {
     redis = getRedis();
   } catch (_e) {
-    logger.warn("Discord worker disabled: Redis not configured");
+    log.warn("Discord worker disabled: Redis not configured");
     return;
   }
 
-  logger.info(`Discord worker started. Queue: ${DISCORD_QUEUE_KEY}`);
+  log.info(`Discord worker started. Queue: ${DISCORD_QUEUE_KEY}`);
 
   // Blocking pop loop using BRPOP with small timeout
   // eslint-disable-next-line no-constant-condition
···
 
       try {
         await dispatch(item);
-        logger.info(`Dispatched Discord webhook: ${item.kind}`);
+        log.info(`Dispatched Discord webhook: ${item.kind}`);
       } catch (_err) {
         const retries = (item.retries ?? 0) + 1;
         if (retries <= 3) {
           item.retries = retries;
           await redis.rpush(DISCORD_QUEUE_KEY, JSON.stringify(item));
-          logger.warn(`Requeued ${item.kind} webhook (attempt ${retries})`);
+          log.warn(`Requeued ${item.kind} webhook (attempt ${retries})`);
         } else {
-          logger.error(
-            `Dropped ${item.kind} webhook after ${retries} attempts`
-          );
+          log.error(`Dropped ${item.kind} webhook after ${retries} attempts`);
         }
       }
     } catch (loopErr) {
-      logger.error("Discord worker loop error", loopErr as Error);
+      log.error("Discord worker loop error", loopErr as Error);
       await sleep(1000);
     }
   }

packages/helpers/logger.ts

···
   }
 };
 
+export const withPrefix = (prefix: string) => {
+  return {
+    debug: (...args: unknown[]) => debug(prefix, ...args),
+    error: (...args: unknown[]) => error(prefix, ...args),
+    info: (...args: unknown[]) => info(prefix, ...args),
+    warn: (...args: unknown[]) => warn(prefix, ...args)
+  };
+};
+
 export default {
   debug,
   error,