sizuku 0.0.6 → 0.1.0

package/dist/generator/valibot/core/extract-schema.js

@@ -1,92 +1,173 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractSchemas = extractSchemas;
+import { Node, Project } from 'ts-morph';
 /**
- * Check if line contains metadata
+ * Check if the comment line is metadata (Zod / Valibot / relation helper)
  */
-const isMetadataComment = (line) => {
-    return line.includes('@z.') || line.includes('@v.') || line.includes('@relation.');
+const isMetadataComment = (text) => {
+    return text.includes('@z.') || text.includes('@v.') || text.includes('@relation.');
 };
 /**
- * Extract schemas from lines of code
- * @function extractSchemas
- * @param lines - Lines of code
- * @returns Schemas
+ * Collect consecutive `///` comment lines that appear immediately above a field.
  */
-function extractSchemas(lines) {
-    const process = (i, acc) => {
-        if (i >= lines.length) {
+const extractFieldComments = (sourceText, fieldStartPos) => {
+    const beforeField = sourceText.substring(0, fieldStartPos);
+    const lines = beforeField.split('\n');
+    return lines
+        .map((line) => line.trim())
+        .reverse()
+        .reduce((acc, line) => {
+        if (acc.stop)
             return acc;
+        if (line.startsWith('///')) {
+            return { commentLines: [line, ...acc.commentLines], stop: false };
         }
-        const line = lines[i];
-        // extract schema name
-        const schemaMatch = line.match(/export const (\w+)\s*=/);
-        if (schemaMatch) {
-            if (acc.currentSchema) {
-                acc.schemas.push(acc.currentSchema);
-            }
-            acc.currentSchema = { name: schemaMatch[1], fields: [] };
-            acc.pendingDescription = undefined;
-            return process(i + 1, acc);
-        }
-        // handle comment line
-        if (line.trim().startsWith('///')) {
-            // detect valibot comment
-            const valibotComment = line.match(/\/\/\/\s*@(v\.[^\n]+)/);
-            if (valibotComment && acc.currentSchema) {
-                // find next field definition line
-                const remainingCandidates = lines.slice(i + 1);
-                const foundRelative = remainingCandidates.findIndex((candidate) => {
-                    const trimmed = candidate.trim();
-                    return trimmed !== '' && !trimmed.startsWith('///');
-                });
-                if (foundRelative !== -1) {
-                    const j = i + 1 + foundRelative;
-                    const candidate = lines[j].trim();
-                    const fieldMatch = candidate.match(/^(\w+)\s*:/);
-                    if (fieldMatch) {
-                        const newField = {
-                            name: fieldMatch[1],
-                            definition: valibotComment[1],
-                            description: acc.pendingDescription,
-                        };
-                        acc.currentSchema.fields.push(newField);
-                        acc.pendingDescription = undefined;
-                        return process(i + 1, acc);
-                    }
-                }
-            }
-            else {
-                // ignore comment line except metadata
-                if (!isMetadataComment(line)) {
-                    const commentText = line.replace('///', '').trim();
-                    acc.pendingDescription = acc.pendingDescription
-                        ? `${acc.pendingDescription} ${commentText}`
-                        : commentText;
-                    return process(i + 1, acc);
-                }
-            }
-            return process(i + 1, acc);
-        }
-        // if field definition is found in non-comment line, use pending comment as field information
-        if (acc.currentSchema && acc.pendingDescription) {
-            const fieldMatch = line.match(/^(\w+)\s*:/);
-            if (fieldMatch) {
-                const newField = {
-                    name: fieldMatch[1],
-                    definition: '',
-                    description: acc.pendingDescription,
-                };
-                acc.currentSchema.fields.push(newField);
-                acc.pendingDescription = undefined;
-                return process(i + 1, acc);
+        if (line === '')
+            return acc;
+        return { commentLines: acc.commentLines, stop: true };
+    }, { commentLines: [], stop: false }).commentLines;
+};
+/**
+ * Parse the collected comment lines -> { valibotDefinition, description }
+ */
+const parseFieldComments = (commentLines) => {
+    const cleaned = commentLines.map((l) => l.replace(/^\/\/\/\s*/, '').trim()).filter(Boolean);
+    const valibotDefinition = cleaned.find((l) => l.startsWith('@v.'))?.replace(/^@/, '') ?? '';
+    const descriptionLines = cleaned.filter((l) => !isMetadataComment(l));
+    const description = descriptionLines.length ? descriptionLines.join(' ') : undefined;
+    return { valibotDefinition, description };
+};
+/**
+ * Convert table name to Schema name (e.g. `user` -> `UserSchema`)
+ */
+const toSchemaName = (table) => `${table.charAt(0).toUpperCase() + table.slice(1)}Schema`;
+/**
+ * Extract an ordinary column field.
+ */
+const extractFieldFromProperty = (property, sourceText) => {
+    if (!Node.isPropertyAssignment(property))
+        return null;
+    const name = property.getName();
+    if (!name)
+        return null;
+    const commentLines = extractFieldComments(sourceText, property.getStart());
+    const { valibotDefinition, description } = parseFieldComments(commentLines);
+    return { name, definition: valibotDefinition, description };
+};
+/**
+ * Extract a relation field (many / one) and infer Valibot schema.
+ */
+const extractRelationFieldFromProperty = (property, sourceText) => {
+    if (!Node.isPropertyAssignment(property))
+        return null;
+    const name = property.getName();
+    if (!name)
+        return null;
+    const init = property.getInitializer();
+    if (!Node.isCallExpression(init))
+        return { name, definition: '', description: undefined };
+    const expr = init.getExpression();
+    if (!Node.isIdentifier(expr))
+        return { name, definition: '', description: undefined };
+    const fnName = expr.getText();
+    const args = init.getArguments();
+    if (!(args.length && Node.isIdentifier(args[0])))
+        return { name, definition: '', description: undefined };
+    const refTable = args[0].getText();
+    const schemaName = toSchemaName(refTable);
+    const definition = fnName === 'many' ? `v.array(${schemaName})` : fnName === 'one' ? schemaName : '';
+    const commentLines = extractFieldComments(sourceText, property.getStart());
+    const { description } = parseFieldComments(commentLines);
+    return { name, definition, description };
+};
+/** Utility: unwrap arrow / paren / etc. until ObjectLiteralExpression or null */
+const extractObjectLiteralFromExpression = (expr) => {
+    if (Node.isObjectLiteralExpression(expr))
+        return expr;
+    if (Node.isParenthesizedExpression(expr))
+        return extractObjectLiteralFromExpression(expr.getExpression());
+    if (Node.isArrowFunction(expr)) {
+        const body = expr.getBody();
+        if (Node.isObjectLiteralExpression(body))
+            return body;
+        if (Node.isParenthesizedExpression(body))
+            return extractObjectLiteralFromExpression(body.getExpression());
+        if (Node.isBlock(body)) {
+            const ret = body.getStatements().find(Node.isReturnStatement);
+            if (ret && Node.isReturnStatement(ret)) {
+                const re = ret.getExpression();
+                return re && Node.isObjectLiteralExpression(re) ? re : null;
             }
         }
-        return process(i + 1, acc);
-    };
-    const finalAcc = process(0, { currentSchema: null, pendingDescription: undefined, schemas: [] });
-    if (finalAcc.currentSchema) {
-        finalAcc.schemas.push(finalAcc.currentSchema);
     }
-    return finalAcc.schemas;
+    return null;
+};
+/** find the first object literal among call expression arguments */
+const findObjectLiteralInArgs = (call) => {
+    for (const arg of call.getArguments()) {
+        const obj = extractObjectLiteralFromExpression(arg);
+        if (obj)
+            return obj;
+    }
+    return null;
+};
+/** recognise `relations()` / `somethingRelation*` helpers */
+const isRelationFunction = (call) => {
+    const expr = call.getExpression();
+    return (Node.isIdentifier(expr) &&
+        (expr.getText() === 'relations' || expr.getText().includes('relation')));
+};
+/** extract fields from mysqlTable / relations call expression */
+const extractFieldsFromCallExpression = (call, sourceText) => {
+    const obj = findObjectLiteralInArgs(call);
+    if (!obj)
+        return [];
+    const relation = isRelationFunction(call);
+    return obj
+        .getProperties()
+        .map((p) => relation
+        ? extractRelationFieldFromProperty(p, sourceText)
+        : extractFieldFromProperty(p, sourceText))
+        .filter((f) => f !== null);
+};
+/** extract a single schema from variable declaration */
+const extractSchemaFromDeclaration = (decl, sourceText) => {
+    if (!Node.isVariableDeclaration(decl))
+        return null;
+    const name = decl.getName();
+    if (!name)
+        return null;
+    const init = decl.getInitializer();
+    // Handle call expressions (mysqlTable, relations, etc.)
+    if (Node.isCallExpression(init)) {
+        // ⛔ Skip relation helper exports (userRelations / postRelations ...)
+        if (isRelationFunction(init))
+            return null;
+        const fields = extractFieldsFromCallExpression(init, sourceText);
+        return { name, fields };
+    }
+    // Direct object literal export
+    if (Node.isObjectLiteralExpression(init)) {
+        const fields = init
+            .getProperties()
+            .map((p) => extractFieldFromProperty(p, sourceText))
+            .filter((f) => f !== null);
+        return { name, fields };
+    }
+    return { name, fields: [] };
+};
+/**
+ * Public API: extract schemas from code lines
+ */
+export function extractSchemas(lines) {
+    const project = new Project({
+        useInMemoryFileSystem: true,
+        compilerOptions: { allowJs: true, skipLibCheck: true },
+    });
+    const file = project.createSourceFile('temp.ts', lines.join('\n'));
+    const fullText = file.getFullText();
+    return file
+        .getVariableStatements()
+        .filter((s) => s.hasExportKeyword())
+        .flatMap((s) => s.getDeclarations())
+        .map((d) => extractSchemaFromDeclaration(d, fullText))
+        .filter((s) => s !== null);
 }

package/dist/generator/valibot/generator/infer-input.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @param name
+ * @returns
+ */
+export declare function inferInput(name: string): string;

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

@@ -0,0 +1,8 @@
+import { capitalize } from '../../../shared/utils/capitalize.js';
+/**
+ * @param name
+ * @returns
+ */
+export function inferInput(name) {
+    return `export type ${capitalize(name)} = v.InferInput<typeof ${capitalize(name)}Schema>`;
+}

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

@@ -0,0 +1,8 @@
+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;

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

@@ -0,0 +1,16 @@
+import { valibot } from './valibot.js';
+import { inferInput } from './infer-input.js';
+/**
+ * @param schema
+ * @param comment
+ * @param type
+ * @returns
+ */
+export function valibotCode(schema, comment, type) {
+    const valibotSchema = valibot(schema, comment);
+    if (type) {
+        const valibotInfer = inferInput(schema.name);
+        return `${valibotSchema}\n\n${valibotInfer}\n`;
+    }
+    return `${valibotSchema}\n`;
+}

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

@@ -0,0 +1,7 @@
+import type { Schema } from '../../../shared/types.js';
+/**
+ * @param schema
+ * @param config
+ * @returns
+ */
+export declare function valibot(schema: Schema, comment: boolean): string;

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

@@ -0,0 +1,11 @@
+import { capitalize } from '../../../shared/utils/capitalize.js';
+import { fieldDefinitions } from '../../../shared/generator/field-definitions.js';
+/**
+ * @param schema
+ * @param config
+ * @returns
+ */
+export function valibot(schema, comment) {
+    const res = fieldDefinitions(schema, comment);
+    return `export const ${capitalize(schema.name)}Schema = v.object({${res}})`;
+}

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

@@ -1,3 +1,9 @@
-#!/usr/bin/env node
-import type { Config } from '../../common/config';
-export declare function main(dev?: boolean, config?: Config): Promise<boolean>;
+import type { Result } from 'neverthrow';
+/**
+ * Generate Valibot schema
+ * @param code - The code to generate Valibot 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
+ */
+export declare function sizukuValibot(code: string[], output: `${string}.ts`, comment?: boolean, type?: boolean): Promise<Result<void, Error>>;

package/dist/generator/valibot/index.js

@@ -1,77 +1,22 @@
-#!/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 format_1 = require("../../common/format");
-const config_1 = require("./config");
-const node_process_1 = require("node:process");
-const generate_valibot_code_1 = require("./generator/generate-valibot-code");
-const IMPORT_VALIBOT = 'import * as v from "valibot"';
-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;
-    }
-    // 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_VALIBOT,
-            '',
-            ...schemas.map((schema) => (0, generate_valibot_code_1.generateValibotCode)(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 Valibot schema at: ${output}`);
-        return true;
-    }
-    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;
-    }
-}
-if (require.main === module) {
-    main().then((success) => {
-        if (!success) {
-            process.exit(1);
-        }
-    });
+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';
+/**
+ * Generate Valibot schema
+ * @param code - The code to generate Valibot 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
+ */
+export async function sizukuValibot(code, output, comment, type) {
+    const valibotGeneratedCode = [
+        'import * as v from "valibot"',
+        '',
+        ...extractSchemas(code).map((schema) => valibotCode(schema, comment ?? false, type ?? false)),
+    ].join('\n');
+    return await mkdir(path.dirname(output))
+        .andThen(() => fmt(valibotGeneratedCode))
+        .andThen((formatted) => writeFile(output, formatted));
 }

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

@@ -1,8 +1,8 @@
-import type { Config } from '../../../common/config';
+import type { Config } from '../../../shared/config/index.js'
 /**
  * Loads the configuration from the `sizuku.json` file or returns the default configuration.
  *
  * @function getConfig
  * @returns The configuration object.
  */
-export declare function getConfig(): Config;
+export declare function getConfig(): Config

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

@@ -1,20 +1,14 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getConfig = getConfig;
-const node_fs_1 = __importDefault(require("node:fs"));
-const config_1 = require("../../../common/config");
+import fs from 'node:fs';
+import { DEFAULT_CONFIG } from '../../../shared/config/index.js';
 /**
  * Loads the configuration from the `sizuku.json` file or returns the default configuration.
  *
  * @function getConfig
  * @returns The configuration object.
  */
-function getConfig() {
-    const config = node_fs_1.default.existsSync('sizuku-zod.json')
-        ? { ...config_1.DEFAULT_CONFIG, ...JSON.parse(node_fs_1.default.readFileSync('sizuku-zod.json', 'utf-8')) }
-        : config_1.DEFAULT_CONFIG;
+export function getConfig() {
+    const config = fs.existsSync('sizuku-zod.json')
+        ? { ...DEFAULT_CONFIG, ...JSON.parse(fs.readFileSync('sizuku-zod.json', 'utf-8')) }
+        : DEFAULT_CONFIG;
     return config;
 }

package/dist/generator/zod/core/extract-schema.d.ts

@@ -1,7 +1,6 @@
-import type { Schema } from '../../../common/type';
+import type { Schema } from '../../../shared/types.js';
 /**
  * Extract schemas from lines of code
- * @function extractSchemas
  * @param lines - Lines of code
  * @returns Schemas
  */