hekireki 0.7.3 → 0.7.5

package/README.md

@@ -257,7 +257,7 @@ export const UserSchema = v.object({
   name: v.pipe(v.string(), v.minLength(1), v.maxLength(50)),
 })
 
-export type User = v.InferInput<typeof UserSchema>
+export type User = v.InferOutput<typeof UserSchema>
 
 export const PostSchema = v.object({
   /**
@@ -278,21 +278,21 @@ export const PostSchema = v.object({
   userId: v.pipe(v.string(), v.uuid()),
 })
 
-export type Post = v.InferInput<typeof PostSchema>
+export type Post = v.InferOutput<typeof PostSchema>
 
 export const UserRelationsSchema = v.object({
   ...UserSchema.entries,
   posts: v.array(PostSchema),
 })
 
-export type UserRelations = v.InferInput<typeof UserRelationsSchema>
+export type UserRelations = v.InferOutput<typeof UserRelationsSchema>
 
 export const PostRelationsSchema = v.object({
   ...PostSchema.entries,
   user: UserSchema,
 })
 
-export type PostRelations = v.InferInput<typeof PostRelationsSchema>
+export type PostRelations = v.InferOutput<typeof PostRelationsSchema>
 ```
 
 ### ArkType
@@ -301,22 +301,34 @@ export type PostRelations = v.InferInput<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',
 })
 
@@ -329,26 +341,38 @@ export type Post = typeof PostSchema.infer
 import { Schema } from 'effect'
 
 export const UserSchema = Schema.Struct({
-  /** Primary key */
+  /**
+   * Primary key
+   */
   id: Schema.UUID,
-  /** Display name */
+  /**
+   * Display name
+   */
   name: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(50)),
 })
 
-export type User = Schema.Schema.Type<typeof UserSchema>
+export type UserEncoded = typeof UserSchema.Encoded
 
 export const PostSchema = Schema.Struct({
-  /** Primary key */
+  /**
+   * Primary key
+   */
   id: Schema.UUID,
-  /** Article title */
+  /**
+   * Article title
+   */
   title: Schema.String.pipe(Schema.minLength(1), Schema.maxLength(100)),
-  /** Body content (no length limit) */
+  /**
+   * Body content (no length limit)
+   */
   content: Schema.String,
-  /** Foreign key referencing User.id */
+  /**
+   * Foreign key referencing User.id
+   */
   userId: Schema.UUID,
 })
 
-export type Post = Schema.Schema.Type<typeof PostSchema>
+export type PostEncoded = typeof PostSchema.Encoded
 ```
 
 ### TypeBox
@@ -357,22 +381,34 @@ export type Post = Schema.Schema.Type<typeof PostSchema>
 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' }),
 })
 
@@ -393,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'
@@ -401,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,
@@ -415,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/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 { a as makeCommentBlock, c as makeValidationExtractor, f as mkdir, l as parseDocumentWithoutAnnotations, p as writeFile, t as getBool } from "../../utils-BGe939v0.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-CfcdmYJs.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 }"
 };
+/**
+* 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) {
 	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`;
 }
+/**
+* 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 { a as makeCommentBlock, c as makeValidationExtractor, f as mkdir, l as parseDocumentWithoutAnnotations, p as writeFile, t as getBool, u as schemaFromFields } from "../../utils-BGe939v0.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-CfcdmYJs.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`;
 }
+/**
+* Generate ArkType type() schema definition
+* @param modelName - The model name for the schema
+* @param fields - The formatted field definitions string
+*/
 function makeArktypeSchema(modelName, fields) {
 	return `export const ${modelName}Schema = type({\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\""
 };
+/**
+* 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) {
 	return schemaFromFields(modelFields, comment, makeArktypeSchema, makeArktypeProperties);
 }
+/**
+* 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 { d as stripAnnotations, f as mkdir, m as writeFileBinary, n as getString, p as writeFile } from "../../utils-BGe939v0.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 { f as mkdir, p as writeFile, s as makeSnakeCase } from "../../utils-BGe939v0.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 { f as mkdir, p as writeFile, s as makeSnakeCase } from "../../utils-BGe939v0.js";
 import { join } from "node:path";
 import pkg from "@prisma/generator-helper";
 

package/dist/generator/effect/index.js

@@ -1,20 +1,20 @@
 #!/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 { a as makeCommentBlock, c as makeValidationExtractor, f as mkdir, l as parseDocumentWithoutAnnotations, p as writeFile, t as getBool, u as schemaFromFields } from "../../utils-BGe939v0.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-CfcdmYJs.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/effect.ts
 function makeEffectInfer(modelName) {
-	return `export type ${modelName} = Schema.Schema.Type<typeof ${modelName}Schema>`;
+	return `export type ${modelName}Encoded = typeof ${modelName}Schema.Encoded`;
 }
 function makeEffectSchema(modelName, fields) {
 	return `export const ${modelName}Schema = Schema.Struct({\n${fields}\n})`;
 }
 function makeEffectProperties(fields, comment) {
 	return fields.map((field) => {
-		return `${comment && field.comment.length > 0 ? `${field.comment.map((c) => `  /** ${c} */`).join("\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) {
@@ -37,7 +37,7 @@ function makeEffectSchemas(modelFields, comment) {
 function makeEffectRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const fields = `${`...${model.name}Schema.fields,`}${relProps.map((r) => `${r.key}:${r.isMany ? `Schema.Array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("")}`;
-	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = Schema.Schema.Type<typeof ${model.name}RelationsSchema>` : "";
+	const typeLine = options?.includeType ? `\n\nexport type ${model.name}RelationsEncoded = typeof ${model.name}RelationsSchema.Encoded` : "";
 	return `export const ${model.name}RelationsSchema = Schema.Struct({${fields}})${typeLine}`;
 }
 function effect(models, type, comment, enums) {

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 { f as mkdir, n as getString, p as writeFile, s as makeSnakeCase } from "../../utils-BGe939v0.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 { d as stripAnnotations, f as mkdir, p as writeFile } from "../../utils-BGe939v0.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 { f as mkdir, n as getString, p as writeFile, s as makeSnakeCase } from "../../utils-BGe939v0.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 { f as mkdir, p as writeFile, s as makeSnakeCase } from "../../utils-BGe939v0.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,47 @@
 #!/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 { a as makeCommentBlock, c as makeValidationExtractor, f as mkdir, l as parseDocumentWithoutAnnotations, p as writeFile, t as getBool, u as schemaFromFields } from "../../utils-BGe939v0.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-CfcdmYJs.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>`;
 }
+/**
+* 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) {
 	return `export const ${modelName}Schema = Type.Object({\n${fields}\n})`;
 }
+/**
+* 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 +53,20 @@ const PRISMA_TO_TYPEBOX = {
 	Json: "Type.Unknown()",
 	Bytes: "Type.Any()"
 };
+/**
+* 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) {
 	return schemaFromFields(modelFields, comment, makeTypeBoxSchema, makeTypeBoxProperties);
 }
+/**
+* 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 +74,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 +98,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,13 +1,13 @@
 #!/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 { c as makeValidationExtractor, f as mkdir, l as parseDocumentWithoutAnnotations, o as makePropertiesGenerator, p as writeFile, t as getBool, u as schemaFromFields } from "../../utils-BGe939v0.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-CfcdmYJs.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 
 //#region src/helper/valibot.ts
 function makeValibotInfer(modelName) {
-	return `export type ${modelName} = v.InferInput<typeof ${modelName}Schema>`;
+	return `export type ${modelName} = v.InferOutput<typeof ${modelName}Schema>`;
 }
 function makeValibotSchema(modelName, fields) {
 	return `export const ${modelName}Schema = v.object({\n${fields}\n})`;
@@ -33,7 +33,7 @@ function makeValibotRelations(model, relProps, options) {
 	if (relProps.length === 0) return null;
 	const base = `  ...${model.name}Schema.entries,`;
 	const rels = relProps.map((r) => `  ${r.key}: ${r.isMany ? `v.array(${r.targetModel}Schema)` : `${r.targetModel}Schema`},`).join("\n");
-	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = v.InferInput<typeof ${model.name}RelationsSchema>` : "";
+	const typeLine = options?.includeType ? `\n\nexport type ${model.name}Relations = v.InferOutput<typeof ${model.name}RelationsSchema>` : "";
 	return `export const ${model.name}RelationsSchema = v.object({\n${base}\n${rels}\n})${typeLine}`;
 }
 function valibot(models, type, comment, enums) {

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 { c as makeValidationExtractor, f as mkdir, l as parseDocumentWithoutAnnotations, n as getString, o as makePropertiesGenerator, p as writeFile, t as getBool, u as schemaFromFields } from "../../utils-BGe939v0.js";
+import { n as validationSchemas, t as makeRelationsOnly } from "../../prisma-CfcdmYJs.js";
 import path from "node:path";
 import pkg from "@prisma/generator-helper";
 

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

@@ -1,4 +1,4 @@
-import { i as isFields, r as groupByModel } from "./utils-0tE5jzYR.js";
+import { i as isFields, r as groupByModel } from "./utils-BGe939v0.js";
 
 //#region src/helper/prisma.ts
 function collectRelationProps(models) {

package/dist/{utils-0tE5jzYR.js → utils-BGe939v0.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}`;
@@ -80,4 +90,4 @@ function schemaFromFields(modelFields, comment, schemaBuilder, propertiesGenerat
 }
 
 //#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 { makeCommentBlock as a, makeValidationExtractor as c, stripAnnotations as d, mkdir as f, isFields as i, parseDocumentWithoutAnnotations as l, writeFileBinary as m, getString as n, makePropertiesGenerator as o, writeFile as p, groupByModel as r, makeSnakeCase as s, getBool as t, schemaFromFields as u };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hekireki",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "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",