@crossfox/query-handler 0.1.0

package/dist/worker.js

@@ -0,0 +1,560 @@
+import { toArray, spliter, isAllowed } from "./util";
+import { getQueryHandlerDefaults } from "./config";
+import { SIMPLE_ID_RE, CUSTOM_SORT_RE, QUERY_HANDLER_BRAND } from "./constants";
+import { err, mergeOptions, parsePositiveInt, resolveFieldEntry, fieldEntryName, qualifySelectField, qualifyWhereColumn, assertSafeColumnRef, sortDecode, isSortAllowed, normalizeRelationMap, normalizeScopeMap, resolveNameList, resolveItems, resolveWithTotal, resolveCursorAllowCount, } from "./helpers";
+import { cacheGet, cacheSet } from "./cache";
+import { checkRateLimit } from "./rate-limit";
+import { runCursor } from "./cursor";
+import { applyFilters } from "./filter";
+import { runHasManyRelations } from "./relation";
+// ─────────────────────────────────────────────────────────────────────────────
+// Worker
+// ─────────────────────────────────────────────────────────────────────────────
+export function queryHandlerWorker(query, optionsArgs = {}) {
+    const globalDefaults = getQueryHandlerDefaults();
+    let options = {
+        maxLimit: globalDefaults.runtime.maxLimit,
+        strictFilters: globalDefaults.runtime.strictFilters,
+        limits: {
+            ...globalDefaults.runtime.limits,
+            ...optionsArgs.limits,
+        },
+        ...optionsArgs,
+        withTotal: optionsArgs.withTotal ?? globalDefaults.runtime.count ?? true,
+    };
+    const queryRaw = query;
+    const ignoreQueryFields = options.ignoreQueryFields
+        ?? globalDefaults.runtime.ignoreQueryFields
+        ?? false;
+    const queryForMerge = ignoreQueryFields
+        ? Object.fromEntries(Object.entries(queryRaw).filter(([k]) => k !== 'field'))
+        : queryRaw;
+    const initialMerged = (() => {
+        const src = options.initial;
+        if (!src)
+            return globalDefaults.initial;
+        const { fields: initialFields, filters: initialFilters, ...rest } = src;
+        return {
+            ...globalDefaults.initial,
+            ...rest,
+            ...(initialFields !== undefined ? { field: initialFields } : {}),
+            ...(initialFilters !== undefined ? { filter: initialFilters } : {}),
+        };
+    })();
+    let { page, limit, field, sort = [], search, filter = {}, relation: relationParam = [], after, before, scope: scopeParam = '', extend: extendParam = '', count: clientCount, v: versionParam, } = {
+        ...globalDefaults.queryMerge,
+        ...initialMerged,
+        ...queryForMerge,
+    };
+    page = parsePositiveInt(page, 'page') ?? globalDefaults.queryMerge.page;
+    limit = parsePositiveInt(limit, 'limit') ?? globalDefaults.queryMerge.limit;
+    options.withTotal = resolveWithTotal(options.withTotal, globalDefaults.runtime.count, clientCount);
+    // ── FIELD + MODEL (сразу — $q доступен до query()) ───────────
+    let resolvedField = [];
+    if (field?.length) {
+        resolvedField = toArray(typeof field === 'string' ? spliter(field, ',') : field);
+    }
+    else if (options.fieldsDefault?.length) {
+        resolvedField = [...options.fieldsDefault];
+    }
+    else if (options.fields?.length) {
+        resolvedField = [...options.fields];
+    }
+    if (options.fields?.length && resolvedField.length) {
+        const allowedNames = options.fields.map(fieldEntryName);
+        const requestedNames = resolvedField.map(fieldEntryName);
+        if (!isAllowed(requestedNames, allowedNames))
+            err('Field is not allowed: ' + requestedNames.join(', '));
+    }
+    if (!resolvedField.length)
+        resolvedField = ['*'];
+    let $q;
+    let baseRef;
+    let schemaRow;
+    if (options.model) {
+        schemaRow = options.model();
+        baseRef = schemaRow.alias || schemaRow.tableWithoutAlias;
+        const selectList = [
+            ...resolvedField.map(f => resolveFieldEntry(f, baseRef)),
+            ...(options.fieldsForced ?? []).map(f => qualifySelectField(f, baseRef)),
+        ];
+        $q = schemaRow.select(selectList);
+    }
+    else if (options.query) {
+        $q = options.query;
+        const selectList = [
+            ...resolvedField.map(f => resolveFieldEntry(f)),
+            ...(options.fieldsForced ?? []),
+        ];
+        if (selectList.length && selectList[0] !== '*')
+            $q.select(...selectList);
+    }
+    else {
+        err('Model or query is required', 500);
+    }
+    const beforeQueryHooks = [];
+    if (globalDefaults.beforeQuery)
+        beforeQueryHooks.push(globalDefaults.beforeQuery);
+    if (options.beforeQuery)
+        beforeQueryHooks.push(options.beforeQuery);
+    if (options.before) {
+        beforeQueryHooks.push((q, hookCtx) => options.before(q, hookCtx));
+    }
+    // ─────────────────────────────────────────────────────────────
+    // Handler object
+    // ─────────────────────────────────────────────────────────────
+    const handler = {
+        [QUERY_HANDLER_BRAND]: true,
+        $q,
+        items: [],
+        total: -1,
+        nextId: null,
+        prevId: null,
+        context: null,
+        aggregate: null,
+        // Защита от параллельных вызовов
+        _promise: null,
+        _cacheKey: null,
+        addField(name) {
+            const rawList = toArray(name).map(String);
+            if (options.fields?.length) {
+                const allowedNames = options.fields.map(fieldEntryName);
+                if (!isAllowed(rawList, allowedNames))
+                    err('Cannot add disallowed field: ' + rawList.join(', '));
+            }
+            $q.select(...rawList.map(n => qualifySelectField(n, baseRef)));
+            return this;
+        },
+        beforeQuery(fn) {
+            beforeQueryHooks.push(fn);
+            return this;
+        },
+        /** Условный merge опций */
+        when(condition, fn) {
+            const cond = typeof condition === 'function' ? condition() : condition;
+            if (cond) {
+                const patch = fn(options);
+                if (patch)
+                    options = mergeOptions(options, patch);
+            }
+            return this;
+        },
+        /** Клонировать handler с новыми опциями */
+        clone(patch) {
+            return queryHandlerWorker(query, mergeOptions(options, patch));
+        },
+        query() {
+            return (handler._promise ??= handler._run());
+        },
+        async run() {
+            if (!handler._promise)
+                await handler.query();
+            const expose = options.expose ?? {};
+            const isCursor = !!options.cursorPaginate;
+            const base = {
+                items: handler.items,
+            };
+            if (isCursor) {
+                const doCount = resolveCursorAllowCount(options.cursorPaginate, clientCount);
+                if (doCount && expose.total !== false)
+                    base.total = handler.total;
+                base.nextId = handler.nextId;
+                base.prevId = handler.prevId;
+                base.hasMore = handler.nextId !== null;
+                if (expose.pageSize !== false)
+                    base.pageSize = limit;
+            }
+            else if (options.withTotal) {
+                if (expose.total !== false)
+                    base.total = handler.total;
+                if (expose.page !== false)
+                    base.page = page;
+                if (expose.pageSize !== false)
+                    base.pageSize = limit;
+            }
+            if (handler.aggregate)
+                base.aggregate = handler.aggregate;
+            if (options.meta && expose.meta !== false) {
+                base._meta = {
+                    appliedFilters: handler.context?.filters,
+                    appliedSort: handler.context?.sort,
+                    fields: handler.context?.fields,
+                    relations: handler.context?.relations,
+                };
+            }
+            return base;
+        },
+        // ─────────────────────────────────────────────────────────
+        // Внутренние методы
+        // ─────────────────────────────────────────────────────────
+        async _run() {
+            // ── Apply ─────────────────────────────────────────────
+            if (options.apply?.length) {
+                for (const entry of options.apply) {
+                    if (!entry)
+                        continue;
+                    if (typeof entry === 'function') {
+                        const patch = await entry(options);
+                        if (patch && typeof patch === 'object') {
+                            options = mergeOptions(options, patch);
+                        }
+                    }
+                    else if (typeof entry === 'object') {
+                        options = mergeOptions(options, entry);
+                    }
+                }
+            }
+            // ── Mock ──────────────────────────────────────────────
+            if (options.mock) {
+                if (!globalDefaults.runtime.allowMock)
+                    err('mock is not allowed in production');
+                handler.items = options.mock;
+                const mockCtx = buildEmptyCtx();
+                await handler._postProcess(mockCtx);
+                return handler.items;
+            }
+            // ── DISTINCT / TRANSACTION ────────────────────────────
+            if (options.distinct)
+                $q.distinct?.();
+            if (options.transaction)
+                $q.transaction?.(options.transaction);
+            // ── CURSOR CONFIG ─────────────────────────────────────
+            const cursorCfg = !options.cursorPaginate ? null
+                : options.cursorPaginate === true ? {}
+                    : typeof options.cursorPaginate === 'string' ? { field: options.cursorPaginate }
+                        : options.cursorPaginate;
+            const cursorField = cursorCfg?.field?.trim()
+                ? assertSafeColumnRef(cursorCfg.field, 'cursorPaginate.field')
+                : schemaRow?.primaryKey ?? 'id';
+            // ── RELATION: JOIN ────────────────────────────────────
+            const requestedRel = resolveNameList(relationParam, options.relationsDefault);
+            const relationMap = normalizeRelationMap(options.relations);
+            const scopeMap = normalizeScopeMap(options.scopes);
+            const appliedRelNames = [];
+            // required — всегда
+            for (const [name, cfg] of relationMap) {
+                if (cfg.required && cfg.with) {
+                    $q.with(cfg.with);
+                    if (cfg.fieldsForced?.length)
+                        $q.select(...cfg.fieldsForced);
+                    appliedRelNames.push(name);
+                }
+            }
+            // клиентские
+            for (const rel of requestedRel) {
+                if (!SIMPLE_ID_RE.test(rel))
+                    err(`Relation name invalid: "${rel}"`);
+                const cfg = relationMap.get(rel);
+                if (!cfg)
+                    err(`Relation "${rel}" is not allowed`);
+                if (cfg.with && !appliedRelNames.includes(rel)) {
+                    if (!options.model)
+                        err(`Relation "${rel}" requires model`, 500);
+                    $q.with(cfg.with);
+                    const selects = cfg.fields?.length
+                        ? cfg.fields.map(f => resolveFieldEntry(f))
+                        : cfg.fieldsDefault?.length
+                            ? [...cfg.fieldsDefault]
+                            : [];
+                    if (selects.length)
+                        $q.select(...selects);
+                    if (cfg.fieldsForced?.length)
+                        $q.select(...cfg.fieldsForced);
+                    appliedRelNames.push(rel);
+                }
+            }
+            // ── SCOPE ─────────────────────────────────────────────
+            const appliedScopes = [];
+            const requestedScopes = resolveNameList(scopeParam, options.scopesDefault);
+            if (scopeMap.size && requestedScopes.length) {
+                for (const raw of requestedScopes) {
+                    const idx = raw.indexOf(':');
+                    const name = (idx === -1 ? raw : raw.slice(0, idx)).trim();
+                    const param = idx === -1 ? undefined : raw.slice(idx + 1);
+                    if (!SIMPLE_ID_RE.test(name))
+                        err(`Scope name invalid: "${raw}"`);
+                    const scopeFn = scopeMap.get(name);
+                    if (scopeFn === undefined)
+                        err(`Scope "${name}" is not allowed`);
+                    await scopeFn($q, param);
+                    appliedScopes.push(name);
+                }
+            }
+            // ── EXTEND: BEFORE ────────────────────────────────────
+            const requestedExtend = toArray(extendParam)
+                .flatMap((s) => s.split(','))
+                .map((s) => s.trim())
+                .filter(Boolean);
+            const appliedExtends = [];
+            if (options.extends && requestedExtend.length) {
+                const partialCtx = buildEmptyCtx();
+                for (const name of requestedExtend) {
+                    if (!SIMPLE_ID_RE.test(name))
+                        err(`Extend name invalid: "${name}"`);
+                    const ext = options.extends[name];
+                    if (!ext)
+                        err(`Extend "${name}" is not allowed`);
+                    if (ext.before) {
+                        await ext.before($q, partialCtx);
+                    }
+                    appliedExtends.push(name);
+                }
+            }
+            // ── SORT ──────────────────────────────────────────────
+            const sortWhitelist = toArray(options.sorts).map(String);
+            const rawSort = toArray(sort).flatMap((s) => s.split(','));
+            const sortTokens = rawSort.length > 0 ? rawSort
+                : options.sortsDefault ? [String(options.sortsDefault)]
+                    : sortWhitelist.length ? [sortWhitelist[0]]
+                        : [];
+            const maxSortFields = options.limits?.maxSortFields;
+            if (maxSortFields && sortTokens.length > maxSortFields)
+                err(`Too many sort fields (max ${maxSortFields})`);
+            if (!cursorCfg) {
+                for (const token of sortTokens) {
+                    const [col, dir] = sortDecode(token);
+                    if (col === '*')
+                        err('Sort column cannot be *');
+                    if (CUSTOM_SORT_RE.test(token)) {
+                        const customName = col.slice(1); // убираем $
+                        const customFn = options.sortsCustom?.[customName];
+                        if (!customFn)
+                            err(`Custom sort "${customName}" is not supported`);
+                        const partialCtx = buildEmptyCtx();
+                        await customFn($q, dir, partialCtx);
+                    }
+                    else {
+                        if (!isSortAllowed(col, sortWhitelist))
+                            err(`Sort "${col}" not supported`);
+                        $q.order(qualifyWhereColumn(col, baseRef), dir);
+                    }
+                }
+            }
+            // ── SEARCH ────────────────────────────────────────────
+            if (search) {
+                const minLen = options.limits?.searchMinLength ?? 2;
+                const maxLen = options.limits?.searchMaxLength ?? 500;
+                if (search.length < minLen)
+                    err(`Search query too short (min ${minLen})`);
+                if (search.length > maxLen)
+                    err(`Search query too long (max ${maxLen})`);
+                if (!options.search)
+                    err('Search is not supported');
+                const partialCtx = buildEmptyCtx();
+                if (typeof options.search === 'function') {
+                    await options.search($q, search, partialCtx);
+                }
+                else {
+                    await $q.search(toArray(options.search), search);
+                }
+            }
+            // ── FILTER ────────────────────────────────────────────
+            const partialCtx = {
+                page, limit, sort: sortTokens,
+                search: search ?? undefined,
+                fields: resolvedField.map(f => typeof f === 'string' ? f : Object.keys(f)[0]),
+                relations: appliedRelNames,
+                scopes: appliedScopes,
+                extends: appliedExtends,
+            };
+            const { appliedFilters } = await applyFilters($q, filter, options, partialCtx, baseRef);
+            // ── GROUPBY / HAVING ──────────────────────────────────
+            if (options.groupBy?.length)
+                $q.groupBy?.(...options.groupBy);
+            if (options.having)
+                $q.having?.(options.having);
+            // ── CONTEXT ───────────────────────────────────────────
+            const ctx = {
+                ...partialCtx,
+                filters: appliedFilters,
+            };
+            handler.context = ctx;
+            // ── BEFORE QUERY HOOKS ────────────────────────────────
+            if (beforeQueryHooks.length) {
+                const hookCtx = { page, limit, filters: appliedFilters };
+                for (const hook of beforeQueryHooks)
+                    await hook($q, hookCtx);
+            }
+            // ── RATE LIMIT ────────────────────────────────────────
+            if (options.rateLimit)
+                await checkRateLimit(options.rateLimit, ctx);
+            // ── CACHE LOOKUP ──────────────────────────────────────
+            if (options.cacheTtl && options.cacheTtl > 0) {
+                const cacheKey = typeof options.cacheKey === 'function'
+                    ? options.cacheKey(ctx)
+                    : options.cacheKey ?? `qh:${baseRef ?? 'unknown'}:${JSON.stringify(ctx)}`;
+                const cached = cacheGet(cacheKey);
+                if (cached) {
+                    handler.items = cached.value;
+                    handler.total = cached.total;
+                    return handler.items;
+                }
+                handler._cacheKey = cacheKey;
+            }
+            // ── LIMIT CHECK ───────────────────────────────────────
+            if (limit > (options.maxLimit ?? Infinity))
+                err(`Limit exceeds ${options.maxLimit}`);
+            // ── RANDOMIZE ─────────────────────────────────────────
+            if (options.randomize) {
+                const rnd = options.randomize;
+                if (rnd === true) {
+                    $q.orderByRaw?.('RAND()');
+                }
+                else if (typeof rnd === 'object' && rnd.type === 'weighted') {
+                    $q.orderByRaw?.(`RAND() * ${rnd.field} DESC`);
+                    if (rnd.limit)
+                        $q.limit(rnd.limit);
+                }
+                else if (typeof rnd === 'object' && rnd.type === 'custom') {
+                    rnd.fn($q);
+                }
+            }
+            // ── CHUNK ─────────────────────────────────────────────
+            if (options.chunk) {
+                await handler._runChunk($q);
+                return handler.items;
+            }
+            // ── EXECUTE ───────────────────────────────────────────
+            if (cursorCfg !== null) {
+                const doCount = resolveCursorAllowCount(cursorCfg, clientCount);
+                const displayDir = sortTokens[0] ? sortDecode(sortTokens[0])[1] : 'DESC';
+                const res = await runCursor($q, after, before, limit, cursorField, { ...cursorCfg, allowCount: doCount }, displayDir);
+                handler.items = res.items;
+                handler.total = res.total;
+                handler.nextId = res.nextId;
+                handler.prevId = res.prevId;
+            }
+            else {
+                const res = options.withTotal
+                    ? await $q.paginate(page, limit)
+                    : { items: await $q.page(page, limit).run(), total: -2 };
+                handler.items = res.items;
+                handler.total = res.total;
+            }
+            // ── AGGREGATE ─────────────────────────────────────────
+            if (options.aggregate) {
+                const aggClone = $q.clone({ from: true, where: true, join: true, groupBy: true });
+                const aggSelects = Object.entries(options.aggregate)
+                    .map(([alias, expr]) => `${expr} AS ${alias}`);
+                handler.aggregate = await aggClone.select(aggSelects).first() ?? {};
+            }
+            // ── CACHE SAVE ────────────────────────────────────────
+            if (options.cacheTtl && handler._cacheKey) {
+                cacheSet(handler._cacheKey, handler.items, handler.total, options.cacheTtl);
+                handler._cacheKey = null;
+            }
+            // ── hasMany relations ─────────────────────────────────
+            await runHasManyRelations(handler.items, relationMap, requestedRel, schemaRow?.primaryKey ?? 'id');
+            await handler._postProcess(ctx);
+            return handler.items;
+        },
+        async _postProcess(ctx) {
+            // ── EXTEND: AFTER / AFTER_EACH ────────────────────────
+            if (options.extends && ctx.extends.length) {
+                for (const name of ctx.extends) {
+                    const ext = options.extends[name];
+                    if (!ext)
+                        continue;
+                    const hooks = ext;
+                    if (hooks.after) {
+                        handler.items = await resolveItems(hooks.after(handler.items, ctx));
+                    }
+                    if (hooks.afterEach) {
+                        handler.items = await Promise.all(handler.items.map((it, idx) => hooks.afterEach(it, idx, ctx)));
+                    }
+                }
+            }
+            // ── AFTER HOOK ────────────────────────────────────────
+            if (options.after) {
+                const next = await resolveItems(options.after(handler.items, ctx));
+                handler.items = next ?? handler.items;
+            }
+            // ── AFTER EACH ────────────────────────────────────────
+            if (options.afterEach) {
+                handler.items = await Promise.all(handler.items.map((it, idx) => options.afterEach(it, idx, ctx)));
+            }
+            // ── ROW TRANSFORM ─────────────────────────────────────
+            if (options.transform) {
+                handler.items = handler.items.map(options.transform);
+            }
+            // ── AFTER QUERY (наблюдатель, без изменения items) ─────
+            const afterCtx = { page, limit, filters: ctx.filters };
+            if (globalDefaults.afterQuery)
+                await globalDefaults.afterQuery(handler.items, handler.total, afterCtx);
+            if (options.afterQuery)
+                await options.afterQuery(handler.items, handler.total, afterCtx);
+            // ── FIELD TRANSFORM ───────────────────────────────────
+            if (options.fieldsTransform) {
+                const transforms = options.fieldsTransform;
+                handler.items = handler.items.map((item) => {
+                    const out = { ...item };
+                    for (const [f, fn] of Object.entries(transforms)) {
+                        if (f in out)
+                            out[f] = fn(out[f], item);
+                    }
+                    return out;
+                });
+            }
+            // ── RANDOMIZE: кастомная досортировка ─────────────────
+            if (options.randomize &&
+                typeof options.randomize === 'object' &&
+                options.randomize.type === 'custom' &&
+                options.randomize.sort) {
+                handler.items = options.randomize.sort(handler.items);
+            }
+            // ── VERSIONS ──────────────────────────────────────────
+            if (options.versions && versionParam !== undefined) {
+                const transformer = options.versions[versionParam];
+                if (transformer)
+                    handler.items = transformer(handler.items);
+            }
+            // ── ON EMPTY ──────────────────────────────────────────
+            if (!handler.items.length && options.onEmpty) {
+                if (options.onEmpty === 'error')
+                    err('No results found', 404);
+                else if (options.onEmpty === 'null')
+                    handler.items = [];
+                else
+                    handler.items = await resolveItems(options.onEmpty(ctx));
+            }
+        },
+        async _runChunk($q) {
+            const cfg = options.chunk;
+            let offset = 0, processed = 0;
+            const total = options.withTotal
+                ? await $q.clone({ from: true, where: true, join: true }).count()
+                : -1;
+            while (true) {
+                const rows = await $q
+                    .clone({ from: true, where: true, join: true, order: true })
+                    .limit(cfg.size, offset)
+                    .run();
+                if (!rows.length)
+                    break;
+                processed += rows.length;
+                const index = Math.floor(offset / cfg.size);
+                await cfg.handler(rows, index, { processed, total, index });
+                offset += cfg.size;
+                if (rows.length < cfg.size)
+                    break;
+            }
+            const finalIndex = Math.floor(offset / cfg.size);
+            if (cfg.onDone)
+                await cfg.onDone({ processed, total, index: finalIndex });
+        },
+    };
+    function buildEmptyCtx() {
+        return {
+            page, limit,
+            filters: {},
+            sort: [],
+            search: undefined,
+            fields: [],
+            relations: [],
+            scopes: [],
+            extends: [],
+        };
+    }
+    // Explicit any: declaration emit can't name private Symbol brand key.
+    return handler;
+}

package/package.json

@@ -0,0 +1,92 @@
+{
+  "name": "@crossfox/query-handler",
+  "version": "0.1.0",
+  "description": "HTTP list API layer on @crossfox/db: filters, sort, search, relations, cursor pagination, cache, optional Elysia plugin.",
+  "license": "PolyForm-Noncommercial-1.0.0",
+  "author": "Oleksii Fursov <nodepro777@gmail.com>",
+  "homepage": "https://crossfox.online",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/OleksiiFursov/packages.git",
+    "directory": "query-handler"
+  },
+  "bugs": {
+    "url": "https://github.com/OleksiiFursov/packages/issues",
+    "email": "nodepro777@gmail.com"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "engines": {
+    "bun": ">=1.1.0"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./elysia": {
+      "types": "./dist/elysia.d.ts",
+      "import": "./dist/elysia.js",
+      "default": "./dist/elysia.js"
+    },
+    "./schema": {
+      "types": "./dist/schema.d.ts",
+      "import": "./dist/schema.js",
+      "default": "./dist/schema.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "typecheck": "tsc --noEmit",
+    "test": "bun test tests/query-handler.unit.test.ts",
+    "test:integration": "bun test tests/query-handler.mysql-suite.ts",
+    "check": "bun run typecheck && bun run test",
+    "prepublishOnly": "bun run check && bun run build"
+  },
+  "peerDependencies": {
+    "@crossfox/db": ">=0.1.0",
+    "elysia": ">=1.4"
+  },
+  "peerDependenciesMeta": {
+    "elysia": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@crossfox/db": "workspace:*",
+    "@types/bun": "^1.3.14",
+    "elysia": "^1.4.28",
+    "typescript": "6.0.3"
+  },
+  "keywords": [
+    "query-handler",
+    "query",
+    "filter",
+    "pagination",
+    "cursor",
+    "mysql",
+    "bun",
+    "elysia",
+    "orm",
+    "api",
+    "crossfox",
+    "@crossfox/db"
+  ],
+  "publishConfig": {
+    "access": "public"
+  }
+}