@omnifyjp/ts 4.10.0 → 5.0.1

package/dist/php/schema-reader.d.ts

@@ -6,6 +6,9 @@ export declare class SchemaReader {
     private data;
     constructor(data: SchemasJson);
     static fromData(data: SchemasJson): SchemaReader;
+    /** Returns the raw root document — needed by generators that read
+     * top-level config like locale.enforceLanguageFk. */
+    getRoot(): SchemasJson;
     getSchemas(): Record<string, SchemaDefinition>;
     getSchema(name: string): SchemaDefinition | undefined;
     getObjectSchemas(): Record<string, SchemaDefinition>;
@@ -41,6 +44,7 @@ export declare class SchemaReader {
         readonly locales: string[];
         readonly defaultLocale: string;
         readonly fallbackLocale: string;
+        readonly enforceLanguageFk?: boolean;
     };
     getLocales(): string[];
     getDefaultLocale(): string;
@@ -72,4 +76,15 @@ export declare class SchemaReader {
     hasServiceSchemas(): boolean;
     /** Get translatable field names (snake_case) for a schema. */
     getTranslatableFields(schemaName: string): string[];
+    /**
+     * Get translatable fields with type info (snake_case name + the
+     * declared property type). Used by translation-model-generator to
+     * emit `$casts` for non-string types — without these the model
+     * returns raw strings for Json / Boolean / Int columns and Eloquent
+     * accessors break at runtime.
+     */
+    getTranslatableFieldDetails(schemaName: string): Array<{
+        name: string;
+        type: string;
+    }>;
 }

package/dist/php/schema-reader.js

@@ -9,6 +9,11 @@ export class SchemaReader {
     static fromData(data) {
         return new SchemaReader(data);
     }
+    /** Returns the raw root document — needed by generators that read
+     * top-level config like locale.enforceLanguageFk. */
+    getRoot() {
+        return this.data;
+    }
     // ---------------------------------------------------------------------------
     // All schemas (project + package)
     // ---------------------------------------------------------------------------
@@ -225,6 +230,16 @@ export class SchemaReader {
     }
     /** Get translatable field names (snake_case) for a schema. */
     getTranslatableFields(schemaName) {
+        return this.getTranslatableFieldDetails(schemaName).map((f) => f.name);
+    }
+    /**
+     * Get translatable fields with type info (snake_case name + the
+     * declared property type). Used by translation-model-generator to
+     * emit `$casts` for non-string types — without these the model
+     * returns raw strings for Json / Boolean / Int columns and Eloquent
+     * accessors break at runtime.
+     */
+    getTranslatableFieldDetails(schemaName) {
         const schema = this.getSchema(schemaName);
         if (!schema?.properties)
             return [];
@@ -233,8 +248,8 @@ export class SchemaReader {
         for (const propName of propertyOrder) {
             const prop = schema.properties[propName];
             if (prop?.translatable) {
-                // Convert to snake_case
-                fields.push(propName.replace(/([A-Z])/g, (_, c, i) => (i > 0 ? '_' : '') + c.toLowerCase()));
+                const snake = propName.replace(/([A-Z])/g, (_, c, i) => (i > 0 ? '_' : '') + c.toLowerCase());
+                fields.push({ name: snake, type: prop.type ?? 'String' });
             }
         }
         return fields;

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

@@ -12,23 +12,77 @@ import { baseFile, userFile, resolveModularBasePath, resolveModularBaseNamespace
 /** Generate translation model files for all project schemas with translatable fields. */
 export function generateTranslationModels(reader, config) {
     const files = [];
+    const enforceLanguageFk = reader.getRoot().locale?.enforceLanguageFk === true;
     for (const [name] of Object.entries(reader.getProjectObjectSchemas())) {
-        const translatableFields = reader.getTranslatableFields(name);
+        const translatableFields = reader.getTranslatableFieldDetails(name);
         if (translatableFields.length === 0)
             continue;
-        files.push(generateTranslationBaseModel(name, translatableFields, config));
+        files.push(generateTranslationBaseModel(name, translatableFields, enforceLanguageFk, config));
         files.push(generateTranslationUserModel(name, config));
     }
     return files;
 }
-function generateTranslationBaseModel(name, translatableFields, config) {
+/**
+ * Map an omnify property type to its Eloquent `$casts` value. Returns
+ * `undefined` for plain string types (no cast needed). Without these
+ * casts, fetching a translation row returns the raw string from the
+ * DB for Json / Boolean / Int / DateTime columns and any consumer code
+ * that assumed a typed value (e.g. `$translation->metadata['key']`)
+ * fails at runtime.
+ */
+function castFor(type) {
+    switch (type) {
+        case 'Json':
+            return 'array';
+        case 'Boolean':
+            return 'boolean';
+        case 'Int':
+        case 'TinyInt':
+        case 'BigInt':
+            return 'integer';
+        case 'Float':
+            return 'float';
+        case 'Decimal':
+            return 'decimal:2';
+        case 'Date':
+            return 'date';
+        case 'DateTime':
+        case 'Timestamp':
+            return 'datetime';
+        default:
+            return undefined;
+    }
+}
+function generateTranslationBaseModel(name, translatableFields, enforceLanguageFk, config) {
     const modelName = toPascalCase(name);
     const modelSnake = toSnakeCase(name);
     const baseNamespace = resolveModularBaseNamespace(config, name, 'Models', config.models.baseNamespace);
     const tableName = `${modelSnake}_translations`;
-    const fillableLines = translatableFields
-        .map(f => `        '${f}',`)
-        .join('\n');
+    // Fillable: every translatable column + the optional `language_id`
+    // FK column (added by the migration when locale.enforceLanguageFk is
+    // on). Without including `language_id` in $fillable, Eloquent mass
+    // assignment via Astrotomic silently drops the value and the FK is
+    // never populated even though the column exists.
+    const fillableNames = translatableFields.map((f) => f.name);
+    if (enforceLanguageFk)
+        fillableNames.push('language_id');
+    const fillableLines = fillableNames.map((f) => `        '${f}',`).join('\n');
+    // Casts: only emit for fields whose type has a non-string Eloquent
+    // representation. Plain String / Text / Email / EnumRef stay as-is.
+    const castEntries = [];
+    for (const f of translatableFields) {
+        const c = castFor(f.type);
+        if (c)
+            castEntries.push(`        '${f.name}' => '${c}',`);
+    }
+    const castsBlock = castEntries.length === 0 ? '' : `
+
+    /**
+     * The attributes that should be cast to native types.
+     */
+    protected $casts = [
+${castEntries.join('\n')}
+    ];`;
     const content = `<?php
 
 namespace ${baseNamespace};
@@ -62,7 +116,7 @@ class ${modelName}TranslationBaseModel extends Model
      */
     protected $fillable = [
 ${fillableLines}
-    ];
+    ];${castsBlock}
 }
 `;
     return baseFile(resolveModularBasePath(config, name, 'Models', `${modelName}TranslationBaseModel.php`, config.models.basePath), content);

package/dist/types.d.ts

@@ -31,6 +31,7 @@ export interface SchemasJson {
         readonly locales: string[];
         readonly defaultLocale: string;
         readonly fallbackLocale: string;
+        readonly enforceLanguageFk?: boolean;
     };
     readonly customTypes: {
         readonly compound: Record<string, CompoundTypeDefinition>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@omnifyjp/ts",
-  "version": "4.10.0",
+  "version": "5.0.1",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",