equipped 5.2.9 → 5.3.0-alpha.0

package/dist/types/{fastify-DLPUK3vD.d.ts → base-3PpBAx1K.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 { 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,23 @@ declare const serverConfigPipe: () => valleyed.Pipe<({
         };
     };
     socketsAuthMethods: BaseRequestAuthMethod<AuthUser>[];
-} & {
-    type: "express";
-})>;
+}>;
 type ServerConfig = PipeOutput<ReturnType<typeof serverConfigPipe>>;
-
-declare class Router<T extends RouteDef> {
+declare abstract class Server {
     #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 abstract class Server<Req = any, Res = any> {
-    #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 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>;
+    test(): TestAgent;
     start(): Promise<boolean>;
 }
 
-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, Router as R, Server as S, type ServerConfig as a, type SocketCallbacks as b, SocketEmitter as c, 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-LWUMIHL4.js";
+import {
+  Instance,
+  configurable
+} from "../../../chunk-32DMHN3G.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-4LRJJSGG.js";
+import "../../../chunk-LWUMIHL4.js";
+import "../../../chunk-32DMHN3G.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-LWUMIHL4.js";
+import "../chunk-32DMHN3G.js";
+import "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
+export {
+  Cache
+};