hekireki 0.7.4 → 0.7.6

package/README.md

@@ -301,22 +301,34 @@ export type PostRelations = v.InferOutput<typeof PostRelationsSchema>
 import { type } from 'arktype'
 
 export const UserSchema = type({
-  /** Primary key */
+  /**
+   * Primary key
+   */
   id: 'string.uuid',
-  /** Display name */
+  /**
+   * Display name
+   */
   name: '1 <= string <= 50',
 })
 
 export type User = typeof UserSchema.infer
 
 export const PostSchema = type({
-  /** Primary key */
+  /**
+   * Primary key
+   */
   id: 'string.uuid',
-  /** Article title */
+  /**
+   * Article title
+   */
   title: '1 <= string <= 100',
-  /** Body content (no length limit) */
+  /**
+   * Body content (no length limit)
+   */
   content: 'string',
-  /** Foreign key referencing User.id */
+  /**
+   * Foreign key referencing User.id
+   */
   userId: 'string.uuid',
 })
 
@@ -369,22 +381,34 @@ export type PostEncoded = typeof PostSchema.Encoded
 import { type Static, Type } from '@sinclair/typebox'
 
 export const UserSchema = Type.Object({
-  /** Primary key */
+  /**
+   * Primary key
+   */
   id: Type.String({ format: 'uuid' }),
-  /** Display name */
+  /**
+   * Display name
+   */
   name: Type.String({ minLength: 1, maxLength: 50 }),
 })
 
 export type User = Static<typeof UserSchema>
 
 export const PostSchema = Type.Object({
-  /** Primary key */
+  /**
+   * Primary key
+   */
   id: Type.String({ format: 'uuid' }),
-  /** Article title */
+  /**
+   * Article title
+   */
   title: Type.String({ minLength: 1, maxLength: 100 }),
-  /** Body content (no length limit) */
+  /**
+   * Body content (no length limit)
+   */
   content: Type.String(),
-  /** Foreign key referencing User.id */
+  /**
+   * Foreign key referencing User.id
+   */
   userId: Type.String({ format: 'uuid' }),
 })
 
@@ -405,7 +429,7 @@ export const PostRelationsSchema = Type.Object({
 export type PostRelations = Static<typeof PostRelationsSchema>
 ```
 
-### AJV (JSON Schema)
+### AJV
 
 ```ts
 import type { FromSchema } from 'json-schema-to-ts'
@@ -413,9 +437,13 @@ import type { FromSchema } from 'json-schema-to-ts'
 export const UserSchema = {
   type: 'object' as const,
   properties: {
-    /** Primary key */
+    /**
+     * Primary key
+     */
     id: { type: 'string' as const, format: 'uuid' as const },
-    /** Display name */
+    /**
+     * Display name
+     */
     name: { type: 'string' as const, minLength: 1, maxLength: 50 },
   },
   required: ['id', 'name'] as const,
@@ -427,13 +455,21 @@ export type User = FromSchema<typeof UserSchema>
 export const PostSchema = {
   type: 'object' as const,
   properties: {
-    /** Primary key */
+    /**
+     * Primary key
+     */
     id: { type: 'string' as const, format: 'uuid' as const },
-    /** Article title */
+    /**
+     * Article title
+     */
     title: { type: 'string' as const, minLength: 1, maxLength: 100 },
-    /** Body content (no length limit) */
+    /**
+     * Body content (no length limit)
+     */
     content: { type: 'string' as const },
-    /** Foreign key referencing User.id */
+    /**
+     * Foreign key referencing User.id
+     */
     userId: { type: 'string' as const, format: 'uuid' as const },
   },
   required: ['id', 'title', 'content', 'userId'] as const,

package/dist/cli/index.d.ts

@@ -1,14 +1,57 @@
 //#region src/cli/index.d.ts
-type Result<T> = {
+declare const HELP_TEXT = "\u26A1\uFE0F hekireki - Prisma schema tools\n\nUsage:\n  hekireki <command> [options]\n\nCommands:\n  docs serve    Start a local server to view the documentation\n\nOptions:\n  -p, --port <port>    Specify the port (default: 5858)\n  -h, --help           Show help\n\nExamples:\n  hekireki docs serve\n  hekireki docs serve -p 3000";
+declare const DOCS_HELP_TEXT = "\u26A1\uFE0F hekireki docs - Documentation tools\n\nUsage:\n  hekireki docs serve [options]\n\nCommands:\n  serve    Start a local server to view the documentation\n\nOptions:\n  -p, --port <port>    Specify the port (default: 5858)\n  -h, --help           Show help\n\nExamples:\n  hekireki docs serve\n  hekireki docs serve -p 3000";
+/**
+ * Parse port from CLI arguments.
+ */
+declare const parsePort: (args: readonly string[]) => {
+  readonly ok: true;
+  readonly value: number;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+/**
+ * Parse CLI arguments for docs serve command.
+ */
+declare const parseDocsServeArgs: (args: readonly string[]) => {
+  readonly ok: true;
+  readonly value: {
+    readonly port: number;
+  };
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+/**
+ * Handle docs subcommand.
+ */
+declare const handleDocs: (args: readonly string[]) => {
+  readonly ok: true;
+  readonly value: string;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
+/**
+ * Main CLI dispatcher (pure — takes args, returns Result).
+ */
+declare const hekirekiCli: (args: readonly string[]) => {
   readonly ok: true;
-  readonly value: T;
+  readonly value: string;
 } | {
   readonly ok: false;
   readonly error: string;
 };
 /**
- * Main CLI entry point for hekireki.
+ * Main CLI entry point for hekireki (reads process.argv).
  */
-declare const hekireki: () => Result<string>;
+declare const hekireki: () => {
+  readonly ok: true;
+  readonly value: string;
+} | {
+  readonly ok: false;
+  readonly error: string;
+};
 //#endregion
-export { hekireki };
+export { DOCS_HELP_TEXT, HELP_TEXT, handleDocs, hekireki, hekirekiCli, parseDocsServeArgs, parsePort };

package/dist/cli/index.js

@@ -137,10 +137,9 @@ const handleDocs = (args) => {
 */
 const commands = { docs: handleDocs };
 /**
-* Main CLI entry point for hekireki.
+* Main CLI dispatcher (pure — takes args, returns Result).
 */
-const hekireki = () => {
-	const args = process.argv.slice(2);
+const hekirekiCli = (args) => {
 	const command = args[0];
 	if (!command || command === "-h" || command === "--help") return {
 		ok: true,
@@ -153,6 +152,12 @@ const hekireki = () => {
 	};
 	return handler(args.slice(1));
 };
+/**
+* Main CLI entry point for hekireki (reads process.argv).
+*/
+const hekireki = () => {
+	return hekirekiCli(process.argv.slice(2));
+};
 const result = hekireki();
 if (result.ok) console.log(result.value);
 else {
@@ -161,4 +166,4 @@ else {
 }
 
 //#endregion
-export { hekireki };
+export { DOCS_HELP_TEXT, HELP_TEXT, handleDocs, hekireki, hekirekiCli, parseDocsServeArgs, parsePort };

package/dist/generator/ajv/index.d.ts

@@ -1,6 +1,10 @@
 import { GeneratorOptions } from "@prisma/generator-helper";
 
 //#region src/generator/ajv/index.d.ts
+/**
+ * Prisma generator entry point for AJV JSON Schema generation
+ * @param options - The Prisma generator options
+ */
 declare function main(options: GeneratorOptions): Promise<void>;
 //#endregion
 export { main };

package/dist/generator/ajv/index.js

@@ -1,17 +1,26 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-DwiYldCm.js";
-import { c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, s as makeValidationExtractor, t as getBool } from "../../utils-0tE5jzYR.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-DHllEbMR.js";
+import { l as makeValidationExtractor, m as writeFile, n as getBool, o as makeCommentBlock, p as mkdir, u as parseDocumentWithoutAnnotations } from "../../utils-3ot3YB3D.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-o4IvnEUh.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/ajv.ts
+/**
+* Generate AJV type inference using FromSchema
+* @param modelName - The model name to generate type inference for
+*/
 function makeAjvInfer(modelName) {
 	return `export type ${modelName} = FromSchema<typeof ${modelName}Schema>`;
 }
+/**
+* Generate JSON Schema enum expression for AJV
+* @param values - The enum values to generate expression for
+*/
 function makeAjvEnumExpression(values) {
 	return `{ enum: [${values.map((v) => `'${v}'`).join(", ")}] as const }`;
 }
+/** Mapping from Prisma scalar types to JSON Schema type expressions */
 const PRISMA_TO_AJV = {
 	String: "{ type: 'string' as const }",
 	Int: "{ type: 'integer' as const }",
@@ -23,14 +32,25 @@ const PRISMA_TO_AJV = {
 	Json: "{}",
 	Bytes: "{ type: 'string' as const }"
 };
-function makeAjvSchemas(modelFields, comment) {
+/**
+* Generate JSON Schema object definition for a model
+* @param modelFields - The fields of the model
+* @param comment - Whether to include JSDoc comments in the generated code
+*/
+function makeAjvSchemas(modelFields, comment, objectType) {
 	const modelName = modelFields[0].modelName;
 	const properties = modelFields.map((field) => {
-		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `    /** ${c} */`).join("\n")}\n` : ""}    ${field.fieldName}: ${field.validation ?? "{ type: 'unknown' as const }"},`;
+		return `${comment ? makeCommentBlock(field.comment, 4) : ""}    ${field.fieldName}: ${field.validation ?? "{ type: 'unknown' as const }"},`;
 	}).join("\n");
 	const requiredFields = modelFields.filter((f) => f.isRequired).map((f) => f.fieldName);
-	return `export const ${modelName}Schema = {\n  type: 'object' as const,\n  properties: {\n${properties}\n  },${requiredFields.length > 0 ? `\n  required: [${requiredFields.map((f) => `'${f}'`).join(", ")}] as const,` : ""}\n  additionalProperties: false,\n} as const`;
+	return `export const ${modelName}Schema = {\n  type: 'object' as const,\n  properties: {\n${properties}\n  },${requiredFields.length > 0 ? `\n  required: [${requiredFields.map((f) => `'${f}'`).join(", ")}] as const,` : ""}\n  additionalProperties: ${objectType === "loose" ? "true" : "false"},\n} as const`;
 }
+/**
+* Generate JSON Schema relation object definition
+* @param model - The model to generate relations for
+* @param relProps - The relation properties
+* @param options - Options for type export generation
+*/
 function makeAjvRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const base = `    ...${model.name}Schema.properties,`;
@@ -38,6 +58,13 @@ function makeAjvRelations(model, relProps, options) {
 	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = FromSchema<typeof ${model.name}RelationsSchema>` : "";
 	return `export const ${model.name}RelationsSchema = {\n  type: 'object' as const,\n  properties: {\n${base}\n${rels}\n  },\n  additionalProperties: false,\n} as const${typeLine}`;
 }
+/**
+* Generate AJV-compatible JSON Schema validation code from Prisma models
+* @param models - The Prisma data models
+* @param type - Whether to include type inference using FromSchema
+* @param comment - Whether to include JSDoc comments in the generated code
+* @param enums - The Prisma enum definitions
+*/
 function ajv(models, type, comment, enums) {
 	return validationSchemas(models, type, comment, {
 		importStatement: type ? `import type { FromSchema } from 'json-schema-to-ts'` : "",
@@ -55,6 +82,10 @@ function ajv(models, type, comment, enums) {
 //#endregion
 //#region src/generator/ajv/index.ts
 const { generatorHandler } = pkg;
+/**
+* Prisma generator entry point for AJV JSON Schema generation
+* @param options - The Prisma generator options
+*/
 async function main(options) {
 	if (!(options.generator.isCustomOutput && options.generator.output?.value)) throw new Error("output is required for Hekireki-AJV. Please specify output in your generator config.");
 	const output = options.generator.output.value;

package/dist/generator/arktype/index.d.ts

@@ -1,6 +1,10 @@
 import { GeneratorOptions } from "@prisma/generator-helper";
 
 //#region src/generator/arktype/index.d.ts
+/**
+ * Prisma generator entry point for ArkType schema generation
+ * @param options - The Prisma generator options
+ */
 declare function main(options: GeneratorOptions): Promise<void>;
 //#endregion
 export { main };

package/dist/generator/arktype/index.js

@@ -1,25 +1,44 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-DwiYldCm.js";
-import { c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, s as makeValidationExtractor, t as getBool } from "../../utils-0tE5jzYR.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-DHllEbMR.js";
+import { d as schemaFromFields, l as makeValidationExtractor, m as writeFile, n as getBool, o as makeCommentBlock, p as mkdir, u as parseDocumentWithoutAnnotations } from "../../utils-3ot3YB3D.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-o4IvnEUh.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/arktype.ts
+/**
+* Generate ArkType type inference
+* @param modelName - The model name to generate type inference for
+*/
 function makeArktypeInfer(modelName) {
 	return `export type ${modelName} = typeof ${modelName}Schema.infer`;
 }
-function makeArktypeSchema(modelName, fields) {
-	return `export const ${modelName}Schema = type({\n${fields}\n})`;
+/**
+* Generate ArkType type() schema definition
+* @param modelName - The model name for the schema
+* @param fields - The formatted field definitions string
+*/
+function makeArktypeSchema(modelName, fields, objectType) {
+	return `export const ${modelName}Schema = type({${objectType === "strict" ? "\n  \"+\": \"reject\",\n" : objectType === "loose" ? "\n  \"+\": \"ignore\",\n" : "\n"}${fields}\n})`;
 }
+/**
+* Generate ArkType property definitions
+* @param fields - The fields to generate properties for
+* @param comment - Whether to include JSDoc comments in the generated code
+*/
 function makeArktypeProperties(fields, comment) {
 	return fields.map((field) => {
-		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\n")}\n` : ""}  ${field.fieldName}: ${field.validation ?? "\"unknown\""},`;
+		return `${comment ? makeCommentBlock(field.comment, 2) : ""}  ${field.fieldName}: ${field.validation ?? "\"unknown\""},`;
 	}).join("\n");
 }
+/**
+* Generate ArkType enum expression using union string syntax
+* @param values - The enum values to generate expression for
+*/
 function makeArktypeEnumExpression(values) {
 	return `"${values.map((v) => `'${v}'`).join(" | ")}"`;
 }
+/** Mapping from Prisma scalar types to ArkType type expressions */
 const PRISMA_TO_ARKTYPE = {
 	String: "\"string\"",
 	Int: "\"number\"",
@@ -31,15 +50,33 @@ const PRISMA_TO_ARKTYPE = {
 	Json: "\"unknown\"",
 	Bytes: "\"unknown\""
 };
-function makeArktypeSchemas(modelFields, comment) {
-	return schemaFromFields(modelFields, comment, makeArktypeSchema, makeArktypeProperties);
+/**
+* Generate ArkType type() schema from model fields
+* @param modelFields - The fields of the model
+* @param comment - Whether to include JSDoc comments in the generated code
+*/
+function makeArktypeSchemas(modelFields, comment, objectType) {
+	return schemaFromFields(modelFields, comment, makeArktypeSchema, makeArktypeProperties, objectType);
 }
+/**
+* Generate ArkType relation schema definition
+* @param model - The model to generate relations for
+* @param relProps - The relation properties
+* @param options - Options for type export generation
+*/
 function makeArktypeRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const fields = `${`...${model.name}Schema.t,`}${relProps.map((r) => `${r.key}:${r.isMany ? `${r.targetModel}Schema.array()` : `${r.targetModel}Schema`},`).join("")}`;
 	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = typeof ${model.name}RelationsSchema.infer` : "";
 	return `export const ${model.name}RelationsSchema = type({${fields}})${typeLine}`;
 }
+/**
+* Generate ArkType validation code from Prisma models
+* @param models - The Prisma data models
+* @param type - Whether to include type inference
+* @param comment - Whether to include JSDoc comments in the generated code
+* @param enums - The Prisma enum definitions
+*/
 function arktype(models, type, comment, enums) {
 	return validationSchemas(models, type, comment, {
 		importStatement: `import { type } from 'arktype'`,
@@ -57,6 +94,10 @@ function arktype(models, type, comment, enums) {
 //#endregion
 //#region src/generator/arktype/index.ts
 const { generatorHandler } = pkg;
+/**
+* Prisma generator entry point for ArkType schema generation
+* @param options - The Prisma generator options
+*/
 async function main(options) {
 	if (!(options.generator.isCustomOutput && options.generator.output?.value)) throw new Error("output is required for Hekireki-ArkType. Please specify output in your generator config.");
 	const output = options.generator.output.value;

package/dist/generator/dbml/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as mkdir, f as writeFile, n as getString, p as writeFileBinary, u as stripAnnotations } from "../../utils-0tE5jzYR.js";
+import { f as stripAnnotations, h as writeFileBinary, m as writeFile, p as mkdir, r as getString } from "../../utils-3ot3YB3D.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 import { Resvg } from "@resvg/resvg-js";

package/dist/generator/drizzle/index.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-DwiYldCm.js";
-import { d as mkdir, f as writeFile, o as makeSnakeCase } from "../../utils-0tE5jzYR.js";
+import { c as makeSnakeCase, m as writeFile, p as mkdir } from "../../utils-3ot3YB3D.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 

package/dist/generator/ecto/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as mkdir, f as writeFile, o as makeSnakeCase } from "../../utils-0tE5jzYR.js";
+import { c as makeSnakeCase, m as writeFile, p as mkdir } from "../../utils-3ot3YB3D.js";
 import { join } from "node:path";
 import pkg from "@prisma/generator-helper";
 

package/dist/generator/effect/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-DwiYldCm.js";
-import { c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, s as makeValidationExtractor, t as getBool } from "../../utils-0tE5jzYR.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-DHllEbMR.js";
+import { d as schemaFromFields, l as makeValidationExtractor, m as writeFile, n as getBool, o as makeCommentBlock, p as mkdir, u as parseDocumentWithoutAnnotations } from "../../utils-3ot3YB3D.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-o4IvnEUh.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
@@ -14,7 +14,7 @@ function makeEffectSchema(modelName, fields) {
 }
 function makeEffectProperties(fields, comment) {
 	return fields.map((field) => {
-		return `${comment && field.comment.length > 0 ? `  /**\n${field.comment.map((c) => `   * ${c}`).join("\n")}\n   */\n` : ""}  ${field.fieldName}: ${field.validation ?? "Schema.Unknown"},`;
+		return `${comment ? makeCommentBlock(field.comment, 2) : ""}  ${field.fieldName}: ${field.validation ?? "Schema.Unknown"},`;
 	}).join("\n");
 }
 function makeEffectEnumExpression(values) {

package/dist/generator/gorm/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as mkdir, f as writeFile, n as getString, o as makeSnakeCase } from "../../utils-0tE5jzYR.js";
+import { c as makeSnakeCase, m as writeFile, p as mkdir, r as getString } from "../../utils-3ot3YB3D.js";
 import path, { dirname } from "node:path";
 import pkg from "@prisma/generator-helper";
 

package/dist/generator/mermaid-er/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as mkdir, f as writeFile, u as stripAnnotations } from "../../utils-0tE5jzYR.js";
+import { f as stripAnnotations, m as writeFile, p as mkdir } from "../../utils-3ot3YB3D.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 

package/dist/generator/sea-orm/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as mkdir, f as writeFile, n as getString, o as makeSnakeCase } from "../../utils-0tE5jzYR.js";
+import { c as makeSnakeCase, m as writeFile, p as mkdir, r as getString } from "../../utils-3ot3YB3D.js";
 import { join } from "node:path";
 import pkg from "@prisma/generator-helper";
 

package/dist/generator/sqlalchemy/index.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { d as mkdir, f as writeFile, o as makeSnakeCase } from "../../utils-0tE5jzYR.js";
+import { c as makeSnakeCase, m as writeFile, p as mkdir } from "../../utils-3ot3YB3D.js";
 import path, { dirname } from "node:path";
 import pkg from "@prisma/generator-helper";
 

package/dist/generator/typebox/index.d.ts

@@ -1,6 +1,10 @@
 import { GeneratorOptions } from "@prisma/generator-helper";
 
 //#region src/generator/typebox/index.d.ts
+/**
+ * Prisma generator entry point for TypeBox schema generation
+ * @param options - The Prisma generator options
+ */
 declare function main(options: GeneratorOptions): Promise<void>;
 //#endregion
 export { main };

package/dist/generator/typebox/index.js

@@ -1,28 +1,48 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-DwiYldCm.js";
-import { c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, s as makeValidationExtractor, t as getBool } from "../../utils-0tE5jzYR.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-DHllEbMR.js";
+import { d as schemaFromFields, l as makeValidationExtractor, m as writeFile, n as getBool, o as makeCommentBlock, p as mkdir, u as parseDocumentWithoutAnnotations } from "../../utils-3ot3YB3D.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-o4IvnEUh.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/typebox.ts
+/**
+* Generate TypeBox type inference using Static
+* @param modelName - The model name to generate type inference for
+*/
 function makeTypeBoxInfer(modelName) {
 	return `export type ${modelName} = Static<typeof ${modelName}Schema>`;
 }
-function makeTypeBoxSchema(modelName, fields) {
-	return `export const ${modelName}Schema = Type.Object({\n${fields}\n})`;
+/**
+* Generate TypeBox Type.Object schema definition
+* @param modelName - The model name for the schema
+* @param fields - The formatted field definitions string
+*/
+function makeTypeBoxSchema(modelName, fields, objectType) {
+	const obj = `Type.Object({\n${fields}\n})`;
+	return objectType === "strict" ? `export const ${modelName}Schema = Type.Strict(${obj})` : `export const ${modelName}Schema = ${obj}`;
 }
+/**
+* Generate TypeBox property definitions with optional wrapping
+* @param fields - The fields to generate properties for
+* @param comment - Whether to include JSDoc comments in the generated code
+*/
 function makeTypeBoxProperties(fields, comment) {
 	return fields.map((field) => {
-		const commentLines = comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\n")}\n` : "";
+		const commentBlock = comment ? makeCommentBlock(field.comment, 2) : "";
 		const expr = field.validation ?? "Type.Unknown()";
 		const wrapped = field.isRequired ? expr : `Type.Optional(${expr})`;
-		return `${commentLines}  ${field.fieldName}: ${wrapped},`;
+		return `${commentBlock}  ${field.fieldName}: ${wrapped},`;
 	}).join("\n");
 }
+/**
+* Generate TypeBox enum expression using Type.Union with Type.Literal
+* @param values - The enum values to generate expression for
+*/
 function makeTypeBoxEnumExpression(values) {
 	return `Type.Union([${values.map((v) => `Type.Literal('${v}')`).join(", ")}])`;
 }
+/** Mapping from Prisma scalar types to TypeBox type expressions */
 const PRISMA_TO_TYPEBOX = {
 	String: "Type.String()",
 	Int: "Type.Integer()",
@@ -34,9 +54,20 @@ const PRISMA_TO_TYPEBOX = {
 	Json: "Type.Unknown()",
 	Bytes: "Type.Any()"
 };
-function makeTypeBoxSchemas(modelFields, comment) {
-	return schemaFromFields(modelFields, comment, makeTypeBoxSchema, makeTypeBoxProperties);
+/**
+* Generate TypeBox Type.Object schema from model fields
+* @param modelFields - The fields of the model
+* @param comment - Whether to include JSDoc comments in the generated code
+*/
+function makeTypeBoxSchemas(modelFields, comment, objectType) {
+	return schemaFromFields(modelFields, comment, makeTypeBoxSchema, makeTypeBoxProperties, objectType);
 }
+/**
+* Generate TypeBox relation schema definition
+* @param model - The model to generate relations for
+* @param relProps - The relation properties
+* @param options - Options for type export generation
+*/
 function makeTypeBoxRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const base = `  ...${model.name}Schema.properties,`;
@@ -44,6 +75,13 @@ function makeTypeBoxRelations(model, relProps, options) {
 	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = Static<typeof ${model.name}RelationsSchema>` : "";
 	return `export const ${model.name}RelationsSchema = Type.Object({\n${base}\n${rels}\n})${typeLine}`;
 }
+/**
+* Generate TypeBox validation code from Prisma models
+* @param models - The Prisma data models
+* @param type - Whether to include type inference using Static
+* @param comment - Whether to include JSDoc comments in the generated code
+* @param enums - The Prisma enum definitions
+*/
 function typebox(models, type, comment, enums) {
 	return validationSchemas(models, type, comment, {
 		importStatement: type ? `import { type Static, Type } from '@sinclair/typebox'` : `import { Type } from '@sinclair/typebox'`,
@@ -61,6 +99,10 @@ function typebox(models, type, comment, enums) {
 //#endregion
 //#region src/generator/typebox/index.ts
 const { generatorHandler } = pkg;
+/**
+* Prisma generator entry point for TypeBox schema generation
+* @param options - The Prisma generator options
+*/
 async function main(options) {
 	if (!(options.generator.isCustomOutput && options.generator.output?.value)) throw new Error("output is required for Hekireki-TypeBox. Please specify output in your generator config.");
 	const output = options.generator.output.value;

package/dist/generator/valibot/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-DwiYldCm.js";
-import { a as makePropertiesGenerator, c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, s as makeValidationExtractor, t as getBool } from "../../utils-0tE5jzYR.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-DHllEbMR.js";
+import { d as schemaFromFields, l as makeValidationExtractor, m as writeFile, n as getBool, p as mkdir, s as makePropertiesGenerator, u as parseDocumentWithoutAnnotations } from "../../utils-3ot3YB3D.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-o4IvnEUh.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
@@ -9,8 +9,8 @@ import pkg from "@prisma/generator-helper";
 function makeValibotInfer(modelName) {
 	return `export type ${modelName} = v.InferOutput<typeof ${modelName}Schema>`;
 }
-function makeValibotSchema(modelName, fields) {
-	return `export const ${modelName}Schema = v.object({\n${fields}\n})`;
+function makeValibotSchema(modelName, fields, objectType) {
+	return `export const ${modelName}Schema = v.${objectType === "strict" ? "strictObject" : objectType === "loose" ? "looseObject" : "object"}({\n${fields}\n})`;
 }
 function makeValibotEnumExpression(values) {
 	return `picklist([${values.map((v) => `'${v}'`).join(", ")}])`;
@@ -26,8 +26,8 @@ const PRISMA_TO_VALIBOT = {
 	Json: "unknown()",
 	Bytes: "any()"
 };
-function makeValibotSchemas(modelFields, comment) {
-	return schemaFromFields(modelFields, comment, makeValibotSchema, makePropertiesGenerator("v", (expr, isRequired) => isRequired ? expr : `v.exactOptional(${expr})`));
+function makeValibotSchemas(modelFields, comment, objectType) {
+	return schemaFromFields(modelFields, comment, makeValibotSchema, makePropertiesGenerator("v", (expr, isRequired) => isRequired ? expr : `v.exactOptional(${expr})`), objectType);
 }
 function makeValibotRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;

package/dist/generator/zod/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { t as fmt } from "../../format-DwiYldCm.js";
-import { a as makePropertiesGenerator, c as parseDocumentWithoutAnnotations, d as mkdir, f as writeFile, l as schemaFromFields, n as getString, s as makeValidationExtractor, t as getBool } from "../../utils-0tE5jzYR.js";
-import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-DHllEbMR.js";
+import { d as schemaFromFields, l as makeValidationExtractor, m as writeFile, n as getBool, p as mkdir, r as getString, s as makePropertiesGenerator, u as parseDocumentWithoutAnnotations } from "../../utils-3ot3YB3D.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-o4IvnEUh.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
@@ -9,8 +9,8 @@ import pkg from "@prisma/generator-helper";
 function makeZodInfer(modelName) {
 	return `export type ${modelName} = z.infer<typeof ${modelName}Schema>`;
 }
-function makeZodSchema(modelName, fields) {
-	return `export const ${modelName}Schema = z.object({\n${fields}\n})`;
+function makeZodSchema(modelName, fields, objectType) {
+	return `export const ${modelName}Schema = z.${objectType === "strict" ? "strictObject" : objectType === "loose" ? "looseObject" : "object"}({\n${fields}\n})`;
 }
 function makeZodEnumExpression(values) {
 	return `enum([${values.map((v) => `'${v}'`).join(", ")}])`;
@@ -26,8 +26,8 @@ const PRISMA_TO_ZOD = {
 	Json: "unknown()",
 	Bytes: "any()"
 };
-function makeZodSchemas(modelFields, comment) {
-	return schemaFromFields(modelFields, comment, makeZodSchema, makePropertiesGenerator("z", (expr, isRequired) => isRequired ? expr : `${expr}.exactOptional()`));
+function makeZodSchemas(modelFields, comment, objectType) {
+	return schemaFromFields(modelFields, comment, makeZodSchema, makePropertiesGenerator("z", (expr, isRequired) => isRequired ? expr : `${expr}.exactOptional()`), objectType);
 }
 function makeZodRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;

package/dist/{prisma-DHllEbMR.js → prisma-o4IvnEUh.js}

@@ -1,4 +1,4 @@
-import { i as isFields, r as groupByModel } from "./utils-0tE5jzYR.js";
+import { a as isFields, i as groupByModel, t as extractObjectType } from "./utils-3ot3YB3D.js";
 
 //#region src/helper/prisma.ts
 function collectRelationProps(models) {
@@ -61,10 +61,13 @@ function validationSchemas(models, type, comment, config) {
 		fieldName: f.name
 	})));
 	if (config.onWarning) for (const { modelName, fieldName } of missing) config.onWarning(`Warning: Field "${modelName}.${fieldName}" has no ${config.annotationPrefix} annotation and will be omitted from the schema`);
-	const schemas = Object.values(groupByModel(isFields(modelFields))).map((fields) => ({
-		schema: config.schemas(fields, comment),
-		inferType: type ? config.inferType(fields[0].modelName) : ""
-	})).flatMap(({ schema, inferType }) => [schema, inferType].filter(Boolean)).join("\n\n");
+	const schemas = Object.values(groupByModel(isFields(modelFields))).map((fields) => {
+		const objectType = extractObjectType(fields[0].documentation, config.annotationPrefix);
+		return {
+			schema: config.schemas(fields, comment, objectType),
+			inferType: type ? config.inferType(fields[0].modelName) : ""
+		};
+	}).flatMap(({ schema, inferType }) => [schema, inferType].filter(Boolean)).join("\n\n");
 	return config.importStatement ? [
 		config.importStatement,
 		"",

package/dist/{utils-0tE5jzYR.js → utils-3ot3YB3D.js}

@@ -56,11 +56,21 @@ function stripAnnotations(doc) {
 	}).join("\n").trim();
 	return result.length > 0 ? result : void 0;
 }
+/**
+* Generate a JSDoc comment block from comment lines
+* @param lines - The comment lines to include
+* @param indent - The indentation level in spaces
+*/
+function makeCommentBlock(lines, indent) {
+	if (lines.length === 0) return "";
+	const prefix = " ".repeat(indent);
+	return `${prefix}/**\n${lines.map((c) => `${prefix} * ${c}`).join("\n")}\n${prefix} */\n`;
+}
 function makePropertiesGenerator(libraryPrefix, wrapCardinality) {
 	return function makeProperties(modelFields, includeComments) {
 		return modelFields.filter((field) => field.validation).map((field) => {
 			const cleanLines = field.comment.filter((line) => !(line.includes("@relation") || line.includes("@z") || line.includes("@v") || line.includes("@a") || line.includes("@e") || line.includes("@t") || line.includes("@j")));
-			const docComment = includeComments && cleanLines.length > 0 ? `  /**\n${cleanLines.map((line) => `   * ${line}`).join("\n")}\n   */\n` : "";
+			const docComment = includeComments ? makeCommentBlock(cleanLines, 2) : "";
 			const base = `${libraryPrefix}.${field.validation}`;
 			const wrapped = wrapCardinality ? wrapCardinality(base, field.isRequired) : base;
 			return `${docComment}  ${field.fieldName}: ${wrapped}`;
@@ -74,10 +84,22 @@ function groupByModel(validFields) {
 function isFields(modelFields) {
 	return modelFields.flat().filter((field) => field.validation !== null);
 }
-function schemaFromFields(modelFields, comment, schemaBuilder, propertiesGenerator) {
+/**
+* Extract object type (strict/loose) from model documentation.
+*/
+function extractObjectType(documentation, prefix) {
+	if (!documentation) return void 0;
+	const lines = documentation.split("\n").map((l) => l.trim());
+	const prefixWithoutAt = prefix.slice(1);
+	const match = lines.find((line) => line.includes(`${prefixWithoutAt}strictObject`) || line.includes(`${prefixWithoutAt}looseObject`));
+	if (!match) return void 0;
+	if (match.includes("strictObject")) return "strict";
+	if (match.includes("looseObject")) return "loose";
+}
+function schemaFromFields(modelFields, comment, schemaBuilder, propertiesGenerator, objectType) {
 	const modelName = modelFields[0].modelName;
-	return schemaBuilder(modelName, propertiesGenerator(modelFields, comment));
+	return schemaBuilder(modelName, propertiesGenerator(modelFields, comment), objectType);
 }
 
 //#endregion
-export { makePropertiesGenerator as a, parseDocumentWithoutAnnotations as c, mkdir as d, writeFile as f, isFields as i, schemaFromFields as l, getString as n, makeSnakeCase as o, writeFileBinary as p, groupByModel as r, makeValidationExtractor as s, getBool as t, stripAnnotations as u };
+export { isFields as a, makeSnakeCase as c, schemaFromFields as d, stripAnnotations as f, writeFileBinary as h, groupByModel as i, makeValidationExtractor as l, writeFile as m, getBool as n, makeCommentBlock as o, mkdir as p, getString as r, makePropertiesGenerator as s, extractObjectType as t, parseDocumentWithoutAnnotations as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hekireki",
-  "version": "0.7.4",
+  "version": "0.7.6",
   "description": "Hekireki is a tool that generates validation schemas for Zod, Valibot, ArkType, and Effect Schema, as well as ER diagrams and DBML, from Prisma schemas annotated with comments.",
   "keywords": [
     "ajv",