@omnifyjp/ts 5.0.0 → 5.0.2

package/dist/php/model-generator.js

@@ -504,7 +504,21 @@ function buildRelations(schemaName, properties, propertyOrder, modelNamespace, r
         const target = prop['target'] ?? '';
         const ns = target ? reader.resolveModelNamespace(target, modelNamespace) : modelNamespace;
         const targetTableName = target ? reader.getTableName(target) : '';
-        const result = buildRelation(propName, prop, ns, { sourceTableName, targetTableName });
+        // For ManyToMany, look up the explicit `kind: pivot` schema (the
+        // sorted PascalCase concat of source + target — auto-created on
+        // first generate) and pass its property names so belongsToMany
+        // emits `->withPivot('col1', 'col2')`. Without this, custom pivot
+        // columns the user added are unreachable through the relation.
+        const relation = prop['relation'] ?? '';
+        let pivotProperties;
+        if (relation === 'ManyToMany' && target) {
+            const pivotName = [schemaName, target].sort().join('');
+            const pivotSchema = reader.getSchema(pivotName);
+            if (pivotSchema?.properties) {
+                pivotProperties = Object.keys(pivotSchema.properties).map(toSnakeCase);
+            }
+        }
+        const result = buildRelation(propName, prop, ns, { sourceTableName, targetTableName, pivotProperties });
         if (result) {
             methods.push('\n' + result.method);
             declaredMethods.add(toCamelCase(propName));

package/dist/php/relation-builder.d.ts

@@ -8,6 +8,12 @@ interface RelationResult {
 interface RelationContext {
     sourceTableName: string;
     targetTableName: string;
+    /** Property names declared on the explicit `kind: pivot` schema for
+     * this M2M (e.g. `["position", "notes"]`). Surfaced in the generated
+     * `belongsToMany()` chain via `->withPivot(...)` so consumers can
+     * read those columns through the relation. Empty / undefined when
+     * the user has not added custom columns to the pivot schema. */
+    pivotProperties?: string[];
 }
 /** Build Eloquent relation method PHP code. */
 export declare function buildRelation(propName: string, property: Record<string, unknown>, modelNamespace: string, context?: RelationContext): RelationResult | null;

package/dist/php/relation-builder.js

@@ -128,12 +128,15 @@ function belongsToMany(propName, property, target, ns, context) {
         joinTable = generatePivotTableName(context.sourceTableName, context.targetTableName);
     }
     const methodName = toCamelCase(propName);
-    const pivotFields = property['pivotFields'] ?? {};
     const fqcn = `\\${ns}\\${target}`;
     let chain = `$this->belongsToMany(${fqcn}::class, '${joinTable}')`;
-    const fieldKeys = Object.keys(pivotFields);
-    if (fieldKeys.length > 0) {
-        const fields = fieldKeys.map(k => `'${toSnakeCase(k)}'`).join(', ');
+    // withPivot for every column declared on the explicit `kind: pivot`
+    // schema (resolved upstream and passed via context.pivotProperties).
+    // The legacy `pivotFields:` block on the M2M property was removed in
+    // v5.0.0; pivot columns now live on the pivot schema itself.
+    const pivotCols = context?.pivotProperties ?? [];
+    if (pivotCols.length > 0) {
+        const fields = pivotCols.map(k => `'${toSnakeCase(k)}'`).join(', ');
         chain += `\n            ->withPivot(${fields})`;
     }
     chain += `\n            ->withTimestamps()`;

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": "5.0.0",
+  "version": "5.0.2",
   "description": "TypeScript model type generator from Omnify schemas.json",
   "type": "module",
   "main": "dist/index.js",