equipped 5.2.9 → 5.3.0-alpha.0

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

@@ -0,0 +1,91 @@
+import {
+  Instance,
+  configurable,
+  parseJSONValue,
+  random_exports
+} from "../../../chunk-32DMHN3G.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-32DMHN3G.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 };

package/dist/types/instance/index.js

@@ -1,136 +1,8 @@
-import pino, {} from "pino";
-import { ulid } from "ulid";
-import { v } from "valleyed";
-import { EquippedError } from "../errors/index.js";
-import { runHooks } from "./hooks.js";
 import {
-  cachePipe,
-  dbPipe,
-  eventBusPipe,
-  instanceSettingsPipe,
-  jobsPipe,
-  serverTypePipe
-} from "./settings.js";
-class Instance {
-  static #id;
-  static #instance;
-  static #hooks = {};
-  settings;
-  log;
-  constructor(settings) {
-    Instance.#instance = this;
-    this.settings = Object.freeze(settings);
-    this.log = pino({
-      level: this.settings.log.level,
-      serializers: {
-        err: pino.stdSerializers.err,
-        error: pino.stdSerializers.err,
-        req: pino.stdSerializers.req,
-        res: pino.stdSerializers.res
-      },
-      mixin: () => ({
-        instanceId: Instance.#id
-      })
-    });
-    Instance.#registerOnExitHandler();
-  }
-  alias(id) {
-    if (Instance.#id !== void 0) return Instance.crash(new EquippedError("Instance already has an alias", {}));
-    Instance.#id = id;
-  }
-  get id() {
-    if (Instance.#id === void 0) return Instance.crash(new EquippedError("Instance doesnt have an alias yet", {}));
-    return Instance.#id;
-  }
-  getScopedName(name, key = ".") {
-    return [this.settings.app.name, name].join(key);
-  }
-  createCache(input) {
-    return v.assert(cachePipe(), input);
-  }
-  createJobs(input) {
-    return v.assert(jobsPipe(), input);
-  }
-  createEventBus(input) {
-    return v.assert(eventBusPipe(), input);
-  }
-  createDb(input) {
-    return v.assert(dbPipe(), input);
-  }
-  createServer(input) {
-    return v.assert(serverTypePipe(), input);
-  }
-  async start() {
-    try {
-      await runHooks(Instance.#hooks["setup"] ?? []);
-      await runHooks(Instance.#hooks["start"] ?? []);
-    } catch (error) {
-      Instance.crash(new EquippedError(`Error starting instance`, {}, error));
-    }
-  }
-  static envs(envsPipe) {
-    const envValidity = v.validate(envsPipe, process.env);
-    if (!envValidity.valid) {
-      Instance.crash(
-        new EquippedError(`Environment variables are not valid
-${envValidity.error.toString()}`, {
-          messages: envValidity.error.messages
-        })
-      );
-    }
-    return envValidity.value;
-  }
-  static create(settings) {
-    if (Instance.#instance) return Instance.crash(new EquippedError("Instance has been initialized already", {}));
-    const settingsValidity = v.validate(instanceSettingsPipe(), settings);
-    if (!settingsValidity.valid) {
-      Instance.crash(
-        new EquippedError(`Settings are not valid
-${settingsValidity.error.toString()}`, {
-          messages: settingsValidity.error.messages
-        })
-      );
-    }
-    return new Instance(settingsValidity.value);
-  }
-  static get() {
-    if (!Instance.#instance)
-      return Instance.crash(
-        new EquippedError("Has not been initialized. Make sure an instance has been created before you get an instance", {})
-      );
-    return Instance.#instance;
-  }
-  static on(event, cb, order) {
-    Instance.#hooks[event] ??= [];
-    Instance.#hooks[event].push({ cb, order });
-  }
-  static #registerOnExitHandler() {
-    const signals = {
-      SIGHUP: 1,
-      SIGINT: 2,
-      SIGTERM: 15
-    };
-    Object.entries(signals).forEach(([signal, code]) => {
-      process.on(signal, async () => {
-        await runHooks(Instance.#hooks["close"] ?? [], () => {
-        });
-        process.exit(128 + code);
-      });
-    });
-  }
-  static resolveBeforeCrash(cb) {
-    const value = cb();
-    Instance.on("close", async () => await value, 10);
-    return value;
-  }
-  static crash(error) {
-    console.error(error);
-    process.exit(1);
-  }
-  static createId(opts) {
-    return `${opts?.prefix ?? ""}${ulid(opts?.time?.getTime())}`;
-  }
-}
+  Instance
+} from "../chunk-32DMHN3G.js";
+import "../chunk-KZKFYO4V.js";
+import "../chunk-MLKGABMK.js";
 export {
   Instance
 };

package/dist/types/introspection-ZQCAW254.js

@@ -0,0 +1,9 @@
+import {
+  OrmIntrospectionError
+} from "./chunk-XOU2A2Y6.js";
+import "./chunk-32DMHN3G.js";
+import "./chunk-KZKFYO4V.js";
+import "./chunk-MLKGABMK.js";
+export {
+  OrmIntrospectionError
+};

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

@@ -0,0 +1,93 @@
+import * as valleyed from 'valleyed';
+import { Job, DelayedJobEvent, RepeatableJobEvent } from '../../index.js';
+import '../../../overrides-6Hxg764S.js';
+
+declare const redisJobsConfigPipe: () => valleyed.Pipe<{
+    redisConfig: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    };
+    queueName: string;
+}, {
+    redisConfig: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    };
+    queueName: string;
+}>;
+declare const RedisJob_base: (abstract new (validated: {
+    redisConfig: {
+        host: string;
+        port: number | undefined;
+        password: string | undefined;
+        username: string | undefined;
+        tls: boolean | undefined;
+        cluster: boolean | undefined;
+    };
+    queueName: string;
+}) => Job & {
+    readonly config: {
+        redisConfig: {
+            host: string;
+            port: number | undefined;
+            password: string | undefined;
+            username: string | undefined;
+            tls: boolean | undefined;
+            cluster: boolean | undefined;
+        };
+        queueName: string;
+    };
+}) & {
+    readonly Config: {
+        redisConfig: {
+            host: string;
+            port: number | undefined;
+            password: string | undefined;
+            username: string | undefined;
+            tls: boolean | undefined;
+            cluster: boolean | undefined;
+        };
+        queueName: string;
+    };
+    create<This extends Function & {
+        prototype: any;
+    }>(this: This, input: {
+        redisConfig: {
+            host: string;
+            port?: number | undefined;
+            password?: string | undefined;
+            username?: string | undefined;
+            tls?: boolean | undefined;
+            cluster?: boolean | undefined;
+        };
+        queueName: string;
+    }, ...args: ConstructorParameters<This & (abstract new (...args: any[]) => any)> extends [{
+        redisConfig: {
+            host: string;
+            port: number | undefined;
+            password: string | undefined;
+            username: string | undefined;
+            tls: boolean | undefined;
+            cluster: boolean | undefined;
+        };
+        queueName: string;
+    }, ...infer R] ? R : never): This["prototype"];
+};
+declare class RedisJob extends RedisJob_base {
+    #private;
+    protected constructor(config: typeof RedisJob.Config);
+    addDelayed(data: DelayedJobEvent, delayInMs: number): Promise<string>;
+    addRepeatable(data: RepeatableJobEvent, cron: string, tz?: string): Promise<string>;
+    removeDelayed(jobId: string): Promise<void>;
+    retryAllFailedJobs(): Promise<void>;
+}
+
+export { RedisJob, redisJobsConfigPipe };