equipped 5.2.9 → 5.3.0-alpha.0

package/dist/types/chunk-4LRJJSGG.js

@@ -0,0 +1,112 @@
+import {
+  Cache
+} from "./chunk-LWUMIHL4.js";
+import {
+  EquippedError,
+  Instance,
+  configurable
+} from "./chunk-32DMHN3G.js";
+
+// src/cache/adapters/redis/index.ts
+import { Cluster, Redis } from "ioredis";
+import { v } from "valleyed";
+var redisConfigPipe = () => v.meta(
+  v.object({
+    host: v.string(),
+    port: v.optional(v.number()),
+    password: v.optional(v.string()),
+    username: v.optional(v.string()),
+    tls: v.optional(v.boolean()),
+    cluster: v.optional(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 Cluster([node], {
+      ...extraConfig,
+      redisOptions: common,
+      lazyConnect: true
+    }) : new 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();
+    });
+  });
+}
+
+export {
+  redisConfigPipe,
+  RedisCache
+};