@kozojs/core 0.3.4 → 0.3.6

package/lib/index.js

@@ -601,10 +601,6 @@ async function createUwsServer(opts) {
   });
 }
 
-// src/compiler.ts
-import { zodToJsonSchema } from "zod-to-json-schema";
-import fastJson from "fast-json-stringify";
-
 // src/fast-response.ts
 var CL_CACHE = /* @__PURE__ */ (() => {
   const arr = new Array(1e4);
@@ -750,7 +746,6 @@ function makeZValidator(schema) {
 function isZodSchema(schema) {
   return typeof schema === "object" && schema !== null && "safeParse" in schema;
 }
-var ZOD_OPTS = { $refStrategy: "none", target: "jsonSchema7" };
 var HDR_JSON = { "Content-Type": "application/json" };
 var RESPONSE_INIT_200 = Object.freeze({ status: 200, headers: HDR_JSON });
 function jsonResponse200(body) {
@@ -775,23 +770,7 @@ var SchemaCompiler = class {
       compiled.validateParams = makeZValidator(schema.params);
     }
     if (schema.response) {
-      if (typeof schema.response === "object" && !isZodSchema(schema.response)) {
-        const keys = Object.keys(schema.response);
-        const isStatusMap = keys.length > 0 && keys.every((k) => !isNaN(Number(k)));
-        if (isStatusMap) {
-          const responseSchemas = schema.response;
-          if (responseSchemas[200]) {
-            const jsonSchema = isZodSchema(responseSchemas[200]) ? zodToJsonSchema(responseSchemas[200], ZOD_OPTS) : responseSchemas[200];
-            compiled.serialize = fastJson(jsonSchema);
-          }
-        } else {
-          compiled.serialize = fastJson(schema.response);
-        }
-      } else {
-        const responseSchema = schema.response;
-        const jsonSchema = zodToJsonSchema(responseSchema, ZOD_OPTS);
-        compiled.serialize = fastJson(jsonSchema);
-      }
+      compiled.serialize = JSON.stringify;
     }
     return compiled;
   }
@@ -2030,7 +2009,7 @@ function createShutdownManager() {
 }
 
 // src/router.ts
-import { glob } from "glob";
+import { readdir } from "fs/promises";
 import { join } from "path";
 import { pathToFileURL } from "url";
 
@@ -2080,6 +2059,19 @@ function isRouteFile(filename) {
 }
 
 // src/router.ts
+async function scanFiles(dir, base = "") {
+  const results = [];
+  const entries = await readdir(dir, { withFileTypes: true });
+  for (const e of entries) {
+    const rel = base ? `${base}/${e.name}` : e.name;
+    if (e.isDirectory()) {
+      results.push(...await scanFiles(join(dir, e.name), rel));
+    } else if (/\.(ts|js)$/.test(e.name) && !e.name.startsWith("_") && !e.name.endsWith(".test.ts") && !e.name.endsWith(".test.js") && !e.name.endsWith(".spec.ts") && !e.name.endsWith(".spec.js")) {
+      results.push(rel);
+    }
+  }
+  return results;
+}
 async function scanRoutes(options) {
   const { routesDir, verbose = true } = options;
   const routes = [];
@@ -2088,12 +2080,7 @@ async function scanRoutes(options) {
 \u{1F50D} Scanning routes in: ${routesDir}
 `);
   }
-  const pattern = "**/*.{ts,js}";
-  const files = await glob(pattern, {
-    cwd: routesDir,
-    nodir: true,
-    ignore: ["**/_*.ts", "**/_*.js", "**/*.test.ts", "**/*.spec.ts"]
-  });
+  const files = await scanFiles(routesDir);
   for (const file of files) {
     if (!isRouteFile(file)) continue;
     const parsed = fileToPath(file);
@@ -2389,110 +2376,9 @@ function buildNativeContext(req, res, params, body, services, serialize) {
 import { z } from "zod";
 
 // src/openapi.ts
-function zodToJsonSchema2(zodSchema) {
-  const schema = zodSchema;
-  const def = schema._def;
-  if (!def) {
-    return { type: "object" };
-  }
-  const typeName = def.typeName;
-  switch (typeName) {
-    case "ZodString": {
-      const result = { type: "string" };
-      for (const check of def.checks || []) {
-        if (check.kind === "min") result.minLength = check.value;
-        if (check.kind === "max") result.maxLength = check.value;
-        if (check.kind === "email") result.format = "email";
-        if (check.kind === "url") result.format = "uri";
-        if (check.kind === "uuid") result.format = "uuid";
-        if (check.kind === "regex") result.pattern = check.regex.source;
-      }
-      return result;
-    }
-    case "ZodNumber": {
-      const result = { type: "number" };
-      for (const check of def.checks || []) {
-        if (check.kind === "min") result.minimum = check.value;
-        if (check.kind === "max") result.maximum = check.value;
-        if (check.kind === "int") result.type = "integer";
-      }
-      return result;
-    }
-    case "ZodBoolean":
-      return { type: "boolean" };
-    case "ZodNull":
-      return { type: "null" };
-    case "ZodArray":
-      return {
-        type: "array",
-        items: zodToJsonSchema2(def.type)
-      };
-    case "ZodObject": {
-      const properties = {};
-      const required = [];
-      const shape = def.shape?.() || def.shape;
-      if (shape) {
-        for (const [key, value] of Object.entries(shape)) {
-          properties[key] = zodToJsonSchema2(value);
-          const fieldDef = value._def;
-          if (fieldDef?.typeName !== "ZodOptional" && fieldDef?.typeName !== "ZodDefault") {
-            required.push(key);
-          }
-        }
-      }
-      return {
-        type: "object",
-        properties,
-        ...required.length > 0 ? { required } : {}
-      };
-    }
-    case "ZodEnum":
-      return {
-        type: "string",
-        enum: def.values
-      };
-    case "ZodNativeEnum":
-      return {
-        type: "string",
-        enum: Object.values(def.values)
-      };
-    case "ZodLiteral":
-      return {
-        type: typeof def.value,
-        enum: [def.value]
-      };
-    case "ZodUnion":
-      return {
-        oneOf: def.options.map((opt) => zodToJsonSchema2(opt))
-      };
-    case "ZodOptional":
-      return {
-        ...zodToJsonSchema2(def.innerType),
-        nullable: true
-      };
-    case "ZodNullable":
-      return {
-        ...zodToJsonSchema2(def.innerType),
-        nullable: true
-      };
-    case "ZodDefault":
-      return {
-        ...zodToJsonSchema2(def.innerType),
-        default: def.defaultValue()
-      };
-    case "ZodRecord":
-      return {
-        type: "object",
-        additionalProperties: zodToJsonSchema2(def.valueType)
-      };
-    case "ZodDate":
-      return { type: "string", format: "date-time" };
-    case "ZodAny":
-    case "ZodUnknown":
-      return {};
-    default:
-      return { type: "object" };
-  }
+import { zodToJsonSchema as _zodToJsonSchema } from "zod-to-json-schema";
+function zodToJsonSchema(zodSchema) {
+  return _zodToJsonSchema(zodSchema, { $refStrategy: "none" });
 }
 var OpenAPIGenerator = class {
   config;
@@ -2581,7 +2467,7 @@ var OpenAPIGenerator = class {
       }
     }
     if (schema?.query) {
-      const querySchema = zodToJsonSchema2(schema.query);
+      const querySchema = zodToJsonSchema(schema.query);
       if (querySchema.properties) {
         for (const [name, propSchema] of Object.entries(querySchema.properties)) {
           operation.parameters.push({
@@ -2594,7 +2480,7 @@ var OpenAPIGenerator = class {
       }
     }
     if (schema?.params) {
-      const paramsSchema = zodToJsonSchema2(schema.params);
+      const paramsSchema = zodToJsonSchema(schema.params);
       if (paramsSchema.properties) {
         for (const [name, propSchema] of Object.entries(paramsSchema.properties)) {
           const existingIdx = operation.parameters.findIndex(
@@ -2611,7 +2497,7 @@ var OpenAPIGenerator = class {
         required: true,
         content: {
           "application/json": {
-            schema: zodToJsonSchema2(schema.body)
+            schema: zodToJsonSchema(schema.body)
           }
         }
       };
@@ -2622,7 +2508,7 @@ var OpenAPIGenerator = class {
           description: this.getStatusDescription(parseInt(status)),
           content: {
             "application/json": {
-              schema: zodToJsonSchema2(responseSchema)
+              schema: zodToJsonSchema(responseSchema)
             }
           }
         };