@strapi/database 5.0.0-beta.12 → 5.0.0-beta.14

package/dist/index.mjs

@@ -5,11 +5,11 @@ import _, { isNil, castArray, prop, omit, isInteger, snakeCase, partition, sumBy
 import crypto from "crypto";
 import crypto$1 from "node:crypto";
 import * as dateFns from "date-fns";
-import { isOperatorOfType, isOperator } from "@strapi/utils";
+import { AsyncLocalStorage } from "node:async_hooks";
 import KnexBuilder from "knex/lib/query/querybuilder";
 import KnexRaw from "knex/lib/raw";
+import { isOperatorOfType, isOperator } from "@strapi/utils";
 import { Readable } from "stream";
-import { AsyncLocalStorage } from "node:async_hooks";
 import _$1 from "lodash";
 import { Umzug } from "umzug";
 import { createId } from "@paralleldrive/cuid2";
@@ -2895,6 +2895,68 @@ const createField = (attribute) => {
   }
   throw new Error(`Undefined field for type ${type}`);
 };
+const storage = new AsyncLocalStorage();
+const transactionCtx = {
+  async run(trx, cb) {
+    const store = storage.getStore();
+    return storage.run(
+      {
+        trx,
+        // Fill with existing callbacks if nesting transactions
+        commitCallbacks: store?.commitCallbacks || [],
+        rollbackCallbacks: store?.rollbackCallbacks || []
+      },
+      cb
+    );
+  },
+  get() {
+    const store = storage.getStore();
+    return store?.trx;
+  },
+  async commit(trx) {
+    const store = storage.getStore();
+    if (store?.trx) {
+      store.trx = null;
+    }
+    await trx.commit();
+    if (!store?.commitCallbacks.length) {
+      return;
+    }
+    store.commitCallbacks.forEach((cb) => cb());
+    store.commitCallbacks = [];
+  },
+  async rollback(trx) {
+    const store = storage.getStore();
+    if (store?.trx) {
+      store.trx = null;
+    }
+    await trx.rollback();
+    if (!store?.rollbackCallbacks.length) {
+      return;
+    }
+    store.rollbackCallbacks.forEach((cb) => cb());
+    store.rollbackCallbacks = [];
+  },
+  onCommit(cb) {
+    const store = storage.getStore();
+    if (store?.commitCallbacks) {
+      store.commitCallbacks.push(cb);
+    }
+  },
+  onRollback(cb) {
+    const store = storage.getStore();
+    if (store?.rollbackCallbacks) {
+      store.rollbackCallbacks.push(cb);
+    }
+  }
+};
+function isKnexQuery(value) {
+  return value instanceof KnexBuilder || value instanceof KnexRaw;
+}
+const addSchema = (db, tableName) => {
+  const schemaName = db.getSchemaName();
+  return schemaName ? `${schemaName}.${tableName}` : tableName;
+};
 const fromSingleRow = (meta, row) => {
   const { attributes } = meta;
   if (_.isNil(row)) {
@@ -3017,7 +3079,7 @@ const escapeQuery = (query, charsToEscape, escapeChar = "\\") => {
     ""
   );
 };
-const createPivotJoin = (ctx, { alias, refAlias, joinTable, targetMeta }) => {
+const createPivotJoin = (ctx, { alias: alias2, refAlias, joinTable, targetMeta }) => {
   const { qb } = ctx;
   const joinAlias = qb.getAlias();
   qb.join({
@@ -3025,7 +3087,7 @@ const createPivotJoin = (ctx, { alias, refAlias, joinTable, targetMeta }) => {
     referencedTable: joinTable.name,
     referencedColumn: joinTable.joinColumn.name,
     rootColumn: joinTable.joinColumn.referencedColumn,
-    rootTable: alias,
+    rootTable: alias2,
     on: joinTable.on
   });
   const subAlias = refAlias || qb.getAlias();
@@ -3038,7 +3100,7 @@ const createPivotJoin = (ctx, { alias, refAlias, joinTable, targetMeta }) => {
   });
   return subAlias;
 };
-const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
+const createJoin = (ctx, { alias: alias2, refAlias, attributeName, attribute }) => {
   const { db, qb, uid } = ctx;
   if (attribute.type !== "relation") {
     throw new Error(`Cannot join on non relational field ${attributeName}`);
@@ -3054,7 +3116,7 @@ const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
         referencedTable: targetMeta.tableName,
         referencedColumn: morphColumn.idColumn.name,
         rootColumn: morphColumn.idColumn.referencedColumn,
-        rootTable: alias,
+        rootTable: alias2,
         on: {
           [morphColumn.typeColumn.name]: uid,
           ...morphColumn.on
@@ -3069,7 +3131,7 @@ const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
         referencedTable: joinTable2.name,
         referencedColumn: joinTable2.morphColumn.idColumn.name,
         rootColumn: joinTable2.morphColumn.idColumn.referencedColumn,
-        rootTable: alias,
+        rootTable: alias2,
         on: {
           [joinTable2.morphColumn.typeColumn.name]: uid,
           field: attributeName
@@ -3085,7 +3147,7 @@ const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
       });
       return subAlias;
     }
-    return alias;
+    return alias2;
   }
   const { joinColumn } = attribute;
   if (joinColumn) {
@@ -3095,20 +3157,20 @@ const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
       referencedTable: targetMeta.tableName,
       referencedColumn: joinColumn.referencedColumn,
       rootColumn: joinColumn.name,
-      rootTable: alias
+      rootTable: alias2
     });
     return subAlias;
   }
   const { joinTable } = attribute;
   if (joinTable) {
-    return createPivotJoin(ctx, { alias, refAlias, joinTable, targetMeta });
+    return createPivotJoin(ctx, { alias: alias2, refAlias, joinTable, targetMeta });
   }
-  return alias;
+  return alias2;
 };
 const applyJoin = (qb, join) => {
   const {
     method = "leftJoin",
-    alias,
+    alias: alias2,
     referencedTable,
     referencedColumn,
     rootColumn,
@@ -3118,26 +3180,28 @@ const applyJoin = (qb, join) => {
     on,
     orderBy
   } = join;
-  qb[method](`${referencedTable} as ${alias}`, (inner) => {
-    inner.on(`${rootTable}.${rootColumn}`, `${alias}.${referencedColumn}`);
+  qb[method](`${referencedTable} as ${alias2}`, (inner) => {
+    inner.on(`${rootTable}.${rootColumn}`, `${alias2}.${referencedColumn}`);
     if (on) {
       for (const key of Object.keys(on)) {
-        inner.onVal(`${alias}.${key}`, on[key]);
+        inner.onVal(`${alias2}.${key}`, on[key]);
       }
     }
   });
   if (orderBy) {
     Object.keys(orderBy).forEach((column) => {
       const direction = orderBy[column];
-      qb.orderBy(`${alias}.${column}`, direction);
+      qb.orderBy(`${alias2}.${column}`, direction);
     });
   }
 };
 const applyJoins = (qb, joins) => {
   return joins.forEach((join) => applyJoin(qb, join));
 };
+const COL_STRAPI_ROW_NUMBER = "__strapi_row_number";
+const COL_STRAPI_ORDER_BY_PREFIX = "__strapi_order_by";
 const processOrderBy = (orderBy, ctx) => {
-  const { db, uid, qb, alias } = ctx;
+  const { db, uid, qb, alias: alias2 } = ctx;
   const meta = db.metadata.get(uid);
   const { attributes } = meta;
   if (typeof orderBy === "string") {
@@ -3146,7 +3210,7 @@ const processOrderBy = (orderBy, ctx) => {
       throw new Error(`Attribute ${orderBy} not found on model ${uid}`);
     }
     const columnName = toColumnName(meta, orderBy);
-    return [{ column: qb.aliasColumn(columnName, alias) }];
+    return [{ column: qb.aliasColumn(columnName, alias2) }];
   }
   if (Array.isArray(orderBy)) {
     return orderBy.flatMap((value) => processOrderBy(value, ctx));
@@ -3160,11 +3224,11 @@ const processOrderBy = (orderBy, ctx) => {
       }
       if (isScalar(attribute.type)) {
         const columnName = toColumnName(meta, key);
-        return { column: qb.aliasColumn(columnName, alias), order: direction };
+        return { column: qb.aliasColumn(columnName, alias2), order: direction };
       }
       if (attribute.type === "relation" && "target" in attribute) {
         const subAlias = createJoin(ctx, {
-          alias: alias || qb.alias,
+          alias: alias2 || qb.alias,
           attributeName: key,
           attribute
         });
@@ -3180,6 +3244,75 @@ const processOrderBy = (orderBy, ctx) => {
   }
   throw new Error("Invalid orderBy syntax");
 };
+const getStrapiOrderColumnAlias = (column) => {
+  const trimmedColumnName = column.replaceAll(".", "_");
+  return `${COL_STRAPI_ORDER_BY_PREFIX}__${trimmedColumnName}`;
+};
+const wrapWithDeepSort = (originalQuery, ctx) => {
+  const { db, qb, uid } = ctx;
+  const { tableName } = db.metadata.get(uid);
+  const orderBy = _.cloneDeep(qb.state.orderBy);
+  const resultQueryAlias = qb.getAlias();
+  const aliasedTableName = qb.mustUseAlias() ? alias(resultQueryAlias, tableName) : tableName;
+  const resultQuery = db.getConnection(aliasedTableName);
+  const baseQuery = originalQuery.clone();
+  const baseQueryAlias = qb.getAlias();
+  baseQuery.clear("select").clear("order").clear("limit").clear("offset");
+  baseQuery.select(
+    // Always select the row id for future manipulation
+    prefix(qb.alias, "id"),
+    ...orderBy.map(
+      (orderByClause) => alias(getStrapiOrderColumnAlias(orderByClause.column), orderByClause.column)
+    )
+  );
+  const partitionedQueryAlias = qb.getAlias();
+  const selectRowsAsNumberedPartitions = (partitionedQuery) => {
+    const prefixedOrderBy = orderBy.map((orderByClause) => ({
+      column: prefix(baseQueryAlias, getStrapiOrderColumnAlias(orderByClause.column)),
+      order: orderByClause.order
+    }));
+    const orderByColumns = prefixedOrderBy.map(_.prop("column"));
+    partitionedQuery.select(
+      // Always select baseQuery.id
+      prefix(baseQueryAlias, "id"),
+      ...orderByColumns
+    ).rowNumber(COL_STRAPI_ROW_NUMBER, (subQuery) => {
+      for (const orderByClause of prefixedOrderBy) {
+        subQuery.orderBy(orderByClause.column, orderByClause.order, "last");
+      }
+      subQuery.partitionBy(`${baseQueryAlias}.id`);
+    }).from(baseQuery.as(baseQueryAlias)).as(partitionedQueryAlias);
+  };
+  const originalSelect = _.difference(
+    qb.state.select,
+    // Remove order by columns from the initial select
+    qb.state.orderBy.map(_.prop("column"))
+  ).map(prefix(resultQueryAlias));
+  resultQuery.select(originalSelect).innerJoin(selectRowsAsNumberedPartitions, function() {
+    this.on(`${partitionedQueryAlias}.id`, `${resultQueryAlias}.id`).andOnVal(`${partitionedQueryAlias}.${COL_STRAPI_ROW_NUMBER}`, "=", 1);
+  });
+  if (qb.state.limit) {
+    resultQuery.limit(qb.state.limit);
+  }
+  if (qb.state.offset) {
+    resultQuery.offset(qb.state.offset);
+  }
+  if (qb.state.first) {
+    resultQuery.first();
+  }
+  resultQuery.orderBy([
+    // Transform "order by" clause to their T alias and prefix them with T alias
+    ...orderBy.map((orderByClause) => ({
+      column: prefix(partitionedQueryAlias, getStrapiOrderColumnAlias(orderByClause.column)),
+      order: orderByClause.order
+    })),
+    // Add T.id to the order by clause to get consistent results in case several rows have the exact same order
+    { column: `${partitionedQueryAlias}.id`, order: "asc" }
+  ]);
+  return resultQuery;
+};
+const alias = _.curry((alias2, value) => `${value} as ${alias2}`);
+const prefix = _.curry((prefix2, value) => `${prefix2}.${value}`);
 const joinColPrefix = "__strapi";
 const XtoOne = async (input, ctx) => {
   const { attribute, attributeName, results, populateValue, targetMeta, isCount } = input;
@@ -3207,8 +3340,8 @@ const XtoOne = async (input, ctx) => {
     const { joinTable } = attribute;
     const qb2 = db.entityManager.createQueryBuilder(targetMeta.uid);
     const { name: joinColumnName, referencedColumn: referencedColumnName } = joinTable.joinColumn;
-    const alias = qb2.getAlias();
-    const joinColAlias = `${alias}.${joinColumnName}`;
+    const alias2 = qb2.getAlias();
+    const joinColAlias = `${alias2}.${joinColumnName}`;
     const joinColRenameAs = `${joinColPrefix}${joinColumnName}`;
     const joinColSelect = `${joinColAlias} as ${joinColRenameAs}`;
     const referencedValues = _.uniq(
@@ -3222,7 +3355,7 @@ const XtoOne = async (input, ctx) => {
         return;
       }
       const rows2 = await qb2.init(populateValue).join({
-        alias,
+        alias: alias2,
         referencedTable: joinTable.name,
         referencedColumn: joinTable.inverseJoinColumn.name,
         rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -3248,7 +3381,7 @@ const XtoOne = async (input, ctx) => {
       return;
     }
     const rows = await qb2.init(populateValue).join({
-      alias,
+      alias: alias2,
       referencedTable: joinTable.name,
       referencedColumn: joinTable.inverseJoinColumn.name,
       rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -3288,8 +3421,8 @@ const oneToMany = async (input, ctx) => {
     const { joinTable } = attribute;
     const qb2 = db.entityManager.createQueryBuilder(targetMeta.uid);
     const { name: joinColumnName, referencedColumn: referencedColumnName } = joinTable.joinColumn;
-    const alias = qb2.getAlias();
-    const joinColAlias = `${alias}.${joinColumnName}`;
+    const alias2 = qb2.getAlias();
+    const joinColAlias = `${alias2}.${joinColumnName}`;
     const joinColRenameAs = `${joinColPrefix}${joinColumnName}`;
     const joinColSelect = `${joinColAlias} as ${joinColRenameAs}`;
     const referencedValues = _.uniq(
@@ -3303,7 +3436,7 @@ const oneToMany = async (input, ctx) => {
         return;
       }
       const rows2 = await qb2.init(populateValue).join({
-        alias,
+        alias: alias2,
         referencedTable: joinTable.name,
         referencedColumn: joinTable.inverseJoinColumn.name,
         rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -3329,7 +3462,7 @@ const oneToMany = async (input, ctx) => {
       return;
     }
     const rows = await qb2.init(populateValue).join({
-      alias,
+      alias: alias2,
       referencedTable: joinTable.name,
       referencedColumn: joinTable.inverseJoinColumn.name,
       rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -3350,8 +3483,8 @@ const manyToMany = async (input, ctx) => {
   const { joinTable } = attribute;
   const populateQb = db.entityManager.createQueryBuilder(targetMeta.uid);
   const { name: joinColumnName, referencedColumn: referencedColumnName } = joinTable.joinColumn;
-  const alias = populateQb.getAlias();
-  const joinColAlias = `${alias}.${joinColumnName}`;
+  const alias2 = populateQb.getAlias();
+  const joinColAlias = `${alias2}.${joinColumnName}`;
   const joinColRenameAs = `${joinColPrefix}${joinColumnName}`;
   const joinColSelect = `${joinColAlias} as ${joinColRenameAs}`;
   const referencedValues = _.uniq(
@@ -3365,7 +3498,7 @@ const manyToMany = async (input, ctx) => {
       return;
     }
     const rows2 = await populateQb.init(populateValue).join({
-      alias,
+      alias: alias2,
       referencedTable: joinTable.name,
       referencedColumn: joinTable.inverseJoinColumn.name,
       rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -3391,7 +3524,7 @@ const manyToMany = async (input, ctx) => {
     return;
   }
   const rows = await populateQb.init(populateValue).join({
-    alias,
+    alias: alias2,
     referencedTable: joinTable.name,
     referencedColumn: joinTable.inverseJoinColumn.name,
     rootColumn: joinTable.inverseJoinColumn.referencedColumn,
@@ -3442,9 +3575,9 @@ const morphX = async (input, ctx) => {
       return;
     }
     const qb = db.entityManager.createQueryBuilder(target);
-    const alias = qb.getAlias();
+    const alias2 = qb.getAlias();
     const rows = await qb.init(populateValue).join({
-      alias,
+      alias: alias2,
       referencedTable: joinTable.name,
       referencedColumn: joinColumn.name,
       rootColumn: joinColumn.referencedColumn,
@@ -3454,9 +3587,9 @@ const morphX = async (input, ctx) => {
         field: attributeName
       },
       orderBy: _.mapValues((v) => populateValue.ordering || v, joinTable.orderBy)
-    }).addSelect([`${alias}.${idColumn.name}`, `${alias}.${typeColumn.name}`]).where({
-      [`${alias}.${idColumn.name}`]: referencedValues,
-      [`${alias}.${typeColumn.name}`]: uid
+    }).addSelect([`${alias2}.${idColumn.name}`, `${alias2}.${typeColumn.name}`]).where({
+      [`${alias2}.${idColumn.name}`]: referencedValues,
+      [`${alias2}.${typeColumn.name}`]: uid
     }).execute({ mapResults: false });
     const map2 = _.groupBy(idColumn.name)(rows);
     results.forEach((result) => {
@@ -3705,13 +3838,6 @@ const processPopulate = (populate, ctx) => {
   }
   return finalPopulate;
 };
-function isKnexQuery(value) {
-  return value instanceof KnexBuilder || value instanceof KnexRaw;
-}
-const addSchema = (db, tableName) => {
-  const schemaName = db.getSchemaName();
-  return schemaName ? `${schemaName}.${tableName}` : tableName;
-};
 const isRecord$1 = (value) => isPlainObject(value);
 const castValue = (value, attribute) => {
   if (!attribute) {
@@ -3753,8 +3879,8 @@ const processNested = (where, ctx) => {
   return processWhere(where, ctx);
 };
 const processRelationWhere = (where, ctx) => {
-  const { qb, alias } = ctx;
-  const idAlias = qb.aliasColumn("id", alias);
+  const { qb, alias: alias2 } = ctx;
+  const idAlias = qb.aliasColumn("id", alias2);
   if (!isRecord$1(where)) {
     return { [idAlias]: where };
   }
@@ -3784,7 +3910,7 @@ function processWhere(where, ctx) {
   if (isArray(where)) {
     return where.map((sub) => processWhere(sub, ctx));
   }
-  const { db, uid, qb, alias } = ctx;
+  const { db, uid, qb, alias: alias2 } = ctx;
   const meta = db.metadata.get(uid);
   const filters = {};
   for (const key of Object.keys(where)) {
@@ -3807,12 +3933,12 @@ function processWhere(where, ctx) {
     }
     const attribute = meta.attributes[key];
     if (!attribute) {
-      filters[qb.aliasColumn(key, alias)] = processAttributeWhere(null, value);
+      filters[qb.aliasColumn(key, alias2)] = processAttributeWhere(null, value);
       continue;
     }
     if (isRelation(attribute.type) && "target" in attribute) {
       const subAlias = createJoin(ctx, {
-        alias: alias || qb.alias,
+        alias: alias2 || qb.alias,
         attributeName: key,
         attribute
       });
@@ -3827,7 +3953,7 @@ function processWhere(where, ctx) {
     }
     if (isScalar(attribute.type)) {
       const columnName = toColumnName(meta, key);
-      const aliasedColumnName = qb.aliasColumn(columnName, alias);
+      const aliasedColumnName = qb.aliasColumn(columnName, alias2);
       filters[aliasedColumnName] = processAttributeWhere(attribute, value);
       continue;
     }
@@ -4055,7 +4181,7 @@ class ReadableStrapiQuery extends Readable {
    * Custom ._read() implementation
    *
    *  NOTE: Here "size" means the number of entities to be read from the database.
-   *  Not the actual byte size, as it would means that we need to return partial entities.
+   *  Not the actual byte size, as it would mean that we need to return partial entities.
    *
    */
   async _read(size) {
@@ -4118,61 +4244,6 @@ class ReadableStrapiQuery extends Readable {
     }
   }
 }
-const storage = new AsyncLocalStorage();
-const transactionCtx = {
-  async run(trx, cb) {
-    const store = storage.getStore();
-    return storage.run(
-      {
-        trx,
-        // Fill with existing callbacks if nesting transactions
-        commitCallbacks: store?.commitCallbacks || [],
-        rollbackCallbacks: store?.rollbackCallbacks || []
-      },
-      cb
-    );
-  },
-  get() {
-    const store = storage.getStore();
-    return store?.trx;
-  },
-  async commit(trx) {
-    const store = storage.getStore();
-    if (store?.trx) {
-      store.trx = null;
-    }
-    await trx.commit();
-    if (!store?.commitCallbacks.length) {
-      return;
-    }
-    store.commitCallbacks.forEach((cb) => cb());
-    store.commitCallbacks = [];
-  },
-  async rollback(trx) {
-    const store = storage.getStore();
-    if (store?.trx) {
-      store.trx = null;
-    }
-    await trx.rollback();
-    if (!store?.rollbackCallbacks.length) {
-      return;
-    }
-    store.rollbackCallbacks.forEach((cb) => cb());
-    store.rollbackCallbacks = [];
-  },
-  onCommit(cb) {
-    const store = storage.getStore();
-    if (store?.commitCallbacks) {
-      store.commitCallbacks.push(cb);
-    }
-  },
-  onRollback(cb) {
-    const store = storage.getStore();
-    if (store?.rollbackCallbacks) {
-      store.rollbackCallbacks.push(cb);
-    }
-  }
-};
 const createQueryBuilder = (uid, db, initialState = {}) => {
   const meta = db.metadata.get(uid);
   const { tableName } = meta;
@@ -4205,9 +4276,9 @@ const createQueryBuilder = (uid, db, initialState = {}) => {
     initialState
   );
   const getAlias = () => {
-    const alias = `t${state.aliasCounter}`;
+    const alias2 = `t${state.aliasCounter}`;
     state.aliasCounter += 1;
-    return alias;
+    return alias2;
   };
   return {
     alias: getAlias(),
@@ -4374,15 +4445,15 @@ const createQueryBuilder = (uid, db, initialState = {}) => {
     mustUseAlias() {
       return ["select", "count"].includes(state.type);
     },
-    aliasColumn(key, alias) {
+    aliasColumn(key, alias2) {
       if (typeof key !== "string") {
         return key;
       }
       if (key.indexOf(".") >= 0) {
         return key;
       }
-      if (!_.isNil(alias)) {
-        return `${alias}.${key}`;
+      if (!_.isNil(alias2)) {
+        return `${alias2}.${key}`;
       }
       return this.mustUseAlias() ? `${this.alias}.${key}` : key;
     },
@@ -4417,6 +4488,20 @@ const createQueryBuilder = (uid, db, initialState = {}) => {
     shouldUseDistinct() {
       return state.joins.length > 0 && _.isEmpty(state.groupBy);
     },
+    shouldUseDeepSort() {
+      return state.orderBy.filter(({ column }) => column.indexOf(".") >= 0).filter(({ column }) => {
+        const col = column.split(".");
+        for (let i = 0; i < col.length - 1; i += 1) {
+          const el = col[i];
+          const isRelationAttribute = meta.attributes[el]?.type === "relation";
+          const isAliasedRelation = Object.values(state.joins).map((join) => join.alias).includes(el);
+          if (isRelationAttribute || isAliasedRelation) {
+            return true;
+          }
+        }
+        return false;
+      }).length > 0;
+    },
     processSelect() {
       state.select = state.select.map((field) => {
         if (isKnexQuery(field)) {
@@ -4534,6 +4619,9 @@ const createQueryBuilder = (uid, db, initialState = {}) => {
       if (state.joins.length > 0) {
         applyJoins(qb, state.joins);
       }
+      if (this.shouldUseDeepSort()) {
+        return wrapWithDeepSort(qb, { qb: this, db, uid });
+      }
       return qb;
     },
     async execute({ mapResults = true } = {}) {
@@ -4743,11 +4831,10 @@ const getDocumentSiblingIdsQuery = (tableName, id) => {
   if (!isContentType) {
     return [id];
   }
-  return (con) => {
-    con.from(tableName).select("id").where(
-      "document_id",
-      (con2) => con2.select("document_id").from(tableName).where("id", id)
-    );
+  return function(query) {
+    query.select("id").from(tableName).whereIn("document_id", (documentIDSubQuery) => {
+      documentIDSubQuery.from(tableName).select("document_id").where("id", id);
+    });
   };
 };
 const deletePreviousOneToAnyRelations = async ({
@@ -4765,11 +4852,7 @@ const deletePreviousOneToAnyRelations = async ({
   const { joinTable } = attribute;
   const { joinColumn, inverseJoinColumn } = joinTable;
   const con = db.getConnection();
-  await con.delete().from(joinTable.name).whereNotIn(
-    // @ts-expect-error - knex incorrectly expects a string array
-    joinColumn.name,
-    getDocumentSiblingIdsQuery(joinColumn.referencedTable, id)
-  ).whereIn(inverseJoinColumn.name, relIdsToadd).where(joinTable.on || {}).transacting(trx);
+  await con.delete().from(joinTable.name).whereNotIn(joinColumn.name, getDocumentSiblingIdsQuery(joinColumn.referencedTable, id)).whereIn(inverseJoinColumn.name, relIdsToadd).where(joinTable.on || {}).transacting(trx);
   await cleanOrderColumns({ attribute, db, inverseRelIds: relIdsToadd, transaction: trx });
 };
 const deletePreviousAnyToOneRelations = async ({
@@ -4787,7 +4870,6 @@ const deletePreviousAnyToOneRelations = async ({
   }
   if (isManyToAny(attribute)) {
     const relsToDelete = await con.select(inverseJoinColumn.name).from(joinTable.name).where(joinColumn.name, id).whereNotIn(
-      // @ts-expect-error - knex incorrectly expects a string array
       inverseJoinColumn.name,
       getDocumentSiblingIdsQuery(inverseJoinColumn.referencedTable, relIdToadd)
     ).where(joinTable.on || {}).transacting(trx);
@@ -4799,7 +4881,6 @@ const deletePreviousAnyToOneRelations = async ({
     await cleanOrderColumns({ attribute, db, inverseRelIds: relIdsToDelete, transaction: trx });
   } else {
     await con.delete().from(joinTable.name).where(joinColumn.name, id).whereNotIn(
-      // @ts-expect-error - knex incorrectly expects a string array
       inverseJoinColumn.name,
       getDocumentSiblingIdsQuery(inverseJoinColumn.referencedTable, relIdToadd)
     ).where(joinTable.on || {}).transacting(trx);