refactor: split monolith into 3 microservices (frontend, backend, discord-gateway)

- Extract services into services/{frontend,backend,discord-gateway}
- Create packages/shared/ for shared logger, errors, utils, types
- Setup Modular MVC pattern in backend (controller→service→repository)
- Setup event-driven architecture in discord-gateway with Redis pub/sub
- Move Docker files to infra/docker/ with per-service Dockerfiles
- Update docker-compose.yml to use Traefik-only routing (no port exposes)
- Update GitHub Actions deploy workflow for multi-service matrix build
- Fix all import paths and resolve type errors across all services
- All 3 services pass tsc --noEmit clean

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

services/discord-gateway/src/shared/logger/logger.ts

@@ -0,0 +1,132 @@
+import fs from "node:fs";
+import path from "node:path";
+import winston from "winston";
+import { formatLogMetadata, serializeLogValue } from "./serialization.js";
+
+const isDev = process.env.NODE_ENV !== "production";
+const logLevel = process.env.LOG_LEVEL || (isDev ? "debug" : "info");
+const logsDir = path.resolve(process.cwd(), "logs");
+
+fs.mkdirSync(logsDir, { recursive: true });
+
+const metadataFormat = winston.format((info) => {
+  const {
+    level: _level,
+    message: _message,
+    timestamp: _timestamp,
+    ...metadata
+  } = info;
+
+  for (const key of Object.keys(metadata)) {
+    delete info[key];
+  }
+
+  Object.assign(info, formatLogMetadata(metadata));
+  return info;
+});
+
+const consoleFormat = winston.format.printf((info) => {
+  const { level, message, timestamp, context, ...metadata } = info;
+  const contextLabel = context ? ` [${String(context)}]` : "";
+  const metadataText = Object.keys(metadata).length
+    ? ` ${JSON.stringify(formatLogMetadata(metadata))}`
+    : "";
+
+  return `${timestamp} ${level}${contextLabel}: ${message}${metadataText}`;
+});
+
+export interface CustomLogger {
+  error: (msgOrObj: any, msgOrArgs?: any, ...args: any[]) => void;
+  warn: (msgOrObj: any, msgOrArgs?: any, ...args: any[]) => void;
+  info: (msgOrObj: any, msgOrArgs?: any, ...args: any[]) => void;
+  debug: (msgOrObj: any, msgOrArgs?: any, ...args: any[]) => void;
+  trace: (msgOrObj: any, msgOrArgs?: any, ...args: any[]) => void;
+  fatal: (msgOrObj: any, msgOrArgs?: any, ...args: any[]) => void;
+  silent: (msgOrObj: any, msgOrArgs?: any, ...args: any[]) => void;
+  child(options: { context: string } & Record<string, any>): CustomLogger;
+  [key: string]: any;
+}
+
+const winstonLogger = winston.createLogger({
+  level: logLevel,
+  levels: winston.config.npm.levels,
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.errors({ stack: true }),
+    metadataFormat(),
+  ),
+  transports: [
+    new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.timestamp(),
+        metadataFormat(),
+        consoleFormat,
+      ),
+    }),
+    new winston.transports.File({
+      filename: path.join(logsDir, "app.log"),
+      format: winston.format.json(),
+    }),
+    new winston.transports.File({
+      filename: path.join(logsDir, "error.log"),
+      level: "error",
+      format: winston.format.json(),
+    }),
+  ],
+});
+
+function wrapLogger(wLogger: winston.Logger): CustomLogger {
+  const logAtLevel = (level: string) => {
+    return (arg1: any, arg2?: any) => {
+      if (arg1 instanceof Error) {
+        wLogger.log(level, arg1.message, { error: arg1 });
+      } else if (typeof arg1 === "object" && arg1 !== null) {
+        const message = typeof arg2 === "string" ? arg2 : "";
+        wLogger.log(level, message, { ...arg1 });
+      } else {
+        const message = typeof arg1 === "string" ? arg1 : String(arg1);
+        const metadata = typeof arg2 === "object" && arg2 !== null ? arg2 : {};
+        wLogger.log(level, message, metadata);
+      }
+    };
+  };
+
+  const wrapped: CustomLogger = {
+    error: logAtLevel("error"),
+    warn: logAtLevel("warn"),
+    info: logAtLevel("info"),
+    debug: logAtLevel("debug"),
+    trace: logAtLevel("debug"),
+    fatal: logAtLevel("error"),
+    silent: () => {},
+    child: (options: any) => {
+      const childWinston = wLogger.child(options);
+      return wrapLogger(childWinston);
+    },
+  };
+
+  const proxy = new Proxy(wrapped, {
+    get(target, prop) {
+      if (prop in target) {
+        return (target as any)[prop];
+      }
+      const val = (wLogger as any)[prop];
+      if (typeof val === "function") {
+        return val.bind(wLogger);
+      }
+      return val;
+    },
+  });
+
+  return proxy;
+}
+
+export const logger: CustomLogger = wrapLogger(winstonLogger);
+
+export const createChildLogger = (context: string): CustomLogger => {
+  return logger.child({ context });
+};
+
+export const serializeLogValueForTest = serializeLogValue;
+export const formatLogMetadataForTest = formatLogMetadata;

services/discord-gateway/src/shared/logger/serialization.ts

@@ -0,0 +1,109 @@
+export type LogMetadata = Record<string, unknown>;
+
+type SerializedError = {
+  name: string;
+  message: string;
+  stack?: string;
+  code?: unknown;
+  statusCode?: unknown;
+} & Record<string, unknown>;
+
+const serializeError = (error: Error): SerializedError => {
+  const serialized: SerializedError = {
+    name: error.name,
+    message: error.message,
+  };
+
+  if (error.stack) {
+    serialized.stack = error.stack;
+  }
+
+  const errorWithFields = error as Error & {
+    code?: unknown;
+    statusCode?: unknown;
+    [key: string]: unknown;
+  };
+
+  if (errorWithFields.code !== undefined) {
+    serialized.code = errorWithFields.code;
+  }
+
+  if (errorWithFields.statusCode !== undefined) {
+    serialized.statusCode = errorWithFields.statusCode;
+  }
+
+  for (const [key, value] of Object.entries(errorWithFields)) {
+    if (serialized[key] === undefined) {
+      serialized[key] = value;
+    }
+  }
+
+  return serialized;
+};
+
+const isPlainObject = (value: unknown): value is Record<string, unknown> => {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+};
+
+export const serializeLogValue = (
+  value: unknown,
+  _seen: WeakSet<object> = new WeakSet(),
+): unknown => {
+  if (value === null || value === undefined) return value;
+
+  if (value instanceof Error) {
+    return serializeError(value);
+  }
+
+  if (value instanceof Date) {
+    return value.toISOString();
+  }
+
+  if (value instanceof RegExp) {
+    return value.toString();
+  }
+
+  if (typeof value === "object") {
+    if (_seen.has(value as object)) {
+      return "[Circular]";
+    }
+    _seen.add(value as object);
+  }
+
+  if (Array.isArray(value)) {
+    return value.map((item) => serializeLogValue(item, _seen));
+  }
+
+  if (isPlainObject(value)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, nestedValue]) => [
+        key,
+        serializeLogValue(nestedValue, _seen),
+      ]),
+    );
+  }
+
+  if (typeof value === "object") {
+    try {
+      return `[Object ${(value as any)?.constructor?.name ?? "unknown"}]`;
+    } catch {
+      return "[Object]";
+    }
+  }
+
+  return value;
+};
+
+export const formatLogMetadata = (metadata: LogMetadata): LogMetadata => {
+  return Object.fromEntries(
+    Object.entries(metadata).map(([key, value]) => [
+      key,
+      serializeLogValue(value),
+    ]),
+  );
+};