@blyp/core 0.1.2

package/dist/workers.js

@@ -0,0 +1,626 @@
+'use strict';
+
+// src/core/colors.ts
+function getMethodColor(method) {
+  const colors = {
+    GET: "\x1B[32m",
+    POST: "\x1B[36m",
+    PUT: "\x1B[33m",
+    PATCH: "\x1B[34m",
+    DELETE: "\x1B[31m"
+  };
+  const reset = "\x1B[0m";
+  return `${colors[method.toUpperCase()] || ""}${method}${reset}`;
+}
+function getStatusColor(statusCode) {
+  const reset = "\x1B[0m";
+  if (statusCode >= 500) return `\x1B[31m${statusCode}${reset}`;
+  if (statusCode >= 400) return `\x1B[33m${statusCode}${reset}`;
+  if (statusCode >= 300) return `\x1B[36m${statusCode}${reset}`;
+  if (statusCode >= 200) return `\x1B[32m${statusCode}${reset}`;
+  return `\x1B[37m${statusCode}${reset}`;
+}
+function getArrowForMethod(method) {
+  const arrows = {
+    GET: "\u2192",
+    POST: "\u2191",
+    PUT: "\u21D1",
+    PATCH: "\u2197",
+    DELETE: "\u2715"
+  };
+  return arrows[method.toUpperCase()] || "\u2022";
+}
+function getResponseTimeColor(ms) {
+  const reset = "\x1B[0m";
+  if (ms < 100) return `\x1B[32m${ms}ms${reset}`;
+  if (ms < 300) return `\x1B[33m${ms}ms${reset}`;
+  if (ms < 1e3) return `\x1B[31m${ms}ms${reset}`;
+  return `\x1B[41m\x1B[37m${ms}ms${reset}`;
+}
+
+// src/frameworks/shared/http.ts
+function getHeaderValue(headers, name) {
+  if (!headers) {
+    return void 0;
+  }
+  if (headers instanceof Headers) {
+    return headers.get(name) ?? headers.get(name.toLowerCase()) ?? void 0;
+  }
+  if (typeof headers.get === "function") {
+    const direct2 = headers.get(name);
+    return direct2 ?? headers.get(name.toLowerCase()) ?? void 0;
+  }
+  const record = headers;
+  const direct = record[name] ?? record[name.toLowerCase()];
+  if (Array.isArray(direct)) {
+    return direct[0];
+  }
+  return direct;
+}
+function parseForwardedHeader(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean).map((entry) => {
+    const match = entry.match(/for="?(\[[^\]]+\]|[^;,\s"]+)/i);
+    return match?.[1]?.replace(/^"|"$/g, "") ?? "";
+  }).map((entry) => entry.replace(/^\[|\]$/g, "")).filter(Boolean);
+}
+function parseForwardedFor(value) {
+  if (!value) {
+    return [];
+  }
+  return value.split(",").map((entry) => entry.trim()).filter(Boolean);
+}
+function stripPort(host) {
+  if (host.startsWith("[")) {
+    const endIndex = host.indexOf("]");
+    return endIndex >= 0 ? host.slice(1, endIndex) : host;
+  }
+  return host.replace(/:\d+$/, "");
+}
+function detectBrowser(userAgent) {
+  if (/edg\//i.test(userAgent)) return "Edge";
+  if (/opr\//i.test(userAgent) || /opera/i.test(userAgent)) return "Opera";
+  if (/chrome\//i.test(userAgent) && !/edg\//i.test(userAgent)) return "Chrome";
+  if (/firefox\//i.test(userAgent)) return "Firefox";
+  if (/safari\//i.test(userAgent) && !/chrome\//i.test(userAgent)) return "Safari";
+  if (/curl\//i.test(userAgent)) return "curl";
+  if (/postmanruntime/i.test(userAgent)) return "Postman";
+  return "Unknown";
+}
+function detectOperatingSystem(userAgent) {
+  if (/windows/i.test(userAgent)) return "Windows";
+  if (/android/i.test(userAgent)) return "Android";
+  if (/iphone|ipad|ipod/i.test(userAgent)) return "iOS";
+  if (/mac os x|macintosh/i.test(userAgent)) return "macOS";
+  if (/linux/i.test(userAgent)) return "Linux";
+  return "Unknown";
+}
+function detectDeviceType(userAgent) {
+  if (!userAgent) return "unknown";
+  if (/bot|crawler|spider|curl|wget|postmanruntime/i.test(userAgent)) return "bot";
+  if (/ipad|tablet/i.test(userAgent)) return "tablet";
+  if (/mobi|iphone|android/i.test(userAgent)) return "mobile";
+  return "desktop";
+}
+function extractPathname(requestUrl, fallbackPath = "/") {
+  if (!requestUrl) {
+    return fallbackPath;
+  }
+  if (requestUrl.startsWith("http://") || requestUrl.startsWith("https://")) {
+    try {
+      return new URL(requestUrl).pathname || fallbackPath;
+    } catch {
+      return fallbackPath;
+    }
+  }
+  if (requestUrl.startsWith("/")) {
+    const queryIndex = requestUrl.indexOf("?");
+    return queryIndex >= 0 ? requestUrl.slice(0, queryIndex) : requestUrl;
+  }
+  try {
+    return new URL(requestUrl, "http://localhost").pathname || fallbackPath;
+  } catch {
+    return fallbackPath;
+  }
+}
+function createRequestLike(method, url, headers) {
+  return { method, url, headers };
+}
+function buildClientDetails(request, fallbackPath) {
+  const pathname = fallbackPath ?? extractPathname(request.url);
+  const urlObject = (() => {
+    try {
+      return new URL(request.url);
+    } catch {
+      try {
+        return new URL(pathname, "http://localhost");
+      } catch {
+        return null;
+      }
+    }
+  })();
+  const hostHeader = getHeaderValue(request.headers, "x-forwarded-host") ?? getHeaderValue(request.headers, "host") ?? urlObject?.host ?? void 0;
+  const hostname = hostHeader ? stripPort(hostHeader) : urlObject?.hostname;
+  const port = hostHeader?.match(/:(\d+)$/)?.[1] ?? (urlObject?.port || void 0);
+  const xForwardedFor = parseForwardedFor(getHeaderValue(request.headers, "x-forwarded-for"));
+  const forwardedFor = parseForwardedHeader(getHeaderValue(request.headers, "forwarded"));
+  const ipCandidates = [
+    getHeaderValue(request.headers, "cf-connecting-ip"),
+    getHeaderValue(request.headers, "true-client-ip"),
+    getHeaderValue(request.headers, "fly-client-ip"),
+    getHeaderValue(request.headers, "x-real-ip"),
+    getHeaderValue(request.headers, "x-client-ip"),
+    xForwardedFor[0],
+    forwardedFor[0]
+  ].filter((value) => Boolean(value));
+  const userAgent = getHeaderValue(request.headers, "user-agent");
+  const platform = getHeaderValue(request.headers, "sec-ch-ua-platform")?.replace(/^"|"$/g, "") ?? void 0;
+  const deviceType = detectDeviceType(userAgent ?? "");
+  return {
+    hostname,
+    ip: ipCandidates[0],
+    forwardedFor: [...xForwardedFor, ...forwardedFor].filter((value, index, values) => {
+      return values.indexOf(value) === index;
+    }),
+    protocol: getHeaderValue(request.headers, "x-forwarded-proto") ?? (urlObject?.protocol ? urlObject.protocol.replace(/:$/, "") : void 0),
+    port,
+    userAgent,
+    origin: getHeaderValue(request.headers, "origin"),
+    referer: getHeaderValue(request.headers, "referer"),
+    acceptLanguage: getHeaderValue(request.headers, "accept-language"),
+    client: {
+      ip: ipCandidates[0],
+      hostname,
+      browser: userAgent ? detectBrowser(userAgent) : void 0,
+      os: userAgent ? detectOperatingSystem(userAgent) : void 0,
+      deviceType,
+      platform,
+      isMobile: deviceType === "mobile"
+    }
+  };
+}
+function buildRequestLogData(request, type, path, statusCode, responseTime, extra = {}) {
+  return {
+    type,
+    method: request.method,
+    url: path,
+    statusCode,
+    responseTime,
+    ...buildClientDetails(request, path),
+    ...extra
+  };
+}
+function buildInfoLogMessage(method, statusCode, url, responseTime) {
+  const methodColor = getMethodColor(method);
+  const statusColor = getStatusColor(statusCode);
+  const timeColor = getResponseTimeColor(responseTime);
+  const arrow = getArrowForMethod(method);
+  return `${methodColor} ${arrow} ${statusColor} ${url} ${timeColor}`;
+}
+function toErrorLike(error, fallbackStatusCode) {
+  if (error === void 0 || error === null) {
+    return fallbackStatusCode === void 0 ? void 0 : { statusCode: fallbackStatusCode, message: `HTTP ${fallbackStatusCode}` };
+  }
+  if (error instanceof Error) {
+    const errorWithStatus = error;
+    return {
+      status: errorWithStatus.status,
+      statusCode: errorWithStatus.statusCode ?? fallbackStatusCode,
+      code: errorWithStatus.code,
+      message: error.message,
+      stack: error.stack,
+      why: errorWithStatus.why,
+      fix: errorWithStatus.fix,
+      link: errorWithStatus.link,
+      details: errorWithStatus.details,
+      cause: errorWithStatus.cause
+    };
+  }
+  if (typeof error === "object") {
+    const record = error;
+    return {
+      status: typeof record.status === "number" ? record.status : void 0,
+      statusCode: typeof record.statusCode === "number" ? record.statusCode : fallbackStatusCode,
+      code: typeof record.code === "string" || typeof record.code === "number" ? record.code : void 0,
+      message: typeof record.message === "string" ? record.message : `HTTP ${fallbackStatusCode ?? 500}`,
+      stack: typeof record.stack === "string" ? record.stack : void 0,
+      why: typeof record.why === "string" ? record.why : void 0,
+      fix: typeof record.fix === "string" ? record.fix : void 0,
+      link: typeof record.link === "string" ? record.link : void 0,
+      details: record.details !== null && typeof record.details === "object" && !Array.isArray(record.details) ? record.details : void 0,
+      cause: record.cause
+    };
+  }
+  return {
+    statusCode: fallbackStatusCode,
+    message: typeof error === "string" ? error : `HTTP ${fallbackStatusCode ?? 500}`
+  };
+}
+function isErrorStatus(statusCode) {
+  return statusCode >= 400;
+}
+
+// src/core/structured-log.ts
+function serializeMessage(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message !== null && typeof message === "object") {
+    try {
+      return JSON.stringify(
+        message,
+        (_key, value) => {
+          if (typeof value === "function") {
+            return `[Function: ${value.name || "anonymous"}]`;
+          }
+          if (value === void 0) {
+            return "[undefined]";
+          }
+          if (typeof value === "symbol") {
+            return value.toString();
+          }
+          return value;
+        },
+        2
+      );
+    } catch {
+      return "[Object]";
+    }
+  }
+  return String(message);
+}
+function normalizeEventData(message, args) {
+  if (typeof message === "string") {
+    if (args.length === 0) {
+      return void 0;
+    }
+    return args.length === 1 ? args[0] : args;
+  }
+  const values = [message, ...args];
+  return values.length === 1 ? values[0] : values;
+}
+function normalizeDetails(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return void 0;
+  }
+  return value;
+}
+function normalizeError(error, fallbackStatus) {
+  if (error === void 0 || error === null) {
+    return fallbackStatus === void 0 || fallbackStatus < 400 ? void 0 : {
+      message: `HTTP ${fallbackStatus}`,
+      code: fallbackStatus,
+      type: "HttpError"
+    };
+  }
+  if (error instanceof Error) {
+    const errorLike = error;
+    return {
+      message: error.message,
+      code: errorLike.code,
+      type: errorLike.type ?? error.name ?? error.constructor?.name,
+      stack: error.stack,
+      why: errorLike.why,
+      fix: errorLike.fix,
+      link: errorLike.link,
+      details: normalizeDetails(errorLike.details),
+      cause: errorLike.cause
+    };
+  }
+  if (typeof error === "object") {
+    const record = error;
+    const statusCode = typeof record.statusCode === "number" ? record.statusCode : typeof record.status === "number" ? record.status : fallbackStatus;
+    return {
+      message: typeof record.message === "string" ? record.message : `HTTP ${statusCode ?? 500}`,
+      code: typeof record.code === "string" || typeof record.code === "number" ? record.code : statusCode,
+      type: typeof record.type === "string" ? record.type : typeof record.name === "string" ? record.name : "Error",
+      stack: typeof record.stack === "string" ? record.stack : void 0,
+      why: typeof record.why === "string" ? record.why : void 0,
+      fix: typeof record.fix === "string" ? record.fix : void 0,
+      link: typeof record.link === "string" ? record.link : void 0,
+      details: normalizeDetails(record.details),
+      cause: record.cause
+    };
+  }
+  return {
+    message: String(error),
+    code: fallbackStatus,
+    type: typeof error
+  };
+}
+function resolveEmitStatus(options) {
+  if (options.response && typeof options.response.status === "number") {
+    return options.response.status;
+  }
+  if (typeof options.status === "number") {
+    return options.status;
+  }
+  if (options.error && typeof options.error === "object" && options.error !== null && typeof options.error.statusCode === "number") {
+    return options.error.statusCode;
+  }
+  if (options.error && typeof options.error === "object" && options.error !== null && typeof options.error.status === "number") {
+    return options.error.status;
+  }
+  return options.error ? 500 : void 0;
+}
+function createStructuredLog(groupId, options) {
+  const startedAt = performance.now();
+  const fields = { ...options.initialFields ?? {} };
+  const events = [];
+  let emittedPayload;
+  options.onCreate?.();
+  const appendEvent = (level, message, args) => {
+    events.push({
+      level,
+      message: serializeMessage(message),
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      ...normalizeEventData(message, args) === void 0 ? {} : { data: normalizeEventData(message, args) }
+    });
+    return structuredLog;
+  };
+  const structuredLog = {
+    set(extraFields) {
+      Object.assign(fields, extraFields);
+      return structuredLog;
+    },
+    debug(message, ...args) {
+      return appendEvent("debug", message, args);
+    },
+    info(message, ...args) {
+      return appendEvent("info", message, args);
+    },
+    warn(message, ...args) {
+      return appendEvent("warn", message, args);
+    },
+    warning(message, ...args) {
+      return appendEvent("warning", message, args);
+    },
+    error(message, ...args) {
+      return appendEvent("error", message, args);
+    },
+    success(message, ...args) {
+      return appendEvent("success", message, args);
+    },
+    critical(message, ...args) {
+      return appendEvent("critical", message, args);
+    },
+    table(message, data) {
+      return appendEvent("table", message, data === void 0 ? [] : [data]);
+    },
+    emit(emitOptions = {}) {
+      if (emittedPayload) {
+        return emittedPayload;
+      }
+      const defaultFields = options.resolveDefaultFields?.() ?? {};
+      const status = resolveEmitStatus(emitOptions);
+      const error = normalizeError(emitOptions.error, status);
+      const level = emitOptions.level ?? (error ? "error" : "info");
+      const payload = {
+        ...defaultFields,
+        ...fields,
+        groupId,
+        timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+        level,
+        duration: Math.round(performance.now() - startedAt),
+        ...typeof status === "number" ? { status } : {},
+        ...events.length > 0 ? { events: [...events] } : {},
+        ...error ? { error } : {}
+      };
+      options.write(payload, emitOptions.message ?? "structured_log");
+      emittedPayload = payload;
+      options.onEmit?.(payload);
+      return payload;
+    }
+  };
+  return structuredLog;
+}
+
+// src/frameworks/workers/logger.ts
+var workersLoggerState = {};
+function serializeMessage2(message) {
+  if (typeof message === "string") {
+    return message;
+  }
+  if (message !== null && typeof message === "object") {
+    try {
+      return JSON.stringify(message, (_key, value) => {
+        if (typeof value === "function") {
+          return `[Function: ${value.name || "anonymous"}]`;
+        }
+        if (value === void 0) {
+          return "[undefined]";
+        }
+        if (typeof value === "symbol") {
+          return value.toString();
+        }
+        return value;
+      }, 2);
+    } catch {
+      return "[Object]";
+    }
+  }
+  return String(message);
+}
+function normalizeStructuredData(message, args) {
+  if (typeof message === "string") {
+    if (args.length === 0) {
+      return void 0;
+    }
+    return args.length === 1 ? args[0] : args;
+  }
+  const values = [message, ...args];
+  return values.length === 1 ? values[0] : values;
+}
+function getConsoleMethod(level) {
+  switch (level) {
+    case "debug":
+      return "debug";
+    case "warn":
+    case "warning":
+      return "warn";
+    case "error":
+    case "critical":
+      return "error";
+    case "success":
+      return "log";
+    case "info":
+    default:
+      return "info";
+  }
+}
+function writeConsole(method, message, payload) {
+  if (typeof console === "undefined") {
+    return;
+  }
+  const logger = console[method] ?? console.info;
+  if (payload === void 0) {
+    logger.call(console, message);
+    return;
+  }
+  logger.call(console, message, payload);
+}
+function writeStructuredConsole(level, message, payload) {
+  writeConsole(getConsoleMethod(level), message, payload);
+}
+function buildRequestMetadata(request, path) {
+  return {
+    method: request.method,
+    url: path,
+    ...buildClientDetails(request, path)
+  };
+}
+function createScopedPayload(request, path, fields, data) {
+  return {
+    request: buildRequestMetadata(request, path),
+    ...fields,
+    ...data === void 0 ? {} : { data }
+  };
+}
+function emitScopedLog(level, request, path, fields, message, args) {
+  writeConsole(
+    getConsoleMethod(level),
+    serializeMessage2(message),
+    createScopedPayload(request, path, fields, normalizeStructuredData(message, args))
+  );
+}
+function resolveEmitStatus2(options) {
+  return options.response?.status ?? options.status ?? (options.error ? 500 : 200);
+}
+function createEmitPayload(request, path, fields, startTime, options) {
+  const statusCode = resolveEmitStatus2(options);
+  const errorLike = toErrorLike(options.error, statusCode);
+  return buildRequestLogData(
+    request,
+    options.error || isErrorStatus(statusCode) ? "http_error" : "http_request",
+    path,
+    statusCode,
+    Math.round(performance.now() - startTime),
+    {
+      ...fields,
+      ...errorLike ? {
+        error: errorLike.message,
+        stack: errorLike.stack,
+        code: errorLike.code,
+        why: errorLike.why,
+        fix: errorLike.fix,
+        link: errorLike.link,
+        details: errorLike.details
+      } : {}
+    }
+  );
+}
+function createScopedFields(request) {
+  return {
+    ...workersLoggerState.env ?? {},
+    ...workersLoggerState.customProps?.(request) ?? {}
+  };
+}
+function initWorkersLogger(config = {}) {
+  workersLoggerState = {
+    env: config.env ? { ...config.env } : void 0,
+    customProps: config.customProps
+  };
+}
+function createWorkersLogger(request) {
+  const startTime = performance.now();
+  const requestLike = createRequestLike(request.method, request.url, request.headers);
+  const path = extractPathname(request.url);
+  const fields = createScopedFields(request);
+  let emittedRecord;
+  const logger = {
+    set(extraFields) {
+      Object.assign(fields, extraFields);
+      return logger;
+    },
+    emit(options = {}) {
+      if (emittedRecord) {
+        return emittedRecord;
+      }
+      emittedRecord = createEmitPayload(requestLike, path, fields, startTime, options);
+      writeConsole(
+        emittedRecord.type === "http_error" ? "error" : "info",
+        buildInfoLogMessage(
+          requestLike.method,
+          emittedRecord.statusCode,
+          path,
+          emittedRecord.responseTime
+        ),
+        emittedRecord
+      );
+      return emittedRecord;
+    },
+    debug(message, ...args) {
+      emitScopedLog("debug", requestLike, path, fields, message, args);
+    },
+    info(message, ...args) {
+      emitScopedLog("info", requestLike, path, fields, message, args);
+    },
+    warn(message, ...args) {
+      emitScopedLog("warn", requestLike, path, fields, message, args);
+    },
+    warning(message, ...args) {
+      emitScopedLog("warning", requestLike, path, fields, message, args);
+    },
+    error(message, ...args) {
+      emitScopedLog("error", requestLike, path, fields, message, args);
+    },
+    success(message, ...args) {
+      emitScopedLog("success", requestLike, path, fields, message, args);
+    },
+    critical(message, ...args) {
+      emitScopedLog("critical", requestLike, path, fields, message, args);
+    },
+    table(message, data) {
+      writeConsole("log", message, createScopedPayload(requestLike, path, fields, data));
+      if (typeof console !== "undefined" && typeof console.table === "function" && data !== void 0) {
+        console.table(data);
+      }
+    },
+    createStructuredLog(groupId, initial) {
+      return createStructuredLog(groupId, {
+        initialFields: initial,
+        resolveDefaultFields: () => ({
+          method: requestLike.method,
+          path,
+          ...fields
+        }),
+        write: (payload, message) => {
+          const writeLevel = payload.level === "warning" ? "warning" : payload.level;
+          writeStructuredConsole(
+            writeLevel === "table" ? "info" : writeLevel,
+            message,
+            payload
+          );
+        }
+      });
+    }
+  };
+  return logger;
+}
+
+exports.createWorkersLogger = createWorkersLogger;
+exports.initWorkersLogger = initWorkersLogger;
+//# sourceMappingURL=workers.js.map
+//# sourceMappingURL=workers.js.map