relq 1.0.91 → 1.0.92

package/dist/cjs/cli/utils/schema-diff.cjs

@@ -345,16 +345,6 @@ function diffIndexes(local, remote) {
 }
 function diffConstraints(local, remote) {
     const diffs = [];
-    const sig = (c) => {
-        const def = (c.definition || '').replace(/"/g, '').replace(/\s+/g, ' ').trim().toLowerCase();
-        return `${c.type}:${def}`;
-    };
-    const localSigs = new Map();
-    const remoteSigs = new Map();
-    for (const c of local)
-        localSigs.set(sig(c), c);
-    for (const c of remote)
-        remoteSigs.set(sig(c), c);
     const toConstraintInfo = (c) => ({
         name: c.name,
         type: (c.type || 'CHECK'),
@@ -362,13 +352,111 @@ function diffConstraints(local, remote) {
         definition: c.definition || '',
         trackingId: c.trackingId,
     });
-    for (const [s, c] of remoteSigs) {
-        if (!localSigs.has(s)) {
+    const matchedLocal = new Set();
+    const matchedRemote = new Set();
+    for (let ri = 0; ri < remote.length; ri++) {
+        if (matchedRemote.has(ri))
+            continue;
+        const rc = remote[ri];
+        if (!rc.trackingId)
+            continue;
+        for (let li = 0; li < local.length; li++) {
+            if (matchedLocal.has(li))
+                continue;
+            const lc = local[li];
+            if (lc.trackingId && lc.trackingId === rc.trackingId) {
+                matchedLocal.add(li);
+                matchedRemote.add(ri);
+                break;
+            }
+        }
+    }
+    for (let ri = 0; ri < remote.length; ri++) {
+        if (matchedRemote.has(ri))
+            continue;
+        const rc = remote[ri];
+        if (!rc.name)
+            continue;
+        for (let li = 0; li < local.length; li++) {
+            if (matchedLocal.has(li))
+                continue;
+            const lc = local[li];
+            if (lc.name && lc.name === rc.name) {
+                matchedLocal.add(li);
+                matchedRemote.add(ri);
+                break;
+            }
+        }
+    }
+    const semanticSig = (c) => {
+        const def = c.definition || '';
+        const type = (c.type || '').toUpperCase();
+        if (type === 'PRIMARY KEY' || type === 'UNIQUE') {
+            const colMatch = def.match(/\(([^)]+)\)/);
+            if (colMatch) {
+                const cols = colMatch[1].replace(/"/g, '').split(',').map(s => s.trim().toLowerCase()).sort().join(',');
+                return `${type}:${cols}`;
+            }
+        }
+        if (type === 'FOREIGN KEY') {
+            const fkMatch = def.match(/FOREIGN\s+KEY\s*\(([^)]+)\)\s*REFERENCES\s+"?(\w+)"?/i);
+            if (fkMatch) {
+                const srcCols = fkMatch[1].replace(/"/g, '').split(',').map(s => s.trim().toLowerCase()).sort().join(',');
+                const targetTable = fkMatch[2].toLowerCase();
+                return `FK:${srcCols}→${targetTable}`;
+            }
+        }
+        return null;
+    };
+    for (let ri = 0; ri < remote.length; ri++) {
+        if (matchedRemote.has(ri))
+            continue;
+        const rSig = semanticSig(remote[ri]);
+        if (!rSig)
+            continue;
+        for (let li = 0; li < local.length; li++) {
+            if (matchedLocal.has(li))
+                continue;
+            const lSig = semanticSig(local[li]);
+            if (lSig && lSig === rSig) {
+                matchedLocal.add(li);
+                matchedRemote.add(ri);
+                break;
+            }
+        }
+    }
+    const unmatchedLocalChecks = local
+        .map((c, i) => ({ c, i }))
+        .filter(({ c, i }) => !matchedLocal.has(i) && (c.type || '').toUpperCase() === 'CHECK');
+    const unmatchedRemoteChecks = remote
+        .map((c, i) => ({ c, i }))
+        .filter(({ c, i }) => !matchedRemote.has(i) && (c.type || '').toUpperCase() === 'CHECK');
+    for (const { c: rc, i: ri } of unmatchedRemoteChecks) {
+        if (matchedRemote.has(ri))
+            continue;
+        if (!rc.name)
+            continue;
+        for (const { c: lc, i: li } of unmatchedLocalChecks) {
+            if (matchedLocal.has(li))
+                continue;
+            if (lc.name && (lc.name === rc.name ||
+                (lc.name.endsWith('_check') && rc.name.endsWith('_check') &&
+                    lc.name.split('_').slice(-2).join('_') === rc.name.split('_').slice(-2).join('_')))) {
+                matchedLocal.add(li);
+                matchedRemote.add(ri);
+                break;
+            }
+        }
+    }
+    for (let ri = 0; ri < remote.length; ri++) {
+        if (!matchedRemote.has(ri)) {
+            const c = remote[ri];
             diffs.push({ name: c.name || c.definition || 'unnamed', type: 'added', after: toConstraintInfo(c) });
         }
     }
-    for (const [s, c] of localSigs) {
-        if (!remoteSigs.has(s)) {
+    for (let li = 0; li < local.length; li++) {
+        if (!matchedLocal.has(li)) {
+            const c = local[li];
             diffs.push({ name: c.name || c.definition || 'unnamed', type: 'removed', before: toConstraintInfo(c) });
         }
     }
@@ -542,32 +630,43 @@ function formatCategorizedSummary(diff) {
                 idxRemoved++;
         }
         for (const con of table.constraints || []) {
-            const name = (con.name || '').toLowerCase();
-            const isFk = name.includes('fkey') || name.includes('foreign');
-            const isUq = name.includes('unique') || name.includes('_key');
-            const isPk = name.includes('pkey') || name.includes('primary');
             const before = con.before;
             const after = con.after;
             const conType = (before?.type || after?.type || '').toUpperCase();
-            if (conType === 'FOREIGN KEY' || isFk) {
+            let category = 'OTHER';
+            if (conType) {
+                category = conType;
+            }
+            else {
+                const name = (con.name || '').toLowerCase();
+                if (name.includes('pkey') || name.includes('primary'))
+                    category = 'PRIMARY KEY';
+                else if (name.includes('fkey') || name.includes('foreign'))
+                    category = 'FOREIGN KEY';
+                else if (name.includes('_check'))
+                    category = 'CHECK';
+                else if (name.includes('_key') || name.includes('unique'))
+                    category = 'UNIQUE';
+            }
+            if (category === 'FOREIGN KEY') {
                 if (con.type === 'added')
                     fkAdded++;
                 else if (con.type === 'removed')
                     fkRemoved++;
             }
-            else if (conType === 'UNIQUE' || isUq) {
+            else if (category === 'UNIQUE') {
                 if (con.type === 'added')
                     uniqueAdded++;
                 else if (con.type === 'removed')
                     uniqueRemoved++;
             }
-            else if (conType === 'PRIMARY KEY' || isPk) {
+            else if (category === 'PRIMARY KEY') {
                 if (con.type === 'added')
                     pkAdded++;
                 else if (con.type === 'removed')
                     pkRemoved++;
             }
-            else if (conType === 'CHECK') {
+            else if (category === 'CHECK') {
                 if (con.type === 'added')
                     checkAdded++;
                 else if (con.type === 'removed')

package/dist/cjs/cli/utils/schema-to-ast.cjs

@@ -419,6 +419,18 @@ function tableToAST(table) {
                 col.isUnique = true;
         }
     }
+    const hasPKConstraint = constraints.some(c => c.type === 'PRIMARY KEY');
+    if (!hasPKConstraint) {
+        const pkCols = columns.filter(c => c.isPrimaryKey).map(c => c.name);
+        if (pkCols.length > 0) {
+            constraints.push({
+                name: `${table.$name}_pkey`,
+                type: 'PRIMARY KEY',
+                columns: pkCols,
+                trackingId: `${table.$name}_pkey`,
+            });
+        }
+    }
     return {
         name: table.$name,
         schema: table.$schema || 'public',

package/dist/esm/cli/utils/schema-diff.js

@@ -334,16 +334,6 @@ function diffIndexes(local, remote) {
 }
 function diffConstraints(local, remote) {
     const diffs = [];
-    const sig = (c) => {
-        const def = (c.definition || '').replace(/"/g, '').replace(/\s+/g, ' ').trim().toLowerCase();
-        return `${c.type}:${def}`;
-    };
-    const localSigs = new Map();
-    const remoteSigs = new Map();
-    for (const c of local)
-        localSigs.set(sig(c), c);
-    for (const c of remote)
-        remoteSigs.set(sig(c), c);
     const toConstraintInfo = (c) => ({
         name: c.name,
         type: (c.type || 'CHECK'),
@@ -351,13 +341,111 @@ function diffConstraints(local, remote) {
         definition: c.definition || '',
         trackingId: c.trackingId,
     });
-    for (const [s, c] of remoteSigs) {
-        if (!localSigs.has(s)) {
+    const matchedLocal = new Set();
+    const matchedRemote = new Set();
+    for (let ri = 0; ri < remote.length; ri++) {
+        if (matchedRemote.has(ri))
+            continue;
+        const rc = remote[ri];
+        if (!rc.trackingId)
+            continue;
+        for (let li = 0; li < local.length; li++) {
+            if (matchedLocal.has(li))
+                continue;
+            const lc = local[li];
+            if (lc.trackingId && lc.trackingId === rc.trackingId) {
+                matchedLocal.add(li);
+                matchedRemote.add(ri);
+                break;
+            }
+        }
+    }
+    for (let ri = 0; ri < remote.length; ri++) {
+        if (matchedRemote.has(ri))
+            continue;
+        const rc = remote[ri];
+        if (!rc.name)
+            continue;
+        for (let li = 0; li < local.length; li++) {
+            if (matchedLocal.has(li))
+                continue;
+            const lc = local[li];
+            if (lc.name && lc.name === rc.name) {
+                matchedLocal.add(li);
+                matchedRemote.add(ri);
+                break;
+            }
+        }
+    }
+    const semanticSig = (c) => {
+        const def = c.definition || '';
+        const type = (c.type || '').toUpperCase();
+        if (type === 'PRIMARY KEY' || type === 'UNIQUE') {
+            const colMatch = def.match(/\(([^)]+)\)/);
+            if (colMatch) {
+                const cols = colMatch[1].replace(/"/g, '').split(',').map(s => s.trim().toLowerCase()).sort().join(',');
+                return `${type}:${cols}`;
+            }
+        }
+        if (type === 'FOREIGN KEY') {
+            const fkMatch = def.match(/FOREIGN\s+KEY\s*\(([^)]+)\)\s*REFERENCES\s+"?(\w+)"?/i);
+            if (fkMatch) {
+                const srcCols = fkMatch[1].replace(/"/g, '').split(',').map(s => s.trim().toLowerCase()).sort().join(',');
+                const targetTable = fkMatch[2].toLowerCase();
+                return `FK:${srcCols}→${targetTable}`;
+            }
+        }
+        return null;
+    };
+    for (let ri = 0; ri < remote.length; ri++) {
+        if (matchedRemote.has(ri))
+            continue;
+        const rSig = semanticSig(remote[ri]);
+        if (!rSig)
+            continue;
+        for (let li = 0; li < local.length; li++) {
+            if (matchedLocal.has(li))
+                continue;
+            const lSig = semanticSig(local[li]);
+            if (lSig && lSig === rSig) {
+                matchedLocal.add(li);
+                matchedRemote.add(ri);
+                break;
+            }
+        }
+    }
+    const unmatchedLocalChecks = local
+        .map((c, i) => ({ c, i }))
+        .filter(({ c, i }) => !matchedLocal.has(i) && (c.type || '').toUpperCase() === 'CHECK');
+    const unmatchedRemoteChecks = remote
+        .map((c, i) => ({ c, i }))
+        .filter(({ c, i }) => !matchedRemote.has(i) && (c.type || '').toUpperCase() === 'CHECK');
+    for (const { c: rc, i: ri } of unmatchedRemoteChecks) {
+        if (matchedRemote.has(ri))
+            continue;
+        if (!rc.name)
+            continue;
+        for (const { c: lc, i: li } of unmatchedLocalChecks) {
+            if (matchedLocal.has(li))
+                continue;
+            if (lc.name && (lc.name === rc.name ||
+                (lc.name.endsWith('_check') && rc.name.endsWith('_check') &&
+                    lc.name.split('_').slice(-2).join('_') === rc.name.split('_').slice(-2).join('_')))) {
+                matchedLocal.add(li);
+                matchedRemote.add(ri);
+                break;
+            }
+        }
+    }
+    for (let ri = 0; ri < remote.length; ri++) {
+        if (!matchedRemote.has(ri)) {
+            const c = remote[ri];
             diffs.push({ name: c.name || c.definition || 'unnamed', type: 'added', after: toConstraintInfo(c) });
         }
     }
-    for (const [s, c] of localSigs) {
-        if (!remoteSigs.has(s)) {
+    for (let li = 0; li < local.length; li++) {
+        if (!matchedLocal.has(li)) {
+            const c = local[li];
             diffs.push({ name: c.name || c.definition || 'unnamed', type: 'removed', before: toConstraintInfo(c) });
         }
     }
@@ -531,32 +619,43 @@ export function formatCategorizedSummary(diff) {
                 idxRemoved++;
         }
         for (const con of table.constraints || []) {
-            const name = (con.name || '').toLowerCase();
-            const isFk = name.includes('fkey') || name.includes('foreign');
-            const isUq = name.includes('unique') || name.includes('_key');
-            const isPk = name.includes('pkey') || name.includes('primary');
             const before = con.before;
             const after = con.after;
             const conType = (before?.type || after?.type || '').toUpperCase();
-            if (conType === 'FOREIGN KEY' || isFk) {
+            let category = 'OTHER';
+            if (conType) {
+                category = conType;
+            }
+            else {
+                const name = (con.name || '').toLowerCase();
+                if (name.includes('pkey') || name.includes('primary'))
+                    category = 'PRIMARY KEY';
+                else if (name.includes('fkey') || name.includes('foreign'))
+                    category = 'FOREIGN KEY';
+                else if (name.includes('_check'))
+                    category = 'CHECK';
+                else if (name.includes('_key') || name.includes('unique'))
+                    category = 'UNIQUE';
+            }
+            if (category === 'FOREIGN KEY') {
                 if (con.type === 'added')
                     fkAdded++;
                 else if (con.type === 'removed')
                     fkRemoved++;
             }
-            else if (conType === 'UNIQUE' || isUq) {
+            else if (category === 'UNIQUE') {
                 if (con.type === 'added')
                     uniqueAdded++;
                 else if (con.type === 'removed')
                     uniqueRemoved++;
             }
-            else if (conType === 'PRIMARY KEY' || isPk) {
+            else if (category === 'PRIMARY KEY') {
                 if (con.type === 'added')
                     pkAdded++;
                 else if (con.type === 'removed')
                     pkRemoved++;
             }
-            else if (conType === 'CHECK') {
+            else if (category === 'CHECK') {
                 if (con.type === 'added')
                     checkAdded++;
                 else if (con.type === 'removed')

package/dist/esm/cli/utils/schema-to-ast.js

@@ -385,6 +385,18 @@ export function tableToAST(table) {
                 col.isUnique = true;
         }
     }
+    const hasPKConstraint = constraints.some(c => c.type === 'PRIMARY KEY');
+    if (!hasPKConstraint) {
+        const pkCols = columns.filter(c => c.isPrimaryKey).map(c => c.name);
+        if (pkCols.length > 0) {
+            constraints.push({
+                name: `${table.$name}_pkey`,
+                type: 'PRIMARY KEY',
+                columns: pkCols,
+                trackingId: `${table.$name}_pkey`,
+            });
+        }
+    }
     return {
         name: table.$name,
         schema: table.$schema || 'public',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "relq",
-  "version": "1.0.91",
+  "version": "1.0.92",
   "description": "The Fully-Typed PostgreSQL ORM for TypeScript",
   "author": "Olajide Mathew O. <olajide.mathew@yuniq.solutions>",
   "license": "MIT",