@crossfox/query-handler 0.1.0

package/dist/rate-limit.d.ts

@@ -0,0 +1,2 @@
+import type { RateLimitConfig, QueryHandlerContext } from "./types";
+export declare function checkRateLimit(cfg: RateLimitConfig, ctx: QueryHandlerContext): Promise<void>;

package/dist/rate-limit.js

@@ -0,0 +1,14 @@
+import { err } from "./helpers";
+import { getQueryHandlerDefaults } from "./config";
+// ─────────────────────────────────────────────────────────────────────────────
+// Rate limit для queryHandler — поверх fixedWindowHit (или inject через configure).
+// ─────────────────────────────────────────────────────────────────────────────
+export async function checkRateLimit(cfg, ctx) {
+    const hit = getQueryHandlerDefaults().runtime.rateLimitHit;
+    if (hit(`qh:${cfg.key(ctx)}`, cfg.max, cfg.window)) {
+        if (cfg.onExceed)
+            cfg.onExceed();
+        else
+            err("Too many requests", 429);
+    }
+}

package/dist/rateLimit.d.ts

@@ -0,0 +1,8 @@
+/**
+ * In-memory fixed-window rate limit (общий Map на процесс).
+ * В кластере приложение может подменить через configureQueryHandler({ rateLimitHit }).
+ */
+export type RateLimitHitFn = (key: string, max: number, windowMs: number) => boolean;
+/** @returns true — лимит превышен */
+export declare function fixedWindowHit(key: string, max: number, windowMs: number): boolean;
+export declare function purgeRateLimitBuckets(): number;

package/dist/rateLimit.js

@@ -0,0 +1,29 @@
+/**
+ * In-memory fixed-window rate limit (общий Map на процесс).
+ * В кластере приложение может подменить через configureQueryHandler({ rateLimitHit }).
+ */
+const buckets = new Map();
+/** @returns true — лимит превышен */
+export function fixedWindowHit(key, max, windowMs) {
+    const now = Date.now();
+    const b = buckets.get(key);
+    if (b && b.reset > now) {
+        if (b.count >= max)
+            return true;
+        b.count++;
+        return false;
+    }
+    buckets.set(key, { count: 1, reset: now + windowMs });
+    return false;
+}
+export function purgeRateLimitBuckets() {
+    const now = Date.now();
+    let purged = 0;
+    for (const [k, v] of buckets) {
+        if (v.reset <= now) {
+            buckets.delete(k);
+            purged++;
+        }
+    }
+    return purged;
+}

package/dist/relation.d.ts

@@ -0,0 +1,2 @@
+import type { RelationConfig } from "./types";
+export declare function runHasManyRelations(items: unknown[], relationMap: Map<string, RelationConfig>, requested: string[], primaryKey: string): Promise<void>;

package/dist/relation.js

@@ -0,0 +1,64 @@
+import { resolveFieldEntry, sortDecode } from "./helpers";
+import { loadManyRelation, normalizeManyConfig } from "@crossfox/db/with-many";
+// ─────────────────────────────────────────────────────────────────────────────
+// hasMany — отдельный запрос с Promise.all
+// ─────────────────────────────────────────────────────────────────────────────
+export async function runHasManyRelations(items, relationMap, requested, primaryKey) {
+    if (!items.length)
+        return;
+    const toLoad = [...relationMap.entries()].filter(([name, cfg]) => cfg.model && (cfg.required || requested.includes(name)));
+    if (!toLoad.length)
+        return;
+    const independent = toLoad.filter(([, cfg]) => !cfg.dependsOn);
+    const dependent = toLoad.filter(([, cfg]) => cfg.dependsOn);
+    await Promise.all(independent.map(([name, cfg]) => runHasMany(name, cfg, items, primaryKey)));
+    for (const [name, cfg] of dependent) {
+        await runHasMany(name, cfg, items, primaryKey);
+    }
+}
+function relationToManyConfig(cfg, primaryKey) {
+    return normalizeManyConfig({
+        model: cfg.model,
+        on: [cfg.dataKey ?? primaryKey, cfg.foreign],
+        dependsOn: cfg.dependsOn,
+        as: cfg.as,
+    });
+}
+async function runHasMany(name, cfg, items, primaryKey) {
+    const root = items;
+    const owners = cfg.dependsOn
+        ? root.flatMap((r) => r[cfg.dependsOn] ?? [])
+        : root;
+    const manyCfg = relationToManyConfig(cfg, primaryKey);
+    const resultKey = cfg.as ?? name;
+    await loadManyRelation(owners, manyCfg, resultKey, undefined, async (relQ) => {
+        let q = relQ;
+        const selectFields = [];
+        if (cfg.fieldsForced?.length)
+            selectFields.push(...cfg.fieldsForced);
+        if (cfg.fields?.length) {
+            selectFields.push(...cfg.fields.map((f) => resolveFieldEntry(f)));
+        }
+        else if (cfg.fieldsDefault?.length) {
+            selectFields.push(...cfg.fieldsDefault);
+        }
+        if (selectFields.length)
+            q = q.select(selectFields);
+        if (cfg.filtersForced)
+            q = q.where(cfg.filtersForced);
+        if (cfg.filtersRequired)
+            q = q.where(cfg.filtersRequired);
+        if (cfg.sortsDefault) {
+            const [col, dir] = sortDecode(cfg.sortsDefault);
+            q = q.order(col, dir);
+        }
+        if (cfg.limit)
+            q = q.limit(cfg.limit);
+        if (cfg.query) {
+            const result = await cfg.query(q);
+            if (result !== false && result)
+                q = result;
+        }
+        return q;
+    });
+}

package/dist/schema.d.ts

@@ -0,0 +1,35 @@
+export declare const typeQuerySchema: import("@sinclair/typebox").TObject<{
+    page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    field: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    search: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    sort: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    relation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    after: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    before: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    scope: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    extend: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    filter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>>>;
+    count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    v: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+}>;
+export declare const queryTypeQuerySchema: {
+    query: import("@sinclair/typebox").TObject<{
+        page: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        field: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        search: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        sort: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        relation: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        after: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        before: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        scope: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        extend: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+        filter: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TRecord<import("@sinclair/typebox").TString, import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TAny>>>;
+        count: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+        v: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    }>;
+    beforeHandle: ({ request }: {
+        request: Request;
+    }) => void;
+};

package/dist/schema.js

@@ -0,0 +1,32 @@
+import { t } from "elysia";
+import { error } from "@crossfox/db";
+// ─────────────────────────────────────────────────────────────────────────────
+// Elysia query schema
+// ─────────────────────────────────────────────────────────────────────────────
+export const typeQuerySchema = t.Object({
+    page: t.Optional(t.Numeric()),
+    limit: t.Optional(t.Numeric()),
+    field: t.Optional(t.String()),
+    search: t.Optional(t.String()),
+    sort: t.Optional(t.String()),
+    relation: t.Optional(t.String()),
+    after: t.Optional(t.Numeric()),
+    before: t.Optional(t.Numeric()),
+    scope: t.Optional(t.String()),
+    extend: t.Optional(t.String()),
+    filter: t.Optional(t.Record(t.String(), t.Optional(t.Any()))),
+    count: t.Optional(t.Numeric()),
+    v: t.Optional(t.Numeric()),
+});
+export const queryTypeQuerySchema = {
+    query: typeQuerySchema,
+    beforeHandle: ({ request }) => {
+        const url = new URL(request.url);
+        const params = Array.from(url.searchParams.keys());
+        const allowedKeys = Object.keys(typeQuerySchema.properties);
+        const extraKeys = params.filter(p => !allowedKeys.includes(p.split('[')[0]));
+        if (extraKeys.length > 0) {
+            throw error(422, `Unknown parameters: ${extraKeys.join(', ')}`);
+        }
+    },
+};

package/dist/types.d.ts

@@ -0,0 +1,267 @@
+import type { QueryBuilder, SchemaFactory } from "@crossfox/db";
+export type SchemaFactoryLike = ((alias?: string) => unknown) & {
+    readonly table: string;
+    readonly tableWithoutAlias: string;
+    readonly alias: string;
+    readonly primaryKey: string;
+};
+export type InferSchemaRow<M extends SchemaFactoryLike> = M extends SchemaFactory<infer TRow, any, any> ? TRow extends Record<string, unknown> ? TRow : Record<string, unknown> : Record<string, unknown>;
+/** Имена scope из `createSchema({ scopes })` (если модель не сужена до `SchemaFactory<T>`). */
+export type InferSchemaScopeNames<M extends SchemaFactoryLike> = M extends SchemaFactory<any, any, infer TScopes extends string> ? TScopes : string;
+export type RowKeys<TRow extends Record<string, unknown>> = keyof TRow & string;
+export type LooseRowKey<TRow extends Record<string, unknown>> = RowKeys<TRow> | (string & {});
+export type SortValue<TRow extends Record<string, unknown>> = RowKeys<TRow> | `!${RowKeys<TRow>}` | `$${string}` | `!$${string}` | (string & {});
+/** Строка колонки или { alias: 'SQL выражение' } */
+export type FieldEntry = string | Record<string, string>;
+export type FilterDefMap<TRow extends Record<string, unknown>> = {
+    [K in RowKeys<TRow>]?: FilterFieldConfig<TRow>;
+} & {
+    [key: string]: FilterFieldConfig<TRow> | undefined;
+};
+export type ForcedWhereMap<TRow extends Record<string, unknown>> = Partial<{
+    [K in RowKeys<TRow>]: unknown;
+}>;
+export interface QueryHandlerUrlQuery {
+    page?: number;
+    limit?: number;
+    /**
+     * Сортировка. Префикс `!` = ASC, без = DESC.
+     * Кастомные: `$popular`, `!$weighted`.
+     */
+    sort?: string | string[];
+    search?: string;
+    filter?: Record<string, unknown>;
+    relation?: string | string[];
+    after?: number | string;
+    before?: number | string;
+    scope?: string | string[];
+    field?: string | string[];
+    extend?: string | string[];
+    /** `?count=0` — отключить total; `?count=1` — явно включить (по умолчанию total включён) */
+    count?: 0 | 1 | boolean;
+    /** ?v=1 — версия ответа */
+    v?: number;
+}
+export type QueryHandlerQueryArg = Partial<QueryHandlerUrlQuery> | Record<string, unknown>;
+export interface QueryHandlerContext {
+    page: number;
+    limit: number;
+    filters: Record<string, unknown>;
+    sort: string[];
+    search: string | undefined;
+    fields: string[];
+    relations: string[];
+    scopes: string[];
+    extends: string[];
+}
+/** Узкий контекст для beforeQuery / afterQuery (наблюдатели). */
+export type QueryHandlerHookCtx = Pick<QueryHandlerContext, 'page' | 'limit' | 'filters'>;
+export type FilterFieldType = 'string' | 'number' | 'date' | 'boolean';
+export type FilterOperator = 'between' | 'in' | 'nin' | 'like' | 'nlike' | 'gt' | 'lt' | 'lte' | 'gte' | 'eq' | 'neq' | 'null' | 'nnull';
+/** enum: массив | модель по primaryKey | { model, field } | async функция */
+export type FilterEnumConfig = unknown[] | SchemaFactoryLike | {
+    model: SchemaFactoryLike;
+    field: string;
+} | ((value: unknown) => void | Promise<void>);
+export type FilterFieldConfig<TRow extends Record<string, unknown> = Record<string, unknown>> = true | FilterFieldType | FilterFieldFullConfig<TRow> | ((q: QueryBuilder, value: unknown) => void | Promise<void>);
+export interface FilterFieldFullConfig<TRow extends Record<string, unknown> = Record<string, unknown>> {
+    /** Тип для парсинга из URL. Автоопределяется по имени поля. */
+    type?: FilterFieldType;
+    /** Разрешённые операторы. Дефолт — по типу. */
+    operators?: FilterOperator[];
+    /** Допустимые значения: массив / модель / { model, field } / функция */
+    enum?: FilterEnumConfig;
+    /** Реальная колонка в БД если отличается от ключа */
+    column?: string;
+    /** Разрешить null */
+    nullable?: boolean;
+    /** Автоматический `in` если передан список через запятую */
+    multiple?: boolean;
+    /** Дефолт если клиент не передал */
+    default?: unknown;
+    /** Активен только если указан другой фильтр */
+    dependsOn?: LooseRowKey<TRow> | LooseRowKey<TRow>[];
+    /** Взаимоисключающие фильтры */
+    conflictsWith?: LooseRowKey<TRow> | LooseRowKey<TRow>[];
+    /** Устаревший — логирует warning в dev */
+    deprecated?: string;
+    /**
+     * Включить/выключить. false → 403.
+     * Функция вызывается с контекстом запроса.
+     */
+    enable?: boolean | ((ctx: QueryHandlerContext) => boolean | Promise<boolean>);
+    /** Очистка ДО валидации */
+    sanitize?: (value: unknown) => unknown;
+    /** Трансформация ПОСЛЕ валидации, перед SQL */
+    transform?: (value: unknown) => unknown;
+    /** Кастомная валидация */
+    validate?: (value: unknown, ctx: QueryHandlerContext) => void | Promise<void>;
+    /** Описание для OpenAPI */
+    description?: string;
+    /** TTL кэша enum-проверки по модели (ms) */
+    cache?: number;
+}
+export interface RelationConfig<TRow extends Record<string, unknown> = Record<string, unknown>> {
+    /** Имя join из схемы → LEFT JOIN */
+    with?: string;
+    /** Всегда подключать без ?relation= */
+    required?: boolean;
+    /** true = LEFT JOIN, false = INNER JOIN */
+    nullable?: boolean;
+    /** Модель для отдельного запроса */
+    model?: SchemaFactoryLike;
+    /** Внешний ключ в связанной таблице */
+    foreign?: string;
+    /** Ключ в основной таблице (дефолт — primaryKey) */
+    dataKey?: string;
+    /** Максимум записей (только hasMany) */
+    limit?: number;
+    fields?: FieldEntry[];
+    fieldsDefault?: string[];
+    fieldsForced?: string[];
+    filters?: FilterDefMap<TRow>;
+    filtersDefault?: ForcedWhereMap<TRow>;
+    filtersRequired?: ForcedWhereMap<TRow>;
+    filtersForced?: ForcedWhereMap<TRow>;
+    sorts?: SortValue<TRow> | ReadonlyArray<SortValue<TRow>>;
+    sortsDefault?: string;
+    /**
+     * Хук над QueryBuilder.
+     * return void/builder → стандартная логика поверх.
+     * return false → полная замена.
+     */
+    query?: (q: QueryBuilder) => QueryBuilder | void | false | Promise<QueryBuilder | void | false>;
+    /** Выполнять только после указанного relation */
+    dependsOn?: string | string[];
+    /** Псевдоним ключа в результирующем объекте */
+    as?: string;
+}
+export type RelationMapInput<TRow extends Record<string, unknown> = Record<string, unknown>> = {
+    [name: string]: RelationConfig<TRow> | false;
+} | ReadonlyArray<string>;
+export interface ExtendHooks {
+    before?: (q: QueryBuilder, ctx: QueryHandlerContext) => void | Promise<void>;
+    after?: (items: unknown[], ctx: QueryHandlerContext) => unknown[] | Promise<unknown[]>;
+    afterEach?: (item: unknown, index: number, ctx: QueryHandlerContext) => unknown | Promise<unknown>;
+}
+export type ScopeHandler = (q: QueryBuilder, param?: string, ctx?: QueryHandlerContext) => void | Promise<void>;
+/** Shorthand в `scopes`: применить `q.scope(имя ключа)` */
+export type ScopeShorthand = true;
+export type ScopeDefMap<TSchemaScopeNames extends string = string> = {
+    [K in TSchemaScopeNames]?: ScopeHandler | ScopeShorthand | false;
+} & {
+    [scopeName: string]: ScopeHandler | ScopeShorthand | false;
+};
+export type ApplyObject = Partial<Omit<QueryHandlerOptions, 'apply'>>;
+export type ApplyFn = (options: QueryHandlerOptions) => ApplyObject | void | false | Promise<ApplyObject | void | false>;
+export type ApplyEntry = ApplyObject | ApplyFn | null | false | undefined;
+export interface CursorPaginateConfig {
+    field?: string;
+    /** По умолчанию `true`. `false` или `?count=0` отключают COUNT. */
+    allowCount?: boolean;
+    stable?: boolean;
+}
+export interface ChunkConfig {
+    size: number;
+    handler: (items: unknown[], index: number, meta: ChunkMeta) => void | Promise<void>;
+    onDone?: (meta: ChunkMeta) => void | Promise<void>;
+}
+export interface ChunkMeta {
+    processed: number;
+    total: number;
+    index: number;
+}
+export type RandomizeConfig = boolean | {
+    type: 'weighted';
+    field: string;
+    limit?: number;
+} | {
+    type: 'custom';
+    fn: (q: QueryBuilder) => void;
+    sort?: (items: unknown[]) => unknown[];
+};
+export interface RateLimitConfig {
+    window: number;
+    max: number;
+    key: (ctx: QueryHandlerContext) => string;
+    onExceed?: () => never;
+}
+export interface QueryHandlerOptions<TRow extends Record<string, unknown> = Record<string, unknown>, TSchemaScopeNames extends string = string> {
+    query?: QueryBuilder | null;
+    apply?: ApplyEntry[];
+    fields?: ReadonlyArray<FieldEntry>;
+    fieldsDefault?: ReadonlyArray<string>;
+    fieldsForced?: ReadonlyArray<string>;
+    sorts?: SortValue<TRow> | ReadonlyArray<SortValue<TRow>>;
+    sortsDefault?: SortValue<TRow>;
+    sortsCustom?: Record<string, (q: QueryBuilder, direction: 'ASC' | 'DESC', ctx: QueryHandlerContext) => void | false | Promise<void | false>>;
+    search?: ReadonlyArray<LooseRowKey<TRow>> | ((q: QueryBuilder, search: string, ctx: QueryHandlerContext) => void | Promise<void>);
+    filters?: FilterDefMap<TRow>;
+    filtersDefault?: ForcedWhereMap<TRow>;
+    filtersRequired?: ForcedWhereMap<TRow>;
+    filtersForced?: ForcedWhereMap<TRow>;
+    requiredFilters?: ReadonlyArray<LooseRowKey<TRow>>;
+    strictFilters?: boolean;
+    /** Объект конфигов или shorthand: `['orders', 'profile']` → `{ with: name }` */
+    relations?: RelationMapInput<TRow>;
+    /** Подключать, если клиент не передал `?relation=` */
+    relationsDefault?: string | string[] | ReadonlyArray<string>;
+    cursorPaginate?: boolean | string | CursorPaginateConfig;
+    withTotal?: boolean;
+    maxLimit?: number;
+    /** `true` → `(q) => q.scope(имя ключа)` */
+    scopes?: ScopeDefMap<TSchemaScopeNames>;
+    /** Применять, если клиент не передал `?scope=` */
+    scopesDefault?: string | string[] | ReadonlyArray<string>;
+    extends?: Record<string, ExtendHooks | false>;
+    before?: (q: QueryBuilder, ctx: QueryHandlerContext) => void | Promise<void>;
+    beforeQuery?: (q: QueryBuilder, ctx: QueryHandlerHookCtx) => void | Promise<void>;
+    after?: (items: unknown[], ctx: QueryHandlerContext) => unknown[] | Promise<unknown[]>;
+    afterQuery?: (items: unknown[], total: number, ctx: QueryHandlerHookCtx) => void | Promise<void>;
+    afterEach?: (item: unknown, index: number, ctx: QueryHandlerContext) => unknown | Promise<unknown>;
+    transform?: (row: unknown, index: number) => unknown;
+    fieldsTransform?: Record<string, (value: unknown, item: unknown) => unknown>;
+    ignoreQueryFields?: boolean;
+    aggregate?: Record<string, string>;
+    groupBy?: ReadonlyArray<string>;
+    having?: Record<string, unknown>;
+    distinct?: boolean;
+    mode?: 'one' | 'many';
+    transaction?: unknown;
+    onEmpty?: 'error' | 'null' | ((ctx: QueryHandlerContext) => unknown[] | Promise<unknown[]>);
+    versions?: Record<number, (items: unknown[]) => unknown[]>;
+    chunk?: ChunkConfig;
+    randomize?: RandomizeConfig;
+    rateLimit?: RateLimitConfig;
+    cacheTtl?: number;
+    cacheKey?: string | ((ctx: QueryHandlerContext) => string);
+    meta?: boolean;
+    mock?: unknown[];
+    initial?: Partial<Omit<QueryHandlerUrlQuery, 'field' | 'filter'> & {
+        fields?: ReadonlyArray<LooseRowKey<TRow>>;
+        filters?: ForcedWhereMap<TRow>;
+    }>;
+    limits?: {
+        searchMinLength?: number;
+        searchMaxLength?: number;
+        allowedOperators?: FilterOperator[];
+        maxSortFields?: number;
+        emptyValues?: unknown[];
+    };
+    expose?: {
+        total?: boolean;
+        page?: boolean;
+        pageSize?: boolean;
+        meta?: boolean;
+    };
+}
+export type QueryHandlerCallOptions<M extends SchemaFactoryLike> = QueryHandlerOptions<InferSchemaRow<M>, InferSchemaScopeNames<M>>;
+export type QueryHandlerBuilderOptions = QueryHandlerOptions & {
+    query: QueryBuilder;
+};
+export type QueryHandlerFilter<M extends SchemaFactoryLike> = FilterDefMap<InferSchemaRow<M>>;
+export type QueryHandlerFilterForced<M extends SchemaFactoryLike> = ForcedWhereMap<InferSchemaRow<M>>;
+export type QueryHandlerInitial<M extends SchemaFactoryLike> = QueryHandlerOptions<InferSchemaRow<M>>['initial'];
+export type WorkerOptions = QueryHandlerOptions & {
+    model?: SchemaFactoryLike;
+};

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/util.d.ts

@@ -0,0 +1,4 @@
+/** Минимальные хелперы без зависимости от app utils. */
+export declare function toArray<T>(value: T | T[]): T[];
+export declare function spliter(str: string, separator: string): string[];
+export declare function isAllowed(input: string[], whitelist: string[]): boolean;

package/dist/util.js

@@ -0,0 +1,11 @@
+/** Минимальные хелперы без зависимости от app utils. */
+export function toArray(value) {
+    return Array.isArray(value) ? value : value ? [value] : [];
+}
+export function spliter(str, separator) {
+    return str.split(separator).map((v) => v.trim());
+}
+export function isAllowed(input, whitelist) {
+    const whiteSet = new Set(whitelist);
+    return input.every((item) => whiteSet.has(item));
+}

package/dist/worker.d.ts

@@ -0,0 +1,19 @@
+import type { QueryBuilder } from "@crossfox/db";
+import type { WorkerOptions, QueryHandlerOptions, QueryHandlerContext, QueryHandlerHookCtx } from "./types";
+export declare function queryHandlerWorker(query: import("./types").QueryHandlerQueryArg, optionsArgs?: WorkerOptions): QueryHandlerWorkerResult;
+/** Публичный результат queryHandler (без Symbol brand в .d.ts). */
+export type QueryHandlerWorkerResult = {
+    $q: QueryBuilder;
+    items: unknown[];
+    total: number;
+    nextId: unknown;
+    prevId: unknown;
+    context: QueryHandlerContext | null;
+    aggregate: Record<string, unknown> | null;
+    addField(name: string | string[]): QueryHandlerWorkerResult;
+    beforeQuery(fn: (q: QueryBuilder, ctx: QueryHandlerHookCtx) => void | Promise<void>): QueryHandlerWorkerResult;
+    when(condition: boolean | (() => boolean), fn: (options: QueryHandlerOptions) => Partial<QueryHandlerOptions> | void): QueryHandlerWorkerResult;
+    clone(patch: Partial<QueryHandlerOptions>): QueryHandlerWorkerResult;
+    query(): Promise<unknown[]>;
+    run(): Promise<Record<string, unknown>>;
+};