@uengage.io/platform-sdk 0.15.0 → 2.0.0

package/dist/events/client.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEventsClient = createEventsClient;
+const client_sns_1 = require("@aws-sdk/client-sns");
+const ulid_1 = require("ulid");
+const errors_1 = require("../errors");
+const schema_1 = require("./schema");
+/** SNS caps PublishBatch at 10 entries per call. */
+const SNS_BATCH_MAX = 10;
+/**
+ * SNS caps a single message at 256 KB, and a whole PublishBatch request
+ * at the same 256 KB across all its entries.
+ */
+const SNS_MAX_BYTES = 262_144;
+/**
+ * Headroom left for the `type` / `domain` / `source` message attributes,
+ * which count toward the limit alongside the body. A few hundred bytes
+ * covers them; being conservative here costs nothing, since an envelope
+ * anywhere near the cap is a call-site mistake either way.
+ */
+const ATTRIBUTE_ALLOWANCE_BYTES = 1_024;
+const MAX_MESSAGE_BYTES = SNS_MAX_BYTES - ATTRIBUTE_ALLOWANCE_BYTES;
+/**
+ * Byte length of a UTF-8 string. `TextEncoder` rather than
+ * `Buffer.byteLength` so this file carries no Node built-in.
+ */
+const encoder = new TextEncoder();
+function byteLength(value) {
+    return encoder.encode(value).length;
+}
+/**
+ * Monotonic within this process: two events minted in the same
+ * millisecond still sort in emission order. Downstream consumers use the
+ * envelope `id` as the ordering and dedupe key, so this is load-bearing,
+ * not a nicety.
+ */
+const nextUlid = (0, ulid_1.monotonicFactory)();
+/**
+ * Build an isolated events client. Reads `PLATFORM_EVENTS_TOPIC_ARN` and
+ * friends from the environment for anything not passed explicitly, so a
+ * Lambda whose deploy stack injected the ARN needs no arguments.
+ */
+function createEventsClient(input = {}) {
+    let client = input.snsClient;
+    function topicArn() {
+        const arn = input.topicArn ?? env('PLATFORM_EVENTS_TOPIC_ARN');
+        if (!arn) {
+            throw new errors_1.ConfigError('events.publish: no topic ARN. Pass {topicArn} to createEventsClient or set PLATFORM_EVENTS_TOPIC_ARN.');
+        }
+        return arn;
+    }
+    function sns() {
+        if (!client) {
+            const region = input.region ?? regionFromArn(topicArn()) ?? env('AWS_REGION') ?? env('AWS_DEFAULT_REGION');
+            client = new client_sns_1.SNSClient(region ? { region } : {});
+        }
+        return client;
+    }
+    function source(override) {
+        return (override ??
+            input.source ??
+            env('PLATFORM_EVENTS_SOURCE') ??
+            env('SERVICE_NAME') ??
+            'platform-sdk');
+    }
+    function buildEnvelope(type, data, opts) {
+        const domain = (0, schema_1.domainForEventType)(type);
+        if (!domain) {
+            throw new errors_1.ValidationError(`events.publish: cannot route event type "${type}". It must be a dotted ` +
+                '"<resource>.<operation>" name whose resource maps to a known bus domain ' +
+                '(order, customer, menu, offer, loyalty, usage). Adding a domain is a one-line ' +
+                'edit in events/schema.ts and its two mirrors.');
+        }
+        const candidate = {
+            id: nextUlid(),
+            type,
+            domain,
+            source: source(opts.source),
+            version: schema_1.PLATFORM_EVENT_VERSION,
+            occurredAt: opts.occurredAt ?? isoNow(),
+            tenantId: opts.tenantId,
+            data,
+        };
+        const result = schema_1.platformEventSchema.safeParse(candidate);
+        if (!result.success) {
+            throw new errors_1.ValidationError(`events.publish: invalid envelope for "${type}"`, {
+                issues: result.error.issues,
+            });
+        }
+        return result.data;
+    }
+    /**
+     * Serialize and size-check one envelope.
+     *
+     * Checked before the publish rather than after the rejection because
+     * SNS's own error for an oversized message names neither the event nor
+     * the offending field, and on the PHP side the same failure disappears
+     * into `error_log`. Better to say which event and how big.
+     */
+    function serialize(event) {
+        const message = JSON.stringify(event);
+        const size = byteLength(message);
+        if (size > MAX_MESSAGE_BYTES) {
+            throw new errors_1.ValidationError(`events.publish: event ${event.id} ("${event.type}") serializes to ${size} bytes, ` +
+                `over the ${MAX_MESSAGE_BYTES}-byte ceiling (SNS caps a message at 256KB including ` +
+                'attributes). Put the payload somewhere addressable and reference it from `data`.');
+        }
+        return message;
+    }
+    return {
+        async publish(type, data, opts) {
+            const event = buildEnvelope(type, data, opts);
+            const message = serialize(event);
+            const arn = topicArn();
+            try {
+                await sns().send(new client_sns_1.PublishCommand({
+                    TopicArn: arn,
+                    Message: message,
+                    MessageAttributes: messageAttributes(event),
+                }));
+            }
+            catch (err) {
+                throw new errors_1.EventPublishError(`events.publish: SNS publish failed for "${type}"`, {
+                    failedEventIds: [event.id],
+                    cause: err,
+                });
+            }
+            return event;
+        },
+        async publishBatch(events) {
+            if (events.length === 0)
+                return [];
+            const envelopes = events.map((e) => buildEnvelope(e.type, e.data, e));
+            // Serialize (and size-check) everything up front, so an oversized
+            // event fails the call before any of its siblings are published.
+            const messages = new Map(envelopes.map((event) => [event.id, serialize(event)]));
+            const arn = topicArn();
+            const failed = [];
+            let firstError;
+            for (const group of chunkByBytes(envelopes, messages)) {
+                const entries = group.map((event) => ({
+                    Id: event.id,
+                    Message: messages.get(event.id),
+                    MessageAttributes: messageAttributes(event),
+                }));
+                try {
+                    const resp = await sns().send(new client_sns_1.PublishBatchCommand({ TopicArn: arn, PublishBatchRequestEntries: entries }));
+                    for (const f of resp.Failed ?? []) {
+                        if (f.Id)
+                            failed.push(f.Id);
+                    }
+                }
+                catch (err) {
+                    firstError = firstError ?? err;
+                    for (const event of group)
+                        failed.push(event.id);
+                }
+            }
+            if (failed.length > 0) {
+                throw new errors_1.EventPublishError(`events.publishBatch: ${failed.length}/${envelopes.length} event(s) did not reach the bus`, { failedEventIds: failed, cause: firstError });
+            }
+            return envelopes;
+        },
+    };
+}
+function messageAttributes(event) {
+    return {
+        type: { DataType: 'String', StringValue: event.type },
+        domain: { DataType: 'String', StringValue: event.domain },
+        source: { DataType: 'String', StringValue: event.source },
+    };
+}
+/** `arn:aws:sns:<region>:<account>:<name>` → `<region>`. */
+function regionFromArn(arn) {
+    const parts = arn.split(':');
+    return parts.length >= 4 && parts[3] ? parts[3] : undefined;
+}
+/** UTC ISO 8601, seconds precision — the format the envelope schema pins. */
+function isoNow() {
+    return new Date().toISOString().replace(/\.\d{3}Z$/, 'Z');
+}
+function env(name) {
+    if (typeof process === 'undefined')
+        return undefined;
+    const value = process.env?.[name];
+    return value === '' ? undefined : value;
+}
+/**
+ * Group envelopes into PublishBatch calls bounded by BOTH limits: at most
+ * 10 entries, and at most 256 KB of combined payload.
+ *
+ * The byte bound matters as soon as payloads get rich — ten 30 KB
+ * envelopes are each individually legal and collectively over the
+ * request cap, and SNS rejects the whole call rather than the overflow.
+ */
+function chunkByBytes(envelopes, messages) {
+    const out = [];
+    let current = [];
+    let currentBytes = 0;
+    for (const event of envelopes) {
+        const size = byteLength(messages.get(event.id)) + ATTRIBUTE_ALLOWANCE_BYTES;
+        const full = current.length >= SNS_BATCH_MAX;
+        const wouldOverflow = current.length > 0 && currentBytes + size > SNS_MAX_BYTES;
+        if (full || wouldOverflow) {
+            out.push(current);
+            current = [];
+            currentBytes = 0;
+        }
+        current.push(event);
+        currentBytes += size;
+    }
+    if (current.length > 0)
+        out.push(current);
+    return out;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/events/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  SNSClient,\n  PublishCommand,\n  PublishBatchCommand,\n  type PublishBatchRequestEntry,\n  type MessageAttributeValue,\n} from '@aws-sdk/client-sns';\nimport { monotonicFactory } from 'ulid';\nimport { ConfigError, EventPublishError, ValidationError } from '../errors';\nimport {\n  domainForEventType,\n  platformEventSchema,\n  PLATFORM_EVENT_VERSION,\n  type PlatformEvent,\n} from './schema';\n\n/** SNS caps PublishBatch at 10 entries per call. */\nconst SNS_BATCH_MAX = 10;\n\n/**\n * SNS caps a single message at 256 KB, and a whole PublishBatch request\n * at the same 256 KB across all its entries.\n */\nconst SNS_MAX_BYTES = 262_144;\n\n/**\n * Headroom left for the `type` / `domain` / `source` message attributes,\n * which count toward the limit alongside the body. A few hundred bytes\n * covers them; being conservative here costs nothing, since an envelope\n * anywhere near the cap is a call-site mistake either way.\n */\nconst ATTRIBUTE_ALLOWANCE_BYTES = 1_024;\n\nconst MAX_MESSAGE_BYTES = SNS_MAX_BYTES - ATTRIBUTE_ALLOWANCE_BYTES;\n\n/**\n * Byte length of a UTF-8 string. `TextEncoder` rather than\n * `Buffer.byteLength` so this file carries no Node built-in.\n */\nconst encoder = new TextEncoder();\n\nfunction byteLength(value: string): number {\n  return encoder.encode(value).length;\n}\n\n/**\n * Monotonic within this process: two events minted in the same\n * millisecond still sort in emission order. Downstream consumers use the\n * envelope `id` as the ordering and dedupe key, so this is load-bearing,\n * not a nicety.\n */\nconst nextUlid = monotonicFactory();\n\n/** What a call site supplies; the SDK derives everything else. */\nexport interface PublishOptions {\n  /** uEngage business id the event belongs to. */\n  tenantId: string;\n  /**\n   * When the thing happened, if it wasn't now — e.g. replaying a\n   * transition read back off a DB row. UTC ISO 8601. Defaults to the\n   * moment `publish()` was called.\n   */\n  occurredAt?: string;\n  /** Overrides the client-level `source` for this one event. */\n  source?: string;\n}\n\nexport interface PublishBatchInput extends PublishOptions {\n  type: string;\n  data: Record<string, unknown>;\n}\n\nexport interface EventsClientInput {\n  /**\n   * Bus topic ARN. Defaults to `PLATFORM_EVENTS_TOPIC_ARN`.\n   */\n  topicArn?: string;\n  /**\n   * AWS region. Defaults to the region embedded in `topicArn`, then\n   * `AWS_REGION` / `AWS_DEFAULT_REGION`. Rarely needs setting.\n   */\n  region?: string;\n  /**\n   * Which system is emitting. Defaults to `PLATFORM_EVENTS_SOURCE`, then\n   * `SERVICE_NAME` (set on every platform Lambda by `LambdaService`),\n   * then `'platform-sdk'`.\n   */\n  source?: string;\n  /** Inject a pre-built SNS client (tests, custom credentials/retry config). */\n  snsClient?: SNSClient;\n}\n\nexport interface EventsClient {\n  /**\n   * Publish one event onto the platform event bus.\n   *\n   * Builds the envelope (monotonic ULID `id`, `occurredAt`, `version`,\n   * `domain` derived from the `type` prefix), validates it, and publishes\n   * with `type` / `domain` / `source` set as SNS message attributes so\n   * consumer filter policies match without deserialising the body.\n   *\n   * THROWS on failure — it does not fail open. Fail-open is the caller's\n   * call and it differs by call site: a legacy order-status transition\n   * must never be blocked by a bus outage (wrap in try/catch and log),\n   * whereas a service that needs the event delivered may want to retry.\n   * The PHP SDK's buffered client makes the fail-open choice explicitly\n   * for the legacy request path.\n   *\n   * @throws {ConfigError} no topic ARN configured\n   * @throws {ValidationError} the envelope failed schema validation\n   * @throws {EventPublishError} SNS rejected or errored on the publish\n   */\n  publish(\n    type: string,\n    data: Record<string, unknown>,\n    opts: PublishOptions,\n  ): Promise<PlatformEvent>;\n  /**\n   * Publish many events in one round trip, chunked at SNS's 10-per-call\n   * `PublishBatch` limit.\n   *\n   * All-or-nothing it is NOT: chunks are attempted independently, and a\n   * partial failure throws `EventPublishError` carrying the ids that did\n   * not land in `failedEventIds`. Envelope validation runs over the whole\n   * input first, so a malformed event fails the call before anything is\n   * published.\n   *\n   * @throws {ConfigError} no topic ARN configured\n   * @throws {ValidationError} any envelope failed schema validation\n   * @throws {EventPublishError} one or more events did not reach the bus\n   */\n  publishBatch(events: PublishBatchInput[]): Promise<PlatformEvent[]>;\n}\n\n/**\n * Build an isolated events client. Reads `PLATFORM_EVENTS_TOPIC_ARN` and\n * friends from the environment for anything not passed explicitly, so a\n * Lambda whose deploy stack injected the ARN needs no arguments.\n */\nexport function createEventsClient(input: EventsClientInput = {}): EventsClient {\n  let client: SNSClient | undefined = input.snsClient;\n\n  function topicArn(): string {\n    const arn = input.topicArn ?? env('PLATFORM_EVENTS_TOPIC_ARN');\n    if (!arn) {\n      throw new ConfigError(\n        'events.publish: no topic ARN. Pass {topicArn} to createEventsClient or set PLATFORM_EVENTS_TOPIC_ARN.',\n      );\n    }\n    return arn;\n  }\n\n  function sns(): SNSClient {\n    if (!client) {\n      const region =\n        input.region ?? regionFromArn(topicArn()) ?? env('AWS_REGION') ?? env('AWS_DEFAULT_REGION');\n      client = new SNSClient(region ? { region } : {});\n    }\n    return client;\n  }\n\n  function source(override?: string): string {\n    return (\n      override ??\n      input.source ??\n      env('PLATFORM_EVENTS_SOURCE') ??\n      env('SERVICE_NAME') ??\n      'platform-sdk'\n    );\n  }\n\n  function buildEnvelope(\n    type: string,\n    data: Record<string, unknown>,\n    opts: PublishOptions,\n  ): PlatformEvent {\n    const domain = domainForEventType(type);\n    if (!domain) {\n      throw new ValidationError(\n        `events.publish: cannot route event type \"${type}\". It must be a dotted ` +\n          '\"<resource>.<operation>\" name whose resource maps to a known bus domain ' +\n          '(order, customer, menu, offer, loyalty, usage). Adding a domain is a one-line ' +\n          'edit in events/schema.ts and its two mirrors.',\n      );\n    }\n    const candidate = {\n      id: nextUlid(),\n      type,\n      domain,\n      source: source(opts.source),\n      version: PLATFORM_EVENT_VERSION,\n      occurredAt: opts.occurredAt ?? isoNow(),\n      tenantId: opts.tenantId,\n      data,\n    };\n    const result = platformEventSchema.safeParse(candidate);\n    if (!result.success) {\n      throw new ValidationError(`events.publish: invalid envelope for \"${type}\"`, {\n        issues: result.error.issues,\n      });\n    }\n    return result.data;\n  }\n\n  /**\n   * Serialize and size-check one envelope.\n   *\n   * Checked before the publish rather than after the rejection because\n   * SNS's own error for an oversized message names neither the event nor\n   * the offending field, and on the PHP side the same failure disappears\n   * into `error_log`. Better to say which event and how big.\n   */\n  function serialize(event: PlatformEvent): string {\n    const message = JSON.stringify(event);\n    const size = byteLength(message);\n    if (size > MAX_MESSAGE_BYTES) {\n      throw new ValidationError(\n        `events.publish: event ${event.id} (\"${event.type}\") serializes to ${size} bytes, ` +\n          `over the ${MAX_MESSAGE_BYTES}-byte ceiling (SNS caps a message at 256KB including ` +\n          'attributes). Put the payload somewhere addressable and reference it from `data`.',\n      );\n    }\n    return message;\n  }\n\n  return {\n    async publish(type, data, opts) {\n      const event = buildEnvelope(type, data, opts);\n      const message = serialize(event);\n      const arn = topicArn();\n      try {\n        await sns().send(\n          new PublishCommand({\n            TopicArn: arn,\n            Message: message,\n            MessageAttributes: messageAttributes(event),\n          }),\n        );\n      } catch (err) {\n        throw new EventPublishError(`events.publish: SNS publish failed for \"${type}\"`, {\n          failedEventIds: [event.id],\n          cause: err,\n        });\n      }\n      return event;\n    },\n\n    async publishBatch(events) {\n      if (events.length === 0) return [];\n      const envelopes = events.map((e) => buildEnvelope(e.type, e.data, e));\n      // Serialize (and size-check) everything up front, so an oversized\n      // event fails the call before any of its siblings are published.\n      const messages = new Map(envelopes.map((event) => [event.id, serialize(event)]));\n      const arn = topicArn();\n\n      const failed: string[] = [];\n      let firstError: unknown;\n      for (const group of chunkByBytes(envelopes, messages)) {\n        const entries: PublishBatchRequestEntry[] = group.map((event) => ({\n          Id: event.id,\n          Message: messages.get(event.id) as string,\n          MessageAttributes: messageAttributes(event),\n        }));\n        try {\n          const resp = await sns().send(\n            new PublishBatchCommand({ TopicArn: arn, PublishBatchRequestEntries: entries }),\n          );\n          for (const f of resp.Failed ?? []) {\n            if (f.Id) failed.push(f.Id);\n          }\n        } catch (err) {\n          firstError = firstError ?? err;\n          for (const event of group) failed.push(event.id);\n        }\n      }\n\n      if (failed.length > 0) {\n        throw new EventPublishError(\n          `events.publishBatch: ${failed.length}/${envelopes.length} event(s) did not reach the bus`,\n          { failedEventIds: failed, cause: firstError },\n        );\n      }\n      return envelopes;\n    },\n  };\n}\n\nfunction messageAttributes(event: PlatformEvent): Record<string, MessageAttributeValue> {\n  return {\n    type: { DataType: 'String', StringValue: event.type },\n    domain: { DataType: 'String', StringValue: event.domain },\n    source: { DataType: 'String', StringValue: event.source },\n  };\n}\n\n/** `arn:aws:sns:<region>:<account>:<name>` → `<region>`. */\nfunction regionFromArn(arn: string): string | undefined {\n  const parts = arn.split(':');\n  return parts.length >= 4 && parts[3] ? parts[3] : undefined;\n}\n\n/** UTC ISO 8601, seconds precision — the format the envelope schema pins. */\nfunction isoNow(): string {\n  return new Date().toISOString().replace(/\\.\\d{3}Z$/, 'Z');\n}\n\nfunction env(name: string): string | undefined {\n  if (typeof process === 'undefined') return undefined;\n  const value = (process as { env?: Record<string, string | undefined> }).env?.[name];\n  return value === '' ? undefined : value;\n}\n\n/**\n * Group envelopes into PublishBatch calls bounded by BOTH limits: at most\n * 10 entries, and at most 256 KB of combined payload.\n *\n * The byte bound matters as soon as payloads get rich — ten 30 KB\n * envelopes are each individually legal and collectively over the\n * request cap, and SNS rejects the whole call rather than the overflow.\n */\nfunction chunkByBytes(\n  envelopes: PlatformEvent[],\n  messages: Map<string, string>,\n): PlatformEvent[][] {\n  const out: PlatformEvent[][] = [];\n  let current: PlatformEvent[] = [];\n  let currentBytes = 0;\n\n  for (const event of envelopes) {\n    const size = byteLength(messages.get(event.id) as string) + ATTRIBUTE_ALLOWANCE_BYTES;\n    const full = current.length >= SNS_BATCH_MAX;\n    const wouldOverflow = current.length > 0 && currentBytes + size > SNS_MAX_BYTES;\n    if (full || wouldOverflow) {\n      out.push(current);\n      current = [];\n      currentBytes = 0;\n    }\n    current.push(event);\n    currentBytes += size;\n  }\n  if (current.length > 0) out.push(current);\n  return out;\n}\n"]}

package/dist/events/index.d.ts

@@ -0,0 +1,15 @@
+import { type EventsClient } from './client';
+export { createEventsClient, type EventsClient, type EventsClientInput, type PublishOptions, type PublishBatchInput, } from './client';
+export { platformEventSchema, domainForEventType, DOMAIN_BY_RESOURCE, PLATFORM_EVENT_TYPES, PLATFORM_EVENT_VERSION, type PlatformEvent, type PlatformEventType, } from './schema';
+/**
+ * Lazily-built default events client, configured entirely from the
+ * environment (`PLATFORM_EVENTS_TOPIC_ARN`, `PLATFORM_EVENTS_SOURCE`).
+ *
+ * Lazy because constructing it eagerly would build an SNS client — and
+ * read config that may not be set — in every process that merely imports
+ * the SDK. Use `createEventsClient(...)` when you need an isolated client
+ * with its own topic, region, or injected SNS client.
+ */
+export declare const events: EventsClient;
+/** Test-only: drop the memoised default client so env changes take effect. */
+export declare function _resetEventsSingleton(): void;

package/dist/events/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.events = exports.PLATFORM_EVENT_VERSION = exports.PLATFORM_EVENT_TYPES = exports.DOMAIN_BY_RESOURCE = exports.domainForEventType = exports.platformEventSchema = exports.createEventsClient = void 0;
+exports._resetEventsSingleton = _resetEventsSingleton;
+const client_1 = require("./client");
+var client_2 = require("./client");
+Object.defineProperty(exports, "createEventsClient", { enumerable: true, get: function () { return client_2.createEventsClient; } });
+var schema_1 = require("./schema");
+Object.defineProperty(exports, "platformEventSchema", { enumerable: true, get: function () { return schema_1.platformEventSchema; } });
+Object.defineProperty(exports, "domainForEventType", { enumerable: true, get: function () { return schema_1.domainForEventType; } });
+Object.defineProperty(exports, "DOMAIN_BY_RESOURCE", { enumerable: true, get: function () { return schema_1.DOMAIN_BY_RESOURCE; } });
+Object.defineProperty(exports, "PLATFORM_EVENT_TYPES", { enumerable: true, get: function () { return schema_1.PLATFORM_EVENT_TYPES; } });
+Object.defineProperty(exports, "PLATFORM_EVENT_VERSION", { enumerable: true, get: function () { return schema_1.PLATFORM_EVENT_VERSION; } });
+let singleton;
+/**
+ * Lazily-built default events client, configured entirely from the
+ * environment (`PLATFORM_EVENTS_TOPIC_ARN`, `PLATFORM_EVENTS_SOURCE`).
+ *
+ * Lazy because constructing it eagerly would build an SNS client — and
+ * read config that may not be set — in every process that merely imports
+ * the SDK. Use `createEventsClient(...)` when you need an isolated client
+ * with its own topic, region, or injected SNS client.
+ */
+exports.events = {
+    publish(type, data, opts) {
+        return defaultClient().publish(type, data, opts);
+    },
+    publishBatch(batch) {
+        return defaultClient().publishBatch(batch);
+    },
+};
+function defaultClient() {
+    if (!singleton)
+        singleton = (0, client_1.createEventsClient)();
+    return singleton;
+}
+/** Test-only: drop the memoised default client so env changes take effect. */
+function _resetEventsSingleton() {
+    singleton = undefined;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/events/schema.d.ts

@@ -0,0 +1,58 @@
+import { z } from 'zod';
+/** Dotted `resource.operation`, e.g. `order.status_changed`. */
+export declare const EVENT_TYPE_RE: RegExp;
+export declare const platformEventSchema: z.ZodObject<{
+    id: z.ZodString;
+    type: z.ZodString;
+    domain: z.ZodString;
+    source: z.ZodString;
+    version: z.ZodNumber;
+    occurredAt: z.ZodString;
+    tenantId: z.ZodString;
+    data: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    type: string;
+    id: string;
+    domain: string;
+    source: string;
+    version: number;
+    occurredAt: string;
+    tenantId: string;
+    data: Record<string, unknown>;
+}, {
+    type: string;
+    id: string;
+    domain: string;
+    source: string;
+    version: number;
+    occurredAt: string;
+    tenantId: string;
+    data: Record<string, unknown>;
+}>;
+export type PlatformEvent = z.infer<typeof platformEventSchema>;
+/** Event types the bus carries in phase 1. */
+export declare const PLATFORM_EVENT_TYPES: readonly ["order.created", "order.status_changed"];
+export type PlatformEventType = (typeof PLATFORM_EVENT_TYPES)[number];
+/** Current envelope version stamped on everything this SDK publishes. */
+export declare const PLATFORM_EVENT_VERSION = 1;
+/**
+ * Resource prefix → bus domain.
+ *
+ * An explicit map, not a pluralisation rule: the platform's domains are
+ * not uniformly plural (`orders` and `customers` are, `menu`, `loyalty`
+ * and `usage` are not).
+ *
+ * Copied from `packages/common/src/events/domains.json`, which is the
+ * single source of truth, because this package is published to npm and
+ * cannot import from a private workspace package. Exported so
+ * `test/events/domain-map.test.ts` can assert it against that JSON — the
+ * suite fails the moment the two drift.
+ */
+export declare const DOMAIN_BY_RESOURCE: Readonly<Record<string, string>>;
+/**
+ * The domain an event type belongs to, or null for a malformed type or
+ * an unregistered resource prefix. `publish()` treats null as an error:
+ * emitting onto a domain that does not exist is a call-site mistake, and
+ * nothing downstream is subscribed to catch it.
+ */
+export declare function domainForEventType(type: string): string | null;

package/dist/events/schema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DOMAIN_BY_RESOURCE = exports.PLATFORM_EVENT_VERSION = exports.PLATFORM_EVENT_TYPES = exports.platformEventSchema = exports.EVENT_TYPE_RE = void 0;
+exports.domainForEventType = domainForEventType;
+const zod_1 = require("zod");
+/**
+ * Platform event-bus envelope, publisher side.
+ *
+ * This mirrors `@uengage/common`'s `platformEventSchema` field for field.
+ * It is duplicated rather than imported because `@uengage/common` is a
+ * private workspace package and this SDK is published to npm — the same
+ * reason `audit/schema.ts` lives here instead of in common. The two are
+ * kept honest by `services/realtime/test/envelope.test.ts`, which
+ * validates an SDK-built envelope against the common schema.
+ */
+/** ULID: Crockford base32, 26 chars, excludes I/L/O/U. */
+const ULID_RE = /^[0-9A-HJKMNP-TV-Z]{26}$/;
+/** Dotted `resource.operation`, e.g. `order.status_changed`. */
+exports.EVENT_TYPE_RE = /^[a-z][a-z0-9_]*\.[a-z][a-z0-9_]*$/;
+exports.platformEventSchema = zod_1.z.object({
+    id: zod_1.z.string().regex(ULID_RE, 'must be a ULID'),
+    type: zod_1.z.string().regex(exports.EVENT_TYPE_RE, 'must be "<resource>.<operation>"'),
+    domain: zod_1.z.string().regex(/^[a-z][a-z0-9_]*$/, 'must be a lowercase domain token'),
+    source: zod_1.z.string().min(1),
+    version: zod_1.z.number().int().positive(),
+    occurredAt: zod_1.z.string().datetime({ offset: false }),
+    tenantId: zod_1.z.string().min(1),
+    data: zod_1.z.record(zod_1.z.string(), zod_1.z.unknown()),
+});
+/** Event types the bus carries in phase 1. */
+exports.PLATFORM_EVENT_TYPES = ['order.created', 'order.status_changed'];
+/** Current envelope version stamped on everything this SDK publishes. */
+exports.PLATFORM_EVENT_VERSION = 1;
+/**
+ * Resource prefix → bus domain.
+ *
+ * An explicit map, not a pluralisation rule: the platform's domains are
+ * not uniformly plural (`orders` and `customers` are, `menu`, `loyalty`
+ * and `usage` are not).
+ *
+ * Copied from `packages/common/src/events/domains.json`, which is the
+ * single source of truth, because this package is published to npm and
+ * cannot import from a private workspace package. Exported so
+ * `test/events/domain-map.test.ts` can assert it against that JSON — the
+ * suite fails the moment the two drift.
+ */
+exports.DOMAIN_BY_RESOURCE = {
+    order: 'orders',
+    customer: 'customers',
+    menu: 'menu',
+    offer: 'offers',
+    loyalty: 'loyalty',
+    usage: 'usage',
+};
+/**
+ * The domain an event type belongs to, or null for a malformed type or
+ * an unregistered resource prefix. `publish()` treats null as an error:
+ * emitting onto a domain that does not exist is a call-site mistake, and
+ * nothing downstream is subscribed to catch it.
+ */
+function domainForEventType(type) {
+    if (!exports.EVENT_TYPE_RE.test(type))
+        return null;
+    const resource = type.slice(0, type.indexOf('.'));
+    return exports.DOMAIN_BY_RESOURCE[resource] ?? null;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/http.js

@@ -2,10 +2,32 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.buildHeaders = buildHeaders;
 exports.sendWithAuthRetry = sendWithAuthRetry;
-const node_crypto_1 = require("node:crypto");
 const token_source_1 = require("./token-source");
 const version_1 = require("./version");
 const MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);
+/**
+ * UUID v4 without a `node:crypto` import.
+ *
+ * The SDK runs in browsers as well as Lambdas — `whitelabel_web` is a
+ * first-class channel — and a static `node:crypto` import breaks any
+ * browser bundler that does not shim it. `crypto.randomUUID` is present
+ * in Node >= 19 and every current browser; the manual fallback covers
+ * older runtimes and non-secure contexts, where the value is only used
+ * as an idempotency key and needs uniqueness, not unguessability.
+ */
+function randomUUID() {
+    const c = globalThis.crypto;
+    if (c?.randomUUID)
+        return c.randomUUID();
+    if (c?.getRandomValues) {
+        const b = c.getRandomValues(new Uint8Array(16));
+        b[6] = (b[6] & 0x0f) | 0x40;
+        b[8] = (b[8] & 0x3f) | 0x80;
+        const hex = [...b].map((x) => x.toString(16).padStart(2, '0')).join('');
+        return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+    }
+    throw new Error('No crypto source available for idempotency-key generation');
+}
 /**
  * Build the headers for a request to the platform API.
  *
@@ -28,7 +50,7 @@ async function buildHeaders(config, params) {
     if (params.body !== undefined)
         headers['content-type'] = 'application/json';
     if (MUTATING_METHODS.has(params.method.toUpperCase())) {
-        headers['idempotency-key'] = (0, node_crypto_1.randomUUID)();
+        headers['idempotency-key'] = randomUUID();
     }
     if (!config.auth)
         return headers;
@@ -78,4 +100,4 @@ async function sendWithAuthRetry(config, params) {
         body: params.body,
     });
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"http.js","sourceRoot":"","sources":["../src/http.ts"],"names":[],"mappings":"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","sourcesContent":["import type { PlatformConfig } from './config';\nimport { getAccessToken, invalidateToken } from './token-source';\nimport { SDK_VERSION } from './version';\n\nexport interface SignedHeaderParams {\n  method: string;\n  /** URL pathname only, without query string. Must match `c.req.path` server-side. */\n  path: string;\n  /** Raw JSON body string, or empty for none. */\n  body?: string;\n}\n\nconst MUTATING_METHODS = new Set(['POST', 'PUT', 'PATCH', 'DELETE']);\n\n/**\n * UUID v4 without a `node:crypto` import.\n *\n * The SDK runs in browsers as well as Lambdas — `whitelabel_web` is a\n * first-class channel — and a static `node:crypto` import breaks any\n * browser bundler that does not shim it. `crypto.randomUUID` is present\n * in Node >= 19 and every current browser; the manual fallback covers\n * older runtimes and non-secure contexts, where the value is only used\n * as an idempotency key and needs uniqueness, not unguessability.\n */\nfunction randomUUID(): string {\n  const c = (\n    globalThis as {\n      crypto?: { randomUUID?: () => string; getRandomValues?: (a: Uint8Array) => Uint8Array };\n    }\n  ).crypto;\n  if (c?.randomUUID) return c.randomUUID();\n  if (c?.getRandomValues) {\n    const b = c.getRandomValues(new Uint8Array(16));\n    b[6] = (b[6] & 0x0f) | 0x40;\n    b[8] = (b[8] & 0x3f) | 0x80;\n    const hex = [...b].map((x) => x.toString(16).padStart(2, '0')).join('');\n    return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;\n  }\n  throw new Error('No crypto source available for idempotency-key generation');\n}\n\n/**\n * Build the headers for a request to the platform API.\n *\n * Adds three platform-wide headers automatically:\n *   - `User-Agent` so the gateway can attribute traffic to SDK version\n *   - `Idempotency-Key` (UUID v4) on mutating methods, so callers don't\n *     have to generate one per call\n *   - `content-type: application/json` when a body is supplied\n *\n * Auth comes from `config.auth`:\n *   - `bearer`: the token is sent verbatim (caller is responsible for\n *     freshness; SDK throws TokenExpiredError on local-detected expiry)\n *   - `token-source`: SDK mints + caches via OAuth2 client_credentials\n *     and refreshes on expiry / 401\n */\nexport async function buildHeaders(\n  config: PlatformConfig,\n  params: SignedHeaderParams,\n): Promise<Record<string, string>> {\n  const headers: Record<string, string> = {\n    'user-agent': `uengage-platform-sdk/${SDK_VERSION}`,\n  };\n  if (params.body !== undefined) headers['content-type'] = 'application/json';\n  if (MUTATING_METHODS.has(params.method.toUpperCase())) {\n    headers['idempotency-key'] = randomUUID();\n  }\n\n  if (!config.auth) return headers;\n\n  if (config.auth.type === 'bearer') {\n    headers['authorization'] = `Bearer ${config.auth.token}`;\n    return headers;\n  }\n\n  // token-source: mint + cache + refresh-dedup happens in getAccessToken\n  const token = await getAccessToken(config.auth.state);\n  headers['authorization'] = `Bearer ${token}`;\n  return headers;\n}\n\nexport interface SendRequestParams {\n  method: string;\n  /** URL pathname only, without query string. Must match `c.req.path` server-side. */\n  path: string;\n  /** Fully-qualified URL the fetch is sent to (base + path + querystring). */\n  url: string;\n  /** Raw JSON body string, or undefined for none. */\n  body?: string;\n}\n\n/**\n * Send a request with the SDK's standard 401-retry-once behaviour.\n *\n * Only retries when auth is `token-source`, since that's the case\n * where the cached token may have expired server-side. HMAC and\n * static bearer 401s mean the auth is misconfigured and a retry\n * would just fail again. Bubble the response so the caller surfaces it.\n *\n * Shared by every namespace client (business, audit, zones, ...) so\n * the retry semantics are uniform. Lifted out of `business/client.ts`\n * with no behaviour change.\n */\nexport async function sendWithAuthRetry(\n  config: PlatformConfig,\n  params: SendRequestParams,\n): Promise<Response> {\n  const headers = await buildHeaders(config, {\n    method: params.method,\n    path: params.path,\n    body: params.body,\n  });\n  const res = await config.fetchFn(params.url, {\n    method: params.method,\n    headers,\n    body: params.body,\n  });\n  if (res.status !== 401 || config.auth?.type !== 'token-source') return res;\n  invalidateToken(config.auth.state);\n  const retryHeaders = await buildHeaders(config, {\n    method: params.method,\n    path: params.path,\n    body: params.body,\n  });\n  return config.fetchFn(params.url, {\n    method: params.method,\n    headers: retryHeaders,\n    body: params.body,\n  });\n}\n"]}

package/dist/index.d.ts

@@ -2,6 +2,7 @@ export * from './audit';
 export * from './business';
 export * from './zones';
 export * from './wallet';
+export * from './upsell';
 export * from './errors';
 export { auth } from './auth';
 export type { PkcePair, AuthorizeUrlInput, ExchangeCodeInput, RefreshInput, TokenPair, } from './auth';

package/dist/index.js

@@ -19,6 +19,7 @@ __exportStar(require("./audit"), exports);
 __exportStar(require("./business"), exports);
 __exportStar(require("./zones"), exports);
 __exportStar(require("./wallet"), exports);
+__exportStar(require("./upsell"), exports);
 __exportStar(require("./errors"), exports);
 var auth_1 = require("./auth");
 Object.defineProperty(exports, "auth", { enumerable: true, get: function () { return auth_1.auth; } });
@@ -26,4 +27,4 @@ var config_1 = require("./config");
 Object.defineProperty(exports, "DEFAULT_BASE_URL", { enumerable: true, get: function () { return config_1.DEFAULT_BASE_URL; } });
 var client_1 = require("./client");
 Object.defineProperty(exports, "createClient", { enumerable: true, get: function () { return client_1.createClient; } });
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwwQ0FBd0I7QUFDeEIsNkNBQTJCO0FBQzNCLDBDQUF3QjtBQUN4QiwyQ0FBeUI7QUFDekIsMkNBQXlCO0FBQ3pCLCtCQUE4QjtBQUFyQiw0RkFBQSxJQUFJLE9BQUE7QUFRYixtQ0FNa0I7QUFEaEIsMEdBQUEsZ0JBQWdCLE9BQUE7QUFFbEIsbUNBQWdGO0FBQXZFLHNHQUFBLFlBQVksT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vYXVkaXQnO1xuZXhwb3J0ICogZnJvbSAnLi9idXNpbmVzcyc7XG5leHBvcnQgKiBmcm9tICcuL3pvbmVzJztcbmV4cG9ydCAqIGZyb20gJy4vd2FsbGV0JztcbmV4cG9ydCAqIGZyb20gJy4vZXJyb3JzJztcbmV4cG9ydCB7IGF1dGggfSBmcm9tICcuL2F1dGgnO1xuZXhwb3J0IHR5cGUge1xuICBQa2NlUGFpcixcbiAgQXV0aG9yaXplVXJsSW5wdXQsXG4gIEV4Y2hhbmdlQ29kZUlucHV0LFxuICBSZWZyZXNoSW5wdXQsXG4gIFRva2VuUGFpcixcbn0gZnJvbSAnLi9hdXRoJztcbmV4cG9ydCB7XG4gIHR5cGUgUGxhdGZvcm1BdXRoLFxuICB0eXBlIFBsYXRmb3JtQXV0aElucHV0LFxuICB0eXBlIFBsYXRmb3JtQ29uZmlnLFxuICB0eXBlIFBsYXRmb3JtQ29uZmlnSW5wdXQsXG4gIERFRkFVTFRfQkFTRV9VUkwsXG59IGZyb20gJy4vY29uZmlnJztcbmV4cG9ydCB7IGNyZWF0ZUNsaWVudCwgdHlwZSBDbGllbnRDb25maWcsIHR5cGUgUGxhdGZvcm1DbGllbnQgfSBmcm9tICcuL2NsaWVudCc7XG4iXX0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwwQ0FBd0I7QUFDeEIsNkNBQTJCO0FBQzNCLDBDQUF3QjtBQUN4QiwyQ0FBeUI7QUFDekIsMkNBQXlCO0FBQ3pCLDJDQUF5QjtBQUN6QiwrQkFBOEI7QUFBckIsNEZBQUEsSUFBSSxPQUFBO0FBUWIsbUNBTWtCO0FBRGhCLDBHQUFBLGdCQUFnQixPQUFBO0FBRWxCLG1DQUFnRjtBQUF2RSxzR0FBQSxZQUFZLE9BQUEiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2F1ZGl0JztcbmV4cG9ydCAqIGZyb20gJy4vYnVzaW5lc3MnO1xuZXhwb3J0ICogZnJvbSAnLi96b25lcyc7XG5leHBvcnQgKiBmcm9tICcuL3dhbGxldCc7XG5leHBvcnQgKiBmcm9tICcuL3Vwc2VsbCc7XG5leHBvcnQgKiBmcm9tICcuL2Vycm9ycyc7XG5leHBvcnQgeyBhdXRoIH0gZnJvbSAnLi9hdXRoJztcbmV4cG9ydCB0eXBlIHtcbiAgUGtjZVBhaXIsXG4gIEF1dGhvcml6ZVVybElucHV0LFxuICBFeGNoYW5nZUNvZGVJbnB1dCxcbiAgUmVmcmVzaElucHV0LFxuICBUb2tlblBhaXIsXG59IGZyb20gJy4vYXV0aCc7XG5leHBvcnQge1xuICB0eXBlIFBsYXRmb3JtQXV0aCxcbiAgdHlwZSBQbGF0Zm9ybUF1dGhJbnB1dCxcbiAgdHlwZSBQbGF0Zm9ybUNvbmZpZyxcbiAgdHlwZSBQbGF0Zm9ybUNvbmZpZ0lucHV0LFxuICBERUZBVUxUX0JBU0VfVVJMLFxufSBmcm9tICcuL2NvbmZpZyc7XG5leHBvcnQgeyBjcmVhdGVDbGllbnQsIHR5cGUgQ2xpZW50Q29uZmlnLCB0eXBlIFBsYXRmb3JtQ2xpZW50IH0gZnJvbSAnLi9jbGllbnQnO1xuIl19