@contractspec/lib.bus 1.56.1 → 1.58.0

package/dist/browser/eventBus.js

@@ -0,0 +1,28 @@
+// src/eventBus.ts
+import {
+  eventKey
+} from "@contractspec/lib.contracts";
+function encodeEvent(envelope) {
+  return new TextEncoder().encode(JSON.stringify(envelope));
+}
+function decodeEvent(data) {
+  return JSON.parse(new TextDecoder().decode(data));
+}
+function makePublisher(bus, spec) {
+  return async (payload, traceId) => {
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: spec.meta.key,
+      version: spec.meta.version,
+      payload,
+      traceId
+    };
+    await bus.publish(eventKey(spec.meta.key, spec.meta.version), encodeEvent(envelope));
+  };
+}
+export {
+  makePublisher,
+  encodeEvent,
+  decodeEvent
+};

package/dist/browser/filtering.js

@@ -0,0 +1,147 @@
+// src/eventBus.ts
+import {
+  eventKey
+} from "@contractspec/lib.contracts";
+function encodeEvent(envelope) {
+  return new TextEncoder().encode(JSON.stringify(envelope));
+}
+function decodeEvent(data) {
+  return JSON.parse(new TextDecoder().decode(data));
+}
+function makePublisher(bus, spec) {
+  return async (payload, traceId) => {
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: spec.meta.key,
+      version: spec.meta.version,
+      payload,
+      traceId
+    };
+    await bus.publish(eventKey(spec.meta.key, spec.meta.version), encodeEvent(envelope));
+  };
+}
+
+// src/filtering.ts
+import { satisfies } from "compare-versions";
+function matchesFilter(envelope, filter) {
+  if (filter.eventName) {
+    const pattern = filter.eventName.replace(/\*/g, ".*");
+    const regex = new RegExp(`^${pattern}$`);
+    if (!regex.test(envelope.key)) {
+      return false;
+    }
+  }
+  if (filter.domain) {
+    if (!envelope.key.startsWith(filter.domain + ".")) {
+      return false;
+    }
+  }
+  if (filter.version) {
+    if (!envelope.version || !satisfies(envelope.version, filter.version)) {
+      return false;
+    }
+  }
+  if (filter.actorId && envelope.metadata?.actorId !== filter.actorId) {
+    return false;
+  }
+  if (filter.orgId && envelope.metadata?.orgId !== filter.orgId) {
+    return false;
+  }
+  if (filter.tags) {
+    const eventTags = envelope.metadata?.tags ?? {};
+    for (const [key, value] of Object.entries(filter.tags)) {
+      if (eventTags[key] !== value) {
+        return false;
+      }
+    }
+  }
+  if (filter.predicate && !filter.predicate(envelope)) {
+    return false;
+  }
+  return true;
+}
+function createFilteredSubscriber(bus, filter, handler) {
+  return async (topic) => {
+    return bus.subscribe(topic, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      if (matchesFilter(envelope, filter)) {
+        await handler(envelope);
+      }
+    });
+  };
+}
+
+class DomainEventBus {
+  bus;
+  domain;
+  constructor(bus, domain) {
+    this.bus = bus;
+    this.domain = domain;
+  }
+  async publish(spec, payload, metadata) {
+    const eventName = spec.meta.key.startsWith(this.domain + ".") ? spec.meta.key : `${this.domain}.${spec.meta.key}`;
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: eventName,
+      version: spec.meta.version,
+      payload,
+      metadata
+    };
+    const bytes = new TextEncoder().encode(JSON.stringify(envelope));
+    await this.bus.publish(`${eventName}.v${spec.meta.version}`, bytes);
+  }
+  async subscribeAll(handler) {
+    return this.bus.subscribe(`${this.domain}.*`, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      await handler(envelope);
+    });
+  }
+  async subscribeFiltered(filter, handler) {
+    const fullFilter = {
+      ...filter,
+      domain: this.domain
+    };
+    return this.bus.subscribe(`${this.domain}.*`, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      if (matchesFilter(envelope, fullFilter)) {
+        await handler(envelope);
+      }
+    });
+  }
+}
+function createDomainBus(bus, domain) {
+  return new DomainEventBus(bus, domain);
+}
+
+class EventRouter {
+  routes = [];
+  route(filter, handler) {
+    this.routes.push({ filter, handler });
+    return this;
+  }
+  async dispatch(envelope) {
+    const matchingRoutes = this.routes.filter((r) => matchesFilter(envelope, r.filter));
+    await Promise.all(matchingRoutes.map((r) => r.handler(envelope)));
+  }
+  createSubscriber(bus) {
+    return async (topic) => {
+      return bus.subscribe(topic, async (bytes) => {
+        const envelope = decodeEvent(bytes);
+        await this.dispatch(envelope);
+      });
+    };
+  }
+}
+function createEventRouter() {
+  return new EventRouter;
+}
+export {
+  matchesFilter,
+  createFilteredSubscriber,
+  createEventRouter,
+  createDomainBus,
+  EventRouter,
+  DomainEventBus
+};

package/dist/browser/inMemoryBus.js

@@ -0,0 +1,25 @@
+// src/inMemoryBus.ts
+class InMemoryBus {
+  listeners = new Map;
+  async publish(topic, payload) {
+    const handlers = this.listeners.get(topic);
+    if (!handlers)
+      return;
+    await Promise.all([...handlers].map((h) => h(payload)));
+  }
+  async subscribe(topic, handler) {
+    const topicStr = String(topic);
+    let set = this.listeners.get(topicStr);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(topicStr, set);
+    }
+    set.add(handler);
+    return async () => {
+      set?.delete(handler);
+    };
+  }
+}
+export {
+  InMemoryBus
+};

package/dist/browser/index.js

@@ -0,0 +1,373 @@
+// src/eventBus.ts
+import {
+  eventKey
+} from "@contractspec/lib.contracts";
+function encodeEvent(envelope) {
+  return new TextEncoder().encode(JSON.stringify(envelope));
+}
+function decodeEvent(data) {
+  return JSON.parse(new TextDecoder().decode(data));
+}
+function makePublisher(bus, spec) {
+  return async (payload, traceId) => {
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: spec.meta.key,
+      version: spec.meta.version,
+      payload,
+      traceId
+    };
+    await bus.publish(eventKey(spec.meta.key, spec.meta.version), encodeEvent(envelope));
+  };
+}
+
+// src/auditableBus.ts
+import {
+  eventKey as eventKey2
+} from "@contractspec/lib.contracts";
+class AuditableEventBus {
+  bus;
+  storage;
+  defaultMetadata;
+  shouldAudit;
+  transformAuditRecord;
+  constructor(options) {
+    this.bus = options.bus;
+    this.storage = options.storage;
+    this.defaultMetadata = options.defaultMetadata ?? {};
+    this.shouldAudit = options.shouldAudit ?? (() => true);
+    this.transformAuditRecord = options.transformAuditRecord;
+  }
+  async publish(topic, bytes) {
+    await this.bus.publish(topic, bytes);
+    if (this.storage) {
+      try {
+        const envelope = decodeEvent(bytes);
+        if (this.shouldAudit(envelope.key, envelope)) {
+          let record = {
+            id: crypto.randomUUID(),
+            eventKey: envelope.key,
+            eventVersion: envelope.version,
+            payload: envelope.payload,
+            metadata: {
+              ...this.defaultMetadata,
+              ...envelope.metadata
+            },
+            occurredAt: envelope.occurredAt,
+            traceId: envelope.traceId,
+            recordedAt: new Date
+          };
+          if (this.transformAuditRecord) {
+            record = this.transformAuditRecord(record);
+          }
+          await this.storage.store(record);
+        }
+      } catch (error) {
+        console.error("Failed to record audit:", error);
+      }
+    }
+  }
+  async subscribe(topic, handler) {
+    return this.bus.subscribe(topic, handler);
+  }
+  async queryAudit(options) {
+    if (!this.storage?.query) {
+      throw new Error("Audit storage does not support querying");
+    }
+    return this.storage.query(options);
+  }
+}
+function makeAuditablePublisher(bus, spec, defaultMetadata) {
+  return async (payload, options) => {
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: spec.meta.key,
+      version: spec.meta.version,
+      payload,
+      traceId: options?.traceId,
+      metadata: {
+        ...defaultMetadata,
+        ...options?.metadata
+      }
+    };
+    await bus.publish(eventKey2(spec.meta.key, spec.meta.version), encodeEvent(envelope));
+  };
+}
+
+class InMemoryAuditStorage {
+  records = [];
+  async store(record) {
+    this.records.push(record);
+  }
+  async query(options) {
+    let results = [...this.records];
+    if (options.eventKey) {
+      results = results.filter((r) => r.eventKey === options.eventKey);
+    }
+    if (options.actorId) {
+      results = results.filter((r) => r.metadata?.actorId === options.actorId);
+    }
+    if (options.targetId) {
+      results = results.filter((r) => r.metadata?.targetId === options.targetId);
+    }
+    if (options.orgId) {
+      results = results.filter((r) => r.metadata?.orgId === options.orgId);
+    }
+    if (options.traceId) {
+      results = results.filter((r) => r.traceId === options.traceId);
+    }
+    if (options.from) {
+      const from = options.from;
+      results = results.filter((r) => new Date(r.occurredAt) >= from);
+    }
+    if (options.to) {
+      const to = options.to;
+      results = results.filter((r) => new Date(r.occurredAt) <= to);
+    }
+    results.sort((a, b) => new Date(b.occurredAt).getTime() - new Date(a.occurredAt).getTime());
+    const offset = options.offset ?? 0;
+    const limit = options.limit ?? 100;
+    return results.slice(offset, offset + limit);
+  }
+  getAll() {
+    return [...this.records];
+  }
+  clear() {
+    this.records = [];
+  }
+}
+function createAuditableEventBus(bus, options) {
+  return new AuditableEventBus({
+    bus,
+    storage: options?.storage ?? new InMemoryAuditStorage,
+    ...options
+  });
+}
+
+// src/filtering.ts
+import { satisfies } from "compare-versions";
+function matchesFilter(envelope, filter) {
+  if (filter.eventName) {
+    const pattern = filter.eventName.replace(/\*/g, ".*");
+    const regex = new RegExp(`^${pattern}$`);
+    if (!regex.test(envelope.key)) {
+      return false;
+    }
+  }
+  if (filter.domain) {
+    if (!envelope.key.startsWith(filter.domain + ".")) {
+      return false;
+    }
+  }
+  if (filter.version) {
+    if (!envelope.version || !satisfies(envelope.version, filter.version)) {
+      return false;
+    }
+  }
+  if (filter.actorId && envelope.metadata?.actorId !== filter.actorId) {
+    return false;
+  }
+  if (filter.orgId && envelope.metadata?.orgId !== filter.orgId) {
+    return false;
+  }
+  if (filter.tags) {
+    const eventTags = envelope.metadata?.tags ?? {};
+    for (const [key, value] of Object.entries(filter.tags)) {
+      if (eventTags[key] !== value) {
+        return false;
+      }
+    }
+  }
+  if (filter.predicate && !filter.predicate(envelope)) {
+    return false;
+  }
+  return true;
+}
+function createFilteredSubscriber(bus, filter, handler) {
+  return async (topic) => {
+    return bus.subscribe(topic, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      if (matchesFilter(envelope, filter)) {
+        await handler(envelope);
+      }
+    });
+  };
+}
+
+class DomainEventBus {
+  bus;
+  domain;
+  constructor(bus, domain) {
+    this.bus = bus;
+    this.domain = domain;
+  }
+  async publish(spec, payload, metadata) {
+    const eventName = spec.meta.key.startsWith(this.domain + ".") ? spec.meta.key : `${this.domain}.${spec.meta.key}`;
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: eventName,
+      version: spec.meta.version,
+      payload,
+      metadata
+    };
+    const bytes = new TextEncoder().encode(JSON.stringify(envelope));
+    await this.bus.publish(`${eventName}.v${spec.meta.version}`, bytes);
+  }
+  async subscribeAll(handler) {
+    return this.bus.subscribe(`${this.domain}.*`, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      await handler(envelope);
+    });
+  }
+  async subscribeFiltered(filter, handler) {
+    const fullFilter = {
+      ...filter,
+      domain: this.domain
+    };
+    return this.bus.subscribe(`${this.domain}.*`, async (bytes) => {
+      const envelope = decodeEvent(bytes);
+      if (matchesFilter(envelope, fullFilter)) {
+        await handler(envelope);
+      }
+    });
+  }
+}
+function createDomainBus(bus, domain) {
+  return new DomainEventBus(bus, domain);
+}
+
+class EventRouter {
+  routes = [];
+  route(filter, handler) {
+    this.routes.push({ filter, handler });
+    return this;
+  }
+  async dispatch(envelope) {
+    const matchingRoutes = this.routes.filter((r) => matchesFilter(envelope, r.filter));
+    await Promise.all(matchingRoutes.map((r) => r.handler(envelope)));
+  }
+  createSubscriber(bus) {
+    return async (topic) => {
+      return bus.subscribe(topic, async (bytes) => {
+        const envelope = decodeEvent(bytes);
+        await this.dispatch(envelope);
+      });
+    };
+  }
+}
+function createEventRouter() {
+  return new EventRouter;
+}
+
+// src/inMemoryBus.ts
+class InMemoryBus {
+  listeners = new Map;
+  async publish(topic, payload) {
+    const handlers = this.listeners.get(topic);
+    if (!handlers)
+      return;
+    await Promise.all([...handlers].map((h) => h(payload)));
+  }
+  async subscribe(topic, handler) {
+    const topicStr = String(topic);
+    let set = this.listeners.get(topicStr);
+    if (!set) {
+      set = new Set;
+      this.listeners.set(topicStr, set);
+    }
+    set.add(handler);
+    return async () => {
+      set?.delete(handler);
+    };
+  }
+}
+
+// src/subscriber.ts
+async function subscribeEvent(bus, spec, handler) {
+  const topic = `${spec.meta.key}.v${spec.meta.version}`;
+  return bus.subscribe(topic, async (u8) => {
+    const env = decodeEvent(u8);
+    if (env.key !== spec.meta.key || env.version !== spec.meta.version)
+      return;
+    await handler(env.payload, { traceId: env.traceId, deliveryId: env.id });
+  });
+}
+
+// src/metadata.ts
+function createMetadataFromContext(context) {
+  return {
+    actorId: context.userId,
+    actorType: context.userId ? "user" : "system",
+    orgId: context.orgId,
+    tenantId: context.orgId,
+    sessionId: context.sessionId,
+    requestId: context.requestId,
+    traceId: context.traceId || crypto.randomUUID(),
+    clientIp: context.clientIp,
+    userAgent: context.userAgent
+  };
+}
+function mergeMetadata(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    tags: {
+      ...base.tags,
+      ...overrides.tags
+    }
+  };
+}
+
+class MetadataContext {
+  metadata;
+  constructor(initial = {}) {
+    this.metadata = { ...initial };
+    if (!this.metadata.traceId) {
+      this.metadata.traceId = crypto.randomUUID();
+    }
+  }
+  get() {
+    return { ...this.metadata };
+  }
+  set(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+  tag(key, value) {
+    this.metadata.tags = { ...this.metadata.tags, [key]: value };
+    return this;
+  }
+  child(overrides = {}) {
+    return new MetadataContext(mergeMetadata(this.metadata, {
+      ...overrides,
+      spanId: crypto.randomUUID()
+    }));
+  }
+}
+function createMetadataContext(initial) {
+  return new MetadataContext(initial);
+}
+export {
+  subscribeEvent,
+  mergeMetadata,
+  matchesFilter,
+  makePublisher,
+  makeAuditablePublisher,
+  encodeEvent,
+  decodeEvent,
+  createMetadataFromContext,
+  createMetadataContext,
+  createFilteredSubscriber,
+  createEventRouter,
+  createDomainBus,
+  createAuditableEventBus,
+  MetadataContext,
+  InMemoryBus,
+  InMemoryAuditStorage,
+  EventRouter,
+  DomainEventBus,
+  AuditableEventBus
+};

package/dist/browser/metadata.js

@@ -0,0 +1,60 @@
+// src/metadata.ts
+function createMetadataFromContext(context) {
+  return {
+    actorId: context.userId,
+    actorType: context.userId ? "user" : "system",
+    orgId: context.orgId,
+    tenantId: context.orgId,
+    sessionId: context.sessionId,
+    requestId: context.requestId,
+    traceId: context.traceId || crypto.randomUUID(),
+    clientIp: context.clientIp,
+    userAgent: context.userAgent
+  };
+}
+function mergeMetadata(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    tags: {
+      ...base.tags,
+      ...overrides.tags
+    }
+  };
+}
+
+class MetadataContext {
+  metadata;
+  constructor(initial = {}) {
+    this.metadata = { ...initial };
+    if (!this.metadata.traceId) {
+      this.metadata.traceId = crypto.randomUUID();
+    }
+  }
+  get() {
+    return { ...this.metadata };
+  }
+  set(key, value) {
+    this.metadata[key] = value;
+    return this;
+  }
+  tag(key, value) {
+    this.metadata.tags = { ...this.metadata.tags, [key]: value };
+    return this;
+  }
+  child(overrides = {}) {
+    return new MetadataContext(mergeMetadata(this.metadata, {
+      ...overrides,
+      spanId: crypto.randomUUID()
+    }));
+  }
+}
+function createMetadataContext(initial) {
+  return new MetadataContext(initial);
+}
+export {
+  mergeMetadata,
+  createMetadataFromContext,
+  createMetadataContext,
+  MetadataContext
+};

package/dist/browser/subscriber.js

@@ -0,0 +1,37 @@
+// src/eventBus.ts
+import {
+  eventKey
+} from "@contractspec/lib.contracts";
+function encodeEvent(envelope) {
+  return new TextEncoder().encode(JSON.stringify(envelope));
+}
+function decodeEvent(data) {
+  return JSON.parse(new TextDecoder().decode(data));
+}
+function makePublisher(bus, spec) {
+  return async (payload, traceId) => {
+    const envelope = {
+      id: crypto.randomUUID(),
+      occurredAt: new Date().toISOString(),
+      key: spec.meta.key,
+      version: spec.meta.version,
+      payload,
+      traceId
+    };
+    await bus.publish(eventKey(spec.meta.key, spec.meta.version), encodeEvent(envelope));
+  };
+}
+
+// src/subscriber.ts
+async function subscribeEvent(bus, spec, handler) {
+  const topic = `${spec.meta.key}.v${spec.meta.version}`;
+  return bus.subscribe(topic, async (u8) => {
+    const env = decodeEvent(u8);
+    if (env.key !== spec.meta.key || env.version !== spec.meta.version)
+      return;
+    await handler(env.payload, { traceId: env.traceId, deliveryId: env.id });
+  });
+}
+export {
+  subscribeEvent
+};

package/dist/eventBus.d.ts

@@ -1,22 +1,17 @@
-import { EventEnvelope, EventKey, EventSpec } from "@contractspec/lib.contracts";
-import { AnySchemaModel } from "@contractspec/lib.schema";
-
-//#region src/eventBus.d.ts
-interface EventBus {
-  publish: (topic: EventKey, bytes: Uint8Array) => Promise<void>;
-  subscribe: (topic: EventKey | string,
-  // allow wildcard if your broker supports it
-  handler: (bytes: Uint8Array) => Promise<void>) => Promise<() => Promise<void>>;
+import { type EventEnvelope, type EventKey, type EventSpec } from '@contractspec/lib.contracts';
+import type { AnySchemaModel } from '@contractspec/lib.schema';
+export interface EventBus {
+    publish: (topic: EventKey, bytes: Uint8Array) => Promise<void>;
+    subscribe: (topic: EventKey | string, // allow wildcard if your broker supports it
+    handler: (bytes: Uint8Array) => Promise<void>) => Promise<() => Promise<void>>;
 }
 /** Helper to encode a typed event envelope into JSON string */
-declare function encodeEvent<T>(envelope: EventEnvelope<T>): Uint8Array;
+export declare function encodeEvent<T>(envelope: EventEnvelope<T>): Uint8Array;
 /** Helper to decode JSON string into a typed event envelope */
-declare function decodeEvent<T>(data: Uint8Array): EventEnvelope<T>;
+export declare function decodeEvent<T>(data: Uint8Array): EventEnvelope<T>;
 /**
  * Create a typed publisher function for a given event spec.
  * It ensures payload conformance at compile time and builds the correct topic.
  */
-declare function makePublisher<T extends AnySchemaModel>(bus: EventBus, spec: EventSpec<T>): (payload: T, traceId?: string) => Promise<void>;
-//#endregion
-export { EventBus, decodeEvent, encodeEvent, makePublisher };
+export declare function makePublisher<T extends AnySchemaModel>(bus: EventBus, spec: EventSpec<T>): (payload: T, traceId?: string) => Promise<void>;
 //# sourceMappingURL=eventBus.d.ts.map