sizuku 0.1.0 → 0.2.0

package/dist/generator/valibot/core.js

@@ -0,0 +1,39 @@
+// 完全純粋なValibotスキーマ生成ユーティリティ - 外部import禁止
+import { toPascalCase } from '../../shared/utils/string-utils.js';
+export const generateValibotSchema = (table) => {
+    const schemaName = `${toPascalCase(table.name)}Schema`;
+    const typeName = toPascalCase(table.name);
+    const properties = table.columns.map(column => generateValibotProperty(column)).join('\n  ');
+    return `export const ${schemaName} = v.object({
+  ${properties}
+})
+export type ${typeName} = v.InferInput<typeof ${schemaName}>`;
+};
+export const generateValibotProperty = (column) => {
+    const comment = column.comment ? `/** ${column.comment} */\n  ` : '';
+    const schema = column.valibotSchema || generateDefaultValibotSchema(column);
+    return `${comment}${column.name}: ${schema},`;
+};
+export const generateDefaultValibotSchema = (column) => {
+    if (column.type === 'varchar') {
+        if (column.length === 36) {
+            return 'v.pipe(v.string(), v.uuid())';
+        }
+        if (column.length) {
+            return `v.pipe(v.string(), v.maxLength(${column.length}))`;
+        }
+        return 'v.string()';
+    }
+    if (column.type === 'int') {
+        return 'v.pipe(v.number(), v.integer())';
+    }
+    if (column.type === 'text') {
+        return 'v.string()';
+    }
+    return 'v.unknown()';
+};
+export const generateValibotFile = (tables) => {
+    const imports = 'import * as v from \'valibot\'\n\n';
+    const schemas = tables.map(table => generateValibotSchema(table)).join('\n\n');
+    return imports + schemas;
+};

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

@@ -1,4 +1,4 @@
-import { capitalize } from '../../../shared/utils/capitalize.js';
+import { capitalize } from '../../../shared/utils/index.js';
 /**
  * @param name
  * @returns

package/dist/generator/valibot/generator/relation-valibot-code.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Generates Valibot relation schema code from a relation schema AST extraction.
+ */
+export declare function relationValibotCode(schema: {
+    name: string;
+    baseName: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, withType: boolean): string;

package/dist/generator/valibot/generator/relation-valibot-code.js

@@ -0,0 +1,19 @@
+import { capitalize, inferInput } from '../../../utils/index.js';
+/**
+ * Generates Valibot relation schema code from a relation schema AST extraction.
+ */
+export function relationValibotCode(schema, withType) {
+    const base = schema.baseName;
+    const relName = `${schema.name}Schema`;
+    const baseSchema = `${capitalize(base)}Schema`;
+    const fields = schema.fields.map((f) => `${f.name}:${f.definition}`).join(',');
+    const objectType = schema.objectType === 'strict'
+        ? 'strictObject'
+        : schema.objectType === 'loose'
+            ? 'looseObject'
+            : 'object';
+    const obj = `\nexport const ${capitalize(relName)} = v.${objectType}({...${baseSchema}.entries,${fields}})`;
+    if (withType)
+        return `${obj}\n\n${inferInput(schema.name)}\n`;
+    return `${obj}`;
+}

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

@@ -1,8 +1,15 @@
-import type { Schema } from '../../../shared/types.js';
 /**
  * @param schema
  * @param comment
  * @param type
  * @returns
  */
-export declare function valibotCode(schema: Schema, comment: boolean, type: boolean): string;
+export declare function valibotCode(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, comment: boolean, type: boolean): string;

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

@@ -1,5 +1,5 @@
+import { inferInput } from '../../../utils/index.js';
 import { valibot } from './valibot.js';
-import { inferInput } from './infer-input.js';
 /**
  * @param schema
  * @param comment

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

@@ -1,7 +1,14 @@
-import type { Schema } from '../../../shared/types.js';
 /**
  * @param schema
  * @param config
  * @returns
  */
-export declare function valibot(schema: Schema, comment: boolean): string;
+export declare function valibot(schema: {
+    name: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, comment: boolean): string;

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

@@ -1,5 +1,4 @@
-import { capitalize } from '../../../shared/utils/capitalize.js';
-import { fieldDefinitions } from '../../../shared/generator/field-definitions.js';
+import { capitalize, fieldDefinitions } from '../../../utils/index.js';
 /**
  * @param schema
  * @param config
@@ -7,5 +6,10 @@ import { fieldDefinitions } from '../../../shared/generator/field-definitions.js
  */
 export function valibot(schema, comment) {
     const res = fieldDefinitions(schema, comment);
-    return `export const ${capitalize(schema.name)}Schema = v.object({${res}})`;
+    const objectType = schema.objectType === 'strict'
+        ? 'strictObject'
+        : schema.objectType === 'loose'
+            ? 'looseObject'
+            : 'object';
+    return `export const ${capitalize(schema.name)}Schema = v.${objectType}({${res}})`;
 }

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

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

package/dist/generator/valibot/generator.js

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

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

@@ -1,4 +1,3 @@
-import type { Result } from 'neverthrow';
 /**
  * Generate Valibot schema
  * @param code - The code to generate Valibot schema from
@@ -6,4 +5,10 @@ import type { Result } from 'neverthrow';
  * @param comment - Whether to include comments in the generated code
  * @param type - Whether to include type information in the generated code
  */
-export declare function sizukuValibot(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean): Promise<Result<void, Error>>;
+export declare function sizukuValibot(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, relations?: boolean): Promise<{
+    ok: true;
+    value: undefined;
+} | {
+    ok: false;
+    error: string;
+}>;

package/dist/generator/valibot/index.js

@@ -1,8 +1,9 @@
 import path from 'node:path';
-import { extractSchemas } from './core/extract-schema.js';
-import { valibotCode } from './generator/valibot-code.js';
 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 { relationValibotCode } from './generator/relation-valibot-code.js';
+import { valibotCode } from './generator/valibot-code.js';
 /**
  * Generate Valibot schema
  * @param code - The code to generate Valibot schema from
@@ -10,13 +11,40 @@ import { mkdir, writeFile } from '../../shared/fsp/index.js';
  * @param comment - Whether to include comments in the generated code
  * @param type - Whether to include type information in the generated code
  */
-export async function sizukuValibot(code, output, comment, type) {
+export async function sizukuValibot(code, output, comment, type, relations) {
+    const baseSchemas = extractSchemas(code, 'valibot');
+    const relationSchemas = extractRelationSchemas(code, 'valibot');
     const valibotGeneratedCode = [
-        'import * as v from "valibot"',
+        "import * as v from 'valibot'",
         '',
-        ...extractSchemas(code).map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
+        ...baseSchemas.map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
+        ...(relations
+            ? relationSchemas.map((schema) => relationValibotCode(schema, type ?? false))
+            : []),
     ].join('\n');
-    return await mkdir(path.dirname(output))
-        .andThen(() => fmt(valibotGeneratedCode))
-        .andThen((formatted) => writeFile(output, formatted));
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return {
+            ok: false,
+            error: mkdirResult.error,
+        };
+    }
+    const fmtResult = await fmt(valibotGeneratedCode);
+    if (!fmtResult.ok) {
+        return {
+            ok: false,
+            error: fmtResult.error,
+        };
+    }
+    const writeFileResult = await writeFile(output, fmtResult.value);
+    if (!writeFileResult.ok) {
+        return {
+            ok: false,
+            error: writeFileResult.error,
+        };
+    }
+    return {
+        ok: true,
+        value: undefined,
+    };
 }

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

@@ -0,0 +1,5 @@
+import type { TableInfo, ColumnInfo } from '../../shared/utils/types.js';
+export declare const generateZodSchema: (table: TableInfo) => string;
+export declare const generateZodProperty: (column: ColumnInfo) => string;
+export declare const generateDefaultZodSchema: (column: ColumnInfo) => string;
+export declare const generateZodFile: (tables: TableInfo[]) => string;

package/dist/generator/zod/core.js

@@ -0,0 +1,39 @@
+// 完全純粋なZodスキーマ生成ユーティリティ - 外部import禁止
+import { toPascalCase } from '../../shared/utils/string-utils.js';
+export const generateZodSchema = (table) => {
+    const schemaName = `${toPascalCase(table.name)}Schema`;
+    const typeName = toPascalCase(table.name);
+    const properties = table.columns.map(column => generateZodProperty(column)).join('\n  ');
+    return `export const ${schemaName} = z.object({
+  ${properties}
+})
+export type ${typeName} = z.infer<typeof ${schemaName}>`;
+};
+export const generateZodProperty = (column) => {
+    const comment = column.comment ? `/** ${column.comment} */\n  ` : '';
+    const schema = column.zodSchema || generateDefaultZodSchema(column);
+    return `${comment}${column.name}: ${schema},`;
+};
+export const generateDefaultZodSchema = (column) => {
+    if (column.type === 'varchar') {
+        if (column.length === 36) {
+            return 'z.uuid()';
+        }
+        if (column.length) {
+            return `z.string().max(${column.length})`;
+        }
+        return 'z.string()';
+    }
+    if (column.type === 'int') {
+        return 'z.number().int()';
+    }
+    if (column.type === 'text') {
+        return 'z.string()';
+    }
+    return 'z.unknown()';
+};
+export const generateZodFile = (tables) => {
+    const imports = 'import * as z from \'zod\'\n\n';
+    const schemas = tables.map(table => generateZodSchema(table)).join('\n\n');
+    return imports + schemas;
+};

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

@@ -1,8 +1,8 @@
-import { capitalize } from '../../../shared/utils/capitalize.js';
 /**
  * @param name
  * @returns
  */
 export function infer(name) {
-    return `export type ${capitalize(name)} = z.infer<typeof ${capitalize(name)}Schema>`;
+    const capitalizedName = name.charAt(0).toUpperCase() + name.slice(1);
+    return `export type ${capitalizedName} = z.infer<typeof ${capitalizedName}Schema>`;
 }

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

@@ -0,0 +1,13 @@
+/**
+ * Generates Zod relation schema code from a relation schema AST extraction.
+ */
+export declare function relationZodCode(schema: {
+    name: string;
+    baseName: string;
+    fields: {
+        name: string;
+        definition: string;
+        description?: string;
+    }[];
+    objectType?: 'strict' | 'loose';
+}, withType: boolean): string;

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

@@ -0,0 +1,19 @@
+import { capitalize, infer } from '../../../utils/index.js';
+/**
+ * Generates Zod relation schema code from a relation schema AST extraction.
+ */
+export function relationZodCode(schema, withType) {
+    const base = schema.baseName;
+    const relName = `${schema.name}Schema`;
+    const baseSchema = `${capitalize(base)}Schema`;
+    const fields = schema.fields.map((f) => `${f.name}:${f.definition}`).join(',');
+    const objectType = schema.objectType === 'strict'
+        ? 'strictObject'
+        : schema.objectType === 'loose'
+            ? 'looseObject'
+            : 'object';
+    const obj = `\nexport const ${capitalize(relName)} = z.${objectType}({...${baseSchema}.shape,${fields}})`;
+    if (withType)
+        return `${obj}\n\n${infer(schema.name)}\n`;
+    return `${obj}`;
+}

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

@@ -1,4 +1,3 @@
-import type { Schema } from '../../../shared/types.js';
 /**
  * Generates Zod code for a given schema and config.
  *
@@ -7,4 +6,12 @@ import type { Schema } from '../../../shared/types.js';
  * @param config - The configuration for the code generation.
  * @returns The generated Zod code.
  */
-export declare function zodCode(schema: Schema, comment: boolean, type: boolean): string;
+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

@@ -1,4 +1,4 @@
-import { infer } from './infer.js';
+import { infer } from '../../../utils/index.js';
 import { zod } from './zod.js';
 /**
  * Generates Zod code for a given schema and config.

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

@@ -1,4 +1,3 @@
-import type { Schema } from '../../../shared/types.js';
 /**
  * Generates a Zod schema for a given schema and config.
  *
@@ -6,4 +5,12 @@ import type { Schema } from '../../../shared/types.js';
  * @param config - The configuration for the code generation.
  * @returns The generated Zod schema.
  */
-export declare function zod(schema: Schema, comment: boolean): string;
+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

@@ -1,5 +1,4 @@
-import { fieldDefinitions } from '../../../shared/generator/field-definitions.js';
-import { capitalize } from '../../../shared/utils/capitalize.js';
+import { capitalize, fieldDefinitions } from '../../../utils/index.js';
 /**
  * Generates a Zod schema for a given schema and config.
  *
@@ -8,5 +7,10 @@ import { capitalize } from '../../../shared/utils/capitalize.js';
  * @returns The generated Zod schema.
  */
 export function zod(schema, comment) {
-    return `export const ${capitalize(schema.name)}Schema = z.object({${fieldDefinitions(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,4 +1,3 @@
-import type { Result } from 'neverthrow';
 /**
  * Generate Zod schema
  * @param code - The code to generate Zod schema from
@@ -7,4 +6,10 @@ import type { Result } from 'neverthrow';
  * @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' | 'v4-mini' | '@hono/zod-openapi'): Promise<Result<void, Error>>;
+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,11 +1,9 @@
 import path from 'node:path';
-import { extractSchemas } from './core/extract-schema.js';
-import { zodCode } from './generator/zod-code.js';
-import { mkdir, writeFile } from '../../shared/fsp/index.js';
 import { fmt } from '../../shared/format/index.js';
-const ZODV4_IMPORT = `import { z } from 'zod/v4'`;
-const ZODV4_MINI_IMPORT = `import { z } from 'zod/v4-mini'`;
-const ZOD_OPENAPI_HONO_IMPORT = `import { z } from '@hono/zod-openapi'`;
+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
@@ -14,17 +12,43 @@ const ZOD_OPENAPI_HONO_IMPORT = `import { z } from '@hono/zod-openapi'`;
  * @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) {
+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 = [
-        zod === 'v4-mini'
-            ? ZODV4_MINI_IMPORT
-            : zod === '@hono/zod-openapi'
-                ? ZOD_OPENAPI_HONO_IMPORT
-                : ZODV4_IMPORT,
+        importLine,
         '',
-        ...extractSchemas(code).map((schema) => zodCode(schema, comment ?? false, type ?? false)),
+        ...baseSchemas.map((schema) => zodCode(schema, comment ?? false, type ?? false)),
+        ...(relations ? relationSchemas.map((schema) => relationZodCode(schema, type ?? false)) : []),
     ].join('\n');
-    return await mkdir(path.dirname(output))
-        .andThen(() => fmt(zodGeneratedCode))
-        .andThen((formatted) => writeFile(output, formatted));
+    const mkdirResult = await mkdir(path.dirname(output));
+    if (!mkdirResult.ok) {
+        return {
+            ok: false,
+            error: mkdirResult.error,
+        };
+    }
+    const fmtResult = await fmt(zodGeneratedCode);
+    if (!fmtResult.ok) {
+        return {
+            ok: false,
+            error: fmtResult.error,
+        };
+    }
+    const writeFileResult = await writeFile(output, fmtResult.value);
+    if (!writeFileResult.ok) {
+        return {
+            ok: false,
+            error: writeFileResult.error,
+        };
+    }
+    return {
+        ok: true,
+        value: undefined,
+    };
 }

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,54 +1,71 @@
+// #!/usr/bin/env node
 import { getConfig } from './config/index.js';
-import { sizukuZod } from './generator/zod/index.js';
-import { sizukuValibot } from './generator/valibot/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';
-import { ok, err, ResultAsync } from 'neverthrow';
 export async function main(config = getConfig()) {
-    return ResultAsync.fromPromise(Promise.resolve(), () => new Error('init'))
-        .andThen(() => {
-        if (!config.input) {
-            return err(new Error('input is not found'));
-        }
-        const contentResult = readFileSync(config.input);
-        if (contentResult.isErr()) {
-            return err(contentResult.error);
-        }
-        const content = contentResult.value;
-        const lines = content.split('\n');
-        const codeStart = lines.findIndex((line) => !line.trim().startsWith('import') && line.trim() !== '');
-        return ok(lines.slice(codeStart));
-    })
-        .andThen((code) => {
-        if (config.zod?.output) {
-            return ResultAsync.fromPromise(sizukuZod(code, config.zod.output, config.zod.comment, config.zod.type, config.zod.zod), (e) => (e instanceof Error ? e : new Error(String(e)))).map(() => {
-                console.log(`Generated Zod schema at: ${config.zod?.output}`);
-                return code;
-            });
+    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,
+            };
         }
-        return ok(code);
-    })
-        .andThen((code) => {
-        if (config.valibot?.output) {
-            return ResultAsync.fromPromise(sizukuValibot(code, config.valibot.output, config.valibot.comment, config.valibot.type), (e) => (e instanceof Error ? e : new Error(String(e)))).map(() => {
-                console.log(`Generated Valibot schema at: ${config.valibot?.output}`);
-                return code;
-            });
+        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,
+            };
         }
-        return ok(code);
-    })
-        .andThen((code) => {
-        if (config.mermaid?.output) {
-            return ResultAsync.fromPromise(sizukuMermaidER(code, config.mermaid.output), (e) => e instanceof Error ? e : new Error(String(e))).map(() => {
-                console.log(`Generated Mermaid ER at: ${config.mermaid?.output}`);
-            });
+        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,
+            };
         }
-        return ok(undefined);
-    });
+        results.push(`Generated Mermaid ER at: ${config.mermaid?.output}`);
+    }
+    return {
+        ok: true,
+        value: results.join('\n'),
+    };
 }
 main().then((result) => {
-    if (!result.isOk()) {
-        console.error(result.error);
-        process.exit(1);
+    if (result?.ok) {
+        console.log(result.value);
+    }
+    else {
+        console.error(result?.error);
     }
 });