@omnifyjp/ts 0.3.0

package/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/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/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/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/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/dist/types.d.ts

@@ -0,0 +1,196 @@
+/**
+ * @omnify/ts — Internal types
+ *
+ * Types for schemas.json input and TypeScript code generation output.
+ */
+/** Localized string — either a plain string or a locale map. */
+export type LocalizedString = string | Record<string, string>;
+/** Top-level schemas.json structure. */
+export interface SchemasJson {
+    readonly generatedAt: string;
+    readonly database: {
+        readonly driver: string;
+    };
+    readonly connections: Record<string, string>;
+    readonly locale: {
+        readonly locales: string[];
+        readonly defaultLocale: string;
+        readonly fallbackLocale: string;
+    };
+    readonly customTypes: {
+        readonly compound: Record<string, CompoundTypeDefinition>;
+        readonly simple: Record<string, SimpleTypeDefinition>;
+        readonly enums: Record<string, string[]>;
+    };
+    readonly schemas: Record<string, SchemaDefinition>;
+}
+/** Compound type definition (e.g., JapaneseName). */
+export interface CompoundTypeDefinition {
+    readonly fields: readonly CompoundField[];
+}
+/** A field within a compound type. */
+export interface CompoundField {
+    readonly suffix: string;
+    readonly mapsTo?: string;
+    readonly length?: number;
+    readonly nullable?: boolean;
+    readonly enumRef?: string;
+}
+/** Simple custom type (e.g., JapanesePhone). */
+export interface SimpleTypeDefinition {
+    readonly mapsTo: string;
+    readonly length?: number;
+}
+/** Expanded property info (pre-computed by omnify-go). */
+export interface ExpandedProperty {
+    readonly sourceType: string;
+    readonly columns: readonly ExpandedColumn[];
+}
+/** A single expanded column from a compound type. */
+export interface ExpandedColumn {
+    readonly name: string;
+    readonly suffix: string;
+    readonly type: string;
+    readonly length?: number;
+    readonly nullable?: boolean;
+    readonly enum?: readonly string[];
+}
+/** Schema options. */
+export interface SchemaOptions {
+    readonly id?: boolean;
+    readonly idType?: string;
+    readonly timestamps?: boolean;
+    readonly softDelete?: boolean;
+    readonly hidden?: boolean;
+    readonly tableName?: string;
+    readonly indexes?: readonly unknown[];
+    readonly unique?: readonly unknown[];
+}
+/** Schema definition from schemas.json. */
+export interface SchemaDefinition {
+    readonly name: string;
+    readonly tableName?: string;
+    readonly connection?: string;
+    readonly displayName?: LocalizedString;
+    readonly group?: string;
+    readonly kind?: 'object' | 'enum' | 'pivot' | 'partial' | 'extend';
+    readonly options?: SchemaOptions;
+    readonly properties?: Record<string, PropertyDefinition>;
+    readonly propertyOrder?: readonly string[];
+    readonly expandedProperties?: Record<string, ExpandedProperty>;
+    readonly values?: readonly EnumValueDefinition[];
+    readonly pivotFor?: readonly string[];
+}
+/** Property definition within a schema. */
+export interface PropertyDefinition {
+    readonly type: string;
+    readonly displayName?: LocalizedString;
+    readonly description?: LocalizedString;
+    readonly placeholder?: LocalizedString;
+    readonly nullable?: boolean;
+    readonly unique?: boolean;
+    readonly primary?: boolean;
+    readonly default?: unknown;
+    readonly length?: number;
+    readonly minLength?: number;
+    readonly maxLength?: number;
+    readonly min?: number;
+    readonly max?: number;
+    readonly unsigned?: boolean;
+    readonly precision?: number;
+    readonly scale?: number;
+    readonly pattern?: string;
+    readonly enum?: string | readonly string[];
+    readonly relation?: string;
+    readonly target?: string;
+    readonly targets?: readonly string[];
+    readonly onDelete?: string;
+    readonly morphName?: string;
+    readonly joinTable?: string;
+    readonly mappedBy?: string;
+    readonly useCurrent?: boolean;
+    readonly fields?: Record<string, FieldOverride>;
+}
+/** Field override for compound type properties. */
+export interface FieldOverride {
+    readonly nullable?: boolean;
+    readonly length?: number;
+    readonly hidden?: boolean;
+    readonly displayName?: LocalizedString;
+    readonly placeholder?: LocalizedString;
+}
+/** Enum value definition (for schema enums). */
+export interface EnumValueDefinition {
+    readonly value: string;
+    readonly label?: LocalizedString;
+    readonly extra?: Record<string, unknown>;
+}
+/** File category for organizing output. */
+export type FileCategory = 'schema' | 'base' | 'enum' | 'plugin-enum';
+/** Generated TypeScript file. */
+export interface TypeScriptFile {
+    readonly filePath: string;
+    readonly content: string;
+    readonly types: readonly string[];
+    readonly overwrite: boolean;
+    readonly category?: FileCategory;
+}
+/** TypeScript property definition. */
+export interface TSProperty {
+    readonly name: string;
+    readonly type: string;
+    readonly optional: boolean;
+    readonly readonly: boolean;
+    readonly comment?: string;
+}
+/** TypeScript interface definition. */
+export interface TSInterface {
+    readonly name: string;
+    readonly properties: readonly TSProperty[];
+    readonly extends?: readonly string[];
+    readonly comment?: string;
+    readonly dependencies?: readonly string[];
+    readonly enumDependencies?: readonly string[];
+}
+/** TypeScript enum definition. */
+export interface TSEnum {
+    readonly name: string;
+    readonly values: readonly TSEnumValue[];
+    readonly comment?: string;
+}
+/** Multi-locale string map. */
+export type LocaleMap = Record<string, string>;
+/** TypeScript enum value. */
+export interface TSEnumValue {
+    readonly name: string;
+    readonly value: string | number;
+    readonly label?: string | LocaleMap;
+    readonly extra?: Record<string, unknown>;
+}
+/** TypeScript type alias definition. */
+export interface TSTypeAlias {
+    readonly name: string;
+    readonly type: string;
+    readonly comment?: string;
+}
+/** Zod schema information for a property. */
+export interface ZodPropertySchema {
+    readonly fieldName: string;
+    readonly schema: string;
+    readonly inCreate: boolean;
+    readonly inUpdate: boolean;
+    readonly comment?: string;
+}
+/** Display names for a schema. */
+export interface SchemaDisplayNames {
+    readonly displayName: LocaleMap;
+    readonly propertyDisplayNames: Record<string, LocaleMap>;
+    readonly propertyPlaceholders: Record<string, LocaleMap>;
+}
+/** Generation options (internal). */
+export interface GeneratorOptions {
+    readonly locales: string[];
+    readonly defaultLocale: string;
+    readonly fallbackLocale: string;
+    readonly customTypes: SchemasJson['customTypes'];
+}

package/dist/types.js

@@ -0,0 +1,6 @@
+/**
+ * @omnify/ts — Internal types
+ *
+ * Types for schemas.json input and TypeScript code generation output.
+ */
+export {};