equipped 5.2.8 → 5.3.0-alpha.0

package/dist/cjs/jobs/adapters/redis/index.cjs

@@ -0,0 +1,979 @@
+"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/jobs/adapters/redis/index.ts
+var redis_exports = {};
+__export(redis_exports, {
+  RedisJob: () => RedisJob,
+  redisJobsConfigPipe: () => redisJobsConfigPipe
+});
+module.exports = __toCommonJS(redis_exports);
+var import_bullmq = require("bullmq");
+var import_valleyed5 = require("valleyed");
+
+// src/cache/adapters/redis/index.ts
+var import_ioredis = require("ioredis");
+var import_valleyed4 = 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/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: v6 } = null;
+  const testPipe = () => v6.object({
+    host: v6.string(),
+    port: v6.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/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/cache/adapters/base.ts
+var Cache = class {
+  getScopedKey(key) {
+    return Instance.get().getScopedName(key, ":");
+  }
+  async getOrSet(key, fn, ttlInSecs) {
+    const cached = await this.get(key);
+    if (cached) return JSON.parse(cached);
+    const result = await fn();
+    await this.set(key, JSON.stringify(result), ttlInSecs);
+    return result;
+  }
+};
+
+// src/cache/adapters/redis/index.ts
+var redisConfigPipe = () => import_valleyed4.v.meta(
+  import_valleyed4.v.object({
+    host: import_valleyed4.v.string(),
+    port: import_valleyed4.v.optional(import_valleyed4.v.number()),
+    password: import_valleyed4.v.optional(import_valleyed4.v.string()),
+    username: import_valleyed4.v.optional(import_valleyed4.v.string()),
+    tls: import_valleyed4.v.optional(import_valleyed4.v.boolean()),
+    cluster: import_valleyed4.v.optional(import_valleyed4.v.boolean())
+  }),
+  { title: "Redis Config", $refId: "RedisConfig" }
+);
+var RedisCache = class _RedisCache extends configurable(redisConfigPipe, Cache) {
+  #client;
+  constructor(config, extraConfig) {
+    super(config);
+    const node = {
+      ...config.host ? { host: config.host } : {},
+      ...config.port ? { port: config.port } : {}
+    };
+    const common = {
+      ...extraConfig,
+      ...config.password ? { password: config.password } : {},
+      ...config.username ? { username: config.username } : {},
+      ...config.tls ? { tls: {} } : {},
+      lazyConnect: true
+    };
+    this.#client = config.cluster ? new import_ioredis.Cluster([node], {
+      ...extraConfig,
+      redisOptions: common,
+      lazyConnect: true
+    }) : new import_ioredis.Redis({ ...common, ...node });
+    this.#client.on("error", async (error) => {
+      Instance.crash(new EquippedError(`Redis failed with error`, {}, error));
+    });
+    if (!extraConfig) Instance.on("start", async () => this.#client.connect(), { class: _RedisCache });
+    Instance.on("close", async () => this.#client.quit(), { class: _RedisCache });
+  }
+  get connectionOptions() {
+    return this.#client.options;
+  }
+  async delete(key) {
+    await this.#client.del(this.getScopedKey(key));
+  }
+  async get(key) {
+    return await this.#client.get(this.getScopedKey(key));
+  }
+  async set(key, data, ttlInSecs) {
+    if (ttlInSecs) await this.#client.setex(this.getScopedKey(key), ttlInSecs, data);
+    else this.#client.set(this.getScopedKey(key), data);
+  }
+};
+if (void 0) {
+  const { describe, test, expect, expectTypeOf, vi, beforeEach, afterEach } = void 0;
+  let hookCalls;
+  beforeEach(() => {
+    hookCalls = [];
+    vi.spyOn(Instance, "on").mockImplementation((event, _cb, options) => {
+      hookCalls.push({ event, options });
+    });
+    vi.spyOn(Instance, "get").mockReturnValue({ getScopedName: (_name, _sep) => `test:${_name}` });
+  });
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+  describe("RedisCache", () => {
+    test("create() produces a working instance", () => {
+      const cache = RedisCache.create({ host: "localhost" });
+      expect(cache).toBeInstanceOf(RedisCache);
+    });
+    test("new RedisCache() is a compile error", () => {
+      void (() => new RedisCache({ host: "localhost" }));
+    });
+    test("Instance.on calls use { class: RedisCache }", () => {
+      RedisCache.create({ host: "localhost" });
+      const startHook = hookCalls.find((h) => h.event === "start");
+      const closeHook = hookCalls.find((h) => h.event === "close");
+      expect(startHook?.options).toEqual({ class: RedisCache });
+      expect(closeHook?.options).toEqual({ class: RedisCache });
+    });
+    test("skips start hook when extraConfig is provided", () => {
+      RedisCache.create({ host: "localhost" }, { maxRetriesPerRequest: null });
+      const startHooks = hookCalls.filter((h) => h.event === "start");
+      const closeHooks = hookCalls.filter((h) => h.event === "close");
+      expect(startHooks).toHaveLength(0);
+      expect(closeHooks).toHaveLength(1);
+    });
+    test("Config type matches pipe output", () => {
+      expectTypeOf().toEqualTypeOf();
+    });
+    test("connectionOptions is accessible", () => {
+      const cache = RedisCache.create({ host: "localhost", port: 6379 });
+      expect(cache.connectionOptions).toBeDefined();
+    });
+  });
+}
+
+// src/jobs/adapters/base.ts
+var Job = class {
+  #crons = [];
+  #callbacks = {};
+  get callbacks() {
+    return this.#callbacks;
+  }
+  set callbacks(newCallbacks) {
+    this.#callbacks = newCallbacks;
+  }
+  get crons() {
+    return this.#crons;
+  }
+  set crons(newCrons) {
+    this.#crons = newCrons;
+  }
+};
+
+// src/jobs/adapters/redis/index.ts
+var redisJobsConfigPipe = () => import_valleyed5.v.meta(
+  import_valleyed5.v.object({
+    redisConfig: redisConfigPipe(),
+    queueName: import_valleyed5.v.string()
+  }),
+  { title: "Redis Jobs Config", $refId: "RedisJobsConfig" }
+);
+var RedisJob = class _RedisJob extends configurable(redisJobsConfigPipe, Job) {
+  #queue;
+  constructor(config) {
+    super(config);
+    const redisCache = RedisCache.create(config.redisConfig, {
+      maxRetriesPerRequest: null,
+      enableReadyCheck: false
+    });
+    const queueName = Instance.get().getScopedName(config.queueName);
+    this.#queue = new import_bullmq.Queue(queueName, { connection: redisCache.connectionOptions, skipVersionCheck: true });
+    const worker = new import_bullmq.Worker(
+      queueName,
+      async (job) => {
+        switch (job.name) {
+          case "DelayedJob" /* DelayedJob */:
+            return this.callbacks.onDelayed?.(job.data);
+          case "CronJob" /* CronJob */:
+            return this.callbacks.onCron?.(job.data.type);
+          case "RepeatableJob" /* RepeatableJob */:
+            return this.callbacks.onRepeatable?.(job.data);
+        }
+      },
+      { connection: redisCache.connectionOptions, autorun: false, skipVersionCheck: true }
+    );
+    Instance.on("start", async () => {
+      await this.#cleanup();
+      await Promise.all(this.crons.map(({ cron, name }) => this.#addCron(name, cron)));
+      worker.run();
+    }, { class: _RedisJob });
+  }
+  #getNewId() {
+    return [Date.now(), random_exports.string()].join("_");
+  }
+  async #addCron(type, cron) {
+    const job = await this.#queue.add(
+      "CronJob" /* CronJob */,
+      { type },
+      {
+        jobId: this.#getNewId(),
+        repeat: { pattern: cron },
+        removeOnComplete: true,
+        backoff: 1e3,
+        attempts: 3
+      }
+    );
+    return job.id.toString();
+  }
+  async #cleanup() {
+    await this.retryAllFailedJobs();
+    const repeatableJobs = await this.#queue.getJobSchedulers();
+    await Promise.all(repeatableJobs.map((job) => this.#queue.removeJobScheduler(job.key)));
+  }
+  async addDelayed(data, delayInMs) {
+    const job = await this.#queue.add("DelayedJob" /* DelayedJob */, data, {
+      jobId: this.#getNewId(),
+      delay: delayInMs,
+      removeOnComplete: true,
+      backoff: 1e3,
+      attempts: 3
+    });
+    return job.id.toString();
+  }
+  async addRepeatable(data, cron, tz) {
+    const job = await this.#queue.add("RepeatableJob" /* RepeatableJob */, data, {
+      jobId: this.#getNewId(),
+      repeat: { pattern: cron, ...tz ? { tz } : {} },
+      removeOnComplete: true,
+      backoff: 1e3,
+      attempts: 3
+    });
+    return job.opts?.repeat?.key ?? "";
+  }
+  async removeDelayed(jobId) {
+    const job = await this.#queue.getJob(jobId);
+    if (job) await job.remove();
+  }
+  async retryAllFailedJobs() {
+    const failedJobs = await this.#queue.getFailed();
+    await Promise.all(failedJobs.map((job) => job.retry()));
+  }
+};
+if (void 0) {
+  const { test, expectTypeOf } = void 0;
+  test("external new is a compile error", () => {
+    void (() => new RedisJob({ redisConfig: { host: "" }, queueName: "" }));
+  });
+  test("Config type matches pipe output", () => {
+    expectTypeOf().toEqualTypeOf();
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  RedisJob,
+  redisJobsConfigPipe
+});
+//# sourceMappingURL=index.cjs.map