equipped 5.2.9 → 5.3.0

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

@@ -1,6 +1,6 @@
-import { R as RequestError } from '../requestError-C2PNWUrt.js';
-export { E as EquippedError } from '../requestError-C2PNWUrt.js';
-export { V as ValidationError } from '../validationError-Bw8OYv5s.js';
+export { E as EquippedError } from '../equippedError-Cmo60Kn-.js';
+import { b as RequestError } from '../requestError-DdaL8hc3.js';
+export { V as ValidationError } from '../validationError-oigtHqBi.js';
 import 'valleyed';
 import '../types/index.js';
 import '../overrides-6Hxg764S.js';

package/dist/types/errors/index.js

@@ -1,8 +1,22 @@
-export * from "./equippedError.js";
-export * from "./requestError.js";
-export * from "./types/badRequestError.js";
-export * from "./types/notAuthenticatedError.js";
-export * from "./types/notAuthorizedError.js";
-export * from "./types/notFoundError.js";
-export * from "./types/tokenExpired.js";
-export * from "./types/validationError.js";
+import {
+  BadRequestError,
+  EquippedError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  RequestError,
+  TokenExpired,
+  ValidationError
+} from "../chunk-YTY3EFNB.js";
+import "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
+export {
+  BadRequestError,
+  EquippedError,
+  NotAuthenticatedError,
+  NotAuthorizedError,
+  NotFoundError,
+  RequestError,
+  TokenExpired,
+  ValidationError
+};

package/dist/types/events/adapters/kafka/index.d.ts

@@ -0,0 +1,83 @@
+import * as valleyed from 'valleyed';
+import { E as Events } from '../../../overrides-6Hxg764S.js';
+import { EventBus, StreamOptions, Stream } from '../../index.js';
+
+declare const kafkaConfigPipe: () => valleyed.Pipe<{
+    brokers: string[];
+    ssl: boolean | undefined;
+    sasl: {
+        mechanism: "plain";
+        username: string;
+        password: string;
+    } | undefined;
+    clientId: string | undefined;
+}, {
+    brokers: string[];
+    ssl: boolean | undefined;
+    sasl: {
+        mechanism: "plain";
+        username: string;
+        password: string;
+    } | undefined;
+    clientId: string | undefined;
+}>;
+declare const KafkaEventBus_base: (abstract new (validated: {
+    brokers: string[];
+    ssl: boolean | undefined;
+    sasl: {
+        mechanism: "plain";
+        username: string;
+        password: string;
+    } | undefined;
+    clientId: string | undefined;
+}) => EventBus & {
+    readonly config: {
+        brokers: string[];
+        ssl: boolean | undefined;
+        sasl: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        clientId: string | undefined;
+    };
+}) & {
+    readonly Config: {
+        brokers: string[];
+        ssl: boolean | undefined;
+        sasl: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        clientId: string | undefined;
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        brokers: string[];
+        ssl?: boolean | undefined;
+        sasl?: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        clientId?: string | undefined;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        brokers: string[];
+        ssl: boolean | undefined;
+        sasl: {
+            mechanism: "plain";
+            username: string;
+            password: string;
+        } | undefined;
+        clientId: string | undefined;
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class KafkaEventBus extends KafkaEventBus_base {
+    #private;
+    protected constructor(config: typeof KafkaEventBus.Config);
+    stream<Event extends Events[keyof Events]>(topicName: Event['topic'], options?: Partial<StreamOptions>): Stream<Event['data']>;
+}
+
+export { KafkaEventBus, kafkaConfigPipe };

package/dist/types/events/adapters/kafka/index.js

@@ -0,0 +1,11 @@
+import {
+  KafkaEventBus,
+  kafkaConfigPipe
+} from "../../../chunk-XGGGAEET.js";
+import "../../../chunk-YTY3EFNB.js";
+import "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+export {
+  KafkaEventBus,
+  kafkaConfigPipe
+};

package/dist/types/events/adapters/rabbitmq/index.d.ts

@@ -0,0 +1,41 @@
+import * as valleyed from 'valleyed';
+import { E as Events } from '../../../overrides-6Hxg764S.js';
+import { EventBus, StreamOptions, Stream } from '../../index.js';
+
+declare const rabbitmqConfigPipe: () => valleyed.Pipe<{
+    uri: string;
+    eventColumnName: string;
+}, {
+    uri: string;
+    eventColumnName: string;
+}>;
+declare const RabbitMQEventBus_base: (abstract new (validated: {
+    uri: string;
+    eventColumnName: string;
+}) => EventBus & {
+    readonly config: {
+        uri: string;
+        eventColumnName: string;
+    };
+}) & {
+    readonly Config: {
+        uri: string;
+        eventColumnName: string;
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        uri: string;
+        eventColumnName: string;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        uri: string;
+        eventColumnName: string;
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class RabbitMQEventBus extends RabbitMQEventBus_base {
+    #private;
+    protected constructor(config: typeof RabbitMQEventBus.Config);
+    stream<Event extends Events[keyof Events]>(topicName: Event['topic'], options?: Partial<StreamOptions>): Stream<Event['data']>;
+}
+
+export { RabbitMQEventBus, rabbitmqConfigPipe };

package/dist/types/events/adapters/rabbitmq/index.js

@@ -0,0 +1,91 @@
+import {
+  Instance,
+  configurable,
+  parseJSONValue,
+  random_exports
+} from "../../../chunk-YTY3EFNB.js";
+import {
+  EventBus
+} from "../../../chunk-KZKFYO4V.js";
+import "../../../chunk-MLKGABMK.js";
+
+// src/events/adapters/rabbitmq/index.ts
+import { connect } from "amqp-connection-manager";
+import { v } from "valleyed";
+var rabbitmqConfigPipe = () => v.meta(
+  v.object({
+    uri: v.string(),
+    eventColumnName: v.string()
+  }),
+  { title: "Rabbitmq Config", $refId: "RabbitmqConfig" }
+);
+var RabbitMQEventBus = class _RabbitMQEventBus extends configurable(rabbitmqConfigPipe, EventBus) {
+  #client;
+  #columnName;
+  constructor(config) {
+    super(config);
+    this.#columnName = config.eventColumnName;
+    this.#client = connect([config.uri]).createChannel({
+      json: false,
+      setup: async (channel) => {
+        await channel.assertExchange(this.#columnName, "direct", { durable: true });
+        await channel.prefetch(1);
+      }
+    });
+  }
+  stream(topicName, options = {}) {
+    const topic = options.skipScope ? topicName : Instance.get().getScopedName(topicName);
+    return {
+      publish: async (data) => await this.#client.publish(this.#columnName, topic, JSON.stringify(data), { persistent: true }),
+      subscribe: async (onMessage) => {
+        const subscribe = async () => {
+          await this.#client.addSetup(async (channel) => {
+            const queueName = options.fanout ? Instance.get().getScopedName(`${Instance.get().id}-fanout-${random_exports.string(10)}`) : topic;
+            const { queue } = await channel.assertQueue(queueName, { durable: !options.fanout, exclusive: options.fanout });
+            await channel.bindQueue(queue, this.#columnName, topic);
+            channel.consume(
+              queue,
+              async (msg) => {
+                await Instance.resolveBeforeCrash(async () => {
+                  if (!msg) return;
+                  try {
+                    await onMessage(parseJSONValue(msg.content.toString()));
+                    channel.ack(msg);
+                  } catch {
+                    channel.nack(msg);
+                  }
+                });
+              },
+              { noAck: false }
+            );
+          });
+        };
+        Instance.on("start", subscribe, { class: _RabbitMQEventBus });
+      }
+    };
+  }
+};
+if (void 0) {
+  const { describe, test, expect, expectTypeOf } = void 0;
+  describe("RabbitMQEventBus", () => {
+    test("create returns an instance with stream method", () => {
+      const bus = RabbitMQEventBus.create({ uri: "amqp://localhost", eventColumnName: "events" });
+      expect(bus).toBeInstanceOf(RabbitMQEventBus);
+      expect(bus.stream).toBeTypeOf("function");
+    });
+    test("external new is a compile error", () => {
+      void (() => new RabbitMQEventBus({ uri: "amqp://localhost", eventColumnName: "events" }));
+    });
+    test("static Config resolves to the pipe output type", () => {
+      expectTypeOf().toHaveProperty("uri");
+      expectTypeOf().toHaveProperty("eventColumnName");
+    });
+    test("create rejects invalid config", () => {
+      expect(() => RabbitMQEventBus.create({ uri: "amqp://localhost" })).toThrow();
+    });
+  });
+}
+export {
+  RabbitMQEventBus,
+  rabbitmqConfigPipe
+};

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

@@ -1,15 +1,15 @@
-import { E as EventBus, R as RabbitMQConfig, S as StreamOptions } from '../kafka-Cf-TUJgv.js';
-export { a as KafkaConfig, K as KafkaEventBus, k as kafkaConfigPipe, r as rabbitmqConfigPipe } from '../kafka-Cf-TUJgv.js';
 import { E as Events } from '../overrides-6Hxg764S.js';
-import 'valleyed';
 
-declare class RabbitMQEventBus extends EventBus {
-    #private;
-    constructor(config: RabbitMQConfig);
-    createStream<Event extends Events[keyof Events]>(topicName: Event['topic'], options?: Partial<StreamOptions>): {
-        publish: (data: Event["data"]) => Promise<boolean>;
-        subscribe: (onMessage: (data: Event["data"]) => Promise<void>) => Promise<void>;
-    };
+type StreamOptions = {
+    skipScope?: boolean;
+    fanout: boolean;
+};
+type Stream<EventData> = {
+    publish: (data: EventData) => Promise<boolean>;
+    subscribe: (onMessage: (data: EventData) => Promise<void>) => void;
+};
+declare abstract class EventBus {
+    abstract stream<Event extends Events[keyof Events]>(topic: Event['topic'], options?: Partial<StreamOptions>): Stream<Event['data']>;
 }
 
-export { EventBus, RabbitMQConfig, RabbitMQEventBus, StreamOptions };
+export { EventBus, type Stream, type StreamOptions };

package/dist/types/events/index.js

@@ -1,4 +1,7 @@
-export * from "./base.js";
-export * from "./pipes.js";
-export * from "./types/kafka.js";
-export * from "./types/rabbitmq.js";
+import {
+  EventBus
+} from "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
+export {
+  EventBus
+};

package/dist/types/index.d.ts

@@ -1,27 +1,4 @@
-export { Instance } from './instance/index.js';
+export { ClassRef, HookCb, HookEvent, HookOptions, Instance } from './instance/index.js';
 import 'pino';
 import 'valleyed';
-import './requestError-C2PNWUrt.js';
-import './types/index.js';
-import './overrides-6Hxg764S.js';
-import 'node:http2';
-import 'node:stream';
-import '@fastify/cookie';
-import './kafka-Cf-TUJgv.js';
-import './events/index.js';
-import './fastify-DLPUK3vD.js';
-import 'express';
-import 'fastify';
-import 'supertest/lib/agent';
-import 'node:http';
-import '@fastify/cors';
-import 'cors';
-import 'supertest';
-import 'socket.io';
-import './core-BrkNSwvc.js';
-import 'mongodb';
-import './cache/index.js';
-import 'ioredis';
-import './db-Dj1SGto0.js';
-import './db-C8YY1yTO.js';
-import './jobs/index.js';
+import './equippedError-Cmo60Kn-.js';

package/dist/types/index.js

@@ -1 +1,8 @@
-export * from "./instance/index.js";
+import {
+  Instance
+} from "./chunk-YTY3EFNB.js";
+import "./chunk-KZKFYO4V.js";
+import "./chunk-MLKGABMK.js";
+export {
+  Instance
+};

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

@@ -1,33 +1,18 @@
 import { Logger } from 'pino';
 import * as valleyed from 'valleyed';
 import { PipeOutput, ConditionalObjectKeys, PipeInput, Pipe } from 'valleyed';
-import { E as EquippedError } from '../requestError-C2PNWUrt.js';
-import { K as KafkaEventBus, E as EventBus } from '../kafka-Cf-TUJgv.js';
-import { RabbitMQEventBus } from '../events/index.js';
-import { A as AuthUser } from '../overrides-6Hxg764S.js';
-import { E as ExpressServer, F as FastifyServer, B as BaseRequestAuthMethod } from '../fastify-DLPUK3vD.js';
-import { InMemoryCache, RedisCache } from '../cache/index.js';
-import { M as MongoDb } from '../db-Dj1SGto0.js';
-import { RedisJob } from '../jobs/index.js';
-import '../types/index.js';
-import 'node:http2';
-import 'node:stream';
-import '@fastify/cookie';
-import 'express';
-import 'fastify';
-import 'supertest/lib/agent';
-import 'node:http';
-import '@fastify/cors';
-import 'cors';
-import 'supertest';
-import 'socket.io';
-import '../core-BrkNSwvc.js';
-import 'mongodb';
-import 'ioredis';
-import '../db-C8YY1yTO.js';
+import { E as EquippedError } from '../equippedError-Cmo60Kn-.js';
 
 type HookEvent = 'setup' | 'start' | 'close';
 type HookCb = Promise<unknown | void> | (() => void | unknown | Promise<void | unknown>);
+type ClassRef = Function & {
+    prototype: unknown;
+    name: string;
+};
+type HookOptions = {
+    class?: ClassRef;
+    after?: ClassRef[];
+};
 
 declare const instanceSettingsPipe: () => valleyed.Pipe<{
     app: {
@@ -56,142 +41,6 @@ declare const instanceSettingsPipe: () => valleyed.Pipe<{
 }>;
 type Settings = PipeOutput<ReturnType<typeof instanceSettingsPipe>>;
 type SettingsInput = ConditionalObjectKeys<PipeInput<ReturnType<typeof instanceSettingsPipe>>>;
-type CacheTypes = {
-    'in-memory': InMemoryCache;
-    redis: RedisCache;
-};
-declare const cachePipe: () => valleyed.Pipe<{
-    type: "in-memory";
-} | ({
-    host: string;
-    port: number | undefined;
-    password: string | undefined;
-    username: string | undefined;
-    tls: boolean | undefined;
-    cluster: boolean | undefined;
-} & {
-    type: "redis";
-}), InMemoryCache | RedisCache>;
-type JobTypes = {
-    redis: RedisJob;
-};
-declare const jobsPipe: () => valleyed.Pipe<{
-    redisConfig: {
-        host: string;
-        port: number | undefined;
-        password: string | undefined;
-        username: string | undefined;
-        tls: boolean | undefined;
-        cluster: boolean | undefined;
-    };
-    queueName: string;
-} & {
-    type: "redis";
-}, RedisJob>;
-type EventBusTypes = {
-    kafka: KafkaEventBus;
-    rabbitmq: RabbitMQEventBus;
-};
-declare const eventBusPipe: () => valleyed.Pipe<({
-    brokers: string[];
-    ssl: boolean | undefined;
-    sasl: {
-        mechanism: "plain";
-        username: string;
-        password: string;
-    } | undefined;
-    clientId: string | undefined;
-} & {
-    type: "kafka";
-}) | ({
-    uri: string;
-    eventColumnName: string;
-} & {
-    type: "rabbitmq";
-}), KafkaEventBus | RabbitMQEventBus>;
-type DbTypes = {
-    mongo: MongoDb;
-};
-declare const dbPipe: () => valleyed.Pipe<{
-    db: {
-        uri: string;
-    } & {
-        type: "mongo";
-    };
-    changes: {
-        debeziumUrl: string;
-        eventBus: KafkaEventBus;
-    } | undefined;
-}, MongoDb>;
-type ServerTypes = {
-    express: ExpressServer;
-    fastify: FastifyServer;
-};
-declare const serverTypePipe: () => 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";
-}) | ({
-    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: "express";
-}), ExpressServer | FastifyServer>;
 
 declare class Instance {
     #private;
@@ -201,28 +50,12 @@ declare class Instance {
     alias(id: string): undefined;
     get id(): string;
     getScopedName(name: string, key?: string): string;
-    createCache<T extends keyof CacheTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof cachePipe>>, {
-        type: T;
-    }>>): CacheTypes[T];
-    createJobs<T extends keyof JobTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof jobsPipe>>, {
-        type: T;
-    }>>): JobTypes[T];
-    createEventBus<T extends keyof EventBusTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof eventBusPipe>>, {
-        type: T;
-    }>>): EventBusTypes[T];
-    createDb<T extends keyof DbTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof dbPipe>>, {
-        db: {
-            type: T;
-        };
-    }>>): DbTypes[T];
-    createServer<T extends keyof ServerTypes>(input: ConditionalObjectKeys<Extract<PipeInput<ReturnType<typeof serverTypePipe>>, {
-        type: T;
-    }>>): ServerTypes[T];
     start(): Promise<void>;
     static envs<E extends object>(envsPipe: Pipe<unknown, E>): E;
     static create(settings: SettingsInput): Instance;
     static get(): Instance;
-    static on(event: HookEvent, cb: HookCb, order: number): void;
+    static maybeGet(): Instance | undefined;
+    static on(event: HookEvent, cb: HookCb, options?: HookOptions): void;
     static resolveBeforeCrash<T>(cb: () => Promise<T>): Promise<T>;
     static crash(error: EquippedError): never;
     static createId(opts?: {
@@ -231,4 +64,4 @@ declare class Instance {
     }): string;
 }
 
-export { Instance };
+export { type ClassRef, type HookCb, type HookEvent, type HookOptions, Instance };