hekireki 0.1.0 → 0.2.1

package/dist/generator/mermaid-er/validator/index.d.ts

@@ -0,0 +1,5 @@
+export { excludeManyToOneRelations } from './exclude-many-to-one-relations.js';
+export { extractRelations } from './extract-relations.js';
+export { isRelationship } from './is-relationship.js';
+export { parseRelation } from './parse-relation.js';
+export { removeDuplicateRelations } from './remove-duplicate-relations.js';

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

@@ -0,0 +1,5 @@
+export { excludeManyToOneRelations } from './exclude-many-to-one-relations.js';
+export { extractRelations } from './extract-relations.js';
+export { isRelationship } from './is-relationship.js';
+export { parseRelation } from './parse-relation.js';
+export { removeDuplicateRelations } from './remove-duplicate-relations.js';

package/dist/generator/mermaid-er/validator/is-relationship.d.ts

@@ -1,4 +1,4 @@
-import type { Relationship } from '../relationship/build-relation-line';
+import type { Relationship } from '../relationship/build-relation-line.js';
 /**
  * isRelationship
  * @param { string } key

package/dist/generator/mermaid-er/validator/is-relationship.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isRelationship = isRelationship;
 /**
  * isRelationship
  * @param { string } key
  * @returns { key is Relationship }
  */
-function isRelationship(key) {
+export function isRelationship(key) {
     return ['zero-one', 'one', 'zero-many', 'many'].includes(key);
 }

package/dist/generator/mermaid-er/validator/parse-relation.d.ts

@@ -1,4 +1,4 @@
-import type { Relation } from '../type';
+import type { Relation } from '../types.js';
 /**
  * parse relation
  * @function parseRelation

package/dist/generator/mermaid-er/validator/parse-relation.js

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseRelation = parseRelation;
 /**
  * parse relation
  * @function parseRelation
  * @param line
  * @returns
  */
-function parseRelation(line) {
+export function parseRelation(line) {
     const relationRegex = /^@relation\s+(\w+)\.(\w+)\s+(\w+)\.(\w+)\s+(\w+-to-\w+)$/;
     const match = line.trim().match(relationRegex);
     if (!match) {

package/dist/generator/mermaid-er/validator/remove-duplicate-relations.js

@@ -1,11 +1,8 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.removeDuplicateRelations = removeDuplicateRelations;
 /**
  * remove duplicate relations
  * @param { readonly string[] } relations
  * @returns { readonly string[] }
  */
-function removeDuplicateRelations(relations) {
+export function removeDuplicateRelations(relations) {
     return [...new Set(relations)];
 }

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

@@ -0,0 +1,5 @@
+export { inferInput } from './infer-input.js';
+export { properties } from './properties.js';
+export { schema } from './schema.js';
+export { schemas } from './schemas.js';
+export { valibot } from './valibot.js';

package/dist/generator/valibot/generator/index.js

@@ -0,0 +1,5 @@
+export { inferInput } from './infer-input.js';
+export { properties } from './properties.js';
+export { schema } from './schema.js';
+export { schemas } from './schemas.js';
+export { valibot } from './valibot.js';

package/dist/generator/valibot/generator/{generate-valibot-infer-input.d.ts → infer-input.d.ts}

@@ -1,8 +1,7 @@
-import type { Config } from '..';
 /**
  * Generate the infer input type for the model
  * @param modelName - The name of the model
  * @param config - The configuration for the generator
  * @returns The generated infer input type
  */
-export declare function generateValibotInferInput(modelName: string, config: Config): string;
+export declare function inferInput(modelName: string): string;

package/dist/generator/valibot/generator/infer-input.js

@@ -0,0 +1,9 @@
+/**
+ * Generate the infer input type for the model
+ * @param modelName - The name of the model
+ * @param config - The configuration for the generator
+ * @returns The generated infer input type
+ */
+export function inferInput(modelName) {
+    return `export type ${modelName} = v.InferInput<typeof ${modelName}Schema>`;
+}

package/dist/generator/valibot/generator/properties.d.ts

@@ -0,0 +1,7 @@
+export declare function properties(modelFields: {
+    documentation: string;
+    modelName: string;
+    fieldName: string;
+    validation: string | null;
+    comment: string[];
+}[], comment: boolean): string;

package/dist/generator/valibot/generator/{generate-valibot-properties.js → properties.js}

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateValibotProperties = generateValibotProperties;
-function generateValibotProperties(modelFields, config) {
+export function properties(modelFields, comment) {
     const fields = modelFields
         .filter((field) => field.validation)
         .map((field) => {
@@ -10,7 +7,7 @@ function generateValibotProperties(modelFields, config) {
             .filter((line) => !(line.includes('@relation') || line.includes('@v') || line.includes('@z')))
             .join('\n')
             .trim();
-        const docComment = config?.comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : '';
+        const docComment = comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : '';
         return `${docComment}  ${field.fieldName}: v.${field.validation}`;
     })
         .join(',\n');

package/dist/generator/valibot/generator/schema.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Generate Valibot schema
+ * @param modelName - The name of the model
+ * @param fields - The fields of the model
+ * @returns The generated Valibot schema
+ */
+export declare function schema(modelName: string, fields: string): string;

package/dist/generator/valibot/generator/schema.js

@@ -0,0 +1,9 @@
+/**
+ * Generate Valibot schema
+ * @param modelName - The name of the model
+ * @param fields - The fields of the model
+ * @returns The generated Valibot schema
+ */
+export function schema(modelName, fields) {
+    return `export const ${modelName}Schema = v.object({\n${fields}\n})`;
+}

package/dist/generator/valibot/generator/{generate-valibot-schemas.d.ts → schemas.d.ts}

@@ -1,15 +1,13 @@
-import type { Config } from '..';
 /**
  * generate valibot schemas
- * @function generateValibotSchemas
  * @param modelFields
  * @param config
  * @returns
  */
-export declare function generateValibotSchemas(modelFields: {
+export declare function schemas(modelFields: {
     documentation: string;
     modelName: string;
     fieldName: string;
     validation: string | null;
     comment: string[];
-}[], config: Config): string;
+}[], comment: boolean): string;

package/dist/generator/valibot/generator/schemas.js

@@ -0,0 +1,17 @@
+import { properties } from './properties.js';
+import { schema } from './schema.js';
+/**
+ * generate valibot schemas
+ * @param modelFields
+ * @param config
+ * @returns
+ */
+export function schemas(modelFields, comment) {
+    const modelName = modelFields[0].modelName;
+    const modelDoc = modelFields[0].documentation || '';
+    const fields = properties(modelFields, comment);
+    if (!(modelDoc || !comment)) {
+        return schema(modelName, fields);
+    }
+    return `${schema(modelName, fields)}`;
+}

package/dist/generator/valibot/generator/valibot.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from '../../mermaid-er/types.js';
+/**
+ * Generate Valibot schemas and types
+ * @param models - The models to generate the Valibot schemas and types for
+ * @param type - Whether to generate types
+ * @param comment - Whether to include comments in the generated code
+ * @returns The generated Valibot schemas and types
+ */
+export declare function valibot(models: readonly Model[], type: boolean, comment: boolean): string;

package/dist/generator/valibot/generator/valibot.js

@@ -0,0 +1,50 @@
+import { isValibot } from '../validator/is-valibot.js';
+import { schemas } from './schemas.js';
+import { groupByModel } from '../../../shared/helper/group-by-model.js';
+import { isFields } from '../../../shared/validator/is-fields.js';
+import { inferInput } from './infer-input.js';
+import { isValibotDocument } from '../validator/is-valibot-document.js';
+const VALIBOT_IMPORT = `import * as v from 'valibot'\n`;
+/**
+ * Generate Valibot schemas and types
+ * @param models - The models to generate the Valibot schemas and types for
+ * @param type - Whether to generate types
+ * @param comment - Whether to include comments in the generated code
+ * @returns The generated Valibot schemas and types
+ */
+export function valibot(models, type, comment) {
+    const modelInfos = models.map((model) => {
+        return {
+            documentation: model.documentation ?? '',
+            name: model.name,
+            fields: model.fields,
+        };
+    });
+    const modelFields = modelInfos.map((model) => {
+        const fields = model.fields.map((field) => ({
+            documentation: model.documentation,
+            modelName: model.name,
+            fieldName: field.name,
+            comment: isValibotDocument(field.documentation),
+            validation: isValibot(field.documentation),
+        }));
+        return fields;
+    });
+    // null exclude
+    const validFields = isFields(modelFields);
+    // group by model
+    const groupedByModel = groupByModel(validFields);
+    const valibots = Object.values(groupedByModel).map((fields) => {
+        return {
+            generateValibotSchema: schemas(fields, comment),
+            generateValibotInfer: type ? inferInput(fields[0].modelName) : '',
+        };
+    });
+    return [
+        VALIBOT_IMPORT,
+        '',
+        valibots
+            .flatMap(({ generateValibotSchema, generateValibotInfer }) => [generateValibotSchema, generateValibotInfer].filter(Boolean))
+            .join('\n\n'),
+    ].join('\n');
+}

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

@@ -1,11 +1,3 @@
 #!/usr/bin/env node
 import type { GeneratorOptions } from '@prisma/generator-helper';
-export type Config = {
-    output?: string;
-    file?: string | string[];
-    schemaName?: 'PascalCase' | 'camelCase' | string | string[];
-    typeName?: 'PascalCase' | 'camelCase' | string | string[];
-    type?: boolean | string | string[];
-    comment?: boolean | string | string[];
-};
 export declare function main(options: GeneratorOptions): Promise<void>;

package/dist/generator/valibot/index.js

@@ -1,49 +1,18 @@
 #!/usr/bin/env node
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.main = main;
-const generator_helper_1 = require("@prisma/generator-helper");
-const generate_valibot_1 = require("./generator/generate-valibot");
-const prettier_1 = require("prettier");
-const node_fs_1 = __importDefault(require("node:fs"));
-const DEFAULT_CONFIG = {
-    output: './valibot',
-    file: 'index.ts',
-    schemaName: 'PascalCase',
-    typeName: 'PascalCase',
-    type: false,
-    comment: false,
-};
-async function main(options) {
-    const config = {
-        output: options.generator.output?.value ?? DEFAULT_CONFIG.output,
-        file: options.generator.config?.file ?? DEFAULT_CONFIG.file,
-        schemaName: options.generator.config?.schemaName ?? DEFAULT_CONFIG.schemaName,
-        typeName: options.generator.config?.typeName ?? DEFAULT_CONFIG.typeName,
-        type: options.generator.config?.type ?? DEFAULT_CONFIG.type,
-        comment: options.generator.config?.comment === 'true',
-    };
-    const content = (0, generate_valibot_1.generateValibot)(options.dmmf.datamodel.models, config);
-    const code = await (0, prettier_1.format)(content, {
-        parser: 'typescript',
-        printWidth: 100,
-        singleQuote: true,
-        semi: false,
-    });
-    if (!config.output) {
-        throw new Error('output is required');
-    }
-    if (!node_fs_1.default.existsSync(config.output)) {
-        node_fs_1.default.mkdirSync(config.output, { recursive: true });
-    }
-    const file = config.file ?? 'index.ts';
-    const filePath = `${config.output}/${file}`;
-    node_fs_1.default.writeFileSync(filePath, code);
+import { valibot } from './generator/valibot.js';
+import fsp from 'node:fs/promises';
+import pkg from '@prisma/generator-helper';
+import { fmt } from '../../shared/format/index.js';
+const { generatorHandler } = pkg;
+export async function main(options) {
+    const output = options.generator.output?.value ?? './valibot';
+    const file = options.generator.config?.file ?? 'index.ts';
+    const content = valibot(options.dmmf.datamodel.models, options.generator.config?.type === 'true', options.generator.config?.comment === 'true');
+    const code = await fmt(content);
+    await fsp.mkdir(output, { recursive: true });
+    await fsp.writeFile(`${output}/${file}`, code, { encoding: 'utf-8' });
 }
-(0, generator_helper_1.generatorHandler)({
+generatorHandler({
     onManifest() {
         return {
             defaultOutput: './valibot/',

package/dist/generator/valibot/validator/index.d.ts

@@ -0,0 +1,2 @@
+export { isValibotDocument } from './is-valibot-document.js';
+export { isValibot } from './is-valibot.js';

package/dist/generator/valibot/validator/index.js

@@ -0,0 +1,2 @@
+export { isValibotDocument } from './is-valibot-document.js';
+export { isValibot } from './is-valibot.js';

package/dist/generator/valibot/validator/is-valibot-document.d.ts

@@ -0,0 +1 @@
+export declare function isValibotDocument(documentation?: string): string[];

package/dist/generator/valibot/validator/{is-valibot-documentation.js → is-valibot-document.js}

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValibotDocumentValidation = isValibotDocumentValidation;
 const VALIDATION_PATTERNS = ['@v.'];
-function isValibotDocumentValidation(documentation) {
+export function isValibotDocument(documentation) {
     if (!documentation)
         return [];
     return documentation

package/dist/generator/valibot/validator/is-valibot.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Check if the documentation is a Valibot validation
+ * @param documentation
+ * @returns string | null
+ */
+export declare function isValibot(documentation?: string): string | null;

package/dist/generator/valibot/validator/{is-valibot-validation.js → is-valibot.js}

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isValibotValidation = isValibotValidation;
 /**
  * Check if the documentation is a Valibot validation
- * @function isValibotValidation
  * @param documentation
  * @returns string | null
  */
-function isValibotValidation(documentation) {
+export function isValibot(documentation) {
     if (!documentation)
         return null;
     const match = documentation.match(/@v\.(.+?)(?:\n|$)/);

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

@@ -0,0 +1,5 @@
+export { infer } from './infer.js';
+export { schemas } from './schemas.js';
+export { properties } from './properties.js';
+export { schema } from './schema.js';
+export { zod } from './zod.js';

package/dist/generator/zod/generator/index.js

@@ -0,0 +1,5 @@
+export { infer } from './infer.js';
+export { schemas } from './schemas.js';
+export { properties } from './properties.js';
+export { schema } from './schema.js';
+export { zod } from './zod.js';

package/dist/generator/zod/generator/{generate-zod-infer.d.ts → infer.d.ts}

@@ -1,8 +1,7 @@
-import type { Config } from '..';
 /**
  * Generate Zod infer
  * @param modelName - The name of the model
  * @param config - The configuration for the generator
  * @returns The generated Zod infer
  */
-export declare function generateZodInfer(modelName: string, config: Config): string;
+export declare function infer(modelName: string): string;

package/dist/generator/zod/generator/infer.js

@@ -0,0 +1,9 @@
+/**
+ * Generate Zod infer
+ * @param modelName - The name of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod infer
+ */
+export function infer(modelName) {
+    return `export type ${modelName} = z.infer<typeof ${modelName}Schema>`;
+}

package/dist/generator/zod/generator/{generate-zod-properties.d.ts → properties.d.ts}

@@ -1,14 +1,13 @@
-import type { Config } from '..';
 /**
  * Generate Zod properties
  * @param modelFields - The fields of the model
  * @param config - The configuration for the generator
  * @returns The generated Zod properties
  */
-export declare function generateZodProperties(modelFields: {
+export declare function properties(modelFields: {
     documentation: string;
     modelName: string;
     fieldName: string;
     validation: string | null;
     comment: string[];
-}[], config?: Config): string;
+}[], comment: boolean): string;

package/dist/generator/zod/generator/{generate-zod-properties.js → properties.js}

@@ -1,13 +1,10 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateZodProperties = generateZodProperties;
 /**
  * Generate Zod properties
  * @param modelFields - The fields of the model
  * @param config - The configuration for the generator
  * @returns The generated Zod properties
  */
-function generateZodProperties(modelFields, config) {
+export function properties(modelFields, comment) {
     const fields = modelFields
         .filter((field) => field.validation)
         .map((field) => {
@@ -16,7 +13,7 @@ function generateZodProperties(modelFields, config) {
             .filter((line) => !(line.includes('@relation') || line.includes('@v') || line.includes('@z')))
             .join('\n')
             .trim();
-        const docComment = config?.comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : '';
+        const docComment = comment && cleanDoc ? `  /**\n   * ${cleanDoc}\n   */\n` : '';
         return `${docComment}  ${field.fieldName}: z.${field.validation}`;
     })
         .join(',\n');

package/dist/generator/zod/generator/{generate-zod-schema.d.ts → schema.d.ts}

@@ -1,4 +1,3 @@
-import type { Config } from '..';
 /**
  * Generate Zod schema
  * @param modelName - The name of the model
@@ -6,4 +5,4 @@ import type { Config } from '..';
  * @param config - The configuration for the generator
  * @returns The generated Zod schema
  */
-export declare function generateZodSchema(modelName: string, fields: string, config: Config): string;
+export declare function schema(modelName: string, fields: string): string;

package/dist/generator/zod/generator/schema.js

@@ -0,0 +1,10 @@
+/**
+ * Generate Zod schema
+ * @param modelName - The name of the model
+ * @param fields - The fields of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod schema
+ */
+export function schema(modelName, fields) {
+    return `export const ${modelName}Schema = z.object({\n${fields}\n})`;
+}

package/dist/generator/zod/generator/{generate-zod-schemas.d.ts → schemas.d.ts}

@@ -1,14 +1,13 @@
-import type { Config } from '..';
 /**
  * Generate Zod schemas
  * @param modelFields - The fields of the model
  * @param config - The configuration for the generator
  * @returns The generated Zod schemas
  */
-export declare function generateZodSchemas(modelFields: {
+export declare function schemas(modelFields: {
     documentation: string;
     modelName: string;
     fieldName: string;
     validation: string | null;
     comment: string[];
-}[], config: Config): string;
+}[], comment: boolean): string;

package/dist/generator/zod/generator/schemas.js

@@ -0,0 +1,16 @@
+import { properties, schema } from './index.js';
+/**
+ * Generate Zod schemas
+ * @param modelFields - The fields of the model
+ * @param config - The configuration for the generator
+ * @returns The generated Zod schemas
+ */
+export function schemas(modelFields, comment) {
+    const modelName = modelFields[0].modelName;
+    const modelDoc = modelFields[0].documentation || '';
+    const fields = properties(modelFields, comment);
+    if (!(modelDoc || !comment)) {
+        return schema(modelName, fields);
+    }
+    return `${schema(modelName, fields)}`;
+}

package/dist/generator/zod/generator/zod.d.ts

@@ -0,0 +1,9 @@
+import type { Model } from '../../../shared/types.js';
+/**
+ * Generate Zod schemas and types
+ * @param models - The models to generate the Zod schemas and types for
+ * @param type - Whether to generate types
+ * @param comment - Whether to include comments in the generated code
+ * @returns The generated Zod schemas and types
+ */
+export declare function zod(models: readonly Model[], type: boolean, comment: boolean, zodVersion?: string | string[]): string;

package/dist/generator/zod/generator/zod.js

@@ -0,0 +1,55 @@
+import { isZod, isZodDocument } from '../validator/index.js';
+import { isFields } from '../../../shared/validator/is-fields.js';
+import { groupByModel } from '../../../shared/helper/group-by-model.js';
+import { infer, schemas } from './index.js';
+const ZODV4_IMPORT = `import { z } from 'zod/v4'\n`;
+const ZODV4_MINI_IMPORT = `import { z } from 'zod/v4-mini'\n`;
+const ZOD_OPENAPI_HONO_IMPORT = `import { z } from '@hono/zod-openapi'\n`;
+/**
+ * Generate Zod schemas and types
+ * @param models - The models to generate the Zod schemas and types for
+ * @param type - Whether to generate types
+ * @param comment - Whether to include comments in the generated code
+ * @returns The generated Zod schemas and types
+ */
+export function zod(models, type, comment, zodVersion) {
+    const modelInfos = models.map((model) => {
+        return {
+            documentation: model.documentation ?? '',
+            name: model.name,
+            fields: model.fields,
+        };
+    });
+    const modelFields = modelInfos.map((model) => {
+        const fields = model.fields.map((field) => ({
+            documentation: model.documentation,
+            modelName: model.name,
+            fieldName: field.name,
+            comment: isZodDocument(field.documentation),
+            validation: isZod(field.documentation),
+        }));
+        return fields;
+    });
+    // null exclude
+    const validFields = isFields(modelFields);
+    // group by model
+    const groupedByModel = groupByModel(validFields);
+    const zods = Object.values(groupedByModel).map((fields) => {
+        return {
+            generateZodSchema: schemas(fields, comment),
+            generateZodInfer: type ? infer(fields[0].modelName) : '',
+        };
+    });
+    const importStatement = zodVersion === 'v4-mini'
+        ? ZODV4_MINI_IMPORT
+        : zodVersion === '@hono/zod-openapi'
+            ? ZOD_OPENAPI_HONO_IMPORT
+            : ZODV4_IMPORT;
+    return [
+        importStatement,
+        '',
+        zods
+            .flatMap(({ generateZodSchema, generateZodInfer }) => [generateZodSchema, generateZodInfer].filter(Boolean))
+            .join('\n\n'),
+    ].join('\n');
+}

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

@@ -1,11 +1,3 @@
 #!/usr/bin/env node
 import type { GeneratorOptions } from '@prisma/generator-helper';
-export type Config = {
-    output?: string;
-    file?: string | string[];
-    schemaName?: 'PascalCase' | 'camelCase' | string | string[];
-    typeName?: 'PascalCase' | 'camelCase' | string | string[];
-    type?: boolean | string | string[];
-    comment?: boolean | string | string[];
-};
 export declare function main(options: GeneratorOptions): Promise<void>;