@campfire-interactive/platform-events 0.1.0

package/dist/events/master-data.js

@@ -0,0 +1,337 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.masterDataEvents = void 0;
+const zod_1 = require("zod");
+/**
+ * master-data event catalog — owned by the master-data team (ADR §10).
+ *
+ * Seeded 2026-06-10 by transcribing the DEPLOYED catalog: every
+ * `publishEvent()` call site in master-data's backend services
+ * (eventPublisher.ts consumers — companyService, contactService,
+ * quoteService, programService, plantService, locationService,
+ * materialService, regionService, partFamilyService, rateLibraryService).
+ * Payload shapes here must track those call sites until master-data
+ * adopts this SDK (plan Phase 2), after which this file IS the contract.
+ *
+ * Conventions inherited from the deployed catalog:
+ * - detail-type = `<entityType>.<action>`, snake_case action
+ *   (`part_family.created`, `quote.status_changed`).
+ * - `.archived` = soft delete; `.deleted` = hard delete (contact,
+ *   location, region, part_family) — consumers drop FK references.
+ * - merge events carry `{ survivorId, mergedIds }`.
+ * - `.updated` events carry `changedFields` (names of changed fields),
+ *   not the new values.
+ * - region + part_family are platform-global: `tenantId` is null.
+ */
+const changedFields = zod_1.z.array(zod_1.z.string());
+function defineEvent(def) {
+    return def;
+}
+exports.masterDataEvents = {
+    // ── company ────────────────────────────────────────────────────────
+    'company.created': defineEvent({
+        entityType: 'company',
+        entityIdField: 'companyId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            companyId: zod_1.z.string(),
+            name: zod_1.z.string(),
+            code: zod_1.z.string().nullable(),
+            roles: zod_1.z.array(zod_1.z.enum(['supplier', 'customer', 'oem'])),
+        }),
+    }),
+    'company.updated': defineEvent({
+        entityType: 'company',
+        entityIdField: 'companyId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ companyId: zod_1.z.string(), changedFields }),
+    }),
+    'company.archived': defineEvent({
+        entityType: 'company',
+        entityIdField: 'companyId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ companyId: zod_1.z.string() }),
+    }),
+    'company.merged': defineEvent({
+        entityType: 'company',
+        entityIdField: 'survivorId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ survivorId: zod_1.z.string(), mergedIds: zod_1.z.array(zod_1.z.string()) }),
+    }),
+    // ── contact ────────────────────────────────────────────────────────
+    'contact.created': defineEvent({
+        entityType: 'contact',
+        entityIdField: 'contactId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ contactId: zod_1.z.string(), companyId: zod_1.z.string(), name: zod_1.z.string() }),
+    }),
+    'contact.updated': defineEvent({
+        entityType: 'contact',
+        entityIdField: 'contactId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ contactId: zod_1.z.string(), companyId: zod_1.z.string(), changedFields }),
+    }),
+    // hard delete — consumers drop FK references
+    'contact.deleted': defineEvent({
+        entityType: 'contact',
+        entityIdField: 'contactId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ contactId: zod_1.z.string(), companyId: zod_1.z.string() }),
+    }),
+    // ── quote ──────────────────────────────────────────────────────────
+    'quote.created': defineEvent({
+        entityType: 'quote',
+        entityIdField: 'quoteId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            quoteId: zod_1.z.string(),
+            quoteNumber: zod_1.z.string(),
+            customerCompanyId: zod_1.z.string(),
+            programId: zod_1.z.string().nullable(),
+            status: zod_1.z.string(),
+        }),
+    }),
+    'quote.updated': defineEvent({
+        entityType: 'quote',
+        entityIdField: 'quoteId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ quoteId: zod_1.z.string(), changedFields }),
+    }),
+    // caller-supplied `meta` is spread into the payload (e.g. ecoId/ecoNumber
+    // on `reason: 'eco_applied'`), hence passthrough.
+    'quote.status_changed': defineEvent({
+        entityType: 'quote',
+        entityIdField: 'quoteId',
+        tenantScoped: true,
+        payload: zod_1.z
+            .object({
+            quoteId: zod_1.z.string(),
+            from: zod_1.z.string(),
+            to: zod_1.z.string(),
+            callerRole: zod_1.z.string(),
+            reason: zod_1.z.string().nullable(),
+        })
+            .passthrough(),
+    }),
+    'quote.effective_cost_set': defineEvent({
+        entityType: 'quote',
+        entityIdField: 'quoteId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            quoteId: zod_1.z.string(),
+            unitCost: zod_1.z.number(),
+            costSource: zod_1.z.string(),
+            costBasis: zod_1.z.string().nullable(),
+            clearsPriorValue: zod_1.z.boolean(),
+        }),
+    }),
+    'quote.effective_price_set': defineEvent({
+        entityType: 'quote',
+        entityIdField: 'quoteId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            quoteId: zod_1.z.string(),
+            unitPrice: zod_1.z.number(),
+            priceSource: zod_1.z.string(),
+            priceBasis: zod_1.z.string().nullable(),
+            clearsPriorValue: zod_1.z.boolean(),
+        }),
+    }),
+    // admin override bypassing the state machine; status forced to 'lost'
+    'quote.archived': defineEvent({
+        entityType: 'quote',
+        entityIdField: 'quoteId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            quoteId: zod_1.z.string(),
+            previousStatus: zod_1.z.string(),
+            reason: zod_1.z.string().nullable(),
+        }),
+    }),
+    // ── program ────────────────────────────────────────────────────────
+    'program.created': defineEvent({
+        entityType: 'program',
+        entityIdField: 'programId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            programId: zod_1.z.string(),
+            name: zod_1.z.string(),
+            code: zod_1.z.string(),
+            customerCompanyId: zod_1.z.string(),
+        }),
+    }),
+    'program.updated': defineEvent({
+        entityType: 'program',
+        entityIdField: 'programId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ programId: zod_1.z.string(), changedFields }),
+    }),
+    'program.archived': defineEvent({
+        entityType: 'program',
+        entityIdField: 'programId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ programId: zod_1.z.string() }),
+    }),
+    // ── plant ──────────────────────────────────────────────────────────
+    'plant.created': defineEvent({
+        entityType: 'plant',
+        entityIdField: 'plantId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            plantId: zod_1.z.string(),
+            name: zod_1.z.string(),
+            code: zod_1.z.string(),
+            companyId: zod_1.z.string().nullable(),
+            locationId: zod_1.z.string().nullable(),
+        }),
+    }),
+    'plant.updated': defineEvent({
+        entityType: 'plant',
+        entityIdField: 'plantId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ plantId: zod_1.z.string(), changedFields }),
+    }),
+    'plant.archived': defineEvent({
+        entityType: 'plant',
+        entityIdField: 'plantId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ plantId: zod_1.z.string() }),
+    }),
+    'plant.merged': defineEvent({
+        entityType: 'plant',
+        entityIdField: 'survivorId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ survivorId: zod_1.z.string(), mergedIds: zod_1.z.array(zod_1.z.string()) }),
+    }),
+    // ── location ───────────────────────────────────────────────────────
+    'location.created': defineEvent({
+        entityType: 'location',
+        entityIdField: 'locationId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            locationId: zod_1.z.string(),
+            companyId: zod_1.z.string(),
+            type: zod_1.z.enum(['hq', 'plant', 'warehouse', 'sales_office', 'remit_to']),
+            name: zod_1.z.string(),
+        }),
+    }),
+    'location.updated': defineEvent({
+        entityType: 'location',
+        entityIdField: 'locationId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ locationId: zod_1.z.string(), companyId: zod_1.z.string(), changedFields }),
+    }),
+    // hard delete — consumers drop FK references
+    'location.deleted': defineEvent({
+        entityType: 'location',
+        entityIdField: 'locationId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ locationId: zod_1.z.string(), companyId: zod_1.z.string() }),
+    }),
+    // ── material ───────────────────────────────────────────────────────
+    'material.created': defineEvent({
+        entityType: 'material',
+        entityIdField: 'materialId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            materialId: zod_1.z.string(),
+            name: zod_1.z.string(),
+            code: zod_1.z.string(),
+            category: zod_1.z.string().nullable(),
+        }),
+    }),
+    // `mergedBy` (source app) is present on batch fill_empty merges
+    'material.updated': defineEvent({
+        entityType: 'material',
+        entityIdField: 'materialId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            materialId: zod_1.z.string(),
+            changedFields,
+            mergedBy: zod_1.z.string().optional(),
+        }),
+    }),
+    'material.archived': defineEvent({
+        entityType: 'material',
+        entityIdField: 'materialId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ materialId: zod_1.z.string() }),
+    }),
+    // ── region (platform-global, tenantId: null) ───────────────────────
+    'region.created': defineEvent({
+        entityType: 'region',
+        entityIdField: 'regionId',
+        tenantScoped: false,
+        payload: zod_1.z.object({ regionId: zod_1.z.string(), code: zod_1.z.string(), name: zod_1.z.string() }),
+    }),
+    'region.updated': defineEvent({
+        entityType: 'region',
+        entityIdField: 'regionId',
+        tenantScoped: false,
+        payload: zod_1.z.object({ regionId: zod_1.z.string(), changedFields }),
+    }),
+    'region.deleted': defineEvent({
+        entityType: 'region',
+        entityIdField: 'regionId',
+        tenantScoped: false,
+        payload: zod_1.z.object({ regionId: zod_1.z.string() }),
+    }),
+    // ── part_family (platform-global, tenantId: null) ──────────────────
+    'part_family.created': defineEvent({
+        entityType: 'part_family',
+        entityIdField: 'partFamilyId',
+        tenantScoped: false,
+        payload: zod_1.z.object({ partFamilyId: zod_1.z.string(), code: zod_1.z.string(), name: zod_1.z.string() }),
+    }),
+    'part_family.updated': defineEvent({
+        entityType: 'part_family',
+        entityIdField: 'partFamilyId',
+        tenantScoped: false,
+        payload: zod_1.z.object({ partFamilyId: zod_1.z.string(), changedFields }),
+    }),
+    'part_family.deleted': defineEvent({
+        entityType: 'part_family',
+        entityIdField: 'partFamilyId',
+        tenantScoped: false,
+        payload: zod_1.z.object({ partFamilyId: zod_1.z.string() }),
+    }),
+    // ── rate_library ───────────────────────────────────────────────────
+    // `forkedFrom` present when created by forking an existing library
+    'rate_library.created': defineEvent({
+        entityType: 'rate_library',
+        entityIdField: 'rateLibraryId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            rateLibraryId: zod_1.z.string(),
+            name: zod_1.z.string(),
+            code: zod_1.z.string(),
+            version: zod_1.z.number(),
+            status: zod_1.z.string(),
+            forkedFrom: zod_1.z.string().optional(),
+        }),
+    }),
+    'rate_library.updated': defineEvent({
+        entityType: 'rate_library',
+        entityIdField: 'rateLibraryId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ rateLibraryId: zod_1.z.string(), changedFields }),
+    }),
+    // lifecycle event for draft → active; distinct from `.updated`
+    'rate_library.published': defineEvent({
+        entityType: 'rate_library',
+        entityIdField: 'rateLibraryId',
+        tenantScoped: true,
+        payload: zod_1.z.object({
+            rateLibraryId: zod_1.z.string(),
+            code: zod_1.z.string(),
+            version: zod_1.z.number(),
+            effectiveDate: zod_1.z.string(),
+        }),
+    }),
+    'rate_library.archived': defineEvent({
+        entityType: 'rate_library',
+        entityIdField: 'rateLibraryId',
+        tenantScoped: true,
+        payload: zod_1.z.object({ rateLibraryId: zod_1.z.string() }),
+    }),
+};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { ENVELOPE_SCHEMA_VERSION, PRODUCERS, envelopeFor, envelopeSchema, producerSchema, } from './envelope';
+export type { Envelope, Producer } from './envelope';
+export { masterDataEvents } from './events/master-data';
+export type { EventDef, MasterDataEventType, MasterDataPayload } from './events/master-data';
+export { buildMasterDataEnvelope, configurePublisher, publishMasterDataEvent, sendCommand, } from './publisher';
+export type { PublishContext, PublisherConfig, SendCommandContext } from './publisher';
+export { isMasterDataEventType, parseEnvelope, parseMasterDataEvent } from './consumer';
+export type { MasterDataEvent } from './consumer';
+export { DynamoDbDedupStore, isReplay, withIdempotency } from './dedup';
+export type { DedupStore, DynamoDbDedupStoreOptions, HandleResult, WithIdempotencyOptions } from './dedup';
+export { relayOutbox, toOutboxRecord } from './outbox';
+export type { OutboxRecord, OutboxStore, RelayResult } from './outbox';
+export { childContext, publishCompensation, startSaga } from './saga';
+export type { SagaContext } from './saga';

package/dist/index.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startSaga = exports.publishCompensation = exports.childContext = exports.toOutboxRecord = exports.relayOutbox = exports.withIdempotency = exports.isReplay = exports.DynamoDbDedupStore = exports.parseMasterDataEvent = exports.parseEnvelope = exports.isMasterDataEventType = exports.sendCommand = exports.publishMasterDataEvent = exports.configurePublisher = exports.buildMasterDataEnvelope = exports.masterDataEvents = exports.producerSchema = exports.envelopeSchema = exports.envelopeFor = exports.PRODUCERS = exports.ENVELOPE_SCHEMA_VERSION = void 0;
+var envelope_1 = require("./envelope");
+Object.defineProperty(exports, "ENVELOPE_SCHEMA_VERSION", { enumerable: true, get: function () { return envelope_1.ENVELOPE_SCHEMA_VERSION; } });
+Object.defineProperty(exports, "PRODUCERS", { enumerable: true, get: function () { return envelope_1.PRODUCERS; } });
+Object.defineProperty(exports, "envelopeFor", { enumerable: true, get: function () { return envelope_1.envelopeFor; } });
+Object.defineProperty(exports, "envelopeSchema", { enumerable: true, get: function () { return envelope_1.envelopeSchema; } });
+Object.defineProperty(exports, "producerSchema", { enumerable: true, get: function () { return envelope_1.producerSchema; } });
+var master_data_1 = require("./events/master-data");
+Object.defineProperty(exports, "masterDataEvents", { enumerable: true, get: function () { return master_data_1.masterDataEvents; } });
+var publisher_1 = require("./publisher");
+Object.defineProperty(exports, "buildMasterDataEnvelope", { enumerable: true, get: function () { return publisher_1.buildMasterDataEnvelope; } });
+Object.defineProperty(exports, "configurePublisher", { enumerable: true, get: function () { return publisher_1.configurePublisher; } });
+Object.defineProperty(exports, "publishMasterDataEvent", { enumerable: true, get: function () { return publisher_1.publishMasterDataEvent; } });
+Object.defineProperty(exports, "sendCommand", { enumerable: true, get: function () { return publisher_1.sendCommand; } });
+var consumer_1 = require("./consumer");
+Object.defineProperty(exports, "isMasterDataEventType", { enumerable: true, get: function () { return consumer_1.isMasterDataEventType; } });
+Object.defineProperty(exports, "parseEnvelope", { enumerable: true, get: function () { return consumer_1.parseEnvelope; } });
+Object.defineProperty(exports, "parseMasterDataEvent", { enumerable: true, get: function () { return consumer_1.parseMasterDataEvent; } });
+var dedup_1 = require("./dedup");
+Object.defineProperty(exports, "DynamoDbDedupStore", { enumerable: true, get: function () { return dedup_1.DynamoDbDedupStore; } });
+Object.defineProperty(exports, "isReplay", { enumerable: true, get: function () { return dedup_1.isReplay; } });
+Object.defineProperty(exports, "withIdempotency", { enumerable: true, get: function () { return dedup_1.withIdempotency; } });
+var outbox_1 = require("./outbox");
+Object.defineProperty(exports, "relayOutbox", { enumerable: true, get: function () { return outbox_1.relayOutbox; } });
+Object.defineProperty(exports, "toOutboxRecord", { enumerable: true, get: function () { return outbox_1.toOutboxRecord; } });
+var saga_1 = require("./saga");
+Object.defineProperty(exports, "childContext", { enumerable: true, get: function () { return saga_1.childContext; } });
+Object.defineProperty(exports, "publishCompensation", { enumerable: true, get: function () { return saga_1.publishCompensation; } });
+Object.defineProperty(exports, "startSaga", { enumerable: true, get: function () { return saga_1.startSaga; } });

package/dist/outbox.d.ts

@@ -0,0 +1,44 @@
+import { Envelope } from './envelope';
+/**
+ * Transactional outbox (ADR §7). The SDK is deliberately DB-agnostic:
+ * the producer persists outbox rows inside its own DB transaction (e.g.
+ * a Prisma `event_outbox` table) and runs the relay on a schedule or
+ * post-commit hook. The SDK owns the record shape and the relay
+ * algorithm; the app owns storage.
+ *
+ * Suggested table: id (pk), envelope (jsonb), source (text),
+ * detail_type (text), created_at, published_at (nullable), attempts (int).
+ */
+export interface OutboxRecord {
+    /** = envelope.eventId — also the FIFO dedup id if the target queue is FIFO (ADR open problem 8) */
+    id: string;
+    source: string;
+    detailType: string;
+    /** JSON-serialized envelope, written in the same transaction as the state change */
+    envelopeJson: string;
+    attempts: number;
+}
+/** Build the outbox row for an envelope — call inside the producing transaction. */
+export declare function toOutboxRecord(envelope: Envelope): OutboxRecord;
+export interface OutboxStore {
+    /**
+     * Fetch up to `limit` unpublished records, oldest first. Ordering
+     * matters: the relay publishes in creation order so per-entity
+     * ordering survives the outbox hop (ADR open problem 8).
+     */
+    fetchUnpublished(limit: number): Promise<OutboxRecord[]>;
+    markPublished(id: string): Promise<void>;
+    recordAttempt(id: string, error: string): Promise<void>;
+}
+export interface RelayResult {
+    published: number;
+    failed: number;
+}
+/**
+ * Drain pending outbox rows to the bus. Stops at the first failure
+ * WITHIN an entity's sequence is not tracked here — on failure the
+ * record stays unpublished and is retried next run, and later records
+ * still publish (cross-entity reordering is acceptable; consumers order
+ * on entityVersion per ADR §5).
+ */
+export declare function relayOutbox(store: OutboxStore, publish: (record: OutboxRecord) => Promise<void>, batchSize?: number): Promise<RelayResult>;

package/dist/outbox.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toOutboxRecord = toOutboxRecord;
+exports.relayOutbox = relayOutbox;
+/** Build the outbox row for an envelope — call inside the producing transaction. */
+function toOutboxRecord(envelope) {
+    return {
+        id: envelope.eventId,
+        source: envelope.producer,
+        detailType: envelope.type,
+        envelopeJson: JSON.stringify(envelope),
+        attempts: 0,
+    };
+}
+/**
+ * Drain pending outbox rows to the bus. Stops at the first failure
+ * WITHIN an entity's sequence is not tracked here — on failure the
+ * record stays unpublished and is retried next run, and later records
+ * still publish (cross-entity reordering is acceptable; consumers order
+ * on entityVersion per ADR §5).
+ */
+async function relayOutbox(store, publish, batchSize = 50) {
+    const pending = await store.fetchUnpublished(batchSize);
+    let published = 0;
+    let failed = 0;
+    for (const record of pending) {
+        try {
+            await publish(record);
+            await store.markPublished(record.id);
+            published += 1;
+        }
+        catch (err) {
+            failed += 1;
+            await store.recordAttempt(record.id, err instanceof Error ? err.message : String(err));
+        }
+    }
+    return { published, failed };
+}

package/dist/publisher.d.ts

@@ -0,0 +1,59 @@
+import { EventBridgeClient } from '@aws-sdk/client-eventbridge';
+import { Envelope, Producer } from './envelope';
+import { MasterDataEventType, MasterDataPayload } from './events/master-data';
+/**
+ * Publisher core. Mirrors the deployed master-data publisher's posture:
+ * fire-and-forget, console fallback when EVENT_BUS_NAME is unset, never
+ * throws into the caller's request path. The transactional outbox (ADR
+ * §7) replaces fire-and-forget in plan Phase 1b.
+ */
+export interface PublisherConfig {
+    /** Defaults to process.env.EVENT_BUS_NAME; when absent, events log to console. */
+    busName?: string;
+    /** The publishing app. Defaults to process.env.PLATFORM_EVENTS_PRODUCER. */
+    producer?: Producer;
+    client?: EventBridgeClient;
+}
+export declare function configurePublisher(next: PublisherConfig): void;
+export interface PublishContext {
+    /** Required for tenant-scoped events; must be null for platform-global ones. */
+    tenantId: string | null;
+    /** Acting user, when user-initiated. */
+    userId?: string;
+    /**
+     * Override the generated eventId. Exists for the dual-publish window
+     * (master plan Phase 2): the v2 copy of an event carries the SAME
+     * eventId as its legacy v1 twin, so per-detail-type parity checks and
+     * cross-bus debugging can correlate the streams directly.
+     */
+    eventId?: string;
+    /** Monotonic per-entity version; required before SDK 1.0.0 (see envelope.ts). */
+    entityVersion?: number;
+    /** Defaults to a fresh uuid; pass through from inbound context when available. */
+    traceId?: string;
+    /** Saga correlation — derive via childContext()/startSaga() (saga.ts). */
+    sagaId?: string;
+    causationId?: string;
+    /** Marks a saga compensating ("undo") event — set via publishCompensation(). */
+    compensation?: boolean;
+    /** Override the occurred-at instant (defaults to now). */
+    occurredAt?: string;
+}
+export interface SendCommandContext extends PublishContext {
+    correlationId?: string;
+    replyTo?: string;
+}
+/** Build + validate the full envelope for a catalogued master-data event. */
+export declare function buildMasterDataEnvelope<T extends MasterDataEventType>(type: T, payload: MasterDataPayload<T>, ctx: PublishContext, producer?: Producer): Envelope<MasterDataPayload<T>>;
+/**
+ * Publish a catalogued master-data event. Fire-and-forget: failures are
+ * logged, never thrown into the caller (until the outbox lands).
+ */
+export declare function publishMasterDataEvent<T extends MasterDataEventType>(type: T, payload: MasterDataPayload<T>, ctx: PublishContext): Promise<void>;
+/**
+ * Send a point-to-point command to one app's inbox, routed through the bus
+ * on `detail.recipient` (ADR §3, default path). Command payloads are not
+ * yet catalogued — the first concrete use case (plan Phase 4) adds typed
+ * command defs alongside the event catalog.
+ */
+export declare function sendCommand(recipient: Producer, type: string, payload: Record<string, unknown>, ctx: SendCommandContext): Promise<void>;

package/dist/publisher.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configurePublisher = configurePublisher;
+exports.buildMasterDataEnvelope = buildMasterDataEnvelope;
+exports.publishMasterDataEvent = publishMasterDataEvent;
+exports.sendCommand = sendCommand;
+const node_crypto_1 = require("node:crypto");
+const client_eventbridge_1 = require("@aws-sdk/client-eventbridge");
+const envelope_1 = require("./envelope");
+const master_data_1 = require("./events/master-data");
+let config = {};
+let client;
+function configurePublisher(next) {
+    config = next;
+    client = next.client;
+}
+function resolveBusName() {
+    return config.busName ?? process.env.EVENT_BUS_NAME;
+}
+function resolveProducer() {
+    const producer = config.producer ?? process.env.PLATFORM_EVENTS_PRODUCER;
+    if (!producer) {
+        throw new Error('@campfire-interactive/platform-events: producer not configured — set PLATFORM_EVENTS_PRODUCER or call configurePublisher({ producer })');
+    }
+    return producer;
+}
+function resolveClient() {
+    if (!client)
+        client = new client_eventbridge_1.EventBridgeClient({});
+    return client;
+}
+/** Build + validate the full envelope for a catalogued master-data event. */
+function buildMasterDataEnvelope(type, payload, ctx, producer = 'master-data') {
+    const def = master_data_1.masterDataEvents[type];
+    const parsedPayload = def.payload.parse(payload);
+    if (def.tenantScoped && ctx.tenantId == null) {
+        throw new Error(`platform-events: ${type} is tenant-scoped but tenantId is null`);
+    }
+    if (!def.tenantScoped && ctx.tenantId != null) {
+        throw new Error(`platform-events: ${type} is platform-global but tenantId was provided`);
+    }
+    const entityId = parsedPayload[def.entityIdField];
+    if (typeof entityId !== 'string' || entityId.length === 0) {
+        throw new Error(`platform-events: ${type} payload is missing entity id field '${def.entityIdField}'`);
+    }
+    const envelope = {
+        schemaVersion: envelope_1.ENVELOPE_SCHEMA_VERSION,
+        eventId: ctx.eventId ?? (0, node_crypto_1.randomUUID)(),
+        occurredAt: ctx.occurredAt ?? new Date().toISOString(),
+        producer,
+        type,
+        entityType: def.entityType,
+        entityId,
+        entityVersion: ctx.entityVersion,
+        tenantId: ctx.tenantId,
+        userId: ctx.userId,
+        sagaId: ctx.sagaId,
+        causationId: ctx.causationId,
+        compensation: ctx.compensation,
+        traceId: ctx.traceId ?? (0, node_crypto_1.randomUUID)(),
+        payload: parsedPayload,
+    };
+    envelope_1.envelopeSchema.parse(envelope);
+    return envelope;
+}
+async function putOnBus(envelope, source) {
+    const busName = resolveBusName();
+    if (!busName) {
+        // Local-dev fallback, same posture as the deployed master-data publisher.
+        console.log('[platform-events] (no EVENT_BUS_NAME — console fallback)', JSON.stringify(envelope));
+        return;
+    }
+    await resolveClient().send(new client_eventbridge_1.PutEventsCommand({
+        Entries: [
+            {
+                EventBusName: busName,
+                Source: source,
+                DetailType: envelope.type,
+                Detail: JSON.stringify(envelope),
+            },
+        ],
+    }));
+}
+/**
+ * Publish a catalogued master-data event. Fire-and-forget: failures are
+ * logged, never thrown into the caller (until the outbox lands).
+ */
+async function publishMasterDataEvent(type, payload, ctx) {
+    try {
+        const envelope = buildMasterDataEnvelope(type, payload, ctx, resolveProducer());
+        await putOnBus(envelope, envelope.producer);
+    }
+    catch (err) {
+        console.error(`[platform-events] publish failed for ${type}`, err);
+    }
+}
+/**
+ * Send a point-to-point command to one app's inbox, routed through the bus
+ * on `detail.recipient` (ADR §3, default path). Command payloads are not
+ * yet catalogued — the first concrete use case (plan Phase 4) adds typed
+ * command defs alongside the event catalog.
+ */
+async function sendCommand(recipient, type, payload, ctx) {
+    try {
+        const envelope = {
+            schemaVersion: envelope_1.ENVELOPE_SCHEMA_VERSION,
+            eventId: (0, node_crypto_1.randomUUID)(),
+            occurredAt: ctx.occurredAt ?? new Date().toISOString(),
+            producer: resolveProducer(),
+            type,
+            entityType: 'command',
+            entityId: ctx.correlationId ?? (0, node_crypto_1.randomUUID)(),
+            entityVersion: ctx.entityVersion,
+            tenantId: ctx.tenantId,
+            userId: ctx.userId,
+            recipient,
+            correlationId: ctx.correlationId,
+            replyTo: ctx.replyTo,
+            sagaId: ctx.sagaId,
+            causationId: ctx.causationId,
+            traceId: ctx.traceId ?? (0, node_crypto_1.randomUUID)(),
+            payload,
+        };
+        envelope_1.envelopeSchema.parse(envelope);
+        await putOnBus(envelope, envelope.producer);
+    }
+    catch (err) {
+        console.error(`[platform-events] sendCommand failed for ${type} -> ${recipient}`, err);
+    }
+}