sizuku 0.0.7 → 0.2.0

package/dist/shared/utils/string-utils.js

@@ -0,0 +1,28 @@
+// 完全純粋な文字列操作ユーティリティ - 外部import禁止
+export const capitalize = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+};
+export const toPascalCase = (str) => {
+    return str
+        .split(/[-_\s]+/)
+        .map(word => capitalize(word))
+        .join('');
+};
+export const extractComment = (commentText) => {
+    return commentText.replace(/^\/\/\/\s*/, '').trim();
+};
+export const parseZodTag = (tag) => {
+    return tag.replace(/^@z\./, '');
+};
+export const parseValibotTag = (tag) => {
+    return tag.replace(/^@v\./, '');
+};
+export const parseRelationTag = (tag) => {
+    return tag.replace(/^@relation\s+/, '');
+};
+export const splitLines = (text) => {
+    return text.split('\n').map(line => line.trim()).filter(line => line.length > 0);
+};
+export const joinLines = (lines) => {
+    return lines.join('\n');
+};

package/dist/shared/utils/types.d.ts

@@ -0,0 +1,32 @@
+export type TableInfo = {
+    name: string;
+    columns: ColumnInfo[];
+    relations: RelationInfo[];
+};
+export type ColumnInfo = {
+    name: string;
+    type: string;
+    isPrimary: boolean;
+    isNullable: boolean;
+    length?: number;
+    zodSchema?: string;
+    valibotSchema?: string;
+    comment?: string;
+};
+export type RelationInfo = {
+    sourceTable: string;
+    sourceColumn: string;
+    targetTable: string;
+    targetColumn: string;
+    type: 'one-to-many' | 'many-to-one' | 'one-to-one' | 'many-to-many';
+};
+export type ParsedSchema = {
+    tables: TableInfo[];
+};
+export type GenerationResult<T> = {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: string;
+};

package/dist/shared/utils/types.js

@@ -0,0 +1,2 @@
+// 完全純粋な型定義 - 外部import禁止
+export {};

package/dist/shared/utils/validation-utils.d.ts

@@ -0,0 +1,8 @@
+import type { ColumnInfo, RelationInfo } from './types.js';
+export declare const validateTableName: (name: string) => boolean;
+export declare const validateColumnName: (name: string) => boolean;
+export declare const validateRelationType: (type: string) => type is "one-to-many" | "many-to-one" | "one-to-one" | "many-to-many";
+export declare const validateSchema: (tables: ColumnInfo[][]) => boolean;
+export declare const findPrimaryKey: (columns: ColumnInfo[]) => ColumnInfo | undefined;
+export declare const findForeignKeys: (columns: ColumnInfo[]) => ColumnInfo[];
+export declare const validateRelation: (relation: RelationInfo, tables: string[]) => boolean;

package/dist/shared/utils/validation-utils.js

@@ -0,0 +1,25 @@
+// 完全純粋なバリデーション関連ユーティリティ - 外部import禁止
+export const validateTableName = (name) => {
+    return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+};
+export const validateColumnName = (name) => {
+    return /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(name);
+};
+export const validateRelationType = (type) => {
+    return ['one-to-many', 'many-to-one', 'one-to-one', 'many-to-many'].includes(type);
+};
+export const validateSchema = (tables) => {
+    return tables.every(table => table.every(column => validateColumnName(column.name) &&
+        column.type.length > 0));
+};
+export const findPrimaryKey = (columns) => {
+    return columns.find(column => column.isPrimary);
+};
+export const findForeignKeys = (columns) => {
+    return columns.filter(column => column.name.toLowerCase().includes('id') &&
+        !column.isPrimary);
+};
+export const validateRelation = (relation, tables) => {
+    return tables.includes(relation.sourceTable) &&
+        tables.includes(relation.targetTable);
+};

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

@@ -0,0 +1,18 @@
+export type Config = {
+    input?: `${string}.ts`;
+    zod?: {
+        output?: `${string}.ts`;
+        comment?: boolean;
+        type?: boolean;
+        zod?: 'v4' | 'mini' | '@hono/zod-openapi';
+    };
+    valibot?: {
+        output?: `${string}.ts`;
+        comment?: boolean;
+        type?: boolean;
+    };
+    mermaid?: {
+        output?: string;
+    };
+};
+export declare function getConfig(): Config;

package/dist/src/config/index.js

@@ -0,0 +1,13 @@
+import fs from 'node:fs';
+export function getConfig() {
+    if (!fs.existsSync('sizuku.json')) {
+        throw new Error('sizuku.json not found');
+    }
+    const parsed = JSON.parse(fs.readFileSync('sizuku.json', 'utf-8'));
+    return {
+        input: parsed.input,
+        zod: parsed.zod,
+        valibot: parsed.valibot,
+        mermaid: parsed.mermaid,
+    };
+}

package/dist/src/generator/mermaid-er/core/extract-relations.d.ts

@@ -0,0 +1,8 @@
+import type { Relation } from '../types.js';
+/**
+ * Extracts relations from the given code.
+ *
+ * @param code - The code to extract relations from.
+ * @returns The extracted relations.
+ */
+export declare function extractRelations(code: string[]): Relation[];

package/dist/src/generator/mermaid-er/core/extract-relations.js

@@ -0,0 +1,12 @@
+import { parseRelationLine } from '../validator/parse-relation-line.js';
+/**
+ * Extracts relations from the given code.
+ *
+ * @param code - The code to extract relations from.
+ * @returns The extracted relations.
+ */
+export function extractRelations(code) {
+    return code
+        .map((line) => parseRelationLine(line))
+        .filter((relation) => relation !== null);
+}

package/dist/src/generator/mermaid-er/generator/er-content.d.ts

@@ -0,0 +1,9 @@
+import type { Relation, TableInfo } from '../types.js';
+/**
+ * Generate ER content.
+ *
+ * @param relations - The relations to generate the ER content from.
+ * @param tables - The tables to generate the ER content from.
+ * @returns The generated ER content.
+ */
+export declare function erContent(relations: Relation[], tables: TableInfo[]): string;

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

@@ -0,0 +1,25 @@
+import { relationLine } from './index.js';
+const ER_HEADER = ['```mermaid', 'erDiagram'];
+const ER_FOOTER = ['```'];
+/**
+ * Generate ER content.
+ *
+ * @param relations - The relations to generate the ER content from.
+ * @param tables - The tables to generate the ER content from.
+ * @returns The generated ER content.
+ */
+export function erContent(relations, tables) {
+    const relationLines = relations.map(relationLine);
+    const tableDefinitions = tables.flatMap((table) => [
+        `    ${table.name} {`,
+        ...table.fields.map((field) => `        ${field.type} ${field.name} ${field.description ? `"${field.description}"` : ''}`),
+        '    }',
+    ]);
+    const erContent = [
+        ...ER_HEADER,
+        ...relationLines,
+        ...tableDefinitions,
+        ...ER_FOOTER,
+    ];
+    return erContent.join('\n');
+}

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

@@ -0,0 +1,2 @@
+export { erContent } from './er-content.js';
+export { relationLine } from './relation-line.js';

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

@@ -0,0 +1,2 @@
+export { erContent } from './er-content.js';
+export { relationLine } from './relation-line.js';

package/dist/src/generator/mermaid-er/generator/relation-line.d.ts

@@ -0,0 +1,8 @@
+import type { Relation } from '../types.js';
+/**
+ * Generate a relation line for a relation.
+ *
+ * @param relation - The relation to generate a line for.
+ * @returns The generated relation line.
+ */
+export declare function relationLine(relation: Relation): string;

package/dist/src/generator/mermaid-er/generator/relation-line.js

@@ -0,0 +1,14 @@
+import { buildRelationLine } from '../relationship/build-relation-line.js';
+/**
+ * Generate a relation line for a relation.
+ *
+ * @param relation - The relation to generate a line for.
+ * @returns The generated relation line.
+ */
+export function relationLine(relation) {
+    const cardinality = buildRelationLine(relation.type);
+    if (!cardinality) {
+        throw new Error(`Unknown relation type: ${relation.type}`);
+    }
+    return `    ${relation.fromModel} ${cardinality} ${relation.toModel} : "(${relation.fromField}) - (${relation.toField})"`;
+}

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

@@ -0,0 +1,6 @@
+/**
+ * Generate Mermaid ER diagram
+ * @param code - The code to generate Mermaid ER diagram from
+ * @param output - The output file path
+ */
+export declare function sizukuMermaidER(code: string[], output: string): Promise<import("neverthrow").Result<void, Error>>;

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

@@ -0,0 +1,16 @@
+import path from 'node:path';
+import { mkdir, writeFile } from '../../shared/fsp/index.js';
+import { extractRelations } from './core/extract-relations.js';
+import { erContent } from './generator/index.js';
+import { parseTableInfo } from './validator/parse-table-info.js';
+/**
+ * Generate Mermaid ER diagram
+ * @param code - The code to generate Mermaid ER diagram from
+ * @param output - The output file path
+ */
+export async function sizukuMermaidER(code, output) {
+    const tables = parseTableInfo(code);
+    const relations = extractRelations(code);
+    const ERContent = erContent(relations, tables);
+    return await mkdir(path.dirname(output)).andThen(() => writeFile(output, ERContent));
+}

package/dist/src/generator/mermaid-er/relationship/build-relation-line.d.ts

@@ -0,0 +1,15 @@
+declare const RELATIONSHIPS: {
+    readonly 'zero-one': "|o";
+    readonly one: "||";
+    readonly 'zero-many': "}o";
+    readonly many: "}|";
+};
+export type Relationship = keyof typeof RELATIONSHIPS;
+/**
+ * Builds a relationship line for mermaid from a string.
+ *
+ * @param input - The relationship string to parse.
+ * @returns The mermaid relationship line.
+ */
+export declare function buildRelationLine(input: string): string;
+export {};

package/dist/src/generator/mermaid-er/relationship/build-relation-line.js

@@ -0,0 +1,35 @@
+import { isRelationship } from '../validator/is-relationship.js';
+const RELATIONSHIPS = {
+    'zero-one': '|o',
+    one: '||',
+    'zero-many': '}o',
+    many: '}|',
+};
+/**
+ * Builds a relationship line for mermaid from a string.
+ *
+ * @param input - The relationship string to parse.
+ * @returns The mermaid relationship line.
+ */
+export function buildRelationLine(input) {
+    const parts = input.split('-to-');
+    if (parts.length !== 2) {
+        throw new Error(`Invalid input format: ${input}`);
+    }
+    const [toRaw, optionalFlag] = parts[1].includes('-optional')
+        ? [parts[1].replace('-optional', ''), 'optional']
+        : [parts[1], ''];
+    const from = parts[0];
+    const to = toRaw;
+    const isOptional = optionalFlag === 'optional';
+    if (!(isRelationship(from) && isRelationship(to))) {
+        throw new Error(`Invalid relationship string: ${input}`);
+    }
+    const fromSymbol = RELATIONSHIPS[from];
+    const toSymbol = RELATIONSHIPS[to];
+    if (!(fromSymbol && toSymbol)) {
+        throw new Error(`Invalid relationship string: ${input}`);
+    }
+    const connector = isOptional ? '..' : '--';
+    return `${fromSymbol}${connector}${toSymbol}`;
+}

package/dist/src/generator/mermaid-er/types.d.ts

@@ -0,0 +1,21 @@
+export type Relation = {
+    fromModel: string;
+    toModel: string;
+    fromField: string;
+    toField: string;
+    type: string;
+};
+export type ERContent = readonly string[];
+export type TableInfo = {
+    name: string;
+    fields: {
+        type: string;
+        name: string;
+        description: string | null;
+    }[];
+};
+export type AccumulatorType = {
+    tables: TableInfo[];
+    currentTable: TableInfo | null;
+    currentDescription: string;
+};

package/dist/src/generator/mermaid-er/types.js

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,4 @@
+export { isRelationship } from './is-relationship.js';
+export { parseRelationLine } from './parse-relation-line.js';
+export { parseTableInfo } from './parse-table-info.js';
+export { removeDuplicateRelations } from './remove-duplicate-relations.js';

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

@@ -0,0 +1,4 @@
+export { isRelationship } from './is-relationship.js';
+export { parseRelationLine } from './parse-relation-line.js';
+export { parseTableInfo } from './parse-table-info.js';
+export { removeDuplicateRelations } from './remove-duplicate-relations.js';

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

@@ -0,0 +1,8 @@
+import type { Relationship } from '../relationship/build-relation-line.js';
+/**
+ * Check if a key is a valid relationship.
+ *
+ * @param key - The key to check.
+ * @returns True if the key is a valid relationship.
+ */
+export declare function isRelationship(key: string): key is Relationship;

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

@@ -0,0 +1,9 @@
+/**
+ * Check if a key is a valid relationship.
+ *
+ * @param key - The key to check.
+ * @returns True if the key is a valid relationship.
+ */
+export function isRelationship(key) {
+    return ['zero-one', 'one', 'zero-many', 'many'].includes(key);
+}

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

@@ -0,0 +1,13 @@
+/**
+ * Parse a relation line.
+ *
+ * @param line - The line to parse.
+ * @returns The parsed relation or null.
+ */
+export declare function parseRelationLine(line: string): {
+    fromModel: string;
+    fromField: string;
+    toModel: string;
+    toField: string;
+    type: string;
+} | null;

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

@@ -0,0 +1,21 @@
+/**
+ * Parse a relation line.
+ *
+ * @param line - The line to parse.
+ * @returns The parsed relation or null.
+ */
+export function parseRelationLine(line) {
+    // @relation <fromModel>.<fromField> <toModel>.<toField> <relationType>
+    const relationMatch = line.match(/@relation\s+(\w+)\.(\w+)\s+(\w+)\.(\w+)\s+(\w+-to-\w+)/);
+    if (relationMatch) {
+        const [_, fromModel, fromField, toModel, toField, type] = relationMatch;
+        return {
+            fromModel,
+            fromField,
+            toModel,
+            toField,
+            type,
+        };
+    }
+    return null;
+}

package/dist/src/generator/mermaid-er/validator/parse-table-info.d.ts

@@ -0,0 +1,8 @@
+import type { TableInfo } from '../types.js';
+/**
+ * Parse table information from code.
+ *
+ * @param code - The code to parse.
+ * @returns Array of table information.
+ */
+export declare function parseTableInfo(code: string[]): TableInfo[];

package/dist/src/generator/mermaid-er/validator/parse-table-info.js

@@ -0,0 +1,91 @@
+import { Node, Project } from 'ts-morph';
+/**
+ * Get the base builder name from an expression.
+ *
+ * @param expr - The expression to get the builder name from.
+ * @returns The base builder name.
+ */
+function baseBuilderName(expr) {
+    if (Node.isIdentifier(expr))
+        return expr.getText();
+    if (Node.isCallExpression(expr) || Node.isPropertyAccessExpression(expr))
+        return baseBuilderName(expr.getExpression());
+    return '';
+}
+/**
+ * Type guard for FieldInfo.
+ *
+ * @param v - The value to check.
+ * @returns True if the value is a FieldInfo.
+ */
+function isFieldInfo(v) {
+    return v !== null;
+}
+/**
+ * Parse table information from code.
+ *
+ * @param code - The code to parse.
+ * @returns Array of table information.
+ */
+export function parseTableInfo(code) {
+    const source = code.join('\n');
+    const file = new Project({ useInMemoryFileSystem: true }).createSourceFile('temp.ts', source);
+    return file
+        .getVariableStatements()
+        .filter((stmt) => stmt.isExported())
+        .flatMap((stmt) => {
+        const decl = stmt.getDeclarations()[0];
+        if (!Node.isVariableDeclaration(decl))
+            return [];
+        const varName = decl.getName();
+        if (varName.toLowerCase().includes('relation'))
+            return [];
+        const init = decl.getInitializer();
+        if (!(init && Node.isCallExpression(init)))
+            return [];
+        const callee = init.getExpression().getText();
+        if (!callee.endsWith('Table') || callee === 'relations')
+            return [];
+        const objLit = init.getArguments()[1];
+        if (!(objLit && Node.isObjectLiteralExpression(objLit)))
+            return [];
+        const fields = objLit
+            .getProperties()
+            .filter(Node.isPropertyAssignment)
+            .map((prop) => {
+            const keyNode = prop.getNameNode();
+            if (!Node.isIdentifier(keyNode))
+                return null;
+            const fieldName = keyNode.getText();
+            const initExpr = prop.getInitializer();
+            if (!(initExpr && Node.isCallExpression(initExpr)))
+                return null;
+            const fieldType = baseBuilderName(initExpr);
+            const initText = initExpr.getText();
+            const lineIdx = prop.getStartLineNumber() - 1;
+            const baseDesc = code
+                .slice(0, lineIdx)
+                .reverse()
+                .find((line) => {
+                const t = line.trim();
+                return (t.startsWith('///') &&
+                    !t.includes('@z.') &&
+                    !t.includes('@v.') &&
+                    !t.includes('@relation'));
+            })
+                ?.replace(/^\s*\/\/\/\s*/, '') ?? '';
+            const prefix = initText.includes('.primaryKey()')
+                ? '(PK) '
+                : initText.includes('.references(')
+                    ? '(FK) '
+                    : '';
+            return {
+                name: fieldName,
+                type: fieldType,
+                description: `${prefix}${baseDesc}`.trim(),
+            };
+        })
+            .filter(isFieldInfo);
+        return [{ name: varName, fields }];
+    });
+}

package/dist/src/generator/mermaid-er/validator/remove-duplicate-relations.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Remove duplicate relations.
+ *
+ * @param relations - The relations to remove duplicates from.
+ * @returns The relations without duplicates.
+ */
+export declare function removeDuplicateRelations(relations: readonly string[]): readonly string[];

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

@@ -0,0 +1,9 @@
+/**
+ * Remove duplicate relations.
+ *
+ * @param relations - The relations to remove duplicates from.
+ * @returns The relations without duplicates.
+ */
+export function removeDuplicateRelations(relations) {
+    return [...new Set(relations)];
+}

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

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

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

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

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

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

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

@@ -0,0 +1,16 @@
+import { inferInput } from './infer-input.js';
+import { valibot } from './valibot.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/src/generator/valibot/generator/valibot.d.ts

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

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

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

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

@@ -0,0 +1,9 @@
+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/src/generator/valibot/index.js

@@ -0,0 +1,34 @@
+import path from 'node:path';
+import { fmt } from '../../shared/format/index.js';
+import { mkdir, writeFile } from '../../shared/fsp/index.js';
+import { buildSchemaExtractor } from '../../shared/helper/build-schema-extractor.js';
+import { createExtractFieldFromProperty } from '../../shared/helper/create-extract-field-from-property.js';
+import { createExtractFieldsFromCallExpression } from '../../shared/helper/create-extract-fields-from-call-expression.js';
+import { createExtractRelationFieldFromProperty } from '../../shared/helper/create-extract-relation-field-from-property.js';
+import { extractSchemas } from '../../shared/helper/extract-schemas.js';
+import { findObjectLiteralExpression } from '../../shared/helper/find-object-literal-expression.js';
+import { findObjectLiteralInArgs } from '../../shared/helper/find-object-literalIn-args.js';
+import { isRelationFunctionCall } from '../../shared/helper/is-relation-function.js';
+import { parseFieldComments } from '../../shared/utils/index.js';
+import { valibotCode } from './generator/valibot-code.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 extractField = createExtractFieldFromProperty((lines) => parseFieldComments(lines, '@v.'));
+    const extractRelationField = createExtractRelationFieldFromProperty((lines) => parseFieldComments(lines, '@v.'), 'v');
+    const extractFieldsFromCall = createExtractFieldsFromCallExpression(extractField, extractRelationField, findObjectLiteralExpression, findObjectLiteralInArgs, isRelationFunctionCall);
+    const extractSchema = buildSchemaExtractor(extractFieldsFromCall, extractField);
+    const valibotGeneratedCode = [
+        'import * as v from "valibot"',
+        '',
+        ...extractSchemas(code, extractSchema).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/src/generator/zod/generator/infer.d.ts

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