Method find

packages/mongodb/src/MongoDriver.ts:89–164

(
    entityName: EntityName<T>,
    where: FilterQuery<T>,
    options: FindOptions<T, P, F, E> = {},
  )

  }

  async find<T extends object, P extends string = never, F extends string = never, E extends string = never>(
    entityName: EntityName<T>,
    where: FilterQuery<T>,
    options: FindOptions<T, P, F, E> = {},
  ): Promise<EntityData<T>[]> {
    if (this.metadata.find(entityName)?.virtual) {
      return this.findVirtual(entityName, where, options);
    }

    const { first, last, before, after } = options as FindByCursorOptions<T>;
    const fields = this.buildFields(
      entityName,
      (options.populate as unknown as PopulateOptions<T>[]) || [],
      options.fields,
      options.exclude as any[],
    );
    where = this.renameFields(entityName, where as T, true);
    const isCursorPagination = [first, last, before, after].some(v => v != null);

    if (isCursorPagination) {
      const andWhere = (cond1: FilterQuery<T>, cond2: FilterQuery<T>): FilterQuery<T> => {
        if (Utils.isEmpty(cond1)) {
          return cond2;
        }

        if (Utils.isEmpty(cond2)) {
          return cond1;
        }

        return { $and: [cond1, cond2] } as FilterQuery<T>;
      };
      const meta = this.metadata.find<T>(entityName)!;
      const { orderBy: newOrderBy, where: newWhere } = this.processCursorOptions(meta, options, options.orderBy!);
      const newWhereConverted = this.renameFields(entityName, newWhere as T, true);
      const orderBy = Utils.asArray(newOrderBy).map(order => this.renameFields(entityName, order as T, true));
      const res = await this.rethrow(
        this.getConnection('read').find(entityName, andWhere(where, newWhereConverted), {
          orderBy,
          limit: options.limit,
          offset: options.offset,
          fields,
          ctx: options.ctx,
          loggerContext: options.logging,
          ...this.buildQueryOptions(options),
        }),
      );

      if (isCursorPagination && !first && !!last) {
        res.reverse();
      }

      return res.map(r => this.mapResult<T>(r, this.metadata.find<T>(entityName))!);
    }

    const orderBy = Utils.asArray(options.orderBy).map(orderBy => this.renameFields(entityName, orderBy as T, true));
    const partitionLimit = (options as Dictionary)._partitionLimit as
      | { partitionBy: string; limit: number; offset?: number }
      | undefined;