equipped 5.2.9 → 5.3.0

package/dist/types/chunk-OHFTQGQG.js

@@ -0,0 +1,52 @@
+import {
+  EquippedError
+} from "./chunk-YTY3EFNB.js";
+
+// src/orm/errors/introspection.ts
+var OrmIntrospectionError = class extends EquippedError {
+  adapter;
+  table;
+  constructor(opts) {
+    super(`Introspection failed for table '${opts.table}' on adapter '${opts.adapter}'`, { adapter: opts.adapter, table: opts.table }, opts.cause);
+    this.adapter = opts.adapter;
+    this.table = opts.table;
+  }
+};
+if (void 0) {
+  const { describe, test, expect } = void 0;
+  const { EquippedError: EquippedError2 } = await null;
+  describe("OrmIntrospectionError", () => {
+    test("stores adapter, table, and cause on the instance", () => {
+      const cause = new Error("unknown column type");
+      const err = new OrmIntrospectionError({ adapter: "postgres", table: "users", cause });
+      expect(err.adapter).toBe("postgres");
+      expect(err.table).toBe("users");
+      expect(err.cause).toBe(cause);
+    });
+    test("message includes adapter and table", () => {
+      const err = new OrmIntrospectionError({ adapter: "pg", table: "posts", cause: "bad type" });
+      expect(err.message).toBe("Introspection failed for table 'posts' on adapter 'pg'");
+    });
+    test("instanceof EquippedError is true", () => {
+      const err = new OrmIntrospectionError({ adapter: "x", table: "y", cause: null });
+      expect(err).toBeInstanceOf(OrmIntrospectionError);
+      expect(err).toBeInstanceOf(EquippedError2);
+    });
+    test("context carries adapter and table", () => {
+      const err = new OrmIntrospectionError({ adapter: "mem", table: "items", cause: "fail" });
+      expect(err.context.adapter).toBe("mem");
+      expect(err.context.table).toBe("items");
+    });
+    test("discriminates from sibling error classes", async () => {
+      const { OrmMigrationError } = await null;
+      const { OrmValidationError } = await null;
+      const err = new OrmIntrospectionError({ adapter: "x", table: "y", cause: null });
+      expect(err).not.toBeInstanceOf(OrmMigrationError);
+      expect(err).not.toBeInstanceOf(OrmValidationError);
+    });
+  });
+}
+
+export {
+  OrmIntrospectionError
+};

package/dist/{esm/events/types/kafka.mjs → types/chunk-XGGGAEET.js}

@@ -1,18 +1,60 @@
+import {
+  EquippedError,
+  Instance,
+  configurable,
+  parseJSONValue,
+  random_exports
+} from "./chunk-YTY3EFNB.js";
+import {
+  EventBus
+} from "./chunk-KZKFYO4V.js";
+
+// src/events/adapters/kafka/index.ts
 import { KafkaJS } from "@confluentinc/kafka-javascript";
-import { EquippedError } from "../../errors/index.mjs";
-import { Instance } from "../../instance/index.mjs";
-import { Random, parseJSONValue } from "../../utilities/index.mjs";
-import { EventBus } from "../base.mjs";
-class KafkaEventBus extends EventBus {
+import { v } from "valleyed";
+var kafkaConfigPipe = () => v.meta(
+  v.object({
+    brokers: v.array(v.string()),
+    ssl: v.optional(v.boolean()),
+    sasl: v.optional(
+      v.object({
+        mechanism: v.is("plain"),
+        username: v.string(),
+        password: v.string()
+      })
+    ),
+    clientId: v.optional(v.string())
+  }),
+  { title: "Kafka Config", $refId: "KafkaConfig" }
+);
+var KafkaEventBus = class _KafkaEventBus extends configurable(kafkaConfigPipe, EventBus) {
   #client;
-  #admin;
+  #admin = null;
   constructor(config) {
-    super();
+    super(config);
     this.#client = new KafkaJS.Kafka({
       kafkaJS: { ...config, logLevel: KafkaJS.logLevel.NOTHING }
     });
   }
-  createStream(topicName, options = {}) {
+  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) => {
@@ -27,7 +69,7 @@ class KafkaEventBus extends EventBus {
       subscribe: (onMessage) => {
         const subscribe = async () => {
           await this.#createTopic(topic);
-          const groupId = options.fanout ? Instance.get().getScopedName(`${Instance.get().id}-fanout-${Random.string(10)}`) : 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 });
@@ -42,39 +84,18 @@ class KafkaEventBus extends EventBus {
             }
           });
           if (options.fanout)
-            Instance.on(
-              "close",
-              async () => {
-                await consumer.disconnect();
-                await this.#deleteGroup(groupId);
-              },
-              10
-            );
+            Instance.on("close", async () => {
+              await consumer.disconnect();
+              await this.#deleteGroup(groupId);
+            }, { class: _KafkaEventBus });
         };
-        Instance.on("start", subscribe, 2);
+        Instance.on("start", subscribe, { class: _KafkaEventBus });
       }
     };
   }
-  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(() => {
-    });
-  }
-}
+};
+
 export {
+  kafkaConfigPipe,
   KafkaEventBus
 };
-//# sourceMappingURL=kafka.mjs.map