@strapi/data-transfer 5.51.2 → 5.52.1

package/dist/strapi/providers/local-source/links.d.ts

@@ -1,7 +1,10 @@
 import { Readable } from 'stream';
 import type { Core } from '@strapi/types';
+export declare const formatOrphanedLinksExportSummary: (count: number) => string;
 /**
  * Create a Readable which will stream all the links from a Strapi instance
  */
-export declare const createLinksStream: (strapi: Core.Strapi) => Readable;
+export declare const createLinksStream: (strapi: Core.Strapi, options?: {
+    onWarning?: (message: string) => void;
+}) => Readable;
 //# sourceMappingURL=links.d.ts.map

package/dist/strapi/providers/local-source/links.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../../../src/strapi/providers/local-source/links.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAK1C;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAAI,QAAQ,IAAI,CAAC,MAAM,KAAG,QAiBvD,CAAC"}
+{"version":3,"file":"links.d.ts","sourceRoot":"","sources":["../../../../src/strapi/providers/local-source/links.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,QAAQ,CAAC;AAClC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAS1C,eAAO,MAAM,gCAAgC,GAAI,OAAO,MAAM,WACkE,CAAC;AAEjI;;GAEG;AACH,eAAO,MAAM,iBAAiB,GAC5B,QAAQ,IAAI,CAAC,MAAM,EACnB,UAAS;IAAE,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAAO,aA6BxD,CAAC"}

package/dist/strapi/providers/local-source/links.js

@@ -1,26 +1,40 @@
 'use strict';
 
 var stream = require('stream');
+var cappedWarnings = require('../../../utils/capped-warnings.js');
 var link = require('../../queries/link.js');
 
+const formatOrphanedExportLinkWarning = (link)=>`Omitting link ${link.left.type}:${link.left.ref} -> ${link.right.type}:${link.right.ref} from export because a referenced entity no longer exists in the database.`;
+const formatOrphanedLinksExportSummary = (count)=>`Links export omitted ${count} relation(s) pointing at missing entities. Verify relations after import if this is unexpected.`;
 /**
  * Create a Readable which will stream all the links from a Strapi instance
- */ const createLinksStream = (strapi)=>{
+ */ const createLinksStream = (strapi, options = {})=>{
     const uids = [
         ...Object.keys(strapi.contentTypes),
         ...Object.keys(strapi.components)
     ];
+    let orphanedLinkCount = 0;
+    const warnings = cappedWarnings.createCappedWarningReporter(options.onWarning);
+    const query = link.createLinkQuery(strapi, undefined, {
+        onOrphanedLink (link) {
+            orphanedLinkCount += 1;
+            warnings.warn(formatOrphanedExportLinkWarning(link));
+        }
+    });
     // Async generator stream that returns every link from a Strapi instance
     return stream.Readable.from(async function* linkGenerator() {
-        const query = link.createLinkQuery(strapi);
         for (const uid of uids){
             const generator = query().generateAll(uid);
             for await (const link of generator){
                 yield link;
             }
         }
+        if (orphanedLinkCount > 0) {
+            options.onWarning?.(formatOrphanedLinksExportSummary(orphanedLinkCount));
+        }
     }());
 };
 
 exports.createLinksStream = createLinksStream;
+exports.formatOrphanedLinksExportSummary = formatOrphanedLinksExportSummary;
 //# sourceMappingURL=links.js.map

package/dist/strapi/providers/local-source/links.js.map

@@ -1 +1 @@
-{"version":3,"file":"links.js","sources":["../../../../src/strapi/providers/local-source/links.ts"],"sourcesContent":["import { Readable } from 'stream';\nimport type { Core } from '@strapi/types';\n\nimport type { ILink } from '../../../types';\nimport { createLinkQuery } from '../../queries/link';\n\n/**\n * Create a Readable which will stream all the links from a Strapi instance\n */\nexport const createLinksStream = (strapi: Core.Strapi): Readable => {\n  const uids = [...Object.keys(strapi.contentTypes), ...Object.keys(strapi.components)] as string[];\n\n  // Async generator stream that returns every link from a Strapi instance\n  return Readable.from(\n    (async function* linkGenerator(): AsyncGenerator<ILink> {\n      const query = createLinkQuery(strapi);\n\n      for (const uid of uids) {\n        const generator = query().generateAll(uid);\n\n        for await (const link of generator) {\n          yield link;\n        }\n      }\n    })()\n  );\n};\n"],"names":["createLinksStream","strapi","uids","Object","keys","contentTypes","components","Readable","from","linkGenerator","query","createLinkQuery","uid","generator","generateAll","link"],"mappings":";;;;;AAMA;;IAGO,MAAMA,iBAAAA,GAAoB,CAACC,MAAAA,GAAAA;AAChC,IAAA,MAAMC,IAAAA,GAAO;WAAIC,MAAAA,CAAOC,IAAI,CAACH,MAAAA,CAAOI,YAAY,CAAA;WAAMF,MAAAA,CAAOC,IAAI,CAACH,MAAAA,CAAOK,UAAU;AAAE,KAAA;;AAGrF,IAAA,OAAOC,eAAAA,CAASC,IAAI,CACjB,gBAAgBC,aAAAA,GAAAA;AACf,QAAA,MAAMC,QAAQC,oBAAAA,CAAgBV,MAAAA,CAAAA;QAE9B,KAAK,MAAMW,OAAOV,IAAAA,CAAM;YACtB,MAAMW,SAAAA,GAAYH,KAAAA,EAAAA,CAAQI,WAAW,CAACF,GAAAA,CAAAA;YAEtC,WAAW,MAAMG,QAAQF,SAAAA,CAAW;gBAClC,MAAME,IAAAA;AACR,YAAA;AACF,QAAA;AACF,IAAA,CAAA,EAAA,CAAA;AAEJ;;;;"}
+{"version":3,"file":"links.js","sources":["../../../../src/strapi/providers/local-source/links.ts"],"sourcesContent":["import { Readable } from 'stream';\nimport type { Core } from '@strapi/types';\n\nimport type { ILink } from '../../../types';\nimport { createCappedWarningReporter } from '../../../utils/capped-warnings';\nimport { createLinkQuery } from '../../queries/link';\n\nconst formatOrphanedExportLinkWarning = (link: ILink) =>\n  `Omitting link ${link.left.type}:${link.left.ref} -> ${link.right.type}:${link.right.ref} from export because a referenced entity no longer exists in the database.`;\n\nexport const formatOrphanedLinksExportSummary = (count: number) =>\n  `Links export omitted ${count} relation(s) pointing at missing entities. Verify relations after import if this is unexpected.`;\n\n/**\n * Create a Readable which will stream all the links from a Strapi instance\n */\nexport const createLinksStream = (\n  strapi: Core.Strapi,\n  options: { onWarning?: (message: string) => void } = {}\n) => {\n  const uids = [...Object.keys(strapi.contentTypes), ...Object.keys(strapi.components)] as string[];\n  let orphanedLinkCount = 0;\n  const warnings = createCappedWarningReporter(options.onWarning);\n\n  const query = createLinkQuery(strapi, undefined, {\n    onOrphanedLink(link) {\n      orphanedLinkCount += 1;\n      warnings.warn(formatOrphanedExportLinkWarning(link));\n    },\n  });\n\n  // Async generator stream that returns every link from a Strapi instance\n  return Readable.from(\n    (async function* linkGenerator(): AsyncGenerator<ILink> {\n      for (const uid of uids) {\n        const generator = query().generateAll(uid);\n\n        for await (const link of generator) {\n          yield link;\n        }\n      }\n\n      if (orphanedLinkCount > 0) {\n        options.onWarning?.(formatOrphanedLinksExportSummary(orphanedLinkCount));\n      }\n    })()\n  );\n};\n"],"names":["formatOrphanedExportLinkWarning","link","left","type","ref","right","formatOrphanedLinksExportSummary","count","createLinksStream","strapi","options","uids","Object","keys","contentTypes","components","orphanedLinkCount","warnings","createCappedWarningReporter","onWarning","query","createLinkQuery","undefined","onOrphanedLink","warn","Readable","from","linkGenerator","uid","generator","generateAll"],"mappings":";;;;;;AAOA,MAAMA,+BAAAA,GAAkC,CAACC,IAAAA,GACvC,CAAC,cAAc,EAAEA,IAAAA,CAAKC,IAAI,CAACC,IAAI,CAAC,CAAC,EAAEF,KAAKC,IAAI,CAACE,GAAG,CAAC,IAAI,EAAEH,IAAAA,CAAKI,KAAK,CAACF,IAAI,CAAC,CAAC,EAAEF,KAAKI,KAAK,CAACD,GAAG,CAAC,0EAA0E,CAAC;AAE/J,MAAME,gCAAAA,GAAmC,CAACC,KAAAA,GAC/C,CAAC,qBAAqB,EAAEA,KAAAA,CAAM,+FAA+F;AAE/H;;AAEC,IACM,MAAMC,iBAAAA,GAAoB,CAC/BC,MAAAA,EACAC,OAAAA,GAAqD,EAAE,GAAA;AAEvD,IAAA,MAAMC,IAAAA,GAAO;WAAIC,MAAAA,CAAOC,IAAI,CAACJ,MAAAA,CAAOK,YAAY,CAAA;WAAMF,MAAAA,CAAOC,IAAI,CAACJ,MAAAA,CAAOM,UAAU;AAAE,KAAA;AACrF,IAAA,IAAIC,iBAAAA,GAAoB,CAAA;IACxB,MAAMC,QAAAA,GAAWC,0CAAAA,CAA4BR,OAAAA,CAAQS,SAAS,CAAA;IAE9D,MAAMC,KAAAA,GAAQC,oBAAAA,CAAgBZ,MAAAA,EAAQa,SAAAA,EAAW;AAC/CC,QAAAA,cAAAA,CAAAA,CAAetB,IAAI,EAAA;YACjBe,iBAAAA,IAAqB,CAAA;YACrBC,QAAAA,CAASO,IAAI,CAACxB,+BAAAA,CAAgCC,IAAAA,CAAAA,CAAAA;AAChD,QAAA;AACF,KAAA,CAAA;;AAGA,IAAA,OAAOwB,eAAAA,CAASC,IAAI,CACjB,gBAAgBC,aAAAA,GAAAA;QACf,KAAK,MAAMC,OAAOjB,IAAAA,CAAM;YACtB,MAAMkB,SAAAA,GAAYT,KAAAA,EAAAA,CAAQU,WAAW,CAACF,GAAAA,CAAAA;YAEtC,WAAW,MAAM3B,QAAQ4B,SAAAA,CAAW;gBAClC,MAAM5B,IAAAA;AACR,YAAA;AACF,QAAA;AAEA,QAAA,IAAIe,oBAAoB,CAAA,EAAG;YACzBN,OAAAA,CAAQS,SAAS,GAAGb,gCAAAA,CAAiCU,iBAAAA,CAAAA,CAAAA;AACvD,QAAA;AACF,IAAA,CAAA,EAAA,CAAA;AAEJ;;;;;"}

package/dist/strapi/providers/local-source/links.mjs

@@ -1,24 +1,37 @@
 import { Readable } from 'stream';
+import { createCappedWarningReporter } from '../../../utils/capped-warnings.mjs';
 import { createLinkQuery } from '../../queries/link.mjs';
 
+const formatOrphanedExportLinkWarning = (link)=>`Omitting link ${link.left.type}:${link.left.ref} -> ${link.right.type}:${link.right.ref} from export because a referenced entity no longer exists in the database.`;
+const formatOrphanedLinksExportSummary = (count)=>`Links export omitted ${count} relation(s) pointing at missing entities. Verify relations after import if this is unexpected.`;
 /**
  * Create a Readable which will stream all the links from a Strapi instance
- */ const createLinksStream = (strapi)=>{
+ */ const createLinksStream = (strapi, options = {})=>{
     const uids = [
         ...Object.keys(strapi.contentTypes),
         ...Object.keys(strapi.components)
     ];
+    let orphanedLinkCount = 0;
+    const warnings = createCappedWarningReporter(options.onWarning);
+    const query = createLinkQuery(strapi, undefined, {
+        onOrphanedLink (link) {
+            orphanedLinkCount += 1;
+            warnings.warn(formatOrphanedExportLinkWarning(link));
+        }
+    });
     // Async generator stream that returns every link from a Strapi instance
     return Readable.from(async function* linkGenerator() {
-        const query = createLinkQuery(strapi);
         for (const uid of uids){
             const generator = query().generateAll(uid);
             for await (const link of generator){
                 yield link;
             }
         }
+        if (orphanedLinkCount > 0) {
+            options.onWarning?.(formatOrphanedLinksExportSummary(orphanedLinkCount));
+        }
     }());
 };
 
-export { createLinksStream };
+export { createLinksStream, formatOrphanedLinksExportSummary };
 //# sourceMappingURL=links.mjs.map

package/dist/strapi/providers/local-source/links.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"links.mjs","sources":["../../../../src/strapi/providers/local-source/links.ts"],"sourcesContent":["import { Readable } from 'stream';\nimport type { Core } from '@strapi/types';\n\nimport type { ILink } from '../../../types';\nimport { createLinkQuery } from '../../queries/link';\n\n/**\n * Create a Readable which will stream all the links from a Strapi instance\n */\nexport const createLinksStream = (strapi: Core.Strapi): Readable => {\n  const uids = [...Object.keys(strapi.contentTypes), ...Object.keys(strapi.components)] as string[];\n\n  // Async generator stream that returns every link from a Strapi instance\n  return Readable.from(\n    (async function* linkGenerator(): AsyncGenerator<ILink> {\n      const query = createLinkQuery(strapi);\n\n      for (const uid of uids) {\n        const generator = query().generateAll(uid);\n\n        for await (const link of generator) {\n          yield link;\n        }\n      }\n    })()\n  );\n};\n"],"names":["createLinksStream","strapi","uids","Object","keys","contentTypes","components","Readable","from","linkGenerator","query","createLinkQuery","uid","generator","generateAll","link"],"mappings":";;;AAMA;;IAGO,MAAMA,iBAAAA,GAAoB,CAACC,MAAAA,GAAAA;AAChC,IAAA,MAAMC,IAAAA,GAAO;WAAIC,MAAAA,CAAOC,IAAI,CAACH,MAAAA,CAAOI,YAAY,CAAA;WAAMF,MAAAA,CAAOC,IAAI,CAACH,MAAAA,CAAOK,UAAU;AAAE,KAAA;;AAGrF,IAAA,OAAOC,QAAAA,CAASC,IAAI,CACjB,gBAAgBC,aAAAA,GAAAA;AACf,QAAA,MAAMC,QAAQC,eAAAA,CAAgBV,MAAAA,CAAAA;QAE9B,KAAK,MAAMW,OAAOV,IAAAA,CAAM;YACtB,MAAMW,SAAAA,GAAYH,KAAAA,EAAAA,CAAQI,WAAW,CAACF,GAAAA,CAAAA;YAEtC,WAAW,MAAMG,QAAQF,SAAAA,CAAW;gBAClC,MAAME,IAAAA;AACR,YAAA;AACF,QAAA;AACF,IAAA,CAAA,EAAA,CAAA;AAEJ;;;;"}
+{"version":3,"file":"links.mjs","sources":["../../../../src/strapi/providers/local-source/links.ts"],"sourcesContent":["import { Readable } from 'stream';\nimport type { Core } from '@strapi/types';\n\nimport type { ILink } from '../../../types';\nimport { createCappedWarningReporter } from '../../../utils/capped-warnings';\nimport { createLinkQuery } from '../../queries/link';\n\nconst formatOrphanedExportLinkWarning = (link: ILink) =>\n  `Omitting link ${link.left.type}:${link.left.ref} -> ${link.right.type}:${link.right.ref} from export because a referenced entity no longer exists in the database.`;\n\nexport const formatOrphanedLinksExportSummary = (count: number) =>\n  `Links export omitted ${count} relation(s) pointing at missing entities. Verify relations after import if this is unexpected.`;\n\n/**\n * Create a Readable which will stream all the links from a Strapi instance\n */\nexport const createLinksStream = (\n  strapi: Core.Strapi,\n  options: { onWarning?: (message: string) => void } = {}\n) => {\n  const uids = [...Object.keys(strapi.contentTypes), ...Object.keys(strapi.components)] as string[];\n  let orphanedLinkCount = 0;\n  const warnings = createCappedWarningReporter(options.onWarning);\n\n  const query = createLinkQuery(strapi, undefined, {\n    onOrphanedLink(link) {\n      orphanedLinkCount += 1;\n      warnings.warn(formatOrphanedExportLinkWarning(link));\n    },\n  });\n\n  // Async generator stream that returns every link from a Strapi instance\n  return Readable.from(\n    (async function* linkGenerator(): AsyncGenerator<ILink> {\n      for (const uid of uids) {\n        const generator = query().generateAll(uid);\n\n        for await (const link of generator) {\n          yield link;\n        }\n      }\n\n      if (orphanedLinkCount > 0) {\n        options.onWarning?.(formatOrphanedLinksExportSummary(orphanedLinkCount));\n      }\n    })()\n  );\n};\n"],"names":["formatOrphanedExportLinkWarning","link","left","type","ref","right","formatOrphanedLinksExportSummary","count","createLinksStream","strapi","options","uids","Object","keys","contentTypes","components","orphanedLinkCount","warnings","createCappedWarningReporter","onWarning","query","createLinkQuery","undefined","onOrphanedLink","warn","Readable","from","linkGenerator","uid","generator","generateAll"],"mappings":";;;;AAOA,MAAMA,+BAAAA,GAAkC,CAACC,IAAAA,GACvC,CAAC,cAAc,EAAEA,IAAAA,CAAKC,IAAI,CAACC,IAAI,CAAC,CAAC,EAAEF,KAAKC,IAAI,CAACE,GAAG,CAAC,IAAI,EAAEH,IAAAA,CAAKI,KAAK,CAACF,IAAI,CAAC,CAAC,EAAEF,KAAKI,KAAK,CAACD,GAAG,CAAC,0EAA0E,CAAC;AAE/J,MAAME,gCAAAA,GAAmC,CAACC,KAAAA,GAC/C,CAAC,qBAAqB,EAAEA,KAAAA,CAAM,+FAA+F;AAE/H;;AAEC,IACM,MAAMC,iBAAAA,GAAoB,CAC/BC,MAAAA,EACAC,OAAAA,GAAqD,EAAE,GAAA;AAEvD,IAAA,MAAMC,IAAAA,GAAO;WAAIC,MAAAA,CAAOC,IAAI,CAACJ,MAAAA,CAAOK,YAAY,CAAA;WAAMF,MAAAA,CAAOC,IAAI,CAACJ,MAAAA,CAAOM,UAAU;AAAE,KAAA;AACrF,IAAA,IAAIC,iBAAAA,GAAoB,CAAA;IACxB,MAAMC,QAAAA,GAAWC,2BAAAA,CAA4BR,OAAAA,CAAQS,SAAS,CAAA;IAE9D,MAAMC,KAAAA,GAAQC,eAAAA,CAAgBZ,MAAAA,EAAQa,SAAAA,EAAW;AAC/CC,QAAAA,cAAAA,CAAAA,CAAetB,IAAI,EAAA;YACjBe,iBAAAA,IAAqB,CAAA;YACrBC,QAAAA,CAASO,IAAI,CAACxB,+BAAAA,CAAgCC,IAAAA,CAAAA,CAAAA;AAChD,QAAA;AACF,KAAA,CAAA;;AAGA,IAAA,OAAOwB,QAAAA,CAASC,IAAI,CACjB,gBAAgBC,aAAAA,GAAAA;QACf,KAAK,MAAMC,OAAOjB,IAAAA,CAAM;YACtB,MAAMkB,SAAAA,GAAYT,KAAAA,EAAAA,CAAQU,WAAW,CAACF,GAAAA,CAAAA;YAEtC,WAAW,MAAM3B,QAAQ4B,SAAAA,CAAW;gBAClC,MAAM5B,IAAAA;AACR,YAAA;AACF,QAAA;AAEA,QAAA,IAAIe,oBAAoB,CAAA,EAAG;YACzBN,OAAAA,CAAQS,SAAS,GAAGb,gCAAAA,CAAiCU,iBAAAA,CAAAA,CAAAA;AACvD,QAAA;AACF,IAAA,CAAA,EAAA,CAAA;AAEJ;;;;"}

package/dist/strapi/queries/link.d.ts

@@ -1,7 +1,10 @@
 import type { Knex } from 'knex';
 import type { Core } from '@strapi/types';
 import { ILink } from '../../types';
-export declare const createLinkQuery: (strapi: Core.Strapi, trx?: Knex.Transaction) => () => {
+export interface LinkQueryOptions {
+    onOrphanedLink?: (link: ILink) => void;
+}
+export declare const createLinkQuery: (strapi: Core.Strapi, trx?: Knex.Transaction, options?: LinkQueryOptions) => () => {
     generateAll: (uid: string) => AsyncGenerator<ILink>;
     generateAllForAttribute: (uid: string, fieldName: string) => AsyncGenerator<ILink>;
     insert: (link: ILink) => Promise<void>;

package/dist/strapi/queries/link.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../src/strapi/queries/link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAE1C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAIpC,eAAO,MAAM,eAAe,GAAI,QAAQ,IAAI,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC,WAAW;uBAmMtC,MAAM,KAAG,cAAc,CAAC,KAAK,CAAC;mCAzLlB,MAAM,aAAa,MAAM,KAAG,cAAc,CAAC,KAAK,CAAC;mBAyMlE,KAAK;CA+GpC,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,wBAY9E,CAAC"}
+{"version":3,"file":"link.d.ts","sourceRoot":"","sources":["../../../src/strapi/queries/link.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,MAAM,CAAC;AAEjC,OAAO,KAAK,EAAE,IAAI,EAAO,MAAM,eAAe,CAAC;AAE/C,OAAO,EAAE,KAAK,EAAE,MAAM,aAAa,CAAC;AAkHpC,MAAM,WAAW,gBAAgB;IAC/B,cAAc,CAAC,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC;CACxC;AAOD,eAAO,MAAM,eAAe,GAC1B,QAAQ,IAAI,CAAC,MAAM,EACnB,MAAM,IAAI,CAAC,WAAW,EACtB,UAAU,gBAAgB;uBAgVS,MAAM,KAAG,cAAc,CAAC,KAAK,CAAC;mCAnUlB,MAAM,aAAa,MAAM,KAAG,cAAc,CAAC,KAAK,CAAC;mBAmVlE,KAAK;CA+GpC,CAAC;AAEF,eAAO,MAAM,+BAA+B,GAAI,YAAY,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,wBAY9E,CAAC"}

package/dist/strapi/queries/link.js

@@ -3,7 +3,105 @@
 var fp = require('lodash/fp');
 
 // TODO: Remove any types when we'll have types for DB metadata
-const createLinkQuery = (strapi, trx)=>{
+const TARGET_EXISTS_ALIAS = '__target_exists';
+const LEFT_EXISTS_ALIAS = '__left_exists';
+const RIGHT_EXISTS_ALIAS = '__right_exists';
+const EXISTENCE_CHECK_CHUNK_SIZE = 1000;
+const getMetadataTableName = (strapi, uid)=>{
+    const metadata = strapi.db.metadata.get(uid);
+    if (!metadata) {
+        throw new Error(`No metadata found for ${uid}`);
+    }
+    return metadata.tableName;
+};
+const refKey = (ref)=>`${typeof ref}:${ref}`;
+/**
+ * Batch-load which refs exist for a content type. Handles numeric `id` refs and
+ * string `documentId` refs separately, chunked to keep `IN (...)` lists bounded.
+ */ const loadExistingRefs = async (strapi, uid, refs)=>{
+    const existing = new Set();
+    // Stale morph type UIDs (removed components/CTs) have no metadata — treat as orphaned.
+    if (!strapi.db.metadata.has(uid)) {
+        return existing;
+    }
+    const uniqueRefs = [
+        ...new Set(refs)
+    ];
+    const numericIds = uniqueRefs.filter((ref)=>typeof ref === 'number');
+    const documentIds = uniqueRefs.filter((ref)=>typeof ref === 'string');
+    for(let i = 0; i < numericIds.length; i += EXISTENCE_CHECK_CHUNK_SIZE){
+        const chunk = numericIds.slice(i, i + EXISTENCE_CHECK_CHUNK_SIZE);
+        const rows = await strapi.db.query(uid).findMany({
+            select: [
+                'id'
+            ],
+            where: {
+                id: {
+                    $in: chunk
+                }
+            }
+        });
+        for (const row of rows){
+            existing.add(refKey(row.id));
+        }
+    }
+    for(let i = 0; i < documentIds.length; i += EXISTENCE_CHECK_CHUNK_SIZE){
+        const chunk = documentIds.slice(i, i + EXISTENCE_CHECK_CHUNK_SIZE);
+        const rows = await strapi.db.query(uid).findMany({
+            select: [
+                'id',
+                'documentId'
+            ],
+            where: {
+                documentId: {
+                    $in: chunk
+                }
+            }
+        });
+        for (const row of rows){
+            if (row.documentId != null) {
+                existing.add(refKey(row.documentId));
+            }
+        }
+    }
+    return existing;
+};
+/**
+ * Filter morph links in batches. The morph owner (`left`) is not checked:
+ * morphColumn rows come from the owner table itself, and morph join-table
+ * owners are FK-backed. Only dynamic morph targets (`right`) need existence
+ * checks, and those have no DB-level FK.
+ */ const filterMorphLinksByTargetExistence = async function* filterMorphLinksByTargetExistence(strapi, links, onOrphanedLink) {
+    const refsByType = new Map();
+    for (const link of links){
+        const { type, ref } = link.right;
+        if (ref == null || type == null) {
+            onOrphanedLink?.(link);
+        } else {
+            const bucket = refsByType.get(type) ?? [];
+            bucket.push(ref);
+            refsByType.set(type, bucket);
+        }
+    }
+    const existingByType = new Map();
+    for (const [type, refs] of refsByType){
+        existingByType.set(type, await loadExistingRefs(strapi, type, refs));
+    }
+    for (const link of links){
+        const { type, ref } = link.right;
+        if (ref == null || type == null) ; else if (existingByType.get(type)?.has(refKey(ref))) {
+            yield link;
+        } else {
+            onOrphanedLink?.(link);
+        }
+    }
+};
+const aliasColumn = (tableAlias, column)=>`${tableAlias}.${column}`;
+const selectAliasedColumns = (tableAlias, columns)=>columns.map((column)=>({
+            [column]: aliasColumn(tableAlias, column)
+        }));
+const createLinkQuery = (strapi, trx, options)=>{
+    const { onOrphanedLink } = options ?? {};
     const query = ()=>{
         const { connection } = strapi.db;
         // TODO: Export utils from database and use the addSchema that is already written
@@ -27,7 +125,34 @@ const createLinkQuery = (strapi, trx)=>{
             // TODO: handle manyToOne joinColumn
             if (attribute.joinColumn) {
                 const joinColumnName = attribute.joinColumn.name;
-                const qb = connection.queryBuilder().select('id', joinColumnName).from(addSchema(metadata.tableName));
+                const referencedColumn = attribute.joinColumn.referencedColumn ?? 'id';
+                const ownerAlias = 'owner';
+                const targetAlias = 'target';
+                const ownerTable = addSchema(metadata.tableName);
+                const targetTable = addSchema(getMetadataTableName(strapi, target));
+                // Use EXISTS (not JOIN): joining on non-unique referencedColumn (e.g. i18n
+                // document_id) multiplies owner rows by matching target locales.
+                const targetExistsSubquery = ()=>connection.queryBuilder().select(connection.raw('1')).from({
+                        [targetAlias]: targetTable
+                    }).whereRaw('??.?? = ??.??', [
+                        targetAlias,
+                        referencedColumn,
+                        ownerAlias,
+                        joinColumnName
+                    ]);
+                const qb = connection.queryBuilder().select(`${ownerAlias}.id`, `${ownerAlias}.${joinColumnName} as ${joinColumnName}`, ...onOrphanedLink ? // becomes `exists ((select ...))`, which SQLite rejects in a SELECT
+                // list. Wrap the EXISTS expression so the compiled SQL is valid.
+                [
+                    connection.raw('(exists ?) as ??', [
+                        targetExistsSubquery(),
+                        TARGET_EXISTS_ALIAS
+                    ])
+                ] : []).from({
+                    [ownerAlias]: ownerTable
+                }).whereNotNull(aliasColumn(ownerAlias, joinColumnName));
+                if (!onOrphanedLink) {
+                    qb.whereExists(targetExistsSubquery());
+                }
                 if (trx) {
                     qb.transacting(trx);
                 }
@@ -35,27 +160,30 @@ const createLinkQuery = (strapi, trx)=>{
                 const entries = await qb;
                 for (const entry of entries){
                     const ref = entry[joinColumnName];
-                    if (ref !== null) {
-                        yield {
-                            kind,
-                            relation,
-                            left: {
-                                type: uid,
-                                ref: entry.id,
-                                field: fieldName
-                            },
-                            right: {
-                                type: target,
-                                ref
-                            }
-                        };
+                    const link = {
+                        kind,
+                        relation,
+                        left: {
+                            type: uid,
+                            ref: entry.id,
+                            field: fieldName
+                        },
+                        right: {
+                            type: target,
+                            ref
+                        }
+                    };
+                    // EXISTS yields 0/1 (or boolean); treat falsy as orphaned.
+                    if (onOrphanedLink && !entry[TARGET_EXISTS_ALIAS]) {
+                        onOrphanedLink(link);
+                    } else {
+                        yield link;
                     }
                 }
             }
             // The relation uses a join table
             if (attribute.joinTable) {
                 const { name, joinColumn, inverseJoinColumn, orderColumnName, morphColumn, inverseOrderColumnName } = attribute.joinTable;
-                const qb = connection.queryBuilder().from(addSchema(name));
                 const columns = {
                     left: {
                         ref: null
@@ -80,56 +208,137 @@ const createLinkQuery = (strapi, trx)=>{
                     if (inverseOrderColumnName) {
                         columns.right.order = inverseOrderColumnName;
                     }
+                    const joinAlias = 'join';
+                    const leftAlias = 'left';
+                    const rightAlias = 'right';
+                    const joinTable = addSchema(name);
+                    const leftTable = addSchema(metadata.tableName);
+                    const rightTable = addSchema(getMetadataTableName(strapi, attribute.target));
+                    const leftReferencedColumn = aliasColumn(leftAlias, joinColumn.referencedColumn ?? 'id');
+                    const rightReferencedColumn = aliasColumn(rightAlias, inverseJoinColumn.referencedColumn ?? 'id');
+                    const validColumns = [
+                        columns.left.ref,
+                        columns.left.order,
+                        columns.right.ref,
+                        columns.right.order
+                    ].filter((column)=>!fp.isNil(column));
+                    const buildJoinTableLink = (entry)=>{
+                        const linkLeft = {
+                            type: uid,
+                            field: fieldName
+                        };
+                        const linkRight = {
+                            type: attribute.target,
+                            field: attribute.inversedBy
+                        };
+                        if (columns.left.ref) {
+                            linkLeft.ref = entry[columns.left.ref];
+                        }
+                        if (columns.right.ref) {
+                            linkRight.ref = entry[columns.right.ref];
+                        }
+                        if (columns.left.order) {
+                            linkLeft.pos = entry[columns.left.order];
+                        }
+                        if (columns.right.order) {
+                            linkRight.pos = entry[columns.right.order];
+                        }
+                        return {
+                            kind,
+                            relation,
+                            left: fp.clone(linkLeft),
+                            right: fp.clone(linkRight)
+                        };
+                    };
+                    const selectColumns = [
+                        ...selectAliasedColumns(joinAlias, validColumns),
+                        ...onOrphanedLink ? [
+                            {
+                                [LEFT_EXISTS_ALIAS]: leftReferencedColumn
+                            },
+                            {
+                                [RIGHT_EXISTS_ALIAS]: rightReferencedColumn
+                            }
+                        ] : []
+                    ];
+                    const joinQb = connection.queryBuilder().select(selectColumns).from({
+                        [joinAlias]: joinTable
+                    });
+                    if (onOrphanedLink) {
+                        joinQb.leftJoin({
+                            [leftAlias]: leftTable
+                        }, aliasColumn(joinAlias, joinColumn.name), leftReferencedColumn).leftJoin({
+                            [rightAlias]: rightTable
+                        }, aliasColumn(joinAlias, inverseJoinColumn.name), rightReferencedColumn);
+                    } else {
+                        joinQb.innerJoin({
+                            [leftAlias]: leftTable
+                        }, aliasColumn(joinAlias, joinColumn.name), leftReferencedColumn).innerJoin({
+                            [rightAlias]: rightTable
+                        }, aliasColumn(joinAlias, inverseJoinColumn.name), rightReferencedColumn);
+                    }
+                    if (trx) {
+                        joinQb.transacting(trx);
+                    }
+                    const entries = await joinQb;
+                    for (const entry of entries){
+                        const link = buildJoinTableLink(entry);
+                        if (onOrphanedLink && (entry[LEFT_EXISTS_ALIAS] == null || entry[RIGHT_EXISTS_ALIAS] == null)) {
+                            onOrphanedLink(link);
+                        } else {
+                            yield link;
+                        }
+                    }
                 }
                 if (kind === 'relation.morph') {
+                    const qb = connection.queryBuilder().from(addSchema(name));
                     columns.left.ref = joinColumn.name;
                     columns.right.ref = morphColumn.idColumn.name;
                     columns.right.type = morphColumn.typeColumn.name;
                     columns.right.field = 'field';
                     columns.right.order = 'order';
-                }
-                const validColumns = [
-                    // Left
-                    columns.left.ref,
-                    columns.left.order,
-                    // Right
-                    columns.right.ref,
-                    columns.right.type,
-                    columns.right.field,
-                    columns.right.order
-                ].filter((column)=>!fp.isNil(column));
-                qb.select(validColumns);
-                if (trx) {
-                    qb.transacting(trx);
-                }
-                // TODO: stream the query to improve performances
-                const entries = await qb;
-                for (const entry of entries){
-                    if (columns.left.ref) {
-                        left.ref = entry[columns.left.ref];
-                    }
-                    if (columns.right.ref) {
-                        right.ref = entry[columns.right.ref];
+                    const validColumns = [
+                        columns.left.ref,
+                        columns.left.order,
+                        columns.right.ref,
+                        columns.right.type,
+                        columns.right.field,
+                        columns.right.order
+                    ].filter((column)=>!fp.isNil(column));
+                    qb.select(validColumns);
+                    if (trx) {
+                        qb.transacting(trx);
                     }
-                    if (columns.left.order) {
-                        left.pos = entry[columns.left.order];
-                    }
-                    if (columns.right.order) {
-                        right.pos = entry[columns.right.order];
-                    }
-                    if (columns.right.type) {
-                        right.type = entry[columns.right.type];
-                    }
-                    if (columns.right.field) {
-                        right.field = entry[columns.right.field];
+                    // TODO: stream the query to improve performances
+                    const entries = await qb;
+                    const morphLinks = [];
+                    for (const entry of entries){
+                        if (columns.left.ref) {
+                            left.ref = entry[columns.left.ref];
+                        }
+                        if (columns.right.ref) {
+                            right.ref = entry[columns.right.ref];
+                        }
+                        if (columns.left.order) {
+                            left.pos = entry[columns.left.order];
+                        }
+                        if (columns.right.order) {
+                            right.pos = entry[columns.right.order];
+                        }
+                        if (columns.right.type) {
+                            right.type = entry[columns.right.type];
+                        }
+                        if (columns.right.field) {
+                            right.field = entry[columns.right.field];
+                        }
+                        morphLinks.push({
+                            kind,
+                            relation,
+                            left: fp.clone(left),
+                            right: fp.clone(right)
+                        });
                     }
-                    const link = {
-                        kind,
-                        relation,
-                        left: fp.clone(left),
-                        right: fp.clone(right)
-                    };
-                    yield link;
+                    yield* filterMorphLinksByTargetExistence(strapi, morphLinks, onOrphanedLink);
                 }
             }
             if (attribute.morphColumn) {
@@ -139,9 +348,7 @@ const createLinkQuery = (strapi, trx)=>{
                     qb.transacting(trx);
                 }
                 const entries = await qb;
-                for (const entry of entries){
-                    const ref = entry[idColumn.name];
-                    yield {
+                const morphLinks = entries.map((entry)=>({
                         kind,
                         relation,
                         left: {
@@ -151,10 +358,10 @@ const createLinkQuery = (strapi, trx)=>{
                         },
                         right: {
                             type: entry[typeColumn.name],
-                            ref
+                            ref: entry[idColumn.name]
                         }
-                    };
-                }
+                    }));
+                yield* filterMorphLinksByTargetExistence(strapi, morphLinks, onOrphanedLink);
             }
         }
         async function* generateAll(uid) {