@strapi/database 5.0.0-beta.8 → 5.0.0-rc.0

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";
@@ -1087,7 +1087,7 @@ const createHelpers = (db) => {
       }
     }
   };
-  const dropIndex = (tableBuilder, index2) => {
+  const dropIndex2 = (tableBuilder, index2) => {
     if (!db.config.settings?.forceMigration) {
       return;
     }
@@ -1164,13 +1164,13 @@ const createHelpers = (db) => {
       for (const removedIndex of table.indexes.removed) {
         if (!ignoreForeignKeyNames.includes(removedIndex.name)) {
           debug$2(`Dropping index ${removedIndex.name} on ${table.name}`);
-          dropIndex(tableBuilder, removedIndex);
+          dropIndex2(tableBuilder, removedIndex);
         }
       }
       for (const updatedIndex of table.indexes.updated) {
         if (!ignoreForeignKeyNames.includes(updatedIndex.name)) {
           debug$2(`Dropping updated index ${updatedIndex.name} on ${table.name}`);
-          dropIndex(tableBuilder, updatedIndex.object);
+          dropIndex2(tableBuilder, updatedIndex.object);
         }
       }
       for (const updatedColumn of table.columns.updated) {
@@ -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,76 @@ 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;
   const { db, qb } = ctx;
@@ -3206,8 +3340,10 @@ 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(
       results.map((r) => r[referencedColumnName]).filter((value) => !_.isNil(value))
     );
@@ -3219,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,
@@ -3245,15 +3381,15 @@ 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,
       rootTable: qb2.alias,
       on: joinTable.on,
       orderBy: joinTable.orderBy
-    }).addSelect(joinColAlias).where({ [joinColAlias]: referencedValues }).execute({ mapResults: false });
-    const map2 = _.groupBy(joinColumnName)(rows);
+    }).addSelect(joinColSelect).where({ [joinColAlias]: referencedValues }).execute({ mapResults: false });
+    const map2 = _.groupBy(joinColRenameAs)(rows);
     results.forEach((result) => {
       result[attributeName] = fromTargetRow(_.first(map2[result[referencedColumnName]]));
     });
@@ -3285,8 +3421,10 @@ 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(
       results.map((r) => r[referencedColumnName]).filter((value) => !_.isNil(value))
     );
@@ -3298,16 +3436,16 @@ 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,
         rootTable: qb2.alias,
         on: joinTable.on
-      }).select([joinColAlias, qb2.raw("count(*) AS count")]).where({ [joinColAlias]: referencedValues }).groupBy(joinColAlias).execute({ mapResults: false });
+      }).select([joinColSelect, qb2.raw("count(*) AS count")]).where({ [joinColAlias]: referencedValues }).groupBy(joinColAlias).execute({ mapResults: false });
       const map22 = rows2.reduce(
         (map3, row) => {
-          map3[row[joinColumnName]] = { count: Number(row.count) };
+          map3[row[joinColRenameAs]] = { count: Number(row.count) };
           return map3;
         },
         {}
@@ -3324,15 +3462,15 @@ 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,
       rootTable: qb2.alias,
       on: joinTable.on,
       orderBy: _.mapValues((v) => populateValue.ordering || v, joinTable.orderBy)
-    }).addSelect(joinColAlias).where({ [joinColAlias]: referencedValues }).execute({ mapResults: false });
-    const map2 = _.groupBy(joinColumnName)(rows);
+    }).addSelect(joinColSelect).where({ [joinColAlias]: referencedValues }).execute({ mapResults: false });
+    const map2 = _.groupBy(joinColRenameAs)(rows);
     results.forEach((r) => {
       r[attributeName] = fromTargetRow(map2[r[referencedColumnName]] || []);
     });
@@ -3345,8 +3483,10 @@ 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(
     results.map((r) => r[referencedColumnName]).filter((value) => !_.isNil(value))
   );
@@ -3358,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,
@@ -3384,15 +3524,15 @@ 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,
     rootTable: populateQb.alias,
     on: joinTable.on,
     orderBy: _.mapValues((v) => populateValue.ordering || v, joinTable.orderBy)
-  }).addSelect(joinColAlias).where({ [joinColAlias]: referencedValues }).execute({ mapResults: false });
-  const map2 = _.groupBy(joinColumnName)(rows);
+  }).addSelect(joinColSelect).where({ [joinColAlias]: referencedValues }).execute({ mapResults: false });
+  const map2 = _.groupBy(joinColRenameAs)(rows);
   results.forEach((result) => {
     result[attributeName] = fromTargetRow(map2[result[referencedColumnName]] || []);
   });
@@ -3435,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,
@@ -3447,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) => {
@@ -3698,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) {
@@ -3746,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 };
   }
@@ -3763,6 +3896,9 @@ const processRelationWhere = (where, ctx) => {
   }
   if (operatorKeys.length === 1) {
     const operator = operatorKeys[0];
+    if (isOperatorOfType("group", operator)) {
+      return processWhere(where, ctx);
+    }
     return { [idAlias]: { [operator]: processNested(where[operator], ctx) } };
   }
   return processWhere(where, ctx);
@@ -3774,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)) {
@@ -3797,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
       });
@@ -3817,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;
     }
@@ -4045,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) {
@@ -4108,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;
@@ -4195,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(),
@@ -4364,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;
     },
@@ -4407,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)) {
@@ -4524,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 } = {}) {
@@ -4725,7 +4823,7 @@ const deleteRelatedMorphOneRelationsAfterMorphToManyUpdate = async (rows, {
     await createQueryBuilder(joinTable.name, db).delete().where({ $or: orWhere }).transacting(trx).execute();
   }
 };
-const getDocumentSiblingIdsQuery = (con, tableName, id) => {
+const getDocumentSiblingIdsQuery = (tableName, id) => {
   const models = Array.from(strapi.db.metadata.values());
   const isContentType = models.find((model) => {
     return model.tableName === tableName && model.attributes.documentId;
@@ -4733,10 +4831,11 @@ const getDocumentSiblingIdsQuery = (con, tableName, id) => {
   if (!isContentType) {
     return [id];
   }
-  return con.from(tableName).select("id").where(
-    "document_id",
-    con.from(tableName).select("document_id").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 ({
   id,
@@ -4753,7 +4852,7 @@ const deletePreviousOneToAnyRelations = async ({
   const { joinTable } = attribute;
   const { joinColumn, inverseJoinColumn } = joinTable;
   const con = db.getConnection();
-  await con.delete().from(joinTable.name).whereNotIn(joinColumn.name, getDocumentSiblingIdsQuery(con, 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 ({
@@ -4772,7 +4871,7 @@ const deletePreviousAnyToOneRelations = async ({
   if (isManyToAny(attribute)) {
     const relsToDelete = await con.select(inverseJoinColumn.name).from(joinTable.name).where(joinColumn.name, id).whereNotIn(
       inverseJoinColumn.name,
-      getDocumentSiblingIdsQuery(con, inverseJoinColumn.referencedTable, relIdToadd)
+      getDocumentSiblingIdsQuery(inverseJoinColumn.referencedTable, relIdToadd)
     ).where(joinTable.on || {}).transacting(trx);
     const relIdsToDelete = map(inverseJoinColumn.name, relsToDelete);
     await createQueryBuilder(joinTable.name, db).delete().where({
@@ -4783,7 +4882,7 @@ const deletePreviousAnyToOneRelations = async ({
   } else {
     await con.delete().from(joinTable.name).where(joinColumn.name, id).whereNotIn(
       inverseJoinColumn.name,
-      getDocumentSiblingIdsQuery(con, inverseJoinColumn.referencedTable, relIdToadd)
+      getDocumentSiblingIdsQuery(inverseJoinColumn.referencedTable, relIdToadd)
     ).where(joinTable.on || {}).transacting(trx);
   }
 };
@@ -5867,6 +5966,21 @@ const createStorage = (opts) => {
 const wrapTransaction = (db) => (fn) => () => {
   return db.transaction(({ trx }) => Promise.resolve(fn(trx, db)));
 };
+const transformLogMessage = (level, message) => {
+  if (typeof message === "string") {
+    return { level, message };
+  }
+  if (typeof message === "object" && message !== null) {
+    if ("event" in message && "name" in message) {
+      return {
+        level,
+        message: `[internal migration]: ${message.event} ${message?.name}`,
+        timestamp: Date.now()
+      };
+    }
+  }
+  return "";
+};
 const migrationResolver = ({ name, path: path2, context }) => {
   const { db } = context;
   if (!path2) {
@@ -5895,7 +6009,20 @@ const createUserMigrationProvider = (db) => {
   const context = { db };
   const umzugProvider = new Umzug({
     storage: createStorage({ db, tableName: "strapi_migrations" }),
-    logger: console,
+    logger: {
+      info(message) {
+        db.logger.info(transformLogMessage("info", message));
+      },
+      warn(message) {
+        db.logger.warn(transformLogMessage("warn", message));
+      },
+      error(message) {
+        db.logger.error(transformLogMessage("error", message));
+      },
+      debug(message) {
+        db.logger.debug(transformLogMessage("debug", message));
+      }
+    },
     context,
     migrations: {
       glob: ["*.{js,sql}", { cwd: dir }],
@@ -6183,16 +6310,115 @@ const findDiffs = (shortMap) => {
   });
   return diffs;
 };
+const createLocaleColumn = async (db, tableName) => {
+  await db.schema.alterTable(tableName, (table) => {
+    table.string("locale");
+  });
+};
+const createdLocale = {
+  name: "5.0.0-03-created-locale",
+  async up(knex2, db) {
+    for (const meta of db.metadata.values()) {
+      const hasTable = await knex2.schema.hasTable(meta.tableName);
+      if (!hasTable) {
+        continue;
+      }
+      const uid = meta.uid;
+      const model = strapi.getModel(uid);
+      if (!model) {
+        continue;
+      }
+      const hasLocaleColumn = await knex2.schema.hasColumn(meta.tableName, "locale");
+      if (meta.attributes.locale && !hasLocaleColumn) {
+        await createLocaleColumn(knex2, meta.tableName);
+      }
+    }
+  },
+  async down() {
+    throw new Error("not implemented");
+  }
+};
+const createPublishedAtColumn = async (db, tableName) => {
+  await db.schema.alterTable(tableName, (table) => {
+    table.string("published_at");
+  });
+};
+const createdPublishedAt = {
+  name: "5.0.0-04-created-published-at",
+  async up(knex2, db) {
+    for (const meta of db.metadata.values()) {
+      const hasTable = await knex2.schema.hasTable(meta.tableName);
+      if (!hasTable) {
+        continue;
+      }
+      const uid = meta.uid;
+      const model = strapi.getModel(uid);
+      if (!model) {
+        continue;
+      }
+      const hasPublishedAtColumn = await knex2.schema.hasColumn(meta.tableName, "published_at");
+      if (meta.attributes.publishedAt && !hasPublishedAtColumn) {
+        await createPublishedAtColumn(knex2, meta.tableName);
+      }
+    }
+  },
+  async down() {
+    throw new Error("not implemented");
+  }
+};
+const dropIndex = async (knex2, tableName, columnName) => {
+  try {
+    await knex2.schema.alterTable(tableName, (table) => {
+      table.dropUnique([columnName], `${tableName}_${columnName}_unique`);
+    });
+  } catch (error) {
+  }
+};
+const dropSlugFieldsIndex = {
+  name: "5.0.0-05-drop-slug-fields-index",
+  async up(knex2, db) {
+    for (const meta of db.metadata.values()) {
+      const hasTable = await knex2.schema.hasTable(meta.tableName);
+      if (!hasTable) {
+        continue;
+      }
+      for (const attribute of Object.values(meta.attributes)) {
+        if (attribute.type === "uid" && attribute.columnName) {
+          await dropIndex(knex2, meta.tableName, attribute.columnName);
+        }
+      }
+    }
+  },
+  async down() {
+    throw new Error("not implemented");
+  }
+};
 const internalMigrations = [
   renameIdentifiersLongerThanMaxLength,
-  createdDocumentId
+  createdDocumentId,
+  createdLocale,
+  createdPublishedAt,
+  dropSlugFieldsIndex
 ];
 const createInternalMigrationProvider = (db) => {
   const context = { db };
   const migrations = [...internalMigrations];
   const umzugProvider = new Umzug({
     storage: createStorage({ db, tableName: "strapi_migrations_internal" }),
-    logger: console,
+    logger: {
+      info(message) {
+        db.logger.debug(transformLogMessage("info", message));
+      },
+      warn(message) {
+        db.logger.warn(transformLogMessage("warn", message));
+      },
+      error(message) {
+        db.logger.error(transformLogMessage("error", message));
+      },
+      debug(message) {
+        db.logger.debug(transformLogMessage("debug", message));
+      }
+    },
     context,
     migrations: () => migrations.map((migration) => {
       return {
@@ -6463,6 +6689,7 @@ class Database {
   migrations;
   lifecycles;
   entityManager;
+  logger;
   constructor(config) {
     this.config = {
       ...config,
@@ -6482,6 +6709,7 @@ class Database {
     this.migrations = createMigrationsProvider(this);
     this.lifecycles = createLifecyclesProvider(this);
     this.entityManager = createEntityManager(this);
+    this.logger = config.logger ?? console;
   }
   async init({ models }) {
     this.metadata.loadModels(models);