@strapi/database 5.0.0-beta.9 → 5.0.0-rc.1

package/dist/index.js

@@ -7,11 +7,11 @@ const _ = require("lodash/fp");
 const crypto = require("crypto");
 const crypto$1 = require("node:crypto");
 const dateFns = require("date-fns");
-const utils = require("@strapi/utils");
+const node_async_hooks = require("node:async_hooks");
 const KnexBuilder = require("knex/lib/query/querybuilder");
 const KnexRaw = require("knex/lib/raw");
+const utils = require("@strapi/utils");
 const stream = require("stream");
-const node_async_hooks = require("node:async_hooks");
 const _$1 = require("lodash");
 const umzug = require("umzug");
 const cuid2 = require("@paralleldrive/cuid2");
@@ -1119,7 +1119,7 @@ const createHelpers = (db) => {
       }
     }
   };
-  const dropIndex = (tableBuilder, index2) => {
+  const dropIndex2 = (tableBuilder, index2) => {
     if (!db.config.settings?.forceMigration) {
       return;
     }
@@ -1196,13 +1196,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) {
@@ -1388,27 +1388,28 @@ const createSchemaDiff = (db) => {
       }
     };
   };
-  const diffTableColumns = (srcTable, destTable) => {
+  const diffTableColumns = (diffCtx) => {
+    const { databaseTable, userSchemaTable, previousTable } = diffCtx;
     const addedColumns = [];
     const updatedColumns = [];
     const unchangedColumns = [];
     const removedColumns = [];
-    for (const destColumn of destTable.columns) {
-      const srcColumn = helpers.findColumn(srcTable, destColumn.name);
-      if (srcColumn) {
-        const { status, diff } = diffColumns(srcColumn, destColumn);
+    for (const userSchemaColumn of userSchemaTable.columns) {
+      const databaseColumn = helpers.findColumn(databaseTable, userSchemaColumn.name);
+      if (databaseColumn) {
+        const { status, diff } = diffColumns(databaseColumn, userSchemaColumn);
         if (status === statuses.CHANGED) {
           updatedColumns.push(diff);
         } else {
-          unchangedColumns.push(srcColumn);
+          unchangedColumns.push(databaseColumn);
         }
       } else {
-        addedColumns.push(destColumn);
+        addedColumns.push(userSchemaColumn);
       }
     }
-    for (const srcColumn of srcTable.columns) {
-      if (!helpers.hasColumn(destTable, srcColumn.name)) {
-        removedColumns.push(srcColumn);
+    for (const databaseColumn of databaseTable.columns) {
+      if (!helpers.hasColumn(userSchemaTable, databaseColumn.name) && previousTable && helpers.hasColumn(previousTable, databaseColumn.name)) {
+        removedColumns.push(databaseColumn);
       }
     }
     const hasChanged = [addedColumns, updatedColumns, removedColumns].some((arr) => arr.length > 0);
@@ -1422,27 +1423,28 @@ const createSchemaDiff = (db) => {
       }
     };
   };
-  const diffTableIndexes = (srcTable, destTable) => {
+  const diffTableIndexes = (diffCtx) => {
+    const { databaseTable, userSchemaTable, previousTable } = diffCtx;
     const addedIndexes = [];
     const updatedIndexes = [];
     const unchangedIndexes = [];
     const removedIndexes = [];
-    for (const destIndex of destTable.indexes) {
-      const srcIndex = helpers.findIndex(srcTable, destIndex.name);
-      if (srcIndex) {
-        const { status, diff } = diffIndexes(srcIndex, destIndex);
+    for (const userSchemaIndex of userSchemaTable.indexes) {
+      const databaseIndex = helpers.findIndex(databaseTable, userSchemaIndex.name);
+      if (databaseIndex) {
+        const { status, diff } = diffIndexes(databaseIndex, userSchemaIndex);
         if (status === statuses.CHANGED) {
           updatedIndexes.push(diff);
         } else {
-          unchangedIndexes.push(srcIndex);
+          unchangedIndexes.push(databaseIndex);
         }
       } else {
-        addedIndexes.push(destIndex);
+        addedIndexes.push(userSchemaIndex);
       }
     }
-    for (const srcIndex of srcTable.indexes) {
-      if (!helpers.hasIndex(destTable, srcIndex.name)) {
-        removedIndexes.push(srcIndex);
+    for (const databaseIndex of databaseTable.indexes) {
+      if (!helpers.hasIndex(userSchemaTable, databaseIndex.name) && previousTable && helpers.hasIndex(previousTable, databaseIndex.name)) {
+        removedIndexes.push(databaseIndex);
       }
     }
     const hasChanged = [addedIndexes, updatedIndexes, removedIndexes].some((arr) => arr.length > 0);
@@ -1456,7 +1458,8 @@ const createSchemaDiff = (db) => {
       }
     };
   };
-  const diffTableForeignKeys = (srcTable, destTable) => {
+  const diffTableForeignKeys = (diffCtx) => {
+    const { databaseTable, userSchemaTable, previousTable } = diffCtx;
     const addedForeignKeys = [];
     const updatedForeignKeys = [];
     const unchangedForeignKeys = [];
@@ -1472,22 +1475,22 @@ const createSchemaDiff = (db) => {
         }
       };
     }
-    for (const destForeignKey of destTable.foreignKeys) {
-      const srcForeignKey = helpers.findForeignKey(srcTable, destForeignKey.name);
-      if (srcForeignKey) {
-        const { status, diff } = diffForeignKeys(srcForeignKey, destForeignKey);
+    for (const userSchemaForeignKeys of userSchemaTable.foreignKeys) {
+      const databaseForeignKeys = helpers.findForeignKey(databaseTable, userSchemaForeignKeys.name);
+      if (databaseForeignKeys) {
+        const { status, diff } = diffForeignKeys(databaseForeignKeys, userSchemaForeignKeys);
         if (status === statuses.CHANGED) {
           updatedForeignKeys.push(diff);
         } else {
-          unchangedForeignKeys.push(srcForeignKey);
+          unchangedForeignKeys.push(databaseForeignKeys);
         }
       } else {
-        addedForeignKeys.push(destForeignKey);
+        addedForeignKeys.push(userSchemaForeignKeys);
       }
     }
-    for (const srcForeignKey of srcTable.foreignKeys) {
-      if (!helpers.hasForeignKey(destTable, srcForeignKey.name)) {
-        removedForeignKeys.push(srcForeignKey);
+    for (const databaseForeignKeys of databaseTable.foreignKeys) {
+      if (!helpers.hasForeignKey(userSchemaTable, databaseForeignKeys.name) && previousTable && helpers.hasForeignKey(previousTable, databaseForeignKeys.name)) {
+        removedForeignKeys.push(databaseForeignKeys);
       }
     }
     const hasChanged = [addedForeignKeys, updatedForeignKeys, removedForeignKeys].some(
@@ -1503,37 +1506,44 @@ const createSchemaDiff = (db) => {
       }
     };
   };
-  const diffTables = (srcTable, destTable) => {
-    const columnsDiff = diffTableColumns(srcTable, destTable);
-    const indexesDiff = diffTableIndexes(srcTable, destTable);
-    const foreignKeysDiff = diffTableForeignKeys(srcTable, destTable);
+  const diffTables = (diffCtx) => {
+    const { databaseTable } = diffCtx;
+    const columnsDiff = diffTableColumns(diffCtx);
+    const indexesDiff = diffTableIndexes(diffCtx);
+    const foreignKeysDiff = diffTableForeignKeys(diffCtx);
     const hasChanged = [columnsDiff, indexesDiff, foreignKeysDiff].some(hasChangedStatus);
     return {
       status: hasChanged ? statuses.CHANGED : statuses.UNCHANGED,
       diff: {
-        name: srcTable.name,
+        name: databaseTable.name,
         indexes: indexesDiff.diff,
         foreignKeys: foreignKeysDiff.diff,
         columns: columnsDiff.diff
       }
     };
   };
-  const diffSchemas = async (srcSchema, destSchema) => {
+  const diffSchemas = async (schemaDiffCtx) => {
+    const { previousSchema, databaseSchema, userSchema } = schemaDiffCtx;
     const addedTables = [];
     const updatedTables = [];
     const unchangedTables = [];
     const removedTables = [];
-    for (const destTable of destSchema.tables) {
-      const srcTable = helpers.findTable(srcSchema, destTable.name);
-      if (srcTable) {
-        const { status, diff } = diffTables(srcTable, destTable);
+    for (const userSchemaTable of userSchema.tables) {
+      const databaseTable = helpers.findTable(databaseSchema, userSchemaTable.name);
+      const previousTable = previousSchema && helpers.findTable(previousSchema, userSchemaTable.name);
+      if (databaseTable) {
+        const { status, diff } = diffTables({
+          previousTable,
+          databaseTable,
+          userSchemaTable
+        });
         if (status === statuses.CHANGED) {
           updatedTables.push(diff);
         } else {
-          unchangedTables.push(srcTable);
+          unchangedTables.push(databaseTable);
         }
       } else {
-        addedTables.push(destTable);
+        addedTables.push(userSchemaTable);
       }
     }
     const parsePersistedTable = (persistedTable) => {
@@ -1542,23 +1552,34 @@ const createSchemaDiff = (db) => {
       }
       return persistedTable.name;
     };
-    const persistedTables = helpers.hasTable(srcSchema, "strapi_core_store_settings") ? await strapi.store.get({
-      type: "core",
-      key: "persisted_tables"
-    }) ?? [] : [];
+    const persistedTables = helpers.hasTable(databaseSchema, "strapi_core_store_settings") ? (
+      // TODO: replace with low level db query instead
+      await strapi.store.get({
+        type: "core",
+        key: "persisted_tables"
+      }) ?? []
+    ) : [];
     const reservedTables = [...RESERVED_TABLE_NAMES, ...persistedTables.map(parsePersistedTable)];
-    for (const srcTable of srcSchema.tables) {
-      if (!helpers.hasTable(destSchema, srcTable.name) && !reservedTables.includes(srcTable.name)) {
+    for (const databaseTable of databaseSchema.tables) {
+      const isInUserSchema = helpers.hasTable(userSchema, databaseTable.name);
+      const wasTracked = previousSchema && helpers.hasTable(previousSchema, databaseTable.name);
+      const isReserved = reservedTables.includes(databaseTable.name);
+      if (!isInUserSchema && !wasTracked) {
+        continue;
+      }
+      if (!isInUserSchema && wasTracked && !isReserved) {
         const dependencies = persistedTables.filter((table) => {
           const dependsOn = table?.dependsOn;
           if (!___default.default.isArray(dependsOn)) {
             return;
           }
-          return dependsOn.some((table2) => table2.name === srcTable.name);
+          return dependsOn.some((table2) => table2.name === databaseTable.name);
         }).map((dependsOnTable) => {
-          return srcSchema.tables.find((srcTable2) => srcTable2.name === dependsOnTable.name);
+          return databaseSchema.tables.find(
+            (databaseTable2) => databaseTable2.name === dependsOnTable.name
+          );
         }).filter((table) => !___default.default.isNil(table));
-        removedTables.push(srcTable, ...dependencies);
+        removedTables.push(databaseTable, ...dependencies);
       }
     }
     const hasChanged = [addedTables, updatedTables, removedTables].some((arr) => arr.length > 0);
@@ -2204,8 +2225,13 @@ const createSchemaProvider = (db) => {
     },
     async syncSchema() {
       debug$1("Synchronizing database schema");
-      const DBSchema = await db.dialect.schemaInspector.getSchema();
-      const { status, diff } = await this.schemaDiff.diff(DBSchema, this.schema);
+      const databaseSchema = await db.dialect.schemaInspector.getSchema();
+      const storedSchema = await this.schemaStorage.read();
+      const { status, diff } = await this.schemaDiff.diff({
+        previousSchema: storedSchema?.schema,
+        databaseSchema,
+        userSchema: this.schema
+      });
       if (status === "CHANGED") {
         await this.builder.updateSchema(diff);
       }
@@ -2927,6 +2953,68 @@ const createField = (attribute) => {
   }
   throw new Error(`Undefined field for type ${type}`);
 };
+const storage = new node_async_hooks.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__default.default || value instanceof KnexRaw__default.default;
+}
+const addSchema = (db, tableName) => {
+  const schemaName = db.getSchemaName();
+  return schemaName ? `${schemaName}.${tableName}` : tableName;
+};
 const fromSingleRow = (meta, row) => {
   const { attributes } = meta;
   if (___default.default.isNil(row)) {
@@ -3049,7 +3137,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({
@@ -3057,7 +3145,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();
@@ -3070,7 +3158,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}`);
@@ -3086,7 +3174,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
@@ -3101,7 +3189,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
@@ -3117,7 +3205,7 @@ const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
       });
       return subAlias;
     }
-    return alias;
+    return alias2;
   }
   const { joinColumn } = attribute;
   if (joinColumn) {
@@ -3127,20 +3215,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,
@@ -3150,26 +3238,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") {
@@ -3178,7 +3268,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));
@@ -3192,11 +3282,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
         });
@@ -3212,6 +3302,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 = ___default.default.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(___default.default.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 = ___default.default.difference(
+    qb.state.select,
+    // Remove order by columns from the initial select
+    qb.state.orderBy.map(___default.default.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 = ___default.default.curry((alias2, value) => `${value} as ${alias2}`);
+const prefix = ___default.default.curry((prefix2, value) => `${prefix2}.${value}`);
 const joinColPrefix = "__strapi";
 const XtoOne = async (input, ctx) => {
   const { attribute, attributeName, results, populateValue, targetMeta, isCount } = input;
@@ -3239,8 +3398,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 = ___default.default.uniq(
@@ -3254,7 +3413,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,
@@ -3280,7 +3439,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,
@@ -3320,8 +3479,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 = ___default.default.uniq(
@@ -3335,7 +3494,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,
@@ -3361,7 +3520,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,
@@ -3382,8 +3541,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 = ___default.default.uniq(
@@ -3397,7 +3556,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,
@@ -3423,7 +3582,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,
@@ -3474,9 +3633,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,
@@ -3486,9 +3645,9 @@ const morphX = async (input, ctx) => {
         field: attributeName
       },
       orderBy: ___default.default.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 map = ___default.default.groupBy(idColumn.name)(rows);
     results.forEach((result) => {
@@ -3737,13 +3896,6 @@ const processPopulate = (populate, ctx) => {
   }
   return finalPopulate;
 };
-function isKnexQuery(value) {
-  return value instanceof KnexBuilder__default.default || value instanceof KnexRaw__default.default;
-}
-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) {
@@ -3785,8 +3937,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 };
   }
@@ -3816,7 +3968,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)) {
@@ -3839,12 +3991,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
       });
@@ -3859,7 +4011,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;
     }
@@ -4087,7 +4239,7 @@ class ReadableStrapiQuery extends stream.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) {
@@ -4150,61 +4302,6 @@ class ReadableStrapiQuery extends stream.Readable {
     }
   }
 }
-const storage = new node_async_hooks.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;
@@ -4237,9 +4334,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(),
@@ -4406,15 +4503,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 (!___default.default.isNil(alias)) {
-        return `${alias}.${key}`;
+      if (!___default.default.isNil(alias2)) {
+        return `${alias2}.${key}`;
       }
       return this.mustUseAlias() ? `${this.alias}.${key}` : key;
     },
@@ -4449,6 +4546,20 @@ const createQueryBuilder = (uid, db, initialState = {}) => {
     shouldUseDistinct() {
       return state.joins.length > 0 && ___default.default.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)) {
@@ -4566,6 +4677,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 } = {}) {
@@ -4767,7 +4881,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;
@@ -4775,10 +4889,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,
@@ -4795,7 +4910,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 ({
@@ -4814,7 +4929,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({
@@ -4825,7 +4940,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);
   }
 };
@@ -5909,6 +6024,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) {
@@ -5937,7 +6067,20 @@ const createUserMigrationProvider = (db) => {
   const context = { db };
   const umzugProvider = new umzug.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 }],
@@ -6243,7 +6386,8 @@ const createdLocale = {
       if (!model) {
         continue;
       }
-      if (_.isNil(meta.attributes.locale)) {
+      const hasLocaleColumn = await knex2.schema.hasColumn(meta.tableName, "locale");
+      if (meta.attributes.locale && !hasLocaleColumn) {
         await createLocaleColumn(knex2, meta.tableName);
       }
     }
@@ -6252,17 +6396,87 @@ const createdLocale = {
     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,
-  createdLocale
+  createdLocale,
+  createdPublishedAt,
+  dropSlugFieldsIndex
 ];
 const createInternalMigrationProvider = (db) => {
   const context = { db };
   const migrations = [...internalMigrations];
   const umzugProvider = new umzug.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 {
@@ -6533,6 +6747,7 @@ class Database {
   migrations;
   lifecycles;
   entityManager;
+  logger;
   constructor(config) {
     this.config = {
       ...config,
@@ -6552,6 +6767,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);