prisma-laravel-migrate 0.1.2 → 0.1.4

package/dist/utils/sort.js

@@ -1,78 +1,109 @@
+var GenTarget;
+(function (GenTarget) {
+    GenTarget[GenTarget["None"] = 0] = "None";
+    GenTarget[GenTarget["Model"] = 1] = "Model";
+    GenTarget[GenTarget["Migrator"] = 2] = "Migrator";
+})(GenTarget || (GenTarget = {}));
+// normalize anything like: true | 'migrator' | 'both' | flags | { migrator?: boolean }
+function isLocalForMigrator(x) {
+    const v = x?.local;
+    if (!v)
+        return false;
+    if (v === true)
+        return true; // blanket local
+    if (typeof v === "string") {
+        const s = v.toLowerCase();
+        return s === "migrator" || s === "both" || s === "all" || s === "*";
+    }
+    if (typeof v === "number")
+        return (v & GenTarget.Migrator) !== 0;
+    if (typeof v === "object")
+        return !!v.migrator || !!v.both || !!v.all;
+    return false;
+}
 /**
- * Reorders migrations so that any table with foreign‐key dependencies
- * is always migrated *after* the tables it references.
- *
- * @param migrations  Array of Migration objects (with tableName & definitions[])
- * @returns           New array sorted in dependency order
- * @throws            If there’s a cycle in the relationships
+ * Topologically sort migrations so FK parents come before children.
+ * - Skips migrations marked local for migrator.
+ * - Skips FK edges from defs marked local for migrator.
+ * - Considers only owning-side FKs.
+ * - Dedupes edges; throws on cycles.
  */
-export function sortMigrations(migrations) {
-    // 1) Build a map: tableName → Migration
-    const migMap = new Map(migrations
-        .filter(m => !m.local) // skip ignored models
-        .map(m => [m.tableName, m]));
-    // 2) Collect “true” FKs only (skip back‐relation object fields)
+export function sortMigrations(input) {
+    // 0) keep only migrations that will actually emit for migrator
+    const migrations = (input || []).filter(m => !isLocalForMigrator(m));
+    // 1) table -> migration
+    const migMap = new Map(migrations.map(m => [m.tableName, m]));
+    // 2) child -> Set<parent>
     const rawDeps = new Map();
-    for (const { tableName } of migrations) {
+    for (const { tableName } of migrations)
         rawDeps.set(tableName, new Set());
-    }
     for (const m of migrations) {
-        for (const def of m.definitions) {
-            // only consider a relationship if:
-            //  - it exists (def.relationship)
-            //  - this field is a scalar FK column (def.kind === 'scalar')
-            //  - it's the owning side (relationFromFields non-empty)
-            if (!def.relationship ||
-                !def.relationship.local ||
-                !def.relationFromFields ||
-                def.relationFromFields.length === 0) {
+        for (const def of m.definitions ?? []) {
+            // skip defs silenced for migrator
+            if (isLocalForMigrator(def))
                 continue;
-            }
-            const parent = def.relationship.on;
-            if (!migMap.has(parent) || m.tableName == parent)
-                continue; // skip external tables
-            rawDeps.get(m.tableName).add(parent);
+            const rel = def.relationship;
+            if (!rel)
+                continue;
+            // Owning side? prefer relationship.fields; fallback to relationFromFields if carried through
+            const ownFields = Array.isArray(rel.fields) ? rel.fields :
+                Array.isArray(def.relationFromFields) ? def.relationFromFields :
+                    [];
+            if (ownFields.length === 0)
+                continue;
+            // Parent table: allow several keys to be safe
+            const parent = rel.on || rel.table || rel.target;
+            if (!parent)
+                continue;
+            if (parent === m.tableName)
+                continue; // self-edge ignored
+            if (!migMap.has(parent))
+                continue; // external table not in this batch
+            rawDeps.get(m.tableName).add(parent); // Set dedupes edges
         }
     }
-    // 3) Build adjacency (parent → dependents) and in-degree (table → count)
+    // 3) Build adjacency & in-degree
     const adj = new Map();
     const inDegree = new Map();
     for (const tbl of migMap.keys()) {
-        adj.set(tbl, []);
+        adj.set(tbl, new Set());
         inDegree.set(tbl, 0);
     }
     for (const [child, parents] of rawDeps) {
         for (const parent of parents) {
-            if (parent !== child)
-                adj.get(parent).push(child);
-            inDegree.set(child, inDegree.get(child) + 1);
+            if (parent === child)
+                continue;
+            if (!adj.get(parent).has(child)) {
+                adj.get(parent).add(child);
+                inDegree.set(child, (inDegree.get(child) || 0) + 1);
+            }
         }
     }
-    // 4) Kahn’s algorithm: enqueue all zero in-degree tables
-    const queue = [];
-    for (const [tbl, deg] of inDegree) {
-        if (deg === 0)
-            queue.push(tbl);
-    }
+    // 4) Kahn’s algorithm
+    const queue = Array.from(inDegree.entries())
+        .filter(([, d]) => d === 0)
+        .map(([t]) => t);
     const sorted = [];
     while (queue.length) {
         const tbl = queue.shift();
         sorted.push(migMap.get(tbl));
         for (const child of adj.get(tbl)) {
-            const nd = inDegree.get(child) - 1;
+            const nd = (inDegree.get(child) || 0) - 1;
             inDegree.set(child, nd);
             if (nd === 0)
                 queue.push(child);
         }
     }
-    // 5) If not all processed, there is a genuine cycle
+    // 5) Cycle detection
     if (sorted.length !== migrations.length) {
-        const cycle = migrations
-            .map(m => m.tableName)
-            .filter(t => !sorted.some(s => s.tableName === t));
-        throw new Error(`Cycle detected in migration dependencies: ${cycle.join(' → ')}`);
+        const stuck = Array.from(inDegree.entries())
+            .filter(([, d]) => d > 0)
+            .map(([t]) => t);
+        const edgeDump = Array.from(rawDeps.entries())
+            .map(([c, ps]) => `${c} ← [${Array.from(ps).join(", ")}]`)
+            .join("; ");
+        throw new Error(`Cycle detected in migration dependencies. Stuck: ${stuck.join(", ")}. Edges: ${edgeDump}`);
     }
-    console.log('\n📦 Sorted Migration Tables:\n' + sorted.map((item, i) => ` ${i + 1}. ${item.tableName}`).join('\n') + '\n');
     return sorted;
 }
 //# sourceMappingURL=sort.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-laravel-migrate",
-  "version": "0.1.2",
+  "version": "0.1.4",
   "description": "Generate laravel migrations and/or models using prisma files",
   "bin": {
     "prisma-laravel-migrations": "./dist/cli/migrator.index.js",