Spaces:
Running
Running
| /** Local UI-search normalization. This is deliberately not a federation decoder. */ | |
| import { OrderBy, SelectQuery } from './ast'; | |
| export type SearchValueType = 'string' | 'number' | 'integer' | 'boolean' | 'date' | 'timestamp' | 'decimal' | 'unsupported'; | |
| export interface SearchModel { | |
| fields: Readonly<Record<string, SearchValueType>>; | |
| relations: Readonly<Record<string, string>>; | |
| } | |
| /** Model-derived scalar bindings. Native query keys are trusted, not input JSON. */ | |
| export interface GeneratedSearchModel extends SearchModel { | |
| queryFields: Readonly<Record<string, string>>; | |
| } | |
| /** | |
| * Default generated binding for scalar fields. Known relation paths require a | |
| * trusted application binding via mergeDynamicSearch, which owns authorization. | |
| * No relation predicate is guessed or silently dropped. | |
| */ | |
| export function mergeGeneratedScalarSearch( | |
| base: SelectQuery, | |
| source: unknown, | |
| models: Readonly<Record<string, GeneratedSearchModel>>, | |
| warn?: (warning: DynamicSearchWarning) => void, | |
| ): { query: SelectQuery; warnings: DynamicSearchWarning[] } { | |
| const field = (path: string): string => { | |
| if (path.includes('.')) throw new Error('Dynamic search requires a trusted relation binding'); | |
| const fields = models[base.entity]?.queryFields; | |
| if (!fields || !Object.prototype.hasOwnProperty.call(fields, path)) { | |
| throw new Error('Missing generated scalar search binding'); | |
| } | |
| return fields[path]; | |
| }; | |
| return mergeDynamicSearch(base, source, models, { | |
| filter: (path, predicate) => { | |
| const [operator, value] = Object.entries(predicate as Record<string, unknown>)[0]; | |
| if (value === null && operator !== '$eq' && operator !== '$ne') { | |
| throw new Error('Null supports only equality predicates'); | |
| } | |
| return { [field(path)]: predicate }; | |
| }, | |
| order: (path, direction) => direction === 'asc' ? OrderBy.asc(field(path)) : OrderBy.desc(field(path)), | |
| }, warn); | |
| } | |
| export interface DynamicSearchWarning { | |
| code: 'DYNAMIC_SEARCH_UNKNOWN_FIELD'; | |
| entity: string; | |
| clause: 'FILTER' | 'ORDER_BY'; | |
| fieldPath: string; | |
| } | |
| export interface DynamicSearchInput { | |
| filter?: Record<string, unknown>; | |
| orderBy?: Array<{ field: string; direction: 'asc' | 'desc' }>; | |
| } | |
| /** Trusted application adapters compile canonical model paths using native query APIs. */ | |
| export interface DynamicSearchBindings { | |
| filter(path: string, predicate: unknown): unknown; | |
| order(path: string, direction: 'asc' | 'desc'): OrderBy; | |
| } | |
| /** Add validated search clauses to an existing scoped query; never replace its policies. */ | |
| export function mergeDynamicSearch( | |
| base: SelectQuery, | |
| source: unknown, | |
| models: Readonly<Record<string, SearchModel>>, | |
| bindings: DynamicSearchBindings, | |
| warn: (warning: DynamicSearchWarning) => void = warning => console.warn({ ...warning, fieldPath: '<omitted>' }), | |
| ): { query: SelectQuery; warnings: DynamicSearchWarning[] } { | |
| const normalized = normalizeDynamicSearch(source, base.entity, models, () => {}); | |
| const filters = Object.entries(normalized.search.filter ?? {}) | |
| .map(([path, predicate]) => bindings.filter(path, predicate)); | |
| const orders = (normalized.search.orderBy ?? []).map(order => bindings.order(order.field, order.direction)); | |
| if (filters.some(filter => !object(filter))) throw new Error('Invalid trusted search filter binding'); | |
| if (orders.some(order => !(order instanceof OrderBy))) throw new Error('Invalid trusted search order binding'); | |
| const query = base.clone(); | |
| // Native providers also accept legacy generated _filters; retain those constraints explicitly. | |
| const legacy = (base as SelectQuery & { _filters?: unknown[] })._filters ?? []; | |
| const existing = [...legacy, ...(base.filterCondition ? [base.filterCondition] : [])]; | |
| if (filters.length || legacy.length) query.filter({ $and: [...existing, ...filters] }); | |
| // Append rather than replace stable default ordering. The application owns primary sort policy. | |
| query.orderItems.push(...orders); | |
| normalized.warnings.forEach(warning => warn({ ...warning })); | |
| return { query, warnings: normalized.warnings }; | |
| } | |
| const own = (object: object, key: string) => Object.prototype.hasOwnProperty.call(object, key); | |
| const object = (value: unknown): value is Record<string, unknown> => | |
| typeof value === 'object' && value !== null && !Array.isArray(value); | |
| const forbidden = new Set(['__proto__', 'prototype', 'constructor']); | |
| const operators = new Set(['$eq', '$ne', '$gt', '$gte', '$lt', '$lte', '$in', '$notIn', '$contains']); | |
| /** | |
| * Metadata, resource limits and warning sink must come from trusted application setup. | |
| * No caller-supplied context, limits, SQL, subqueries or arbitrary AST are accepted. | |
| * Returned clauses still require the normal query authorization/execution pipeline. | |
| */ | |
| export function normalizeDynamicSearch( | |
| source: string | unknown, | |
| entity: string, | |
| models: Readonly<Record<string, SearchModel>>, | |
| warn: (warning: DynamicSearchWarning) => void = warning => console.warn({ ...warning, fieldPath: '<omitted>' }), | |
| maxClauses = 100, | |
| ): { search: DynamicSearchInput; warnings: DynamicSearchWarning[] } { | |
| if (!Number.isSafeInteger(maxClauses) || maxClauses < 1) throw new Error('Invalid search limit'); | |
| if (!own(models, entity)) throw new Error('Unknown search entity'); | |
| let input: unknown; | |
| try { input = typeof source === 'string' ? JSON.parse(source) : source; } | |
| catch { throw new Error('Dynamic search requires valid JSON'); } | |
| if (!object(input) || Object.keys(input).some(key => !['filter', 'orderBy'].includes(key))) { | |
| throw new Error('Unsupported dynamic search input or control'); | |
| } | |
| if (input.filter !== undefined && !object(input.filter)) throw new Error('Invalid search filter'); | |
| if (input.orderBy !== undefined && !Array.isArray(input.orderBy)) throw new Error('Invalid search ordering'); | |
| const filters = Object.entries((input.filter ?? {}) as Record<string, unknown>); | |
| const orders = (input.orderBy ?? []) as unknown[]; | |
| if (filters.length + orders.length > maxClauses) throw new Error('Dynamic search exceeds clause limit'); | |
| const warnings: DynamicSearchWarning[] = []; | |
| const search: DynamicSearchInput = { filter: Object.create(null), orderBy: [] }; | |
| function fieldType(path: string): SearchValueType | undefined { | |
| const segments = path.split('.'); | |
| if (segments.length > 16 || segments.some(s => !s || s.startsWith('$') || forbidden.has(s))) { | |
| throw new Error('Invalid dynamic search field path'); | |
| } | |
| let model = models[entity]; | |
| for (const segment of segments.slice(0, -1)) { | |
| if (!own(model.relations, segment)) return undefined; | |
| const target = model.relations[segment]; | |
| if (!own(models, target)) throw new Error('Invalid trusted search relation metadata'); | |
| model = models[target]; | |
| } | |
| const field = segments[segments.length - 1]; | |
| return own(model.fields, field) ? model.fields[field] : undefined; | |
| } | |
| function missing(path: string, clause: DynamicSearchWarning['clause']) { | |
| warnings.push({ code: 'DYNAMIC_SEARCH_UNKNOWN_FIELD', entity, clause, fieldPath: path }); | |
| } | |
| function scalar(value: unknown, type: SearchValueType) { | |
| if (value === null) return; | |
| const valid = type === 'date' | |
| ? typeof value === 'string' && /^\d{4}-\d{2}-\d{2}$/.test(value) && !value.startsWith('0000-') | |
| && Number.isFinite(Date.parse(value + 'T00:00:00Z')) | |
| && new Date(value + 'T00:00:00Z').toISOString().slice(0, 10) === value | |
| : type === 'decimal' | |
| ? (typeof value === 'string' && /^[+-]?\d+(?:\.\d+)?$/.test(value)) | |
| || (typeof value === 'number' && Number.isFinite(value)) | |
| : type === 'integer' || type === 'timestamp' ? typeof value === 'number' && Number.isSafeInteger(value) | |
| : type === 'number' ? typeof value === 'number' && Number.isFinite(value) | |
| : typeof value === type; | |
| if (!valid) throw new Error('Invalid value for known search field'); | |
| } | |
| for (const [path, predicate] of filters) { | |
| const entries = object(predicate) ? Object.entries(predicate) : [['$eq', predicate]]; | |
| if (entries.length !== 1 || !operators.has(entries[0][0] as string)) { | |
| throw new Error('Unsupported or malformed dynamic search operator'); | |
| } | |
| const [operator, value] = entries[0]; | |
| if ((operator === '$in' || operator === '$notIn') && (!Array.isArray(value) || value.length > 1000)) { | |
| throw new Error('Invalid or oversized search value list'); | |
| } | |
| const type = fieldType(path); | |
| if (type === undefined) { missing(path, 'FILTER'); continue; } | |
| if (type === 'unsupported') throw new Error('Known search field has no supported scalar binding'); | |
| if (operator === '$contains' && type !== 'string') throw new Error('String operator requires a string field'); | |
| if (Array.isArray(value)) { | |
| if (operator !== '$in' && operator !== '$notIn') throw new Error('Unexpected search value list'); | |
| value.forEach(item => scalar(item, type)); | |
| } else scalar(value, type); | |
| search.filter![path] = { [operator as string]: Array.isArray(value) ? [...value] : value }; | |
| } | |
| for (const order of orders) { | |
| if (!object(order) || Object.keys(order).some(key => !['field', 'direction'].includes(key)) | |
| || typeof order.field !== 'string' || !['asc', 'desc'].includes(order.direction as string)) { | |
| throw new Error('Invalid dynamic search ordering'); | |
| } | |
| const type = fieldType(order.field); | |
| if (type === undefined) { missing(order.field, 'ORDER_BY'); continue; } | |
| if (type === 'unsupported') throw new Error('Known search field has no supported scalar binding'); | |
| search.orderBy!.push({ field: order.field, direction: order.direction as 'asc' | 'desc' }); | |
| } | |
| // Publish diagnostics only after all fatal validation completes; never log source values. | |
| warnings.forEach(warning => warn({ ...warning })); | |
| return { search, warnings }; | |
| } | |