import { EntityMetadata, FindOperator, SelectQueryBuilder } from 'typeorm'; import { WherePredicateOperator } from 'typeorm/query-builder/WhereClause'; import { PaginateQuery } from './decorator'; import { JoinMethod } from './helper'; import { EmbeddedMetadata } from 'typeorm/metadata/EmbeddedMetadata'; import { RelationMetadata } from 'typeorm/metadata/RelationMetadata'; import { DistanceColumnConfig } from './distance'; /** Per-column distance configuration, keyed by the name used in `:$dist:lat,lng`. */ export type DistanceColumns = Record; export declare enum FilterOperator { EQ = "$eq", GT = "$gt", GTE = "$gte", IN = "$in", NULL = "$null", LT = "$lt", LTE = "$lte", BTW = "$btw", ILIKE = "$ilike", SW = "$sw", CONTAINS = "$contains" } export declare function isOperator(value: unknown): value is FilterOperator; export declare enum FilterSuffix { NOT = "$not" } export declare function isSuffix(value: unknown): value is FilterSuffix; export declare enum FilterQuantifier { ALL = "$all", ANY = "$any", NONE = "$none" } export declare function isQuantifier(value: unknown): value is FilterQuantifier; /** Internal: how a built `Filter` combines with the previous one (JSONB `$in` ORs its terms). */ export declare enum FilterComparator { AND = "$and", OR = "$or" } export declare const OperatorSymbolToFunction: Map FindOperator>; type Filter = { quantifier: FilterQuantifier; comparator: FilterComparator; findOperator: FindOperator; /** * A bare `$any`/`$none` on a relation column: the quantifier is the whole predicate, so this * filter contributes no condition of its own. The relation still joins, and that join is what * decides whether the row exists. */ bare?: boolean; }; type ColumnFilters = { [columnName: string]: Filter[]; }; type ColumnJoinMethods = { [columnName: string]: JoinMethod; }; /** * Matches TypeORM named parameters (`:name` and `:...name` spread form) while skipping * PostgreSQL cast syntax (`::type`). * * TypeORM parameter names may contain letters, digits, underscores, and dots (the latter * for embedded-property paths, e.g. `size.height0`). The pattern captures the full name * including any embedded-path dots. * * Capture groups: * 1 — optional `...` spread prefix (present for IN parameters) * 2 — parameter name (may contain dots for embedded paths) * * Examples: * `:name` → matches, spread=undefined, name='name' * `:...vals` → matches, spread='...', name='vals' * `:size.height0` → matches, spread=undefined, name='size.height0' * `col::text` → no match (lookbehind rejects `::`) * `:param::int` → matches `:param`, skips `::int` */ /** @internal Exported for testing only. */ export declare const TYPEORM_PARAM_REGEX: RegExp; export interface FilterToken { quantifier: FilterQuantifier; comparator: FilterComparator; suffix?: FilterSuffix; operator: FilterOperator; value: string; } export declare function fixQueryParam(alias: string, column: string, filter: Filter, condition: WherePredicateOperator, parameters: { [key: string]: string; }): { [key: string]: string; }; export declare function generatePredicateCondition(qb: SelectQueryBuilder, column: string, filter: Filter, alias: string, isVirtualProperty?: boolean): WherePredicateOperator; /** * Validates the parts of a polymorphic `a~b` column and left-joins any to-one relation parts * (without selecting them). Must run on the main query builder — joins cannot be added from * inside a `Brackets` where-callback. Each part must be a plain or to-one relation column. * * Relation parts may be nested (`a.b.c.leaf`): every segment before the leaf column is a hop that * is joined step by step (the database cannot resolve a multi-level path in one join). Each hop is * joined under a path-derived alias (`__rel`) that matches exactly what * `fixColumnAlias`/`buildPolymorphicCoalesce` reference for the leaf, and hops shared across parts * (e.g. a common `a.b` prefix) reuse the already-created join by alias rather than colliding. */ export declare function preparePolymorphicColumn(qb: SelectQueryBuilder, column: string): void; export declare function addWhereCondition(qb: SelectQueryBuilder, column: string, filter: ColumnFilters, paramKeySuffix?: string, distanceColumns?: DistanceColumns): void; export declare function parseFilterToken(raw?: string): FilterToken | null; export declare function parseFilter(query: PaginateQuery, filterableColumns?: { [column: string]: (FilterOperator | FilterSuffix | FilterQuantifier)[] | true; }, qb?: SelectQueryBuilder, throwOnInvalidFilter?: boolean): ColumnFilters; /** * Retrieves the relation path for a given column name within the provided metadata. * * This method analyzes the column name's segments to identify corresponding relations or embedded entities * within the hierarchy described by the given metadata and returns a structured path. * * @param {string} columnName - The dot-delimited name of the column whose relation path is to be determined. * @param {EntityMetadata | EmbeddedMetadata} metadata - The metadata of the entity or embedded component * which holds the relations or embedded items. * @return {[string, RelationMetadata | EmbeddedMetadata][]} The ordered array describing the path, * where each element contains a field name and its corresponding relation or embedded metadata. * Throws an error if no matching relation or embedded metadata is found. */ export declare function getRelationPath(columnName: string, metadata: EntityMetadata | EmbeddedMetadata): [string, RelationMetadata | EmbeddedMetadata][]; export interface AddFilterOptions { /** * Set when `addFilter` is called recursively to build an EXISTS subquery. Inside a subquery * to-one relations are joined locally (they don't pollute the outer result set), so only * to-many relations are lifted into nested EXISTS. At the top level every relation filter * becomes an EXISTS. * @internal */ subFilter?: boolean; /** * Suffix appended to EXISTS subquery aliases and parameters to keep them unique across * sibling filter-expression leaves on the same relation path. * @internal */ scope?: string | number; } export declare function addFilter(qb: SelectQueryBuilder, query: PaginateQuery, filterableColumns?: { [column: string]: (FilterOperator | FilterSuffix | FilterQuantifier)[] | true; }, opts?: AddFilterOptions, throwOnInvalidFilter?: boolean, distanceColumns?: DistanceColumns): ColumnJoinMethods; type ExpressionFilterableColumns = { [column: string]: (FilterOperator | FilterSuffix | FilterQuantifier)[] | true; }; /** * Applies a `filter=` boolean expression to the query. Each leaf is wrapped in its own * `Brackets` so AND/OR/NOT compose uniformly. Root/embedded and polymorphic (`a~b`) leaves * become direct conditions; relation leaves become correlated EXISTS (NOT EXISTS when negated). */ export declare function addFilterExpression(qb: SelectQueryBuilder, expression: string, filterableColumns?: ExpressionFilterableColumns, maxComplexity?: number): void; export declare function addDirectFilters(qb: SelectQueryBuilder, filter: ColumnFilters, subFilter?: boolean, distanceColumns?: DistanceColumns): void; /** * Adds a correlated EXISTS subquery to `qb` for every relation-path filter, rooted at the first * relation on each path. The path's `$any`/`$none`/`$all` quantifier decides whether it becomes * EXISTS, NOT EXISTS, or an all-match check. */ export declare function addToManySubFilters(qb: SelectQueryBuilder, filter: ColumnFilters, query: PaginateQuery, filterableColumns?: { [column: string]: (FilterOperator | FilterSuffix | FilterQuantifier)[] | true; }, { subFilter, scope }?: AddFilterOptions): void; export declare function createSubFilter(query: PaginateQuery, filterableColumns: { [column: string]: (FilterOperator | FilterSuffix | FilterQuantifier)[] | true; }, column: string): { subQuery: PaginateQuery; subFilterableColumns: { [column: string]: true | (FilterOperator | FilterSuffix | FilterQuantifier)[]; }; }; export {};