@omnifyjp/omnify 0.2.2 → 0.2.4

package/README.md

@@ -14,6 +14,7 @@ Define your database schemas in YAML, generate Laravel PHP migrations, raw SQL,
 - **Laravel Migration Generation** — Complete PHP migration files with foreign keys, indexes, and comments
 - **Raw SQL Generation** — MySQL, PostgreSQL, and SQLite
 - **TypeScript Generation** — Interfaces, Zod schemas, and i18n types from `schemas.json`
+- **PHP Codegen** — Eloquent models, form requests, API resources, and factories from `schemas.json`
 - **Incremental Generation** — Lock file tracks changes; only regenerates what's needed
 - **Compound Types** — Single property expands to multiple columns (e.g., `JapaneseName` → 4 columns)
 - **Associations** — ManyToOne, OneToMany, ManyToMany (pivot tables), MorphMany/MorphTo
@@ -34,11 +35,6 @@ This installs:
 
 Both are available in `node_modules/.bin/` after installation.
 
-> **Note:** You can also install Go binary directly:
-> ```bash
-> go install github.com/famgia/omnify-go/cmd/omnify@latest
-> ```
-
 ---
 
 ## Quick Start / クイックスタート
@@ -96,9 +92,10 @@ npx omnify generate
 This generates:
 - **Laravel migrations** → `database/migrations/omnify/`
 - **SQL files** → configured output path
-- **TypeScript types** → configured `typescript.path` (interfaces, Zod schemas, i18n)
+- **TypeScript types** → if `codegen.typescript` configured (interfaces, Zod schemas, i18n)
+- **PHP codegen** → if `codegen.laravel` configured (Eloquent models, requests, resources, factories)
 - **schemas.json** → serialized schema data
-- **Lock file** → `.omnify.lock` (tracks schema state)
+- **Lock file** → `.omnify/lock.json` (tracks schema state)
 
 ---
 
@@ -108,20 +105,18 @@ Create `omnify.yaml` in your project root:
 
 ```yaml
 schemasDir: ./schemas
-lockFilePath: .omnify.lock
+lockFilePath: .omnify/lock.json
 
 connections:
   default:
     driver: mysql
-    output:
-      laravel:
-        migrationsPath: database/migrations/omnify
+    migrations:
+      - type: laravel
+        path: database/migrations/omnify
         schemasPath: database/omnify/schemas.json
-      sql:
+      - type: sql
         path: migrations/sql
         dialect: mysql
-      typescript:
-        path: resources/js/types/models    # TypeScript types output directory
 
 default: default
 
@@ -132,35 +127,53 @@ locale:
 
 compoundTypes:
   - japan    # Enables JapaneseName, JapaneseAddress, JapaneseBankAccount
+
+codegen:
+  typescript:
+    enable: true
+    modelsPath: resources/js/types/models    # TS interfaces, Zod schemas, i18n
+  laravel:
+    enable: true
+    model:                                   # Eloquent models
+      path: app/Models/Omnify
+      namespace: App\Models\Omnify
 ```
 
-### TypeScript Auto-Generation / TypeScript自動生成
+### Codegen / コード自動生成
 
-When `typescript.path` is configured, `omnify generate` automatically generates TypeScript types after writing `schemas.json`. No separate step needed.
+When `codegen` is configured, `omnify generate` automatically generates code after writing `schemas.json`. No separate step needed.
 
-`typescript.path`を設定すると、`omnify generate`実行時にTypeScript型が自動生成されます。別途コマンドを実行する必要はありません。
+`codegen`を設定すると、`omnify generate`実行時にコードが自動生成されます。
 
-Generated files:
+#### TypeScript (`codegen.typescript`)
 - `base/` — Auto-generated interfaces and Zod schemas (overwritten on each generation)
 - `enum/` — Enum type definitions
 - Model files — User-editable model files (created once, never overwritten)
 
+#### Laravel PHP (`codegen.laravel`)
+- Eloquent base models (`Base/`) — always overwritten
+- User models — created once, never overwritten
+- Form requests (Store + Update) — base + user files
+- API resources — base + user files
+- Factories — created once
+- Service provider, traits, locales
+
 ### Multiple Connections / 複数接続
 
 ```yaml
 connections:
   default:
     driver: mysql
-    output:
-      laravel:
-        migrationsPath: database/migrations/omnify
+    migrations:
+      - type: laravel
+        path: database/migrations/omnify
 
   product-db:
     driver: pgsql
-    output:
-      laravel:
-        migrationsPath: database/migrations/product
-      sql:
+    migrations:
+      - type: laravel
+        path: database/migrations/product
+      - type: sql
         path: output/sql/product
         dialect: postgresql
 ```

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "description": "Schema-driven code generation for Laravel, TypeScript, and SQL",
   "license": "MIT",
   "repository": {
@@ -36,10 +36,10 @@
     "zod": "^3.24.0"
   },
   "optionalDependencies": {
-    "@omnifyjp/omnify-darwin-arm64": "0.2.0",
-    "@omnifyjp/omnify-darwin-x64": "0.2.0",
-    "@omnifyjp/omnify-linux-x64": "0.2.0",
-    "@omnifyjp/omnify-linux-arm64": "0.2.0",
-    "@omnifyjp/omnify-win32-x64": "0.2.0"
+    "@omnifyjp/omnify-darwin-arm64": "0.2.4",
+    "@omnifyjp/omnify-darwin-x64": "0.2.4",
+    "@omnifyjp/omnify-linux-x64": "0.2.4",
+    "@omnifyjp/omnify-linux-arm64": "0.2.4",
+    "@omnifyjp/omnify-win32-x64": "0.2.4"
   }
 }

package/ts-dist/cli.js

@@ -15,6 +15,7 @@ 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);
@@ -26,27 +27,38 @@ function resolveFromConfig(configPath) {
     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 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;
+        }
     }
-    // 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.`);
+    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),
-        output: resolve(configDir, tsPath),
+        tsEnabled,
+        tsOutput,
+        laravelEnabled,
+        laravelOverrides,
     };
 }
 // ============================================================================
@@ -55,22 +67,27 @@ function resolveFromConfig(configPath) {
 const program = new Command();
 program
     .name('omnify-ts')
-    .description('Generate TypeScript types from Omnify schemas.json')
+    .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 (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 outputDir;
+    let tsEnabled = true;
+    let tsOutput;
+    let laravelEnabled = false;
+    let laravelOverrides;
+    let configDir = process.cwd();
     if (opts.input && opts.output) {
-        // Explicit flags — skip config
+        // Explicit flags — skip config, only TS generation
         inputPath = resolve(opts.input);
-        outputDir = resolve(opts.output);
+        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.`);
@@ -78,7 +95,10 @@ program
         }
         const resolved = resolveFromConfig(configPath);
         inputPath = opts.input ? resolve(opts.input) : resolved.input;
-        outputDir = opts.output ? resolve(opts.output) : resolved.output;
+        tsEnabled = resolved.tsEnabled;
+        tsOutput = opts.output ? resolve(opts.output) : resolved.tsOutput;
+        laravelEnabled = resolved.laravelEnabled;
+        laravelOverrides = resolved.laravelOverrides;
     }
     // Read schemas.json
     if (!existsSync(inputPath)) {
@@ -88,46 +108,73 @@ program
     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;
+    // ---- 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++;
+            }
         }
-        writeFileSync(filePath, file.content, 'utf-8');
-        if (file.overwrite || !existsSync(filePath)) {
-            overwritten++;
-        }
-        else {
-            created++;
+        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:`);
-    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`);
+    console.log(`\nGeneration complete.`);
 });
 program.parse();

package/ts-dist/php/base-model-generator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Port of BaseModelGenerator.php — generates abstract BaseModel with morph map.
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate the abstract BaseModel class with morph map. */
+export declare function generateBaseModel(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/ts-dist/php/base-model-generator.js

@@ -0,0 +1,70 @@
+/**
+ * Port of BaseModelGenerator.php — generates abstract BaseModel with morph map.
+ */
+import { toPascalCase } from './naming-helper.js';
+import { baseFile } from './types.js';
+/** Generate the abstract BaseModel class with morph map. */
+export function generateBaseModel(reader, config) {
+    const baseNamespace = config.models.baseNamespace;
+    const modelNamespace = config.models.namespace;
+    // Build morph map entries from all visible object schemas
+    const morphMap = {};
+    for (const name of Object.keys(reader.getVisibleObjectSchemas())) {
+        const modelName = toPascalCase(name);
+        morphMap[modelName] = `\\${modelNamespace}\\${modelName}::class`;
+    }
+    // Sort for consistent output
+    const sortedKeys = Object.keys(morphMap).sort();
+    const morphEntries = sortedKeys
+        .map(k => `        '${k}' => ${morphMap[k]},`)
+        .join('\n');
+    const content = `<?php
+
+namespace ${baseNamespace};
+
+/**
+ * Base model class for all Omnify-generated models.
+ * Contains model mapping for polymorphic relations.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+
+use Illuminate\\Database\\Eloquent\\Model;
+use Illuminate\\Database\\Eloquent\\Relations\\Relation;
+
+abstract class BaseModel extends Model
+{
+    /**
+     * Model class map for polymorphic relations.
+     */
+    protected static array $modelMap = [
+${morphEntries}
+    ];
+
+    /**
+     * Boot the model and register morph map.
+     */
+    protected static function boot(): void
+    {
+        parent::boot();
+
+        // Register morph map for polymorphic relations
+        Relation::enforceMorphMap(static::$modelMap);
+    }
+
+    /**
+     * Get the model class for a given morph type.
+     */
+    public static function getModelClass(string $morphType): ?string
+    {
+        return static::$modelMap[$morphType] ?? null;
+    }
+}
+`;
+    return [
+        baseFile(`${config.models.basePath}/BaseModel.php`, content),
+    ];
+}

package/ts-dist/php/factory-generator.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Port of FactoryGenerator.php — generates Model Factory classes.
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate Factory classes for all visible object schemas. */
+export declare function generateFactories(reader: SchemaReader, config: PhpConfig): GeneratedFile[];

package/ts-dist/php/factory-generator.js

@@ -0,0 +1,95 @@
+/**
+ * Port of FactoryGenerator.php — generates Model Factory classes.
+ */
+import { toPascalCase } from './naming-helper.js';
+import { toFaker, compoundFaker, associationFaker } from './faker-mapper.js';
+import { userFile } from './types.js';
+/** Generate Factory classes for all visible object schemas. */
+export function generateFactories(reader, config) {
+    const files = [];
+    const schemas = reader.getSchemas();
+    for (const [name, schema] of Object.entries(reader.getVisibleObjectSchemas())) {
+        const file = generateFactory(name, schema, reader, schemas, config);
+        if (file)
+            files.push(file);
+    }
+    return files;
+}
+function generateFactory(name, schema, reader, schemas, config) {
+    const modelName = toPascalCase(name);
+    const modelNamespace = config.models.namespace;
+    const factoryNamespace = config.factories.namespace;
+    const properties = (schema.properties ?? {});
+    const expandedProperties = reader.getExpandedProperties(name);
+    const propertyOrder = reader.getPropertyOrder(name);
+    const attributes = [];
+    const imports = [];
+    for (const propName of propertyOrder) {
+        const prop = properties[propName];
+        if (!prop)
+            continue;
+        const type = prop['type'] ?? 'String';
+        // Handle associations (foreign keys)
+        if (type === 'Association') {
+            const result = associationFaker(propName, prop, modelNamespace, name);
+            if (result) {
+                attributes.push(result.fake);
+                if (result.import)
+                    imports.push(result.import);
+            }
+            continue;
+        }
+        // Handle compound types
+        if (expandedProperties[propName]) {
+            const expansion = expandedProperties[propName];
+            const sourceType = expansion.sourceType ?? '';
+            const fakes = compoundFaker(propName, expansion, sourceType);
+            attributes.push(...fakes);
+            continue;
+        }
+        // Handle regular properties
+        const fake = toFaker(propName, prop, schemas);
+        if (fake)
+            attributes.push(fake);
+    }
+    const attributesStr = attributes.length > 0
+        ? attributes.map(a => `            ${a}`).join('\n')
+        : '';
+    const uniqueImports = [...new Set(imports)];
+    const importsStr = uniqueImports.length > 0
+        ? '\n' + uniqueImports.join('\n')
+        : '';
+    const content = `<?php
+
+namespace ${factoryNamespace};
+
+use ${modelNamespace}\\${modelName};
+use Illuminate\\Database\\Eloquent\\Factories\\Factory;
+${importsStr}
+
+/**
+ * ${modelName} Factory
+ *
+ * SAFE TO EDIT - This file is never overwritten by Omnify.
+ *
+ * @extends Factory<${modelName}>
+ */
+class ${modelName}Factory extends Factory
+{
+    protected $model = ${modelName}::class;
+
+    /**
+     * Define the model's default state.
+     *
+     * @return array<string, mixed>
+     */
+    public function definition(): array
+    {
+        return [
+${attributesStr}
+        ];
+    }
+}
+`;
+    return userFile(`${config.factories.path}/${modelName}Factory.php`, content);
+}

package/ts-dist/php/faker-mapper.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Port of FakerMapper.php — generates Faker expressions for factories.
+ */
+/** Generate faker expression for a property. */
+export declare function toFaker(propName: string, property: Record<string, unknown>, schemas?: Record<string, Record<string, unknown>>): string | null;
+/** Generate faker expressions for compound type expanded columns. */
+export declare function compoundFaker(propName: string, expansion: Record<string, unknown>, sourceType: string): string[];
+/** Generate faker for association (foreign key). */
+export declare function associationFaker(propName: string, property: Record<string, unknown>, modelNamespace: string, currentSchema: string): {
+    fake: string;
+    import: string | null;
+} | null;