@famgia/omnify-laravel 0.0.106 → 0.0.107

package/dist/index.cjs

@@ -20,6 +20,8 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
+  extractManyToManyRelations: () => extractManyToManyRelations,
+  extractMorphToManyRelations: () => extractMorphToManyRelations,
   formatColumnMethod: () => formatColumnMethod,
   formatForeignKey: () => formatForeignKey,
   formatIndex: () => formatIndex,
@@ -34,6 +36,9 @@ __export(index_exports, {
   generateMigrations: () => generateMigrations,
   generateMigrationsFromChanges: () => generateMigrationsFromChanges,
   generateModels: () => generateModels,
+  generateMorphToManyPivotBlueprint: () => generateMorphToManyPivotBlueprint,
+  generatePivotTableBlueprint: () => generatePivotTableBlueprint,
+  generatePivotTableName: () => generatePivotTableName,
   generatePrimaryKeyColumn: () => generatePrimaryKeyColumn,
   generateProviderRegistration: () => generateProviderRegistration,
   generateSoftDeleteColumn: () => generateSoftDeleteColumn,
@@ -604,6 +609,9 @@ function extractManyToManyRelations(schema, allSchemas) {
     if (assocProp.relation !== "ManyToMany") {
       continue;
     }
+    if (assocProp.mappedBy) {
+      continue;
+    }
     const targetName = assocProp.target;
     if (!targetName) {
       continue;
@@ -618,6 +626,19 @@ function extractManyToManyRelations(schema, allSchemas) {
     const pivotTableName = generatePivotTableName(sourceTable, targetTable, assocProp.joinTable);
     const sourceColumn = sourceTable.replace(/ies$/, "y").replace(/s$/, "") + "_id";
     const targetColumn = targetTable.replace(/ies$/, "y").replace(/s$/, "") + "_id";
+    const pivotFields = [];
+    if (assocProp.pivotFields) {
+      for (const [fieldName, fieldDef] of Object.entries(assocProp.pivotFields)) {
+        pivotFields.push({
+          name: toColumnName(fieldName),
+          type: fieldDef.type,
+          nullable: fieldDef.nullable,
+          default: fieldDef.default,
+          length: fieldDef.length,
+          unsigned: fieldDef.unsigned
+        });
+      }
+    }
     pivotTables.push({
       tableName: pivotTableName,
       sourceTable,
@@ -627,11 +648,35 @@ function extractManyToManyRelations(schema, allSchemas) {
       sourcePkType,
       targetPkType,
       onDelete: assocProp.onDelete,
-      onUpdate: assocProp.onUpdate
+      onUpdate: assocProp.onUpdate,
+      pivotFields: pivotFields.length > 0 ? pivotFields : void 0
     });
   }
   return pivotTables;
 }
+function pivotFieldToColumn(field) {
+  const method = TYPE_METHOD_MAP[field.type] ?? "string";
+  const args = [field.name];
+  const modifiers = [];
+  if (method === "string" && field.length) {
+    args.push(field.length);
+  }
+  if (field.nullable) {
+    modifiers.push({ method: "nullable" });
+  }
+  if (field.default !== void 0 && field.default !== null) {
+    modifiers.push({ method: "default", args: [field.default] });
+  }
+  if (field.unsigned && (method === "tinyInteger" || method === "integer" || method === "bigInteger")) {
+    modifiers.push({ method: "unsigned" });
+  }
+  return {
+    name: field.name,
+    method,
+    args,
+    modifiers
+  };
+}
 function generatePivotTableBlueprint(pivot) {
   const columns = [];
   const foreignKeys = [];
@@ -660,6 +705,11 @@ function generatePivotTableBlueprint(pivot) {
     args: [pivot.targetColumn],
     modifiers: []
   });
+  if (pivot.pivotFields && pivot.pivotFields.length > 0) {
+    for (const field of pivot.pivotFields) {
+      columns.push(pivotFieldToColumn(field));
+    }
+  }
   columns.push(...generateTimestampColumns());
   foreignKeys.push({
     columns: [pivot.sourceColumn],
@@ -695,6 +745,126 @@ function generatePivotTableBlueprint(pivot) {
     indexes
   };
 }
+function extractMorphToManyRelations(schema, allSchemas) {
+  const morphPivotTables = [];
+  if (!schema.properties) {
+    return morphPivotTables;
+  }
+  for (const [propName, property] of Object.entries(schema.properties)) {
+    if (property.type !== "Association") {
+      continue;
+    }
+    const assocProp = property;
+    if (assocProp.relation !== "MorphToMany") {
+      continue;
+    }
+    const targetName = assocProp.target;
+    if (!targetName) {
+      continue;
+    }
+    const targetSchema = allSchemas[targetName];
+    const targetTable = toTableName(targetName);
+    const targetPkType = targetSchema ? getIdType(targetSchema) : "BigInt";
+    const isOwningSide = assocProp.owning ?? schema.name < targetName;
+    if (!isOwningSide) {
+      continue;
+    }
+    const morphTargets = [];
+    morphTargets.push(schema.name);
+    for (const [otherName, otherSchema] of Object.entries(allSchemas)) {
+      if (otherName === schema.name) continue;
+      if (!otherSchema.properties) continue;
+      for (const otherProp of Object.values(otherSchema.properties)) {
+        if (otherProp.type !== "Association") continue;
+        const otherAssoc = otherProp;
+        if (otherAssoc.relation === "MorphToMany" && otherAssoc.target === targetName) {
+          if (!morphTargets.includes(otherName)) {
+            morphTargets.push(otherName);
+          }
+        }
+      }
+    }
+    const defaultTableName = targetTable.replace(/s$/, "") + "ables";
+    const tableName = assocProp.joinTable ?? defaultTableName;
+    const targetColumn = targetTable.replace(/ies$/, "y").replace(/s$/, "") + "_id";
+    const morphName = propName.replace(/s$/, "") + "able";
+    morphPivotTables.push({
+      tableName,
+      targetTable,
+      targetColumn,
+      targetPkType,
+      morphName,
+      morphTargets,
+      onDelete: assocProp.onDelete,
+      onUpdate: assocProp.onUpdate
+    });
+  }
+  return morphPivotTables;
+}
+function generateMorphToManyPivotBlueprint(pivot) {
+  const columns = [];
+  const foreignKeys = [];
+  const indexes = [];
+  const getMethodForPkType = (pkType) => {
+    switch (pkType) {
+      case "Int":
+        return "unsignedInteger";
+      case "Uuid":
+        return "uuid";
+      case "String":
+        return "string";
+      default:
+        return "unsignedBigInteger";
+    }
+  };
+  columns.push({
+    name: pivot.targetColumn,
+    method: getMethodForPkType(pivot.targetPkType),
+    args: [pivot.targetColumn],
+    modifiers: []
+  });
+  const typeColumnName = `${pivot.morphName}_type`;
+  columns.push({
+    name: typeColumnName,
+    method: "enum",
+    args: [typeColumnName, pivot.morphTargets],
+    modifiers: []
+  });
+  const idColumnName = `${pivot.morphName}_id`;
+  columns.push({
+    name: idColumnName,
+    method: "unsignedBigInteger",
+    // Default to BigInt for polymorphic IDs
+    args: [idColumnName],
+    modifiers: []
+  });
+  foreignKeys.push({
+    columns: [pivot.targetColumn],
+    references: "id",
+    on: [pivot.targetTable],
+    onDelete: pivot.onDelete ?? "cascade",
+    onUpdate: pivot.onUpdate ?? "cascade"
+  });
+  indexes.push({
+    columns: [pivot.targetColumn, typeColumnName, idColumnName],
+    unique: true
+  });
+  indexes.push({
+    columns: [typeColumnName, idColumnName],
+    unique: false
+  });
+  indexes.push({
+    columns: [pivot.targetColumn],
+    unique: false
+  });
+  return {
+    tableName: pivot.tableName,
+    columns,
+    primaryKey: [pivot.targetColumn, typeColumnName, idColumnName],
+    foreignKeys,
+    indexes
+  };
+}
 
 // src/migration/generator.ts
 function generateTimestamp() {
@@ -1648,12 +1818,30 @@ function generateRelation(propName, assoc, schema, schemas, options) {
     }
     case "ManyToMany": {
       const pivotTable = assoc.joinTable ?? `${toSnakeCase(propName)}_pivot`;
+      let pivotFieldNames = [];
+      if (assoc.pivotFields && Object.keys(assoc.pivotFields).length > 0) {
+        pivotFieldNames = Object.keys(assoc.pivotFields).map((f) => toSnakeCase(f));
+      } else if (assoc.mappedBy && assoc.target) {
+        const targetSchema = schemas[assoc.target];
+        if (targetSchema?.properties) {
+          const owningProp = targetSchema.properties[assoc.mappedBy];
+          if (owningProp?.type === "Association") {
+            const owningAssoc = owningProp;
+            if (owningAssoc.pivotFields && Object.keys(owningAssoc.pivotFields).length > 0) {
+              pivotFieldNames = Object.keys(owningAssoc.pivotFields).map((f) => toSnakeCase(f));
+            }
+          }
+        }
+      }
+      const pivotFieldsCode = pivotFieldNames.length > 0 ? pivotFieldNames.map((f) => `'${f}'`).join(", ") : null;
+      const withPivotLine = pivotFieldsCode ? `
+            ->withPivot(${pivotFieldsCode})` : "";
       return `    /**
      * The ${propName} that belong to this model.
      */
     public function ${methodName}(): BelongsToMany
     {
-        return $this->belongsToMany(${targetClass}::class, '${pivotTable}')
+        return $this->belongsToMany(${targetClass}::class, '${pivotTable}')${withPivotLine}
             ->withTimestamps();
     }`;
     }
@@ -4620,6 +4808,8 @@ function laravelPlugin(options) {
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  extractManyToManyRelations,
+  extractMorphToManyRelations,
   formatColumnMethod,
   formatForeignKey,
   formatIndex,
@@ -4634,6 +4824,9 @@ function laravelPlugin(options) {
   generateMigrations,
   generateMigrationsFromChanges,
   generateModels,
+  generateMorphToManyPivotBlueprint,
+  generatePivotTableBlueprint,
+  generatePivotTableName,
   generatePrimaryKeyColumn,
   generateProviderRegistration,
   generateSoftDeleteColumn,