Class CriteriaNode

packages/sql/src/query/CriteriaNode.ts:20–198

 * @internal
 */
export class CriteriaNode<T extends object> implements ICriteriaNode<T> {
  payload: any;
  prop?: EntityProperty<T>;
  index?: number;

  constructor(
    protected readonly metadata: MetadataStorage,
    readonly entityName: EntityName<T>,
    readonly parent?: ICriteriaNode<T>,
    readonly key?: EntityKey<T> | RawQueryFragmentSymbol,
    readonly validate = true,
    readonly strict = false,
  ) {
    const meta = parent && metadata.find<T>(parent.entityName);

    if (meta && key && !RawQueryFragment.isKnownFragmentSymbol(key)) {
      const pks = Utils.splitPrimaryKeys<T>(key);

      if (pks.length > 1) {
        return;
      }

      for (const k of pks) {
        this.prop = meta.props.find(
          prop =>
            prop.name === k || (prop.fieldNames?.length === 1 && prop.fieldNames[0] === k && prop.persist !== false),
        );
        const isProp = this.prop || meta.props.find(prop => (prop.fieldNames || []).includes(k));

        // do not validate if the key is prefixed or type casted (e.g. `k::text`)
        if (validate && !isProp && !k.includes('.') && !k.includes('::') && !Utils.isOperator(k)) {
          throw new Error(`Trying to query by not existing property ${Utils.className(entityName)}.${k}`);
        }
      }
    }
  }

  process(qb: IQueryBuilder<T>, options?: ICriteriaNodeProcessOptions): any {
    return this.payload;
  }

  unwrap(): any {
    return this.payload;
  }

  shouldInline(payload: any): boolean {
    return false;
  }

  willAutoJoin(qb: IQueryBuilder<T>, alias?: string, options?: ICriteriaNodeProcessOptions): boolean {
    return false;
  }

  shouldRename(payload: any): boolean {
    const type = this.prop ? this.prop.kind : null;
    // Polymorphic relations have a composite column set (discriminator + FK), but we only
    // need tuple-renaming when the payload is itself a tuple (entity ref expanded by
    // `convertCompositeEntityRefs`) or an array-valued operator like `$in`. Scalar payloads