equipped 5.2.9 → 5.3.0

package/dist/cjs/dbs/adapters/mongodb/index.cjs

@@ -0,0 +1,1314 @@
+"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/dbs/adapters/mongodb/index.ts
+var mongodb_exports = {};
+__export(mongodb_exports, {
+  MongoDb: () => MongoDb,
+  MongoDbChange: () => MongoDbChange,
+  mongoDbConfigPipe: () => mongoDbConfigPipe
+});
+module.exports = __toCommonJS(mongodb_exports);
+
+// src/dbs/adapters/mongodb/changes.ts
+var import_mongodb = require("mongodb");
+var import_valleyed7 = 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/instance/index.ts
+var import_pino = __toESM(require("pino"), 1);
+var import_ulid = require("ulid");
+var import_valleyed2 = require("valleyed");
+
+// 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_valleyed = require("valleyed");
+var instanceSettingsPipe = () => import_valleyed.v.object({
+  app: import_valleyed.v.object({
+    name: import_valleyed.v.string()
+  }),
+  log: import_valleyed.v.defaults(
+    import_valleyed.v.object({
+      level: import_valleyed.v.defaults(import_valleyed.v.in(["fatal", "error", "warn", "info", "debug", "trace", "silent"]), "info")
+    }),
+    {}
+  ),
+  utils: import_valleyed.v.defaults(
+    import_valleyed.v.object({
+      hashSaltRounds: import_valleyed.v.defaults(import_valleyed.v.number(), 10),
+      paginationDefaultLimit: import_valleyed.v.defaults(import_valleyed.v.number(), 100),
+      maxFileUploadSizeInMb: import_valleyed.v.defaults(import_valleyed.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_valleyed2.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_valleyed2.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/utilities/configurable.ts
+var import_valleyed3 = require("valleyed");
+function configurable(pipeFn, base) {
+  const pipe = pipeFn();
+  import_valleyed3.v.compile(pipe);
+  class Configurable extends base {
+    constructor(config, ...baseArgs) {
+      super(...baseArgs);
+      this.config = config;
+    }
+    static create(input, ...args) {
+      const r = import_valleyed3.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: v10 } = null;
+  const testPipe = () => v10.object({
+    host: v10.string(),
+    port: v10.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/utilities/retry.ts
+var sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var retry = async (cb, tries, waitTimeInMs) => {
+  if (tries <= 0) throw new EquippedError("out of tries", { tries, waitTimeInMs });
+  const result = await cb();
+  if (result.done === true) return result.value;
+  await sleep(waitTimeInMs);
+  return await retry(cb, tries - 1, waitTimeInMs);
+};
+
+// src/dbs/adapters/base/changes.ts
+var import_axios = __toESM(require("axios"), 1);
+var import_valleyed6 = require("valleyed");
+
+// src/dbs/adapters/base/types.ts
+var import_valleyed5 = require("valleyed");
+
+// src/events/adapters/kafka/index.ts
+var import_kafka_javascript = require("@confluentinc/kafka-javascript");
+var import_valleyed4 = require("valleyed");
+var kafkaConfigPipe = () => import_valleyed4.v.meta(
+  import_valleyed4.v.object({
+    brokers: import_valleyed4.v.array(import_valleyed4.v.string()),
+    ssl: import_valleyed4.v.optional(import_valleyed4.v.boolean()),
+    sasl: import_valleyed4.v.optional(
+      import_valleyed4.v.object({
+        mechanism: import_valleyed4.v.is("plain"),
+        username: import_valleyed4.v.string(),
+        password: import_valleyed4.v.string()
+      })
+    ),
+    clientId: import_valleyed4.v.optional(import_valleyed4.v.string())
+  }),
+  { title: "Kafka Config", $refId: "KafkaConfig" }
+);
+var KafkaEventBus = class _KafkaEventBus extends configurable(kafkaConfigPipe, EventBus) {
+  #client;
+  #admin = null;
+  constructor(config) {
+    super(config);
+    this.#client = new import_kafka_javascript.KafkaJS.Kafka({
+      kafkaJS: { ...config, logLevel: import_kafka_javascript.KafkaJS.logLevel.NOTHING }
+    });
+  }
+  async #getAdmin() {
+    if (!this.#admin)
+      this.#admin = (async () => {
+        const admin = this.#client.admin();
+        await admin.connect();
+        return admin;
+      })();
+    return this.#admin;
+  }
+  async #createTopic(topic) {
+    const admin = await this.#getAdmin();
+    await admin.createTopics({ topics: [{ topic }], timeout: 5e3 });
+  }
+  async #deleteGroup(groupId) {
+    const admin = await this.#getAdmin();
+    await admin.deleteGroups([groupId]).catch(() => {
+    });
+  }
+  stream(topicName, options = {}) {
+    const topic = options.skipScope ? topicName : Instance.get().getScopedName(topicName);
+    return {
+      publish: async (data) => {
+        const producer = this.#client.producer();
+        await producer.connect();
+        await producer.send({
+          topic,
+          messages: [{ value: JSON.stringify(data) }]
+        });
+        return true;
+      },
+      subscribe: (onMessage) => {
+        const subscribe = async () => {
+          await this.#createTopic(topic);
+          const groupId = options.fanout ? Instance.get().getScopedName(`${Instance.get().id}-fanout-${random_exports.string(10)}`) : topic;
+          const consumer = this.#client.consumer({ kafkaJS: { groupId } });
+          await consumer.connect();
+          await consumer.subscribe({ topic });
+          await consumer.run({
+            eachMessage: async ({ message }) => {
+              await Instance.resolveBeforeCrash(async () => {
+                if (!message.value) return;
+                await onMessage(parseJSONValue(message.value.toString()));
+              }).catch(
+                (error) => Instance.crash(new EquippedError("Error processing kafka event", { topic, groupId, options }, error))
+              );
+            }
+          });
+          if (options.fanout)
+            Instance.on("close", async () => {
+              await consumer.disconnect();
+              await this.#deleteGroup(groupId);
+            }, { class: _KafkaEventBus });
+        };
+        Instance.on("start", subscribe, { class: _KafkaEventBus });
+      }
+    };
+  }
+};
+
+// src/dbs/adapters/base/types.ts
+var dbChangeConfigPipe = () => import_valleyed5.v.object({
+  debeziumUrl: import_valleyed5.v.string(),
+  eventBus: import_valleyed5.v.instanceOf(KafkaEventBus)
+});
+
+// src/dbs/adapters/base/changes.ts
+var TopicPrefix = "db-changes";
+var DbChange = class {
+  constructor(config, callbacks, mapper) {
+    this.config = config;
+    this.callbacks = callbacks;
+    this.mapper = mapper;
+    this.config = import_valleyed6.v.assert(dbChangeConfigPipe(), config);
+  }
+  async configureConnector(key, data) {
+    const instance = import_axios.default.create({ baseURL: this.config.debeziumUrl });
+    return await instance.put(`/connectors/${key}/config`, {
+      "topic.prefix": TopicPrefix,
+      "topic.creation.enable": "false",
+      "topic.creation.default.replication.factor": `-1`,
+      "topic.creation.default.partitions": "-1",
+      "key.converter": "org.apache.kafka.connect.json.JsonConverter",
+      "key.converter.schemas.enable": "false",
+      "value.converter": "org.apache.kafka.connect.json.JsonConverter",
+      "value.converter.schemas.enable": "false",
+      ...data
+    }).then(async () => {
+      const topics = await instance.get(`/connectors/${key}/topics`);
+      return topics.data[key]?.topics?.includes?.(key) ?? false;
+    }).catch((err) => {
+      throw new EquippedError(`Failed to configure watcher`, { key }, err);
+    });
+  }
+};
+
+// src/dbs/adapters/mongodb/changes.ts
+var MongoDbChange = class extends DbChange {
+  #started = false;
+  constructor(config, change, collection, callbacks, mapper) {
+    super(change, callbacks, mapper);
+    const hydrate = (data) => data._id ? {
+      ...data,
+      _id: data._id["$oid"] ?? data._id
+    } : void 0;
+    const dbName = collection.dbName;
+    const colName = collection.collectionName;
+    const dbColName = `${dbName}.${colName}`;
+    const topic = `${TopicPrefix}.${dbColName}`;
+    const TestId = "5f5f65717569707065645f5f";
+    const condition = { _id: TestId };
+    change.eventBus.stream(topic, { skipScope: true }).subscribe(async (data) => {
+      const op = data.op;
+      let before = JSON.parse(data.before ?? "null");
+      let after = JSON.parse(data.after ?? "null");
+      if (before) before = hydrate(before);
+      if (after) after = hydrate(after);
+      if (before?._id === TestId || after?._id === TestId) return;
+      if (op === "c" && this.callbacks.created && after)
+        await this.callbacks.created({
+          before: null,
+          after: this.mapper(after)
+        });
+      else if (op === "u" && this.callbacks.updated && before && after)
+        await this.callbacks.updated({
+          before: this.mapper(before),
+          after: this.mapper(after),
+          changes: import_valleyed7.differ.from(import_valleyed7.differ.diff(before, after))
+        });
+      else if (op === "d" && this.callbacks.deleted && before)
+        await this.callbacks.deleted({
+          before: this.mapper(before),
+          after: null
+        });
+    });
+    Instance.on("start", async () => {
+      if (this.#started) return;
+      this.#started = true;
+      await retry(
+        async () => {
+          const started = await this.configureConnector(topic, {
+            "connector.class": "io.debezium.connector.mongodb.MongoDbConnector",
+            "capture.mode": "change_streams_update_full_with_pre_image",
+            "mongodb.connection.string": config.uri,
+            "collection.include.list": dbColName,
+            "snapshot.mode": "when_needed",
+            "capture.scope": "collection",
+            "capture.target": dbColName,
+            "heartbeat.interval.ms": "60000",
+            "errors.max.retries": "3"
+          });
+          if (started) return { done: true, value: true };
+          await collection.findOneAndUpdate(condition, { $set: { colName } }, { upsert: true });
+          await collection.findOneAndDelete(condition);
+          Instance.get().log.warn(`Waiting for db changes for ${dbColName} to start...`);
+          return { done: false };
+        },
+        6,
+        3e4
+      ).catch((err) => Instance.crash(new EquippedError(`Failed to start db changes`, { dbColName }, err)));
+    });
+  }
+};
+
+// src/dbs/adapters/mongodb/db.ts
+var import_node_async_hooks = require("async_hooks");
+var import_mongodb3 = require("mongodb");
+var import_valleyed10 = require("valleyed");
+
+// src/dbs/adapters/mongodb/pipes.ts
+var import_valleyed8 = require("valleyed");
+var mongoDbConfigPipe = () => import_valleyed8.v.meta(
+  import_valleyed8.v.object({
+    uri: import_valleyed8.v.string()
+  }),
+  { title: "Mongodb Config", $refId: "MongodbConfig" }
+);
+
+// src/dbs/adapters/mongodb/query.ts
+var import_mongodb2 = require("mongodb");
+
+// src/dbs/pipes.ts
+var import_valleyed9 = require("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 = import_valleyed9.v.catch(import_valleyed9.v.defaults(import_valleyed9.v.in(["and" /* and */, "or" /* or */]), "and" /* and */), "and" /* and */);
+var queryWhere = import_valleyed9.v.object({
+  field: import_valleyed9.v.string(),
+  value: import_valleyed9.v.any(),
+  // eslint-disable-next-line promise/valid-params -- valleyed v.catch(schema, fallback) is not Promise.prototype.catch
+  condition: import_valleyed9.v.catch(import_valleyed9.v.defaults(import_valleyed9.v.in(Object.values(Conditions)), "eq" /* eq */), "eq" /* eq */)
+});
+var queryWhereBlock = import_valleyed9.v.recursive(
+  () => import_valleyed9.v.discriminate((d) => Object.values(QueryKeys).includes(d.condition) ? "block" : "regular", {
+    block: import_valleyed9.v.object({
+      condition: queryKeys,
+      value: import_valleyed9.v.array(queryWhereBlock)
+    }),
+    regular: queryWhere
+  }),
+  "QueryWhereBlock"
+);
+var queryWhereClause = import_valleyed9.v.defaults(import_valleyed9.v.array(queryWhereBlock), []);
+
+// src/dbs/adapters/mongodb/query.ts
+var parseMongodbQueryParams = async (collection, params) => {
+  const query = [];
+  const where = buildWhereQuery(params.where, params.whereType);
+  if (where) query.push(where);
+  const auth = buildWhereQuery(params.auth, params.authType);
+  if (auth) query.push(auth);
+  if (params.search && params.search.fields.length > 0) {
+    const search = params.search.fields.map((field) => ({
+      [field]: {
+        $regex: new RegExp(params.search.value, "i")
+      }
+    }));
+    query.push({ $or: search });
+  }
+  const totalClause = {};
+  if (query.length > 0) totalClause["$and"] = query;
+  const sort = params.sort.map((p) => [p.field, p.desc ? "desc" : "asc"]);
+  const all = params.all ?? false;
+  const limit = params.limit;
+  const page = params.page;
+  const total = await collection.countDocuments(totalClause);
+  const projection = params.select?.length ? Object.fromEntries(params.select.map((k) => [k, 1])) : void 0;
+  let builtQuery = collection.find(totalClause, { projection });
+  if (sort.length) builtQuery = builtQuery.sort(Object.fromEntries(sort));
+  if (!all && limit) {
+    builtQuery = builtQuery.limit(limit);
+    if (page) builtQuery = builtQuery.skip((page - 1) * limit);
+  }
+  const results = await builtQuery.toArray();
+  const start = 1;
+  const last = Math.ceil(total / limit) || 1;
+  const next = page >= last ? null : page + 1;
+  const previous = page <= start ? null : page - 1;
+  return {
+    pages: { start, last, next, previous, current: page },
+    docs: { limit, total, count: results.length },
+    results
+  };
+};
+function isWhereBlock(param) {
+  return Object.values(QueryKeys).includes(param.condition);
+}
+var buildWhereQuery = (params, key = "and" /* and */) => {
+  const where = (Array.isArray(params) ? params : []).map((param) => {
+    if (isWhereBlock(param)) return buildWhereQuery(param.value, param.condition);
+    const { field } = param;
+    const checkedField = field === "id" ? "_id" : field ?? "";
+    const checkedValue = param.value === void 0 ? "" : param.value;
+    return {
+      field: checkedField,
+      value: checkedValue,
+      condition: param.condition,
+      isWhere: true
+    };
+  }).filter((c) => !!c).map((c) => {
+    if (c.isWhere) return { [`${c.field}`]: { [`$${c.condition}`]: c.value } };
+    else return c;
+  });
+  return where.length > 0 ? { [`$${key}`]: where } : null;
+};
+
+// 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/mongodb/db.ts
+var idKey = "_id";
+var sessionStore = new import_node_async_hooks.AsyncLocalStorage(void 0);
+var MongoDb = class extends Db {
+  constructor(mongoConfig, dbConfig) {
+    super(dbConfig);
+    this.mongoConfig = mongoConfig;
+    this.mongoConfig = import_valleyed10.v.assert(mongoDbConfigPipe(), mongoConfig);
+    this.client = new import_mongodb3.MongoClient(mongoConfig.uri, { ignoreUndefined: true });
+    Instance.on("start", async () => {
+      await this.client.connect();
+      const grouped = this.#cols.reduce((acc, cur) => {
+        if (!acc[cur.db]) acc[cur.db] = [];
+        acc[cur.db].push(cur.col);
+        return acc;
+      }, {});
+      const options = {
+        changeStreamPreAndPostImages: { enabled: true }
+      };
+      await Promise.all(
+        Object.entries(grouped).map(async ([dbName, colNames]) => {
+          const db = this.client.db(dbName);
+          const collections = await db.listCollections().toArray();
+          return colNames.map(async (colName) => {
+            const existing = collections.find((collection) => collection.name === colName);
+            if (existing) {
+              if (existing.options?.changeStreamPreAndPostImages?.enabled !== options.changeStreamPreAndPostImages.enabled)
+                await db.command({ collMod: colName, ...options });
+            } else await db.createCollection(colName, options);
+          });
+        })
+      );
+    });
+    Instance.on("close", async () => this.client.close());
+  }
+  client;
+  #cols = [];
+  async session(callback) {
+    if (sessionStore.getStore()) return callback();
+    const session = await this.client.startSession();
+    return session.withTransaction(async () => sessionStore.run(session, callback));
+  }
+  id() {
+    return new import_mongodb3.ObjectId();
+  }
+  use(config) {
+    const db = this.getScopedDb(config.db);
+    this.#cols.push({ db, col: config.col });
+    return this.#getTable(config, this.client.db(db).collection(config.col));
+  }
+  #getTable(config, collection) {
+    function transform(doc, select) {
+      const docs = Array.isArray(doc) ? doc : [doc];
+      const mapped = docs.map((d) => config.mapper(d, select));
+      return Array.isArray(doc) ? mapped : mapped[0];
+    }
+    function prepInsertValue(value, id, now, skipUpdate) {
+      const base = {
+        [idKey]: id,
+        ...config.options?.skipAudit ? {} : {
+          createdAt: now.getTime(),
+          ...skipUpdate ? {} : { updatedAt: now.getTime() }
+        }
+      };
+      return {
+        ...value,
+        ...base
+      };
+    }
+    function prepUpdateValue(value, now, upsert = false) {
+      return {
+        ...value,
+        $set: {
+          ...value.$set,
+          ...upsert || Object.keys(value).length > 0 && !config.options?.skipAudit ? { updatedAt: now.getTime() } : {}
+        }
+      };
+    }
+    const dbThis = this;
+    const table = {
+      config,
+      extras: { collection },
+      query: async (params) => {
+        const results = await parseMongodbQueryParams(collection, params);
+        return {
+          ...results,
+          results: transform(results.results, params.select)
+        };
+      },
+      findMany: async (filter, options = {}) => {
+        const { select, ...rest } = options;
+        const projection = select?.length ? Object.fromEntries(select.map((k) => [k, 1])) : void 0;
+        const sortArray = Array.isArray(rest.sort) ? rest.sort : rest.sort ? [rest.sort] : [];
+        const sort = sortArray.map((p) => [p.field, p.desc ? "desc" : "asc"]);
+        const docs = await collection.find(filter, {
+          session: sessionStore.getStore(),
+          limit: rest.limit,
+          sort,
+          projection
+        }).toArray();
+        return transform(docs, select);
+      },
+      findOne: async (filter, options = {}) => {
+        const result = await table.findMany(filter, { ...options, limit: 1 });
+        return result.at(0) ?? null;
+      },
+      findById: async (id, options = {}) => {
+        const result = await table.findOne({ [idKey]: id }, options);
+        return result;
+      },
+      insertMany: async (values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const payload = values.map((value, i) => prepInsertValue(value, options.makeId?.(i) ?? new import_mongodb3.ObjectId().toString(), now));
+        await collection.insertMany(payload, { session: sessionStore.getStore() });
+        const insertedData = await Promise.all(payload.map(async (data) => await table.findById(data[idKey])));
+        return insertedData.filter((value) => !!value);
+      },
+      insertOne: async (values, options = {}) => {
+        const result = await table.insertMany([values], options);
+        return result[0];
+      },
+      updateMany: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const session = sessionStore.getStore();
+        const data = await collection.find(filter, { session, projection: { [idKey]: 1 } }).toArray();
+        const ids = data.map((doc) => doc[idKey]);
+        const filterUpd = { [idKey]: { $in: ids } };
+        await collection.updateMany(filterUpd, prepUpdateValue(values, now), { session });
+        return table.findMany(filterUpd);
+      },
+      updateOne: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const doc = await collection.findOneAndUpdate(filter, prepUpdateValue(values, now), {
+          returnDocument: "after",
+          session: sessionStore.getStore()
+        });
+        return doc ? transform(doc, void 0) : null;
+      },
+      updateById: async (id, values, options = {}) => {
+        const result = await table.updateOne({ [idKey]: id }, values, options);
+        return result;
+      },
+      upsertOne: async (filter, values, options = {}) => {
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        const doc = await collection.findOneAndUpdate(
+          filter,
+          {
+            ...prepUpdateValue("update" in values ? values.update : {}, now, true),
+            // @ts-expect-error fighting ts
+            $setOnInsert: prepInsertValue(values.insert, options.makeId?.() ?? new import_mongodb3.ObjectId().toString(), now, true)
+          },
+          { returnDocument: "after", session: sessionStore.getStore(), upsert: true }
+        );
+        return transform(doc, void 0);
+      },
+      deleteMany: async (filter, options = {}) => {
+        const docs = await table.findMany(filter, options);
+        await collection.deleteMany(filter, { session: sessionStore.getStore() });
+        return docs;
+      },
+      deleteOne: async (filter) => {
+        const doc = await collection.findOneAndDelete(filter, { session: sessionStore.getStore() });
+        return doc ? transform(doc, void 0) : null;
+      },
+      deleteById: async (id) => {
+        const result = await table.deleteOne({ [idKey]: id });
+        return result;
+      },
+      bulkWrite: async (operations, options = {}) => {
+        if (!operations.length) return;
+        const bulk = collection.initializeUnorderedBulkOp({ session: sessionStore.getStore() });
+        const now = options.getTime?.() ?? /* @__PURE__ */ new Date();
+        operations.forEach((operation, i) => {
+          switch (operation.op) {
+            case "insert":
+              bulk.insert(prepInsertValue(operation.value, operation.makeId?.(i) ?? new import_mongodb3.ObjectId().toString(), now));
+              break;
+            case "delete":
+              bulk.find(operation.filter).delete();
+              break;
+            case "update":
+              bulk.find(operation.filter).update(prepUpdateValue(operation.value, now));
+              break;
+            case "upsert":
+              bulk.find(operation.filter).upsert().update({
+                ...prepUpdateValue("update" in operation ? operation.update : {}, now, true),
+                $setOnInsert: prepInsertValue(
+                  operation.insert,
+                  operation.makeId?.(i) ?? new import_mongodb3.ObjectId().toString(),
+                  now,
+                  true
+                )
+              });
+              break;
+            default:
+              throw new EquippedError(`Unknown bulkWrite operation`, { operation });
+          }
+        });
+        await bulk.execute({ session: sessionStore.getStore() });
+      },
+      watch(callbacks) {
+        if (!dbThis.config.changes)
+          Instance.crash(new EquippedError("Db changes are not enabled in the configuration.", { config }));
+        return new MongoDbChange(
+          dbThis.mongoConfig,
+          dbThis.config.changes,
+          collection,
+          callbacks,
+          (m) => config.mapper(m)
+        );
+      }
+    };
+    return table;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MongoDb,
+  MongoDbChange,
+  mongoDbConfigPipe
+});
+//# sourceMappingURL=index.cjs.map