fix(datasource-sql): ensure dedup keeps correct schema FK target + add composite+multi-schema test

- Sort filtered references by referencedTableSchema match before dedup
  to guarantee the correct schema's FK target is always preserved
- Add assertion verifying deduplication warning is logged
- Add test combining real composite FK with multi-schema collision
- Make test comment self-contained (remove fragile "described above" ref)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: alban bertolini

packages/datasource-sql/src/introspection/introspector.ts

@@ -240,9 +240,17 @@ export default class Introspector {
 
     // Deduplicate: the filtered step above matches on the source table's schema (tableSchema),
     // but the Sequelize join bug produces rows that differ in referencedTableSchema (the FK
-    // target's schema). Keep one per (constraintName, columnName) to collapse these duplicates.
+    // target's schema). Sort so rows matching the source schema come first, then keep one per
+    // (constraintName, columnName) to ensure we always preserve the correct FK target.
+    const sorted = [...filtered].sort((a, b) => {
+      const aMatch = a.referencedTableSchema === tableIdentifier.schema ? 0 : 1;
+      const bMatch = b.referencedTableSchema === tableIdentifier.schema ? 0 : 1;
+
+      return aMatch - bMatch;
+    });
+
     const seen = new Set<string>();
-    const deduplicated = filtered.filter(ref => {
+    const deduplicated = sorted.filter(ref => {
       if (!ref.constraintName) return true;
 
       const key = `${ref.constraintName}::${ref.columnName}`;

packages/datasource-sql/test/introspection/introspector.integration.test.ts

@@ -480,8 +480,8 @@ ALTER TABLE "TableA" ADD CONSTRAINT "A_fkey" FOREIGN KEY ("type") REFERENCES "Ta
       });
 
       it('should not misdetect composite FK when another schema has same constraint names', async () => {
-        // Set up the exact conditions described above: two schemas with matching table names,
-        // FK column names, and therefore identical auto-generated constraint names.
+        // Two schemas with matching table names and FK column names cause PostgreSQL to generate
+        // identical auto-constraint names, triggering the Sequelize cross-schema join bug.
         await sequelize.query(`
           CREATE TABLE schema1.main_table (
             id SERIAL PRIMARY KEY,
@@ -550,6 +550,56 @@ ALTER TABLE "TableA" ADD CONSTRAINT "A_fkey" FOREIGN KEY ("type") REFERENCES "Ta
           'Warn',
           expect.stringContaining('Composite relations are not supported'),
         );
+
+        // Should log that cross-schema duplicates were deduplicated
+        expect(logger).toHaveBeenCalledWith('Warn', expect.stringContaining('Deduplicated'));
+      });
+
+      it('should still detect real composite FKs when another schema has same constraint names', async () => {
+        await sequelize.query(`
+          CREATE TABLE schema1.target (
+            type TEXT NOT NULL,
+            code TEXT NOT NULL,
+            PRIMARY KEY (type, code)
+          );
+
+          CREATE TABLE schema1.source (
+            id SERIAL PRIMARY KEY,
+            fk_type TEXT NOT NULL,
+            fk_code TEXT NOT NULL,
+            CONSTRAINT source_composite_fkey FOREIGN KEY (fk_type, fk_code)
+              REFERENCES schema1.target(type, code)
+          );
+
+          -- Schema2: identical structure produces identical auto-constraint names
+          CREATE TABLE schema2.target (
+            type TEXT NOT NULL,
+            code TEXT NOT NULL,
+            PRIMARY KEY (type, code)
+          );
+
+          CREATE TABLE schema2.source (
+            id SERIAL PRIMARY KEY,
+            fk_type TEXT NOT NULL,
+            fk_code TEXT NOT NULL,
+            CONSTRAINT source_composite_fkey FOREIGN KEY (fk_type, fk_code)
+              REFERENCES schema2.target(type, code)
+          );
+        `);
+
+        const logger = jest.fn();
+        const { tables } = await Introspector.introspect(sequelizeSchema1, logger);
+
+        const sourceTable = tables.find(t => t.name === 'source');
+
+        // Composite FKs should be filtered out (not supported by Sequelize)
+        expect(sourceTable?.columns.find(c => c.name === 'fk_type')?.constraints).toEqual([]);
+        expect(sourceTable?.columns.find(c => c.name === 'fk_code')?.constraints).toEqual([]);
+
+        expect(logger).toHaveBeenCalledWith(
+          'Warn',
+          expect.stringContaining('Composite relations are not supported'),
+        );
       });
     });
   });