@kozojs/core 0.3.1 → 0.3.3

package/lib/index.js

@@ -1,20 +1,3 @@
-import {
-  BadRequestError,
-  ConflictError,
-  ForbiddenError,
-  HttpError,
-  InternalServerError,
-  NotFoundError,
-  UnauthorizedError,
-  applyFileSystemRouting,
-  clearRateLimitStore,
-  cors,
-  createFileSystemRouting,
-  errorHandler,
-  logger,
-  rateLimit
-} from "./chunk-W44TTZNJ.js";
-
 // src/app.ts
 import { Hono } from "hono/quick";
 import { serve } from "@hono/node-server";
@@ -404,19 +387,19 @@ var ValidationFailedError = class extends KozoError {
     return new Response(JSON.stringify(body), INIT_400);
   }
 };
-var NotFoundError2 = class extends KozoError {
+var NotFoundError = class extends KozoError {
   constructor(message = "Resource Not Found") {
     super(message, 404, "not-found");
     this.name = "NotFoundError";
   }
 };
-var UnauthorizedError2 = class extends KozoError {
+var UnauthorizedError = class extends KozoError {
   constructor(message = "Unauthorized") {
     super(message, 401, "unauthorized");
     this.name = "UnauthorizedError";
   }
 };
-var ForbiddenError2 = class extends KozoError {
+var ForbiddenError = class extends KozoError {
   constructor(message = "Forbidden") {
     super(message, 403, "forbidden");
     this.name = "ForbiddenError";
@@ -517,11 +500,11 @@ function uwsWrite404(uwsRes) {
   });
 }
 function getFreePort() {
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const srv = netCreateServer();
     srv.listen(0, "0.0.0.0", () => {
       const port = srv.address().port;
-      srv.close((err) => err ? reject(err) : resolve(port));
+      srv.close((err) => err ? reject(err) : resolve2(port));
     });
   });
 }
@@ -538,7 +521,7 @@ async function createUwsServer(opts) {
   const { uws, routes } = opts;
   const port = opts.port === 0 ? await getFreePort() : opts.port;
   const emptyParams = Object.freeze({});
-  return new Promise((resolve, reject) => {
+  return new Promise((resolve2, reject) => {
     const uwsApp = uws.App();
     for (const route of routes) {
       const fn = UWS_METHOD[route.method];
@@ -606,7 +589,7 @@ async function createUwsServer(opts) {
         return;
       }
       listenToken = token;
-      resolve({
+      resolve2({
         port,
         server: {
           close() {
@@ -620,8 +603,6 @@ async function createUwsServer(opts) {
 
 // src/compiler.ts
 import { zodToJsonSchema } from "zod-to-json-schema";
-import Ajv from "ajv";
-import addFormats from "ajv-formats";
 import fastJson from "fast-json-stringify";
 
 // src/fast-response.ts
@@ -744,12 +725,28 @@ function fastWriteError(err, res) {
 }
 
 // src/compiler.ts
-var ajv = new Ajv({
-  removeAdditional: "all",
-  useDefaults: true,
-  coerceTypes: true
-});
-addFormats(ajv);
+function makeZValidator(schema) {
+  const fn = function(data) {
+    const r = schema.safeParse(data);
+    fn.errors = null;
+    if (r.success) {
+      if (data !== null && typeof data === "object" && !Array.isArray(data)) {
+        const d = data;
+        const rd = r.data;
+        for (const k of Object.keys(d)) if (!(k in rd)) delete d[k];
+        Object.assign(d, rd);
+      }
+      return true;
+    }
+    fn.errors = r.error.issues.map((i) => ({
+      instancePath: i.path.length ? "/" + i.path.join("/") : "",
+      message: i.message
+    }));
+    return false;
+  };
+  fn.errors = null;
+  return fn;
+}
 function isZodSchema(schema) {
   return typeof schema === "object" && schema !== null && "safeParse" in schema;
 }
@@ -768,17 +765,14 @@ function toJsonBody(result) {
 var SchemaCompiler = class {
   static compile(schema) {
     const compiled = {};
-    if (schema.body) {
-      const jsonSchema = isZodSchema(schema.body) ? zodToJsonSchema(schema.body, ZOD_OPTS) : schema.body;
-      compiled.validateBody = ajv.compile(jsonSchema);
+    if (schema.body && isZodSchema(schema.body)) {
+      compiled.validateBody = makeZValidator(schema.body);
     }
-    if (schema.query) {
-      const jsonSchema = isZodSchema(schema.query) ? zodToJsonSchema(schema.query, ZOD_OPTS) : schema.query;
-      compiled.validateQuery = ajv.compile(jsonSchema);
+    if (schema.query && isZodSchema(schema.query)) {
+      compiled.validateQuery = makeZValidator(schema.query);
     }
-    if (schema.params) {
-      const jsonSchema = isZodSchema(schema.params) ? zodToJsonSchema(schema.params, ZOD_OPTS) : schema.params;
-      compiled.validateParams = ajv.compile(jsonSchema);
+    if (schema.params && isZodSchema(schema.params)) {
+      compiled.validateParams = makeZValidator(schema.params);
     }
     if (schema.response) {
       if (typeof schema.response === "object" && !isZodSchema(schema.response)) {
@@ -1875,8 +1869,8 @@ function createInflightTracker() {
 function trackRequest(tracker) {
   tracker.count++;
   let resolvePromise;
-  const promise = new Promise((resolve) => {
-    resolvePromise = resolve;
+  const promise = new Promise((resolve2) => {
+    resolvePromise = resolve2;
   });
   tracker.requests.add(promise);
   return () => {
@@ -1971,10 +1965,10 @@ var ShutdownManager = class {
       });
     }
     const drainPromise = this.drainRequests();
-    const timeoutPromise = new Promise((resolve) => {
+    const timeoutPromise = new Promise((resolve2) => {
       setTimeout(() => {
         onShutdownTimeout?.(this.tracker.count);
-        resolve();
+        resolve2();
       }, timeoutMs);
     });
     await Promise.race([drainPromise, timeoutPromise]);
@@ -2715,23 +2709,212 @@ function generateSwaggerHtml(specUrl, title = "API Documentation") {
 function createOpenAPIGenerator(config) {
   return new OpenAPIGenerator(config);
 }
+
+// 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 UnauthorizedError2 = class extends HttpError {
+  constructor(message = "Unauthorized") {
+    super(401, message);
+  }
+};
+var ForbiddenError2 = class extends HttpError {
+  constructor(message = "Forbidden") {
+    super(403, message);
+  }
+};
+var NotFoundError2 = 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 as pathToFileURL2 } 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 : pathToFileURL2(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 {
   ERROR_RESPONSES,
-  ForbiddenError2 as ForbiddenError,
+  ForbiddenError,
   BadRequestError as HttpBadRequestError,
   ConflictError as HttpConflictError,
   HttpError,
-  ForbiddenError as HttpForbiddenError,
+  ForbiddenError2 as HttpForbiddenError,
   InternalServerError as HttpInternalServerError,
-  NotFoundError as HttpNotFoundError,
-  UnauthorizedError as HttpUnauthorizedError,
+  NotFoundError2 as HttpNotFoundError,
+  UnauthorizedError2 as HttpUnauthorizedError,
   Kozo,
   KozoError,
-  NotFoundError2 as NotFoundError,
+  NotFoundError,
   OpenAPIGenerator,
   SchemaCompiler,
   ShutdownManager,
-  UnauthorizedError2 as UnauthorizedError,
+  UnauthorizedError,
   ValidationFailedError,
   applyFileSystemRouting,
   buildNativeContext,
@@ -2767,3 +2950,4 @@ export {
   validationErrorResponse,
   z
 };
+//# sourceMappingURL=index.js.map