@strapi/database 4.20.5 → 5.0.0-alpha.0

package/dist/index.js

@@ -1,23 +1,21 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const semver = require("semver");
 const path = require("path");
 const fse = require("fs-extra");
 const createDebug = require("debug");
 const _ = require("lodash/fp");
 const crypto = require("crypto");
-const utils = require("@strapi/utils");
+const crypto$1 = require("node:crypto");
 const dateFns = require("date-fns");
+const utils$1 = require("@strapi/utils");
 const KnexBuilder = require("knex/lib/query/querybuilder");
 const KnexRaw = require("knex/lib/raw");
 const stream = require("stream");
 const node_async_hooks = require("node:async_hooks");
 const _$1 = require("lodash");
-const path$1 = require("node:path");
 const umzug = require("umzug");
 const assert = require("assert");
 const knex = require("knex");
-const SqliteClient = require("knex/lib/dialects/sqlite3/index");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
 function _interopNamespace(e) {
   if (e && e.__esModule)
@@ -37,19 +35,17 @@ function _interopNamespace(e) {
   n.default = e;
   return Object.freeze(n);
 }
-const semver__default = /* @__PURE__ */ _interopDefault(semver);
 const path__default = /* @__PURE__ */ _interopDefault(path);
 const fse__default = /* @__PURE__ */ _interopDefault(fse);
 const createDebug__default = /* @__PURE__ */ _interopDefault(createDebug);
 const ___default = /* @__PURE__ */ _interopDefault(_);
 const crypto__default = /* @__PURE__ */ _interopDefault(crypto);
+const crypto__default$1 = /* @__PURE__ */ _interopDefault(crypto$1);
 const dateFns__namespace = /* @__PURE__ */ _interopNamespace(dateFns);
 const KnexBuilder__default = /* @__PURE__ */ _interopDefault(KnexBuilder);
 const KnexRaw__default = /* @__PURE__ */ _interopDefault(KnexRaw);
 const ___default$1 = /* @__PURE__ */ _interopDefault(_$1);
-const path__default$1 = /* @__PURE__ */ _interopDefault(path$1);
 const knex__default = /* @__PURE__ */ _interopDefault(knex);
-const SqliteClient__default = /* @__PURE__ */ _interopDefault(SqliteClient);
 class Dialect {
   db;
   schemaInspector = {};
@@ -60,7 +56,8 @@ class Dialect {
   }
   configure() {
   }
-  initialize() {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async initialize(_nativeConnection) {
   }
   getSqlType(type) {
     return type;
@@ -77,9 +74,6 @@ class Dialect {
   supportsUnsigned() {
     return false;
   }
-  supportsWindowFunctions() {
-    return true;
-  }
   supportsOperator() {
     return true;
   }
@@ -423,7 +417,7 @@ class PostgresDialect extends Dialect {
   useReturning() {
     return true;
   }
-  async initialize() {
+  async initialize(nativeConnection) {
     this.db.connection.client.driver.types.setTypeParser(
       this.db.connection.client.driver.types.builtins.DATE,
       "text",
@@ -439,6 +433,10 @@ class PostgresDialect extends Dialect {
       "text",
       parseFloat
     );
+    const schemaName = this.db.getSchemaName();
+    if (schemaName) {
+      await this.db.connection.raw(`SET search_path TO "${schemaName}"`).connection(nativeConnection);
+    }
   }
   usesForeignKeys() {
     return true;
@@ -702,11 +700,11 @@ class MysqlDatabaseInspector {
   constructor(db) {
     this.db = db;
   }
-  async getInformation() {
+  async getInformation(nativeConnection) {
     let database;
     let versionNumber;
     try {
-      const [results] = await this.db.connection.raw(SQL_QUERIES$1.VERSION);
+      const [results] = await this.db.connection.raw(SQL_QUERIES$1.VERSION).connection(nativeConnection);
       const versionSplit = results[0].version.split("-");
       const databaseName = versionSplit[1];
       versionNumber = versionSplit[0];
@@ -753,12 +751,14 @@ class MysqlDialect extends Dialect {
       return next();
     };
   }
-  async initialize() {
+  async initialize(nativeConnection) {
     try {
-      await this.db.connection.raw(`set session sql_require_primary_key = 0;`);
+      await this.db.connection.raw(`set session sql_require_primary_key = 0;`).connection(nativeConnection);
     } catch (err) {
     }
-    this.info = await this.databaseInspector.getInformation();
+    if (!this.info) {
+      this.info = await this.databaseInspector.getInformation(nativeConnection);
+    }
   }
   async startSchemaUpdate() {
     try {
@@ -773,14 +773,6 @@ class MysqlDialect extends Dialect {
   supportsUnsigned() {
     return true;
   }
-  supportsWindowFunctions() {
-    const isMysqlDB = !this.info?.database || this.info.database === MYSQL;
-    const isBeforeV8 = !semver__default.default.valid(this.info?.version) || semver__default.default.lt(this.info?.version ?? "", "8.0.0");
-    if (isMysqlDB && isBeforeV8) {
-      return false;
-    }
-    return true;
-  }
   usesForeignKeys() {
     return true;
   }
@@ -938,8 +930,8 @@ class SqliteDialect extends Dialect {
   useReturning() {
     return true;
   }
-  async initialize() {
-    await this.db.connection.raw("pragma foreign_keys = on");
+  async initialize(nativeConnection) {
+    await this.db.connection.raw("pragma foreign_keys = on").connection(nativeConnection);
   }
   canAlterConstraints() {
     return false;
@@ -1001,10 +993,8 @@ const getDialectName = (client) => {
     case "postgres":
       return "postgres";
     case "mysql":
-    case "mysql2":
       return "mysql";
     case "sqlite":
-    case "sqlite-legacy":
       return "sqlite";
     default:
       throw new Error(`Unknown dialect ${client}`);
@@ -1268,7 +1258,11 @@ const createHelpers = (db) => {
     dropTableForeignKeys
   };
 };
-const RESERVED_TABLE_NAMES = ["strapi_migrations", "strapi_database_schema"];
+const RESERVED_TABLE_NAMES = [
+  "strapi_migrations",
+  "strapi_migrations_internal",
+  "strapi_database_schema"
+];
 const statuses = {
   CHANGED: "CHANGED",
   UNCHANGED: "UNCHANGED"
@@ -1648,11 +1642,212 @@ const NUMBER_TYPES = ["biginteger", "integer", "decimal", "float"];
 const isString = (type) => STRING_TYPES.includes(type);
 const isNumber = (type) => NUMBER_TYPES.includes(type);
 const isScalar = (type) => SCALAR_TYPES.includes(type);
-const isComponent = (type) => type === "component";
-const isDynamicZone = (type) => type === "dynamiczone";
 const isRelation = (type) => type === "relation";
 const isScalarAttribute = (attribute) => isScalar(attribute.type);
 const isRelationalAttribute = (attribute) => isRelation(attribute.type);
+const MAX_DB_IDENTIFIER_LENGTH = 0;
+const HASH_LENGTH = 5;
+const HASH_SEPARATOR = "";
+const IDENTIFIER_SEPARATOR = "_";
+const MIN_TOKEN_LENGTH = 3;
+function createHash(data, len) {
+  if (!_.isInteger(len) || len <= 0) {
+    throw new Error(`createHash length must be a positive integer, received ${len}`);
+  }
+  const hash = crypto__default$1.default.createHash("shake256", { outputLength: Math.ceil(len / 2) }).update(data);
+  return hash.digest("hex").substring(0, len);
+}
+function getShortenedName(name, len) {
+  if (!_.isInteger(len) || len <= 0) {
+    throw new Error(`tokenWithHash length must be a positive integer, received ${len}`);
+  }
+  if (name.length <= len) {
+    return name;
+  }
+  if (len < MIN_TOKEN_LENGTH + HASH_LENGTH) {
+    throw new Error(
+      `length for part of identifier too short, minimum is hash length (${HASH_LENGTH}) plus min token length (${MIN_TOKEN_LENGTH}), received ${len} for token ${name}`
+    );
+  }
+  const availableLength = len - HASH_LENGTH - HASH_SEPARATOR.length;
+  if (availableLength < MIN_TOKEN_LENGTH) {
+    throw new Error(
+      `length for part of identifier minimum is less than min token length (${MIN_TOKEN_LENGTH}), received ${len} for token ${name}`
+    );
+  }
+  return `${name.substring(0, availableLength)}${HASH_SEPARATOR}${createHash(name, HASH_LENGTH)}`;
+}
+function getNameFromTokens(nameTokens, maxLength = MAX_DB_IDENTIFIER_LENGTH) {
+  if (!_.isInteger(maxLength) || maxLength < 0) {
+    throw new Error("maxLength must be a positive integer or 0 (for unlimited length)");
+  }
+  const fullLengthName = nameTokens.map((token) => _.snakeCase(token.name)).join(IDENTIFIER_SEPARATOR);
+  if (fullLengthName.length <= maxLength || maxLength === 0) {
+    return fullLengthName;
+  }
+  const [compressible, incompressible] = _.partition(
+    (token) => token.compressible,
+    nameTokens
+  );
+  const totalIncompressibleLength = _.sumBy((token) => token.name.length)(incompressible);
+  const totalSeparatorsLength = nameTokens.length * IDENTIFIER_SEPARATOR.length - 1;
+  const available = maxLength - totalIncompressibleLength - totalSeparatorsLength;
+  const availablePerToken = Math.floor(available / compressible.length);
+  if (totalIncompressibleLength + totalSeparatorsLength > maxLength || availablePerToken < MIN_TOKEN_LENGTH) {
+    throw new Error("Maximum length is too small to accommodate all tokens");
+  }
+  let surplus = available % compressible.length;
+  const minHashedLength = HASH_LENGTH + HASH_SEPARATOR.length + MIN_TOKEN_LENGTH;
+  const totalLength = nameTokens.reduce((total, token) => {
+    if (token.compressible) {
+      if (token.name.length < availablePerToken) {
+        return total + token.name.length;
+      }
+      return total + minHashedLength;
+    }
+    return total + token.name.length;
+  }, nameTokens.length * IDENTIFIER_SEPARATOR.length - 1);
+  if (maxLength < totalLength) {
+    throw new Error("Maximum length is too small to accommodate all tokens");
+  }
+  let deficits = [];
+  compressible.forEach((token) => {
+    const actualLength = token.name.length;
+    if (actualLength < availablePerToken) {
+      surplus += availablePerToken - actualLength;
+      token.allocatedLength = actualLength;
+    } else {
+      token.allocatedLength = availablePerToken;
+      deficits.push(token);
+    }
+  });
+  function filterAndIncreaseLength(token) {
+    if (token.allocatedLength < token.name.length && surplus > 0) {
+      token.allocatedLength += 1;
+      surplus -= 1;
+      return token.allocatedLength < token.name.length;
+    }
+    return false;
+  }
+  let previousSurplus = surplus + 1;
+  while (surplus > 0 && deficits.length > 0) {
+    deficits = deficits.filter((token) => filterAndIncreaseLength(token));
+    if (surplus === previousSurplus) {
+      break;
+    }
+    previousSurplus = surplus;
+  }
+  const shortenedName = nameTokens.map((token) => {
+    if (token.compressible && "allocatedLength" in token && token.allocatedLength !== void 0) {
+      return getShortenedName(token.name, token.allocatedLength);
+    }
+    return token.name;
+  }).join(IDENTIFIER_SEPARATOR);
+  if (shortenedName.length > maxLength) {
+    throw new Error(
+      `name shortening failed to generate a name of the correct maxLength; name ${shortenedName}`
+    );
+  }
+  return shortenedName;
+}
+const ID_COLUMN = "id";
+const ORDER_COLUMN = "order";
+const FIELD_COLUMN = "field";
+const getName = (names, options) => {
+  const tokens = ___default.default.castArray(names).map((name) => {
+    return {
+      name,
+      compressible: true
+    };
+  });
+  if (options?.suffix) {
+    tokens.push({ name: options.suffix, compressible: false });
+  }
+  if (options?.prefix) {
+    tokens.unshift({ name: options.prefix, compressible: false });
+  }
+  const maxLength = options?.maxLength ?? MAX_DB_IDENTIFIER_LENGTH;
+  return getNameFromTokens(tokens, maxLength);
+};
+const getTableName = (name, options) => {
+  return getName(name, options);
+};
+const getJoinTableName = (collectionName, attributeName, options) => {
+  return getName([collectionName, attributeName], { suffix: "links", ...options });
+};
+const getMorphTableName = (collectionName, attributeName, options) => {
+  return getName([collectionName, attributeName], { suffix: "morphs", ...options });
+};
+const getColumnName = (attributeName, options) => {
+  return getName(attributeName, options);
+};
+const getJoinColumnAttributeIdName = (attributeName, options) => {
+  return getName(attributeName, { suffix: "id", ...options });
+};
+const getInverseJoinColumnAttributeIdName = (attributeName, options) => {
+  return getName(attributeName, { suffix: "id", prefix: "inv", ...options });
+};
+const getOrderColumnName = (singularName, options) => {
+  return getName(singularName, { suffix: "order", ...options });
+};
+const getInverseOrderColumnName = (singularName, options) => {
+  return getName(singularName, { suffix: "order", prefix: "inv", ...options });
+};
+const getMorphColumnJoinTableIdName = (singularName, options) => {
+  return getName(singularName, { suffix: "id", ...options });
+};
+const getMorphColumnAttributeIdName = (attributeName, options) => {
+  return getName(attributeName, { suffix: "id", ...options });
+};
+const getMorphColumnTypeName = (attributeName, options) => {
+  return getName(attributeName, { suffix: "type", ...options });
+};
+const getIndexName = (names, options) => {
+  return getName(names, { suffix: "index", ...options });
+};
+const getFkIndexName = (names, options) => {
+  return getName(names, { suffix: "fk", ...options });
+};
+const getInverseFkIndexName = (names, options) => {
+  return getName(names, { suffix: "inv_fk", ...options });
+};
+const getOrderFkIndexName = (names, options) => {
+  return getName(names, { suffix: "order_fk", ...options });
+};
+const getOrderInverseFkIndexName = (names, options) => {
+  return getName(names, { suffix: "order_inv_fk", ...options });
+};
+const getUniqueIndexName = (names, options) => {
+  return getName(names, { suffix: "unique", ...options });
+};
+const getPrimaryIndexName = (names) => {
+  return getName(names, { suffix: "primary" });
+};
+const identifiers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ Object.defineProperty({
+  __proto__: null,
+  FIELD_COLUMN,
+  ID_COLUMN,
+  ORDER_COLUMN,
+  getColumnName,
+  getFkIndexName,
+  getIndexName,
+  getInverseFkIndexName,
+  getInverseJoinColumnAttributeIdName,
+  getInverseOrderColumnName,
+  getJoinColumnAttributeIdName,
+  getJoinTableName,
+  getMorphColumnAttributeIdName,
+  getMorphColumnJoinTableIdName,
+  getMorphColumnTypeName,
+  getMorphTableName,
+  getName,
+  getOrderColumnName,
+  getOrderFkIndexName,
+  getOrderInverseFkIndexName,
+  getPrimaryIndexName,
+  getTableName,
+  getUniqueIndexName
+}, Symbol.toStringTag, { value: "Module" }));
 const createColumn = (name, attribute) => {
   const { type, args = [], ...opts } = getColumnType(attribute);
   return {
@@ -1678,51 +1873,62 @@ const createTable = (meta) => {
     if (attribute.type === "relation") {
       if ("morphColumn" in attribute && attribute.morphColumn && attribute.owner) {
         const { idColumn, typeColumn } = attribute.morphColumn;
+        const idColumnName = getName(idColumn.name);
+        const typeColumnName = getName(typeColumn.name);
         table.columns.push(
-          createColumn(idColumn.name, {
+          createColumn(idColumnName, {
             type: "integer",
             column: {
               unsigned: true
             }
           })
         );
-        table.columns.push(createColumn(typeColumn.name, { type: "string" }));
+        table.columns.push(createColumn(typeColumnName, { type: "string" }));
       } else if ("joinColumn" in attribute && attribute.joinColumn && attribute.owner && attribute.joinColumn.referencedTable) {
-        const { name: columnName, referencedColumn, referencedTable } = attribute.joinColumn;
+        const {
+          name: columnNameFull,
+          referencedColumn,
+          referencedTable,
+          columnType = "integer"
+        } = attribute.joinColumn;
+        const columnName = getName(columnNameFull);
         const column = createColumn(columnName, {
-          type: "integer",
+          // TODO: find the column type automatically, or allow passing all the column params
+          type: columnType,
           column: {
             unsigned: true
           }
         });
         table.columns.push(column);
+        const fkName = getFkIndexName([table.name, columnName]);
         table.foreignKeys.push({
-          name: `${table.name}_${columnName}_fk`,
-          columns: [columnName],
+          name: fkName,
+          columns: [column.name],
           referencedTable,
           referencedColumns: [referencedColumn],
           // NOTE: could allow configuration
           onDelete: "SET NULL"
         });
         table.indexes.push({
-          name: `${table.name}_${columnName}_fk`,
-          columns: [columnName]
+          name: fkName,
+          columns: [column.name]
         });
       }
     } else if (isScalarAttribute(attribute)) {
-      const column = createColumn(attribute.columnName || key, attribute);
+      const columnName = getName(attribute.columnName || key);
+      const column = createColumn(columnName, attribute);
       if (column.unique) {
         table.indexes.push({
           type: "unique",
-          name: `${table.name}_${column.name}_unique`,
-          columns: [column.name]
+          name: getUniqueIndexName([table.name, column.name]),
+          columns: [columnName]
         });
       }
       if (column.primary) {
         table.indexes.push({
           type: "primary",
-          name: `${table.name}_${column.name}_primary`,
-          columns: [column.name]
+          name: getPrimaryIndexName([table.name, column.name]),
+          columns: [columnName]
         });
       }
       table.columns.push(column);
@@ -1750,8 +1956,7 @@ const getColumnType = (attribute) => {
     }
     case "uid": {
       return {
-        type: "string",
-        unique: true
+        type: "string"
       };
     }
     case "richtext":
@@ -1824,8 +2029,14 @@ const metadataToSchema = (metadata) => {
 };
 const debug = createDebug__default.default("strapi::database");
 const createSchemaProvider = (db) => {
-  const schema = metadataToSchema(db.metadata);
+  const state = {};
   return {
+    get schema() {
+      if (!state.schema) {
+        state.schema = metadataToSchema(db.metadata);
+      }
+      return state.schema;
+    },
     builder: createSchemaBuilder(db),
     schemaDiff: createSchemaDiff(db),
     schemaStorage: createSchemaStorage(db),
@@ -1842,7 +2053,7 @@ const createSchemaProvider = (db) => {
      */
     async create() {
       debug("Created database schema");
-      await this.builder.createSchema(schema);
+      await this.builder.createSchema(this.schema);
     },
     /**
      * Resets the database schema
@@ -1855,11 +2066,11 @@ const createSchemaProvider = (db) => {
     async syncSchema() {
       debug("Synchronizing database schema");
       const DBSchema = await db.dialect.schemaInspector.getSchema();
-      const { status, diff } = await this.schemaDiff.diff(DBSchema, schema);
+      const { status, diff } = await this.schemaDiff.diff(DBSchema, this.schema);
       if (status === "CHANGED") {
         await this.builder.updateSchema(diff);
       }
-      await this.schemaStorage.add(schema);
+      await this.schemaStorage.add(this.schema);
     },
     // TODO: support options to migrate softly or forcefully
     // TODO: support option to disable auto migration & run a CLI command instead to avoid doing it at startup
@@ -1876,7 +2087,7 @@ const createSchemaProvider = (db) => {
         return this.syncSchema();
       }
       const { hash: oldHash } = oldSchema;
-      const hash = await this.schemaStorage.hashSchema(schema);
+      const hash = await this.schemaStorage.hashSchema(this.schema);
       if (oldHash !== hash) {
         debug("Schema changed");
         return this.syncSchema();
@@ -1885,9 +2096,11 @@ const createSchemaProvider = (db) => {
     }
   };
 };
+const ID = ID_COLUMN;
+const ORDER = ORDER_COLUMN;
+const FIELD = FIELD_COLUMN;
 const hasInversedBy = (attr) => "inversedBy" in attr;
 const hasMappedBy = (attr) => "mappedBy" in attr;
-const isPolymorphic = (attribute) => ["morphOne", "morphMany", "morphToOne", "morphToMany"].includes(attribute.relation);
 const isOneToAny = (attribute) => ["oneToOne", "oneToMany"].includes(attribute.relation);
 const isManyToAny = (attribute) => ["manyToMany", "manyToOne"].includes(attribute.relation);
 const isAnyToOne = (attribute) => ["oneToOne", "manyToOne"].includes(attribute.relation);
@@ -1895,7 +2108,6 @@ const isAnyToMany = (attribute) => ["oneToMany", "manyToMany"].includes(attribut
 const isBidirectional = (attribute) => hasInversedBy(attribute) || hasMappedBy(attribute);
 const isOwner = (attribute) => !isBidirectional(attribute) || hasInversedBy(attribute);
 const shouldUseJoinTable = (attribute) => !("useJoinTable" in attribute) || attribute.useJoinTable !== false;
-const getJoinTableName = (tableName, attributeName) => ___default.default.snakeCase(`${tableName}_${attributeName}_links`);
 const hasOrderColumn = (attribute) => isAnyToMany(attribute);
 const hasInverseOrderColumn = (attribute) => isBidirectional(attribute) && isManyToAny(attribute);
 const createOneToOne = (attributeName, attribute, meta, metadata) => {
@@ -1954,8 +2166,11 @@ const createManyToMany = (attributeName, attribute, meta, metadata) => {
   }
 };
 const createMorphToOne = (attributeName, attribute) => {
-  const idColumnName = "target_id";
-  const typeColumnName = "target_type";
+  const idColumnName = getJoinColumnAttributeIdName("target");
+  const typeColumnName = getMorphColumnTypeName("target");
+  if ("morphColumn" in attribute && attribute.morphColumn) {
+    return;
+  }
   Object.assign(attribute, {
     owner: true,
     morphColumn: {
@@ -1965,23 +2180,26 @@ const createMorphToOne = (attributeName, attribute) => {
       },
       idColumn: {
         name: idColumnName,
-        referencedColumn: "id"
+        referencedColumn: ID
       }
     }
   });
 };
 const createMorphToMany = (attributeName, attribute, meta, metadata) => {
-  const joinTableName = ___default.default.snakeCase(`${meta.tableName}_${attributeName}_morphs`);
-  const joinColumnName = ___default.default.snakeCase(`${meta.singularName}_id`);
-  const morphColumnName = ___default.default.snakeCase(`${attributeName}`);
-  const idColumnName = `${morphColumnName}_id`;
-  const typeColumnName = `${morphColumnName}_type`;
+  if ("joinTable" in attribute && attribute.joinTable) {
+    return;
+  }
+  const joinTableName = getMorphTableName(meta.tableName, attributeName);
+  const joinColumnName = getMorphColumnJoinTableIdName(meta.singularName);
+  const idColumnName = getMorphColumnAttributeIdName(attributeName);
+  const typeColumnName = getMorphColumnTypeName(attributeName);
+  const fkIndexName = getFkIndexName(joinTableName);
   metadata.add({
     singularName: joinTableName,
     uid: joinTableName,
     tableName: joinTableName,
     attributes: {
-      id: {
+      [ID]: {
         type: "increments"
       },
       [joinColumnName]: {
@@ -1999,10 +2217,10 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
       [typeColumnName]: {
         type: "string"
       },
-      field: {
+      [FIELD]: {
         type: "string"
       },
-      order: {
+      [ORDER]: {
         type: "float",
         column: {
           unsigned: true
@@ -2011,12 +2229,12 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
     },
     indexes: [
       {
-        name: `${joinTableName}_fk`,
+        name: fkIndexName,
         columns: [joinColumnName]
       },
       {
         name: `${joinTableName}_order_index`,
-        columns: ["order"]
+        columns: [ORDER]
       },
       {
         name: `${joinTableName}_id_column_index`,
@@ -2025,10 +2243,10 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
     ],
     foreignKeys: [
       {
-        name: `${joinTableName}_fk`,
+        name: fkIndexName,
         columns: [joinColumnName],
-        referencedColumns: ["id"],
-        referencedTable: meta.tableName,
+        referencedColumns: [ID],
+        referencedTable: getTableName(meta.tableName),
         onDelete: "CASCADE"
       }
     ],
@@ -2039,7 +2257,7 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
     name: joinTableName,
     joinColumn: {
       name: joinColumnName,
-      referencedColumn: "id"
+      referencedColumn: ID
     },
     morphColumn: {
       typeColumn: {
@@ -2047,7 +2265,7 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
       },
       idColumn: {
         name: idColumnName,
-        referencedColumn: "id"
+        referencedColumn: ID
       }
     },
     orderBy: {
@@ -2083,9 +2301,12 @@ const createJoinColum = (metadata, { attribute, attributeName }) => {
   const joinColumnName = ___default.default.snakeCase(`${attributeName}_id`);
   const joinColumn = {
     name: joinColumnName,
-    referencedColumn: "id",
+    referencedColumn: ID,
     referencedTable: targetMeta.tableName
   };
+  if ("joinColumn" in attribute) {
+    Object.assign(joinColumn, attribute.joinColumn);
+  }
   Object.assign(attribute, { owner: true, joinColumn });
   if (isBidirectional(attribute)) {
     const inverseAttribute = targetMeta.attributes[attribute.inversedBy];
@@ -2102,23 +2323,30 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   if (!targetMeta) {
     throw new Error(`Unknown target ${attribute.target}`);
   }
+  if ("joinTable" in attribute && attribute.joinTable) {
+    return;
+  }
   const joinTableName = getJoinTableName(meta.tableName, attributeName);
-  const joinColumnName = ___default.default.snakeCase(`${meta.singularName}_id`);
-  let inverseJoinColumnName = ___default.default.snakeCase(`${targetMeta.singularName}_id`);
+  const joinColumnName = getJoinColumnAttributeIdName(meta.singularName);
+  let inverseJoinColumnName = getJoinColumnAttributeIdName(targetMeta.singularName);
   if (joinColumnName === inverseJoinColumnName) {
-    inverseJoinColumnName = `inv_${inverseJoinColumnName}`;
+    inverseJoinColumnName = getInverseJoinColumnAttributeIdName(
+      targetMeta.singularName
+    );
   }
-  const orderColumnName = ___default.default.snakeCase(`${targetMeta.singularName}_order`);
-  let inverseOrderColumnName = ___default.default.snakeCase(`${meta.singularName}_order`);
+  const orderColumnName = getOrderColumnName(targetMeta.singularName);
+  let inverseOrderColumnName = getOrderColumnName(meta.singularName);
   if (attribute.relation === "manyToMany" && orderColumnName === inverseOrderColumnName) {
-    inverseOrderColumnName = `inv_${inverseOrderColumnName}`;
+    inverseOrderColumnName = getInverseOrderColumnName(meta.singularName);
   }
+  const fkIndexName = getFkIndexName(joinTableName);
+  const invFkIndexName = getInverseFkIndexName(joinTableName);
   const metadataSchema = {
     singularName: joinTableName,
     uid: joinTableName,
     tableName: joinTableName,
     attributes: {
-      id: {
+      [ID]: {
         type: "increments"
       },
       [joinColumnName]: {
@@ -2137,32 +2365,34 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
     },
     indexes: [
       {
-        name: `${joinTableName}_fk`,
+        name: fkIndexName,
         columns: [joinColumnName]
       },
       {
-        name: `${joinTableName}_inv_fk`,
+        name: invFkIndexName,
         columns: [inverseJoinColumnName]
       },
       {
-        name: `${joinTableName}_unique`,
+        name: getUniqueIndexName(joinTableName),
         columns: [joinColumnName, inverseJoinColumnName],
         type: "unique"
       }
     ],
     foreignKeys: [
       {
-        name: `${joinTableName}_fk`,
+        name: fkIndexName,
         columns: [joinColumnName],
-        referencedColumns: ["id"],
+        referencedColumns: [ID],
         referencedTable: meta.tableName,
+        // TODO: does this need to be wrapped or do we trust meta.tableName to be the right shortened version?
         onDelete: "CASCADE"
       },
       {
-        name: `${joinTableName}_inv_fk`,
+        name: invFkIndexName,
         columns: [inverseJoinColumnName],
-        referencedColumns: ["id"],
+        referencedColumns: [ID],
         referencedTable: targetMeta.tableName,
+        // TODO: does this need to be wrapped or do we trust meta.tableName to be the right shortened version?
         onDelete: "CASCADE"
       }
     ],
@@ -2173,11 +2403,13 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
     name: joinTableName,
     joinColumn: {
       name: joinColumnName,
-      referencedColumn: "id"
+      referencedColumn: ID,
+      referencedTable: meta.tableName
     },
     inverseJoinColumn: {
       name: inverseJoinColumnName,
-      referencedColumn: "id"
+      referencedColumn: ID,
+      referencedTable: targetMeta.tableName
     },
     pivotColumns: [joinColumnName, inverseJoinColumnName]
   };
@@ -2190,7 +2422,8 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       }
     };
     metadataSchema.indexes.push({
-      name: `${joinTableName}_order_fk`,
+      name: getOrderFkIndexName(joinTableName),
+      // TODO: should we send joinTableName as parts?
       columns: [orderColumnName]
     });
     joinTable.orderColumnName = orderColumnName;
@@ -2205,7 +2438,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       }
     };
     metadataSchema.indexes.push({
-      name: `${joinTableName}_order_inv_fk`,
+      name: getOrderInverseFkIndexName(joinTableName),
       columns: [inverseOrderColumnName]
     });
     joinTable.inverseOrderColumnName = inverseOrderColumnName;
@@ -2286,207 +2519,60 @@ class Metadata extends Map {
       seenTables.set(meta.tableName, true);
     }
   }
-}
-const createMetadata = (models = []) => {
-  const metadata = new Metadata();
-  for (const model of ___default.default.cloneDeep(models)) {
-    if ("id" in model.attributes) {
-      throw new Error('The attribute "id" is reserved and cannot be used in a model');
-    }
-    metadata.add({
-      ...model,
-      attributes: {
-        id: {
-          type: "increments"
+  loadModels(models = []) {
+    for (const model of ___default.default.cloneDeep(models)) {
+      this.add({
+        ...model,
+        attributes: {
+          ...model.attributes
         },
-        ...model.attributes
-      },
-      lifecycles: model.lifecycles ?? {},
-      indexes: model.indexes || [],
-      foreignKeys: model.foreignKeys || [],
-      columnToAttribute: {}
-    });
-  }
-  for (const meta of metadata.values()) {
-    if (hasComponentsOrDz(meta)) {
-      const compoLinkModelMeta = createCompoLinkModelMeta(meta);
-      meta.componentLink = compoLinkModelMeta;
-      metadata.add(compoLinkModelMeta);
+        lifecycles: model.lifecycles ?? {},
+        indexes: model.indexes ?? [],
+        foreignKeys: model.foreignKeys ?? [],
+        columnToAttribute: {}
+      });
     }
-    for (const [attributeName, attribute] of Object.entries(meta.attributes)) {
-      try {
-        if (isComponent(attribute.type) && hasComponentsOrDz(meta)) {
-          createComponent(attributeName, attribute, meta);
-          continue;
-        }
-        if (isDynamicZone(attribute.type) && hasComponentsOrDz(meta)) {
-          createDynamicZone(attributeName, attribute, meta);
-          continue;
-        }
-        if (isRelationalAttribute(attribute)) {
-          createRelation(attributeName, attribute, meta, metadata);
-          continue;
-        }
-        createAttribute(attributeName, attribute);
-      } catch (error) {
-        console.log(error);
-        if (error instanceof Error) {
-          throw new Error(
-            `Error on attribute ${attributeName} in model ${meta.singularName}(${meta.uid}): ${error.message}`
-          );
+    for (const meta of this.values()) {
+      for (const [attributeName, attribute] of Object.entries(meta.attributes)) {
+        try {
+          if (isRelationalAttribute(attribute)) {
+            createRelation(attributeName, attribute, meta, this);
+            continue;
+          }
+          createAttribute(attributeName, attribute);
+        } catch (error) {
+          if (error instanceof Error) {
+            throw new Error(
+              `Error on attribute ${attributeName} in model ${meta.singularName}(${meta.uid}): ${error.message}`
+            );
+          }
         }
       }
     }
-  }
-  for (const meta of metadata.values()) {
-    const columnToAttribute = Object.keys(meta.attributes).reduce((acc, key) => {
-      const attribute = meta.attributes[key];
-      if ("columnName" in attribute) {
-        return Object.assign(acc, { [attribute.columnName || key]: key });
-      }
-      return Object.assign(acc, { [key]: key });
-    }, {});
-    meta.columnToAttribute = columnToAttribute;
-  }
-  metadata.validate();
-  return metadata;
-};
-const hasComponentsOrDz = (model) => {
-  return Object.values(model.attributes).some(
-    ({ type }) => isComponent(type) || isDynamicZone(type)
-  );
-};
-const createCompoLinkModelMeta = (baseModelMeta) => {
-  const name = `${baseModelMeta.tableName}_components`;
-  return {
-    // TODO: make sure there can't be any conflicts with a prefix
-    singularName: name,
-    uid: name,
-    tableName: name,
-    attributes: {
-      id: {
-        type: "increments"
-      },
-      entity_id: {
-        type: "integer",
-        column: {
-          unsigned: true
-        }
-      },
-      component_id: {
-        type: "integer",
-        column: {
-          unsigned: true
-        }
-      },
-      component_type: {
-        type: "string"
-      },
-      field: {
-        type: "string"
-      },
-      order: {
-        type: "float",
-        column: {
-          unsigned: true,
-          defaultTo: null
+    for (const meta of this.values()) {
+      const columnToAttribute = Object.keys(meta.attributes).reduce((acc, key) => {
+        const attribute = meta.attributes[key];
+        if ("columnName" in attribute) {
+          return Object.assign(acc, { [attribute.columnName || key]: key });
         }
-      }
-    },
-    indexes: [
-      {
-        name: `${baseModelMeta.tableName}_field_index`,
-        columns: ["field"]
-      },
-      {
-        name: `${baseModelMeta.tableName}_component_type_index`,
-        columns: ["component_type"]
-      },
-      {
-        name: `${baseModelMeta.tableName}_entity_fk`,
-        columns: ["entity_id"]
-      },
-      {
-        name: `${baseModelMeta.tableName}_unique`,
-        columns: ["entity_id", "component_id", "field", "component_type"],
-        type: "unique"
-      }
-    ],
-    foreignKeys: [
-      {
-        name: `${baseModelMeta.tableName}_entity_fk`,
-        columns: ["entity_id"],
-        referencedColumns: ["id"],
-        referencedTable: baseModelMeta.tableName,
-        onDelete: "CASCADE"
-      }
-    ],
-    lifecycles: {},
-    columnToAttribute: {}
-  };
-};
-const createDynamicZone = (attributeName, attribute, meta) => {
-  Object.assign(attribute, {
-    type: "relation",
-    relation: "morphToMany",
-    // TODO: handle restrictions at some point
-    // target: attribute.components,
-    joinTable: {
-      name: meta.componentLink.tableName,
-      joinColumn: {
-        name: "entity_id",
-        referencedColumn: "id"
-      },
-      morphColumn: {
-        idColumn: {
-          name: "component_id",
-          referencedColumn: "id"
-        },
-        typeColumn: {
-          name: "component_type"
-        },
-        typeField: "__component"
-      },
-      on: {
-        field: attributeName
-      },
-      orderBy: {
-        order: "asc"
-      },
-      pivotColumns: ["entity_id", "component_id", "field", "component_type"]
-    }
-  });
-};
-const createComponent = (attributeName, attribute, meta) => {
-  Object.assign(attribute, {
-    type: "relation",
-    relation: "repeatable" in attribute && attribute.repeatable === true ? "oneToMany" : "oneToOne",
-    target: "component" in attribute && attribute.component,
-    joinTable: {
-      name: meta.componentLink.tableName,
-      joinColumn: {
-        name: "entity_id",
-        referencedColumn: "id"
-      },
-      inverseJoinColumn: {
-        name: "component_id",
-        referencedColumn: "id"
-      },
-      on: {
-        field: attributeName
-      },
-      orderColumnName: "order",
-      orderBy: {
-        order: "asc"
-      },
-      pivotColumns: ["entity_id", "component_id", "field", "component_type"]
+        return Object.assign(acc, { [key]: key });
+      }, {});
+      meta.columnToAttribute = columnToAttribute;
     }
-  });
-};
+    this.validate();
+  }
+}
 const createAttribute = (attributeName, attribute) => {
-  const columnName = ___default.default.snakeCase(attributeName);
+  const columnName = getColumnName(attributeName);
   Object.assign(attribute, { columnName });
 };
+const createMetadata = (models = []) => {
+  const metadata = new Metadata();
+  if (models.length) {
+    metadata.loadModels(models);
+  }
+  return metadata;
+};
 class Field {
   config;
   constructor(config) {
@@ -3458,7 +3544,7 @@ const castValue = (value, attribute) => {
 };
 const processSingleAttributeWhere = (attribute, where, operator = "$eq") => {
   if (!isRecord$1(where)) {
-    if (utils.isOperatorOfType("cast", operator)) {
+    if (utils$1.isOperatorOfType("cast", operator)) {
       return castValue(where, attribute);
     }
     return where;
@@ -3466,7 +3552,7 @@ const processSingleAttributeWhere = (attribute, where, operator = "$eq") => {
   const filters = {};
   for (const key of Object.keys(where)) {
     const value = where[key];
-    if (!utils.isOperatorOfType("where", key)) {
+    if (!utils$1.isOperatorOfType("where", key)) {
       throw new Error(`Undefined attribute level operator ${key}`);
     }
     filters[key] = processAttributeWhere(attribute, value, key);
@@ -3497,7 +3583,7 @@ function processWhere(where, ctx) {
   const filters = {};
   for (const key of Object.keys(where)) {
     const value = where[key];
-    if (utils.isOperatorOfType("group", key) && Array.isArray(value)) {
+    if (utils$1.isOperatorOfType("group", key) && Array.isArray(value)) {
       filters[key] = value.map((sub) => processNested(sub, ctx));
       continue;
     }
@@ -3505,7 +3591,7 @@ function processWhere(where, ctx) {
       filters[key] = processNested(value, ctx);
       continue;
     }
-    if (utils.isOperatorOfType("where", key)) {
+    if (utils$1.isOperatorOfType("where", key)) {
       throw new Error(
         `Only $and, $or and $not can only be used as root level operators. Found ${key}.`
       );
@@ -3527,7 +3613,7 @@ function processWhere(where, ctx) {
         alias: subAlias,
         uid: attribute.target
       });
-      if (!isRecord$1(nestedWhere) || utils.isOperatorOfType("where", _.keys(nestedWhere)[0])) {
+      if (!isRecord$1(nestedWhere) || utils$1.isOperatorOfType("where", _.keys(nestedWhere)[0])) {
         nestedWhere = { [qb.aliasColumn("id", subAlias)]: nestedWhere };
       }
       Object.assign(filters, nestedWhere);
@@ -3544,7 +3630,7 @@ function processWhere(where, ctx) {
   return filters;
 }
 const applyOperator = (qb, column, operator, value) => {
-  if (Array.isArray(value) && !utils.isOperatorOfType("array", operator)) {
+  if (Array.isArray(value) && !utils$1.isOperatorOfType("array", operator)) {
     return qb.where((subQB) => {
       value.forEach(
         (subValue) => subQB.orWhere((innerQB) => {
@@ -4343,9 +4429,6 @@ const createRepository = (uid, db) => {
     updateMany(params) {
       return db.entityManager.updateMany(uid, params);
     },
-    clone(id, params) {
-      return db.entityManager.clone(uid, id, params);
-    },
     delete(params) {
       return db.entityManager.delete(uid, params);
     },
@@ -4371,9 +4454,6 @@ const createRepository = (uid, db) => {
     deleteRelations(id) {
       return db.entityManager.deleteRelations(uid, id);
     },
-    cloneRelations(targetId, sourceId, params) {
-      return db.entityManager.cloneRelations(uid, targetId, sourceId, params);
-    },
     populate(entity, populate) {
       return db.entityManager.populate(uid, entity, populate);
     },
@@ -4449,6 +4529,19 @@ const deleteRelatedMorphOneRelationsAfterMorphToManyUpdate = async (rows, {
     await createQueryBuilder(joinTable.name, db).delete().where({ $or: orWhere }).transacting(trx).execute();
   }
 };
+const getDocumentSiblingIdsQuery = (con, tableName, id) => {
+  const models = Array.from(strapi.db.metadata.values());
+  const isContentType = models.find((model) => {
+    return model.tableName === tableName && model.attributes.documentId;
+  });
+  if (!isContentType) {
+    return [id];
+  }
+  return con.from(tableName).select("id").where(
+    "document_id",
+    con.from(tableName).select("document_id").where("id", id)
+  );
+};
 const deletePreviousOneToAnyRelations = async ({
   id,
   attribute,
@@ -4463,10 +4556,8 @@ const deletePreviousOneToAnyRelations = async ({
   }
   const { joinTable } = attribute;
   const { joinColumn, inverseJoinColumn } = joinTable;
-  await createQueryBuilder(joinTable.name, db).delete().where({
-    [inverseJoinColumn.name]: relIdsToadd,
-    [joinColumn.name]: { $ne: id }
-  }).where(joinTable.on || {}).transacting(trx).execute();
+  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 cleanOrderColumns({ attribute, db, inverseRelIds: relIdsToadd, transaction: trx });
 };
 const deletePreviousAnyToOneRelations = async ({
@@ -4478,14 +4569,15 @@ const deletePreviousAnyToOneRelations = async ({
 }) => {
   const { joinTable } = attribute;
   const { joinColumn, inverseJoinColumn } = joinTable;
+  const con = db.getConnection();
   if (!isAnyToOne(attribute)) {
     throw new Error("deletePreviousAnyToOneRelations can only be called for anyToOne relations");
   }
   if (isManyToAny(attribute)) {
-    const relsToDelete = await createQueryBuilder(joinTable.name, db).select(inverseJoinColumn.name).where({
-      [joinColumn.name]: id,
-      [inverseJoinColumn.name]: { $ne: relIdToadd }
-    }).where(joinTable.on || {}).transacting(trx).execute();
+    const relsToDelete = await con.select(inverseJoinColumn.name).from(joinTable.name).where(joinColumn.name, id).whereNotIn(
+      inverseJoinColumn.name,
+      getDocumentSiblingIdsQuery(con, inverseJoinColumn.referencedTable, relIdToadd)
+    ).where(joinTable.on || {}).transacting(trx);
     const relIdsToDelete = _.map(inverseJoinColumn.name, relsToDelete);
     await createQueryBuilder(joinTable.name, db).delete().where({
       [joinColumn.name]: id,
@@ -4493,10 +4585,10 @@ const deletePreviousAnyToOneRelations = async ({
     }).where(joinTable.on || {}).transacting(trx).execute();
     await cleanOrderColumns({ attribute, db, inverseRelIds: relIdsToDelete, transaction: trx });
   } else {
-    await createQueryBuilder(joinTable.name, db).delete().where({
-      [joinColumn.name]: id,
-      [inverseJoinColumn.name]: { $ne: relIdToadd }
-    }).where(joinTable.on || {}).transacting(trx).execute();
+    await con.delete().from(joinTable.name).where(joinColumn.name, id).whereNotIn(
+      inverseJoinColumn.name,
+      getDocumentSiblingIdsQuery(con, inverseJoinColumn.referencedTable, relIdToadd)
+    ).where(joinTable.on || {}).transacting(trx);
   }
 };
 const deleteRelations = async ({
@@ -4548,10 +4640,6 @@ const cleanOrderColumns = async ({
   if (!(hasOrderColumn(attribute) && id) && !(hasInverseOrderColumn(attribute) && !_.isEmpty(inverseRelIds))) {
     return;
   }
-  if (!strapi.db.dialect.supportsWindowFunctions()) {
-    await cleanOrderColumnsForOldDatabases({ id, attribute, db, inverseRelIds, transaction: trx });
-    return;
-  }
   const { joinTable } = attribute;
   const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
   const updateOrderColumn = async () => {
@@ -4613,94 +4701,6 @@ const cleanOrderColumns = async ({
   };
   return Promise.all([updateOrderColumn(), updateInverseOrderColumn()]);
 };
-const cleanOrderColumnsForOldDatabases = async ({
-  id,
-  attribute,
-  db,
-  inverseRelIds,
-  transaction: trx
-}) => {
-  const { joinTable } = attribute;
-  const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
-  const randomSuffix = `${(/* @__PURE__ */ new Date()).valueOf()}_${crypto.randomBytes(16).toString("hex")}`;
-  if (hasOrderColumn(attribute) && id) {
-    const orderVar = `order_${randomSuffix}`;
-    await db.connection.raw(`SET @${orderVar} = 0;`).transacting(trx);
-    await db.connection.raw(
-      `UPDATE :joinTableName: as a, (
-          SELECT id, (@${orderVar}:=@${orderVar} + 1) AS src_order
-          FROM :joinTableName:
-	        WHERE :joinColumnName: = :id
-	        ORDER BY :orderColumnName:
-        ) AS b
-        SET :orderColumnName: = b.src_order
-        WHERE a.id = b.id
-        AND a.:joinColumnName: = :id`,
-      {
-        joinTableName: joinTable.name,
-        orderColumnName,
-        joinColumnName: joinColumn.name,
-        id
-      }
-    ).transacting(trx);
-  }
-  if (hasInverseOrderColumn(attribute) && !_.isEmpty(inverseRelIds)) {
-    const orderVar = `order_${randomSuffix}`;
-    const columnVar = `col_${randomSuffix}`;
-    await db.connection.raw(`SET @${orderVar} = 0;`).transacting(trx);
-    await db.connection.raw(
-      `UPDATE ?? as a, (
-          SELECT
-          	id,
-            @${orderVar}:=CASE WHEN @${columnVar} = ?? THEN @${orderVar} + 1 ELSE 1 END AS inv_order,
-        	  @${columnVar}:=?? ??
-        	FROM ?? a
-        	WHERE ?? IN(${inverseRelIds.map(() => "?").join(", ")})
-        	ORDER BY ??, ??
-        ) AS b
-        SET ?? = b.inv_order
-        WHERE a.id = b.id
-        AND a.?? IN(${inverseRelIds.map(() => "?").join(", ")})`,
-      [
-        joinTable.name,
-        inverseJoinColumn.name,
-        inverseJoinColumn.name,
-        inverseJoinColumn.name,
-        joinTable.name,
-        inverseJoinColumn.name,
-        ...inverseRelIds,
-        inverseJoinColumn.name,
-        joinColumn.name,
-        inverseOrderColumnName,
-        inverseJoinColumn.name,
-        ...inverseRelIds
-      ]
-    ).transacting(trx);
-  }
-};
-const cleanInverseOrderColumn = async ({
-  id,
-  attribute,
-  trx
-}) => {
-  const con = strapi.db.connection;
-  const { joinTable } = attribute;
-  const { joinColumn, inverseJoinColumn, inverseOrderColumnName } = joinTable;
-  switch (strapi.db.dialect.client) {
-    case "mysql": {
-      const subQuery = con(joinTable.name).select(inverseJoinColumn.name).max(inverseOrderColumnName, { as: "max_inv_order" }).groupBy(inverseJoinColumn.name).as("t2");
-      await con(`${joinTable.name} as t1`).join(subQuery, `t1.${inverseJoinColumn.name}`, "=", `t2.${inverseJoinColumn.name}`).where(joinColumn.name, id).update({
-        [inverseOrderColumnName]: con.raw("t2.max_inv_order + 1")
-      }).transacting(trx);
-      break;
-    }
-    default: {
-      const selectMaxInverseOrder = con.raw(`max(${inverseOrderColumnName}) + 1`);
-      const subQuery = con(`${joinTable.name} as t2`).select(selectMaxInverseOrder).whereRaw(`t2.${inverseJoinColumn.name} = t1.${inverseJoinColumn.name}`);
-      await con(`${joinTable.name} as t1`).where(`t1.${joinColumn.name}`, id).update({ [inverseOrderColumnName]: subQuery }).transacting(trx);
-    }
-  }
-};
 const sortConnectArray = (connectArr, initialArr = [], strictSort = true) => {
   const sortedConnect = [];
   let needsSorting = false;
@@ -4841,55 +4841,6 @@ const relationsOrderer = (initArr, idColumn, orderColumn, strict) => {
     }
   };
 };
-const replaceRegularRelations = async ({
-  targetId,
-  sourceId,
-  attribute,
-  omitIds,
-  transaction: trx
-}) => {
-  const { joinTable } = attribute;
-  const { joinColumn, inverseJoinColumn } = joinTable;
-  await strapi.db.entityManager.createQueryBuilder(joinTable.name).update({ [joinColumn.name]: targetId }).where({ [joinColumn.name]: sourceId }).where({ $not: { [inverseJoinColumn.name]: omitIds } }).onConflict([joinColumn.name, inverseJoinColumn.name]).ignore().transacting(trx).execute();
-};
-const cloneRegularRelations = async ({
-  targetId,
-  sourceId,
-  attribute,
-  transaction: trx
-}) => {
-  const { joinTable } = attribute;
-  const { joinColumn, inverseJoinColumn, orderColumnName, inverseOrderColumnName } = joinTable;
-  const connection = strapi.db.getConnection();
-  const columns = [joinColumn.name, inverseJoinColumn.name];
-  if (orderColumnName) {
-    columns.push(orderColumnName);
-  }
-  if (inverseOrderColumnName) {
-    columns.push(inverseOrderColumnName);
-  }
-  if (joinTable.on) {
-    columns.push(...Object.keys(joinTable.on));
-  }
-  const selectStatement = connection.select(
-    // Override joinColumn with the new id
-    { [joinColumn.name]: targetId },
-    ...columns.slice(1)
-  ).where(joinColumn.name, sourceId).from(joinTable.name).toSQL();
-  await strapi.db.entityManager.createQueryBuilder(joinTable.name).insert(
-    strapi.db.connection.raw(
-      `(${columns.join(",")})  ${selectStatement.sql}`,
-      selectStatement.bindings
-    )
-  ).onConflict([joinColumn.name, inverseJoinColumn.name]).ignore().transacting(trx).execute();
-  if (inverseOrderColumnName) {
-    await cleanInverseOrderColumn({
-      id: targetId,
-      attribute,
-      trx
-    });
-  }
-};
 const isRecord = (value) => _.isObject(value) && !_.isNil(value);
 const toId = (value) => {
   if (isRecord(value) && "id" in value && isValidId(value.id)) {
@@ -5039,7 +4990,8 @@ const createEntityManager = (db) => {
       const result = await this.findOne(uid, {
         where: { id },
         select: params.select,
-        populate: params.populate
+        populate: params.populate,
+        filters: params.filters
       });
       await db.lifecycles.run("afterCreate", uid, { params, result }, states);
       return result;
@@ -5097,7 +5049,8 @@ const createEntityManager = (db) => {
       const result = await this.findOne(uid, {
         where: { id },
         select: params.select,
-        populate: params.populate
+        populate: params.populate,
+        filters: params.filters
       });
       await db.lifecycles.run("afterUpdate", uid, { params, result }, states);
       return result;
@@ -5116,50 +5069,6 @@ const createEntityManager = (db) => {
       await db.lifecycles.run("afterUpdateMany", uid, { params, result }, states);
       return result;
     },
-    async clone(uid, cloneId, params = {}) {
-      const states = await db.lifecycles.run("beforeCreate", uid, { params });
-      const metadata = db.metadata.get(uid);
-      const { data } = params;
-      if (!_.isNil(data) && !_.isPlainObject(data)) {
-        throw new Error("Create expects a data object");
-      }
-      const entity = await this.findOne(uid, { where: { id: cloneId } });
-      const dataToInsert = _.flow(
-        // Omit unwanted properties
-        _.omit(["id", "created_at", "updated_at"]),
-        // Merge with provided data, set attribute to null if data attribute is null
-        _.mergeWith(
-          data || {},
-          (original, override) => override === null ? override : original
-        ),
-        // Process data with metadata
-        (entity2) => processData(metadata, entity2, { withDefaults: true })
-      )(entity);
-      const res = await this.createQueryBuilder(uid).insert(dataToInsert).execute();
-      const id = isRecord(res[0]) ? res[0].id : res[0];
-      const trx = await strapi.db.transaction();
-      try {
-        const cloneAttrs = Object.entries(metadata.attributes).reduce((acc, [attrName, attr]) => {
-          if (isRelationalAttribute(attr) && "joinTable" in attr && attr.joinTable && !("component" in attr)) {
-            acc.push(attrName);
-          }
-          return acc;
-        }, []);
-        await this.cloneRelations(uid, id, cloneId, data, { cloneAttrs, transaction: trx.get() });
-        await trx.commit();
-      } catch (e) {
-        await trx.rollback();
-        await this.createQueryBuilder(uid).where({ id }).delete().execute();
-        throw e;
-      }
-      const result = await this.findOne(uid, {
-        where: { id },
-        select: params.select,
-        populate: params.populate
-      });
-      await db.lifecycles.run("afterCreate", uid, { params, result }, states);
-      return result;
-    },
     async delete(uid, params = {}) {
       const states = await db.lifecycles.run("beforeDelete", uid, { params });
       const { where, select, populate } = params;
@@ -5445,9 +5354,8 @@ const createEntityManager = (db) => {
             const isPartialUpdate = !_.has("set", cleanRelationData);
             let relIdsToaddOrMove;
             if (isPartialUpdate) {
-              if (isAnyToOne(attribute)) {
-                cleanRelationData.connect = cleanRelationData.connect?.slice(-1);
-              }
+              if (isAnyToOne(attribute))
+                ;
               relIdsToaddOrMove = toIds(cleanRelationData.connect);
               const relIdsToDelete = toIds(
                 _.differenceWith(
@@ -5661,58 +5569,6 @@ const createEntityManager = (db) => {
         }
       }
     },
-    // TODO: Clone polymorphic relations
-    /**
-     *
-     * @param {string} uid - uid of the entity to clone
-     * @param {number} targetId - id of the entity to clone into
-     * @param {number} sourceId - id of the entity to clone from
-     * @param {object} opt
-     * @param {object} opt.cloneAttrs - key value pair of attributes to clone
-     * @param {object} opt.transaction - transaction to use
-     * @example cloneRelations('user', 3, 1, { cloneAttrs: ["comments"]})
-     * @example cloneRelations('post', 5, 2, { cloneAttrs: ["comments", "likes"] })
-     */
-    async cloneRelations(uid, targetId, sourceId, data, options) {
-      const { attributes } = db.metadata.get(uid);
-      const { cloneAttrs = [], transaction } = options ?? {};
-      if (!attributes) {
-        return;
-      }
-      await utils.mapAsync(cloneAttrs, async (attrName) => {
-        const attribute = attributes[attrName];
-        if (attribute.type !== "relation") {
-          throw new DatabaseError(
-            `Attribute ${attrName} is not a relation attribute. Cloning relations is only supported for relation attributes.`
-          );
-        }
-        if (isPolymorphic(attribute)) {
-          return;
-        }
-        if ("joinColumn" in attribute) {
-          return;
-        }
-        if (!attribute.joinTable) {
-          return;
-        }
-        let omitIds = [];
-        if (_.has(attrName, data)) {
-          const cleanRelationData = toAssocs(data[attrName]);
-          if (cleanRelationData.set) {
-            return;
-          }
-          if (cleanRelationData.disconnect) {
-            omitIds = toIds(cleanRelationData.disconnect);
-          }
-        }
-        if (isOneToAny(attribute) && isBidirectional(attribute)) {
-          await replaceRegularRelations({ targetId, sourceId, attribute, omitIds, transaction });
-        } else {
-          await cloneRegularRelations({ targetId, sourceId, attribute, transaction });
-        }
-      });
-      await this.updateRelations(uid, targetId, data, { transaction });
-    },
     // TODO: add lifecycle events
     async populate(uid, entity, populate) {
       const entry = await this.findOne(uid, {
@@ -5774,7 +5630,7 @@ const createEntityManager = (db) => {
   };
 };
 const createStorage = (opts) => {
-  const { db, tableName = "strapi_migrations" } = opts;
+  const { db, tableName } = opts;
   const hasMigrationTable = () => db.getSchemaConnection().hasTable(tableName);
   const createMigrationTable = () => {
     return db.getSchemaConnection().createTable(tableName, (table) => {
@@ -5804,7 +5660,7 @@ const createStorage = (opts) => {
   };
 };
 const wrapTransaction = (db) => (fn) => () => {
-  return db.connection.transaction((trx) => Promise.resolve(fn(trx)));
+  return db.connection.transaction((trx) => Promise.resolve(fn(trx, db)));
 };
 const migrationResolver = ({ name, path: path2, context }) => {
   const { db } = context;
@@ -5828,31 +5684,82 @@ const migrationResolver = ({ name, path: path2, context }) => {
     down: wrapTransaction(db)(migration.down)
   };
 };
-const createUmzugProvider = (db) => {
-  const migrationDir = path__default$1.default.join(strapi.dirs.app.root, "database/migrations");
-  fse__default.default.ensureDirSync(migrationDir);
-  return new umzug.Umzug({
+const createUserMigrationProvider = (db) => {
+  const dir = db.config.settings.migrations.dir;
+  fse__default.default.ensureDirSync(dir);
+  const context = { db };
+  const umzugProvider = new umzug.Umzug({
     storage: createStorage({ db, tableName: "strapi_migrations" }),
     logger: console,
-    context: { db },
+    context,
     migrations: {
-      glob: ["*.{js,sql}", { cwd: migrationDir }],
+      glob: ["*.{js,sql}", { cwd: dir }],
       resolve: migrationResolver
     }
   });
+  return {
+    async shouldRun() {
+      const pendingMigrations = await umzugProvider.pending();
+      return pendingMigrations.length > 0 && db.config?.settings?.runMigrations === true;
+    },
+    async up() {
+      await umzugProvider.up();
+    },
+    async down() {
+      await umzugProvider.down();
+    }
+  };
+};
+const internalMigrations = [];
+const createInternalMigrationProvider = (db) => {
+  const context = { db };
+  const umzugProvider = new umzug.Umzug({
+    storage: createStorage({ db, tableName: "strapi_migrations_internal" }),
+    logger: console,
+    context,
+    migrations: internalMigrations.map((migration) => {
+      return {
+        name: migration.name,
+        up: wrapTransaction(context.db)(migration.up),
+        down: wrapTransaction(context.db)(migration.down)
+      };
+    })
+  });
+  return {
+    async shouldRun() {
+      const pendingMigrations = await umzugProvider.pending();
+      return pendingMigrations.length > 0;
+    },
+    async up() {
+      await umzugProvider.up();
+    },
+    async down() {
+      await umzugProvider.down();
+    }
+  };
 };
 const createMigrationsProvider = (db) => {
-  const migrations = createUmzugProvider(db);
+  const providers = [createUserMigrationProvider(db), createInternalMigrationProvider(db)];
   return {
     async shouldRun() {
-      const pending = await migrations.pending();
-      return pending.length > 0 && db.config?.settings?.runMigrations === true;
+      const shouldRunResponses = await Promise.all(
+        providers.map((provider) => provider.shouldRun())
+      );
+      return shouldRunResponses.some((shouldRun) => shouldRun);
     },
     async up() {
-      await migrations.up();
+      for (const provider of providers) {
+        if (await provider.shouldRun()) {
+          await provider.up();
+        }
+      }
     },
     async down() {
-      await migrations.down();
+      for (const provider of providers) {
+        if (await provider.shouldRun()) {
+          await provider.down();
+        }
+      }
     }
   };
 };
@@ -5965,82 +5872,41 @@ const createLifecyclesProvider = (db) => {
     }
   };
 };
-class LegacySqliteClient extends SqliteClient__default.default {
-  _driver() {
-    return require("sqlite3");
-  }
-}
 const clientMap = {
-  "better-sqlite3": "better-sqlite3",
-  "@vscode/sqlite3": "sqlite",
-  sqlite3: LegacySqliteClient
+  sqlite: "better-sqlite3",
+  mysql: "mysql2",
+  postgres: "pg"
 };
-const trySqlitePackage = (packageName) => {
-  try {
-    require.resolve(packageName);
-    return packageName;
-  } catch (error) {
-    if (error instanceof Error && "code" in error && error.code === "MODULE_NOT_FOUND") {
-      return false;
-    }
-    throw error;
-  }
-};
-const getSqlitePackageName = () => {
-  if (typeof process.env.SQLITE_PKG !== "undefined") {
-    return process.env.SQLITE_PKG;
-  }
-  const matchingPackage = trySqlitePackage("better-sqlite3") || trySqlitePackage("@vscode/sqlite3") || trySqlitePackage("sqlite3");
-  if (!matchingPackage) {
-    throw new Error("No sqlite package found");
-  }
-  return matchingPackage;
-};
-const createConnection = (config) => {
-  const knexConfig = { ...config };
-  if (knexConfig.client === "sqlite") {
-    const sqlitePackageName = getSqlitePackageName();
-    knexConfig.client = clientMap[sqlitePackageName];
+function isClientValid(config) {
+  return Object.keys(clientMap).includes(config.client);
+}
+const createConnection = (userConfig, strapiConfig) => {
+  if (!isClientValid(userConfig)) {
+    throw new Error(`Unsupported database client ${userConfig.client}`);
+  }
+  const knexConfig = { ...userConfig, client: clientMap[userConfig.client] };
+  if (strapiConfig?.pool?.afterCreate) {
+    knexConfig.pool = knexConfig.pool || {};
+    const userAfterCreate = knexConfig.pool?.afterCreate;
+    const strapiAfterCreate = strapiConfig.pool.afterCreate;
+    knexConfig.pool.afterCreate = (conn, done) => {
+      strapiAfterCreate(conn, (err, nativeConn) => {
+        if (err) {
+          return done(err, nativeConn);
+        }
+        if (userAfterCreate) {
+          return userAfterCreate(nativeConn, done);
+        }
+        return done(null, nativeConn);
+      });
+    };
   }
   return knex__default.default(knexConfig);
 };
-const transformAttribute = (attribute) => {
-  switch (attribute.type) {
-    case "media": {
-      return {
-        type: "relation",
-        relation: attribute.multiple === true ? "morphMany" : "morphOne",
-        target: "plugin::upload.file",
-        morphBy: "related"
-      };
-    }
-    default: {
-      return attribute;
-    }
-  }
-};
-const transformContentTypes = (contentTypes) => {
-  return contentTypes.map((contentType) => {
-    const model = {
-      ...contentType,
-      // reuse new model def
-      singularName: contentType.modelName,
-      tableName: contentType.collectionName,
-      attributes: {
-        ...Object.keys(contentType.attributes || {}).reduce((attrs, attrName) => {
-          return Object.assign(attrs, {
-            [attrName]: transformAttribute(contentType.attributes[attrName])
-          });
-        }, {})
-      }
-    };
-    return model;
-  });
-};
 const getLinksWithoutMappedBy = (db) => {
   const relationsToUpdate = {};
-  db.metadata.forEach((contentType) => {
-    const attributes = contentType.attributes;
+  db.metadata.forEach((modelMetadata) => {
+    const attributes = modelMetadata.attributes;
     Object.values(attributes).forEach((attribute) => {
       if (attribute.type !== "relation") {
         return;
@@ -6068,19 +5934,19 @@ const isLinkTableEmpty = async (db, linkTableName) => {
 const validateBidirectionalRelations = async (db) => {
   const invalidLinks = getLinksWithoutMappedBy(db);
   for (const { relation, invRelation } of invalidLinks) {
-    const contentType = db.metadata.get(invRelation.target);
-    const invContentType = db.metadata.get(relation.target);
-    const joinTableName = getJoinTableName(contentType.tableName, invRelation.inversedBy);
-    const inverseJoinTableName = getJoinTableName(invContentType.tableName, relation.inversedBy);
+    const modelMetadata = db.metadata.get(invRelation.target);
+    const invModelMetadata = db.metadata.get(relation.target);
+    const joinTableName = getJoinTableName(modelMetadata.tableName, invRelation.inversedBy);
+    const inverseJoinTableName = getJoinTableName(invModelMetadata.tableName, relation.inversedBy);
     const joinTableEmpty = await isLinkTableEmpty(db, joinTableName);
     const inverseJoinTableEmpty = await isLinkTableEmpty(db, inverseJoinTableName);
     if (joinTableEmpty) {
       process.emitWarning(
-        `Error on attribute "${invRelation.inversedBy}" in model "${contentType.singularName}" (${contentType.uid}). Please modify your ${contentType.singularName} schema by renaming the key "inversedBy" to "mappedBy". Ex: { "inversedBy": "${relation.inversedBy}" } -> { "mappedBy": "${relation.inversedBy}" }`
+        `Error on attribute "${invRelation.inversedBy}" in model "${modelMetadata.singularName}" (${modelMetadata.uid}). Please modify your ${modelMetadata.singularName} schema by renaming the key "inversedBy" to "mappedBy". Ex: { "inversedBy": "${relation.inversedBy}" } -> { "mappedBy": "${relation.inversedBy}" }`
       );
     } else if (inverseJoinTableEmpty) {
       process.emitWarning(
-        `Error on attribute "${relation.inversedBy}" in model "${invContentType.singularName}" (${invContentType.uid}). Please modify your ${invContentType.singularName} schema by renaming the key "inversedBy" to "mappedBy". Ex: { "inversedBy": "${invRelation.inversedBy}" } -> { "mappedBy": "${invRelation.inversedBy}" }`
+        `Error on attribute "${relation.inversedBy}" in model "${invModelMetadata.singularName}" (${invModelMetadata.uid}). Please modify your ${invModelMetadata.singularName} schema by renaming the key "inversedBy" to "mappedBy". Ex: { "inversedBy": "${invRelation.inversedBy}" } -> { "mappedBy": "${invRelation.inversedBy}" }`
       );
     } else
       ;
@@ -6092,6 +5958,11 @@ const validateRelations = async (db) => {
 async function validateDatabase(db) {
   await validateRelations(db);
 }
+const afterCreate = (db) => (nativeConnection, done) => {
+  db.dialect.initialize(nativeConnection).then(() => {
+    return done(null, nativeConnection);
+  });
+};
 class Database {
   connection;
   dialect;
@@ -6101,14 +5972,7 @@ class Database {
   migrations;
   lifecycles;
   entityManager;
-  static transformContentTypes = transformContentTypes;
-  static async init(config) {
-    const db = new Database(config);
-    await validateDatabase(db);
-    return db;
-  }
   constructor(config) {
-    this.metadata = createMetadata(config.models);
     this.config = {
       ...config,
       settings: {
@@ -6119,13 +5983,20 @@ class Database {
     };
     this.dialect = getDialect(this);
     this.dialect.configure();
-    this.connection = createConnection(this.config.connection);
-    this.dialect.initialize();
+    this.metadata = createMetadata();
+    this.connection = createConnection(this.config.connection, {
+      pool: { afterCreate: afterCreate(this) }
+    });
     this.schema = createSchemaProvider(this);
     this.migrations = createMigrationsProvider(this);
     this.lifecycles = createLifecyclesProvider(this);
     this.entityManager = createEntityManager(this);
   }
+  async init({ models }) {
+    this.metadata.loadModels(models);
+    await validateDatabase(this);
+    return this;
+  }
   query(uid) {
     if (!this.metadata.has(uid)) {
       throw new Error(`Model ${uid} not found`);
@@ -6189,7 +6060,9 @@ class Database {
     await this.connection.destroy();
   }
 }
+const utils = { identifiers };
 exports.Database = Database;
 exports.errors = index;
 exports.isKnexQuery = isKnexQuery;
+exports.utils = utils;
 //# sourceMappingURL=index.js.map