@strapi/database 5.23.6 → 5.24.0

package/dist/repairs/index.d.ts

@@ -1,6 +1,7 @@
 import type { Database } from '..';
 export declare const createRepairManager: (db: Database) => {
     removeOrphanMorphType: (arg: import("./operations/remove-orphan-morph-types").RemoveOrphanMorphTypeOptions) => Promise<void>;
+    processUnidirectionalJoinTables: (arg: (db: Database, joinTableName: string, relation: any, sourceModel: any) => Promise<number>) => Promise<number>;
 };
 export type RepairManager = ReturnType<typeof createRepairManager>;
 //# sourceMappingURL=index.d.ts.map

package/dist/repairs/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/repairs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAInC,eAAO,MAAM,mBAAmB,OAAQ,QAAQ;;CAI/C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/repairs/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,IAAI,CAAC;AAKnC,eAAO,MAAM,mBAAmB,OAAQ,QAAQ;;;CAK/C,CAAC;AAEF,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/repairs/index.js

@@ -1,11 +1,13 @@
 'use strict';
 
 var removeOrphanMorphTypes = require('./operations/remove-orphan-morph-types.js');
+var processUnidirectionalJoinTables = require('./operations/process-unidirectional-join-tables.js');
 var asyncCurry = require('../utils/async-curry.js');
 
 const createRepairManager = (db)=>{
     return {
-        removeOrphanMorphType: asyncCurry.asyncCurry(removeOrphanMorphTypes.removeOrphanMorphType)(db)
+        removeOrphanMorphType: asyncCurry.asyncCurry(removeOrphanMorphTypes.removeOrphanMorphType)(db),
+        processUnidirectionalJoinTables: asyncCurry.asyncCurry(processUnidirectionalJoinTables.processUnidirectionalJoinTables)(db)
     };
 };
 

package/dist/repairs/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sources":["../../src/repairs/index.ts"],"sourcesContent":["import type { Database } from '..';\nimport { removeOrphanMorphType as removeOrphanMorphTypeFunc } from './operations/remove-orphan-morph-types';\nimport { asyncCurry } from '../utils/async-curry';\n\nexport const createRepairManager = (db: Database) => {\n  return {\n    removeOrphanMorphType: asyncCurry(removeOrphanMorphTypeFunc)(db),\n  };\n};\n\nexport type RepairManager = ReturnType<typeof createRepairManager>;\n"],"names":["createRepairManager","db","removeOrphanMorphType","asyncCurry","removeOrphanMorphTypeFunc"],"mappings":";;;;;AAIO,MAAMA,sBAAsB,CAACC,EAAAA,GAAAA;IAClC,OAAO;AACLC,QAAAA,qBAAAA,EAAuBC,sBAAWC,4CAA2BH,CAAAA,CAAAA,EAAAA;AAC/D,KAAA;AACF;;;;"}
+{"version":3,"file":"index.js","sources":["../../src/repairs/index.ts"],"sourcesContent":["import type { Database } from '..';\nimport { removeOrphanMorphType as removeOrphanMorphTypeFunc } from './operations/remove-orphan-morph-types';\nimport { processUnidirectionalJoinTables } from './operations/process-unidirectional-join-tables';\nimport { asyncCurry } from '../utils/async-curry';\n\nexport const createRepairManager = (db: Database) => {\n  return {\n    removeOrphanMorphType: asyncCurry(removeOrphanMorphTypeFunc)(db),\n    processUnidirectionalJoinTables: asyncCurry(processUnidirectionalJoinTables)(db),\n  };\n};\n\nexport type RepairManager = ReturnType<typeof createRepairManager>;\n"],"names":["createRepairManager","db","removeOrphanMorphType","asyncCurry","removeOrphanMorphTypeFunc","processUnidirectionalJoinTables"],"mappings":";;;;;;AAKO,MAAMA,sBAAsB,CAACC,EAAAA,GAAAA;IAClC,OAAO;AACLC,QAAAA,qBAAAA,EAAuBC,sBAAWC,4CAA2BH,CAAAA,CAAAA,EAAAA,CAAAA;AAC7DI,QAAAA,+BAAAA,EAAiCF,sBAAWE,+DAAiCJ,CAAAA,CAAAA,EAAAA;AAC/E,KAAA;AACF;;;;"}

package/dist/repairs/index.mjs

@@ -1,9 +1,11 @@
 import { removeOrphanMorphType } from './operations/remove-orphan-morph-types.mjs';
+import { processUnidirectionalJoinTables } from './operations/process-unidirectional-join-tables.mjs';
 import { asyncCurry } from '../utils/async-curry.mjs';
 
 const createRepairManager = (db)=>{
     return {
-        removeOrphanMorphType: asyncCurry(removeOrphanMorphType)(db)
+        removeOrphanMorphType: asyncCurry(removeOrphanMorphType)(db),
+        processUnidirectionalJoinTables: asyncCurry(processUnidirectionalJoinTables)(db)
     };
 };
 

package/dist/repairs/index.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.mjs","sources":["../../src/repairs/index.ts"],"sourcesContent":["import type { Database } from '..';\nimport { removeOrphanMorphType as removeOrphanMorphTypeFunc } from './operations/remove-orphan-morph-types';\nimport { asyncCurry } from '../utils/async-curry';\n\nexport const createRepairManager = (db: Database) => {\n  return {\n    removeOrphanMorphType: asyncCurry(removeOrphanMorphTypeFunc)(db),\n  };\n};\n\nexport type RepairManager = ReturnType<typeof createRepairManager>;\n"],"names":["createRepairManager","db","removeOrphanMorphType","asyncCurry","removeOrphanMorphTypeFunc"],"mappings":";;;AAIO,MAAMA,sBAAsB,CAACC,EAAAA,GAAAA;IAClC,OAAO;AACLC,QAAAA,qBAAAA,EAAuBC,WAAWC,qBAA2BH,CAAAA,CAAAA,EAAAA;AAC/D,KAAA;AACF;;;;"}
+{"version":3,"file":"index.mjs","sources":["../../src/repairs/index.ts"],"sourcesContent":["import type { Database } from '..';\nimport { removeOrphanMorphType as removeOrphanMorphTypeFunc } from './operations/remove-orphan-morph-types';\nimport { processUnidirectionalJoinTables } from './operations/process-unidirectional-join-tables';\nimport { asyncCurry } from '../utils/async-curry';\n\nexport const createRepairManager = (db: Database) => {\n  return {\n    removeOrphanMorphType: asyncCurry(removeOrphanMorphTypeFunc)(db),\n    processUnidirectionalJoinTables: asyncCurry(processUnidirectionalJoinTables)(db),\n  };\n};\n\nexport type RepairManager = ReturnType<typeof createRepairManager>;\n"],"names":["createRepairManager","db","removeOrphanMorphType","asyncCurry","removeOrphanMorphTypeFunc","processUnidirectionalJoinTables"],"mappings":";;;;AAKO,MAAMA,sBAAsB,CAACC,EAAAA,GAAAA;IAClC,OAAO;AACLC,QAAAA,qBAAAA,EAAuBC,WAAWC,qBAA2BH,CAAAA,CAAAA,EAAAA,CAAAA;AAC7DI,QAAAA,+BAAAA,EAAiCF,WAAWE,+BAAiCJ,CAAAA,CAAAA,EAAAA;AAC/E,KAAA;AACF;;;;"}

package/dist/repairs/operations/process-unidirectional-join-tables.d.ts

@@ -0,0 +1,14 @@
+import type { Database } from '../..';
+/**
+ * Iterates over all models and their unidirectional relations, invoking a provided operation on each join table.
+ *
+ * This function does not perform any cleaning or modification itself. Instead, it identifies all unidirectional
+ * relations (relations without inversedBy or mappedBy) that use join tables, and delegates any join table operation
+ * (such as cleaning, validation, or analysis) to the provided operateOnJoinTable function.
+ *
+ * @param db - The database instance
+ * @param operateOnJoinTable - A function to execute for each unidirectional join table relation
+ * @returns The sum of results returned by operateOnJoinTable for all processed relations
+ */
+export declare const processUnidirectionalJoinTables: (db: Database, operateOnJoinTable: (db: Database, joinTableName: string, relation: any, sourceModel: any) => Promise<number>) => Promise<number>;
+//# sourceMappingURL=process-unidirectional-join-tables.d.ts.map

package/dist/repairs/operations/process-unidirectional-join-tables.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-unidirectional-join-tables.d.ts","sourceRoot":"","sources":["../../../src/repairs/operations/process-unidirectional-join-tables.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAC;AAEtC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,+BAA+B,OACtC,QAAQ,sBACQ,CAClB,EAAE,EAAE,QAAQ,EACZ,aAAa,EAAE,MAAM,EACrB,QAAQ,EAAE,GAAG,EACb,WAAW,EAAE,GAAG,KACb,QAAQ,MAAM,CAAC,KACnB,QAAQ,MAAM,CA4BhB,CAAC"}

package/dist/repairs/operations/process-unidirectional-join-tables.js

@@ -0,0 +1,57 @@
+'use strict';
+
+/**
+ * Iterates over all models and their unidirectional relations, invoking a provided operation on each join table.
+ *
+ * This function does not perform any cleaning or modification itself. Instead, it identifies all unidirectional
+ * relations (relations without inversedBy or mappedBy) that use join tables, and delegates any join table operation
+ * (such as cleaning, validation, or analysis) to the provided operateOnJoinTable function.
+ *
+ * @param db - The database instance
+ * @param operateOnJoinTable - A function to execute for each unidirectional join table relation
+ * @returns The sum of results returned by operateOnJoinTable for all processed relations
+ */ const processUnidirectionalJoinTables = async (db, operateOnJoinTable)=>{
+    let totalResult = 0;
+    const mdValues = db.metadata.values();
+    const mdArray = Array.from(mdValues);
+    if (mdArray.length === 0) {
+        return 0;
+    }
+    db.logger.debug('Starting unidirectional join table operation');
+    for (const model of mdArray){
+        const unidirectionalRelations = getUnidirectionalRelations(model.attributes || {});
+        for (const relation of unidirectionalRelations){
+            if (hasJoinTable(relation) && hasTarget(relation)) {
+                const result = await operateOnJoinTable(db, relation.joinTable.name, relation, model);
+                totalResult += result;
+            }
+        }
+    }
+    db.logger.debug(`Unidirectional join table operation completed. Processed ${totalResult} entries.`);
+    return totalResult;
+};
+/**
+ * Identifies unidirectional relations (relations without inversedBy or mappedBy)
+ * Uses same logic as prevention fix in unidirectional-relations.ts:54-61
+ */ const getUnidirectionalRelations = (attributes)=>{
+    return Object.values(attributes).filter((attribute)=>{
+        if (attribute.type !== 'relation') {
+            return false;
+        }
+        // Check if it's unidirectional (no inversedBy or mappedBy) - same as prevention logic
+        return !attribute.inversedBy && !attribute.mappedBy;
+    });
+};
+/**
+ * Type guard to check if a relation has a joinTable property
+ */ const hasJoinTable = (relation)=>{
+    return 'joinTable' in relation && relation.joinTable != null;
+};
+/**
+ * Type guard to check if a relation has a target property
+ */ const hasTarget = (relation)=>{
+    return 'target' in relation && typeof relation.target === 'string';
+};
+
+exports.processUnidirectionalJoinTables = processUnidirectionalJoinTables;
+//# sourceMappingURL=process-unidirectional-join-tables.js.map

package/dist/repairs/operations/process-unidirectional-join-tables.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-unidirectional-join-tables.js","sources":["../../../src/repairs/operations/process-unidirectional-join-tables.ts"],"sourcesContent":["import type { Database } from '../..';\n\n/**\n * Iterates over all models and their unidirectional relations, invoking a provided operation on each join table.\n *\n * This function does not perform any cleaning or modification itself. Instead, it identifies all unidirectional\n * relations (relations without inversedBy or mappedBy) that use join tables, and delegates any join table operation\n * (such as cleaning, validation, or analysis) to the provided operateOnJoinTable function.\n *\n * @param db - The database instance\n * @param operateOnJoinTable - A function to execute for each unidirectional join table relation\n * @returns The sum of results returned by operateOnJoinTable for all processed relations\n */\nexport const processUnidirectionalJoinTables = async (\n  db: Database,\n  operateOnJoinTable: (\n    db: Database,\n    joinTableName: string,\n    relation: any,\n    sourceModel: any\n  ) => Promise<number>\n): Promise<number> => {\n  let totalResult = 0;\n\n  const mdValues = db.metadata.values();\n  const mdArray = Array.from(mdValues);\n\n  if (mdArray.length === 0) {\n    return 0;\n  }\n\n  db.logger.debug('Starting unidirectional join table operation');\n\n  for (const model of mdArray) {\n    const unidirectionalRelations = getUnidirectionalRelations(model.attributes || {});\n\n    for (const relation of unidirectionalRelations) {\n      if (hasJoinTable(relation) && hasTarget(relation)) {\n        const result = await operateOnJoinTable(db, relation.joinTable.name, relation, model);\n        totalResult += result;\n      }\n    }\n  }\n\n  db.logger.debug(\n    `Unidirectional join table operation completed. Processed ${totalResult} entries.`\n  );\n\n  return totalResult;\n};\n\n/**\n * Identifies unidirectional relations (relations without inversedBy or mappedBy)\n * Uses same logic as prevention fix in unidirectional-relations.ts:54-61\n */\nconst getUnidirectionalRelations = (attributes: Record<string, any>): any[] => {\n  return Object.values(attributes).filter((attribute) => {\n    if (attribute.type !== 'relation') {\n      return false;\n    }\n\n    // Check if it's unidirectional (no inversedBy or mappedBy) - same as prevention logic\n    return !attribute.inversedBy && !attribute.mappedBy;\n  });\n};\n\n/**\n * Type guard to check if a relation has a joinTable property\n */\nconst hasJoinTable = (relation: any): boolean => {\n  return 'joinTable' in relation && relation.joinTable != null;\n};\n\n/**\n * Type guard to check if a relation has a target property\n */\nconst hasTarget = (relation: any): boolean => {\n  return 'target' in relation && typeof relation.target === 'string';\n};\n"],"names":["processUnidirectionalJoinTables","db","operateOnJoinTable","totalResult","mdValues","metadata","values","mdArray","Array","from","length","logger","debug","model","unidirectionalRelations","getUnidirectionalRelations","attributes","relation","hasJoinTable","hasTarget","result","joinTable","name","Object","filter","attribute","type","inversedBy","mappedBy","target"],"mappings":";;AAEA;;;;;;;;;;AAUC,IACM,MAAMA,+BAAkC,GAAA,OAC7CC,EACAC,EAAAA,kBAAAA,GAAAA;AAOA,IAAA,IAAIC,WAAc,GAAA,CAAA;AAElB,IAAA,MAAMC,QAAWH,GAAAA,EAAAA,CAAGI,QAAQ,CAACC,MAAM,EAAA;IACnC,MAAMC,OAAAA,GAAUC,KAAMC,CAAAA,IAAI,CAACL,QAAAA,CAAAA;IAE3B,IAAIG,OAAAA,CAAQG,MAAM,KAAK,CAAG,EAAA;QACxB,OAAO,CAAA;AACT;IAEAT,EAAGU,CAAAA,MAAM,CAACC,KAAK,CAAC,8CAAA,CAAA;IAEhB,KAAK,MAAMC,SAASN,OAAS,CAAA;AAC3B,QAAA,MAAMO,uBAA0BC,GAAAA,0BAAAA,CAA2BF,KAAMG,CAAAA,UAAU,IAAI,EAAC,CAAA;QAEhF,KAAK,MAAMC,YAAYH,uBAAyB,CAAA;YAC9C,IAAII,YAAAA,CAAaD,QAAaE,CAAAA,IAAAA,SAAAA,CAAUF,QAAW,CAAA,EAAA;gBACjD,MAAMG,MAAAA,GAAS,MAAMlB,kBAAmBD,CAAAA,EAAAA,EAAIgB,SAASI,SAAS,CAACC,IAAI,EAAEL,QAAUJ,EAAAA,KAAAA,CAAAA;gBAC/EV,WAAeiB,IAAAA,MAAAA;AACjB;AACF;AACF;IAEAnB,EAAGU,CAAAA,MAAM,CAACC,KAAK,CACb,CAAC,yDAAyD,EAAET,WAAY,CAAA,SAAS,CAAC,CAAA;IAGpF,OAAOA,WAAAA;AACT;AAEA;;;IAIA,MAAMY,6BAA6B,CAACC,UAAAA,GAAAA;AAClC,IAAA,OAAOO,OAAOjB,MAAM,CAACU,UAAYQ,CAAAA,CAAAA,MAAM,CAAC,CAACC,SAAAA,GAAAA;QACvC,IAAIA,SAAAA,CAAUC,IAAI,KAAK,UAAY,EAAA;YACjC,OAAO,KAAA;AACT;;AAGA,QAAA,OAAO,CAACD,SAAUE,CAAAA,UAAU,IAAI,CAACF,UAAUG,QAAQ;AACrD,KAAA,CAAA;AACF,CAAA;AAEA;;IAGA,MAAMV,eAAe,CAACD,QAAAA,GAAAA;AACpB,IAAA,OAAO,WAAeA,IAAAA,QAAAA,IAAYA,QAASI,CAAAA,SAAS,IAAI,IAAA;AAC1D,CAAA;AAEA;;IAGA,MAAMF,YAAY,CAACF,QAAAA,GAAAA;AACjB,IAAA,OAAO,QAAYA,IAAAA,QAAAA,IAAY,OAAOA,QAAAA,CAASY,MAAM,KAAK,QAAA;AAC5D,CAAA;;;;"}

package/dist/repairs/operations/process-unidirectional-join-tables.mjs

@@ -0,0 +1,55 @@
+/**
+ * Iterates over all models and their unidirectional relations, invoking a provided operation on each join table.
+ *
+ * This function does not perform any cleaning or modification itself. Instead, it identifies all unidirectional
+ * relations (relations without inversedBy or mappedBy) that use join tables, and delegates any join table operation
+ * (such as cleaning, validation, or analysis) to the provided operateOnJoinTable function.
+ *
+ * @param db - The database instance
+ * @param operateOnJoinTable - A function to execute for each unidirectional join table relation
+ * @returns The sum of results returned by operateOnJoinTable for all processed relations
+ */ const processUnidirectionalJoinTables = async (db, operateOnJoinTable)=>{
+    let totalResult = 0;
+    const mdValues = db.metadata.values();
+    const mdArray = Array.from(mdValues);
+    if (mdArray.length === 0) {
+        return 0;
+    }
+    db.logger.debug('Starting unidirectional join table operation');
+    for (const model of mdArray){
+        const unidirectionalRelations = getUnidirectionalRelations(model.attributes || {});
+        for (const relation of unidirectionalRelations){
+            if (hasJoinTable(relation) && hasTarget(relation)) {
+                const result = await operateOnJoinTable(db, relation.joinTable.name, relation, model);
+                totalResult += result;
+            }
+        }
+    }
+    db.logger.debug(`Unidirectional join table operation completed. Processed ${totalResult} entries.`);
+    return totalResult;
+};
+/**
+ * Identifies unidirectional relations (relations without inversedBy or mappedBy)
+ * Uses same logic as prevention fix in unidirectional-relations.ts:54-61
+ */ const getUnidirectionalRelations = (attributes)=>{
+    return Object.values(attributes).filter((attribute)=>{
+        if (attribute.type !== 'relation') {
+            return false;
+        }
+        // Check if it's unidirectional (no inversedBy or mappedBy) - same as prevention logic
+        return !attribute.inversedBy && !attribute.mappedBy;
+    });
+};
+/**
+ * Type guard to check if a relation has a joinTable property
+ */ const hasJoinTable = (relation)=>{
+    return 'joinTable' in relation && relation.joinTable != null;
+};
+/**
+ * Type guard to check if a relation has a target property
+ */ const hasTarget = (relation)=>{
+    return 'target' in relation && typeof relation.target === 'string';
+};
+
+export { processUnidirectionalJoinTables };
+//# sourceMappingURL=process-unidirectional-join-tables.mjs.map

package/dist/repairs/operations/process-unidirectional-join-tables.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-unidirectional-join-tables.mjs","sources":["../../../src/repairs/operations/process-unidirectional-join-tables.ts"],"sourcesContent":["import type { Database } from '../..';\n\n/**\n * Iterates over all models and their unidirectional relations, invoking a provided operation on each join table.\n *\n * This function does not perform any cleaning or modification itself. Instead, it identifies all unidirectional\n * relations (relations without inversedBy or mappedBy) that use join tables, and delegates any join table operation\n * (such as cleaning, validation, or analysis) to the provided operateOnJoinTable function.\n *\n * @param db - The database instance\n * @param operateOnJoinTable - A function to execute for each unidirectional join table relation\n * @returns The sum of results returned by operateOnJoinTable for all processed relations\n */\nexport const processUnidirectionalJoinTables = async (\n  db: Database,\n  operateOnJoinTable: (\n    db: Database,\n    joinTableName: string,\n    relation: any,\n    sourceModel: any\n  ) => Promise<number>\n): Promise<number> => {\n  let totalResult = 0;\n\n  const mdValues = db.metadata.values();\n  const mdArray = Array.from(mdValues);\n\n  if (mdArray.length === 0) {\n    return 0;\n  }\n\n  db.logger.debug('Starting unidirectional join table operation');\n\n  for (const model of mdArray) {\n    const unidirectionalRelations = getUnidirectionalRelations(model.attributes || {});\n\n    for (const relation of unidirectionalRelations) {\n      if (hasJoinTable(relation) && hasTarget(relation)) {\n        const result = await operateOnJoinTable(db, relation.joinTable.name, relation, model);\n        totalResult += result;\n      }\n    }\n  }\n\n  db.logger.debug(\n    `Unidirectional join table operation completed. Processed ${totalResult} entries.`\n  );\n\n  return totalResult;\n};\n\n/**\n * Identifies unidirectional relations (relations without inversedBy or mappedBy)\n * Uses same logic as prevention fix in unidirectional-relations.ts:54-61\n */\nconst getUnidirectionalRelations = (attributes: Record<string, any>): any[] => {\n  return Object.values(attributes).filter((attribute) => {\n    if (attribute.type !== 'relation') {\n      return false;\n    }\n\n    // Check if it's unidirectional (no inversedBy or mappedBy) - same as prevention logic\n    return !attribute.inversedBy && !attribute.mappedBy;\n  });\n};\n\n/**\n * Type guard to check if a relation has a joinTable property\n */\nconst hasJoinTable = (relation: any): boolean => {\n  return 'joinTable' in relation && relation.joinTable != null;\n};\n\n/**\n * Type guard to check if a relation has a target property\n */\nconst hasTarget = (relation: any): boolean => {\n  return 'target' in relation && typeof relation.target === 'string';\n};\n"],"names":["processUnidirectionalJoinTables","db","operateOnJoinTable","totalResult","mdValues","metadata","values","mdArray","Array","from","length","logger","debug","model","unidirectionalRelations","getUnidirectionalRelations","attributes","relation","hasJoinTable","hasTarget","result","joinTable","name","Object","filter","attribute","type","inversedBy","mappedBy","target"],"mappings":"AAEA;;;;;;;;;;AAUC,IACM,MAAMA,+BAAkC,GAAA,OAC7CC,EACAC,EAAAA,kBAAAA,GAAAA;AAOA,IAAA,IAAIC,WAAc,GAAA,CAAA;AAElB,IAAA,MAAMC,QAAWH,GAAAA,EAAAA,CAAGI,QAAQ,CAACC,MAAM,EAAA;IACnC,MAAMC,OAAAA,GAAUC,KAAMC,CAAAA,IAAI,CAACL,QAAAA,CAAAA;IAE3B,IAAIG,OAAAA,CAAQG,MAAM,KAAK,CAAG,EAAA;QACxB,OAAO,CAAA;AACT;IAEAT,EAAGU,CAAAA,MAAM,CAACC,KAAK,CAAC,8CAAA,CAAA;IAEhB,KAAK,MAAMC,SAASN,OAAS,CAAA;AAC3B,QAAA,MAAMO,uBAA0BC,GAAAA,0BAAAA,CAA2BF,KAAMG,CAAAA,UAAU,IAAI,EAAC,CAAA;QAEhF,KAAK,MAAMC,YAAYH,uBAAyB,CAAA;YAC9C,IAAII,YAAAA,CAAaD,QAAaE,CAAAA,IAAAA,SAAAA,CAAUF,QAAW,CAAA,EAAA;gBACjD,MAAMG,MAAAA,GAAS,MAAMlB,kBAAmBD,CAAAA,EAAAA,EAAIgB,SAASI,SAAS,CAACC,IAAI,EAAEL,QAAUJ,EAAAA,KAAAA,CAAAA;gBAC/EV,WAAeiB,IAAAA,MAAAA;AACjB;AACF;AACF;IAEAnB,EAAGU,CAAAA,MAAM,CAACC,KAAK,CACb,CAAC,yDAAyD,EAAET,WAAY,CAAA,SAAS,CAAC,CAAA;IAGpF,OAAOA,WAAAA;AACT;AAEA;;;IAIA,MAAMY,6BAA6B,CAACC,UAAAA,GAAAA;AAClC,IAAA,OAAOO,OAAOjB,MAAM,CAACU,UAAYQ,CAAAA,CAAAA,MAAM,CAAC,CAACC,SAAAA,GAAAA;QACvC,IAAIA,SAAAA,CAAUC,IAAI,KAAK,UAAY,EAAA;YACjC,OAAO,KAAA;AACT;;AAGA,QAAA,OAAO,CAACD,SAAUE,CAAAA,UAAU,IAAI,CAACF,UAAUG,QAAQ;AACrD,KAAA,CAAA;AACF,CAAA;AAEA;;IAGA,MAAMV,eAAe,CAACD,QAAAA,GAAAA;AACpB,IAAA,OAAO,WAAeA,IAAAA,QAAAA,IAAYA,QAASI,CAAAA,SAAS,IAAI,IAAA;AAC1D,CAAA;AAEA;;IAGA,MAAMF,YAAY,CAACF,QAAAA,GAAAA;AACjB,IAAA,OAAO,QAAYA,IAAAA,QAAAA,IAAY,OAAOA,QAAAA,CAASY,MAAM,KAAK,QAAA;AAC5D,CAAA;;;;"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@strapi/database",
-  "version": "5.23.6",
+  "version": "5.24.0",
   "description": "Strapi's database layer",
   "homepage": "https://strapi.io",
   "bugs": {
@@ -42,7 +42,7 @@
   },
   "dependencies": {
     "@paralleldrive/cuid2": "2.2.2",
-    "@strapi/utils": "5.23.6",
+    "@strapi/utils": "5.24.0",
     "ajv": "8.16.0",
     "date-fns": "2.30.0",
     "debug": "4.3.4",
@@ -54,8 +54,8 @@
   },
   "devDependencies": {
     "@types/fs-extra": "11.0.4",
-    "eslint-config-custom": "5.23.6",
-    "tsconfig": "5.23.6"
+    "eslint-config-custom": "5.24.0",
+    "tsconfig": "5.24.0"
   },
   "engines": {
     "node": ">=18.0.0 <=22.x.x",