@uengage.io/platform-sdk 0.15.0 → 1.0.0

package/dist/realtime/envelope.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Dependency-free envelope guard for the browser realtime client.
+ *
+ * This mirrors `@uengage/common`'s `platformEventSchema` and the SDK's own
+ * `events/schema.ts`, but hand-rolled: the `/realtime` subpath ships with
+ * zero runtime dependencies (no zod, no Node built-ins) so it stays a few
+ * KB in a frontend bundle. Change one, change all three.
+ *
+ * NO DOMAIN CROSS-CHECK, deliberately — this is the one mirror that does
+ * not carry the resource→domain map, and it is not an oversight:
+ *
+ *   - It would be checking the wrong thing. The producing SDK derives
+ *     `domain` from `type` and the consuming service re-validates the pair
+ *     before it ever publishes to a channel. By the time an envelope
+ *     reaches a browser the pair has been checked twice server-side; a
+ *     third check can only reject, never repair.
+ *   - It would rot dangerously. A browser bundle sits in someone's cache
+ *     for weeks. Baking today's map into it means that the day a new
+ *     domain ships, every un-refreshed tab starts silently dropping live
+ *     events for it — a stale client rejecting the future, which is the
+ *     failure mode `validatePlatformEvent` is careful to avoid even
+ *     server-side.
+ *
+ * So the guard is structural only: shapes and types, not membership.
+ * `packages/platform-sdk/test/events/domain-map.test.ts` asserts that
+ * every canonical domain is accepted, and that an unlisted one is too.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.asRealtimeEvent = asRealtimeEvent;
+exports.isNewer = isNewer;
+/** 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`. */
+const EVENT_TYPE_RE = /^[a-z][a-z0-9_]*\.[a-z][a-z0-9_]*$/;
+/**
+ * Structural check on an untrusted payload. Returns the event or null —
+ * never throws, because a single malformed frame must not tear down a
+ * live subscription.
+ */
+function asRealtimeEvent(value) {
+    if (typeof value !== 'object' || value === null)
+        return null;
+    const v = value;
+    if (typeof v.id !== 'string' || !ULID_RE.test(v.id))
+        return null;
+    if (typeof v.type !== 'string' || !EVENT_TYPE_RE.test(v.type))
+        return null;
+    if (typeof v.domain !== 'string' || v.domain.length === 0)
+        return null;
+    if (typeof v.source !== 'string' || v.source.length === 0)
+        return null;
+    if (typeof v.version !== 'number' || !Number.isInteger(v.version) || v.version < 1)
+        return null;
+    if (typeof v.occurredAt !== 'string' || v.occurredAt.length === 0)
+        return null;
+    if (typeof v.tenantId !== 'string' || v.tenantId.length === 0)
+        return null;
+    if (typeof v.data !== 'object' || v.data === null || Array.isArray(v.data))
+        return null;
+    return v;
+}
+/**
+ * Ordering/dedupe guard, keyed on the envelope's monotonic ULID.
+ *
+ * ULIDs are lexicographically sortable by mint time, so a plain string
+ * compare orders events without parsing timestamps or knowing anything
+ * about the domain. This is what makes at-least-once delivery and the
+ * snapshot/stream race both harmless: whichever arrives second with an
+ * id <= the one already rendered is dropped.
+ */
+function isNewer(candidateId, seenId) {
+    if (seenId === undefined)
+        return true;
+    return candidateId > seenId;
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/realtime/index.d.ts

@@ -0,0 +1,37 @@
+/**
+ * `@uengage.io/platform-sdk/realtime` — browser-safe realtime client.
+ *
+ * A thin client for the platform's AppSync Events API: it owns the wire
+ * protocol, the keepalive watchdog, reconnect with jittered backoff,
+ * resubscribe, token refresh, snapshot catch-up on every (re)connect,
+ * and ULID-based ordering/dedupe. Apps own rendering and channel names.
+ *
+ * ```ts
+ * import { realtime } from '@uengage.io/platform-sdk/realtime';
+ *
+ * const client = realtime.connect({
+ *   env: 'prod',
+ *   getToken: () => session.jwt(),
+ * });
+ *
+ * const sub = client.subscribe(`/orders/${orderId}`, {
+ *   onUpdate(event, meta) { render(event.data); },
+ *   onError(err) { showOffline(err); },
+ * });
+ *
+ * sub.unsubscribe();
+ * ```
+ *
+ * This subpath is deliberately isolated from the SDK's main entry: zero
+ * runtime dependencies, no Node built-ins, no server auth code, so it
+ * stays a few KB in a frontend bundle and works unchanged in React
+ * Native. Do not import from `../` here.
+ */
+import { connect } from './connect';
+export declare const realtime: {
+    connect: typeof connect;
+};
+export { connect, jitteredBackoff, type RealtimeClient, type RealtimeConnectOptions, type Subscription, type SubscribeOptions, type UpdateMeta, type MinimalWebSocket, type WebSocketCtor, } from './connect';
+export { asRealtimeEvent, isNewer, type RealtimeEvent } from './envelope';
+export { API_BASE, endpointsFor, type RealtimeEndpoints, type RealtimeEnv } from './endpoints';
+export { EVENT_WS_SUBPROTOCOL, authHeader, authSubprotocol, base64UrlEncode } from './protocol';

package/dist/realtime/index.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.base64UrlEncode = exports.authSubprotocol = exports.authHeader = exports.EVENT_WS_SUBPROTOCOL = exports.endpointsFor = exports.API_BASE = exports.isNewer = exports.asRealtimeEvent = exports.jitteredBackoff = exports.connect = exports.realtime = void 0;
+/**
+ * `@uengage.io/platform-sdk/realtime` — browser-safe realtime client.
+ *
+ * A thin client for the platform's AppSync Events API: it owns the wire
+ * protocol, the keepalive watchdog, reconnect with jittered backoff,
+ * resubscribe, token refresh, snapshot catch-up on every (re)connect,
+ * and ULID-based ordering/dedupe. Apps own rendering and channel names.
+ *
+ * ```ts
+ * import { realtime } from '@uengage.io/platform-sdk/realtime';
+ *
+ * const client = realtime.connect({
+ *   env: 'prod',
+ *   getToken: () => session.jwt(),
+ * });
+ *
+ * const sub = client.subscribe(`/orders/${orderId}`, {
+ *   onUpdate(event, meta) { render(event.data); },
+ *   onError(err) { showOffline(err); },
+ * });
+ *
+ * sub.unsubscribe();
+ * ```
+ *
+ * This subpath is deliberately isolated from the SDK's main entry: zero
+ * runtime dependencies, no Node built-ins, no server auth code, so it
+ * stays a few KB in a frontend bundle and works unchanged in React
+ * Native. Do not import from `../` here.
+ */
+const connect_1 = require("./connect");
+exports.realtime = { connect: connect_1.connect };
+var connect_2 = require("./connect");
+Object.defineProperty(exports, "connect", { enumerable: true, get: function () { return connect_2.connect; } });
+Object.defineProperty(exports, "jitteredBackoff", { enumerable: true, get: function () { return connect_2.jitteredBackoff; } });
+var envelope_1 = require("./envelope");
+Object.defineProperty(exports, "asRealtimeEvent", { enumerable: true, get: function () { return envelope_1.asRealtimeEvent; } });
+Object.defineProperty(exports, "isNewer", { enumerable: true, get: function () { return envelope_1.isNewer; } });
+var endpoints_1 = require("./endpoints");
+Object.defineProperty(exports, "API_BASE", { enumerable: true, get: function () { return endpoints_1.API_BASE; } });
+Object.defineProperty(exports, "endpointsFor", { enumerable: true, get: function () { return endpoints_1.endpointsFor; } });
+var protocol_1 = require("./protocol");
+Object.defineProperty(exports, "EVENT_WS_SUBPROTOCOL", { enumerable: true, get: function () { return protocol_1.EVENT_WS_SUBPROTOCOL; } });
+Object.defineProperty(exports, "authHeader", { enumerable: true, get: function () { return protocol_1.authHeader; } });
+Object.defineProperty(exports, "authSubprotocol", { enumerable: true, get: function () { return protocol_1.authSubprotocol; } });
+Object.defineProperty(exports, "base64UrlEncode", { enumerable: true, get: function () { return protocol_1.base64UrlEncode; } });
+//# sourceMappingURL=data:application/json;base64,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

package/dist/realtime/protocol.d.ts

@@ -0,0 +1,73 @@
+/**
+ * The AppSync Events WebSocket wire protocol, as documented at
+ * https://docs.aws.amazon.com/appsync/latest/eventapi/event-api-websocket-protocol.html
+ *
+ * Everything here is pure data + string manipulation: no I/O, no
+ * dependencies, no Node built-ins. The socket lifecycle lives in
+ * `connect.ts`.
+ */
+/** WebSocket subprotocol that selects the Events (not GraphQL) protocol. */
+export declare const EVENT_WS_SUBPROTOCOL = "aws-appsync-event-ws";
+/**
+ * AppSync takes connection auth as a *subprotocol*, because a browser
+ * WebSocket cannot set request headers. The auth header object is
+ * JSON-encoded, base64url-encoded, and prefixed with `header-`.
+ */
+export declare function authSubprotocol(header: Record<string, string>): string;
+/**
+ * The auth object AppSync expects, for both the connection handshake and
+ * each `subscribe` frame. `host` must be the API's HTTP domain (not the
+ * realtime domain) — AppSync validates the signature/token against it.
+ */
+export declare function authHeader(httpHost: string, token: string): Record<string, string>;
+/**
+ * base64url with padding stripped. Uses `btoa` over UTF-8 bytes rather
+ * than `Buffer`, which does not exist in a browser.
+ */
+export declare function base64UrlEncode(input: string): string;
+export interface ConnectionAckFrame {
+    type: 'connection_ack';
+    /**
+     * How long the server will tolerate silence before it closes the
+     * connection. The client watchdog uses this rather than a hard-coded
+     * 60s so a server-side change doesn't strand us.
+     */
+    connectionTimeoutMs?: number;
+}
+export interface DataFrame {
+    type: 'data';
+    id: string;
+    /**
+     * The published payload, JSON-encoded *inside* the already-JSON frame.
+     * Double-encoded on the wire; `parseDataFrameEvent` unwraps both.
+     */
+    event: string;
+}
+export interface ErrorFrame {
+    type: 'connection_error' | 'subscribe_error' | 'publish_error';
+    id?: string;
+    errors?: Array<{
+        errorType?: string;
+        message?: string;
+    }>;
+}
+export type ServerFrame = ConnectionAckFrame | DataFrame | ErrorFrame | {
+    type: 'ka';
+} | {
+    type: 'subscribe_success';
+    id: string;
+} | {
+    type: 'unsubscribe_success';
+    id: string;
+} | {
+    type: string;
+    [k: string]: unknown;
+};
+export declare function parseServerFrame(raw: string): ServerFrame | null;
+/** Unwrap the inner JSON of a `data` frame. Null if it isn't parseable. */
+export declare function parseDataFrameEvent(frame: DataFrame): unknown;
+/** Human-readable text from an error frame, for `onError`. */
+export declare function errorFrameMessage(frame: ErrorFrame): string;
+export declare function connectionInitFrame(): string;
+export declare function subscribeFrame(id: string, channel: string, auth: Record<string, string>): string;
+export declare function unsubscribeFrame(id: string): string;

package/dist/realtime/protocol.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * The AppSync Events WebSocket wire protocol, as documented at
+ * https://docs.aws.amazon.com/appsync/latest/eventapi/event-api-websocket-protocol.html
+ *
+ * Everything here is pure data + string manipulation: no I/O, no
+ * dependencies, no Node built-ins. The socket lifecycle lives in
+ * `connect.ts`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EVENT_WS_SUBPROTOCOL = void 0;
+exports.authSubprotocol = authSubprotocol;
+exports.authHeader = authHeader;
+exports.base64UrlEncode = base64UrlEncode;
+exports.parseServerFrame = parseServerFrame;
+exports.parseDataFrameEvent = parseDataFrameEvent;
+exports.errorFrameMessage = errorFrameMessage;
+exports.connectionInitFrame = connectionInitFrame;
+exports.subscribeFrame = subscribeFrame;
+exports.unsubscribeFrame = unsubscribeFrame;
+/** WebSocket subprotocol that selects the Events (not GraphQL) protocol. */
+exports.EVENT_WS_SUBPROTOCOL = 'aws-appsync-event-ws';
+/**
+ * AppSync takes connection auth as a *subprotocol*, because a browser
+ * WebSocket cannot set request headers. The auth header object is
+ * JSON-encoded, base64url-encoded, and prefixed with `header-`.
+ */
+function authSubprotocol(header) {
+    return `header-${base64UrlEncode(JSON.stringify(header))}`;
+}
+/**
+ * The auth object AppSync expects, for both the connection handshake and
+ * each `subscribe` frame. `host` must be the API's HTTP domain (not the
+ * realtime domain) — AppSync validates the signature/token against it.
+ */
+function authHeader(httpHost, token) {
+    return { host: httpHost, Authorization: token };
+}
+/**
+ * base64url with padding stripped. Uses `btoa` over UTF-8 bytes rather
+ * than `Buffer`, which does not exist in a browser.
+ */
+function base64UrlEncode(input) {
+    const bytes = new TextEncoder().encode(input);
+    let binary = '';
+    for (let i = 0; i < bytes.length; i++)
+        binary += String.fromCharCode(bytes[i]);
+    return btoa(binary).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/, '');
+}
+function parseServerFrame(raw) {
+    try {
+        const parsed = JSON.parse(raw);
+        if (typeof parsed !== 'object' || parsed === null)
+            return null;
+        const frame = parsed;
+        if (typeof frame.type !== 'string')
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** Unwrap the inner JSON of a `data` frame. Null if it isn't parseable. */
+function parseDataFrameEvent(frame) {
+    try {
+        return JSON.parse(frame.event);
+    }
+    catch {
+        return null;
+    }
+}
+/** Human-readable text from an error frame, for `onError`. */
+function errorFrameMessage(frame) {
+    const parts = (frame.errors ?? [])
+        .map((e) => e.message ?? e.errorType)
+        .filter((m) => typeof m === 'string' && m.length > 0);
+    return parts.length > 0 ? parts.join('; ') : frame.type;
+}
+function connectionInitFrame() {
+    return JSON.stringify({ type: 'connection_init' });
+}
+function subscribeFrame(id, channel, auth) {
+    return JSON.stringify({ type: 'subscribe', id, channel, authorization: auth });
+}
+function unsubscribeFrame(id) {
+    return JSON.stringify({ type: 'unsubscribe', id });
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"protocol.js","sourceRoot":"","sources":["../../src/realtime/protocol.ts"],"names":[],"mappings":";AAAA;;;;;;;GAOG;;;AAUH,0CAEC;AAOD,gCAEC;AAMD,0CAKC;AAuCD,4CAUC;AAGD,kDAMC;AAGD,8CAKC;AAED,kDAEC;AAED,wCAEC;AAED,4CAEC;AA5GD,4EAA4E;AAC/D,QAAA,oBAAoB,GAAG,sBAAsB,CAAC;AAE3D;;;;GAIG;AACH,SAAgB,eAAe,CAAC,MAA8B;IAC5D,OAAO,UAAU,eAAe,CAAC,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC,EAAE,CAAC;AAC7D,CAAC;AAED;;;;GAIG;AACH,SAAgB,UAAU,CAAC,QAAgB,EAAE,KAAa;IACxD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,aAAa,EAAE,KAAK,EAAE,CAAC;AAClD,CAAC;AAED;;;GAGG;AACH,SAAgB,eAAe,CAAC,KAAa;IAC3C,MAAM,KAAK,GAAG,IAAI,WAAW,EAAE,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC;IAC9C,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE;QAAE,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAC/E,OAAO,IAAI,CAAC,MAAM,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;AACjF,CAAC;AAuCD,SAAgB,gBAAgB,CAAC,GAAW;IAC1C,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAY,CAAC;QAC1C,IAAI,OAAO,MAAM,KAAK,QAAQ,IAAI,MAAM,KAAK,IAAI;YAAE,OAAO,IAAI,CAAC;QAC/D,MAAM,KAAK,GAAG,MAA4B,CAAC;QAC3C,IAAI,OAAO,KAAK,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC;QAChD,OAAO,MAAqB,CAAC;IAC/B,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,2EAA2E;AAC3E,SAAgB,mBAAmB,CAAC,KAAgB;IAClD,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,KAAK,CAAY,CAAC;IAC5C,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,IAAI,CAAC;IACd,CAAC;AACH,CAAC;AAED,8DAA8D;AAC9D,SAAgB,iBAAiB,CAAC,KAAiB;IACjD,MAAM,KAAK,GAAG,CAAC,KAAK,CAAC,MAAM,IAAI,EAAE,CAAC;SAC/B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,CAAC,SAAS,CAAC;SACpC,MAAM,CAAC,CAAC,CAAC,EAAe,EAAE,CAAC,OAAO,CAAC,KAAK,QAAQ,IAAI,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACrE,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;AAC1D,CAAC;AAED,SAAgB,mBAAmB;IACjC,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,iBAAiB,EAAE,CAAC,CAAC;AACrD,CAAC;AAED,SAAgB,cAAc,CAAC,EAAU,EAAE,OAAe,EAAE,IAA4B;IACtF,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,OAAO,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;AACjF,CAAC;AAED,SAAgB,gBAAgB,CAAC,EAAU;IACzC,OAAO,IAAI,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,aAAa,EAAE,EAAE,EAAE,CAAC,CAAC;AACrD,CAAC","sourcesContent":["/**\n * The AppSync Events WebSocket wire protocol, as documented at\n * https://docs.aws.amazon.com/appsync/latest/eventapi/event-api-websocket-protocol.html\n *\n * Everything here is pure data + string manipulation: no I/O, no\n * dependencies, no Node built-ins. The socket lifecycle lives in\n * `connect.ts`.\n */\n\n/** WebSocket subprotocol that selects the Events (not GraphQL) protocol. */\nexport const EVENT_WS_SUBPROTOCOL = 'aws-appsync-event-ws';\n\n/**\n * AppSync takes connection auth as a *subprotocol*, because a browser\n * WebSocket cannot set request headers. The auth header object is\n * JSON-encoded, base64url-encoded, and prefixed with `header-`.\n */\nexport function authSubprotocol(header: Record<string, string>): string {\n  return `header-${base64UrlEncode(JSON.stringify(header))}`;\n}\n\n/**\n * The auth object AppSync expects, for both the connection handshake and\n * each `subscribe` frame. `host` must be the API's HTTP domain (not the\n * realtime domain) — AppSync validates the signature/token against it.\n */\nexport function authHeader(httpHost: string, token: string): Record<string, string> {\n  return { host: httpHost, Authorization: token };\n}\n\n/**\n * base64url with padding stripped. Uses `btoa` over UTF-8 bytes rather\n * than `Buffer`, which does not exist in a browser.\n */\nexport function base64UrlEncode(input: string): string {\n  const bytes = new TextEncoder().encode(input);\n  let binary = '';\n  for (let i = 0; i < bytes.length; i++) binary += String.fromCharCode(bytes[i]);\n  return btoa(binary).replace(/\\+/g, '-').replace(/\\//g, '_').replace(/=+$/, '');\n}\n\n// ─── Frames ────────────────────────────────────────────────────────────\n\nexport interface ConnectionAckFrame {\n  type: 'connection_ack';\n  /**\n   * How long the server will tolerate silence before it closes the\n   * connection. The client watchdog uses this rather than a hard-coded\n   * 60s so a server-side change doesn't strand us.\n   */\n  connectionTimeoutMs?: number;\n}\n\nexport interface DataFrame {\n  type: 'data';\n  id: string;\n  /**\n   * The published payload, JSON-encoded *inside* the already-JSON frame.\n   * Double-encoded on the wire; `parseDataFrameEvent` unwraps both.\n   */\n  event: string;\n}\n\nexport interface ErrorFrame {\n  type: 'connection_error' | 'subscribe_error' | 'publish_error';\n  id?: string;\n  errors?: Array<{ errorType?: string; message?: string }>;\n}\n\nexport type ServerFrame =\n  | ConnectionAckFrame\n  | DataFrame\n  | ErrorFrame\n  | { type: 'ka' }\n  | { type: 'subscribe_success'; id: string }\n  | { type: 'unsubscribe_success'; id: string }\n  | { type: string; [k: string]: unknown };\n\nexport function parseServerFrame(raw: string): ServerFrame | null {\n  try {\n    const parsed = JSON.parse(raw) as unknown;\n    if (typeof parsed !== 'object' || parsed === null) return null;\n    const frame = parsed as { type?: unknown };\n    if (typeof frame.type !== 'string') return null;\n    return parsed as ServerFrame;\n  } catch {\n    return null;\n  }\n}\n\n/** Unwrap the inner JSON of a `data` frame. Null if it isn't parseable. */\nexport function parseDataFrameEvent(frame: DataFrame): unknown {\n  try {\n    return JSON.parse(frame.event) as unknown;\n  } catch {\n    return null;\n  }\n}\n\n/** Human-readable text from an error frame, for `onError`. */\nexport function errorFrameMessage(frame: ErrorFrame): string {\n  const parts = (frame.errors ?? [])\n    .map((e) => e.message ?? e.errorType)\n    .filter((m): m is string => typeof m === 'string' && m.length > 0);\n  return parts.length > 0 ? parts.join('; ') : frame.type;\n}\n\nexport function connectionInitFrame(): string {\n  return JSON.stringify({ type: 'connection_init' });\n}\n\nexport function subscribeFrame(id: string, channel: string, auth: Record<string, string>): string {\n  return JSON.stringify({ type: 'subscribe', id, channel, authorization: auth });\n}\n\nexport function unsubscribeFrame(id: string): string {\n  return JSON.stringify({ type: 'unsubscribe', id });\n}\n"]}

package/package.json

@@ -1,9 +1,34 @@
 {
   "name": "@uengage.io/platform-sdk",
-  "version": "0.15.0",
-  "description": "Client SDK for the uEngage platform API (audit, business, zones, wallet, auth). Single createClient(...) factory; OAuth2 client_credentials, static Bearer, or legacy session-token auth modes.",
+  "version": "1.0.0",
+  "description": "Client SDK for the uEngage platform API (audit, business, zones, wallet, auth, events). Single createClient(...) factory; OAuth2 client_credentials, static Bearer, or legacy session-token auth modes. Browser-safe realtime client at the /realtime subpath.",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./events": {
+      "types": "./dist/events/index.d.ts",
+      "default": "./dist/events/index.js"
+    },
+    "./realtime": {
+      "types": "./dist/realtime/index.d.ts",
+      "default": "./dist/realtime/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "typesVersions": {
+    "*": {
+      "events": [
+        "./dist/events/index.d.ts"
+      ],
+      "realtime": [
+        "./dist/realtime/index.d.ts"
+      ]
+    }
+  },
   "files": [
     "dist/",
     "README.md"
@@ -18,6 +43,8 @@
     "sdk",
     "audit",
     "business",
+    "events",
+    "realtime",
     "hmac"
   ],
   "dependencies": {
@@ -27,12 +54,21 @@
     "@uengage.io/js-logger": "0.10.0"
   },
   "devDependencies": {
+    "@aws-sdk/client-sns": "^3.668.0",
     "@types/jest": "^29.5.14",
     "@types/node": "^20.14.10",
     "jest": "^29.7.0",
     "ts-jest": "^29.2.5",
     "typescript": "^5.5.4"
   },
+  "peerDependencies": {
+    "@aws-sdk/client-sns": "^3.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@aws-sdk/client-sns": {
+      "optional": true
+    }
+  },
   "scripts": {
     "build": "tsc",
     "typecheck": "tsc --noEmit",