stashing code

packages/logger/client.ts

@@ -0,0 +1,97 @@
+type LogLevel = "error" | "warn" | "info" | "http" | "debug";
+
+export interface LogEntry {
+  level: LogLevel;
+  timestamp: string;
+  message: any;
+  metadata?: any;
+}
+
+interface Error {
+  code: string;
+  message: string;
+  userHint?: string;
+  detail?: string;
+  error?: any;
+  actionable?: boolean;
+}
+
+class BrowserLogger {
+  private async sendLog(entry: LogEntry) {
+    try {
+      // Only send logs to server in production
+      if (process.env.NODE_ENV === "production") {
+        await fetch("/api/logs", {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify(entry),
+        });
+      }
+
+      // Always log to console in development
+      const consoleMethod = entry.level === "debug" ? "log" : entry.level;
+      // @ts-ignore
+      console[consoleMethod as keyof Console](
+        `[${entry.level}] ${entry.timestamp}: `,
+        entry.message,
+        entry.metadata || "",
+      );
+    } catch (err) {
+      console.error("Failed to send log to server:", err);
+      // @ts-ignore
+      console[entry.level as keyof Console](entry.message);
+    }
+  }
+
+  private createLogEntry(
+    level: LogLevel,
+    message: any,
+    metadata?: any,
+  ): LogEntry {
+    return {
+      level,
+      timestamp: new Date().toISOString(),
+      message,
+      metadata,
+    };
+  }
+
+  error(message: any, metadata?: any) {
+    this.sendLog(this.createLogEntry("error", message, metadata));
+  }
+
+  warn(message: any, metadata?: any) {
+    this.sendLog(this.createLogEntry("warn", message, metadata));
+  }
+
+  info(message: any, metadata?: any) {
+    this.sendLog(this.createLogEntry("info", message, metadata));
+  }
+
+  http(message: any, metadata?: any) {
+    this.sendLog(this.createLogEntry("http", message, metadata));
+  }
+
+  debug(message: any, metadata?: any) {
+    this.sendLog(this.createLogEntry("debug", message, metadata));
+  }
+}
+
+const ClientLogger = new BrowserLogger();
+
+function getError(payload: Error, error?: any) {
+  ClientLogger.error(payload);
+  if (error) {
+    ClientLogger.error(error);
+  }
+  return {
+    code: payload.code,
+    message: payload.message,
+    userHint: payload.userHint,
+    detail: payload.detail,
+    error: error,
+    actionable: payload.actionable,
+  } as Error;
+}
+
+export { ClientLogger, getError };

packages/logger/index.ts

@@ -0,0 +1,105 @@
+import winston from "winston";
+import DailyRotateFile from "winston-daily-rotate-file";
+import path from "path";
+import type { Err } from "@pkg/result";
+import util from "util";
+
+process.on("warning", (warning) => {
+  if (warning.message.includes("punycode")) {
+    return;
+  }
+  console.warn(warning);
+});
+
+const levels = {
+  error: 0,
+  warn: 1,
+  info: 2,
+  http: 3,
+  debug: 4,
+};
+
+const colors = {
+  error: "red",
+  warn: "yellow",
+  info: "green",
+  http: "magenta",
+  debug: "white",
+};
+
+const level = () => {
+  const env = process.env.NODE_ENV || "development";
+  return env === "development" ? "debug" : "warn";
+};
+
+const format = winston.format.combine(
+  winston.format.errors({ stack: true }),
+  winston.format.timestamp({ format: "YYYY-MM-DD HH:mm:ss:ms" }),
+  winston.format.colorize({ all: true }),
+  winston.format.printf((info) => {
+    const { level, message, timestamp, ...extra } = info;
+
+    let formattedMessage = "";
+    if (message instanceof Error) {
+      formattedMessage = message.stack || message.message;
+    } else if (typeof message === "object") {
+      formattedMessage = util.inspect(message, { depth: null, colors: true });
+    } else {
+      formattedMessage = message as any as string;
+    }
+
+    // Handle extra fields (if any)
+    const formattedExtra =
+      Object.keys(extra).length > 0
+        ? `\n${util.inspect(extra, { depth: null, colors: true })}`
+        : "";
+
+    return `[${level}] ${timestamp}: ${formattedMessage}${formattedExtra}`;
+  }),
+);
+
+const transports = [
+  new winston.transports.Console(),
+
+  new DailyRotateFile({
+    filename: path.join("logs", "error-%DATE%.log"),
+    datePattern: "YYYY-MM-DD",
+    level: "error",
+    maxSize: "5m",
+    maxFiles: "14d",
+    format: format,
+  }),
+
+  new DailyRotateFile({
+    filename: path.join("logs", "all-%DATE%.log"),
+    datePattern: "YYYY-MM-DD",
+    maxSize: "5m",
+    maxFiles: "14d",
+    format: format,
+  }),
+];
+
+winston.addColors(colors);
+
+const Logger = winston.createLogger({
+  level: level(),
+  levels,
+  format,
+  transports,
+});
+
+const stream = { write: (message: string) => Logger.http(message.trim()) };
+
+function getError(payload: Err, error?: any) {
+  Logger.error(JSON.stringify({ payload, error }, null, 2));
+  return {
+    code: payload.code,
+    message: payload.message,
+    userHint: payload.userHint,
+    detail: payload.detail,
+    error: error instanceof Error ? error.message : error,
+    actionable: payload.actionable,
+  } as Err;
+}
+
+export { Logger, stream, getError };

packages/logger/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "@pkg/logger",
+  "module": "index.ts",
+  "type": "module",
+  "devDependencies": {
+    "@types/bun": "latest"
+  },
+  "peerDependencies": {
+    "typescript": "^5.0.0"
+  },
+  "dependencies": {
+    "@pkg/result": "workspace:*",
+    "winston": "^3.17.0",
+    "winston-daily-rotate-file": "^5.0.0"
+  }
+}