@omnifyjp/ts 0.3.0

package/dist/cli.d.ts

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+/**
+ * @omnify/ts CLI
+ *
+ * Reads omnify.yaml to resolve schemas.json input and TypeScript output paths.
+ * Falls back to explicit --input / --output flags.
+ *
+ * Usage:
+ *   omnify-ts                              # reads omnify.yaml in cwd
+ *   omnify-ts --config path/to/omnify.yaml
+ *   omnify-ts --input schemas.json --output ./types  # explicit override
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,180 @@
+#!/usr/bin/env node
+/**
+ * @omnify/ts CLI
+ *
+ * Reads omnify.yaml to resolve schemas.json input and TypeScript output paths.
+ * Falls back to explicit --input / --output flags.
+ *
+ * Usage:
+ *   omnify-ts                              # reads omnify.yaml in cwd
+ *   omnify-ts --config path/to/omnify.yaml
+ *   omnify-ts --input schemas.json --output ./types  # explicit override
+ */
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
+import { resolve, dirname, join } from 'node:path';
+import { Command } from 'commander';
+import { parse as parseYaml } from 'yaml';
+import { generateTypeScript } from './generator.js';
+import { generatePhp } from './php/index.js';
+function resolveFromConfig(configPath) {
+    const raw = readFileSync(configPath, 'utf-8');
+    const config = parseYaml(raw);
+    const configDir = dirname(configPath);
+    // Find default connection
+    const defaultName = config.default ?? 'default';
+    const connections = config.connections ?? {};
+    const conn = connections[defaultName];
+    if (!conn) {
+        throw new Error(`Connection "${defaultName}" not found in ${configPath}`);
+    }
+    // Resolve schemas.json input path from migrations[type=laravel].schemasPath
+    let schemasPath;
+    for (const m of conn.migrations ?? []) {
+        if (m.type === 'laravel' && m.schemasPath) {
+            schemasPath = m.schemasPath;
+            break;
+        }
+    }
+    if (!schemasPath) {
+        throw new Error(`No schemasPath found in laravel migration for connection "${defaultName}" in ${configPath}.\n` +
+            `Either add schemasPath to your laravel migration config, or use --input explicitly.`);
+    }
+    // TypeScript config (enable defaults to false)
+    const tsConfig = config.codegen?.typescript;
+    const tsEnabled = tsConfig?.enable === true && !!tsConfig?.modelsPath;
+    const tsOutput = tsEnabled ? resolve(configDir, tsConfig.modelsPath) : undefined;
+    // Laravel config (enable defaults to false)
+    const laravelConfig = config.codegen?.laravel;
+    const laravelEnabled = laravelConfig?.enable === true;
+    const laravelOverrides = laravelEnabled ? {
+        model: laravelConfig?.model,
+        request: laravelConfig?.request,
+        resource: laravelConfig?.resource,
+        factory: laravelConfig?.factory,
+        provider: laravelConfig?.provider,
+    } : undefined;
+    return {
+        input: resolve(configDir, schemasPath),
+        tsEnabled,
+        tsOutput,
+        laravelEnabled,
+        laravelOverrides,
+    };
+}
+// ============================================================================
+// CLI
+// ============================================================================
+const program = new Command();
+program
+    .name('omnify-ts')
+    .description('Generate TypeScript types and Laravel PHP code from Omnify schemas.json')
+    .option('-c, --config <path>', 'Path to omnify.yaml (default: ./omnify.yaml)')
+    .option('-i, --input <path>', 'Path to schemas.json (overrides config)')
+    .option('-o, --output <path>', 'Output directory for TypeScript (overrides config)')
+    .option('--force', 'Overwrite user-editable model files', false)
+    .action((opts) => {
+    let inputPath;
+    let tsEnabled = true;
+    let tsOutput;
+    let laravelEnabled = false;
+    let laravelOverrides;
+    let configDir = process.cwd();
+    if (opts.input && opts.output) {
+        // Explicit flags — skip config, only TS generation
+        inputPath = resolve(opts.input);
+        tsOutput = resolve(opts.output);
+    }
+    else {
+        // Read from omnify.yaml
+        const configPath = resolve(opts.config ?? 'omnify.yaml');
+        configDir = dirname(configPath);
+        if (!existsSync(configPath)) {
+            console.error(`Error: Config not found: ${configPath}\n` +
+                `Run from a directory with omnify.yaml, or use --config / --input + --output.`);
+            process.exit(1);
+        }
+        const resolved = resolveFromConfig(configPath);
+        inputPath = opts.input ? resolve(opts.input) : resolved.input;
+        tsEnabled = resolved.tsEnabled;
+        tsOutput = opts.output ? resolve(opts.output) : resolved.tsOutput;
+        laravelEnabled = resolved.laravelEnabled;
+        laravelOverrides = resolved.laravelOverrides;
+    }
+    // Read schemas.json
+    if (!existsSync(inputPath)) {
+        console.error(`Error: schemas.json not found: ${inputPath}\nRun "omnify generate" first.`);
+        process.exit(1);
+    }
+    const raw = readFileSync(inputPath, 'utf-8');
+    const input = JSON.parse(raw);
+    console.log(`Reading schemas from ${inputPath}`);
+    // ---- TypeScript generation ----
+    if (tsEnabled && tsOutput) {
+        console.log(`\n[TypeScript] Output: ${tsOutput}`);
+        const files = generateTypeScript(input);
+        mkdirSync(join(tsOutput, 'base'), { recursive: true });
+        mkdirSync(join(tsOutput, 'enum'), { recursive: true });
+        let tsCreated = 0;
+        let tsOverwritten = 0;
+        let tsSkipped = 0;
+        for (const file of files) {
+            let filePath;
+            if (file.category === 'enum' || file.category === 'plugin-enum') {
+                filePath = join(tsOutput, 'enum', file.filePath);
+            }
+            else {
+                filePath = join(tsOutput, file.filePath);
+            }
+            mkdirSync(dirname(filePath), { recursive: true });
+            if (!file.overwrite && existsSync(filePath) && !opts.force) {
+                tsSkipped++;
+                continue;
+            }
+            writeFileSync(filePath, file.content, 'utf-8');
+            if (file.overwrite || !existsSync(filePath)) {
+                tsOverwritten++;
+            }
+            else {
+                tsCreated++;
+            }
+        }
+        console.log(`  ${tsOverwritten} files written (auto-generated)`);
+        if (tsCreated > 0)
+            console.log(`  ${tsCreated} files created (user-editable)`);
+        if (tsSkipped > 0)
+            console.log(`  ${tsSkipped} files skipped (already exist)`);
+    }
+    else {
+        console.log(`\n[TypeScript] Skipped (disabled)`);
+    }
+    // ---- PHP/Laravel generation ----
+    if (laravelEnabled) {
+        console.log(`\n[Laravel] Generating PHP files`);
+        const phpFiles = generatePhp(input, laravelOverrides);
+        let phpCreated = 0;
+        let phpOverwritten = 0;
+        let phpSkipped = 0;
+        for (const file of phpFiles) {
+            const filePath = resolve(configDir, file.path);
+            mkdirSync(dirname(filePath), { recursive: true });
+            if (!file.overwrite && existsSync(filePath) && !opts.force) {
+                phpSkipped++;
+                continue;
+            }
+            writeFileSync(filePath, file.content, 'utf-8');
+            if (file.overwrite || !existsSync(filePath)) {
+                phpOverwritten++;
+            }
+            else {
+                phpCreated++;
+            }
+        }
+        console.log(`  ${phpOverwritten} files written (auto-generated)`);
+        if (phpCreated > 0)
+            console.log(`  ${phpCreated} files created (user-editable)`);
+        if (phpSkipped > 0)
+            console.log(`  ${phpSkipped} files skipped (already exist)`);
+    }
+    console.log(`\nGeneration complete.`);
+});
+program.parse();

package/dist/enum-generator.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @omnify/ts — TypeScript Enum Generator
+ *
+ * Generates TypeScript enums with helper methods from schema enum definitions,
+ * plugin enums (customTypes.enums), and inline property enums.
+ */
+import type { SchemaDefinition, TSEnum, TSTypeAlias, GeneratorOptions } from './types.js';
+/** Convert a string to PascalCase. */
+export declare function toPascalCase(value: string): string;
+/** Convert enum value to valid TypeScript enum member name. */
+export declare function toEnumMemberName(value: string): string;
+/** Generate TSEnum from a schema enum definition. */
+export declare function schemaToEnum(schema: SchemaDefinition, options: GeneratorOptions): TSEnum | null;
+/** Generate enums from all schema enums. */
+export declare function generateEnums(schemas: Record<string, SchemaDefinition>, options: GeneratorOptions): TSEnum[];
+/** Generate enums from plugin enums (customTypes.enums in schemas.json). */
+export declare function generatePluginEnums(pluginEnums: Record<string, string[]>, _options: GeneratorOptions): TSEnum[];
+/** Format a TypeScript enum with helpers (Values array, type guard, label getter). */
+export declare function formatEnum(enumDef: TSEnum): string;
+/** Format a TypeScript type alias with helpers. */
+export declare function formatTypeAlias(alias: TSTypeAlias): string;
+/** Result of extracting inline enums. */
+export interface ExtractedInlineEnum {
+    typeAlias?: TSTypeAlias;
+    enum?: TSEnum;
+}
+/** Extract inline enums from Enum/Select properties. */
+export declare function extractInlineEnums(schemas: Record<string, SchemaDefinition>, options: GeneratorOptions): ExtractedInlineEnum[];

package/dist/enum-generator.js

@@ -0,0 +1,253 @@
+/**
+ * @omnify/ts — TypeScript Enum Generator
+ *
+ * Generates TypeScript enums with helper methods from schema enum definitions,
+ * plugin enums (customTypes.enums), and inline property enums.
+ */
+/** Convert a string to PascalCase. */
+export function toPascalCase(value) {
+    const normalized = value.replace(/([a-z])([A-Z])/g, '$1_$2');
+    return normalized
+        .split(/[-_\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('');
+}
+/** Convert enum value to valid TypeScript enum member name. */
+export function toEnumMemberName(value) {
+    let result = value
+        .split(/[-_\s]+/)
+        .map(word => word.charAt(0).toUpperCase() + word.slice(1).toLowerCase())
+        .join('')
+        .replace(/[^a-zA-Z0-9]/g, '');
+    if (/^\d/.test(result)) {
+        result = '_' + result;
+    }
+    return result;
+}
+/** Parse an enum value from schema (string or object with value/label). */
+function parseEnumValue(value, options) {
+    if (typeof value === 'string') {
+        return { name: toEnumMemberName(value), value };
+    }
+    let label;
+    if (value.label !== undefined) {
+        if (typeof value.label === 'object') {
+            // Multi-locale: keep all locales
+            label = value.label;
+        }
+        else {
+            label = value.label;
+        }
+    }
+    return {
+        name: toEnumMemberName(value.value),
+        value: value.value,
+        label,
+        extra: value.extra,
+    };
+}
+/** Generate TSEnum from a schema enum definition. */
+export function schemaToEnum(schema, options) {
+    if (schema.kind !== 'enum' || !schema.values)
+        return null;
+    const values = schema.values.map(v => parseEnumValue(v, options));
+    const displayName = resolveString(schema.displayName, options);
+    return {
+        name: schema.name,
+        values,
+        comment: displayName ?? schema.name,
+    };
+}
+/** Generate enums from all schema enums. */
+export function generateEnums(schemas, options) {
+    const enums = [];
+    for (const schema of Object.values(schemas)) {
+        if (schema.kind === 'enum') {
+            const enumDef = schemaToEnum(schema, options);
+            if (enumDef)
+                enums.push(enumDef);
+        }
+    }
+    return enums;
+}
+/** Generate enums from plugin enums (customTypes.enums in schemas.json). */
+export function generatePluginEnums(pluginEnums, _options) {
+    const enums = [];
+    for (const [name, values] of Object.entries(pluginEnums)) {
+        enums.push({
+            name,
+            values: values.map(v => ({
+                name: toEnumMemberName(v),
+                value: v,
+            })),
+            comment: name,
+        });
+    }
+    return enums;
+}
+/** Check if label is multi-locale. */
+function isMultiLocaleLabel(label) {
+    return label !== undefined && typeof label === 'object';
+}
+/** Lowercase first character. */
+function lowerFirst(str) {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+}
+/** Escape single quotes in strings. */
+function escapeString(str) {
+    return str.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+/** Format a TypeScript enum with helpers (Values array, type guard, label getter). */
+export function formatEnum(enumDef) {
+    const { name, values, comment } = enumDef;
+    const parts = [];
+    if (comment) {
+        parts.push(`/**\n * ${comment}\n */\n`);
+    }
+    // Enum definition
+    const enumValues = values.map(v => `  ${v.name} = '${v.value}',`).join('\n');
+    parts.push(`export enum ${name} {\n${enumValues}\n}\n\n`);
+    // Values array
+    parts.push(`/** All ${name} values */\n`);
+    parts.push(`export const ${name}Values = Object.values(${name}) as ${name}[];\n\n`);
+    // Type guard
+    parts.push(`/** Type guard for ${name} */\n`);
+    parts.push(`export function is${name}(value: unknown): value is ${name} {\n`);
+    parts.push(`  return ${name}Values.includes(value as ${name});\n`);
+    parts.push(`}\n\n`);
+    // Labels
+    const hasLabels = values.some(v => v.label !== undefined);
+    const hasMultiLocale = values.some(v => isMultiLocaleLabel(v.label));
+    if (hasLabels) {
+        if (hasMultiLocale) {
+            const labelEntries = values
+                .filter(v => v.label !== undefined)
+                .map(v => {
+                if (isMultiLocaleLabel(v.label)) {
+                    const locales = Object.entries(v.label)
+                        .map(([locale, text]) => `'${locale}': '${escapeString(text)}'`)
+                        .join(', ');
+                    return `  [${name}.${v.name}]: { ${locales} },`;
+                }
+                return `  [${name}.${v.name}]: { default: '${escapeString(String(v.label))}' },`;
+            })
+                .join('\n');
+            parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, Record<string, string>>> = {\n${labelEntries}\n};\n\n`);
+            parts.push(`/** Get label for ${name} value with locale support */\n`);
+            parts.push(`export function get${name}Label(value: ${name}, locale?: string): string {\n`);
+            parts.push(`  const labels = ${lowerFirst(name)}Labels[value];\n`);
+            parts.push(`  if (!labels) return value;\n`);
+            parts.push(`  if (locale && labels[locale]) return labels[locale];\n`);
+            parts.push(`  return labels['ja'] ?? labels['en'] ?? Object.values(labels)[0] ?? value;\n`);
+            parts.push(`}\n\n`);
+        }
+        else {
+            const labelEntries = values
+                .filter(v => v.label !== undefined)
+                .map(v => `  [${name}.${v.name}]: '${escapeString(String(v.label))}',`)
+                .join('\n');
+            parts.push(`const ${lowerFirst(name)}Labels: Partial<Record<${name}, string>> = {\n${labelEntries}\n};\n\n`);
+            parts.push(`/** Get label for ${name} value */\n`);
+            parts.push(`export function get${name}Label(value: ${name}): string {\n`);
+            parts.push(`  return ${lowerFirst(name)}Labels[value] ?? value;\n`);
+            parts.push(`}\n\n`);
+        }
+    }
+    else {
+        parts.push(`/** Get label for ${name} value */\n`);
+        parts.push(`export function get${name}Label(value: ${name}): string {\n`);
+        parts.push(`  return value;\n`);
+        parts.push(`}\n\n`);
+    }
+    // Extra
+    const hasExtra = values.some(v => v.extra !== undefined);
+    if (hasExtra) {
+        const extraEntries = values
+            .filter(v => v.extra !== undefined)
+            .map(v => `  [${name}.${v.name}]: ${JSON.stringify(v.extra)},`)
+            .join('\n');
+        parts.push(`const ${lowerFirst(name)}Extra: Partial<Record<${name}, Record<string, unknown>>> = {\n${extraEntries}\n};\n\n`);
+        parts.push(`/** Get extra metadata for ${name} value */\n`);
+        parts.push(`export function get${name}Extra(value: ${name}): Record<string, unknown> | undefined {\n`);
+        parts.push(`  return ${lowerFirst(name)}Extra[value];\n`);
+        parts.push(`}`);
+    }
+    else {
+        parts.push(`/** Get extra metadata for ${name} value */\n`);
+        parts.push(`export function get${name}Extra(_value: ${name}): Record<string, unknown> | undefined {\n`);
+        parts.push(`  return undefined;\n`);
+        parts.push(`}`);
+    }
+    return parts.join('');
+}
+/** Format a TypeScript type alias with helpers. */
+export function formatTypeAlias(alias) {
+    const { name, type, comment } = alias;
+    const parts = [];
+    if (comment) {
+        parts.push(`/**\n * ${comment}\n */\n`);
+    }
+    parts.push(`export type ${name} = ${type};\n\n`);
+    const values = type.split(' | ').map(v => v.trim());
+    parts.push(`/** All ${name} values */\n`);
+    parts.push(`export const ${name}Values: ${name}[] = [${values.join(', ')}];\n\n`);
+    parts.push(`/** Type guard for ${name} */\n`);
+    parts.push(`export function is${name}(value: unknown): value is ${name} {\n`);
+    parts.push(`  return ${name}Values.includes(value as ${name});\n`);
+    parts.push(`}\n\n`);
+    parts.push(`/** Get label for ${name} value */\n`);
+    parts.push(`export function get${name}Label(value: ${name}): string {\n`);
+    parts.push(`  return value;\n`);
+    parts.push(`}\n\n`);
+    parts.push(`/** Get extra metadata for ${name} value */\n`);
+    parts.push(`export function get${name}Extra(_value: ${name}): Record<string, unknown> | undefined {\n`);
+    parts.push(`  return undefined;\n`);
+    parts.push(`}`);
+    return parts.join('');
+}
+/** Extract inline enums from Enum/Select properties. */
+export function extractInlineEnums(schemas, options) {
+    const results = [];
+    for (const schema of Object.values(schemas)) {
+        if (schema.kind === 'enum' || !schema.properties)
+            continue;
+        for (const [propName, property] of Object.entries(schema.properties)) {
+            if (property.type === 'Enum' && Array.isArray(property.enum) && property.enum.length > 0) {
+                const typeName = `${schema.name}${toPascalCase(propName)}`;
+                const displayName = resolveString(schema.displayName, options);
+                // Check if values have labels (i.e., are objects not strings)
+                const enumValues = property.enum;
+                const hasLabels = enumValues.some(v => typeof v !== 'string' && v.label !== undefined);
+                if (hasLabels) {
+                    const values = enumValues.map(v => parseEnumValue(v, options));
+                    results.push({
+                        enum: {
+                            name: typeName,
+                            values,
+                            comment: displayName ?? `${schema.name} ${propName} enum`,
+                        },
+                    });
+                }
+                else {
+                    const values = enumValues.map(v => typeof v === 'string' ? v : v.value);
+                    results.push({
+                        typeAlias: {
+                            name: typeName,
+                            type: values.map(v => `'${v}'`).join(' | '),
+                            comment: displayName ?? `${schema.name} ${propName} enum`,
+                        },
+                    });
+                }
+            }
+        }
+    }
+    return results;
+}
+/** Resolve a LocalizedString to a single string. */
+function resolveString(value, options) {
+    if (value === undefined)
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    return value[options.defaultLocale] ?? value[options.fallbackLocale] ?? value['en'] ?? Object.values(value)[0];
+}

package/dist/generator.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @omnify/ts — Main Generator
+ *
+ * Orchestrates TypeScript code generation from schemas.json.
+ * Reads the JSON, builds options, calls sub-generators, and assembles output files.
+ *
+ * Output structure:
+ *   base/{SchemaName}.ts   — Auto-generated interfaces + Zod + i18n (always overwritten)
+ *   enum/{EnumName}.ts     — Auto-generated enums (always overwritten)
+ *   common.ts              — Shared types (DateTimeString, etc.)
+ *   i18n.ts                — Validation messages + locale helpers
+ *   {SchemaName}.ts        — User-editable models extending base (created once, never overwritten)
+ *   index.ts               — Re-exports (always overwritten)
+ */
+import type { SchemasJson, TypeScriptFile } from './types.js';
+/**
+ * Generate all TypeScript files from schemas.json input.
+ */
+export declare function generateTypeScript(input: SchemasJson): TypeScriptFile[];