sizuku 0.0.7 → 0.2.0

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

@@ -0,0 +1,17 @@
+/**
+ * Generates Zod code for a given schema and config.
+ *
+ * @function generateZodCode
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod code.
+ */
+export declare function zodCode(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, comment: boolean, type: boolean): string;

package/dist/generator/zod/generator/zod-code.js

@@ -0,0 +1,18 @@
+import { infer } from '../../../utils/index.js';
+import { zod } from './zod.js';
+/**
+ * Generates Zod code for a given schema and config.
+ *
+ * @function generateZodCode
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod code.
+ */
+export function zodCode(schema, comment, type) {
+    const zodSchema = zod(schema, comment);
+    if (type) {
+        const zInfer = infer(schema.name);
+        return `${zodSchema}\n\n${zInfer}\n`;
+    }
+    return `${zodSchema}\n`;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Generates a Zod schema for a given schema and config.
+ *
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod schema.
+ */
+export declare function zod(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, comment: boolean): string;

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

@@ -0,0 +1,16 @@
+import { capitalize, fieldDefinitions } from '../../../utils/index.js';
+/**
+ * Generates a Zod schema for a given schema and config.
+ *
+ * @param schema - The schema to generate code for.
+ * @param config - The configuration for the code generation.
+ * @returns The generated Zod schema.
+ */
+export function zod(schema, comment) {
+    const objectType = schema.objectType === 'strict'
+        ? 'strictObject'
+        : schema.objectType === 'loose'
+            ? 'looseObject'
+            : 'object';
+    return `export const ${capitalize(schema.name)}Schema = z.${objectType}({${fieldDefinitions(schema, comment)}})`;
+}

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

@@ -0,0 +1,3 @@
+import { Result } from 'neverthrow';
+import type { ParsedSchema } from '../../shared/utils/types.js';
+export declare const generateZodSchemas: (schema: ParsedSchema) => Result<string, Error>;

package/dist/generator/zod/generator.js

@@ -0,0 +1,14 @@
+import { Result, err, ok } from 'neverthrow';
+import { generateZodFile } from './core.js';
+export const generateZodSchemas = (schema) => {
+    try {
+        if (schema.tables.length === 0) {
+            return err(new Error('No tables found in schema'));
+        }
+        const zodContent = generateZodFile(schema.tables);
+        return ok(zodContent);
+    }
+    catch (error) {
+        return err(new Error(`Failed to generate Zod schemas: ${error instanceof Error ? error.message : String(error)}`));
+    }
+};

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

@@ -1,3 +1,15 @@
-#!/usr/bin/env node
-import type { Config } from '../../common/config';
-export declare function main(dev?: boolean, config?: Config): Promise<boolean>;
+/**
+ * Generate Zod schema
+ * @param code - The code to generate Zod schema from
+ * @param output - The output file path
+ * @param comment - Whether to include comments in the generated code
+ * @param type - Whether to include type information in the generated code
+ * @param zod - The Zod version to use
+ */
+export declare function sizukuZod(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, zod?: 'v4' | 'mini' | '@hono/zod-openapi', relations?: boolean): Promise<{
+    ok: true;
+    value: undefined;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/generator/zod/index.js

@@ -1,77 +1,54 @@
-#!/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 node_fs_1 = require("node:fs");
-const node_path_1 = __importDefault(require("node:path"));
-const extract_schema_1 = require("./core/extract-schema");
-const generate_zod_code_1 = require("./generator/generate-zod-code");
-const format_1 = require("../../common/format");
-const config_1 = require("./config");
-const node_process_1 = require("node:process");
-const IMPORT_ZOD = 'import { z } from "zod"';
-async function main(dev = false, config = (0, config_1.getConfig)()) {
-    // 1. argv ['**/bin/node', ''/workspaces/sizuku-test/packages/sizuku/dist/generator/zod/index.js',', 'db/schema.ts', '-o', 'zod/index.ts']
-    if (config.output === undefined && !node_process_1.argv.includes('-o')) {
-        console.error('Error: -o is not found');
-        return false;
+import path from 'node:path';
+import { fmt } from '../../shared/format/index.js';
+import { mkdir, writeFile } from '../../shared/fsp/index.js';
+import { extractRelationSchemas, extractSchemas } from '../../shared/helper/extract-schemas.js';
+import { relationZodCode } from './generator/relation-zod-code.js';
+import { zodCode } from './generator/zod-code.js';
+/**
+ * Generate Zod schema
+ * @param code - The code to generate Zod schema from
+ * @param output - The output file path
+ * @param comment - Whether to include comments in the generated code
+ * @param type - Whether to include type information in the generated code
+ * @param zod - The Zod version to use
+ */
+export async function sizukuZod(code, output, comment, type, zod, relations) {
+    const importLine = zod === 'mini'
+        ? `import * as z from 'zod/mini'`
+        : zod === '@hono/zod-openapi'
+            ? `import { z } from '@hono/zod-openapi'`
+            : `import * as z from 'zod'`;
+    const baseSchemas = extractSchemas(code, 'zod');
+    const relationSchemas = extractRelationSchemas(code, 'zod');
+    const zodGeneratedCode = [
+        importLine,
+        '',
+        ...baseSchemas.map((schema) => zodCode(schema, comment ?? false, type ?? false)),
+        ...(relations ? relationSchemas.map((schema) => relationZodCode(schema, type ?? false)) : []),
+    ].join('\n');
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return {
+            ok: false,
+            error: mkdirResult.error,
+        };
     }
-    // 2. slice ['db/schema.ts', '-o', 'zod/index.ts']
-    const args = process.argv.slice(2);
-    // 3. input = args[0] = 'db/schema.ts'
-    const input = config.input ?? args[0];
-    config.input = input;
-    // 4. output = 'zod/index.ts'
-    const output = config.output ?? args[args.indexOf('-o') + 1];
-    config.output = output;
-    try {
-        // 5. read db/schema.ts
-        const content = (0, node_fs_1.readFileSync)(input, 'utf-8');
-        // 6. split lines
-        const lines = content.split('\n');
-        // 7. create output directory
-        const outputDir = node_path_1.default.dirname(output);
-        if (!(0, node_fs_1.existsSync)(outputDir)) {
-            (0, node_fs_1.mkdirSync)(outputDir, { recursive: true });
-        }
-        // 8. skip import section
-        const codeStart = lines.findIndex((line) => !line.trim().startsWith('import') && line.trim() !== '');
-        // 9. extract schemas
-        const schemas = (0, extract_schema_1.extractSchemas)(lines.slice(codeStart));
-        // 10. generate zod code
-        const generatedCode = [
-            IMPORT_ZOD,
-            '',
-            ...schemas.map((schema) => (0, generate_zod_code_1.generateZodCode)(schema, config)),
-        ].join('\n');
-        // 11. format code
-        const code = await (0, format_1.formatCode)(generatedCode);
-        // 12. write to output file
-        (0, node_fs_1.writeFileSync)(output, code);
-        console.log(`Generated Zod schema at: ${output}`);
-        return true;
+    const fmtResult = await fmt(zodGeneratedCode);
+    if (!fmtResult.ok) {
+        return {
+            ok: false,
+            error: fmtResult.error,
+        };
     }
-    catch (e) {
-        if (e instanceof Error) {
-            console.error(e.message);
-            if (dev) {
-                throw e;
-            }
-            process.exit(1);
-        }
-        if (dev) {
-            throw new Error('Unknown error occurred');
-        }
-        return false;
+    const writeFileResult = await writeFile(output, fmtResult.value);
+    if (!writeFileResult.ok) {
+        return {
+            ok: false,
+            error: writeFileResult.error,
+        };
     }
-}
-if (require.main === module) {
-    main().then((success) => {
-        if (!success) {
-            process.exit(1);
-        }
-    });
+    return {
+        ok: true,
+        value: undefined,
+    };
 }

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type { Config } from './config/index.js';
+export declare function main(config?: Config): Promise<{
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/index.js

@@ -0,0 +1,71 @@
+// #!/usr/bin/env node
+import { getConfig } from './config/index.js';
+import { sizukuMermaidER } from './generator/mermaid-er/index.js';
+import { sizukuValibot } from './generator/valibot/index.js';
+import { sizukuZod } from './generator/zod/index.js';
+import { readFileSync } from './shared/fs/index.js';
+export async function main(config = getConfig()) {
+    if (!config.input) {
+        return {
+            ok: false,
+            error: 'input is not found',
+        };
+    }
+    const contentResult = readFileSync(config.input);
+    if (!contentResult.ok) {
+        return {
+            ok: false,
+            error: contentResult.error,
+        };
+    }
+    const content = contentResult.value;
+    const lines = content.split('\n');
+    const codeStart = lines.findIndex((line) => !line.trim().startsWith('import') && line.trim() !== '');
+    const code = lines.slice(codeStart);
+    const results = [];
+    /* zod */
+    if (config.zod?.output) {
+        const zodResult = await sizukuZod(code, config.zod.output, config.zod.comment, config.zod.type, config.zod.zod, true);
+        if (!zodResult.ok) {
+            return {
+                ok: false,
+                error: zodResult.error,
+            };
+        }
+        results.push(`Generated Zod schema at: ${config.zod?.output}`);
+    }
+    /* valibot */
+    if (config.valibot?.output) {
+        const valibotResult = await sizukuValibot(code, config.valibot.output, config.valibot.comment, config.valibot.type, true);
+        if (!valibotResult.ok) {
+            return {
+                ok: false,
+                error: valibotResult.error,
+            };
+        }
+        results.push(`Generated Valibot schema at: ${config.valibot?.output}`);
+    }
+    /* mermaid */
+    if (config.mermaid?.output) {
+        const mermaidResult = await sizukuMermaidER(code, config.mermaid.output);
+        if (!mermaidResult.ok) {
+            return {
+                ok: false,
+                error: mermaidResult.error,
+            };
+        }
+        results.push(`Generated Mermaid ER at: ${config.mermaid?.output}`);
+    }
+    return {
+        ok: true,
+        value: results.join('\n'),
+    };
+}
+main().then((result) => {
+    if (result?.ok) {
+        console.log(result.value);
+    }
+    else {
+        console.error(result?.error);
+    }
+});

package/dist/shared/config/index.d.ts

@@ -0,0 +1,13 @@
+export type Config = {
+  schema: {
+    name: 'PascalCase' | 'camelCase'
+  }
+  type: {
+    name: 'PascalCase' | 'camelCase'
+    export: boolean
+  }
+  input?: string
+  output?: string
+  comment?: boolean
+}
+export declare const DEFAULT_CONFIG: Config

package/dist/{common → shared}/config/index.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_CONFIG = void 0;
-exports.DEFAULT_CONFIG = {
+export const DEFAULT_CONFIG = {
     schema: {
         name: 'PascalCase',
     },

package/dist/shared/format/index.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Formats TypeScript source with Prettier.
+ *
+ * @param code - Source code to format.
+ * @returns A `Result` containing the formatted code or an error message.
+ */
+export declare function fmt(code: string): Promise<{
+    ok: true;
+    value: string;
+    error?: undefined;
+} | {
+    ok: false;
+    error: string;
+    value?: undefined;
+}>;

package/dist/shared/format/index.js

@@ -0,0 +1,24 @@
+import { format } from 'prettier';
+/**
+ * Formats TypeScript source with Prettier.
+ *
+ * @param code - Source code to format.
+ * @returns A `Result` containing the formatted code or an error message.
+ */
+export async function fmt(code) {
+    try {
+        const formatted = await format(code, {
+            parser: 'typescript',
+            printWidth: 100,
+            singleQuote: true,
+            semi: false,
+        });
+        return { ok: true, value: formatted };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}

package/dist/shared/fs/index.d.ts

@@ -0,0 +1,7 @@
+export declare function readFileSync(path: string): {
+    ok: true;
+    value: string;
+} | {
+    ok: false;
+    error: string;
+};

package/dist/shared/fs/index.js

@@ -0,0 +1,16 @@
+import fs from 'node:fs';
+export function readFileSync(path) {
+    try {
+        const result = fs.readFileSync(path, 'utf-8');
+        return {
+            ok: true,
+            value: result,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}

package/dist/shared/fsp/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Creates a directory if it does not already exist.
+ *
+ * @param dir - Directory path to create.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
+ */
+export declare function mkdir(dir: string): Promise<{
+    ok: false;
+    error: string;
+} | {
+    ok: true;
+    value: undefined;
+}>;
+/**
+ * Writes UTF-8 text to a file, creating it if necessary.
+ *
+ * @param path - File path to write.
+ * @param data - Text data to write.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
+ */
+export declare function writeFile(path: string, data: string): Promise<{
+    ok: true;
+    value: undefined;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/shared/fsp/index.js

@@ -0,0 +1,38 @@
+import fsp from 'node:fs/promises';
+/**
+ * Creates a directory if it does not already exist.
+ *
+ * @param dir - Directory path to create.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
+ */
+export async function mkdir(dir) {
+    try {
+        await fsp.mkdir(dir, { recursive: true });
+        return {
+            ok: true,
+            value: undefined,
+        };
+    }
+    catch (e) {
+        return {
+            ok: false,
+            error: e instanceof Error ? e.message : String(e),
+        };
+    }
+}
+/**
+ * Writes UTF-8 text to a file, creating it if necessary.
+ *
+ * @param path - File path to write.
+ * @param data - Text data to write.
+ * @returns A `Result` that is `ok` on success, otherwise an error message.
+ */
+export async function writeFile(path, data) {
+    try {
+        await fsp.writeFile(path, data, 'utf-8');
+        return { ok: true, value: undefined };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}

package/dist/shared/generator/field-definitions.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @param schema
+ * @returns
+ */
+export declare function fieldDefinitions(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+}, comment: boolean): string;

package/dist/shared/generator/field-definitions.js

@@ -0,0 +1,12 @@
+/**
+ * @param schema
+ * @returns
+ */
+export function fieldDefinitions(schema, comment) {
+    return schema.fields
+        .map(({ name, definition, description }) => {
+        const commentCode = description && comment ? `/**\n* ${description}\n*/\n` : '';
+        return `${commentCode}${name}:${definition}`;
+    })
+        .join(',\n');
+}

package/dist/shared/helper/ast-parser.d.ts

@@ -0,0 +1,3 @@
+import { Result } from 'neverthrow';
+import type { ParsedSchema } from '../utils/types.js';
+export declare const parseSchemaFile: (filePath: string) => Result<ParsedSchema, Error>;