equipped 5.2.9 → 5.3.0-alpha.0

package/dist/cjs/events/adapters/rabbitmq/index.cjs

@@ -0,0 +1,836 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/events/adapters/rabbitmq/index.ts
+var rabbitmq_exports = {};
+__export(rabbitmq_exports, {
+  RabbitMQEventBus: () => RabbitMQEventBus,
+  rabbitmqConfigPipe: () => rabbitmqConfigPipe
+});
+module.exports = __toCommonJS(rabbitmq_exports);
+var import_amqp_connection_manager = require("amqp-connection-manager");
+var import_valleyed4 = require("valleyed");
+
+// src/instance/index.ts
+var import_pino = __toESM(require("pino"), 1);
+var import_ulid = require("ulid");
+var import_valleyed3 = require("valleyed");
+
+// src/errors/equippedError.ts
+var EquippedError = class extends Error {
+  constructor(message, context, cause) {
+    super(message, { cause });
+    this.message = message;
+    this.context = context;
+    this.cause = cause;
+  }
+};
+
+// src/events/adapters/base.ts
+var EventBus = class {
+};
+
+// src/utilities/configurable.ts
+var import_valleyed = require("valleyed");
+function configurable(pipeFn, base) {
+  const pipe = pipeFn();
+  import_valleyed.v.compile(pipe);
+  class Configurable extends base {
+    constructor(config, ...baseArgs) {
+      super(...baseArgs);
+      this.config = config;
+    }
+    static create(input, ...args) {
+      const r = import_valleyed.v.validate(pipe, input);
+      if (!r.valid) throw r.error;
+      return new this(r.value, ...args);
+    }
+  }
+  return Configurable;
+}
+if (void 0) {
+  const { describe, test, expect, expectTypeOf } = void 0;
+  const { v: v5 } = null;
+  const testPipe = () => v5.object({
+    host: v5.string(),
+    port: v5.number()
+  });
+  class TestBase {
+    baseValue;
+    constructor() {
+      this.baseValue = "base";
+    }
+  }
+  class TestBaseWithArgs {
+    label;
+    constructor(label) {
+      this.label = label;
+    }
+  }
+  describe("configurable", () => {
+    test("validation runs in static create before constructor body executes", () => {
+      let constructorRan = false;
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+          constructorRan = true;
+        }
+      }
+      expect(() => MyClass.create({ host: 123, port: "bad" })).toThrow();
+      expect(constructorRan).toBe(false);
+      MyClass.create({ host: "localhost", port: 3e3 });
+      expect(constructorRan).toBe(true);
+    });
+    test("constructor receives validated value", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      let receivedConfig;
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+          receivedConfig = this.config;
+        }
+      }
+      MyClass.create({ host: "localhost", port: 3e3 });
+      expect(receivedConfig).toEqual({ host: "localhost", port: 3e3 });
+    });
+    test("external new is a compile error", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+      }
+      void (() => new MyClass({ host: "localhost", port: 3e3 }));
+    });
+    test("static Config resolves to PipeOutput<P> at the type level", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+      }
+      expectTypeOf().toEqualTypeOf();
+      expect(MyClass.create).toBeTypeOf("function");
+    });
+    test("ConstructorParameters<This>-based extras inference works for non-zero-arg leaf signatures", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        extra;
+        constructor(config, extra) {
+          super(config);
+          this.extra = extra;
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 }, 42);
+      expect(instance.extra).toBe(42);
+      expectTypeOf(instance).toHaveProperty("extra");
+      expectTypeOf(instance.extra).toEqualTypeOf();
+      void (() => MyClass.create({ host: "localhost", port: 3e3 }, "not-a-number"));
+    });
+    test("base-args forwarding works for non-zero-arg bases", () => {
+      const Wrapped = configurable(testPipe, TestBaseWithArgs);
+      class MyClass extends Wrapped {
+        constructor(config, label) {
+          super(config, label);
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 }, "test-label");
+      expect(instance.label).toBe("test-label");
+    });
+    test("config is accessible as protected readonly on instances", () => {
+      const Wrapped = configurable(testPipe, TestBase);
+      class MyClass extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+        getHost() {
+          return this.config.host;
+        }
+      }
+      const instance = MyClass.create({ host: "localhost", port: 3e3 });
+      expect(instance.getHost()).toBe("localhost");
+    });
+    test("accepts an abstract base class", () => {
+      class AbstractBase {
+      }
+      const Wrapped = configurable(testPipe, AbstractBase);
+      class Concrete extends Wrapped {
+        constructor(config) {
+          super(config);
+        }
+        greet() {
+          return `hello from ${this.config.host}`;
+        }
+      }
+      const instance = Concrete.create({ host: "localhost", port: 3e3 });
+      expect(instance.greet()).toBe("hello from localhost");
+      expectTypeOf(instance).toHaveProperty("config");
+    });
+  });
+}
+
+// src/utilities/json.ts
+var parseJSONValue = (data) => {
+  try {
+    if (data?.constructor?.name !== "String") return data;
+    return JSON.parse(data);
+  } catch {
+    return data;
+  }
+};
+
+// src/utilities/random.ts
+var random_exports = {};
+__export(random_exports, {
+  number: () => number,
+  string: () => string
+});
+var import_crypto = __toESM(require("crypto"), 1);
+function string(length = 20) {
+  return import_crypto.default.randomBytes(length).toString("hex").slice(0, length);
+}
+function number(min = 0, max = 2 ** 48 - 1) {
+  return import_crypto.default.randomInt(min, max);
+}
+
+// src/instance/hooks.ts
+function registerHook(hooks, record) {
+  for (const dep of record.after) {
+    if (!hooks.some((h) => h.class === dep)) {
+      const depName = dep.name || "unknown";
+      const ownerName = record.class?.name || "anonymous";
+      throw new Error(`Missing dependency: ${ownerName} declares after: [${depName}], but ${depName} is not registered`);
+    }
+  }
+  if (record.class) {
+    const tentative = [...hooks, record];
+    detectCycle(tentative);
+  }
+  hooks.push(record);
+}
+function detectCycle(hooks) {
+  const classToAfter = /* @__PURE__ */ new Map();
+  for (const h of hooks) {
+    if (!h.class) continue;
+    const existing = classToAfter.get(h.class);
+    if (existing) {
+      for (const dep of h.after) {
+        if (!existing.includes(dep)) existing.push(dep);
+      }
+    } else {
+      classToAfter.set(h.class, [...h.after]);
+    }
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const stack = /* @__PURE__ */ new Set();
+  function visit(cls, path) {
+    if (stack.has(cls)) {
+      const cycleStart = path.indexOf(cls);
+      const cycle = [...path.slice(cycleStart), cls];
+      const names = cycle.map((c) => c.name || "unknown");
+      throw new Error(`Cycle detected: ${names.join(" \u2192 ")}`);
+    }
+    if (visited.has(cls)) return;
+    stack.add(cls);
+    path.push(cls);
+    for (const dep of classToAfter.get(cls) ?? []) {
+      visit(dep, path);
+    }
+    path.pop();
+    stack.delete(cls);
+    visited.add(cls);
+  }
+  for (const cls of classToAfter.keys()) {
+    visit(cls, []);
+  }
+}
+function resolveHookDAG(hooks, invert = false) {
+  if (hooks.length === 0) return [];
+  const classToHooks = /* @__PURE__ */ new Map();
+  const anonymous = [];
+  for (const h of hooks) {
+    if (h.class) {
+      const list = classToHooks.get(h.class);
+      if (list) list.push(h);
+      else classToHooks.set(h.class, [h]);
+    } else {
+      anonymous.push(h);
+    }
+  }
+  const classes = [...classToHooks.keys()];
+  const inDegree = /* @__PURE__ */ new Map();
+  const graph = /* @__PURE__ */ new Map();
+  for (const cls of classes) {
+    inDegree.set(cls, 0);
+    graph.set(cls, []);
+  }
+  for (const h of hooks) {
+    if (!h.class) continue;
+    for (const dep of h.after) {
+      const [from, to] = invert ? [h.class, dep] : [dep, h.class];
+      const edges = graph.get(from);
+      if (!edges.includes(to)) {
+        edges.push(to);
+        inDegree.set(to, inDegree.get(to) + 1);
+      }
+    }
+  }
+  const layers = [];
+  let queue = classes.filter((c) => inDegree.get(c) === 0);
+  while (queue.length > 0) {
+    const layer = [];
+    const next = [];
+    for (const cls of queue) {
+      layer.push(...classToHooks.get(cls) ?? []);
+    }
+    layers.push(layer);
+    for (const cls of queue) {
+      for (const neighbor of graph.get(cls) ?? []) {
+        const d = inDegree.get(neighbor) - 1;
+        inDegree.set(neighbor, d);
+        if (d === 0) next.push(neighbor);
+      }
+    }
+    queue = next;
+  }
+  if (anonymous.length > 0) {
+    const anonWithDeps = anonymous.filter((h) => h.after.length > 0);
+    const anonWithoutDeps = anonymous.filter((h) => h.after.length === 0);
+    if (anonWithDeps.length > 0) {
+      let maxLayer = -1;
+      for (const h of anonWithDeps) {
+        for (const dep of h.after) {
+          const depLayer = layers.findIndex((l) => l.some((r) => r.class === dep));
+          if (depLayer > maxLayer) maxLayer = depLayer;
+        }
+      }
+      const insertAt = maxLayer + 1;
+      if (insertAt < layers.length) {
+        layers[insertAt].push(...anonWithDeps);
+      } else {
+        layers.push(anonWithDeps);
+      }
+    }
+    if (anonWithoutDeps.length > 0) {
+      if (layers.length > 0) {
+        layers[layers.length - 1].push(...anonWithoutDeps);
+      } else {
+        layers.push(anonWithoutDeps);
+      }
+    }
+  }
+  return layers;
+}
+async function runHooks(hooks, onError = (error) => {
+  throw error;
+}, invert = false) {
+  const layers = resolveHookDAG(hooks, invert);
+  for (const layer of layers)
+    await Promise.all(
+      layer.map(async (h) => {
+        try {
+          if (typeof h.cb === "function") return await h.cb();
+          return await h.cb;
+        } catch (error) {
+          return onError(error instanceof Error ? error : new Error(`${error}`));
+        }
+      })
+    );
+}
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  class A {
+  }
+  class B {
+  }
+  class C {
+  }
+  class D {
+  }
+  const noop = () => {
+  };
+  describe("registerHook", () => {
+    test("registers a hook with no dependencies", () => {
+      const hooks = [];
+      registerHook(hooks, { cb: noop, class: A, after: [] });
+      expect(hooks).toHaveLength(1);
+    });
+    test("throws on missing dependency", () => {
+      const hooks = [];
+      expect(() => registerHook(hooks, { cb: noop, class: B, after: [A] })).toThrow(/Missing dependency.*B.*A/);
+    });
+    test("throws on cycle: A\u2192B\u2192A", () => {
+      const hooks = [];
+      registerHook(hooks, { cb: noop, class: A, after: [] });
+      registerHook(hooks, { cb: noop, class: B, after: [A] });
+      expect(() => registerHook(hooks, { cb: noop, class: A, after: [B] })).toThrow(/Cycle detected/);
+    });
+    test("throws on transitive cycle: A\u2192B\u2192C\u2192A", () => {
+      const hooks = [];
+      registerHook(hooks, { cb: noop, class: A, after: [] });
+      registerHook(hooks, { cb: noop, class: B, after: [A] });
+      registerHook(hooks, { cb: noop, class: C, after: [B] });
+      expect(() => registerHook(hooks, { cb: noop, class: A, after: [C] })).toThrow(/Cycle detected/);
+    });
+    test("allows anonymous hooks with dependencies", () => {
+      const hooks = [];
+      registerHook(hooks, { cb: noop, class: A, after: [] });
+      registerHook(hooks, { cb: noop, after: [A] });
+      expect(hooks).toHaveLength(2);
+    });
+    test("anonymous hook throws on missing dependency", () => {
+      const hooks = [];
+      expect(() => registerHook(hooks, { cb: noop, after: [A] })).toThrow(/Missing dependency.*anonymous.*A/);
+    });
+  });
+  describe("resolveHookDAG", () => {
+    test("linear chain: A \u2192 B \u2192 C", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [B] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(3);
+      expect(layers[0].every((h) => h.class === A)).toBe(true);
+      expect(layers[1].every((h) => h.class === B)).toBe(true);
+      expect(layers[2].every((h) => h.class === C)).toBe(true);
+    });
+    test("fan-out: A \u2192 B, A \u2192 C (B and C are parallel)", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [A] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(2);
+      expect(layers[0].every((h) => h.class === A)).toBe(true);
+      const secondClasses = layers[1].map((h) => h.class);
+      expect(secondClasses).toContain(B);
+      expect(secondClasses).toContain(C);
+    });
+    test("fan-in: B \u2192 D, C \u2192 D", () => {
+      const hooks = [
+        { cb: noop, class: B, after: [] },
+        { cb: noop, class: C, after: [] },
+        { cb: noop, class: D, after: [B, C] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(2);
+      const firstClasses = layers[0].map((h) => h.class);
+      expect(firstClasses).toContain(B);
+      expect(firstClasses).toContain(C);
+      expect(layers[1].every((h) => h.class === D)).toBe(true);
+    });
+    test("diamond: A \u2192 B, A \u2192 C, B \u2192 D, C \u2192 D", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [A] },
+        { cb: noop, class: D, after: [B, C] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(3);
+      expect(layers[0][0].class).toBe(A);
+      const midClasses = layers[1].map((h) => h.class);
+      expect(midClasses).toContain(B);
+      expect(midClasses).toContain(C);
+      expect(layers[2][0].class).toBe(D);
+    });
+    test("close-event inversion reverses the graph", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [B] }
+      ];
+      const layers = resolveHookDAG(hooks, true);
+      expect(layers).toHaveLength(3);
+      expect(layers[0].every((h) => h.class === C)).toBe(true);
+      expect(layers[1].every((h) => h.class === B)).toBe(true);
+      expect(layers[2].every((h) => h.class === A)).toBe(true);
+    });
+    test("close inversion: fan-out becomes fan-in", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [A] }
+      ];
+      const layers = resolveHookDAG(hooks, true);
+      expect(layers).toHaveLength(2);
+      const firstClasses = layers[0].map((h) => h.class);
+      expect(firstClasses).toContain(B);
+      expect(firstClasses).toContain(C);
+      expect(layers[1].every((h) => h.class === A)).toBe(true);
+    });
+    test("multiple hooks per class are all in the same layer", () => {
+      const cb1 = () => {
+      };
+      const cb2 = () => {
+      };
+      const hooks = [
+        { cb: cb1, class: A, after: [] },
+        { cb: cb2, class: A, after: [] },
+        { cb: noop, class: B, after: [A] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(2);
+      expect(layers[0]).toHaveLength(2);
+      expect(layers[0].every((h) => h.class === A)).toBe(true);
+    });
+    test("anonymous hooks without deps run at deepest level", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, after: [] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      expect(layers).toHaveLength(2);
+      const lastLayer = layers[layers.length - 1];
+      expect(lastLayer.some((h) => h.class === void 0)).toBe(true);
+    });
+    test("anonymous hooks with deps run after their dependencies", () => {
+      const hooks = [
+        { cb: noop, class: A, after: [] },
+        { cb: noop, class: B, after: [A] },
+        { cb: noop, class: C, after: [B] },
+        { cb: noop, after: [A] }
+      ];
+      const layers = resolveHookDAG(hooks);
+      const anonLayer = layers.findIndex((l) => l.some((h) => h.class === void 0));
+      const aLayer = layers.findIndex((l) => l.some((h) => h.class === A));
+      expect(anonLayer).toBeGreaterThan(aLayer);
+    });
+    test("empty hooks returns empty layers", () => {
+      expect(resolveHookDAG([])).toEqual([]);
+    });
+  });
+  describe("runHooks", () => {
+    test("same-depth siblings observably overlap", async () => {
+      const log = [];
+      const hooks = [
+        {
+          cb: async () => {
+            log.push("B-start");
+            await new Promise((r) => setTimeout(r, 20));
+            log.push("B-end");
+          },
+          class: B,
+          after: []
+        },
+        {
+          cb: async () => {
+            log.push("C-start");
+            await new Promise((r) => setTimeout(r, 20));
+            log.push("C-end");
+          },
+          class: C,
+          after: []
+        }
+      ];
+      await runHooks(hooks);
+      expect(log[0]).toBe("B-start");
+      expect(log[1]).toBe("C-start");
+    });
+    test("different depths run sequentially", async () => {
+      const log = [];
+      const hooks = [
+        {
+          cb: async () => {
+            log.push("A");
+          },
+          class: A,
+          after: []
+        },
+        {
+          cb: async () => {
+            log.push("B");
+          },
+          class: B,
+          after: [A]
+        }
+      ];
+      await runHooks(hooks);
+      expect(log).toEqual(["A", "B"]);
+    });
+    test("close inversion runs hooks in reverse dependency order", async () => {
+      const log = [];
+      const hooks = [
+        { cb: async () => log.push("A"), class: A, after: [] },
+        { cb: async () => log.push("B"), class: B, after: [A] },
+        { cb: async () => log.push("C"), class: C, after: [B] }
+      ];
+      await runHooks(hooks, void 0, true);
+      expect(log).toEqual(["C", "B", "A"]);
+    });
+    test("errors are routed to onError handler", async () => {
+      const errors = [];
+      const hooks = [
+        {
+          cb: () => {
+            throw new Error("boom");
+          },
+          class: A,
+          after: []
+        }
+      ];
+      await runHooks(hooks, (e) => {
+        errors.push(e);
+      });
+      expect(errors).toHaveLength(1);
+      expect(errors[0].message).toBe("boom");
+    });
+    test("raw promise callbacks are awaited", async () => {
+      const log = [];
+      const hooks = [
+        {
+          cb: Promise.resolve().then(() => log.push("resolved")),
+          class: A,
+          after: []
+        }
+      ];
+      await runHooks(hooks);
+      expect(log).toContain("resolved");
+    });
+  });
+}
+
+// src/instance/settings.ts
+var import_valleyed2 = require("valleyed");
+var instanceSettingsPipe = () => import_valleyed2.v.object({
+  app: import_valleyed2.v.object({
+    name: import_valleyed2.v.string()
+  }),
+  log: import_valleyed2.v.defaults(
+    import_valleyed2.v.object({
+      level: import_valleyed2.v.defaults(import_valleyed2.v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+    }),
+    {}
+  ),
+  utils: import_valleyed2.v.defaults(
+    import_valleyed2.v.object({
+      hashSaltRounds: import_valleyed2.v.defaults(import_valleyed2.v.number(), 10),
+      paginationDefaultLimit: import_valleyed2.v.defaults(import_valleyed2.v.number(), 100),
+      maxFileUploadSizeInMb: import_valleyed2.v.defaults(import_valleyed2.v.number(), 500)
+    }),
+    {}
+  )
+});
+
+// src/instance/index.ts
+var Instance = class _Instance {
+  static #id;
+  static #instance;
+  static #hooks = {};
+  settings;
+  log;
+  constructor(settings) {
+    _Instance.#instance = this;
+    this.settings = Object.freeze(settings);
+    this.log = (0, import_pino.default)({
+      level: this.settings.log.level,
+      serializers: {
+        err: import_pino.default.stdSerializers.err,
+        error: import_pino.default.stdSerializers.err,
+        req: import_pino.default.stdSerializers.req,
+        res: import_pino.default.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);
+  }
+  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 = import_valleyed3.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 = import_valleyed3.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 maybeGet() {
+    return _Instance.#instance;
+  }
+  static on(event, cb, options) {
+    _Instance.#hooks[event] ??= [];
+    const record = { cb, class: options?.class, after: options?.after ?? [] };
+    registerHook(_Instance.#hooks[event], record);
+  }
+  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"] ?? [], () => {
+        }, true);
+        process.exit(128 + code);
+      });
+    });
+  }
+  static resolveBeforeCrash(cb) {
+    const value = cb();
+    _Instance.on("close", async () => await value);
+    return value;
+  }
+  static crash(error) {
+    console.error(error);
+    process.exit(1);
+  }
+  static createId(opts) {
+    return `${opts?.prefix ?? ""}${(0, import_ulid.ulid)(opts?.time?.getTime())}`;
+  }
+};
+
+// src/events/adapters/rabbitmq/index.ts
+var rabbitmqConfigPipe = () => import_valleyed4.v.meta(
+  import_valleyed4.v.object({
+    uri: import_valleyed4.v.string(),
+    eventColumnName: import_valleyed4.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 = (0, import_amqp_connection_manager.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();
+    });
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RabbitMQEventBus,
+  rabbitmqConfigPipe
+});
+//# sourceMappingURL=index.cjs.map