@kozojs/core 0.2.2

package/lib/index.js

@@ -0,0 +1,694 @@
+// src/app.ts
+import { Hono } from "hono";
+import { serve } from "@hono/node-server";
+import Ajv3 from "ajv";
+import addFormats3 from "ajv-formats";
+
+// src/client-generator.ts
+function generateMethodName(method, path) {
+  const cleanPath = path.replace(/^\/+|\/+$/g, "");
+  const withParams = cleanPath.replace(/:(\w+)/g, "By$1");
+  const safeName = withParams.replace(/[\/\-\.]/g, "_").replace(/[^\w]/g, "");
+  if (method.toLowerCase() !== "get") {
+    return method.toLowerCase() + safeName.charAt(0).toUpperCase() + safeName.slice(1);
+  }
+  return safeName || "index";
+}
+function extractPathParams(path) {
+  const matches = path.match(/:(\w+)/g);
+  return matches ? matches.map((m) => m.slice(1)) : [];
+}
+function generateTypedClient(routes, options = {}) {
+  const {
+    includeValidation = true,
+    baseUrl = "",
+    validateByDefault = false,
+    defaultHeaders = {}
+  } = options;
+  const imports = [];
+  const typeDefinitions = [];
+  const schemaExports = [];
+  const methodImplementations = [];
+  if (includeValidation) {
+    imports.push(`import { z } from 'zod';`);
+  }
+  let code = `// Auto-generated Kozo Client
+`;
+  code += `// Generated at ${(/* @__PURE__ */ new Date()).toISOString()}
+`;
+  code += `// DO NOT EDIT - Changes will be overwritten
+
+`;
+  const schemaVars = /* @__PURE__ */ new Map();
+  for (const route of routes) {
+    const methodName = generateMethodName(route.method, route.path);
+    const pathParams = extractPathParams(route.path);
+    let paramsType = "void";
+    let bodyType = "void";
+    let queryType = "void";
+    let responseType = "unknown";
+    if (pathParams.length > 0) {
+      paramsType = `{ ${pathParams.map((p) => `${p}: string`).join("; ")} }`;
+    }
+    if (route.zodSchemas?.body || route.schema.body) {
+      const schemaVarName = `${capitalize(methodName)}BodySchema`;
+      schemaVars.set(`${methodName}_body`, schemaVarName);
+      bodyType = `z.infer<typeof ${schemaVarName}>`;
+      if (includeValidation) {
+        schemaExports.push(`// @ts-ignore - Schema defined at runtime
+export const ${schemaVarName}: any = null;`);
+      }
+    }
+    if (route.zodSchemas?.query || route.schema.query) {
+      const schemaVarName = `${capitalize(methodName)}QuerySchema`;
+      schemaVars.set(`${methodName}_query`, schemaVarName);
+      queryType = `z.infer<typeof ${schemaVarName}>`;
+      if (includeValidation) {
+        schemaExports.push(`// @ts-ignore - Schema defined at runtime
+export const ${schemaVarName}: any = null;`);
+      }
+    }
+    if (route.zodSchemas?.response || route.schema.response) {
+      const schemaVarName = `${capitalize(methodName)}ResponseSchema`;
+      schemaVars.set(`${methodName}_response`, schemaVarName);
+      responseType = `z.infer<typeof ${schemaVarName}>`;
+      if (includeValidation) {
+        schemaExports.push(`// @ts-ignore - Schema defined at runtime
+export const ${schemaVarName}: any = null;`);
+      }
+    }
+    if (bodyType !== "void" && !bodyType.includes("z.infer")) {
+      typeDefinitions.push(`export type ${capitalize(methodName)}Body = ${bodyType};`);
+    }
+    if (queryType !== "void" && !queryType.includes("z.infer")) {
+      typeDefinitions.push(`export type ${capitalize(methodName)}Query = ${queryType};`);
+    }
+    if (!responseType.includes("z.infer")) {
+      typeDefinitions.push(`export type ${capitalize(methodName)}Response = ${responseType};`);
+    }
+    const args = [];
+    if (paramsType !== "void") args.push(`params: ${paramsType}`);
+    if (bodyType !== "void") args.push(`body: ${bodyType}`);
+    if (queryType !== "void") args.push(`query?: ${queryType}`);
+    const argsStr = args.join(", ");
+    const returnType = `Promise<${responseType}>`;
+    let methodBody = `  async ${methodName}(${argsStr}): ${returnType} {
+`;
+    if (includeValidation && bodyType !== "void") {
+      const schemaVar = schemaVars.get(`${methodName}_body`);
+      if (schemaVar) {
+        methodBody += `    if (this.validateRequests && ${schemaVar}) {
+`;
+        methodBody += `      ${schemaVar}.parse(body);
+`;
+        methodBody += `    }
+`;
+      }
+    }
+    let urlExpression = `\`\${this.baseUrl}${route.path}\``;
+    if (pathParams.length > 0) {
+      const pathWithParams = route.path.replace(/:(\w+)/g, "${params.$1}");
+      urlExpression = `\`\${this.baseUrl}${pathWithParams}\``;
+    }
+    methodBody += `    let url = ${urlExpression};
+`;
+    if (queryType !== "void") {
+      methodBody += `    if (query) {
+`;
+      methodBody += `      const queryString = new URLSearchParams(query as any).toString();
+`;
+      methodBody += `      url += \`?\${queryString}\`;
+`;
+      methodBody += `    }
+`;
+    }
+    methodBody += `    const options: RequestInit = {
+`;
+    methodBody += `      method: '${route.method.toUpperCase()}',
+`;
+    methodBody += `      headers: { ...this.defaultHeaders, 'Content-Type': 'application/json' },
+`;
+    if (bodyType !== "void") {
+      methodBody += `      body: JSON.stringify(body),
+`;
+    }
+    methodBody += `    };
+`;
+    methodBody += `    const response = await fetch(url, options);
+`;
+    methodBody += `    if (!response.ok) {
+`;
+    methodBody += `      throw new Error(\`HTTP \${response.status}: \${response.statusText}\`);
+`;
+    methodBody += `    }
+`;
+    methodBody += `    return response.json();
+`;
+    methodBody += `  }
+`;
+    methodImplementations.push(methodBody);
+  }
+  if (imports.length > 0) {
+    code += imports.join("\n") + "\n\n";
+  }
+  if (typeDefinitions.length > 0) {
+    code += "// Type Definitions\n";
+    code += typeDefinitions.join("\n") + "\n\n";
+  }
+  if (includeValidation && schemaExports.length > 0) {
+    code += "// Zod Schemas\n";
+    code += schemaExports.join("\n") + "\n\n";
+  }
+  code += `export interface KozoClientOptions {
+`;
+  code += `  baseUrl?: string;
+`;
+  code += `  validateRequests?: boolean;
+`;
+  code += `  defaultHeaders?: Record<string, string>;
+`;
+  code += `}
+
+`;
+  code += `export class KozoClient {
+`;
+  code += `  private baseUrl: string;
+`;
+  code += `  private validateRequests: boolean;
+`;
+  code += `  private defaultHeaders: Record<string, string>;
+
+`;
+  code += `  constructor(options: KozoClientOptions = {}) {
+`;
+  code += `    this.baseUrl = options.baseUrl || '${baseUrl}';
+`;
+  code += `    this.validateRequests = options.validateRequests ?? ${validateByDefault};
+`;
+  code += `    this.defaultHeaders = options.defaultHeaders || ${JSON.stringify(defaultHeaders)};
+`;
+  code += `  }
+
+`;
+  code += methodImplementations.join("\n");
+  code += `}
+
+`;
+  code += `export default KozoClient;
+`;
+  return code;
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+
+// src/optimizations/serializer.ts
+import fastJson from "fast-json-stringify";
+import { zodToJsonSchema } from "zod-to-json-schema";
+function isZodSchema(schema) {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema;
+}
+var ResponseSerializer = class {
+  serializers = /* @__PURE__ */ new Map();
+  fallback = JSON.stringify;
+  compile(routeId, schema) {
+    try {
+      let jsonSchema;
+      const isZod = isZodSchema(schema);
+      if (isZod) {
+        jsonSchema = zodToJsonSchema(schema, { $refStrategy: "none", target: "jsonSchema7" });
+        if (process.env.KOZO_DEBUG_SCHEMA === "true") {
+          console.log(`
+[DIAGNOSTIC] Schema for ${routeId}:`);
+          console.log(JSON.stringify(jsonSchema, null, 2));
+          const schemaStr = JSON.stringify(jsonSchema);
+          const hasAnyOf = schemaStr.includes("anyOf");
+          const hasOneOf = schemaStr.includes("oneOf");
+          const hasAllOf = schemaStr.includes("allOf");
+          if (hasAnyOf || hasOneOf || hasAllOf) {
+            console.warn(`\u26A0\uFE0F  Complex schema detected for ${routeId}:`, { hasAnyOf, hasOneOf, hasAllOf });
+            console.warn("   This may reduce fast-json-stringify performance");
+          }
+        }
+      } else {
+        jsonSchema = schema;
+      }
+      const stringify = fastJson(jsonSchema);
+      this.serializers.set(routeId, stringify);
+    } catch (err) {
+      console.error(`Failed to compile serializer for ${routeId}`, err);
+      this.serializers.set(routeId, this.fallback);
+    }
+  }
+  // Deprecated: for backward compatibility
+  compileFromZod(routeId, zodSchema) {
+    this.compile(routeId, zodSchema);
+  }
+  // Deprecated: for backward compatibility
+  compileFromJsonSchema(routeId, schema) {
+    this.compile(routeId, schema);
+  }
+  serialize(routeId, data) {
+    const serializer = this.serializers.get(routeId);
+    return serializer ? serializer(data) : this.fallback(data);
+  }
+  has(routeId) {
+    return this.serializers.has(routeId);
+  }
+  getSerializer(routeId) {
+    return this.serializers.get(routeId);
+  }
+};
+var commonSchemas = {
+  health: {
+    type: "object",
+    properties: {
+      status: { type: "string" },
+      timestamp: { type: "number" }
+    }
+  },
+  error: {
+    type: "object",
+    properties: {
+      error: { type: "string" },
+      status: { type: "number" }
+    }
+  },
+  success: {
+    type: "object",
+    properties: {
+      success: { type: "boolean" },
+      data: {}
+    }
+  }
+};
+var globalSerializer = new ResponseSerializer();
+globalSerializer.compile("__health", commonSchemas.health);
+globalSerializer.compile("__error", commonSchemas.error);
+
+// src/optimizations/validator.ts
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import { zodToJsonSchema as zodToJsonSchema2 } from "zod-to-json-schema";
+function isZodSchema2(schema) {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema;
+}
+var HybridValidator = class {
+  ajv;
+  validators = /* @__PURE__ */ new Map();
+  constructor() {
+    this.ajv = new Ajv({
+      allErrors: false,
+      // Stop at first error (faster)
+      coerceTypes: true,
+      // Auto-coerce strings to numbers etc
+      removeAdditional: true
+      // Strip unknown properties
+    });
+    addFormats(this.ajv);
+  }
+  compile(routeId, schema) {
+    try {
+      let jsonSchema;
+      if (isZodSchema2(schema)) {
+        jsonSchema = zodToJsonSchema2(schema, { $refStrategy: "none", target: "jsonSchema7" });
+      } else {
+        jsonSchema = schema;
+      }
+      const validate = this.ajv.compile(jsonSchema);
+      this.validators.set(routeId, (data) => {
+        const valid = validate(data);
+        if (valid) {
+          return { valid: true, data };
+        }
+        return {
+          valid: false,
+          errors: validate.errors?.map((e) => `${e.instancePath} ${e.message}`) || ["Validation failed"]
+        };
+      });
+    } catch (err) {
+      if (isZodSchema2(schema)) {
+        this.validators.set(routeId, (data) => {
+          const result = schema.safeParse(data);
+          if (result.success) {
+            return { valid: true, data: result.data };
+          }
+          return {
+            valid: false,
+            errors: result.error.issues.map((i) => `${i.path.join(".")} ${i.message}`)
+          };
+        });
+      } else {
+        console.error(`Failed to compile validator for ${routeId}`, err);
+        this.validators.set(routeId, () => ({ valid: false, errors: ["Internal Server Error: Validator compilation failed"] }));
+      }
+    }
+  }
+  // Deprecated: kept for backward compatibility if needed, but redirects to compile
+  compileFromZod(routeId, zodSchema) {
+    this.compile(routeId, zodSchema);
+  }
+  validate(routeId, data) {
+    const validator = this.validators.get(routeId);
+    if (!validator) {
+      return { valid: true, data };
+    }
+    return validator(data);
+  }
+  // For production: throws on invalid (faster than returning errors)
+  validateOrThrow(routeId, data) {
+    const result = this.validate(routeId, data);
+    if (!result.valid) {
+      const error = new Error("Validation failed");
+      error.errors = result.errors;
+      throw error;
+    }
+    return result.data;
+  }
+  has(routeId) {
+    return this.validators.has(routeId);
+  }
+};
+var globalValidator = new HybridValidator();
+
+// src/compiler.ts
+import { zodToJsonSchema as zodToJsonSchema3 } from "zod-to-json-schema";
+import Ajv2 from "ajv";
+import addFormats2 from "ajv-formats";
+import fastJson2 from "fast-json-stringify";
+var ajv = new Ajv2({
+  removeAdditional: "all",
+  useDefaults: true,
+  coerceTypes: true
+});
+addFormats2(ajv);
+function isZodSchema3(schema) {
+  return typeof schema === "object" && schema !== null && "safeParse" in schema;
+}
+var SchemaCompiler = class {
+  static compile(schema) {
+    const compiled = {};
+    if (schema.body) {
+      const jsonSchema = isZodSchema3(schema.body) ? zodToJsonSchema3(schema.body, { target: "jsonSchema7" }) : schema.body;
+      compiled.validateBody = ajv.compile(jsonSchema);
+    }
+    if (schema.query) {
+      const jsonSchema = isZodSchema3(schema.query) ? zodToJsonSchema3(schema.query, { target: "jsonSchema7" }) : schema.query;
+      compiled.validateQuery = ajv.compile(jsonSchema);
+    }
+    if (schema.params) {
+      const jsonSchema = isZodSchema3(schema.params) ? zodToJsonSchema3(schema.params, { target: "jsonSchema7" }) : schema.params;
+      compiled.validateParams = ajv.compile(jsonSchema);
+    }
+    if (schema.response) {
+      if (typeof schema.response === "object" && !isZodSchema3(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 = isZodSchema3(responseSchemas[200]) ? zodToJsonSchema3(responseSchemas[200], { target: "jsonSchema7" }) : responseSchemas[200];
+            compiled.serialize = fastJson2(jsonSchema);
+          }
+        } else {
+          compiled.serialize = fastJson2(schema.response);
+        }
+      } else {
+        const responseSchema = schema.response;
+        const jsonSchema = zodToJsonSchema3(responseSchema, { target: "jsonSchema7" });
+        compiled.serialize = fastJson2(jsonSchema);
+      }
+    }
+    return compiled;
+  }
+};
+var RESPONSE_INIT_200 = { status: 200, headers: { "Content-Type": "application/json" } };
+var RESPONSE_INIT_400 = { status: 400, headers: { "Content-Type": "application/json" } };
+var RESPONSE_INIT_500 = { status: 500, headers: { "Content-Type": "application/json" } };
+var ERROR_INVALID = '{"error":"Validation failed"}';
+var ERROR_INTERNAL = '{"error":"Internal server error"}';
+function compileRouteHandler(userHandler, schema, services, compiled) {
+  const bodyValidator = compiled.validateBody;
+  const queryValidator = compiled.validateQuery;
+  const paramsValidator = compiled.validateParams;
+  const serializer = compiled.serialize;
+  const needsBody = !!bodyValidator;
+  const needsQuery = !!queryValidator;
+  const needsParams = !!paramsValidator;
+  const needsSerialize = !!serializer;
+  if (!needsBody && !needsQuery && !needsParams) {
+    if (needsSerialize) {
+      return (c) => {
+        c.services = services;
+        const result = userHandler(c);
+        if (result instanceof Promise) {
+          return result.then((res) => {
+            if (res instanceof Response) return res;
+            return new Response(serializer(res), RESPONSE_INIT_200);
+          });
+        }
+        if (result instanceof Response) return result;
+        return new Response(serializer(result), RESPONSE_INIT_200);
+      };
+    } else {
+      return (c) => {
+        c.services = services;
+        const result = userHandler(c);
+        if (result instanceof Promise) {
+          return result.then((res) => {
+            if (res instanceof Response) return res;
+            return new Response(JSON.stringify(res), RESPONSE_INIT_200);
+          });
+        }
+        if (result instanceof Response) return result;
+        return new Response(JSON.stringify(result), RESPONSE_INIT_200);
+      };
+    }
+  }
+  if (!needsBody) {
+    if (needsSerialize) {
+      return (c) => {
+        const ctx = c;
+        ctx.services = services;
+        if (needsParams) {
+          const params = c.req.param();
+          if (!paramsValidator(params)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.params = params;
+        }
+        if (needsQuery) {
+          const query = c.req.query();
+          if (!queryValidator(query)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.query = query;
+        }
+        const result = userHandler(c);
+        if (result instanceof Promise) {
+          return result.then((res) => {
+            if (res instanceof Response) return res;
+            return new Response(serializer(res), RESPONSE_INIT_200);
+          });
+        }
+        if (result instanceof Response) return result;
+        return new Response(serializer(result), RESPONSE_INIT_200);
+      };
+    } else {
+      return (c) => {
+        const ctx = c;
+        ctx.services = services;
+        if (needsParams) {
+          const params = c.req.param();
+          if (!paramsValidator(params)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.params = params;
+        }
+        if (needsQuery) {
+          const query = c.req.query();
+          if (!queryValidator(query)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.query = query;
+        }
+        const result = userHandler(c);
+        if (result instanceof Promise) {
+          return result.then((res) => {
+            if (res instanceof Response) return res;
+            return new Response(JSON.stringify(res), RESPONSE_INIT_200);
+          });
+        }
+        if (result instanceof Response) return result;
+        return new Response(JSON.stringify(result), RESPONSE_INIT_200);
+      };
+    }
+  }
+  if (needsSerialize) {
+    return async (c) => {
+      try {
+        const ctx = c;
+        ctx.services = services;
+        if (needsParams) {
+          const params = c.req.param();
+          if (!paramsValidator(params)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.params = params;
+        }
+        if (needsQuery) {
+          const query = c.req.query();
+          if (!queryValidator(query)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.query = query;
+        }
+        if (needsBody) {
+          const rawBody = await c.req.json().catch(() => ({}));
+          if (!bodyValidator(rawBody)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.body = rawBody;
+        }
+        const result = await userHandler(c);
+        if (result instanceof Response) return result;
+        return new Response(serializer(result), RESPONSE_INIT_200);
+      } catch (err) {
+        console.error("[Kozo] Handler error:", err);
+        return new Response(ERROR_INTERNAL, RESPONSE_INIT_500);
+      }
+    };
+  } else {
+    return async (c) => {
+      try {
+        const ctx = c;
+        ctx.services = services;
+        if (needsParams) {
+          const params = c.req.param();
+          if (!paramsValidator(params)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.params = params;
+        }
+        if (needsQuery) {
+          const query = c.req.query();
+          if (!queryValidator(query)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.query = query;
+        }
+        if (needsBody) {
+          const rawBody = await c.req.json().catch(() => ({}));
+          if (!bodyValidator(rawBody)) {
+            return new Response(ERROR_INVALID, RESPONSE_INIT_400);
+          }
+          ctx.body = rawBody;
+        }
+        const result = await userHandler(c);
+        if (result instanceof Response) return result;
+        return new Response(JSON.stringify(result), RESPONSE_INIT_200);
+      } catch (err) {
+        console.error("[Kozo] Handler error:", err);
+        return new Response(ERROR_INTERNAL, RESPONSE_INIT_500);
+      }
+    };
+  }
+}
+
+// src/app.ts
+var ajv2 = new Ajv3({
+  removeAdditional: "all",
+  useDefaults: true,
+  coerceTypes: true
+});
+addFormats3(ajv2);
+var isBun = typeof Bun !== "undefined";
+if (isBun) {
+  try {
+    if (typeof Bun !== "undefined" && Bun.json) {
+      globalThis.JSON = {
+        parse: Bun.json.parse,
+        stringify: Bun.json.stringify
+      };
+    }
+  } catch (e) {
+  }
+}
+var Kozo = class {
+  app;
+  services;
+  routes = [];
+  constructor(config = {}) {
+    this.app = new Hono();
+    this.services = config.services || {};
+  }
+  // Plugin system
+  use(plugin) {
+    plugin.install(this);
+    return this;
+  }
+  generateClient(baseUrlOrOptions) {
+    const options = typeof baseUrlOrOptions === "string" ? { baseUrl: baseUrlOrOptions, includeValidation: false } : baseUrlOrOptions || {};
+    const routeInfos = this.routes.map((r) => ({
+      method: r.method,
+      path: r.path,
+      schema: r.schema
+    }));
+    return generateTypedClient(routeInfos, options);
+  }
+  get(path, schema, handler) {
+    this.register("get", path, schema, handler);
+  }
+  post(path, schema, handler) {
+    this.register("post", path, schema, handler);
+  }
+  put(path, schema, handler) {
+    this.register("put", path, schema, handler);
+  }
+  patch(path, schema, handler) {
+    this.register("patch", path, schema, handler);
+  }
+  delete(path, schema, handler) {
+    this.register("delete", path, schema, handler);
+  }
+  register(method, path, schema, handler) {
+    this.routes.push({ method, path, schema });
+    const compiled = SchemaCompiler.compile(schema);
+    const optimizedHandler = compileRouteHandler(
+      handler,
+      schema,
+      this.services,
+      compiled
+    );
+    this.app[method](path, optimizedHandler);
+  }
+  async listen(port) {
+    const finalPort = port || 3e3;
+    serve({
+      fetch: this.app.fetch,
+      port: finalPort
+    });
+    console.log(`\u{1F680} Kozo server listening on http://localhost:${finalPort}`);
+  }
+  getApp() {
+    return this.app;
+  }
+  get fetch() {
+    return this.app.fetch;
+  }
+};
+function createKozo(config) {
+  return new Kozo(config);
+}
+
+// src/index.ts
+import { z } from "zod";
+export {
+  Kozo,
+  SchemaCompiler,
+  compileRouteHandler,
+  createKozo,
+  generateTypedClient,
+  z
+};
+//# sourceMappingURL=index.js.map