Function createQueryBuilderFromOptions

packages/sql/src/AbstractSqlDriver.ts:173–251

(
    meta: EntityMetadata<T>,
    where: FilterQuery<T>,
    options: FindOptions<T, any, any, any> = {},
  )

  }

  private async createQueryBuilderFromOptions<T extends object>(
    meta: EntityMetadata<T>,
    where: FilterQuery<T>,
    options: FindOptions<T, any, any, any> = {},
  ): Promise<AnyQueryBuilder<T>> {
    const connectionType = this.resolveConnectionType({ ctx: options.ctx, connectionType: options.connectionType });
    const populate = this.autoJoinOneToOneOwner(
      meta,
      options.populate as unknown as PopulateOptions<T>[],
      options.fields,
    );
    const joinedProps = this.joinedProps(meta, populate, options);
    const schema = this.getSchemaName(meta, options);
    const qb = this.createQueryBuilder(
      meta.class,
      options.ctx,
      connectionType,
      false,
      options.logging,
      undefined,
      options.em as any,
    )
      .withSchema(schema)
      .cache(false);
    qb.setAbortOptions(pickAbortOptions(options));
    const fields = this.buildFields(meta, populate, joinedProps, qb, qb.alias, options, schema);
    const orderBy = this.buildOrderBy(qb, meta, populate, options);
    const populateWhere = this.buildPopulateWhere(meta, joinedProps, options);
    Utils.asArray(options.flags).forEach(flag => qb.setFlag(flag));

    if (Utils.isPrimaryKey(where, meta.compositePK)) {
      where = { [Utils.getPrimaryKeyHash(meta.primaryKeys)]: where } as ObjectQuery<T>;
    }

    this.validateSqlOptions(options);

    const { first, last, before, after } = options as FindByCursorOptions<T>;
    const isCursorPagination = [first, last, before, after].some(v => v != null);
    qb.state.resolvedPopulateWhere = (options as Dictionary)._populateWhere;
    qb.select(fields as any)
      // only add populateWhere if we are populate-joining, as this will be used to add `on` conditions
      .populate(
        populate,
        joinedProps.length > 0 ? populateWhere : undefined,
        joinedProps.length > 0 ? options.populateFilter : undefined,
      )
      .where(where as any)
      .groupBy(options.groupBy as any)
      .having(options.having as any)
      .indexHint(options.indexHint as string)
      .collation(options.collation as string)
      .comment(options.comments)
      .hintComment(options.hintComments);

    if (isCursorPagination) {
      const { orderBy: newOrderBy, where } = this.processCursorOptions(meta, options, orderBy);
      (qb.andWhere as any)(where).orderBy(newOrderBy);
    } else {