Method findOne

packages/core/src/EntityManager.ts:1037–1139

(
    entityName: EntityName<Entity>,
    where: FilterQuery<NoInfer<Entity>>,
    options: FindOneOptions<Entity, Hint, Fields, Excludes> = {},
  )

  ): Promise<Loaded<Entity, Hint, Fields, Excludes> | null>;

  async findOne<
    Entity extends object,
    Hint extends string = never,
    Fields extends string = never,
    Excludes extends string = never,
  >(
    entityName: EntityName<Entity>,
    where: FilterQuery<NoInfer<Entity>>,
    options: FindOneOptions<Entity, Hint, Fields, Excludes> = {},
  ): Promise<Loaded<Entity, Hint, Fields, Excludes> | null> {
    if (options.disableIdentityMap ?? this.config.get('disableIdentityMap')) {
      const em = this.getContext(false);
      const fork = em.fork({ keepTransactionContext: true });
      const ret = await fork.findOne(entityName, where as any, { ...options, disableIdentityMap: false });
      fork.clear();

      return ret;
    }

    const em = this.getContext();
    em.prepareOptions(options);
    let entity = em.#unitOfWork.tryGetById(entityName, where, options.schema);

    // query for a not managed entity which is already in the identity map as it
    // was provided with a PK this entity does not exist in the db, there can't
    // be any relations to it, so no need to deal with the populate hint
    if (entity && !helper(entity).__managed) {
      return entity as Loaded<Entity, Hint, Fields, Excludes>;
    }

    await em.tryFlush(entityName, options);
    const meta = em.metadata.get<Entity>(entityName);
    em.validateIndexUsage(meta, where, options);
    where = await em.processWhere(entityName, where, options, 'read');
    validateEmptyWhere(where);
    em.checkLockRequirements(options.lockMode, meta);
    const isOptimisticLocking =
      options.lockMode == null || options.lockMode === LockMode.NONE || options.lockMode === LockMode.OPTIMISTIC;

    if (entity && !em.shouldRefresh(meta, entity, options) && isOptimisticLocking) {
      return em.lockAndPopulate(meta, entity, where, options);
    }

    validateParams(where);
    options.populate = (await em.preparePopulate(entityName, options)) as any;
    const cacheKey = em.cacheKey(entityName, options, 'em.findOne', where);
    const cached = await em.tryCache<Entity, Loaded<Entity, Hint, Fields, Excludes>>(
      entityName,
      options.cache,
      cacheKey,
      options.refresh,
      true,
    );

    if (cached?.data !== undefined) {
      if (cached.data) {
        await em.#entityLoader.populate<Entity, Fields>(
          entityName,