@omnifyjp/ts 5.9.21 → 6.0.1

package/dist/php/model-generator.js

@@ -719,16 +719,22 @@ function buildRelations(schemaName, properties, propertyOrder, modelNamespace, r
         // columns the user added are unreachable through the relation.
         const relation = prop['relation'] ?? '';
         let pivotProperties;
+        let pivotTableName;
         if (relation === 'ManyToMany' && target) {
             const pivotName = [schemaName, target].sort().join('');
             const pivotSchema = reader.getSchema(pivotName);
+            const conventionalPivotTable = [toSnakeCase(schemaName), toSnakeCase(target)].sort().join('_');
+            const resolvedPivotTable = pivotSchema ? reader.getTableName(pivotName) : '';
+            if (resolvedPivotTable && resolvedPivotTable !== conventionalPivotTable) {
+                pivotTableName = resolvedPivotTable;
+            }
             if (pivotSchema?.properties) {
                 pivotProperties = Object.entries(pivotSchema.properties).map(([propName, prop]) => prop.type === 'Association' && !prop.mappedBy
                     ? prop.column || toFkColumnName(propName)
                     : toSnakeCase(propName));
             }
         }
-        const result = buildRelation(propName, prop, ns, { sourceTableName, targetTableName, pivotProperties });
+        const result = buildRelation(propName, prop, ns, { sourceTableName, targetTableName, pivotProperties, pivotTableName });
         if (result) {
             methods.push('\n' + result.method);
             declaredMethods.add(toCamelCase(propName));

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

@@ -8,6 +8,9 @@ interface RelationResult {
 interface RelationContext {
     sourceTableName: string;
     targetTableName: string;
+    /** Non-conventional physical table resolved from an explicit pivot schema.
+     * Omitted when Laravel can infer the joining table from model basenames. */
+    pivotTableName?: 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
@@ -17,8 +20,8 @@ interface RelationContext {
 }
 /** Build Eloquent relation method PHP code. */
 export declare function buildRelation(propName: string, property: Record<string, unknown>, modelNamespace: string, context?: RelationContext): RelationResult | null;
-/** Generate pivot table name matching Go's GeneratePivotTableName logic. */
-export declare function generatePivotTableName(sourceTable: string, targetTable: string): string;
+/** Generate the table name Laravel's joiningTable() infers from model basenames. */
+export declare function generatePivotTableName(sourceModel: string, targetModel: string): string;
 /** Get the return type hint for a relation. */
 export declare function getReturnType(relation: string): string;
 /**

package/dist/php/relation-builder.js

@@ -1,7 +1,7 @@
 /**
  * Port of RelationBuilder.php — generates Eloquent relation methods.
  */
-import { toSnakeCase, toCamelCase, toFkColumnName, singularize } from './naming-helper.js';
+import { toSnakeCase, toCamelCase, toFkColumnName } from './naming-helper.js';
 /** Build Eloquent relation method PHP code. */
 export function buildRelation(propName, property, modelNamespace, context) {
     const relation = property['relation'] ?? '';
@@ -41,10 +41,9 @@ export function buildRelation(propName, property, modelNamespace, context) {
         return null;
     return { method, imports };
 }
-/** Generate pivot table name matching Go's GeneratePivotTableName logic. */
-export function generatePivotTableName(sourceTable, targetTable) {
-    const tables = [singularize(sourceTable), singularize(targetTable)].sort();
-    return tables.join('_') + '_pivot';
+/** Generate the table name Laravel's joiningTable() infers from model basenames. */
+export function generatePivotTableName(sourceModel, targetModel) {
+    return [toSnakeCase(sourceModel), toSnakeCase(targetModel)].sort().join('_');
 }
 /** Get the return type hint for a relation. */
 export function getReturnType(relation) {
@@ -122,13 +121,12 @@ export function formatOrderByChain(orderBy) {
         .join('');
 }
 function belongsToMany(propName, property, target, ns, context) {
-    let joinTable = property['joinTable'] ?? '';
-    if (!joinTable && context?.sourceTableName && context?.targetTableName) {
-        joinTable = generatePivotTableName(context.sourceTableName, context.targetTableName);
-    }
+    const joinTable = property['joinTable'] || context?.pivotTableName || '';
     const methodName = toCamelCase(propName);
     const fqcn = `\\${ns}\\${target}`;
-    let chain = `$this->belongsToMany(${fqcn}::class, '${joinTable}')`;
+    let chain = joinTable
+        ? `$this->belongsToMany(${fqcn}::class, '${joinTable}')`
+        : `$this->belongsToMany(${fqcn}::class)`;
     // 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

package/package.json

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