@omnifyjp/omnify 0.1.0 → 0.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Schema-driven code generation for Laravel, TypeScript, and SQL",
   "license": "MIT",
   "repository": {
@@ -8,7 +8,8 @@
     "url": "https://github.com/omnifyjp/omnify-go"
   },
   "bin": {
-    "omnify": "bin/omnify"
+    "omnify": "bin/omnify",
+    "omnify-ts": "ts-dist/cli.js"
   },
   "types": "types/index.d.ts",
   "exports": {
@@ -21,7 +22,12 @@
     "./omnify-schema.json": "./omnify-schema.json",
     "./omnify-config-schema.json": "./omnify-config-schema.json"
   },
-  "files": ["bin/", "types/", "omnify-schema.json", "omnify-config-schema.json", "README.md"],
+  "files": ["bin/", "ts-dist/", "types/", "omnify-schema.json", "omnify-config-schema.json", "README.md"],
+  "dependencies": {
+    "commander": "^13.0.0",
+    "yaml": "^2.7.0",
+    "zod": "^3.24.0"
+  },
   "optionalDependencies": {
     "@omnifyjp/omnify-darwin-arm64": "0.1.0",
     "@omnifyjp/omnify-darwin-x64": "0.1.0",

package/ts-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/ts-dist/cli.js

@@ -0,0 +1,133 @@
+#!/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';
+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
+    const schemasPath = conn.output?.laravel?.schemasPath;
+    if (!schemasPath) {
+        throw new Error(`No output.laravel.schemasPath found for connection "${defaultName}" in ${configPath}.\n` +
+            `Either add schemasPath to your config, or use --input explicitly.`);
+    }
+    // Resolve typescript output path
+    const tsPath = conn.output?.typescript?.path;
+    if (!tsPath) {
+        throw new Error(`No output.typescript.path found for connection "${defaultName}" in ${configPath}.\n` +
+            `Add this to your omnify.yaml:\n\n` +
+            `  connections:\n` +
+            `    ${defaultName}:\n` +
+            `      output:\n` +
+            `        typescript:\n` +
+            `          path: resources/js/types/models\n\n` +
+            `Or use --output explicitly.`);
+    }
+    return {
+        input: resolve(configDir, schemasPath),
+        output: resolve(configDir, tsPath),
+    };
+}
+// ============================================================================
+// CLI
+// ============================================================================
+const program = new Command();
+program
+    .name('omnify-ts')
+    .description('Generate TypeScript types 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 (overrides config)')
+    .option('--force', 'Overwrite user-editable model files', false)
+    .action((opts) => {
+    let inputPath;
+    let outputDir;
+    if (opts.input && opts.output) {
+        // Explicit flags — skip config
+        inputPath = resolve(opts.input);
+        outputDir = resolve(opts.output);
+    }
+    else {
+        // Read from omnify.yaml
+        const configPath = resolve(opts.config ?? 'omnify.yaml');
+        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;
+        outputDir = opts.output ? resolve(opts.output) : resolved.output;
+    }
+    // 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}`);
+    console.log(`Output directory: ${outputDir}`);
+    // Generate files
+    const files = generateTypeScript(input);
+    // Ensure output directories exist
+    mkdirSync(join(outputDir, 'base'), { recursive: true });
+    mkdirSync(join(outputDir, 'enum'), { recursive: true });
+    // Write files
+    let created = 0;
+    let overwritten = 0;
+    let skipped = 0;
+    for (const file of files) {
+        // Route files to correct subdirectory
+        let filePath;
+        if (file.category === 'enum' || file.category === 'plugin-enum') {
+            filePath = join(outputDir, 'enum', file.filePath);
+        }
+        else {
+            filePath = join(outputDir, file.filePath);
+        }
+        // Ensure parent directory exists
+        mkdirSync(dirname(filePath), { recursive: true });
+        // Skip user-editable files if they already exist (unless --force)
+        if (!file.overwrite && existsSync(filePath) && !opts.force) {
+            skipped++;
+            continue;
+        }
+        writeFileSync(filePath, file.content, 'utf-8');
+        if (file.overwrite || !existsSync(filePath)) {
+            overwritten++;
+        }
+        else {
+            created++;
+        }
+    }
+    console.log(`\nGeneration complete:`);
+    console.log(`  ${overwritten} files written (auto-generated)`);
+    if (created > 0)
+        console.log(`  ${created} files created (user-editable)`);
+    if (skipped > 0)
+        console.log(`  ${skipped} files skipped (already exist)`);
+    console.log(`\nTotal: ${files.length} files`);
+});
+program.parse();

package/ts-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/ts-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/ts-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[];