@kozojs/core 0.3.2 → 0.3.3

package/lib/index.d.ts

@@ -5,7 +5,6 @@ import { IncomingMessage, ServerResponse, Server } from 'node:http';
 import { z } from 'zod';
 export { z } from 'zod';
 import { TSchema, Static } from '@sinclair/typebox';
-import { ValidateFunction } from 'ajv';
 export { CorsOptions, FileSystemRoutingOptions, HttpBadRequestError, HttpConflictError, HttpError, HttpForbiddenError, HttpInternalServerError, HttpNotFoundError, HttpUnauthorizedError, LoggerOptions, ManifestHttpMethod, ManifestRoute, RateLimitOptions, RoutesManifest, applyFileSystemRouting, clearRateLimitStore, cors, createFileSystemRouting, errorHandler, logger, rateLimit } from './middleware/index.js';
 
 type SchemaType = z.ZodType<any> | TSchema;
@@ -334,14 +333,20 @@ declare class Kozo<TServices extends Services = Services> {
 }
 declare function createKozo<TServices extends Services = Services>(config?: KozoConfig<TServices>): Kozo<TServices>;
 
+type ZValidatorErrors = {
+    instancePath: string;
+    message: string;
+}[];
+type ZValidator = ((data: unknown) => boolean) & {
+    errors: ZValidatorErrors | null;
+};
 type CompiledHandler = (c: Context) => Promise<Response> | Response;
 type UserHandler = (c: any) => any;
 type CompiledRoute = {
-    validateBody?: ValidateFunction;
-    validateQuery?: ValidateFunction;
-    validateParams?: ValidateFunction;
+    validateBody?: ZValidator;
+    validateQuery?: ZValidator;
+    validateParams?: ZValidator;
     serialize?: (data: any) => string;
-    errors?: any;
 };
 declare class SchemaCompiler {
     static compile(schema: RouteSchema): CompiledRoute;

package/lib/index.js

@@ -603,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
@@ -727,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;
 }
@@ -751,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)) {