@kozojs/core 0.2.7 → 0.3.0

package/lib/chunk-W44TTZNJ.js

@@ -0,0 +1,205 @@
+// src/middleware/logger.ts
+function logger(options = {}) {
+  const { prefix = "\u{1F310}", colorize = true } = options;
+  return async (c, next) => {
+    const start = Date.now();
+    const method = c.req.method;
+    const path = new URL(c.req.url).pathname;
+    await next();
+    const duration = Date.now() - start;
+    const status = c.res.status;
+    const statusColor = status >= 500 ? "\u{1F534}" : status >= 400 ? "\u{1F7E1}" : "\u{1F7E2}";
+    const log = `${prefix} ${method.padEnd(6)} ${path} ${statusColor} ${status} ${duration}ms`;
+    console.log(log);
+  };
+}
+
+// src/middleware/cors.ts
+import { cors as honoCors } from "hono/cors";
+function cors(options = {}) {
+  return honoCors({
+    origin: options.origin || "*",
+    allowMethods: options.allowMethods || ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS"],
+    allowHeaders: options.allowHeaders || ["Content-Type", "Authorization"],
+    exposeHeaders: options.exposeHeaders || [],
+    maxAge: options.maxAge || 86400,
+    credentials: options.credentials || false
+  });
+}
+
+// src/middleware/rate-limit.ts
+var store = /* @__PURE__ */ new Map();
+function rateLimit(options) {
+  const {
+    max = 100,
+    window = 60,
+    keyGenerator = (c) => c.req.header("x-forwarded-for") ?? c.req.header("x-real-ip") ?? "anonymous",
+    message = "Too many requests"
+  } = options;
+  return async (c, next) => {
+    const key = keyGenerator(c);
+    const now = Date.now();
+    const windowMs = window * 1e3;
+    let record = store.get(key);
+    if (!record || now > record.resetAt) {
+      record = { count: 0, resetAt: now + windowMs };
+    }
+    record.count++;
+    store.set(key, record);
+    c.header("X-RateLimit-Limit", String(max));
+    c.header("X-RateLimit-Remaining", String(Math.max(0, max - record.count)));
+    c.header("X-RateLimit-Reset", String(Math.ceil(record.resetAt / 1e3)));
+    if (record.count > max) {
+      return c.json({ error: message }, 429);
+    }
+    await next();
+  };
+}
+function clearRateLimitStore() {
+  store.clear();
+}
+
+// src/middleware/error-handler.ts
+var HttpError = class extends Error {
+  constructor(statusCode, message, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "HttpError";
+  }
+};
+var BadRequestError = class extends HttpError {
+  constructor(message = "Bad Request", details) {
+    super(400, message, details);
+  }
+};
+var UnauthorizedError = class extends HttpError {
+  constructor(message = "Unauthorized") {
+    super(401, message);
+  }
+};
+var ForbiddenError = class extends HttpError {
+  constructor(message = "Forbidden") {
+    super(403, message);
+  }
+};
+var NotFoundError = class extends HttpError {
+  constructor(message = "Not Found") {
+    super(404, message);
+  }
+};
+var ConflictError = class extends HttpError {
+  constructor(message = "Conflict", details) {
+    super(409, message, details);
+  }
+};
+var InternalServerError = class extends HttpError {
+  constructor(message = "Internal Server Error") {
+    super(500, message);
+  }
+};
+function errorHandler() {
+  return async (c, next) => {
+    try {
+      await next();
+    } catch (err) {
+      if (err instanceof HttpError) {
+        return c.json({
+          error: err.message,
+          status: err.statusCode,
+          ...err.details ? { details: err.details } : {}
+        }, err.statusCode);
+      }
+      console.error("Unhandled error:", err);
+      return c.json({
+        error: "Internal Server Error",
+        status: 500
+      }, 500);
+    }
+  };
+}
+
+// src/middleware/fileSystemRouting.ts
+import { readFile } from "fs/promises";
+import { resolve } from "path";
+import { pathToFileURL } from "url";
+async function readManifest(manifestPath, onMissing) {
+  try {
+    const raw = await readFile(manifestPath, "utf-8");
+    return JSON.parse(raw);
+  } catch (err) {
+    onMissing(err instanceof Error ? err : new Error(String(err)));
+    return null;
+  }
+}
+async function importHandler(handlerPath) {
+  try {
+    const url = handlerPath.startsWith("file://") ? handlerPath : pathToFileURL(handlerPath).href;
+    const mod = await import(url);
+    if (typeof mod.default !== "function") {
+      console.warn(
+        `[kozo:fsr] Skipping ${handlerPath}: no default export function`
+      );
+      return null;
+    }
+    return mod.default;
+  } catch (err) {
+    console.warn(
+      `[kozo:fsr] Failed to import handler ${handlerPath}:`,
+      err.message
+    );
+    return null;
+  }
+}
+async function applyFileSystemRouting(app, options = {}) {
+  const {
+    manifestPath = resolve(process.cwd(), "routes-manifest.json"),
+    verbose = false,
+    onMissingManifest = () => {
+    },
+    logger: logger2 = console.log
+  } = options;
+  const manifest = await readManifest(manifestPath, onMissingManifest);
+  if (!manifest) return;
+  const log = logger2;
+  if (verbose) {
+    log(
+      `
+\u{1F4CB} [kozo:fsr] Loading ${manifest.routes.length} route(s) from manifest
+`
+    );
+  }
+  for (const route of manifest.routes) {
+    const handler = await importHandler(route.handler);
+    if (!handler) continue;
+    app[route.method](route.path, handler);
+    if (verbose) {
+      log(
+        `   ${route.method.toUpperCase().padEnd(6)} ${route.path}  \u2192  ${route.handler}`
+      );
+    }
+  }
+  if (verbose) {
+    log("");
+  }
+}
+function createFileSystemRouting(options = {}) {
+  return (app) => applyFileSystemRouting(app, options);
+}
+
+export {
+  logger,
+  cors,
+  rateLimit,
+  clearRateLimitStore,
+  HttpError,
+  BadRequestError,
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  ConflictError,
+  InternalServerError,
+  errorHandler,
+  applyFileSystemRouting,
+  createFileSystemRouting
+};