@nanokajs/core 0.1.4 → 1.0.1

package/dist/index.js

@@ -1,9 +1,9 @@
-export { t } from './chunk-F5OBRXXY.js';
+export { t } from './chunk-UYXRKFAR.js';
 import { drizzle } from 'drizzle-orm/d1';
 import { zValidator } from '@hono/zod-validator';
+import { z } from 'zod';
 import { asc, desc, eq, and } from 'drizzle-orm';
 import { HTTPException } from 'hono/http-exception';
-import { z } from 'zod';
 import { sqliteTable } from 'drizzle-orm/sqlite-core';
 import { Hono } from 'hono';
 
@@ -14,6 +14,305 @@ function d1Adapter(d1) {
     batch: (queries) => db.batch(queries)
   };
 }
+
+// src/model/types.ts
+function resolveSchemaOptionKeys(opt, accessor) {
+  if (opt === void 0) return void 0;
+  if (typeof opt === "function") return opt(accessor);
+  return opt;
+}
+function buildFieldAccessor(fields) {
+  const acc = {};
+  for (const k of Object.keys(fields)) acc[k] = k;
+  return Object.freeze(acc);
+}
+
+// src/model/schema.ts
+function computeForcedOmit(fields) {
+  const omit = [];
+  for (const [key, field] of Object.entries(fields)) {
+    if (field.modifiers.policy === "serverOnly") {
+      omit.push(key);
+    }
+  }
+  return omit;
+}
+function computeOptionalOmit(fields, target) {
+  const omit = [];
+  for (const [key, field] of Object.entries(fields)) {
+    const policy = field.modifiers.policy;
+    if (!policy) continue;
+    if (policy === "writeOnly" && target === "output") {
+      omit.push(key);
+    } else if (policy === "readOnly" && (target === "input-create" || target === "input-update")) {
+      omit.push(key);
+    }
+  }
+  return omit;
+}
+function derivePolicyOptions(fields, usage, userOpts, accessor) {
+  const forced = computeForcedOmit(fields);
+  const optional = computeOptionalOmit(fields, usage);
+  const acc = accessor ?? {};
+  const resolvedPick = resolveSchemaOptionKeys(userOpts?.pick, acc);
+  const resolvedOmit = resolveSchemaOptionKeys(userOpts?.omit, acc);
+  if (resolvedPick !== void 0) {
+    const partial2 = usage === "input-update" ? userOpts?.partial ?? true : userOpts?.partial;
+    const sanitizedPick = Array.from(resolvedPick).filter((k) => !forced.includes(k));
+    const combinedOmit2 = [.../* @__PURE__ */ new Set([...forced, ...resolvedOmit ?? []])];
+    return {
+      ...userOpts,
+      pick: sanitizedPick,
+      ...combinedOmit2.length > 0 ? { omit: combinedOmit2 } : {},
+      partial: partial2
+    };
+  }
+  const combinedOmit = [.../* @__PURE__ */ new Set([...forced, ...optional, ...resolvedOmit ?? []])];
+  const partial = usage === "input-update" ? userOpts?.partial ?? true : userOpts?.partial ?? void 0;
+  return {
+    ...userOpts ?? {},
+    pick: void 0,
+    ...combinedOmit.length > 0 ? { omit: combinedOmit } : {},
+    ...partial !== void 0 ? { partial } : {}
+  };
+}
+function buildBaseObject(fields) {
+  const shape = {};
+  for (const [key, field] of Object.entries(fields)) {
+    shape[key] = field.zodBase;
+  }
+  return z.object(shape);
+}
+function applySchemaOptions(baseSchema, opts, accessor) {
+  if (!opts) {
+    return baseSchema;
+  }
+  const acc = accessor ?? {};
+  const resolvedPick = resolveSchemaOptionKeys(opts.pick, acc);
+  const resolvedOmit = resolveSchemaOptionKeys(opts.omit, acc);
+  let schema = baseSchema;
+  if (resolvedPick !== void 0) {
+    const pickArray = Array.from(resolvedPick);
+    schema = schema.pick(
+      // biome-ignore lint/suspicious/noExplicitAny: Zod API
+      Object.fromEntries(pickArray.map((k) => [k, true]))
+    );
+  }
+  if (resolvedOmit !== void 0) {
+    const omitArray = Array.from(resolvedOmit);
+    schema = schema.omit(
+      // biome-ignore lint/suspicious/noExplicitAny: Zod API
+      Object.fromEntries(omitArray.map((k) => [k, true]))
+    );
+  }
+  if (opts.partial === true) {
+    schema = schema.partial();
+  }
+  return schema;
+}
+
+// src/openapi/generate.ts
+function toOpenAPIComponent(fields, opts) {
+  return {
+    create: toOpenAPISchema(fields, "create", opts),
+    update: toOpenAPISchema(fields, "update", opts),
+    output: toOpenAPISchema(fields, "output", opts)
+  };
+}
+function toOpenAPISchema(fields, usage, opts) {
+  const policyUsage = usage === "create" ? "input-create" : usage === "update" ? "input-update" : "output";
+  const merged = derivePolicyOptions(fields, policyUsage, opts?.opts);
+  const schema = applySchemaOptions(buildBaseObject(fields), merged);
+  const shape = getZodObjectShape(schema);
+  const properties = {};
+  const required = [];
+  for (const [key, zodSchema] of Object.entries(shape)) {
+    const field = fields[key];
+    if (field === void 0) continue;
+    properties[key] = fieldToOpenAPISchema(field, opts?.strict);
+    if (field.modifiers.policy === "writeOnly" && (usage === "create" || usage === "update")) {
+      properties[key].writeOnly = true;
+    }
+    if (field.modifiers.policy === "readOnly" && usage === "output") {
+      properties[key].readOnly = true;
+    }
+    if (usage !== "update" && isRequiredZodSchema(zodSchema)) {
+      required.push(key);
+    }
+  }
+  return {
+    type: "object",
+    properties,
+    ...required.length > 0 ? { required } : {}
+  };
+}
+function fieldToOpenAPISchema(field, strict = false) {
+  const schema = field.kind === "json" ? zodToOpenAPISchema(field.zodBase, strict) : field.kind === "string" ? { type: "string" } : field.kind === "uuid" ? { type: "string", format: "uuid" } : field.kind === "number" ? { type: "number" } : field.kind === "integer" ? { type: "integer" } : field.kind === "boolean" ? { type: "boolean" } : field.kind === "timestamp" ? { type: "string", format: "date-time" } : {};
+  if (field.modifiers.format === "email") {
+    schema.format = "email";
+  }
+  if (field.modifiers.min !== void 0) {
+    if (field.kind === "string" || field.kind === "uuid") {
+      schema.minLength = field.modifiers.min;
+    } else {
+      schema.minimum = field.modifiers.min;
+    }
+  }
+  if (field.modifiers.max !== void 0) {
+    if (field.kind === "string" || field.kind === "uuid") {
+      schema.maxLength = field.modifiers.max;
+    } else {
+      schema.maximum = field.modifiers.max;
+    }
+  }
+  return schema;
+}
+function zodToOpenAPISchema(schema, strict = false) {
+  const def = getZodDef(schema);
+  if (def === void 0) return {};
+  const typeName = getZodTypeName(def);
+  if (typeName === "ZodOptional" || typeName === "optional") {
+    return zodToOpenAPISchema(def.innerType, strict);
+  }
+  if (typeName === "ZodDefault" || typeName === "default") {
+    return zodToOpenAPISchema(def.innerType, strict);
+  }
+  if (typeName === "ZodNullable" || typeName === "nullable") {
+    return { ...zodToOpenAPISchema(def.innerType, strict), nullable: true };
+  }
+  if (typeName === "ZodObject" || typeName === "object") {
+    const shape = getZodObjectShape(schema);
+    const properties = {};
+    const required = [];
+    for (const [key, childSchema] of Object.entries(shape)) {
+      properties[key] = zodToOpenAPISchema(childSchema, strict);
+      if (isRequiredZodSchema(childSchema)) {
+        required.push(key);
+      }
+    }
+    return {
+      type: "object",
+      properties,
+      ...required.length > 0 ? { required } : {}
+    };
+  }
+  if (typeName === "ZodString" || typeName === "string") {
+    return applyStringChecks({ type: "string" }, def);
+  }
+  if (typeName === "ZodNumber" || typeName === "number") {
+    return applyNumberChecks({ type: hasIntegerCheck(def) ? "integer" : "number" }, def);
+  }
+  if (typeName === "ZodBoolean" || typeName === "boolean") {
+    return { type: "boolean" };
+  }
+  if (typeName === "ZodArray" || typeName === "array") {
+    const itemSchema = def.element ?? def.type;
+    return {
+      type: "array",
+      items: zodToOpenAPISchema(itemSchema, strict)
+    };
+  }
+  if (typeName === "ZodRecord" || typeName === "record") {
+    return {
+      type: "object",
+      additionalProperties: zodToOpenAPISchema(def.valueType, strict)
+    };
+  }
+  if (typeName === "ZodUnknown" || typeName === "unknown") {
+    return {};
+  }
+  if (strict) {
+    throw new Error(`Unsupported Zod type for strict OpenAPI generation: ${typeName ?? "unknown"}`);
+  }
+  return {
+    "x-nanoka-zod-unsupported": true,
+    ...typeName ? { "x-nanoka-zod-type": typeName } : {}
+  };
+}
+function getZodObjectShape(schema) {
+  if (typeof schema === "object" && schema !== null && "shape" in schema && typeof schema.shape === "object" && schema.shape !== null) {
+    return schema.shape;
+  }
+  if (typeof schema === "object" && schema !== null && "_def" in schema && typeof schema._def === "object" && schema._def !== null && "shape" in schema._def) {
+    const shape = schema._def.shape;
+    return typeof shape === "function" ? shape() : shape;
+  }
+  return {};
+}
+function isRequiredZodSchema(schema) {
+  const def = getZodDef(schema);
+  if (def === void 0) {
+    return true;
+  }
+  const typeName = getZodTypeName(def);
+  return typeName !== "ZodOptional" && typeName !== "optional" && typeName !== "ZodDefault" && typeName !== "default";
+}
+function getZodDef(schema) {
+  if (typeof schema === "object" && schema !== null && "_def" in schema && typeof schema._def === "object" && schema._def !== null) {
+    return schema._def;
+  }
+  return void 0;
+}
+function getZodTypeName(def) {
+  return typeof def.typeName === "string" ? def.typeName : typeof def.type === "string" ? def.type : void 0;
+}
+function applyStringChecks(schema, def) {
+  for (const check of getZodChecks(def)) {
+    const checkDef = getZodCheckDef(check);
+    if (checkDef.kind === "email" || checkDef.format === "email") {
+      schema.format = "email";
+    }
+    if (checkDef.kind === "min" && typeof checkDef.value === "number") {
+      schema.minLength = checkDef.value;
+    }
+    if (checkDef.kind === "max" && typeof checkDef.value === "number") {
+      schema.maxLength = checkDef.value;
+    }
+    if (checkDef.check === "min_length" && typeof checkDef.minimum === "number") {
+      schema.minLength = checkDef.minimum;
+    }
+    if (checkDef.check === "max_length" && typeof checkDef.maximum === "number") {
+      schema.maxLength = checkDef.maximum;
+    }
+  }
+  return schema;
+}
+function applyNumberChecks(schema, def) {
+  for (const check of getZodChecks(def)) {
+    const checkDef = getZodCheckDef(check);
+    if (checkDef.kind === "min" && typeof checkDef.value === "number") {
+      schema.minimum = checkDef.value;
+    }
+    if (checkDef.kind === "max" && typeof checkDef.value === "number") {
+      schema.maximum = checkDef.value;
+    }
+    if ((checkDef.check === "greater_than" || checkDef.check === "number_format") && typeof checkDef.minimum === "number") {
+      schema.minimum = checkDef.minimum;
+    }
+    if ((checkDef.check === "less_than" || checkDef.check === "number_format") && typeof checkDef.maximum === "number") {
+      schema.maximum = checkDef.maximum;
+    }
+  }
+  return schema;
+}
+function hasIntegerCheck(def) {
+  return getZodChecks(def).some((check) => {
+    const checkDef = getZodCheckDef(check);
+    return checkDef.kind === "int" || checkDef.format === "safeint" || checkDef.format === "int32" || checkDef.format === "int64";
+  });
+}
+function getZodChecks(def) {
+  return Array.isArray(def.checks) ? def.checks : [];
+}
+function getZodCheckDef(check) {
+  if (typeof check !== "object" || check === null) {
+    return {};
+  }
+  if ("_zod" in check && typeof check._zod === "object" && check._zod !== null && "def" in check._zod && typeof check._zod.def === "object" && check._zod.def !== null) {
+    return check._zod.def;
+  }
+  return check;
+}
 var MAX_LIMIT = 100;
 function guardLimit(limit) {
   if (!Number.isInteger(limit)) {
@@ -39,9 +338,9 @@ function guardOffset(offset) {
   return n;
 }
 function findPrimaryKey(fields) {
+  let pkKey;
+  let pkField;
   let pkCount = 0;
-  let pkKey = null;
-  let pkField = null;
   for (const [key, field] of Object.entries(fields)) {
     if (field.modifiers.primary === true) {
       pkCount++;
@@ -57,6 +356,9 @@ function findPrimaryKey(fields) {
   if (pkCount > 1) {
     throw new HTTPException(500, { message: "model has multiple primary keys" });
   }
+  if (pkKey === void 0 || pkField === void 0) {
+    return null;
+  }
   return [pkKey, pkField];
 }
 function buildWhereClause(table, fields, where) {
@@ -166,37 +468,6 @@ async function deleteImpl(adapter, table, fields, idOrWhere) {
   const result = await adapter.drizzle.delete(table).where(whereClause).returning();
   return { deleted: result.length };
 }
-function buildBaseObject(fields) {
-  const shape = {};
-  for (const [key, field] of Object.entries(fields)) {
-    shape[key] = field.zodBase;
-  }
-  return z.object(shape);
-}
-function applySchemaOptions(baseSchema, opts) {
-  if (!opts) {
-    return baseSchema;
-  }
-  let schema = baseSchema;
-  if (opts.pick !== void 0) {
-    const pickArray = Array.from(opts.pick);
-    schema = schema.pick(
-      // biome-ignore lint/suspicious/noExplicitAny: Zod API
-      Object.fromEntries(pickArray.map((k) => [k, true]))
-    );
-  }
-  if (opts.omit !== void 0) {
-    const omitArray = Array.from(opts.omit);
-    schema = schema.omit(
-      // biome-ignore lint/suspicious/noExplicitAny: Zod API
-      Object.fromEntries(omitArray.map((k) => [k, true]))
-    );
-  }
-  if (opts.partial === true) {
-    schema = schema.partial();
-  }
-  return schema;
-}
 function buildTable(tableName, fields) {
   const columns = {};
   for (const [key, field] of Object.entries(fields)) {
@@ -208,19 +479,49 @@ function buildTable(tableName, fields) {
 // src/model/define.ts
 function defineModel(tableName, fields) {
   const table = buildTable(tableName, fields);
+  const accessor = buildFieldAccessor(fields);
   return {
     fields,
     tableName,
     table,
     schema(opts) {
       const baseSchema = buildBaseObject(fields);
-      const schema = applySchemaOptions(baseSchema, opts);
+      const schema = applySchemaOptions(baseSchema, opts, accessor);
       return schema;
     },
-    validator(target, opts, hook) {
-      const schema = this.schema(opts);
+    validator(target, optsOrPreset, hook) {
+      let schema;
+      if (optsOrPreset === "create" || optsOrPreset === "update") {
+        schema = this.inputSchema(optsOrPreset);
+      } else {
+        schema = this.schema(optsOrPreset);
+      }
       return zValidator(target, schema, hook);
     },
+    inputSchema(usage, opts) {
+      const merged = derivePolicyOptions(
+        fields,
+        usage === "create" ? "input-create" : "input-update",
+        opts,
+        accessor
+      );
+      const baseSchema = buildBaseObject(fields);
+      return applySchemaOptions(baseSchema, merged);
+    },
+    outputSchema(opts) {
+      const merged = derivePolicyOptions(fields, "output", opts, accessor);
+      const baseSchema = buildBaseObject(fields);
+      return applySchemaOptions(baseSchema, merged);
+    },
+    toResponse(row) {
+      return this.outputSchema().parse(row);
+    },
+    toOpenAPIComponent() {
+      return toOpenAPIComponent(fields);
+    },
+    toOpenAPISchema(usage) {
+      return toOpenAPISchema(fields, usage);
+    },
     findMany(adapter, options) {
       return findManyImpl(adapter, table, fields, options);
     },
@@ -238,13 +539,91 @@ function defineModel(tableName, fields) {
     }
   };
 }
+
+// src/openapi/route.ts
+function honoPathToOpenAPI(path) {
+  return path.replace(/:([^/]+)/g, "{$1}");
+}
+function buildOpenAPIDocument(routes, options) {
+  const paths = {};
+  for (const route of routes) {
+    const openAPIPath = honoPathToOpenAPI(route.path);
+    if (!paths[openAPIPath]) {
+      paths[openAPIPath] = {};
+    }
+    const operation = {};
+    if (route.operationId) operation.operationId = route.operationId;
+    if (route.summary) operation.summary = route.summary;
+    if (route.description) operation.description = route.description;
+    if (route.tags) operation.tags = route.tags;
+    const parameters = [];
+    const pathParams = [...route.path.matchAll(/:([^/]+)/g)].map((m) => m[1]);
+    for (const param of pathParams) {
+      const alreadyDefined = route.params?.some((p) => p.name === param && p.in === "path");
+      if (!alreadyDefined) {
+        parameters.push({ name: param, in: "path", required: true, schema: { type: "string" } });
+      }
+    }
+    if (route.params) {
+      parameters.push(...route.params);
+    }
+    if (parameters.length > 0) operation.parameters = parameters;
+    if (route.requestBody) operation.requestBody = route.requestBody;
+    operation.responses = route.responses;
+    paths[openAPIPath][route.method] = operation;
+  }
+  const doc = {
+    openapi: "3.1.0",
+    info: options.info,
+    ...options.servers ? { servers: options.servers } : {},
+    paths
+  };
+  return doc;
+}
+
+// src/openapi/swagger-ui.ts
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function swaggerUI(options) {
+  const title = escapeHtml(options.title ?? "API Documentation");
+  const html = `<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <title>${title}</title>
+  <link rel="stylesheet" href="https://unpkg.com/swagger-ui-dist@5/swagger-ui.css" />
+</head>
+<body>
+  <div id="swagger-ui"></div>
+  <script src="https://unpkg.com/swagger-ui-dist@5/swagger-ui-bundle.js"></script>
+  <script>
+    SwaggerUIBundle({
+      url: ${JSON.stringify(options.url)},
+      dom_id: '#swagger-ui',
+      presets: [SwaggerUIBundle.presets.apis, SwaggerUIBundle.SwaggerUIStandalonePreset],
+      layout: 'BaseLayout',
+    })
+  </script>
+</body>
+</html>`;
+  return async (c) => {
+    return c.html(html);
+  };
+}
 function nanoka(adapter) {
   const app = new Hono();
+  const openapiRoutes = [];
   Object.defineProperty(app, "db", {
     get: () => adapter.drizzle,
     enumerable: true
   });
   app.batch = ((queries) => adapter.batch(queries));
+  app.openapi = (metadata) => {
+    openapiRoutes.push(metadata);
+    return app;
+  };
+  app.generateOpenAPISpec = (options) => buildOpenAPIDocument(openapiRoutes, options);
   app.model = function model(name, fields) {
     const inner = defineModel(name, fields);
     return {
@@ -252,7 +631,14 @@ function nanoka(adapter) {
       tableName: inner.tableName,
       table: inner.table,
       schema: (opts) => inner.schema(opts),
-      validator: (target, opts, hook) => inner.validator(target, opts, hook),
+      validator: (...args) => {
+        return inner.validator(...args);
+      },
+      inputSchema: (usage, opts) => inner.inputSchema(usage, opts),
+      outputSchema: (opts) => inner.outputSchema(opts),
+      toResponse: (row) => inner.toResponse(row),
+      toOpenAPIComponent: () => inner.toOpenAPIComponent(),
+      toOpenAPISchema: (usage) => inner.toOpenAPISchema(usage),
       findMany: (options) => inner.findMany(adapter, options),
       findOne: (idOrWhere) => inner.findOne(adapter, idOrWhere),
       create: (data) => inner.create(adapter, data),
@@ -263,6 +649,6 @@ function nanoka(adapter) {
   return app;
 }
 
-export { d1Adapter, defineModel, nanoka };
+export { d1Adapter, defineModel, nanoka, swaggerUI };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map