@omnifyjp/omnify 3.5.0 → 3.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/omnify",
-  "version": "3.5.0",
+  "version": "3.6.0",
   "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": "3.5.0",
-    "@omnifyjp/omnify-darwin-x64": "3.5.0",
-    "@omnifyjp/omnify-linux-x64": "3.5.0",
-    "@omnifyjp/omnify-linux-arm64": "3.5.0",
-    "@omnifyjp/omnify-win32-x64": "3.5.0"
+    "@omnifyjp/omnify-darwin-arm64": "3.6.0",
+    "@omnifyjp/omnify-darwin-x64": "3.6.0",
+    "@omnifyjp/omnify-linux-x64": "3.6.0",
+    "@omnifyjp/omnify-linux-arm64": "3.6.0",
+    "@omnifyjp/omnify-win32-x64": "3.6.0"
   }
 }

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

@@ -0,0 +1,19 @@
+/**
+ * Generates PHP enum classes for `kind: enum` schemas.
+ *
+ * Issue #34: every enum schema becomes a self-contained PHP 8.1+ backed enum
+ * placed in the global Omnify enums namespace (default `App\Omnify\Enums`).
+ * Localized labels from the schema are embedded as a `LABELS` constant so
+ * the generated enum is usable without setting up Laravel translation files.
+ *
+ * Class name convention: `{SchemaName}Enum.php` (e.g. schema `MenuStatus` →
+ * `MenuStatusEnum`). The trailing `Enum` suffix is intentional — it prevents
+ * collisions with model classes of the same base name and signals "this is an
+ * enum class" at every callsite (`MenuStatusEnum::Draft`).
+ */
+import { SchemaReader } from './schema-reader.js';
+import type { GeneratedFile, PhpConfig } from './types.js';
+/** Generate one PHP enum class for each `kind: enum` schema. */
+export declare function generateEnums(reader: SchemaReader, config: PhpConfig): GeneratedFile[];
+/** Convert a schema name (e.g. `MenuStatus`) to its enum class name (`MenuStatusEnum`). */
+export declare function enumClassName(schemaName: string): string;

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

@@ -0,0 +1,165 @@
+/**
+ * Generates PHP enum classes for `kind: enum` schemas.
+ *
+ * Issue #34: every enum schema becomes a self-contained PHP 8.1+ backed enum
+ * placed in the global Omnify enums namespace (default `App\Omnify\Enums`).
+ * Localized labels from the schema are embedded as a `LABELS` constant so
+ * the generated enum is usable without setting up Laravel translation files.
+ *
+ * Class name convention: `{SchemaName}Enum.php` (e.g. schema `MenuStatus` →
+ * `MenuStatusEnum`). The trailing `Enum` suffix is intentional — it prevents
+ * collisions with model classes of the same base name and signals "this is an
+ * enum class" at every callsite (`MenuStatusEnum::Draft`).
+ */
+import { toPascalCase } from './naming-helper.js';
+import { baseFile, resolveGlobalEnumPath, resolveGlobalEnumNamespace } from './types.js';
+/** Generate one PHP enum class for each `kind: enum` schema. */
+export function generateEnums(reader, config) {
+    const files = [];
+    for (const [name, schema] of Object.entries(reader.getEnumSchemas())) {
+        // Skip package-owned enums — those are generated by their owning package's
+        // codegen, not the host project's. Mirrors how object schemas are filtered
+        // by `getProjectObjectSchemas()` elsewhere.
+        if (schema.package != null)
+            continue;
+        files.push(generateEnumClass(name, schema, config));
+    }
+    return files;
+}
+function generateEnumClass(name, schema, config) {
+    const className = enumClassName(name);
+    const namespace = resolveGlobalEnumNamespace(config, config.models.namespace);
+    const values = (schema.values ?? []);
+    const cases = values.map(v => buildCase(v));
+    const labelsConst = buildLabelsConstant(values);
+    const content = `<?php
+
+namespace ${namespace};
+
+/**
+ * ${name}${schema.displayName ? ` — ${pickDefaultLabel(schema.displayName)}` : ''}
+ *
+ * DO NOT EDIT - This file is auto-generated by Omnify.
+ * Any changes will be overwritten on next generation.
+ *
+ * @generated by omnify
+ */
+enum ${className}: string
+{
+${cases.map(c => `    ${c}`).join('\n')}
+
+${labelsConst}
+
+    /**
+     * Get the localized label for this enum case.
+     *
+     * Falls back to the configured app fallback locale, then any defined
+     * locale, then the raw value if no labels were declared in the schema.
+     */
+    public function label(?string $locale = null): string
+    {
+        $locale = $locale ?? app()->getLocale();
+        $labels = static::LABELS[$this->value] ?? [];
+
+        return $labels[$locale]
+            ?? $labels[config('app.fallback_locale', 'en')]
+            ?? $labels[array_key_first($labels) ?? 'en']
+            ?? $this->value;
+    }
+
+    /**
+     * Get all enum values as a flat list.
+     *
+     * @return array<int, string>
+     */
+    public static function values(): array
+    {
+        return array_column(self::cases(), 'value');
+    }
+
+    /**
+     * Get an array of value → localized label suitable for select dropdowns.
+     *
+     * @return array<string, string>
+     */
+    public static function options(?string $locale = null): array
+    {
+        $out = [];
+        foreach (self::cases() as $case) {
+            $out[$case->value] = $case->label($locale);
+        }
+        return $out;
+    }
+}
+`;
+    return baseFile(resolveGlobalEnumPath(config, `${className}.php`, config.models.path), content);
+}
+/** Convert a schema name (e.g. `MenuStatus`) to its enum class name (`MenuStatusEnum`). */
+export function enumClassName(schemaName) {
+    const pascal = toPascalCase(schemaName);
+    return pascal.endsWith('Enum') ? pascal : `${pascal}Enum`;
+}
+/** Build a single `case Foo = 'foo';` line from a schema enum value. */
+function buildCase(v) {
+    const value = v.value;
+    return `case ${toPhpCaseName(value)} = '${escapePhpString(value)}';`;
+}
+/**
+ * Convert an enum value into a valid PHP case identifier. PHP case names must
+ * start with a letter or underscore and contain only `[A-Za-z0-9_]`. We map
+ * everything else through PascalCase and prefix a digit-leading name with
+ * `Case` so it's still legal.
+ */
+function toPhpCaseName(value) {
+    const cleaned = value
+        .replace(/[^A-Za-z0-9_]+/g, '_')
+        .split('_')
+        .filter(Boolean)
+        .map(part => part.charAt(0).toUpperCase() + part.slice(1))
+        .join('');
+    if (!cleaned)
+        return 'Unknown';
+    return /^[0-9]/.test(cleaned) ? `Case${cleaned}` : cleaned;
+}
+/** Build the `LABELS` constant containing every locale label for every value. */
+function buildLabelsConstant(values) {
+    const lines = [];
+    lines.push('    /**');
+    lines.push('     * Localized labels for each case, embedded directly so the generated enum');
+    lines.push('     * is self-contained and works without Laravel translation files.');
+    lines.push('     *');
+    lines.push('     * @var array<string, array<string, string>>');
+    lines.push('     */');
+    lines.push('    public const LABELS = [');
+    for (const v of values) {
+        const rawLabel = v.label;
+        // `label` can be either a plain string or a `{locale: text}` map. Normalize.
+        const labels = typeof rawLabel === 'string'
+            ? { en: rawLabel }
+            : (rawLabel ?? {});
+        const entries = Object.entries(labels);
+        if (entries.length === 0) {
+            lines.push(`        '${escapePhpString(v.value)}' => [],`);
+            continue;
+        }
+        const inner = entries
+            .map(([loc, txt]) => `'${escapePhpString(loc)}' => '${escapePhpString(String(txt))}'`)
+            .join(', ');
+        lines.push(`        '${escapePhpString(v.value)}' => [${inner}],`);
+    }
+    lines.push('    ];');
+    return lines.join('\n');
+}
+/** Pick a sensible default label from a localized string for the doc comment. */
+function pickDefaultLabel(displayName) {
+    if (typeof displayName === 'string')
+        return displayName;
+    return (displayName.en ??
+        displayName.ja ??
+        Object.values(displayName)[0] ??
+        '');
+}
+/** Escape single quotes and backslashes for inclusion in a PHP single-quoted string. */
+function escapePhpString(value) {
+    return value.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}

package/ts-dist/php/index.js

@@ -30,6 +30,7 @@ import { baseFile } from './types.js';
 import { generateControllers } from './controller-generator.js';
 import { generateServices } from './service-generator.js';
 import { generateRoutes } from './route-generator.js';
+import { generateEnums } from './enum-generator.js';
 export { derivePhpConfig } from './types.js';
 /** Generate all PHP files from schemas.json data. */
 export function generatePhp(data, overrides) {
@@ -61,6 +62,8 @@ export function generatePhp(data, overrides) {
         files.push(...generateServices(reader, config));
         files.push(...generateRoutes(reader, config));
     }
+    // Issue #34: every `kind: enum` schema becomes a global PHP enum class.
+    files.push(...generateEnums(reader, config));
     // Per-schema files
     files.push(...generateLocales(reader, config));
     files.push(...generateModels(reader, config));

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

@@ -4,7 +4,8 @@
 import { toPascalCase, toSnakeCase, toCamelCase } from './naming-helper.js';
 import { toCast, toPhpDocType, isHiddenByDefault } from './type-mapper.js';
 import { buildRelation } from './relation-builder.js';
-import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, } from './types.js';
+import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace, resolveSharedBaseNamespace, resolveGlobalTraitNamespace, resolveGlobalEnumNamespace, } from './types.js';
+import { enumClassName } from './enum-generator.js';
 /** Generate base model and user model for all project-owned object schemas,
  *  plus user models for package schemas (extending the package model). */
 export function generateModels(reader, config) {
@@ -71,7 +72,7 @@ function generateBaseModel(name, schema, reader, config) {
     const fillable = buildFillable(properties, expandedProperties, propertyOrder);
     const hidden = buildHidden(properties, expandedProperties, propertyOrder);
     const appends = buildAppends(expandedProperties);
-    const casts = buildCasts(properties, expandedProperties, propertyOrder, reader);
+    const casts = buildCasts(properties, expandedProperties, propertyOrder, reader, config);
     const relations = buildRelations(name, properties, propertyOrder, modelNamespace, reader);
     const accessors = buildAccessors(expandedProperties);
     const fileAccessors = hasFiles ? buildFileAccessors(properties, propertyOrder, modelNamespace) : '';
@@ -253,9 +254,14 @@ function buildImports(baseNamespace, modelName, hasSoftDelete, isAuthenticatable
     lines.push(`use ${traitsNamespace || baseNamespace + '\\Traits'}\\HasLocalizedDisplayName;`);
     lines.push(`use ${localesNamespace || baseNamespace + '\\Locales'}\\${modelName}Locales;`);
     if (hasFiles) {
-        // HasFiles lives in File module, not Shared
+        // Issue #33 followup: HasFiles is a global Omnify trait — see
+        // file-trait-generator.ts. The trait now lives at
+        // `app/Omnify/Traits/HasFiles.php` (namespace `App\Omnify\Traits`),
+        // not under per-module `Modules/File/Traits/`. The import statement
+        // here must match, otherwise generated models crash with
+        // `Trait "App\Omnify\Modules\File\Traits\HasFiles" not found`.
         const fileTraitsNs = config
-            ? resolveModularBaseNamespace(config, 'File', 'Traits', baseNamespace + '\\Traits')
+            ? resolveGlobalTraitNamespace(config, baseNamespace + '\\Traits')
             : (traitsNamespace || baseNamespace + '\\Traits');
         lines.push(`use ${fileTraitsNs}\\HasFiles;`);
         if (modelNamespace) {
@@ -423,13 +429,29 @@ function buildAppends(expandedProperties) {
         return '';
     return appends.map(a => `        '${a}',`).join('\n') + '\n';
 }
-function buildCasts(properties, expandedProperties, propertyOrder, reader) {
+function buildCasts(properties, expandedProperties, propertyOrder, reader, config) {
     const casts = [];
+    // Issue #34: cast `EnumRef` properties to their generated PHP enum class.
+    // Use a fully-qualified `\Namespace\FooEnum::class` reference so we don't
+    // need to track imports — Laravel resolves the enum cast by class name.
+    const globalEnumNs = config
+        ? resolveGlobalEnumNamespace(config, config.models.namespace)
+        : '';
     for (const propName of propertyOrder) {
         const prop = properties[propName];
         if (!prop)
             continue;
         const type = prop['type'] ?? 'String';
+        // EnumRef → cast to generated enum class (only when the referenced enum
+        // schema actually exists; otherwise fall through to a plain string).
+        if (type === 'EnumRef') {
+            const enumName = prop['enum'];
+            if (typeof enumName === 'string' && reader.getSchema(enumName)?.kind === 'enum' && globalEnumNs) {
+                const snakeName = toSnakeCase(propName);
+                casts.push(`'${snakeName}' => \\${globalEnumNs}\\${enumClassName(enumName)}::class,`);
+                continue;
+            }
+        }
         if (type === 'Association') {
             const relation = prop['relation'] ?? '';
             if (relation === 'ManyToOne') {