sizuku 0.2.1 → 0.3.0

package/README.md

@@ -72,22 +72,26 @@ export const postRelations = relations(post, ({ one }) => ({
 
 Prepare sizuku.json:
 
-```json
-{
-  "input": "db/schema.ts",
-  "zod": {
-    "output": "zod/index.ts",
-    "comment": true,
-    "type": true
+```ts
+import defineConfig from 'sizuku/config'
+
+export default defineConfig({
+  input: 'db/schema.ts',
+  zod: {
+    output: 'zod/index.ts',
+    comment: true,
+    type: true,
+    zod: 'v4',
+  },
+  valibot: {
+    output: 'valibot/index.ts',
+    comment: true,
+    type: true,
   },
-  "valibot": {
-    "output": "valibot/index.ts",
-    "comment": true
+  mermaid: {
+    output: 'mermaid-er/ER.md',
   },
-  "mermaid": {
-    "output": "mermaid-er/ER.md"
-  }
-}
+})
 ```
 
 Run Sizuku:
@@ -160,6 +164,8 @@ export const UserSchema = v.object({
   name: v.pipe(v.string(), v.minLength(1), v.maxLength(50)),
 })
 
+export type User = v.InferInput<typeof UserSchema>
+
 export const PostSchema = v.object({
   /**
    * Primary key
@@ -179,9 +185,15 @@ export const PostSchema = v.object({
   userId: v.pipe(v.string(), v.uuid()),
 })
 
+export type Post = v.InferInput<typeof PostSchema>
+
 export const UserRelationsSchema = v.object({ ...UserSchema.entries, posts: v.array(PostSchema) })
 
+export type UserRelations = v.InferInput<typeof UserRelationsSchema>
+
 export const PostRelationsSchema = v.object({ ...PostSchema.entries, user: UserSchema })
+
+export type PostRelations = v.InferInput<typeof PostRelationsSchema>
 ```
 
 ### Mermaid ER

package/dist/config/index.d.ts

@@ -1,18 +1,27 @@
-export type Config = {
-    input?: `${string}.ts`;
+export type Config = Readonly<{
+    input: `${string}.ts`;
     zod?: {
-        output?: `${string}.ts`;
+        output: `${string}.ts`;
         comment?: boolean;
         type?: boolean;
         zod?: 'v4' | 'mini' | '@hono/zod-openapi';
+        relation?: boolean;
     };
     valibot?: {
-        output?: `${string}.ts`;
+        output: `${string}.ts`;
         comment?: boolean;
         type?: boolean;
+        relation?: boolean;
     };
     mermaid?: {
-        output?: string;
+        output: string;
     };
-};
-export declare function getConfig(): Config;
+}>;
+export declare function config(): Promise<{
+    ok: true;
+    value: Config;
+} | {
+    ok: false;
+    error: string;
+}>;
+export default function defineConfig(config: Config): Config;

package/dist/config/index.js

@@ -1,13 +1,85 @@
-import fs from 'node:fs';
-export function getConfig() {
-    if (!fs.existsSync('sizuku.json')) {
-        throw new Error('sizuku.json not found');
+import { existsSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { register } from 'tsx/esm/api';
+export async function config() {
+    const isTs = (o) => o.endsWith('.ts');
+    const abs = resolve(process.cwd(), 'sizuku.config.ts');
+    if (!existsSync(abs)) {
+        return { ok: false, error: `Config not found: ${abs}` };
     }
-    const parsed = JSON.parse(fs.readFileSync('sizuku.json', 'utf-8'));
-    return {
-        input: parsed.input,
-        zod: parsed.zod,
-        valibot: parsed.valibot,
-        mermaid: parsed.mermaid,
-    };
+    try {
+        register();
+        const mod = await import(pathToFileURL(abs).href);
+        if (!('default' in mod)) {
+            return { ok: false, error: 'Config must export default object' };
+        }
+        if (mod.default !== undefined) {
+            if (!isTs(mod.default.input)) {
+                return { ok: false, error: 'Input must be a .ts file' };
+            }
+            // zod
+            if (mod.default.zod !== undefined) {
+                if (!isTs(mod.default.zod.output)) {
+                    return { ok: false, error: 'Zod output must be a .ts file' };
+                }
+                if (mod.default.zod.comment !== undefined) {
+                    if (typeof mod.default.zod.comment !== 'boolean') {
+                        return { ok: false, error: 'Zod comment must be a boolean' };
+                    }
+                }
+                if (mod.default.zod.type !== undefined) {
+                    if (typeof mod.default.zod.type !== 'boolean') {
+                        return { ok: false, error: 'Zod type must be a boolean' };
+                    }
+                }
+                if (mod.default.zod.zod !== undefined) {
+                    if (mod.default.zod.zod !== 'v4' &&
+                        mod.default.zod.zod !== 'mini' &&
+                        mod.default.zod.zod !== '@hono/zod-openapi') {
+                        return { ok: false, error: 'zod must be v4, mini, or @hono/zod-openapi' };
+                    }
+                }
+                if (mod.default.zod.relation !== undefined) {
+                    if (typeof mod.default.zod.relation !== 'boolean') {
+                        return { ok: false, error: 'Zod relation must be a boolean' };
+                    }
+                }
+            }
+        }
+        // valibot
+        if (mod.default.valibot !== undefined) {
+            if (!isTs(mod.default.valibot.output)) {
+                return { ok: false, error: 'Valibot output must be a .ts file' };
+            }
+            if (mod.default.valibot.comment !== undefined) {
+                if (typeof mod.default.valibot.comment !== 'boolean') {
+                    return { ok: false, error: 'Valibot comment must be a boolean' };
+                }
+            }
+            if (mod.default.valibot.type !== undefined) {
+                if (typeof mod.default.valibot.type !== 'boolean') {
+                    return { ok: false, error: 'Valibot type must be a boolean' };
+                }
+            }
+            if (mod.default.valibot.relation !== undefined) {
+                if (typeof mod.default.valibot.relation !== 'boolean') {
+                    return { ok: false, error: 'Valibot relation must be a boolean' };
+                }
+            }
+        }
+        // mermaid
+        if (mod.default.mermaid !== undefined) {
+            if (typeof mod.default.mermaid.output !== 'string') {
+                return { ok: false, error: 'Mermaid output must be a string' };
+            }
+        }
+        return { ok: true, value: mod.default };
+    }
+    catch (e) {
+        return { ok: false, error: e instanceof Error ? e.message : String(e) };
+    }
+}
+export default function defineConfig(config) {
+    return config;
 }

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

@@ -14,7 +14,7 @@ export function erContent(relations, tables) {
         // Generate per-table definitions
         ...tables.flatMap((table) => [
             `    ${table.name} {`,
-            ...table.fields.map((field) => `        ${field.type} ${field.name} ${field.description ? `"${field.description}"` : ''}`),
+            ...table.fields.map((field) => `        ${field.type} ${field.name}${field.description ? ` "${field.description}"` : ''}`),
             '    }',
         ]),
         ...ER_FOOTER,

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

@@ -43,7 +43,8 @@ export function parseTableInfo(code) {
             const fieldType = baseBuilderName(initExpr);
             const initText = initExpr.getText();
             const lineIdx = prop.getStartLineNumber() - 1;
-            const baseDesc = code
+            // Find the immediate comment above this field
+            const immediateComment = code
                 .slice(0, lineIdx)
                 .reverse()
                 .find((line) => {
@@ -59,10 +60,12 @@ export function parseTableInfo(code) {
                 : initText.includes('.references(')
                     ? '(FK) '
                     : '';
+            // Only include description if there's a comment
+            const description = immediateComment ? `${prefix}${immediateComment}`.trim() : null;
             return {
                 name: fieldName,
                 type: fieldType,
-                description: `${prefix}${baseDesc}`.trim(),
+                description,
             };
         })
             .filter(isFieldInfo);

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

@@ -5,7 +5,7 @@
  * @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, relations?: boolean): Promise<{
+export declare function sizukuValibot(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, relation?: boolean): Promise<{
     ok: true;
     value: undefined;
 } | {

package/dist/generator/valibot/index.js

@@ -11,14 +11,14 @@ import { valibotCode } from './generator/valibot-code.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, relations) {
+export async function sizukuValibot(code, output, comment, type, relation) {
     const baseSchemas = extractSchemas(code, 'valibot');
     const relationSchemas = extractRelationSchemas(code, 'valibot');
     const valibotGeneratedCode = [
         "import * as v from 'valibot'",
         '',
         ...baseSchemas.map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
-        ...(relations
+        ...(relation
             ? relationSchemas.map((schema) => relationValibotCode(schema, type ?? false))
             : []),
     ].join('\n');

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

@@ -6,7 +6,7 @@
  * @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<{
+export declare function sizukuZod(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean, zod?: 'v4' | 'mini' | '@hono/zod-openapi', relation?: boolean): Promise<{
     ok: true;
     value: undefined;
 } | {

package/dist/generator/zod/index.js

@@ -12,7 +12,7 @@ import { zodCode } from './generator/zod-code.js';
  * @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) {
+export async function sizukuZod(code, output, comment, type, zod, relation) {
     const importLine = zod === 'mini'
         ? `import * as z from 'zod/mini'`
         : zod === '@hono/zod-openapi'
@@ -24,7 +24,7 @@ export async function sizukuZod(code, output, comment, type, zod, relations) {
         importLine,
         '',
         ...baseSchemas.map((schema) => zodCode(schema, comment ?? false, type ?? false)),
-        ...(relations ? relationSchemas.map((schema) => relationZodCode(schema, type ?? false)) : []),
+        ...(relation ? relationSchemas.map((schema) => relationZodCode(schema, type ?? false)) : []),
     ].join('\n');
     const mkdirResult = await mkdir(path.dirname(output));
     if (!mkdirResult.ok) {

package/dist/index.d.ts

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

package/dist/index.js

@@ -1,17 +1,19 @@
 // #!/usr/bin/env node
-import { getConfig } from './config/index.js';
+import { config } 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) {
+export async function main() {
+    const configResult = await config();
+    if (!configResult.ok) {
         return {
             ok: false,
-            error: 'input is not found',
+            error: configResult.error,
         };
     }
-    const contentResult = readFileSync(config.input);
+    const c = configResult.value;
+    const contentResult = readFileSync(c.input);
     if (!contentResult.ok) {
         return {
             ok: false,
@@ -24,37 +26,37 @@ export async function main(config = getConfig()) {
     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 (c.zod?.output) {
+        const zodResult = await sizukuZod(code, c.zod.output, c.zod.comment, c.zod.type, c.zod.zod, c.zod.relation);
         if (!zodResult.ok) {
             return {
                 ok: false,
                 error: zodResult.error,
             };
         }
-        results.push(`Generated Zod schema at: ${config.zod?.output}`);
+        results.push(`Generated Zod schema at: ${c.zod?.output}`);
     }
     /* valibot */
-    if (config.valibot?.output) {
-        const valibotResult = await sizukuValibot(code, config.valibot.output, config.valibot.comment, config.valibot.type, true);
+    if (c.valibot?.output) {
+        const valibotResult = await sizukuValibot(code, c.valibot.output, c.valibot.comment, c.valibot.type, c.valibot.relation);
         if (!valibotResult.ok) {
             return {
                 ok: false,
                 error: valibotResult.error,
             };
         }
-        results.push(`Generated Valibot schema at: ${config.valibot?.output}`);
+        results.push(`Generated Valibot schema at: ${c.valibot?.output}`);
     }
     /* mermaid */
-    if (config.mermaid?.output) {
-        const mermaidResult = await sizukuMermaidER(code, config.mermaid.output);
+    if (c.mermaid?.output) {
+        const mermaidResult = await sizukuMermaidER(code, c.mermaid.output);
         if (!mermaidResult.ok) {
             return {
                 ok: false,
                 error: mermaidResult.error,
             };
         }
-        results.push(`Generated Mermaid ER at: ${config.mermaid?.output}`);
+        results.push(`Generated Mermaid ER at: ${c.mermaid?.output}`);
     }
     return {
         ok: true,

package/dist/utils/index.js

@@ -73,19 +73,7 @@ export function joinWithSpace(arr) {
  * @returns Array of strings split by newline.
  */
 export function splitByNewline(str) {
-    const result = [];
-    let current = '';
-    for (let i = 0; i < str.length; i++) {
-        if (str[i] === '\n') {
-            result.push(current);
-            current = '';
-        }
-        else {
-            current += str[i];
-        }
-    }
-    result.push(current);
-    return result;
+    return str.split('\n');
 }
 /**
  * Trim whitespace from string.
@@ -94,17 +82,7 @@ export function splitByNewline(str) {
  * @returns Trimmed string.
  */
 export function trimString(str) {
-    let start = 0;
-    let end = str.length - 1;
-    while (start <= end &&
-        (str[start] === ' ' || str[start] === '\t' || str[start] === '\r' || str[start] === '\n')) {
-        start++;
-    }
-    while (end >= start &&
-        (str[end] === ' ' || str[end] === '\t' || str[end] === '\r' || str[end] === '\n')) {
-        end--;
-    }
-    return str.substring(start, end + 1);
+    return str.trim();
 }
 /**
  * Parse relation line and extract components.
@@ -113,13 +91,13 @@ export function trimString(str) {
  * @returns Parsed relation or null if not a relation line.
  */
 export function parseRelationLine(line) {
-    if (!startsWith(line, '@relation'))
+    if (!line.startsWith('@relation'))
         return null;
-    const parts = splitByWhitespace(line);
+    const parts = line.trim().split(/\s+/);
     if (parts.length < 5)
         return null;
-    const fromParts = splitByDot(parts[1]);
-    const toParts = splitByDot(parts[2]);
+    const fromParts = parts[1].split('.');
+    const toParts = parts[2].split('.');
     if (fromParts.length !== 2 || toParts.length !== 2)
         return null;
     return {
@@ -159,28 +137,10 @@ export function removeOptionalSuffix(str) {
  * @returns Array of strings split by whitespace.
  */
 export function splitByWhitespace(str) {
-    const result = [];
-    let current = '';
-    let inWord = false;
-    for (let i = 0; i < str.length; i++) {
-        const char = str[i];
-        const isWhitespace = char === ' ' || char === '\t' || char === '\r' || char === '\n';
-        if (isWhitespace) {
-            if (inWord) {
-                result.push(current);
-                current = '';
-                inWord = false;
-            }
-        }
-        else {
-            current += char;
-            inWord = true;
-        }
-    }
-    if (inWord) {
-        result.push(current);
-    }
-    return result;
+    return str
+        .trim()
+        .split(/\s+/)
+        .filter((s) => s.length > 0);
 }
 /**
  * Split string by dot character.
@@ -189,19 +149,7 @@ export function splitByWhitespace(str) {
  * @returns Array of strings split by dot.
  */
 export function splitByDot(str) {
-    const result = [];
-    let current = '';
-    for (let i = 0; i < str.length; i++) {
-        if (str[i] === '.') {
-            result.push(current);
-            current = '';
-        }
-        else {
-            current += str[i];
-        }
-    }
-    result.push(current);
-    return result;
+    return str.split('.');
 }
 /* ========================================================================== *
  *  parse
@@ -214,24 +162,25 @@ export function splitByDot(str) {
  * @returns Parsed definition and description
  */
 export function parseFieldComments(commentLines, tag) {
-    const cleaned = commentLines.map((line) => removeTripleSlash(line).trim()).filter(isNonEmpty);
-    // Extract object type from strictObject/looseObject tags
-    const objectTypeLine = cleaned.find((line) => containsSubstring(line, `${tag.slice(1)}strictObject`) ||
-        containsSubstring(line, `${tag.slice(1)}looseObject`));
-    const objectType = objectTypeLine && containsSubstring(objectTypeLine, 'strictObject')
-        ? 'strict'
-        : objectTypeLine && containsSubstring(objectTypeLine, 'looseObject')
-            ? 'loose'
-            : undefined;
-    // Extract definition (excluding strictObject/looseObject tags)
-    const definitionLine = cleaned.find((line) => startsWith(line, tag) &&
-        !containsSubstring(line, 'strictObject') &&
-        !containsSubstring(line, 'looseObject'));
-    const definition = definitionLine ? removeAtSign(definitionLine) : '';
-    const descriptionLines = cleaned.filter((line) => !(containsSubstring(line, '@z.') ||
-        containsSubstring(line, '@v.') ||
-        containsSubstring(line, '@relation.')));
-    const description = descriptionLines.length > 0 ? joinWithSpace(descriptionLines) : undefined;
+    const cleaned = commentLines
+        .map((line) => (line.startsWith('///') ? line.substring(3) : line).trim())
+        .filter((line) => line.length > 0);
+    const objectTypeLine = cleaned.find((line) => line.includes(`${tag.slice(1)}strictObject`) || line.includes(`${tag.slice(1)}looseObject`));
+    const objectType = objectTypeLine
+        ? objectTypeLine.includes('strictObject')
+            ? 'strict'
+            : objectTypeLine.includes('looseObject')
+                ? 'loose'
+                : undefined
+        : undefined;
+    const definitionLine = cleaned.find((line) => line.startsWith(tag) && !line.includes('strictObject') && !line.includes('looseObject'));
+    const definition = definitionLine
+        ? definitionLine.startsWith('@')
+            ? definitionLine.substring(1)
+            : definitionLine
+        : '';
+    const descriptionLines = cleaned.filter((line) => !(line.includes('@z.') || line.includes('@v.') || line.includes('@relation.')));
+    const description = descriptionLines.length > 0 ? descriptionLines.join(' ') : undefined;
     return { definition, description, objectType };
 }
 /* ========================================================================== *
@@ -246,14 +195,14 @@ export function parseFieldComments(commentLines, tag) {
  */
 export function extractFieldComments(sourceText, fieldStartPos) {
     const beforeField = sourceText.substring(0, fieldStartPos);
-    const lines = splitByNewline(beforeField);
+    const lines = beforeField.split('\n');
     const reverseIndex = lines
-        .map((line, index) => ({ line: trimString(line), index }))
+        .map((line, index) => ({ line: line.trim(), index }))
         .reverse()
         .reduce((acc, { line }) => {
         if (acc.shouldStop)
             return acc;
-        if (startsWith(line, '///')) {
+        if (line.startsWith('///')) {
             return {
                 commentLines: [line, ...acc.commentLines],
                 shouldStop: false,

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sizuku",
   "type": "module",
-  "version": "0.2.1",
+  "version": "0.3.0",
   "description": "Sizuku is a tool that generates validation schemas for Zod and Valibot, as well as ER diagrams, from Drizzle schemas annotated with comments.",
   "license": "MIT",
   "keywords": [
@@ -29,6 +29,12 @@
   "bin": {
     "sizuku": "dist/index.js"
   },
+  "exports": {
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "import": "./dist/config/index.js"
+    }
+  },
   "scripts": {
     "deps": "rm -rf node_modules && pnpm install",
     "build": "tsc",
@@ -48,6 +54,7 @@
   },
   "dependencies": {
     "prettier": "^3.6.2",
-    "ts-morph": "^26.0.0"
+    "ts-morph": "^26.0.0",
+    "tsx": "^4.20.5"
   }
 }