equipped 5.2.9 → 5.3.0

package/dist/types/{fastify-DLPUK3vD.d.ts → base-DVr0fHil.d.ts}

@@ -1,18 +1,14 @@
-import express from 'express';
-import { FastifyRequest, FastifyReply } from 'fastify';
-import * as valleyed from 'valleyed';
-import { PipeOutput } from 'valleyed';
-import { E as EventBus } from './kafka-Cf-TUJgv.js';
-import { A as AuthUser } from './overrides-6Hxg764S.js';
-import { IncomingHttpHeaders } from 'node:http2';
-import * as supertest_lib_agent from 'supertest/lib/agent';
-import http from 'node:http';
+import http, { IncomingMessage, ServerResponse } from 'node:http';
 import { FastifyCorsOptions } from '@fastify/cors';
 import { CorsOptions } from 'cors';
-import supertest from 'supertest';
-import { d as RouteDef, j as RouterConfig, i as RouteConfig, l as RouteDefHandler, k as MergeRouteDefs, e as Route, a as Request, b as Response, f as MethodsEnum } from './requestError-C2PNWUrt.js';
+import TestAgent from 'supertest/lib/agent';
+import { Pipe, PipeOutput } from 'valleyed';
+import { EventBus } from './events/index.js';
+import { A as AuthUser } from './overrides-6Hxg764S.js';
+import { d as RouteDef, j as RouterConfig, i as RouteConfig, l as RouteDefHandler, k as MergeRouteDefs, e as Route, R as Request, a as Response, M as MethodsEnum } from './requestError-DdaL8hc3.js';
+import { IncomingHttpHeaders } from 'node:http2';
 import { Server as Server$1 } from 'socket.io';
-import { E as Entity } from './core-BrkNSwvc.js';
+import { E as Entity } from './core-tNlIMH9Y.js';
 
 declare abstract class BaseRequestAuthMethod<T extends {
     id: string;
@@ -24,39 +20,44 @@ declare abstract class BaseRequestAuthMethod<T extends {
     }>(methods: BaseRequestAuthMethod<T>[], headers: IncomingHttpHeaders): Promise<T | null>;
 }
 
-declare const serverConfigPipe: () => valleyed.Pipe<({
-    port: number;
-    cors: {
-        origin: true | string[] | undefined;
-        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
-        credentials: boolean | undefined;
-    } | undefined;
-    eventBus: EventBus | undefined;
-    publicPath: string | undefined;
-    healthPath: string | undefined;
-    openapi: {
-        docsVersion: string | undefined;
-        docsBaseUrl: string[] | undefined;
-        docsPath: string | undefined;
-    } | undefined;
-    requests: {
-        log: boolean | undefined;
-        rateLimit: {
-            enabled: boolean | undefined;
-            periodInMs: number | undefined;
-            limit: number | undefined;
-        } | undefined;
-        slowdown: {
-            enabled: boolean | undefined;
-            periodInMs: number | undefined;
-            delayAfter: number | undefined;
-            delayInMs: number | undefined;
-        } | undefined;
-    } | undefined;
-    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
-} & {
-    type: "fastify";
-}) | ({
+declare class Router<T extends RouteDef> {
+    #private;
+    constructor(config?: RouterConfig<T>);
+    head: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
+    get: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
+    post: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
+    put: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
+    patch: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
+    delete: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
+    options: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
+    nest(...routers: Router<any>[]): void;
+    get routes(): Route<any>[];
+}
+
+type OnJoinFn = (data: {
+    channel: string;
+    user: AuthUser | null;
+}, params: Record<string, any>, query: Record<string, any>) => Promise<string | null>;
+type SocketCallbacks = {
+    onConnect: (userId: string, socketId: string) => Promise<void>;
+    onDisconnect: (userId: string, socketId: string) => Promise<void>;
+};
+declare class SocketEmitter {
+    #private;
+    private config;
+    readonly socketInstance: Server$1;
+    constructor(socket: Server$1, config: ServerConfig);
+    created<T extends Entity>(channels: string[], data: T, to: string | string[] | null): Promise<void>;
+    updated<T extends Entity>(channels: string[], { after, before }: {
+        after: T;
+        before: T;
+    }, to: string | string[] | null): Promise<void>;
+    deleted<T extends Entity>(channels: string[], data: T, to: string | string[] | null): Promise<void>;
+    set connectionCallbacks(callbacks: SocketCallbacks);
+    register(channel: string, onJoin: OnJoinFn): this;
+}
+
+declare const serverConfigPipe: () => Pipe<{
     port: number;
     cors: {
         origin: true | string[] | undefined;
@@ -86,41 +87,7 @@ declare const serverConfigPipe: () => valleyed.Pipe<({
         } | undefined;
     } | undefined;
     socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[] | undefined;
-} & {
-    type: "express";
-}), ({
-    port: number;
-    cors: {
-        origin: true | string[] | undefined;
-        methods: ("get" | "delete" | "head" | "options" | "post" | "put" | "patch")[] | undefined;
-        credentials: boolean | undefined;
-    } | undefined;
-    eventBus: EventBus | undefined;
-    publicPath: string | undefined;
-    healthPath: string | undefined;
-    openapi: {
-        docsVersion: string;
-        docsBaseUrl: string[];
-        docsPath: string;
-    };
-    requests: {
-        log: boolean;
-        rateLimit: {
-            enabled: boolean;
-            periodInMs: number;
-            limit: number;
-        };
-        slowdown: {
-            enabled: boolean;
-            periodInMs: number;
-            delayAfter: number;
-            delayInMs: number;
-        };
-    };
-    socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[];
-} & {
-    type: "fastify";
-}) | ({
+}, {
     port: number;
     cors: {
         origin: true | string[] | undefined;
@@ -150,75 +117,41 @@ declare const serverConfigPipe: () => valleyed.Pipe<({
         };
     };
     socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[];
-} & {
-    type: "express";
-})>;
+}>;
 type ServerConfig = PipeOutput<ReturnType<typeof serverConfigPipe>>;
-
-declare class Router<T extends RouteDef> {
-    #private;
-    constructor(config?: RouterConfig<T>);
-    head: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
-    get: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
-    post: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
-    put: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
-    patch: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
-    delete: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
-    options: <R extends RouteDef>(path: string, config?: RouteConfig<R>) => (handler: RouteDefHandler<MergeRouteDefs<T, R>>) => Route<MergeRouteDefs<T, R>>;
-    nest(...routers: Router<any>[]): void;
-    get routes(): Route<any>[];
-}
-
-type OnJoinFn = (data: {
-    channel: string;
-    user: AuthUser | null;
-}, params: Record<string, any>, query: Record<string, any>) => Promise<string | null>;
-type SocketCallbacks = {
-    onConnect: (userId: string, socketId: string) => Promise<void>;
-    onDisconnect: (userId: string, socketId: string) => Promise<void>;
+declare const rawResponseHandledSymbol: unique symbol;
+type RawResponseHandled = {
+    readonly [rawResponseHandledSymbol]: true;
 };
-declare class SocketEmitter {
-    #private;
-    private config;
-    readonly socketInstance: Server$1;
-    constructor(socket: Server$1, config: ServerConfig);
-    created<T extends Entity>(channels: string[], data: T, to: string | string[] | null): Promise<void>;
-    updated<T extends Entity>(channels: string[], { after, before }: {
-        after: T;
-        before: T;
-    }, to: string | string[] | null): Promise<void>;
-    deleted<T extends Entity>(channels: string[], data: T, to: string | string[] | null): Promise<void>;
-    set connectionCallbacks(callbacks: SocketCallbacks);
-    register(channel: string, onJoin: OnJoinFn): this;
-}
-
-declare abstract class Server<Req = any, Res = any> {
+type RawResponseHandler = (request: IncomingMessage, response: ServerResponse) => unknown | Promise<unknown>;
+type RawResponder = (handler: RawResponseHandler) => Promise<RawResponseHandled>;
+type ServerNotFoundContext = {
+    request: Request<any>;
+    respondWithRaw: RawResponder;
+};
+type ServerNotFoundHandler = (context: ServerNotFoundContext) => Response<any> | RawResponseHandled | Promise<Response<any> | RawResponseHandled>;
+declare abstract class Server {
     #private;
-    private config;
-    private implementations;
     socket: SocketEmitter;
-    protected server: http.Server;
-    protected get cors(): CorsOptions & FastifyCorsOptions;
-    constructor(server: http.Server, config: ServerConfig, implementations: {
-        parseRequest: (req: Req) => Promise<Request<any>>;
-        handleResponse: (res: Res, response: Response<any>) => Promise<void>;
-        registerRoute: (method: MethodsEnum, path: string, cb: (req: Req, res: Res) => Promise<void>) => void;
-        registerErrorHandler: (cb: (error: Error, req: Req, res: Res) => Promise<void>) => void;
-        registerNotFoundHandler: (cb: (req: Req, res: Res) => Promise<void>) => void;
-        start: (port: number) => Promise<boolean>;
-    });
+    cors: CorsOptions & FastifyCorsOptions;
+    protected abstract parseRequest(req: any): Promise<Request<any>>;
+    protected abstract handleResponse(res: any, response: Response<any>): Promise<void>;
+    protected abstract createRawResponder(req: any, res: any): RawResponder;
+    protected abstract registerRoute(method: MethodsEnum, path: string, cb: (req: any, res: any) => Promise<void>): void;
+    protected abstract registerErrorHandler(cb: (error: Error, req: any, res: any) => Promise<void>): void;
+    protected abstract registerNotFoundHandler(cb: (req: any, res: any) => Promise<void>): void;
+    protected abstract startServer(port: number): Promise<boolean>;
+    protected setup(httpServer: http.Server, config: ServerConfig): void;
     addRouter(...routers: Router<any>[]): void;
     addRoute<T extends RouteDef>(...routes: Route<T>[]): void;
-    test(): supertest_lib_agent<supertest.SuperTestStatic.Test>;
+    setNotFoundHandler(handler: ServerNotFoundHandler): this;
+    test(): TestAgent;
     start(): Promise<boolean>;
+    protected createNodeRawResponder(input: {
+        request: IncomingMessage;
+        response: ServerResponse;
+        beforeHandle?: () => void;
+    }): RawResponder;
 }
 
-declare class ExpressServer extends Server<express.Request, express.Response> {
-    constructor(config: ServerConfig);
-}
-
-declare class FastifyServer extends Server<FastifyRequest, FastifyReply> {
-    constructor(config: ServerConfig);
-}
-
-export { BaseRequestAuthMethod as B, ExpressServer as E, FastifyServer as F, type OnJoinFn as O, Router as R, Server as S, type ServerConfig as a, type SocketCallbacks as b, SocketEmitter as c, serverConfigPipe as s };
+export { BaseRequestAuthMethod as B, type OnJoinFn as O, type RawResponder as R, Server as S, type ServerConfig as a, type RawResponseHandled as b, type RawResponseHandler as c, type ServerNotFoundContext as d, type ServerNotFoundHandler as e, Router as f, type SocketCallbacks as g, SocketEmitter as h, serverConfigPipe as s };

package/dist/types/cache/adapters/in-memory/index.d.ts

@@ -0,0 +1,21 @@
+import * as valleyed from 'valleyed';
+import { Cache } from '../../index.js';
+
+declare const inMemoryCacheConfigPipe: () => valleyed.Pipe<{}, {}>;
+declare const InMemoryCache_base: (abstract new (validated: {}) => Cache & {
+    readonly config: {};
+}) & {
+    readonly Config: {};
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {}, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{}, ...infer R] ? R : never): This["prototype"];
+};
+declare class InMemoryCache extends InMemoryCache_base {
+    #private;
+    protected constructor(config: typeof InMemoryCache.Config);
+    delete(key: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    set(key: string, data: string, ttlInSecs?: number): Promise<void>;
+}
+
+export { InMemoryCache, inMemoryCacheConfigPipe };

package/dist/types/cache/adapters/in-memory/index.js

@@ -0,0 +1,92 @@
+import {
+  Cache
+} from "../../../chunk-3TKJGSCZ.js";
+import {
+  Instance,
+  configurable
+} from "../../../chunk-YTY3EFNB.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+
+// src/cache/adapters/in-memory/index.ts
+import { v } from "valleyed";
+var inMemoryCacheConfigPipe = () => v.object({});
+var InMemoryCache = class _InMemoryCache extends configurable(inMemoryCacheConfigPipe, Cache) {
+  #caches = /* @__PURE__ */ new Map();
+  #interval;
+  constructor(config) {
+    super(config);
+    Instance.on("start", async () => {
+      this.#interval = setInterval(() => {
+        const now = Date.now();
+        for (const [key, record] of this.#caches.entries()) {
+          if (record.expiredAt && record.expiredAt <= now) this.#caches.delete(key);
+        }
+      }, 5e3);
+    }, { class: _InMemoryCache });
+    Instance.on("close", async () => clearInterval(this.#interval), { class: _InMemoryCache });
+  }
+  async delete(key) {
+    this.#caches.delete(this.getScopedKey(key));
+  }
+  async get(key) {
+    const record = this.#caches.get(this.getScopedKey(key));
+    if (record && (record.expiredAt === void 0 || record.expiredAt > Date.now())) return record.data;
+    return null;
+  }
+  async set(key, data, ttlInSecs) {
+    this.#caches.set(this.getScopedKey(key), { data, expiredAt: ttlInSecs ? Date.now() + ttlInSecs * 1e3 : void 0 });
+  }
+};
+if (void 0) {
+  const { describe, test, expect, expectTypeOf, vi, beforeEach, afterEach } = void 0;
+  let hookCalls;
+  beforeEach(() => {
+    hookCalls = [];
+    vi.spyOn(Instance, "on").mockImplementation((event, _cb, options) => {
+      hookCalls.push({ event, options });
+    });
+    vi.spyOn(Instance, "get").mockReturnValue({ getScopedName: (_name, _sep) => `test:${_name}` });
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+  describe("InMemoryCache", () => {
+    test("create() produces a working instance", () => {
+      const cache = InMemoryCache.create({});
+      expect(cache).toBeInstanceOf(InMemoryCache);
+    });
+    test("new InMemoryCache() is a compile error", () => {
+      void (() => new InMemoryCache({}));
+    });
+    test("Instance.on calls use { class: InMemoryCache }", () => {
+      InMemoryCache.create({});
+      const startHook = hookCalls.find((h) => h.event === "start");
+      const closeHook = hookCalls.find((h) => h.event === "close");
+      expect(startHook?.options).toEqual({ class: InMemoryCache });
+      expect(closeHook?.options).toEqual({ class: InMemoryCache });
+    });
+    test("set/get/delete work correctly", async () => {
+      const cache = InMemoryCache.create({});
+      await cache.set("key1", "value1");
+      expect(await cache.get("key1")).toBe("value1");
+      await cache.delete("key1");
+      expect(await cache.get("key1")).toBeNull();
+    });
+    test("get returns null after ttl expires", async () => {
+      const now = Date.now();
+      vi.spyOn(Date, "now").mockReturnValue(now);
+      const cache = InMemoryCache.create({});
+      await cache.set("key1", "value1", 1);
+      vi.spyOn(Date, "now").mockReturnValue(now + 1001);
+      expect(await cache.get("key1")).toBeNull();
+    });
+    test("Config type is accessible", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+  });
+}
+export {
+  InMemoryCache,
+  inMemoryCacheConfigPipe
+};

package/dist/types/cache/adapters/redis/index.d.ts

@@ -0,0 +1,73 @@
+import * as ioredis from 'ioredis';
+import { RedisOptions } from 'ioredis';
+import * as valleyed from 'valleyed';
+import { Cache } from '../../index.js';
+
+declare const redisConfigPipe: () => valleyed.Pipe<{
+    host: string;
+    port: number | undefined;
+    password: string | undefined;
+    username: string | undefined;
+    tls: boolean | undefined;
+    cluster: boolean | undefined;
+}, {
+    host: string;
+    port: number | undefined;
+    password: string | undefined;
+    username: string | undefined;
+    tls: boolean | undefined;
+    cluster: boolean | undefined;
+}>;
+declare const RedisCache_base: (abstract new (validated: {
+    host: string;
+    port: number | undefined;
+    password: string | undefined;
+    username: string | undefined;
+    tls: boolean | undefined;
+    cluster: boolean | undefined;
+}) => Cache & {
+    readonly config: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    };
+}) & {
+    readonly Config: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        host: string;
+        port?: number | undefined;
+        password?: string | undefined;
+        username?: string | undefined;
+        tls?: boolean | undefined;
+        cluster?: boolean | undefined;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class RedisCache extends RedisCache_base {
+    #private;
+    protected constructor(config: typeof RedisCache.Config, extraConfig?: Partial<RedisOptions>);
+    get connectionOptions(): ioredis.ClusterOptions | RedisOptions;
+    delete(key: string): Promise<void>;
+    get(key: string): Promise<string | null>;
+    set(key: string, data: string, ttlInSecs?: number): Promise<void>;
+}
+
+export { RedisCache, redisConfigPipe };

package/dist/types/cache/adapters/redis/index.js

@@ -0,0 +1,12 @@
+import {
+  RedisCache,
+  redisConfigPipe
+} from "../../../chunk-65EHKCDZ.js";
+import "../../../chunk-3TKJGSCZ.js";
+import "../../../chunk-YTY3EFNB.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+export {
+  RedisCache,
+  redisConfigPipe
+};

package/dist/types/cache/index.d.ts

@@ -1,49 +1,9 @@
-import * as valleyed from 'valleyed';
-import { PipeOutput } from 'valleyed';
-import { Redis, Cluster, RedisOptions } from 'ioredis';
-
 declare abstract class Cache {
     abstract set(key: string, data: string, ttlInSecs?: number): Promise<void>;
     abstract get(key: string): Promise<string | null>;
     abstract delete(key: string): Promise<void>;
-    abstract getOrSet<T>(key: string, fn: () => Promise<T>, ttlInSecs?: number): Promise<T>;
-}
-
-declare const redisConfigPipe: () => valleyed.Pipe<{
-    host: string;
-    port: number | undefined;
-    password: string | undefined;
-    username: string | undefined;
-    tls: boolean | undefined;
-    cluster: boolean | undefined;
-}, {
-    host: string;
-    port: number | undefined;
-    password: string | undefined;
-    username: string | undefined;
-    tls: boolean | undefined;
-    cluster: boolean | undefined;
-}>;
-type RedisConfig = PipeOutput<ReturnType<typeof redisConfigPipe>>;
-
-declare class InMemoryCache extends Cache {
-    private readonly cache;
-    constructor();
-    private getScopedKey;
-    delete(key: string): Promise<void>;
-    get(key: string): Promise<string | null>;
-    set(key: string, data: string, ttlInSecs?: number): Promise<void>;
+    getScopedKey(key: string): string;
     getOrSet<T>(key: string, fn: () => Promise<T>, ttlInSecs?: number): Promise<T>;
 }
 
-declare class RedisCache extends Cache {
-    client: Redis | Cluster;
-    constructor(settings: RedisConfig, extraConfig?: Partial<RedisOptions>);
-    private getScopedKey;
-    delete(key: string): Promise<void>;
-    get(key: string): Promise<string | null>;
-    set(key: string, data: string, ttlInSecs?: number): Promise<void>;
-    getOrSet<T>(key: string, fn: () => Promise<T>, ttlInSecs?: number): Promise<any>;
-}
-
-export { Cache, InMemoryCache, RedisCache, type RedisConfig, redisConfigPipe };
+export { Cache };

package/dist/types/cache/index.js

@@ -1,4 +1,9 @@
-export * from "./base.js";
-export * from "./pipes.js";
-export * from "./types/in-memory.js";
-export * from "./types/redis.js";
+import {
+  Cache
+} from "../chunk-3TKJGSCZ.js";
+import "../chunk-YTY3EFNB.js";
+import "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Cache
+};

package/dist/types/chunk-3M4PBZAQ.js

@@ -0,0 +1,125 @@
+import {
+  KafkaEventBus
+} from "./chunk-XGGGAEET.js";
+import {
+  Instance
+} from "./chunk-YTY3EFNB.js";
+
+// src/dbs/adapters/base/db.ts
+var Db = class {
+  constructor(config) {
+    this.config = config;
+  }
+  getScopedDb(db) {
+    return Instance.get().getScopedName(db).replaceAll(".", "-");
+  }
+};
+
+// src/dbs/adapters/base/types.ts
+import { v } from "valleyed";
+var dbChangeConfigPipe = () => v.object({
+  debeziumUrl: v.string(),
+  eventBus: v.instanceOf(KafkaEventBus)
+});
+
+// src/dbs/pipes.ts
+import { v as v2 } from "valleyed";
+var QueryKeys = /* @__PURE__ */ ((QueryKeys2) => {
+  QueryKeys2["and"] = "and";
+  QueryKeys2["or"] = "or";
+  return QueryKeys2;
+})(QueryKeys || {});
+var Conditions = /* @__PURE__ */ ((Conditions2) => {
+  Conditions2["lt"] = "lt";
+  Conditions2["lte"] = "lte";
+  Conditions2["gt"] = "gt";
+  Conditions2["gte"] = "gte";
+  Conditions2["eq"] = "eq";
+  Conditions2["ne"] = "ne";
+  Conditions2["in"] = "in";
+  Conditions2["nin"] = "nin";
+  return Conditions2;
+})(Conditions || {});
+var queryKeys = v2.catch(v2.defaults(v2.in(["and" /* and */, "or" /* or */]), "and" /* and */), "and" /* and */);
+var queryWhere = v2.object({
+  field: v2.string(),
+  value: v2.any(),
+  // eslint-disable-next-line promise/valid-params -- valleyed v.catch(schema, fallback) is not Promise.prototype.catch
+  condition: v2.catch(v2.defaults(v2.in(Object.values(Conditions)), "eq" /* eq */), "eq" /* eq */)
+});
+var queryWhereBlock = v2.recursive(
+  () => v2.discriminate((d) => Object.values(QueryKeys).includes(d.condition) ? "block" : "regular", {
+    block: v2.object({
+      condition: queryKeys,
+      value: v2.array(queryWhereBlock)
+    }),
+    regular: queryWhere
+  }),
+  "QueryWhereBlock"
+);
+var queryWhereClause = v2.defaults(v2.array(queryWhereBlock), []);
+function queryParamsPipe() {
+  return v2.meta(
+    v2.object({
+      all: v2.defaults(v2.boolean(), false),
+      limit: v2.lazy(() => {
+        const pagLimit = Instance.get().settings.utils.paginationDefaultLimit;
+        return v2.catch(v2.defaults(v2.number().pipe(v2.lte(pagLimit)), pagLimit), pagLimit);
+      }),
+      // eslint-disable-next-line promise/valid-params -- valleyed v.catch(schema, fallback) is not Promise.prototype.catch
+      page: v2.catch(v2.defaults(v2.number().pipe(v2.gte(1)), 1), 1),
+      search: v2.defaults(
+        v2.nullish(
+          v2.object({
+            value: v2.string(),
+            fields: v2.array(v2.string())
+          })
+        ),
+        null
+      ),
+      sort: v2.defaults(
+        v2.array(
+          v2.object({
+            field: v2.string(),
+            desc: v2.defaults(v2.boolean(), false)
+          })
+        ),
+        []
+      ),
+      whereType: queryKeys,
+      where: queryWhereClause,
+      select: v2.optional(v2.array(v2.string()))
+    }).pipe((p) => ({ ...p, auth: [], authType: "and" /* and */ })),
+    { title: "Query Params", $refId: "QueryParams" }
+  );
+}
+function queryResultsPipe(model) {
+  return v2.object({
+    pages: v2.object({
+      current: v2.number(),
+      start: v2.number(),
+      last: v2.number(),
+      previous: v2.nullable(v2.number()),
+      next: v2.nullable(v2.number())
+    }),
+    docs: v2.object({
+      limit: v2.number(),
+      total: v2.number(),
+      count: v2.number()
+    }),
+    results: v2.array(model)
+  });
+}
+function wrapQueryParams(params) {
+  return v2.assert(queryParamsPipe(), params);
+}
+
+export {
+  Db,
+  dbChangeConfigPipe,
+  QueryKeys,
+  Conditions,
+  queryParamsPipe,
+  queryResultsPipe,
+  wrapQueryParams
+};

package/dist/types/chunk-3TKJGSCZ.js

@@ -0,0 +1,21 @@
+import {
+  Instance
+} from "./chunk-YTY3EFNB.js";
+
+// src/cache/adapters/base.ts
+var Cache = class {
+  getScopedKey(key) {
+    return Instance.get().getScopedName(key, ":");
+  }
+  async getOrSet(key, fn, ttlInSecs) {
+    const cached = await this.get(key);
+    if (cached) return JSON.parse(cached);
+    const result = await fn();
+    await this.set(key, JSON.stringify(result), ttlInSecs);
+    return result;
+  }
+};
+
+export {
+  Cache
+};