Spaces:
Running
Running
| import { Value } from './value'; | |
| import { SmartList } from './smart-list'; | |
| import { retainQueryDiagnosticOrigin, snapshotQuery } from './query-snapshot'; | |
| import type { QueryOperation } from './request-intent'; | |
| export enum SortDirection { | |
| Asc = 'Asc', | |
| Desc = 'Desc' | |
| } | |
| export class OrderBy { | |
| constructor( | |
| public field: string, | |
| public expr: any | null, | |
| public direction: SortDirection | |
| ) {} | |
| static new(field: string, direction: SortDirection): OrderBy { | |
| return new OrderBy(field, null, direction); | |
| } | |
| static expr(expr: any, direction: SortDirection): OrderBy { | |
| return new OrderBy('', expr, direction); | |
| } | |
| static asc(field: string): OrderBy { return OrderBy.new(field, SortDirection.Asc); } | |
| static desc(field: string): OrderBy { return OrderBy.new(field, SortDirection.Desc); } | |
| } | |
| export class AggregationCacheOptions { | |
| constructor( | |
| public enabledValue: boolean, | |
| public cacheExpiredMillis: number, | |
| public propagateValue: boolean, | |
| public propagateCacheExpiredMillis: number | |
| ) {} | |
| static enabled(cacheExpiredMillis: number): AggregationCacheOptions { | |
| return new AggregationCacheOptions(true, cacheExpiredMillis, false, 0); | |
| } | |
| propagate(cacheExpiredMillis: number): AggregationCacheOptions { | |
| this.propagateValue = true; | |
| this.propagateCacheExpiredMillis = cacheExpiredMillis; | |
| return this; | |
| } | |
| } | |
| export interface TeaQLPage<T> { | |
| data: SmartList<T>; | |
| totalCount: number; | |
| offset: number; | |
| limit: number; | |
| } | |
| export interface QuerySelection { | |
| toQuery(): SelectQuery; | |
| } | |
| export interface FacetRequest { | |
| facetName: string; | |
| relationName: string; | |
| query: SelectQuery; | |
| includeAllFacets: boolean; | |
| operation?: QueryOperation; | |
| } | |
| export interface RelationAggregate { | |
| relationName: string; | |
| alias: string; | |
| query: SelectQuery; | |
| singleResult: boolean; | |
| operation?: QueryOperation; | |
| } | |
| export class SelectQuery { | |
| private hardLimitValue: number = 10_000; | |
| private continuousPageFetchOptions?: { namespace: string; ttlSeconds: number }; | |
| private continuousPageRuntimeContext?: any; | |
| private idSetPaginationOptions?: { namespace: string; ttlSeconds: number; maxIds: number }; | |
| private idSetPaginationRuntimeContext?: any; | |
| private topNProbeThreshold?: number; | |
| public entity: string; | |
| public filterCondition: any | null = null; | |
| public limitValue: number = 0; | |
| public offsetValue: number = 0; | |
| public orderItems: OrderBy[] = []; | |
| public selectItems: string[] = []; | |
| public properties: string[] = []; | |
| public joins: any[] = []; | |
| public groupByItems: string[] = []; | |
| public aggregateItems: any[] = []; | |
| public aggregationCache?: AggregationCacheOptions; | |
| public facets: FacetRequest[] = []; | |
| public relations: Array<{ | |
| name: string; | |
| query?: SelectQuery; | |
| localKey?: string; | |
| foreignKey?: string; | |
| many?: boolean; | |
| operation?: QueryOperation; | |
| }> = []; | |
| public relationAggregates: RelationAggregate[] = []; | |
| public commentText?: string; | |
| public purposeText?: string; | |
| constructor(entity: string) { | |
| this.entity = entity; | |
| // Local runtime policy must never cross the federation JSON boundary. | |
| Object.defineProperty(this, 'hardLimitValue', { enumerable: false, writable: true, value: 10_000 }); | |
| Object.defineProperty(this, 'continuousPageFetchOptions', { enumerable: false, writable: true, value: undefined }); | |
| Object.defineProperty(this, 'continuousPageRuntimeContext', { enumerable: false, writable: true, value: undefined }); | |
| Object.defineProperty(this, 'idSetPaginationOptions', { enumerable: false, writable: true, value: undefined }); | |
| Object.defineProperty(this, 'idSetPaginationRuntimeContext', { enumerable: false, writable: true, value: undefined }); | |
| Object.defineProperty(this, 'topNProbeThreshold', { enumerable: false, writable: true, value: undefined }); | |
| } | |
| comment(text: string): this { | |
| this.commentText = text; | |
| return this; | |
| } | |
| purpose(text: string): this { | |
| this.purposeText = text; | |
| return this; | |
| } | |
| facetBy( | |
| facetName: string, | |
| relationName: string, | |
| request: QuerySelection, | |
| includeAllFacets = true, | |
| operation?: QueryOperation, | |
| ): this { | |
| this.facets.push({ | |
| facetName, | |
| relationName, | |
| query: request.toQuery(), | |
| includeAllFacets, | |
| operation, | |
| }); | |
| return this; | |
| } | |
| clone(): SelectQuery { | |
| const copy = snapshotQuery(this); | |
| // Cloning an execution snapshot produces a mutable builder. The request | |
| // envelope still owns immutable intent and reapplies it on derivation. | |
| for (const field of ['commentText', 'purposeText', '_comment', '_purpose']) { | |
| const descriptor = Object.getOwnPropertyDescriptor(copy, field); | |
| if (descriptor && 'value' in descriptor && descriptor.configurable) { | |
| Object.defineProperty(copy, field, { ...descriptor, writable: true }); | |
| } | |
| } | |
| return copy; | |
| } | |
| filter(condition: any): this { | |
| this.filterCondition = condition; | |
| return this; | |
| } | |
| limit(limit: number): this { | |
| if (!Number.isSafeInteger(limit) || limit < 1) { | |
| throw new Error('QUERY_INVALID_LIMIT: limit must be a positive safe integer'); | |
| } | |
| this.limitValue = limit; | |
| return this; | |
| } | |
| optimizeForContinuousPageFetch(): this { | |
| return this.optimizeForContinuousPageFetchWith('default', 600); | |
| } | |
| optimizeForContinuousPageFetchWith(namespace: string, ttlSeconds: number): this { | |
| if (!namespace?.trim()) throw new Error('continuous page namespace must not be empty'); | |
| if (!Number.isSafeInteger(ttlSeconds) || ttlSeconds <= 0) throw new Error('continuous page ttlSeconds must be a positive integer'); | |
| this.continuousPageFetchOptions = { namespace, ttlSeconds }; | |
| return this; | |
| } | |
| bindContinuousPageRuntime(runtime: any): this { this.continuousPageRuntimeContext = runtime; return this; } | |
| localContinuousPageOptions(): { namespace: string; ttlSeconds: number } | undefined { return this.continuousPageFetchOptions; } | |
| localContinuousPageRuntime(): any { return this.continuousPageRuntimeContext; } | |
| clearContinuousPageRuntime(): this { this.continuousPageRuntimeContext = undefined; return this; } | |
| optimizePaginationWithIdSet(): this { | |
| return this.optimizePaginationWithIdSetConfig('default', 600, 3_000_000); | |
| } | |
| optimizePaginationWithIdSetConfig(namespace: string, ttlSeconds: number, maxIds: number): this { | |
| if (!namespace?.trim()) throw new Error('ID set namespace must not be empty'); | |
| if (!Number.isSafeInteger(ttlSeconds) || ttlSeconds <= 0) throw new Error('ID set ttlSeconds must be a positive integer'); | |
| if (!Number.isSafeInteger(maxIds) || maxIds <= 0) throw new Error('ID set maxIds must be a positive integer'); | |
| this.idSetPaginationOptions = { namespace, ttlSeconds, maxIds }; | |
| return this; | |
| } | |
| bindIdSetPaginationRuntime(runtime: any): this { this.idSetPaginationRuntimeContext = runtime; return this; } | |
| localIdSetPaginationOptions(): { namespace: string; ttlSeconds: number; maxIds: number } | undefined { return this.idSetPaginationOptions; } | |
| localIdSetPaginationRuntime(): any { return this.idSetPaginationRuntimeContext; } | |
| clearIdSetPaginationRuntime(): this { this.idSetPaginationRuntimeContext = undefined; return this; } | |
| topNProbeParentThreshold(threshold: number): this { | |
| if (!Number.isSafeInteger(threshold) || threshold < 0) { | |
| throw new Error('topNProbeParentThreshold must be a non-negative safe integer'); | |
| } | |
| this.topNProbeThreshold = threshold; | |
| return this; | |
| } | |
| localTopNProbeParentThreshold(): number | undefined { | |
| return this.topNProbeThreshold; | |
| } | |
| prepareForList(): this { | |
| if (!Number.isSafeInteger(this.offsetValue) || this.offsetValue < 0) { | |
| throw new Error('QUERY_INVALID_OFFSET: offset must be a non-negative safe integer'); | |
| } | |
| if (this.limitValue && (!Number.isSafeInteger(this.limitValue) || this.limitValue < 1)) { | |
| throw new Error('QUERY_INVALID_LIMIT: limit must be a positive safe integer'); | |
| } | |
| this.applyListLimit(this.hardLimitValue); | |
| return this; | |
| } | |
| forExactCount(alias = '__teaql_total'): SelectQuery { | |
| const count = new SelectQuery(this.entity); | |
| count.filterCondition = snapshotQuery(this.filterCondition); | |
| count.commentText = this.commentText; | |
| count.purposeText = this.purposeText; | |
| count.aggregate('Count', 'id', alias); | |
| retainQueryDiagnosticOrigin(this, count); | |
| return count; | |
| } | |
| private applyListLimit(ceiling: number): void { | |
| if (!this.limitValue) this.limitValue = ceiling; | |
| if (this.limitValue > ceiling) { | |
| throw new Error(`QUERY_HARD_LIMIT_EXCEEDED: requested limit ${this.limitValue} exceeds hard limit ${ceiling}`); | |
| } | |
| for (const relation of this.relations) { | |
| relation.query?.applyListLimit(10_000); | |
| } | |
| } | |
| offset(offset: number): this { | |
| if (!Number.isSafeInteger(offset) || offset < 0) { | |
| throw new Error('QUERY_INVALID_OFFSET: offset must be a non-negative safe integer'); | |
| } | |
| this.offsetValue = offset; | |
| return this; | |
| } | |
| relation(name: string): this { | |
| this.relations.push({ name }); | |
| return this; | |
| } | |
| relationQuery( | |
| name: string, | |
| query: SelectQuery, | |
| localKey = 'id', | |
| foreignKey = 'id', | |
| many = true, | |
| operation?: QueryOperation, | |
| ): this { | |
| this.relations.push({ name, query, localKey, foreignKey, many, operation }); | |
| return this; | |
| } | |
| relationAggregate( | |
| relationName: string, | |
| alias: string, | |
| query: SelectQuery, | |
| singleResult = true, | |
| operation?: QueryOperation, | |
| ): this { | |
| this.relationAggregates.push({ relationName, alias, query, singleResult, operation }); | |
| return this; | |
| } | |
| order(orderBy: OrderBy): this { | |
| this.orderItems.push(orderBy); | |
| return this; | |
| } | |
| select(items: string[]): this { | |
| this.selectItems.push(...items); | |
| return this; | |
| } | |
| enableAggregationCacheFor(cacheExpiredMillis: number): this { | |
| this.aggregationCache = AggregationCacheOptions.enabled(cacheExpiredMillis); | |
| return this; | |
| } | |
| propagateAggregationCache(cacheExpiredMillis: number): this { | |
| if (!this.aggregationCache) { | |
| this.aggregationCache = AggregationCacheOptions.enabled(0); | |
| } | |
| this.aggregationCache.propagate(cacheExpiredMillis); | |
| return this; | |
| } | |
| aggregate(functionName: string, field: string, alias: string): this { | |
| this.aggregateItems.push({ function: functionName, field, alias }); | |
| return this; | |
| } | |
| groupBy(item: string): this { | |
| this.groupByItems.push(item); | |
| return this; | |
| } | |
| } | |
| export class MutationQuery { | |
| constructor( | |
| public entity: string, | |
| public action: "Create" | "Update" | "Delete", | |
| public payload: any, | |
| public id?: any, | |
| public comment?: string, | |
| public expectedVersion?: number, | |
| ) {} | |
| } | |