@omnifyjp/omnify 0.2.3 → 0.3.0

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

@@ -0,0 +1,104 @@
+/**
+ * Port of TraitGenerator.php — generates HasLocalizedDisplayName trait.
+ */
+import { baseFile } from './types.js';
+/** Generate the HasLocalizedDisplayName trait. */
+export function generateTrait(config) {
+    const baseNamespace = config.models.baseNamespace;
+    const content = `<?php
+
+namespace ${baseNamespace}\\Traits;
+
+/**
+ * Trait for localized display names.
+ * Uses Laravel's app()->getLocale() for locale resolution.
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+trait HasLocalizedDisplayName
+{
+    /**
+     * Get the localized display name for this model.
+     *
+     * @param string|null $locale Locale code (defaults to app locale)
+     * @return string
+     */
+    public static function displayName(?string $locale = null): string
+    {
+        $locale = $locale ?? app()->getLocale();
+        $displayNames = static::$localizedDisplayNames ?? [];
+
+        return $displayNames[$locale]
+            ?? $displayNames[config('app.fallback_locale', 'en')]
+            ?? $displayNames[array_key_first($displayNames) ?? 'en']
+            ?? class_basename(static::class);
+    }
+
+    /**
+     * Get all localized display names for this model.
+     *
+     * @return array<string, string>
+     */
+    public static function allDisplayNames(): array
+    {
+        return static::$localizedDisplayNames ?? [];
+    }
+
+    /**
+     * Get the localized display name for a property.
+     *
+     * @param string $property Property name
+     * @param string|null $locale Locale code (defaults to app locale)
+     * @return string
+     */
+    public static function propertyDisplayName(string $property, ?string $locale = null): string
+    {
+        $locale = $locale ?? app()->getLocale();
+        $displayNames = static::$localizedPropertyDisplayNames[$property] ?? [];
+
+        return $displayNames[$locale]
+            ?? $displayNames[config('app.fallback_locale', 'en')]
+            ?? $displayNames[array_key_first($displayNames) ?? 'en']
+            ?? $property;
+    }
+
+    /**
+     * Get all localized display names for a property.
+     *
+     * @param string $property Property name
+     * @return array<string, string>
+     */
+    public static function allPropertyDisplayNames(string $property): array
+    {
+        return static::$localizedPropertyDisplayNames[$property] ?? [];
+    }
+
+    /**
+     * Get all property display names for a given locale.
+     *
+     * @param string|null $locale Locale code (defaults to app locale)
+     * @return array<string, string>
+     */
+    public static function allPropertyDisplayNamesForLocale(?string $locale = null): array
+    {
+        $locale = $locale ?? app()->getLocale();
+        $result = [];
+
+        foreach (static::$localizedPropertyDisplayNames ?? [] as $property => $displayNames) {
+            $result[$property] = $displayNames[$locale]
+                ?? $displayNames[config('app.fallback_locale', 'en')]
+                ?? $displayNames[array_key_first($displayNames) ?? 'en']
+                ?? $property;
+        }
+
+        return $result;
+    }
+}
+`;
+    return [
+        baseFile(`${config.models.basePath}/Traits/HasLocalizedDisplayName.php`, content),
+    ];
+}

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

@@ -0,0 +1,25 @@
+/**
+ * Port of TypeMapper.php — type mappings for PHP casts, rules, resources.
+ */
+type Rule = string | ['rule_in', string[]] | ['rule_unique_ignore', string, string];
+/** Map Omnify property type to PHP cast. */
+export declare function toCast(type: string, property?: Record<string, unknown>): string | null;
+/** Map Omnify property type to PHP doc type. */
+export declare function toPhpDocType(type: string, nullable?: boolean): string;
+/** Generate validation rules for a property (Store request). */
+export declare function toStoreRules(property: Record<string, unknown>, tableName: string): Rule[];
+/** Generate validation rules for a property (Update request). */
+export declare function toUpdateRules(property: Record<string, unknown>, tableName: string, modelRouteParam: string): Rule[];
+/** Format validation rules as PHP code string. */
+export declare function formatRules(rules: Rule[]): string;
+/** Resolve enum values from property definition. */
+export declare function resolveEnumValues(property: Record<string, unknown>): string[] | null;
+/** Check if a property type should be hidden by default. */
+export declare function isHiddenByDefault(type: string): boolean;
+/** Check if a property needs a cast. */
+export declare function needsCast(type: string): boolean;
+/** Get the resource output expression for a property. */
+export declare function toResourceExpression(fieldName: string, type: string): string;
+/** Check if a rules array contains a Rule:: object. */
+export declare function hasRuleObject(rules: Rule[]): boolean;
+export {};

package/ts-dist/php/type-mapper.js

@@ -0,0 +1,217 @@
+/**
+ * Port of TypeMapper.php — type mappings for PHP casts, rules, resources.
+ */
+import { toTableName } from './naming-helper.js';
+/** Map Omnify property type to PHP cast. */
+export function toCast(type, property = {}) {
+    switch (type) {
+        case 'Boolean': return 'boolean';
+        case 'Int':
+        case 'BigInt':
+        case 'TinyInt': return 'integer';
+        case 'Float': return 'float';
+        case 'Decimal': return `decimal:${property['scale'] ?? 2}`;
+        case 'Json': return 'array';
+        case 'Date': return 'date';
+        case 'DateTime':
+        case 'Timestamp': return 'datetime';
+        case 'Password': return 'hashed';
+        default: return null;
+    }
+}
+/** Map Omnify property type to PHP doc type. */
+export function toPhpDocType(type, nullable = false) {
+    let phpType;
+    switch (type) {
+        case 'String':
+        case 'Email':
+        case 'Password':
+        case 'Text':
+        case 'MediumText':
+        case 'LongText':
+        case 'Enum':
+        case 'EnumRef':
+        case 'Uuid':
+        case 'Slug':
+        case 'Url':
+        case 'Phone':
+            phpType = 'string';
+            break;
+        case 'Int':
+        case 'BigInt':
+        case 'TinyInt':
+            phpType = 'int';
+            break;
+        case 'Float':
+        case 'Decimal':
+            phpType = 'float';
+            break;
+        case 'Boolean':
+            phpType = 'bool';
+            break;
+        case 'Date':
+        case 'DateTime':
+        case 'Timestamp':
+        case 'Time':
+            phpType = 'mixed';
+            break;
+        case 'Json':
+            phpType = 'array';
+            break;
+        default:
+            phpType = 'mixed';
+    }
+    return nullable ? `${phpType}|null` : phpType;
+}
+/** Generate validation rules for a property (Store request). */
+export function toStoreRules(property, tableName) {
+    const type = property['type'] ?? 'String';
+    const nullable = property['nullable'] ?? false;
+    const unique = property['unique'] ?? false;
+    const rules = [];
+    rules.push(nullable ? 'nullable' : 'required');
+    switch (type) {
+        case 'String':
+        case 'Slug':
+        case 'Url':
+        case 'Phone': {
+            rules.push('string');
+            const length = property['length'] ?? 255;
+            rules.push(`max:${length}`);
+            break;
+        }
+        case 'Email':
+            rules.push('string', 'max:255', 'email');
+            if (unique)
+                rules.push(`unique:${tableName}`);
+            break;
+        case 'Password':
+            rules.push('string', 'max:255');
+            break;
+        case 'Text':
+        case 'MediumText':
+        case 'LongText':
+            rules.push('string');
+            break;
+        case 'Int':
+        case 'BigInt':
+        case 'TinyInt':
+            rules.push('integer');
+            break;
+        case 'Float':
+        case 'Decimal':
+            rules.push('numeric');
+            break;
+        case 'Boolean':
+            rules.push('boolean');
+            break;
+        case 'Date':
+        case 'DateTime':
+        case 'Timestamp':
+        case 'Time':
+            rules.push('date');
+            break;
+        case 'Json':
+            rules.push('array');
+            break;
+        case 'Uuid':
+            rules.push('string', 'uuid');
+            break;
+        case 'Enum': {
+            rules.push('string');
+            const enumValues = resolveEnumValues(property);
+            if (enumValues)
+                rules.push(['rule_in', enumValues]);
+            break;
+        }
+        case 'EnumRef':
+            rules.push('string');
+            break;
+        case 'Association': {
+            const relation = property['relation'] ?? '';
+            if (relation === 'ManyToOne') {
+                rules.push('integer');
+                const target = property['target'] ?? '';
+                if (target)
+                    rules.push(`exists:${toTableName(target)},id`);
+            }
+            break;
+        }
+        default:
+            rules.push('string', 'max:255');
+    }
+    if (unique && type !== 'Email') {
+        rules.push(`unique:${tableName}`);
+    }
+    return rules;
+}
+/** Generate validation rules for a property (Update request). */
+export function toUpdateRules(property, tableName, modelRouteParam) {
+    let rules = toStoreRules(property, tableName);
+    const unique = property['unique'] ?? false;
+    // Replace 'required' with 'sometimes'
+    rules = rules.map(r => r === 'required' ? 'sometimes' : r);
+    // Replace simple unique with Rule::unique()->ignore()
+    if (unique) {
+        rules = rules.filter(r => !(typeof r === 'string' && r === `unique:${tableName}`));
+        rules.push(['rule_unique_ignore', tableName, modelRouteParam]);
+    }
+    return rules;
+}
+/** Format validation rules as PHP code string. */
+export function formatRules(rules) {
+    const parts = [];
+    for (const rule of rules) {
+        if (typeof rule === 'string') {
+            parts.push(`'${rule}'`);
+        }
+        else if (Array.isArray(rule)) {
+            if (rule[0] === 'rule_in') {
+                const values = rule[1].map(v => `'${v}'`).join(', ');
+                parts.push(`Rule::in([${values}])`);
+            }
+            else if (rule[0] === 'rule_unique_ignore') {
+                parts.push(`Rule::unique('${rule[1]}')->ignore($this->route('${rule[2]}'))`);
+            }
+        }
+    }
+    return `[${parts.join(', ')}]`;
+}
+/** Resolve enum values from property definition. */
+export function resolveEnumValues(property) {
+    const enumDef = property['enum'];
+    if (enumDef == null)
+        return null;
+    if (Array.isArray(enumDef)) {
+        const values = [];
+        for (const v of enumDef) {
+            if (typeof v === 'string')
+                values.push(v);
+            else if (typeof v === 'object' && v !== null && 'value' in v)
+                values.push(v.value);
+        }
+        return values.length > 0 ? values : null;
+    }
+    return null;
+}
+/** Check if a property type should be hidden by default. */
+export function isHiddenByDefault(type) {
+    return type === 'Password';
+}
+/** Check if a property needs a cast. */
+export function needsCast(type) {
+    return toCast(type) !== null;
+}
+/** Get the resource output expression for a property. */
+export function toResourceExpression(fieldName, type) {
+    switch (type) {
+        case 'Date': return `$this->${fieldName}?->toDateString()`;
+        case 'DateTime':
+        case 'Timestamp': return `$this->${fieldName}?->toISOString()`;
+        default: return `$this->${fieldName}`;
+    }
+}
+/** Check if a rules array contains a Rule:: object. */
+export function hasRuleObject(rules) {
+    return rules.some(r => Array.isArray(r) && ['rule_in', 'rule_unique_ignore'].includes(r[0]));
+}

package/ts-dist/php/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Types for PHP code generation output.
+ */
+/** A generated PHP file. */
+export interface GeneratedFile {
+    readonly path: string;
+    readonly content: string;
+    readonly overwrite: boolean;
+    readonly type: 'base' | 'user';
+}
+/** Create a base file (always overwritten). */
+export declare function baseFile(path: string, content: string): GeneratedFile;
+/** Create a user file (created once, skip if exists). */
+export declare function userFile(path: string, content: string): GeneratedFile;
+/** Per-target path and namespace override from codegen.laravel config. */
+export interface LaravelPathOverride {
+    path?: string;
+    namespace?: string;
+}
+/** Overrides from codegen.laravel YAML config (all optional). */
+export interface LaravelCodegenOverrides {
+    model?: LaravelPathOverride;
+    request?: LaravelPathOverride;
+    resource?: LaravelPathOverride;
+    factory?: LaravelPathOverride;
+    provider?: LaravelPathOverride;
+}
+/** PHP codegen configuration (resolved with defaults). */
+export interface PhpConfig {
+    models: {
+        namespace: string;
+        baseNamespace: string;
+        path: string;
+        basePath: string;
+    };
+    requests: {
+        namespace: string;
+        baseNamespace: string;
+        path: string;
+        basePath: string;
+    };
+    resources: {
+        namespace: string;
+        baseNamespace: string;
+        path: string;
+        basePath: string;
+    };
+    factories: {
+        namespace: string;
+        path: string;
+    };
+    providers: {
+        namespace: string;
+        path: string;
+    };
+}
+/**
+ * Derive full PHP config from optional overrides.
+ * All paths and namespaces fall back to sensible defaults.
+ */
+export declare function derivePhpConfig(overrides?: LaravelCodegenOverrides): PhpConfig;

package/ts-dist/php/types.js

@@ -0,0 +1,68 @@
+/**
+ * Types for PHP code generation output.
+ */
+/** Create a base file (always overwritten). */
+export function baseFile(path, content) {
+    return { path, content, overwrite: true, type: 'base' };
+}
+/** Create a user file (created once, skip if exists). */
+export function userFile(path, content) {
+    return { path, content, overwrite: false, type: 'user' };
+}
+/** Convert a file path to a PHP namespace (e.g., app/Models/Omnify → App\Models\Omnify). */
+function pathToNamespace(p) {
+    return p
+        .split('/')
+        .map(s => s.charAt(0).toUpperCase() + s.slice(1))
+        .join('\\');
+}
+// Default paths
+const DEFAULT_MODEL_PATH = 'app/Models/Omnify';
+const DEFAULT_REQUEST_PATH = 'app/Http/Requests';
+const DEFAULT_RESOURCE_PATH = 'app/Http/Resources';
+const DEFAULT_FACTORY_PATH = 'database/factories';
+const DEFAULT_PROVIDER_PATH = 'app/Providers';
+/**
+ * Derive full PHP config from optional overrides.
+ * All paths and namespaces fall back to sensible defaults.
+ */
+export function derivePhpConfig(overrides) {
+    const modelPath = overrides?.model?.path ?? DEFAULT_MODEL_PATH;
+    const modelNs = overrides?.model?.namespace ?? pathToNamespace(modelPath);
+    const requestPath = overrides?.request?.path ?? DEFAULT_REQUEST_PATH;
+    const requestNs = overrides?.request?.namespace ?? pathToNamespace(requestPath);
+    const resourcePath = overrides?.resource?.path ?? DEFAULT_RESOURCE_PATH;
+    const resourceNs = overrides?.resource?.namespace ?? pathToNamespace(resourcePath);
+    const factoryPath = overrides?.factory?.path ?? DEFAULT_FACTORY_PATH;
+    const factoryNs = overrides?.factory?.namespace ?? pathToNamespace(factoryPath);
+    const providerPath = overrides?.provider?.path ?? DEFAULT_PROVIDER_PATH;
+    const providerNs = overrides?.provider?.namespace ?? pathToNamespace(providerPath);
+    return {
+        models: {
+            namespace: modelNs,
+            baseNamespace: `${modelNs}\\Base`,
+            path: modelPath,
+            basePath: `${modelPath}/Base`,
+        },
+        requests: {
+            namespace: requestNs,
+            baseNamespace: `${requestNs}\\OmnifyBase`,
+            path: requestPath,
+            basePath: `${requestPath}/OmnifyBase`,
+        },
+        resources: {
+            namespace: resourceNs,
+            baseNamespace: `${resourceNs}\\OmnifyBase`,
+            path: resourcePath,
+            basePath: `${resourcePath}/OmnifyBase`,
+        },
+        factories: {
+            namespace: factoryNs,
+            path: factoryPath,
+        },
+        providers: {
+            namespace: providerNs,
+            path: providerPath,
+        },
+    };
+}

package/types/config.d.ts

@@ -6,39 +6,63 @@ export type DatabaseDriver = "mysql" | "pgsql" | "postgres" | "sqlite";
 /** SQL dialect for generated migrations. */
 export type SQLDialect = "mysql" | "postgresql" | "sqlite";
 
-/** Laravel output configuration. */
-export interface LaravelOutputConfig {
-  /** Directory for Laravel migration files. */
-  migrationsPath: string;
-  /** Path for exported schemas JSON (used by omnify-php-laravel). */
-  schemasPath?: string;
-}
+/** Migration type identifier. */
+export type MigrationType = "laravel" | "sql";
 
-/** Raw SQL output configuration. */
-export interface SQLOutputConfig {
-  /** Directory for SQL migration files. */
+/** Per-migration output configuration. */
+export interface MigrationConfig {
+  /** Migration output type. */
+  type: MigrationType;
+  /** Output directory for migration files. */
   path: string;
-  /** SQL dialect for generated migrations. */
+  /** Path for exported schemas JSON (laravel only). */
+  schemasPath?: string;
+  /** SQL dialect for generated migrations (sql only). */
   dialect?: SQLDialect;
 }
 
-/** TypeScript output configuration. */
-export interface TypeScriptOutputConfig {
-  /** Directory for generated TypeScript model files. */
-  path: string;
+/** Per-connection database and migration configuration. */
+export interface ConnectionConfig {
+  driver: DatabaseDriver;
+  migrations?: MigrationConfig[];
 }
 
-/** All output configurations for a connection. */
-export interface OutputConfig {
-  laravel?: LaravelOutputConfig;
-  sql?: SQLOutputConfig;
-  typescript?: TypeScriptOutputConfig;
+/** TypeScript codegen configuration. */
+export interface CodegenTypeScriptConfig {
+  /** Enable TypeScript codegen. Defaults to false. */
+  enable: boolean;
+  /** Output directory for generated TypeScript model files. */
+  modelsPath: string;
 }
 
-/** Per-connection database and output configuration. */
-export interface ConnectionConfig {
-  driver: DatabaseDriver;
-  output: OutputConfig;
+/** Laravel codegen path configuration for a target (model, request, etc.). */
+export interface CodegenLaravelPathConfig {
+  /** Output directory path. */
+  path?: string;
+  /** PHP namespace. Defaults to namespace derived from path. */
+  namespace?: string;
+}
+
+/** Laravel PHP codegen configuration. */
+export interface CodegenLaravelConfig {
+  /** Enable Laravel codegen. Defaults to false. */
+  enable: boolean;
+  /** Model output configuration. */
+  model?: CodegenLaravelPathConfig;
+  /** Request output configuration. */
+  request?: CodegenLaravelPathConfig;
+  /** Resource output configuration. */
+  resource?: CodegenLaravelPathConfig;
+  /** Factory output configuration. */
+  factory?: CodegenLaravelPathConfig;
+  /** Provider output configuration. */
+  provider?: CodegenLaravelPathConfig;
+}
+
+/** Code generation configuration (connection-independent). */
+export interface CodegenConfig {
+  typescript?: CodegenTypeScriptConfig;
+  laravel?: CodegenLaravelConfig;
 }
 
 /** Additional schema directory to load. */
@@ -65,6 +89,8 @@ export interface OmnifyConfig {
   locale?: LocaleConfig;
   /** Built-in compound type packs to enable (e.g. "japan"). */
   compoundTypes?: string[];
+  /** Code generation configuration (connection-independent). */
+  codegen?: CodegenConfig;
   /** Enable verbose output during generation. */
   verbose?: boolean;
 }