@strapi/database 5.0.0-beta.1 → 5.0.0-beta.3

package/dist/index.js

@@ -7,13 +7,14 @@ const _ = require("lodash/fp");
 const crypto = require("crypto");
 const crypto$1 = require("node:crypto");
 const dateFns = require("date-fns");
-const utils$1 = require("@strapi/utils");
+const utils = 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 umzug = require("umzug");
+const cuid2 = require("@paralleldrive/cuid2");
 const assert = require("assert");
 const knex = require("knex");
 const _interopDefault = (e) => e && e.__esModule ? e : { default: e };
@@ -1007,7 +1008,7 @@ const getDialect = (db) => {
   const dialect = new constructor(db, dialectName);
   return dialect;
 };
-const debug$1 = createDebug__default.default("strapi::database");
+const debug$2 = createDebug__default.default("strapi::database");
 const createSchemaBuilder = (db) => {
   const helpers2 = createHelpers(db);
   return {
@@ -1033,12 +1034,12 @@ const createSchemaBuilder = (db) => {
      */
     async createTables(tables, trx) {
       for (const table of tables) {
-        debug$1(`Creating table: ${table.name}`);
+        debug$2(`Creating table: ${table.name}`);
         const schemaBuilder = this.getSchemaBuilder(trx);
         await helpers2.createTable(schemaBuilder, table);
       }
       for (const table of tables) {
-        debug$1(`Creating table foreign keys: ${table.name}`);
+        debug$2(`Creating table foreign keys: ${table.name}`);
         const schemaBuilder = this.getSchemaBuilder(trx);
         await helpers2.createTableForeignKeys(schemaBuilder, table);
       }
@@ -1069,18 +1070,18 @@ const createSchemaBuilder = (db) => {
         await this.createTables(schemaDiff.tables.added, trx);
         if (forceMigration) {
           for (const table of schemaDiff.tables.removed) {
-            debug$1(`Removing table foreign keys: ${table.name}`);
+            debug$2(`Removing table foreign keys: ${table.name}`);
             const schemaBuilder = this.getSchemaBuilder(trx);
             await helpers2.dropTableForeignKeys(schemaBuilder, table);
           }
           for (const table of schemaDiff.tables.removed) {
-            debug$1(`Removing table: ${table.name}`);
+            debug$2(`Removing table: ${table.name}`);
             const schemaBuilder = this.getSchemaBuilder(trx);
             await helpers2.dropTable(schemaBuilder, table);
           }
         }
         for (const table of schemaDiff.tables.updated) {
-          debug$1(`Updating table: ${table.name}`);
+          debug$2(`Updating table: ${table.name}`);
           const schemaBuilder = this.getSchemaBuilder(trx);
           await helpers2.alterTable(schemaBuilder, table);
         }
@@ -1176,27 +1177,27 @@ const createHelpers = (db) => {
   const alterTable = async (schemaBuilder, table) => {
     await schemaBuilder.alterTable(table.name, (tableBuilder) => {
       for (const removedIndex of table.indexes.removed) {
-        debug$1(`Dropping index ${removedIndex.name}`);
+        debug$2(`Dropping index ${removedIndex.name} on ${table.name}`);
         dropIndex(tableBuilder, removedIndex);
       }
       for (const updateddIndex of table.indexes.updated) {
-        debug$1(`Dropping updated index ${updateddIndex.name}`);
+        debug$2(`Dropping updated index ${updateddIndex.name} on ${table.name}`);
         dropIndex(tableBuilder, updateddIndex.object);
       }
       for (const removedForeignKey of table.foreignKeys.removed) {
-        debug$1(`Dropping foreign key ${removedForeignKey.name}`);
+        debug$2(`Dropping foreign key ${removedForeignKey.name} on ${table.name}`);
         dropForeignKey(tableBuilder, removedForeignKey);
       }
       for (const updatedForeignKey of table.foreignKeys.updated) {
-        debug$1(`Dropping updated foreign key ${updatedForeignKey.name}`);
+        debug$2(`Dropping updated foreign key ${updatedForeignKey.name} on ${table.name}`);
         dropForeignKey(tableBuilder, updatedForeignKey.object);
       }
       for (const removedColumn of table.columns.removed) {
-        debug$1(`Dropping column ${removedColumn.name}`);
+        debug$2(`Dropping column ${removedColumn.name} on ${table.name}`);
         dropColumn(tableBuilder, removedColumn);
       }
       for (const updatedColumn of table.columns.updated) {
-        debug$1(`Updating column ${updatedColumn.name}`);
+        debug$2(`Updating column ${updatedColumn.name} on ${table.name}`);
         const { object } = updatedColumn;
         if (object.type === "increments") {
           createColumn2(tableBuilder, { ...object, type: "integer" }).alter();
@@ -1205,15 +1206,15 @@ const createHelpers = (db) => {
         }
       }
       for (const updatedForeignKey of table.foreignKeys.updated) {
-        debug$1(`Recreating updated foreign key ${updatedForeignKey.name}`);
+        debug$2(`Recreating updated foreign key ${updatedForeignKey.name} on ${table.name}`);
         createForeignKey(tableBuilder, updatedForeignKey.object);
       }
       for (const updatedIndex of table.indexes.updated) {
-        debug$1(`Recreating updated index ${updatedIndex.name}`);
+        debug$2(`Recreating updated index ${updatedIndex.name} on ${table.name}`);
         createIndex(tableBuilder, updatedIndex.object);
       }
       for (const addedColumn of table.columns.added) {
-        debug$1(`Creating column ${addedColumn.name}`);
+        debug$2(`Creating column ${addedColumn.name} on ${table.name}`);
         if (addedColumn.type === "increments" && !db.dialect.canAddIncrements()) {
           tableBuilder.integer(addedColumn.name).unsigned();
           tableBuilder.primary([addedColumn.name]);
@@ -1222,11 +1223,11 @@ const createHelpers = (db) => {
         }
       }
       for (const addedForeignKey of table.foreignKeys.added) {
-        debug$1(`Creating foreign keys ${addedForeignKey.name}`);
+        debug$2(`Creating foreign keys ${addedForeignKey.name} on ${table.name}`);
         createForeignKey(tableBuilder, addedForeignKey);
       }
       for (const addedIndex of table.indexes.added) {
-        debug$1(`Creating index ${addedIndex.name}`);
+        debug$2(`Creating index ${addedIndex.name} on ${table.name}`);
         createIndex(tableBuilder, addedIndex);
       }
     });
@@ -1645,11 +1646,6 @@ const isScalar = (type) => SCALAR_TYPES.includes(type);
 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}`);
@@ -1657,201 +1653,334 @@ function createHash(data, 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}`
-    );
+const IDENTIFIER_MAX_LENGTH = 55;
+class Identifiers {
+  ID_COLUMN = "id";
+  ORDER_COLUMN = "order";
+  FIELD_COLUMN = "field";
+  HASH_LENGTH = 5;
+  HASH_SEPARATOR = "";
+  // no separator is needed, we will just attach hash directly to shortened name
+  IDENTIFIER_SEPARATOR = "_";
+  MIN_TOKEN_LENGTH = 3;
+  // the min characters required at the beginning of a name part
+  // Fixed compression map for suffixes and prefixes
+  #replacementMap = {
+    links: "lnk",
+    order_inv_fk: "oifk",
+    order: "ord",
+    morphs: "mph",
+    index: "idx",
+    inv_fk: "ifk",
+    order_fk: "ofk",
+    id_column_index: "idix",
+    order_index: "oidx",
+    unique: "uq",
+    primary: "pk"
+  };
+  #options;
+  constructor(options) {
+    this.#options = options;
   }
-  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)");
+  get replacementMap() {
+    return this.#replacementMap;
   }
-  const fullLengthName = nameTokens.map((token) => _.snakeCase(token.name)).join(IDENTIFIER_SEPARATOR);
-  if (fullLengthName.length <= maxLength || maxLength === 0) {
-    return fullLengthName;
+  get options() {
+    return this.#options;
   }
-  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);
+  mapshortNames = (name) => {
+    if (name in this.replacementMap) {
+      return this.replacementMap[name];
     }
-  });
-  function filterAndIncreaseLength(token) {
-    if (token.allocatedLength < token.name.length && surplus > 0) {
-      token.allocatedLength += 1;
-      surplus -= 1;
-      return token.allocatedLength < token.name.length;
+    return void 0;
+  };
+  // Generic name handler that must be used by all helper functions
+  /**
+   * TODO: we should be requiring snake_case inputs for all names here, but we
+   * aren't and it will require some refactoring to make it work. Currently if
+   * we get names 'myModel' and 'my_model' they would be converted to the same
+   * final string my_model which generally works but is not entirely safe
+   * */
+  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,
+        shortName: this.mapshortNames(options.suffix)
+      });
     }
-    return false;
-  }
-  let previousSurplus = surplus + 1;
-  while (surplus > 0 && deficits.length > 0) {
-    deficits = deficits.filter((token) => filterAndIncreaseLength(token));
-    if (surplus === previousSurplus) {
-      break;
+    if (options?.prefix) {
+      tokens.unshift({
+        name: options.prefix,
+        compressible: false,
+        shortName: this.mapshortNames(options.prefix)
+      });
     }
-    previousSurplus = surplus;
-  }
-  const shortenedName = nameTokens.map((token) => {
-    if (token.compressible && "allocatedLength" in token && token.allocatedLength !== void 0) {
-      return getShortenedName(token.name, token.allocatedLength);
+    return this.getNameFromTokens(tokens);
+  };
+  /**
+   * TABLES
+   */
+  getTableName = (name, options) => {
+    return this.getName(name, options);
+  };
+  getJoinTableName = (collectionName, attributeName, options) => {
+    return this.getName([collectionName, attributeName], {
+      suffix: "links",
+      ...options
+    });
+  };
+  getMorphTableName = (collectionName, attributeName, options) => {
+    return this.getName([_.snakeCase(collectionName), _.snakeCase(attributeName)], {
+      suffix: "morphs",
+      ...options
+    });
+  };
+  /**
+   * COLUMNS
+   */
+  getColumnName = (attributeName, options) => {
+    return this.getName(attributeName, options);
+  };
+  getJoinColumnAttributeIdName = (attributeName, options) => {
+    return this.getName(attributeName, { suffix: "id", ...options });
+  };
+  getInverseJoinColumnAttributeIdName = (attributeName, options) => {
+    return this.getName(_.snakeCase(attributeName), { suffix: "id", prefix: "inv", ...options });
+  };
+  getOrderColumnName = (singularName, options) => {
+    return this.getName(singularName, { suffix: "order", ...options });
+  };
+  getInverseOrderColumnName = (singularName, options) => {
+    return this.getName(singularName, {
+      suffix: "order",
+      prefix: "inv",
+      ...options
+    });
+  };
+  /**
+   * Morph Join Tables
+   */
+  getMorphColumnJoinTableIdName = (singularName, options) => {
+    return this.getName(_.snakeCase(singularName), { suffix: "id", ...options });
+  };
+  getMorphColumnAttributeIdName = (attributeName, options) => {
+    return this.getName(_.snakeCase(attributeName), { suffix: "id", ...options });
+  };
+  getMorphColumnTypeName = (attributeName, options) => {
+    return this.getName(_.snakeCase(attributeName), { suffix: "type", ...options });
+  };
+  /**
+   * INDEXES
+   * Note that these methods are generally used to reference full table names + attribute(s), which
+   * may already be shortened strings rather than individual parts.
+   * That is fine and expected to compress the previously incompressible parts of those strings,
+   * because in these cases the relevant information is the table name and we can't really do
+   * any better; shortening the individual parts again might make it even more confusing.
+   *
+   * So for example, the fk for the table `mytable_myattr4567d_localizations` will become
+   * mytable_myattr4567d_loc63bf2_fk
+   */
+  // base index types
+  getIndexName = (names, options) => {
+    return this.getName(names, { suffix: "index", ...options });
+  };
+  getFkIndexName = (names, options) => {
+    return this.getName(names, { suffix: "fk", ...options });
+  };
+  getUniqueIndexName = (names, options) => {
+    return this.getName(names, { suffix: "unique", ...options });
+  };
+  getPrimaryIndexName = (names, options) => {
+    return this.getName(names, { suffix: "primary", ...options });
+  };
+  // custom index types
+  getInverseFkIndexName = (names, options) => {
+    return this.getName(names, { suffix: "inv_fk", ...options });
+  };
+  getOrderFkIndexName = (names, options) => {
+    return this.getName(names, { suffix: "order_fk", ...options });
+  };
+  getOrderInverseFkIndexName = (names, options) => {
+    return this.getName(names, { suffix: "order_inv_fk", ...options });
+  };
+  getIdColumnIndexName = (names, options) => {
+    return this.getName(names, { suffix: "id_column_index", ...options });
+  };
+  getOrderIndexName = (names, options) => {
+    return this.getName(names, { suffix: "order_index", ...options });
+  };
+  /**
+   * Generates a string with a max length, appending a hash at the end if necessary to keep it unique
+   *
+   * @example
+   * // if we have strings such as "longstring1" and "longstring2" with a max length of 9,
+   * // we don't want to end up with "longstrin" and "longstrin"
+   * // we want something such as    "longs0b23" and "longs953f"
+   * const token1 = generateToken("longstring1", 9); // "longs0b23"
+   * const token2 = generateToken("longstring2", 9); // "longs953f"
+   *
+   * @param name - The base name
+   * @param len - The desired length of the token.
+   * @returns The generated token with hash.
+   * @throws Error if the length is not a positive integer, or if the length is too short for the token.
+   * @internal
+   */
+  getShortenedName = (name, len) => {
+    if (!_.isInteger(len) || len <= 0) {
+      throw new Error(`tokenWithHash length must be a positive integer, received ${len}`);
     }
-    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}`
+    if (name.length <= len) {
+      return name;
+    }
+    if (len < this.MIN_TOKEN_LENGTH + this.HASH_LENGTH) {
+      throw new Error(
+        `length for part of identifier too short, minimum is hash length (${this.HASH_LENGTH}) plus min token length (${this.MIN_TOKEN_LENGTH}), received ${len} for token ${name}`
+      );
+    }
+    const availableLength = len - this.HASH_LENGTH - this.HASH_SEPARATOR.length;
+    if (availableLength < this.MIN_TOKEN_LENGTH) {
+      throw new Error(
+        `length for part of identifier minimum is less than min token length (${this.MIN_TOKEN_LENGTH}), received ${len} for token ${name}`
+      );
+    }
+    return `${name.substring(0, availableLength)}${this.HASH_SEPARATOR}${createHash(
+      name,
+      this.HASH_LENGTH
+    )}`;
+  };
+  /**
+   * Constructs a name from an array of name tokens within a specified maximum length. It ensures the final name does not exceed
+   * this limit by selectively compressing tokens marked as compressible. If the name exceeds the maximum length and cannot be
+   * compressed sufficiently, an error is thrown. This function supports dynamic adjustment of token lengths to fit within the
+   * maxLength constraint (that is, it will always make use of all available space), while also ensuring the preservation of
+   * incompressible tokens.
+   * @internal
+   */
+  getNameFromTokens = (nameTokens) => {
+    const { maxLength } = this.options;
+    if (!_.isInteger(maxLength) || maxLength < 0) {
+      throw new Error("maxLength must be a positive integer or 0 (for unlimited length)");
+    }
+    const unshortenedName = nameTokens.map((token) => {
+      return token.name;
+    }).join(this.IDENTIFIER_SEPARATOR);
+    if (maxLength === 0) {
+      this.setUnshortenedName(unshortenedName, unshortenedName);
+      return unshortenedName;
+    }
+    const fullLengthName = nameTokens.map((token) => {
+      if (token.compressible) {
+        return token.name;
+      }
+      return token.shortName ?? token.name;
+    }).join(this.IDENTIFIER_SEPARATOR);
+    if (fullLengthName.length <= maxLength) {
+      this.setUnshortenedName(fullLengthName, unshortenedName);
+      return fullLengthName;
+    }
+    const [compressible, incompressible] = _.partition(
+      (token) => token.compressible,
+      nameTokens
     );
-  }
-  return shortenedName;
+    const totalIncompressibleLength = _.sumBy(
+      (token) => token.compressible === false && token.shortName !== void 0 ? token.shortName.length : token.name.length
+    )(incompressible);
+    const totalSeparatorsLength = nameTokens.length * this.IDENTIFIER_SEPARATOR.length - 1;
+    const available = maxLength - totalIncompressibleLength - totalSeparatorsLength;
+    const availablePerToken = Math.floor(available / compressible.length);
+    if (totalIncompressibleLength + totalSeparatorsLength > maxLength || availablePerToken < this.MIN_TOKEN_LENGTH) {
+      throw new Error("Maximum length is too small to accommodate all tokens");
+    }
+    let surplus = available % compressible.length;
+    const minHashedLength = this.HASH_LENGTH + this.HASH_SEPARATOR.length + this.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;
+        }
+        const tokenName = token.shortName ?? token.name;
+        return total + tokenName.length;
+      },
+      nameTokens.length * this.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 this.getShortenedName(token.name, token.allocatedLength);
+      }
+      if (token.compressible === false && token.shortName) {
+        return token.shortName;
+      }
+      return token.name;
+    }).join(this.IDENTIFIER_SEPARATOR);
+    if (shortenedName.length > maxLength) {
+      throw new Error(
+        `name shortening failed to generate a name of the correct maxLength; name ${shortenedName}`
+      );
+    }
+    this.setUnshortenedName(shortenedName, unshortenedName);
+    return shortenedName;
+  };
+  // We need to be able to find the full-length name for any shortened name, primarily for migration purposes
+  // Therefore we store every name that passes through so we can retrieve the original later
+  nameMap = /* @__PURE__ */ new Map();
+  getUnshortenedName = (shortName) => {
+    return this.nameMap.get(this.serializeKey(shortName)) ?? shortName;
+  };
+  setUnshortenedName = (shortName, fullName) => {
+    if (this.nameMap.get(this.serializeKey(shortName)) && shortName === fullName) {
+      return;
+    }
+    this.nameMap.set(this.serializeKey(shortName), fullName);
+  };
+  serializeKey = (shortName) => {
+    return `${shortName}.${this.options.maxLength}`;
+  };
 }
-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 identifiers = new Identifiers({ maxLength: IDENTIFIER_MAX_LENGTH });
 const createColumn = (name, attribute) => {
   const { type, args = [], ...opts } = getColumnType(attribute);
   return {
-    name,
+    name: identifiers.getName(name),
     type,
     args,
     defaultTo: null,
@@ -1873,8 +2002,8 @@ 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);
+        const idColumnName = identifiers.getName(idColumn.name);
+        const typeColumnName = identifiers.getName(typeColumn.name);
         table.columns.push(
           createColumn(idColumnName, {
             type: "integer",
@@ -1891,7 +2020,7 @@ const createTable = (meta) => {
           referencedTable,
           columnType = "integer"
         } = attribute.joinColumn;
-        const columnName = getName(columnNameFull);
+        const columnName = identifiers.getName(columnNameFull);
         const column = createColumn(columnName, {
           // TODO: find the column type automatically, or allow passing all the column params
           type: columnType,
@@ -1900,7 +2029,7 @@ const createTable = (meta) => {
           }
         });
         table.columns.push(column);
-        const fkName = getFkIndexName([table.name, columnName]);
+        const fkName = identifiers.getFkIndexName([table.name, columnName]);
         table.foreignKeys.push({
           name: fkName,
           columns: [column.name],
@@ -1915,19 +2044,19 @@ const createTable = (meta) => {
         });
       }
     } else if (isScalarAttribute(attribute)) {
-      const columnName = getName(attribute.columnName || key);
+      const columnName = identifiers.getName(attribute.columnName || key);
       const column = createColumn(columnName, attribute);
       if (column.unique) {
         table.indexes.push({
           type: "unique",
-          name: getUniqueIndexName([table.name, column.name]),
+          name: identifiers.getUniqueIndexName([table.name, column.name]),
           columns: [columnName]
         });
       }
       if (column.primary) {
         table.indexes.push({
           type: "primary",
-          name: getPrimaryIndexName([table.name, column.name]),
+          name: identifiers.getPrimaryIndexName([table.name, column.name]),
           columns: [columnName]
         });
       }
@@ -2027,12 +2156,13 @@ const metadataToSchema = (metadata) => {
   });
   return schema;
 };
-const debug = createDebug__default.default("strapi::database");
+const debug$1 = createDebug__default.default("strapi::database");
 const createSchemaProvider = (db) => {
   const state = {};
   return {
     get schema() {
       if (!state.schema) {
+        debug$1("Converting metadata to database schema");
         state.schema = metadataToSchema(db.metadata);
       }
       return state.schema;
@@ -2044,7 +2174,7 @@ const createSchemaProvider = (db) => {
      * Drops the database schema
      */
     async drop() {
-      debug("Dropping database schema");
+      debug$1("Dropping database schema");
       const DBSchema = await db.dialect.schemaInspector.getSchema();
       await this.builder.dropSchema(DBSchema);
     },
@@ -2052,19 +2182,19 @@ const createSchemaProvider = (db) => {
      * Creates the database schema
      */
     async create() {
-      debug("Created database schema");
+      debug$1("Created database schema");
       await this.builder.createSchema(this.schema);
     },
     /**
      * Resets the database schema
      */
     async reset() {
-      debug("Resetting database schema");
+      debug$1("Resetting database schema");
       await this.drop();
       await this.create();
     },
     async syncSchema() {
-      debug("Synchronizing database schema");
+      debug$1("Synchronizing database schema");
       const DBSchema = await db.dialect.schemaInspector.getSchema();
       const { status, diff } = await this.schemaDiff.diff(DBSchema, this.schema);
       if (status === "CHANGED") {
@@ -2077,28 +2207,28 @@ const createSchemaProvider = (db) => {
     // TODO: Allow keeping extra indexes / extra tables / extra columns (globally or on a per table basis)
     async sync() {
       if (await db.migrations.shouldRun()) {
-        debug("Found migrations to run");
+        debug$1("Found migrations to run");
         await db.migrations.up();
         return this.syncSchema();
       }
       const oldSchema = await this.schemaStorage.read();
       if (!oldSchema) {
-        debug("Schema not persisted yet");
+        debug$1("Schema not persisted yet");
         return this.syncSchema();
       }
       const { hash: oldHash } = oldSchema;
       const hash = await this.schemaStorage.hashSchema(this.schema);
       if (oldHash !== hash) {
-        debug("Schema changed");
+        debug$1("Schema changed");
         return this.syncSchema();
       }
-      debug("Schema unchanged");
+      debug$1("Schema unchanged");
     }
   };
 };
-const ID = ID_COLUMN;
-const ORDER = ORDER_COLUMN;
-const FIELD = FIELD_COLUMN;
+const ID = identifiers.ID_COLUMN;
+const ORDER = identifiers.ORDER_COLUMN;
+const FIELD = identifiers.FIELD_COLUMN;
 const hasInversedBy = (attr) => "inversedBy" in attr;
 const hasMappedBy = (attr) => "mappedBy" in attr;
 const isOneToAny = (attribute) => ["oneToOne", "oneToMany"].includes(attribute.relation);
@@ -2119,7 +2249,7 @@ const createOneToOne = (attributeName, attribute, meta, metadata) => {
         meta
       });
     } else {
-      createJoinColum(metadata, {
+      createJoinColumn(metadata, {
         attribute,
         attributeName,
         meta
@@ -2149,7 +2279,7 @@ const createManyToOne = (attributeName, attribute, meta, metadata) => {
       meta
     });
   } else {
-    createJoinColum(metadata, {
+    createJoinColumn(metadata, {
       attribute,
       attributeName,
       meta
@@ -2166,15 +2296,11 @@ const createManyToMany = (attributeName, attribute, meta, metadata) => {
   }
 };
 const createMorphToOne = (attributeName, attribute) => {
-  const idColumnName = getJoinColumnAttributeIdName("target");
-  const typeColumnName = getMorphColumnTypeName("target");
-  if ("morphColumn" in attribute && attribute.morphColumn) {
-    return;
-  }
+  const idColumnName = identifiers.getJoinColumnAttributeIdName("target");
+  const typeColumnName = identifiers.getMorphColumnTypeName("target");
   Object.assign(attribute, {
     owner: true,
-    morphColumn: {
-      // TODO: add referenced column
+    morphColumn: attribute.morphColumn ?? {
       typeColumn: {
         name: typeColumnName
       },
@@ -2189,11 +2315,11 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
   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);
+  const joinTableName = identifiers.getMorphTableName(meta.tableName, attributeName);
+  const joinColumnName = identifiers.getMorphColumnJoinTableIdName(_.snakeCase(meta.singularName));
+  const idColumnName = identifiers.getMorphColumnAttributeIdName(attributeName);
+  const typeColumnName = identifiers.getMorphColumnTypeName(attributeName);
+  const fkIndexName = identifiers.getFkIndexName(joinTableName);
   metadata.add({
     singularName: joinTableName,
     uid: joinTableName,
@@ -2206,7 +2332,9 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
         type: "integer",
         column: {
           unsigned: true
-        }
+        },
+        // This must be set explicitly so that it is used instead of shortening the attribute name, which is already shortened
+        columnName: joinColumnName
       },
       [idColumnName]: {
         type: "integer",
@@ -2233,11 +2361,11 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
         columns: [joinColumnName]
       },
       {
-        name: `${joinTableName}_order_index`,
+        name: identifiers.getOrderIndexName(joinTableName),
         columns: [ORDER]
       },
       {
-        name: `${joinTableName}_id_column_index`,
+        name: identifiers.getIdColumnIndexName(joinTableName),
         columns: [idColumnName]
       }
     ],
@@ -2246,7 +2374,7 @@ const createMorphToMany = (attributeName, attribute, meta, metadata) => {
         name: fkIndexName,
         columns: [joinColumnName],
         referencedColumns: [ID],
-        referencedTable: getTableName(meta.tableName),
+        referencedTable: meta.tableName,
         onDelete: "CASCADE"
       }
     ],
@@ -2293,12 +2421,12 @@ const createMorphMany = (attributeName, attribute, meta, metadata) => {
     throw new Error(`Morph target attribute not found. Looking for ${attribute.morphBy}`);
   }
 };
-const createJoinColum = (metadata, { attribute, attributeName }) => {
+const createJoinColumn = (metadata, { attribute, attributeName }) => {
   const targetMeta = metadata.get(attribute.target);
   if (!targetMeta) {
     throw new Error(`Unknown target ${attribute.target}`);
   }
-  const joinColumnName = ___default.default.snakeCase(`${attributeName}_id`);
+  const joinColumnName = identifiers.getJoinColumnAttributeIdName(_.snakeCase(attributeName));
   const joinColumn = {
     name: joinColumnName,
     referencedColumn: ID,
@@ -2313,7 +2441,7 @@ const createJoinColum = (metadata, { attribute, attributeName }) => {
     Object.assign(inverseAttribute, {
       joinColumn: {
         name: joinColumn.referencedColumn,
-        referencedColumn: joinColumn.name
+        referencedColumn: joinColumnName
       }
     });
   }
@@ -2326,21 +2454,26 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
   if ("joinTable" in attribute && attribute.joinTable) {
     return;
   }
-  const joinTableName = getJoinTableName(meta.tableName, attributeName);
-  const joinColumnName = getJoinColumnAttributeIdName(meta.singularName);
-  let inverseJoinColumnName = getJoinColumnAttributeIdName(targetMeta.singularName);
+  const joinTableName = identifiers.getJoinTableName(
+    _.snakeCase(meta.tableName),
+    _.snakeCase(attributeName)
+  );
+  const joinColumnName = identifiers.getJoinColumnAttributeIdName(_.snakeCase(meta.singularName));
+  let inverseJoinColumnName = identifiers.getJoinColumnAttributeIdName(
+    _.snakeCase(targetMeta.singularName)
+  );
   if (joinColumnName === inverseJoinColumnName) {
-    inverseJoinColumnName = getInverseJoinColumnAttributeIdName(
-      targetMeta.singularName
+    inverseJoinColumnName = identifiers.getInverseJoinColumnAttributeIdName(
+      _.snakeCase(targetMeta.singularName)
     );
   }
-  const orderColumnName = getOrderColumnName(targetMeta.singularName);
-  let inverseOrderColumnName = getOrderColumnName(meta.singularName);
+  const orderColumnName = identifiers.getOrderColumnName(_.snakeCase(targetMeta.singularName));
+  let inverseOrderColumnName = identifiers.getOrderColumnName(_.snakeCase(meta.singularName));
   if (attribute.relation === "manyToMany" && orderColumnName === inverseOrderColumnName) {
-    inverseOrderColumnName = getInverseOrderColumnName(meta.singularName);
+    inverseOrderColumnName = identifiers.getInverseOrderColumnName(_.snakeCase(meta.singularName));
   }
-  const fkIndexName = getFkIndexName(joinTableName);
-  const invFkIndexName = getInverseFkIndexName(joinTableName);
+  const fkIndexName = identifiers.getFkIndexName(joinTableName);
+  const invFkIndexName = identifiers.getInverseFkIndexName(joinTableName);
   const metadataSchema = {
     singularName: joinTableName,
     uid: joinTableName,
@@ -2353,13 +2486,17 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
         type: "integer",
         column: {
           unsigned: true
-        }
+        },
+        // This must be set explicitly so that it is used instead of shortening the attribute name, which is already shortened
+        columnName: joinColumnName
       },
       [inverseJoinColumnName]: {
         type: "integer",
         column: {
           unsigned: true
-        }
+        },
+        // This must be set explicitly so that it is used instead of shortening the attribute name, which is already shortened
+        columnName: inverseJoinColumnName
       }
       // TODO: add extra pivot attributes -> user should use an intermediate entity
     },
@@ -2373,7 +2510,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
         columns: [inverseJoinColumnName]
       },
       {
-        name: getUniqueIndexName(joinTableName),
+        name: identifiers.getUniqueIndexName(joinTableName),
         columns: [joinColumnName, inverseJoinColumnName],
         type: "unique"
       }
@@ -2384,7 +2521,6 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
         columns: [joinColumnName],
         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"
       },
       {
@@ -2392,7 +2528,6 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
         columns: [inverseJoinColumnName],
         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"
       }
     ],
@@ -2422,8 +2557,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       }
     };
     metadataSchema.indexes.push({
-      name: getOrderFkIndexName(joinTableName),
-      // TODO: should we send joinTableName as parts?
+      name: identifiers.getOrderFkIndexName(joinTableName),
       columns: [orderColumnName]
     });
     joinTable.orderColumnName = orderColumnName;
@@ -2438,7 +2572,7 @@ const createJoinTable = (metadata, { attributeName, attribute, meta }) => {
       }
     };
     metadataSchema.indexes.push({
-      name: getOrderInverseFkIndexName(joinTableName),
+      name: identifiers.getOrderInverseFkIndexName(joinTableName),
       columns: [inverseOrderColumnName]
     });
     joinTable.inverseOrderColumnName = inverseOrderColumnName;
@@ -2496,6 +2630,12 @@ const createRelation = (attributeName, attribute, meta, metadata) => {
   }
 };
 class Metadata extends Map {
+  // TODO: we expose the global identifiers in this way so that in the future we can instantiate our own
+  // However, it should NOT be done until all the methods used by metadata can be part of this metadata object
+  // and access this one; currently they all access the global identifiers directly.
+  get identifiers() {
+    return identifiers;
+  }
   get(key) {
     if (!super.has(key)) {
       throw new Error(`Metadata for "${key}" not found`);
@@ -2519,10 +2659,12 @@ class Metadata extends Map {
       seenTables.set(meta.tableName, true);
     }
   }
-  loadModels(models = []) {
-    for (const model of ___default.default.cloneDeep(models)) {
+  loadModels(models) {
+    for (const model of _.cloneDeep(models ?? [])) {
+      const tableName = identifiers.getTableName(model.tableName);
       this.add({
         ...model,
+        tableName,
         attributes: {
           ...model.attributes
         },
@@ -2563,10 +2705,13 @@ class Metadata extends Map {
   }
 }
 const createAttribute = (attributeName, attribute) => {
-  const columnName = getColumnName(attributeName);
+  if ("columnName" in attribute && attribute.columnName) {
+    return;
+  }
+  const columnName = identifiers.getColumnName(_.snakeCase(attributeName));
   Object.assign(attribute, { columnName });
 };
-const createMetadata = (models = []) => {
+const createMetadata = (models) => {
   const metadata = new Metadata();
   if (models.length) {
     metadata.loadModels(models);
@@ -2917,11 +3062,54 @@ const createPivotJoin = (ctx, { alias, refAlias, joinTable, targetMeta }) => {
   return subAlias;
 };
 const createJoin = (ctx, { alias, refAlias, attributeName, attribute }) => {
-  const { db, qb } = ctx;
+  const { db, qb, uid } = ctx;
   if (attribute.type !== "relation") {
     throw new Error(`Cannot join on non relational field ${attributeName}`);
   }
   const targetMeta = db.metadata.get(attribute.target);
+  if (["morphOne", "morphMany"].includes(attribute.relation)) {
+    const targetAttribute = targetMeta.attributes[attribute.morphBy];
+    const { joinTable: joinTable2, morphColumn } = targetAttribute;
+    if (morphColumn) {
+      const subAlias = refAlias || qb.getAlias();
+      qb.join({
+        alias: subAlias,
+        referencedTable: targetMeta.tableName,
+        referencedColumn: morphColumn.idColumn.name,
+        rootColumn: morphColumn.idColumn.referencedColumn,
+        rootTable: alias,
+        on: {
+          [morphColumn.typeColumn.name]: uid,
+          ...morphColumn.on
+        }
+      });
+      return subAlias;
+    }
+    if (joinTable2) {
+      const joinAlias = qb.getAlias();
+      qb.join({
+        alias: joinAlias,
+        referencedTable: joinTable2.name,
+        referencedColumn: joinTable2.morphColumn.idColumn.name,
+        rootColumn: joinTable2.morphColumn.idColumn.referencedColumn,
+        rootTable: alias,
+        on: {
+          [joinTable2.morphColumn.typeColumn.name]: uid,
+          field: attributeName
+        }
+      });
+      const subAlias = refAlias || qb.getAlias();
+      qb.join({
+        alias: subAlias,
+        referencedTable: targetMeta.tableName,
+        referencedColumn: joinTable2.joinColumn.referencedColumn,
+        rootColumn: joinTable2.joinColumn.name,
+        rootTable: joinAlias
+      });
+      return subAlias;
+    }
+    return alias;
+  }
   const { joinColumn } = attribute;
   if (joinColumn) {
     const subAlias = refAlias || qb.getAlias();
@@ -3061,10 +3249,13 @@ const XtoOne = async (input, ctx) => {
         rootTable: qb2.alias,
         on: joinTable.on
       }).select([joinColAlias, qb2.raw("count(*) AS count")]).where({ [joinColAlias]: referencedValues }).groupBy(joinColAlias).execute({ mapResults: false });
-      const map2 = rows2.reduce((map3, row) => {
-        map3[row[joinColumnName]] = { count: Number(row.count) };
-        return map3;
-      }, {});
+      const map2 = rows2.reduce(
+        (map3, row) => {
+          map3[row[joinColumnName]] = { count: Number(row.count) };
+          return map3;
+        },
+        {}
+      );
       results.forEach((result) => {
         result[attributeName] = map2[result[referencedColumnName]] || { count: 0 };
       });
@@ -3137,10 +3328,13 @@ const oneToMany = async (input, ctx) => {
         rootTable: qb2.alias,
         on: joinTable.on
       }).select([joinColAlias, qb2.raw("count(*) AS count")]).where({ [joinColAlias]: referencedValues }).groupBy(joinColAlias).execute({ mapResults: false });
-      const map2 = rows2.reduce((map3, row) => {
-        map3[row[joinColumnName]] = { count: Number(row.count) };
-        return map3;
-      }, {});
+      const map2 = rows2.reduce(
+        (map3, row) => {
+          map3[row[joinColumnName]] = { count: Number(row.count) };
+          return map3;
+        },
+        {}
+      );
       results.forEach((result) => {
         result[attributeName] = map2[result[referencedColumnName]] || { count: 0 };
       });
@@ -3194,10 +3388,13 @@ const manyToMany = async (input, ctx) => {
       rootTable: populateQb.alias,
       on: joinTable.on
     }).select([joinColAlias, populateQb.raw("count(*) AS count")]).where({ [joinColAlias]: referencedValues }).groupBy(joinColAlias).execute({ mapResults: false });
-    const map2 = rows2.reduce((map3, row) => {
-      map3[row[joinColumnName]] = { count: Number(row.count) };
-      return map3;
-    }, {});
+    const map2 = rows2.reduce(
+      (map3, row) => {
+        map3[row[joinColumnName]] = { count: Number(row.count) };
+        return map3;
+      },
+      {}
+    );
     results.forEach((result) => {
       result[attributeName] = map2[result[referencedColumnName]] || { count: 0 };
     });
@@ -3544,7 +3741,7 @@ const castValue = (value, attribute) => {
 };
 const processSingleAttributeWhere = (attribute, where, operator = "$eq") => {
   if (!isRecord$1(where)) {
-    if (utils$1.isOperatorOfType("cast", operator)) {
+    if (utils.isOperatorOfType("cast", operator)) {
       return castValue(where, attribute);
     }
     return where;
@@ -3552,7 +3749,7 @@ const processSingleAttributeWhere = (attribute, where, operator = "$eq") => {
   const filters = {};
   for (const key of Object.keys(where)) {
     const value = where[key];
-    if (!utils$1.isOperatorOfType("where", key)) {
+    if (!utils.isOperatorOfType("where", key)) {
       throw new Error(`Undefined attribute level operator ${key}`);
     }
     filters[key] = processAttributeWhere(attribute, value, key);
@@ -3571,6 +3768,28 @@ const processNested = (where, ctx) => {
   }
   return processWhere(where, ctx);
 };
+const processRelationWhere = (where, ctx) => {
+  const { qb, alias } = ctx;
+  const idAlias = qb.aliasColumn("id", alias);
+  if (!isRecord$1(where)) {
+    return { [idAlias]: where };
+  }
+  const keys = Object.keys(where);
+  const operatorKeys = keys.filter((key) => utils.isOperator(key));
+  if (operatorKeys.length > 0 && operatorKeys.length !== keys.length) {
+    throw new Error(`Operator and non-operator keys cannot be mixed in a relation where clause`);
+  }
+  if (operatorKeys.length > 1) {
+    throw new Error(
+      `Only one operator key is allowed in a relation where clause, but found: ${operatorKeys}`
+    );
+  }
+  if (operatorKeys.length === 1) {
+    const operator = operatorKeys[0];
+    return { [idAlias]: { [operator]: processNested(where[operator], ctx) } };
+  }
+  return processWhere(where, ctx);
+};
 function processWhere(where, ctx) {
   if (!_.isArray(where) && !isRecord$1(where)) {
     throw new Error("Where must be an array or an object");
@@ -3583,7 +3802,10 @@ function processWhere(where, ctx) {
   const filters = {};
   for (const key of Object.keys(where)) {
     const value = where[key];
-    if (utils$1.isOperatorOfType("group", key) && Array.isArray(value)) {
+    if (utils.isOperatorOfType("group", key)) {
+      if (!Array.isArray(value)) {
+        throw new Error(`Operator ${key} must be an array`);
+      }
       filters[key] = value.map((sub) => processNested(sub, ctx));
       continue;
     }
@@ -3591,7 +3813,7 @@ function processWhere(where, ctx) {
       filters[key] = processNested(value, ctx);
       continue;
     }
-    if (utils$1.isOperatorOfType("where", key)) {
+    if (utils.isOperatorOfType("where", key)) {
       throw new Error(
         `Only $and, $or and $not can only be used as root level operators. Found ${key}.`
       );
@@ -3607,15 +3829,12 @@ function processWhere(where, ctx) {
         attributeName: key,
         attribute
       });
-      let nestedWhere = processNested(value, {
+      const nestedWhere = processRelationWhere(value, {
         db,
         qb,
         alias: subAlias,
         uid: attribute.target
       });
-      if (!isRecord$1(nestedWhere) || utils$1.isOperatorOfType("where", _.keys(nestedWhere)[0])) {
-        nestedWhere = { [qb.aliasColumn("id", subAlias)]: nestedWhere };
-      }
       Object.assign(filters, nestedWhere);
       continue;
     }
@@ -3630,7 +3849,7 @@ function processWhere(where, ctx) {
   return filters;
 }
 const applyOperator = (qb, column, operator, value) => {
-  if (Array.isArray(value) && !utils$1.isOperatorOfType("array", operator)) {
+  if (Array.isArray(value) && !utils.isOperatorOfType("array", operator)) {
     return qb.where((subQB) => {
       value.forEach(
         (subValue) => subQB.orWhere((innerQB) => {
@@ -3768,8 +3987,8 @@ const applyWhereToColumn = (qb, column, columnWhere) => {
     }
     return qb.where(column, columnWhere);
   }
-  const keys2 = Object.keys(columnWhere);
-  keys2.forEach((operator) => {
+  const keys = Object.keys(columnWhere);
+  keys.forEach((operator) => {
     const value = columnWhere[operator];
     applyOperator(qb, column, operator, value);
   });
@@ -4708,21 +4927,24 @@ const sortConnectArray = (connectArr, initialArr = [], strictSort = true) => {
     (acc, rel) => ({ ...acc, [rel.id]: true }),
     {}
   );
-  const mappedRelations = connectArr.reduce((mapper, relation) => {
-    const adjacentRelId = relation.position?.before || relation.position?.after;
-    if (!adjacentRelId || !relationInInitialArray[adjacentRelId] && !mapper[adjacentRelId]) {
-      needsSorting = true;
-    }
-    if (mapper[relation.id]) {
-      throw new InvalidRelationError(
-        `The relation with id ${relation.id} is already connected. You cannot connect the same relation twice.`
-      );
-    }
-    return {
-      [relation.id]: { ...relation, computed: false },
-      ...mapper
-    };
-  }, {});
+  const mappedRelations = connectArr.reduce(
+    (mapper, relation) => {
+      const adjacentRelId = relation.position?.before || relation.position?.after;
+      if (!adjacentRelId || !relationInInitialArray[adjacentRelId] && !mapper[adjacentRelId]) {
+        needsSorting = true;
+      }
+      if (mapper[relation.id]) {
+        throw new InvalidRelationError(
+          `The relation with id ${relation.id} is already connected. You cannot connect the same relation twice.`
+        );
+      }
+      return {
+        [relation.id]: { ...relation, computed: false },
+        ...mapper
+      };
+    },
+    {}
+  );
   if (!needsSorting)
     return connectArr;
   const computeRelation = (relation, relationsSeenInBranch) => {
@@ -4830,14 +5052,17 @@ const relationsOrderer = (initArr, idColumn, orderColumn, strict) => {
      * Get a map between the relation id and its order
      */
     getOrderMap() {
-      return ___default$1.default(computedRelations).groupBy("order").reduce((acc, relations) => {
-        if (relations[0]?.init)
+      return ___default$1.default(computedRelations).groupBy("order").reduce(
+        (acc, relations) => {
+          if (relations[0]?.init)
+            return acc;
+          relations.forEach((relation, idx) => {
+            acc[relation.id] = Math.floor(relation.order) + (idx + 1) / (relations.length + 1);
+          });
           return acc;
-        relations.forEach((relation, idx) => {
-          acc[relation.id] = Math.floor(relation.order) + (idx + 1) / (relations.length + 1);
-        });
-        return acc;
-      }, {});
+        },
+        {}
+      );
     }
   };
 };
@@ -5591,10 +5816,13 @@ const createEntityManager = (db) => {
       const entry = await this.findOne(uid, {
         select: ["id"],
         where: { id: entity.id },
-        populate: fieldsArr.reduce((acc, field) => {
-          acc[field] = populate || true;
-          return acc;
-        }, {})
+        populate: fieldsArr.reduce(
+          (acc, field) => {
+            acc[field] = populate || true;
+            return acc;
+          },
+          {}
+        )
       });
       if (!entry) {
         return null;
@@ -5710,7 +5938,280 @@ const createUserMigrationProvider = (db) => {
     }
   };
 };
-const internalMigrations = [];
+const QUERIES = {
+  async postgres(knex2, params) {
+    const res = await knex2.raw(
+      `
+    SELECT :tableName:.id as id, string_agg(DISTINCT :inverseJoinColumn:::character varying, ',') as other_ids
+    FROM :tableName:
+    LEFT JOIN :joinTableName: ON :tableName:.id = :joinTableName:.:joinColumn:
+    WHERE document_id IS NULL
+    GROUP BY :tableName:.id, :joinColumn:
+    LIMIT 1;
+  `,
+      params
+    );
+    return res.rows;
+  },
+  async mysql(knex2, params) {
+    const [res] = await knex2.raw(
+      `
+    SELECT :tableName:.id as id, group_concat(DISTINCT :inverseJoinColumn:) as other_ids
+    FROM :tableName:
+    LEFT JOIN :joinTableName: ON :tableName:.id = :joinTableName:.:joinColumn:
+    WHERE document_id IS NULL
+    GROUP BY :tableName:.id, :joinColumn:
+    LIMIT 1;
+  `,
+      params
+    );
+    return res;
+  },
+  async sqlite(knex2, params) {
+    return knex2.raw(
+      `
+    SELECT :tableName:.id as id, group_concat(DISTINCT :inverseJoinColumn:) as other_ids
+    FROM :tableName:
+    LEFT JOIN :joinTableName: ON :tableName:.id = :joinTableName:.:joinColumn:
+    WHERE document_id IS NULL
+    GROUP BY :joinColumn:
+    LIMIT 1;
+    `,
+      params
+    );
+  }
+};
+const getNextIdsToCreateDocumentId = async (db, knex2, {
+  joinColumn,
+  inverseJoinColumn,
+  tableName,
+  joinTableName
+}) => {
+  const res = await QUERIES[db.dialect.client](knex2, {
+    joinColumn,
+    inverseJoinColumn,
+    tableName,
+    joinTableName
+  });
+  if (res.length > 0) {
+    const row = res[0];
+    const otherIds = row.other_ids ? row.other_ids.split(",").map((v) => parseInt(v, 10)) : [];
+    return [row.id, ...otherIds];
+  }
+  return [];
+};
+const migrateDocumentIdsWithLocalizations = async (db, knex2, meta) => {
+  const singularName = meta.singularName.toLowerCase();
+  const joinColumn = identifiers.getJoinColumnAttributeIdName(singularName);
+  const inverseJoinColumn = identifiers.getInverseJoinColumnAttributeIdName(singularName);
+  let ids;
+  do {
+    ids = await getNextIdsToCreateDocumentId(db, knex2, {
+      joinColumn,
+      inverseJoinColumn,
+      tableName: meta.tableName,
+      joinTableName: identifiers.getJoinTableName(meta.tableName, `localizations`)
+    });
+    if (ids.length > 0) {
+      await knex2(meta.tableName).update({ document_id: cuid2.createId() }).whereIn("id", ids);
+    }
+  } while (ids.length > 0);
+};
+const migrationDocumentIds = async (db, knex2, meta) => {
+  let run = true;
+  do {
+    const updatedRows = await knex2(meta.tableName).update({ document_id: cuid2.createId() }).whereIn("id", (builder) => {
+      return builder.whereNull("document_id").select("id").limit(1);
+    });
+    if (updatedRows <= 0) {
+      run = false;
+    }
+  } while (run);
+};
+const createDocumentIdColumn = async (knex2, tableName) => {
+  await knex2.schema.alterTable(tableName, (table) => {
+    table.string("document_id");
+  });
+};
+const hasLocalizationsJoinTable = async (knex2, tableName) => {
+  const joinTableName = identifiers.getJoinTableName(tableName, "localizations");
+  return knex2.schema.hasTable(joinTableName);
+};
+const createdDocumentId = {
+  name: "5.0.0-02-created-document-id",
+  async up(knex2, db) {
+    for (const meta of db.metadata.values()) {
+      const hasTable = await knex2.schema.hasTable(meta.tableName);
+      if (!hasTable) {
+        continue;
+      }
+      if ("documentId" in meta.attributes) {
+        const hasDocumentIdColumn = await knex2.schema.hasColumn(meta.tableName, "document_id");
+        if (hasDocumentIdColumn) {
+          continue;
+        }
+        await createDocumentIdColumn(knex2, meta.tableName);
+        if (await hasLocalizationsJoinTable(knex2, meta.tableName)) {
+          await migrateDocumentIdsWithLocalizations(db, knex2, meta);
+        } else {
+          await migrationDocumentIds(db, knex2, meta);
+        }
+      }
+    }
+  },
+  async down() {
+    throw new Error("not implemented");
+  }
+};
+const debug = createDebug__default.default("strapi::database::migration");
+const renameIdentifiersLongerThanMaxLength = {
+  name: "5.0.0-rename-identifiers-longer-than-max-length",
+  async up(knex2, db) {
+    const md = db.metadata;
+    const diffs = findDiffs(md);
+    for (const indexDiff of diffs.indexes) {
+      await renameIndex(knex2, db, indexDiff);
+    }
+    for (const columnDiff of diffs.columns) {
+      const { full, short } = columnDiff;
+      const tableName = full.tableName;
+      const hasTable = await knex2.schema.hasTable(tableName);
+      if (hasTable) {
+        const hasColumn = await knex2.schema.hasColumn(tableName, full.columnName);
+        if (hasColumn) {
+          await knex2.schema.alterTable(tableName, async (table) => {
+            debug(`renaming column ${full.columnName} to ${short.columnName}`);
+            table.renameColumn(full.columnName, short.columnName);
+          });
+        }
+      }
+    }
+    for (const tableDiff of diffs.tables) {
+      const hasTable = await knex2.schema.hasTable(tableDiff.full.tableName);
+      if (hasTable) {
+        debug(`renaming table ${tableDiff.full.tableName} to ${tableDiff.short.tableName}`);
+        await knex2.schema.renameTable(tableDiff.full.tableName, tableDiff.short.tableName);
+      }
+    }
+  },
+  async down() {
+    throw new Error("not implemented");
+  }
+};
+const renameIndex = async (knex2, db, diff) => {
+  const client = db.config.connection.client;
+  const short = diff.short;
+  const full = diff.full;
+  if (full.indexName === short.indexName) {
+    debug(`not renaming index ${full.indexName} because name hasn't changed`);
+    return;
+  }
+  if (short.indexName.includes("_lnk_") || full.indexName.includes("_lnk_") || short.indexName.endsWith("fk") || full.indexName.endsWith("fk")) {
+    return;
+  }
+  debug(`renaming index from ${full.indexName} to ${short.indexName}`);
+  try {
+    await knex2.transaction(async (trx) => {
+      if (client === "mysql" || client === "mariadb") {
+        await knex2.raw(
+          `ALTER TABLE \`${full.tableName}\` RENAME INDEX \`${full.indexName}\` TO \`${short.indexName}\``
+        ).transacting(trx);
+      } else if (client === "pg" || client === "postgres") {
+        await knex2.raw(`ALTER INDEX "${full.indexName}" RENAME TO "${short.indexName}"`).transacting(trx);
+      } else if (client === "sqlite" || client === "better") {
+      } else {
+        debug("No db client name matches, not creating index");
+      }
+    });
+  } catch (err) {
+    debug(`error creating index: ${JSON.stringify(err)}`);
+  }
+};
+const findDiffs = (shortMap) => {
+  const diffs = {
+    tables: [],
+    columns: [],
+    indexes: []
+  };
+  const shortArr = Array.from(shortMap.entries());
+  shortArr.forEach(([, shortObj], index2) => {
+    const fullTableName = identifiers.getUnshortenedName(shortObj.tableName);
+    if (!fullTableName) {
+      throw new Error(`Missing full table name for ${shortObj.tableName}`);
+    }
+    if (shortObj.tableName !== fullTableName) {
+      diffs.tables.push({
+        full: {
+          index: index2,
+          key: "tableName",
+          tableName: fullTableName
+        },
+        short: {
+          index: index2,
+          key: "tableName",
+          tableName: shortObj.tableName
+        }
+      });
+    }
+    for (const attrKey in shortObj.attributes) {
+      if (shortObj.attributes[attrKey].type === "relation") {
+        continue;
+      }
+      const attr = shortObj.attributes[attrKey];
+      const shortColumnName = attr.columnName;
+      const longColumnName = identifiers.getUnshortenedName(shortColumnName);
+      if (!shortColumnName || !longColumnName) {
+        throw new Error(`missing column name(s) for attribute ${JSON.stringify(attr, null, 2)}`);
+      }
+      if (shortColumnName && longColumnName && shortColumnName !== longColumnName) {
+        diffs.columns.push({
+          short: {
+            index: index2,
+            tableName: fullTableName,
+            // NOTE: this means that we must rename columns before tables
+            key: `attributes.${attrKey}`,
+            columnName: shortColumnName
+          },
+          full: {
+            index: index2,
+            tableName: fullTableName,
+            key: `attributes.${attrKey}`,
+            columnName: longColumnName
+          }
+        });
+      }
+    }
+    for (const attrKey in shortObj.indexes) {
+      const shortIndexName = shortObj.indexes[attrKey].name;
+      const longIndexName = identifiers.getUnshortenedName(shortIndexName);
+      if (!longIndexName) {
+        throw new Error(`Missing full index name for ${shortIndexName}`);
+      }
+      if (shortIndexName && longIndexName && shortIndexName !== longIndexName) {
+        diffs.indexes.push({
+          short: {
+            index: index2,
+            tableName: fullTableName,
+            // NOTE: this means that we must rename columns before tables
+            key: `indexes.${attrKey}`,
+            indexName: shortIndexName
+          },
+          full: {
+            index: index2,
+            tableName: fullTableName,
+            key: `indexes.${attrKey}`,
+            indexName: longIndexName
+          }
+        });
+      }
+    }
+  });
+  return diffs;
+};
+const internalMigrations = [
+  renameIdentifiersLongerThanMaxLength,
+  createdDocumentId
+];
 const createInternalMigrationProvider = (db) => {
   const context = { db };
   const umzugProvider = new umzug.Umzug({
@@ -5936,8 +6437,14 @@ const validateBidirectionalRelations = async (db) => {
   for (const { relation, invRelation } of invalidLinks) {
     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 joinTableName = identifiers.getJoinTableName(
+      _.snakeCase(modelMetadata.tableName),
+      _.snakeCase(invRelation.inversedBy)
+    );
+    const inverseJoinTableName = identifiers.getJoinTableName(
+      _.snakeCase(invModelMetadata.tableName),
+      _.snakeCase(relation.inversedBy)
+    );
     const joinTableEmpty = await isLinkTableEmpty(db, joinTableName);
     const inverseJoinTableEmpty = await isLinkTableEmpty(db, inverseJoinTableName);
     if (joinTableEmpty) {
@@ -5983,7 +6490,7 @@ class Database {
     };
     this.dialect = getDialect(this);
     this.dialect.configure();
-    this.metadata = createMetadata();
+    this.metadata = createMetadata([]);
     this.connection = createConnection(this.config.connection, {
       pool: { afterCreate: afterCreate(this) }
     });
@@ -6060,9 +6567,7 @@ 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