Method validateIndexUsage

packages/core/src/EntityManager.ts:2732–2796

(
    meta: EntityMetadata<Entity>,
    where: FilterQuery<Entity> | Dictionary,
    options: { using?: string | string[]; orderBy?: any },
  )

  }

  private validateIndexUsage<Entity extends object>(
    meta: EntityMetadata<Entity>,
    where: FilterQuery<Entity> | Dictionary,
    options: { using?: string | string[]; orderBy?: any },
  ): void {
    if (!options.using) {
      return;
    }

    const indexNames = Utils.asArray(options.using);
    const allIndexes = [...meta.indexes, ...meta.uniques];

    const indexMap = new Map<string, string[]>();

    for (const idx of allIndexes) {
      if (idx.name) {
        indexMap.set(idx.name, Utils.asArray(idx.properties ?? []) as string[]);
      }
    }

    for (const prop of meta.props) {
      if (typeof prop.index === 'string') {
        indexMap.set(prop.index, [prop.name]);
      }

      if (typeof prop.unique === 'string') {
        indexMap.set(prop.unique, [prop.name]);
      }
    }

    const allowedProps = new Set<string>();

    for (const name of indexNames) {
      const props = indexMap.get(name);

      if (!props) {
        const available = [...indexMap.keys()];
        throw new Error(
          `Index '${name}' not found on entity '${meta.className}'. ` +
            (available.length > 0 ? `Available indexes: ${available.join(', ')}` : 'No named indexes defined.'),
        );
      }

      for (const prop of props) {
        allowedProps.add(prop);
      }
    }

    this.validateWhereKeysForIndex(where, allowedProps, indexNames);

    if (options.orderBy) {
      const orderMaps = Array.isArray(options.orderBy) ? options.orderBy : [options.orderBy];

      for (const orderMap of orderMaps) {
        for (const key of Object.keys(orderMap)) {
          if (!allowedProps.has(key)) {
            throw new Error(
              `Property '${key}' in orderBy is not covered by index '${indexNames.join("', '")}'. ` +