@uengage.io/platform-sdk 0.15.0 → 2.0.0

package/dist/upsell/client.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpsellApiError = void 0;
+exports.createUpsellClient = createUpsellClient;
+const config_1 = require("../config");
+const http_1 = require("../http");
+class UpsellApiError extends Error {
+    status;
+    body;
+    constructor(status, body) {
+        super(`upsell API ${status}: ${body}`);
+        this.name = 'UpsellApiError';
+        this.status = status;
+        this.body = body;
+    }
+}
+exports.UpsellApiError = UpsellApiError;
+function assertPositiveInt(label, value) {
+    if (!Number.isInteger(value) || value <= 0) {
+        throw new Error(`upsell.${label}: expected a positive integer (got ${JSON.stringify(value)})`);
+    }
+}
+function assertTenantIds(label, input) {
+    if (input.parentId !== undefined)
+        assertPositiveInt(`${label}.parentId`, input.parentId);
+    if (input.businessId !== undefined) {
+        assertPositiveInt(`${label}.businessId`, input.businessId);
+        if (input.parentId === undefined) {
+            throw new Error(`upsell.${label}: businessId requires parentId`);
+        }
+    }
+}
+/**
+ * Build the `upsell` namespace.
+ *
+ * Shape and contract mirror {@link createZonesClient} - lazy config
+ * resolution via {@link ConfigState}, shared 401-retry via
+ * {@link sendWithAuthRetry}, immutable per-call config; no globals.
+ *
+ * Reads (`placements`, `suggest`) accept user or service tokens —
+ * channel apps call them with customer session JWTs. Admin methods
+ * require a service-actor token; the server answers 403 otherwise and
+ * we surface it as {@link UpsellApiError}.
+ */
+function createUpsellClient(input = {}) {
+    const state = new config_1.ConfigState();
+    state.apply(input);
+    async function send(method, path, query, body) {
+        const config = state.resolve();
+        const url = `${config.baseUrl}${path}${query ?? ''}`;
+        const payload = body === undefined ? undefined : JSON.stringify(body);
+        return (0, http_1.sendWithAuthRetry)(config, { method, path, url, body: payload });
+    }
+    async function expectJson(res) {
+        if (!res.ok)
+            throw new UpsellApiError(res.status, await res.text());
+        return (await res.json());
+    }
+    const client = {
+        config(opts) {
+            state.apply(opts);
+            return client;
+        },
+        auth(opts) {
+            state.setAuth(opts);
+            return client;
+        },
+        async placements(query) {
+            assertPositiveInt('placements.parentId', query.parentId);
+            assertPositiveInt('placements.businessId', query.businessId);
+            const params = new URLSearchParams({
+                channel: query.channel,
+                parentId: String(query.parentId),
+                businessId: String(query.businessId),
+            });
+            const res = await send('GET', '/v1/upsell/placements', `?${params.toString()}`);
+            const body = await expectJson(res);
+            return body.placements;
+        },
+        async suggest(input) {
+            if (!input || typeof input !== 'object' || !input.tenant) {
+                throw new Error('upsell.suggest: input must include `tenant` and `context.cart`');
+            }
+            assertPositiveInt('suggest.tenant.parentId', input.tenant.parentId);
+            assertPositiveInt('suggest.tenant.businessId', input.tenant.businessId);
+            if (!input.context?.cart || !Array.isArray(input.context.cart.items)) {
+                throw new Error('upsell.suggest: context.cart.items must be an array');
+            }
+            const res = await send('POST', '/v1/upsell/suggestions', undefined, input);
+            return expectJson(res);
+        },
+        async reportEvents(input) {
+            if (!input?.events?.length) {
+                throw new Error('upsell.reportEvents: events must be a non-empty array');
+            }
+            assertPositiveInt('reportEvents.tenant.parentId', input.tenant.parentId);
+            assertPositiveInt('reportEvents.tenant.businessId', input.tenant.businessId);
+            const res = await send('POST', '/v1/upsell/events', undefined, input);
+            return expectJson(res);
+        },
+        async adminListPlacements(opts = {}) {
+            if (opts.parentId !== undefined)
+                assertPositiveInt('adminListPlacements.parentId', opts.parentId);
+            const qs = opts.parentId !== undefined ? `?parentId=${opts.parentId}` : undefined;
+            const res = await send('GET', '/v1/upsell/admin/placements', qs);
+            const body = await expectJson(res);
+            return body.placements;
+        },
+        async adminUpsertPlacement(input) {
+            assertTenantIds('adminUpsertPlacement', input);
+            const res = await send('PUT', '/v1/upsell/admin/placements', undefined, input);
+            return expectJson(res);
+        },
+        async adminDeletePlacement(input) {
+            assertTenantIds('adminDeletePlacement', input);
+            const params = new URLSearchParams({ channel: input.channel, key: input.key });
+            if (input.parentId !== undefined)
+                params.set('parentId', String(input.parentId));
+            if (input.businessId !== undefined)
+                params.set('businessId', String(input.businessId));
+            // Omitting parentId targets the platform default row, which the
+            // server refuses to delete without an explicit confirmation. Send
+            // the flag through rather than inferring it, so a caller that meant
+            // to scope the delete still gets the 400 instead of silently
+            // wiping the default for every tenant.
+            if (input.confirmDeleteDefault)
+                params.set('confirmDeleteDefault', 'true');
+            const res = await send('DELETE', '/v1/upsell/admin/placements', `?${params.toString()}`);
+            if (res.status === 204)
+                return;
+            throw new UpsellApiError(res.status, await res.text());
+        },
+    };
+    return client;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"client.js","sourceRoot":"","sources":["../../src/upsell/client.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n  ConfigState,\n  type PlatformAuth,\n  type PlatformAuthInput,\n  type PlatformConfigInput,\n} from '../config';\nimport { sendWithAuthRetry } from '../http';\nimport type {\n  Placement,\n  PlacementDeleteInput,\n  PlacementRecord,\n  PlacementUpsertInput,\n  PlacementsQuery,\n  SuggestionsInput,\n  SuggestionsResult,\n  UpsellEventsInput,\n} from './schema';\n\nexport interface UpsellClient {\n  config(input: PlatformConfigInput): UpsellClient;\n  auth(input: PlatformAuthInput | PlatformAuth): UpsellClient;\n\n  /** GET /v1/upsell/placements - resolved placements for a channel + tenant. */\n  placements(query: PlacementsQuery): Promise<Placement[]>;\n  /** POST /v1/upsell/suggestions - items for one placement given the live cart. */\n  suggest(input: SuggestionsInput): Promise<SuggestionsResult>;\n  /**\n   * POST /v1/upsell/events - report shown / added / ignored for a\n   * rendered placement. Fire-and-forget; feeds attach-rate measurement\n   * and the weight tuning that follows it.\n   */\n  reportEvents(input: UpsellEventsInput): Promise<{ accepted: number }>;\n\n  /** GET /v1/upsell/admin/placements - raw config rows (service-actor only). */\n  adminListPlacements(opts?: { parentId?: number }): Promise<PlacementRecord[]>;\n  /** PUT /v1/upsell/admin/placements - create/replace a config row (service-actor only). */\n  adminUpsertPlacement(input: PlacementUpsertInput): Promise<PlacementRecord>;\n  /** DELETE /v1/upsell/admin/placements - throws UpsellApiError(404) if absent. */\n  adminDeletePlacement(input: PlacementDeleteInput): Promise<void>;\n}\n\nexport class UpsellApiError extends Error {\n  readonly status: number;\n  readonly body: string;\n\n  constructor(status: number, body: string) {\n    super(`upsell API ${status}: ${body}`);\n    this.name = 'UpsellApiError';\n    this.status = status;\n    this.body = body;\n  }\n}\n\nfunction assertPositiveInt(label: string, value: number): void {\n  if (!Number.isInteger(value) || value <= 0) {\n    throw new Error(`upsell.${label}: expected a positive integer (got ${JSON.stringify(value)})`);\n  }\n}\n\nfunction assertTenantIds(label: string, input: { parentId?: number; businessId?: number }): void {\n  if (input.parentId !== undefined) assertPositiveInt(`${label}.parentId`, input.parentId);\n  if (input.businessId !== undefined) {\n    assertPositiveInt(`${label}.businessId`, input.businessId);\n    if (input.parentId === undefined) {\n      throw new Error(`upsell.${label}: businessId requires parentId`);\n    }\n  }\n}\n\n/**\n * Build the `upsell` namespace.\n *\n * Shape and contract mirror {@link createZonesClient} - lazy config\n * resolution via {@link ConfigState}, shared 401-retry via\n * {@link sendWithAuthRetry}, immutable per-call config; no globals.\n *\n * Reads (`placements`, `suggest`) accept user or service tokens —\n * channel apps call them with customer session JWTs. Admin methods\n * require a service-actor token; the server answers 403 otherwise and\n * we surface it as {@link UpsellApiError}.\n */\nexport function createUpsellClient(input: PlatformConfigInput = {}): UpsellClient {\n  const state = new ConfigState();\n  state.apply(input);\n\n  async function send(\n    method: string,\n    path: string,\n    query?: string,\n    body?: unknown,\n  ): Promise<Response> {\n    const config = state.resolve();\n    const url = `${config.baseUrl}${path}${query ?? ''}`;\n    const payload = body === undefined ? undefined : JSON.stringify(body);\n    return sendWithAuthRetry(config, { method, path, url, body: payload });\n  }\n\n  async function expectJson<T>(res: Response): Promise<T> {\n    if (!res.ok) throw new UpsellApiError(res.status, await res.text());\n    return (await res.json()) as T;\n  }\n\n  const client: UpsellClient = {\n    config(opts) {\n      state.apply(opts);\n      return client;\n    },\n    auth(opts) {\n      state.setAuth(opts);\n      return client;\n    },\n\n    async placements(query) {\n      assertPositiveInt('placements.parentId', query.parentId);\n      assertPositiveInt('placements.businessId', query.businessId);\n      const params = new URLSearchParams({\n        channel: query.channel,\n        parentId: String(query.parentId),\n        businessId: String(query.businessId),\n      });\n      const res = await send('GET', '/v1/upsell/placements', `?${params.toString()}`);\n      const body = await expectJson<{ placements: Placement[] }>(res);\n      return body.placements;\n    },\n\n    async suggest(input) {\n      if (!input || typeof input !== 'object' || !input.tenant) {\n        throw new Error('upsell.suggest: input must include `tenant` and `context.cart`');\n      }\n      assertPositiveInt('suggest.tenant.parentId', input.tenant.parentId);\n      assertPositiveInt('suggest.tenant.businessId', input.tenant.businessId);\n      if (!input.context?.cart || !Array.isArray(input.context.cart.items)) {\n        throw new Error('upsell.suggest: context.cart.items must be an array');\n      }\n      const res = await send('POST', '/v1/upsell/suggestions', undefined, input);\n      return expectJson<SuggestionsResult>(res);\n    },\n\n    async reportEvents(input) {\n      if (!input?.events?.length) {\n        throw new Error('upsell.reportEvents: events must be a non-empty array');\n      }\n      assertPositiveInt('reportEvents.tenant.parentId', input.tenant.parentId);\n      assertPositiveInt('reportEvents.tenant.businessId', input.tenant.businessId);\n      const res = await send('POST', '/v1/upsell/events', undefined, input);\n      return expectJson<{ accepted: number }>(res);\n    },\n\n    async adminListPlacements(opts = {}) {\n      if (opts.parentId !== undefined)\n        assertPositiveInt('adminListPlacements.parentId', opts.parentId);\n      const qs = opts.parentId !== undefined ? `?parentId=${opts.parentId}` : undefined;\n      const res = await send('GET', '/v1/upsell/admin/placements', qs);\n      const body = await expectJson<{ placements: PlacementRecord[] }>(res);\n      return body.placements;\n    },\n\n    async adminUpsertPlacement(input) {\n      assertTenantIds('adminUpsertPlacement', input);\n      const res = await send('PUT', '/v1/upsell/admin/placements', undefined, input);\n      return expectJson<PlacementRecord>(res);\n    },\n\n    async adminDeletePlacement(input) {\n      assertTenantIds('adminDeletePlacement', input);\n      const params = new URLSearchParams({ channel: input.channel, key: input.key });\n      if (input.parentId !== undefined) params.set('parentId', String(input.parentId));\n      if (input.businessId !== undefined) params.set('businessId', String(input.businessId));\n      // Omitting parentId targets the platform default row, which the\n      // server refuses to delete without an explicit confirmation. Send\n      // the flag through rather than inferring it, so a caller that meant\n      // to scope the delete still gets the 400 instead of silently\n      // wiping the default for every tenant.\n      if (input.confirmDeleteDefault) params.set('confirmDeleteDefault', 'true');\n      const res = await send('DELETE', '/v1/upsell/admin/placements', `?${params.toString()}`);\n      if (res.status === 204) return;\n      throw new UpsellApiError(res.status, await res.text());\n    },\n  };\n\n  return client;\n}\n"]}

package/dist/upsell/index.d.ts

@@ -0,0 +1,2 @@
+export { createUpsellClient, UpsellApiError, type UpsellClient } from './client';
+export type { Cart, CartItem, Channel, KnownLayout, LadderRung, Layout, Placement, PlacementDeleteInput, PlacementDisplay, PlacementRecord, PlacementScope, PlacementUpsertInput, PlacementsQuery, ReasonCode, StrategyParams, SuggestionsInput, SuggestionsResult, Tenant, Touchpoint, UpsellEvent, UpsellEventType, UpsellEventsInput, UpsellItem, UpsellStrategy, } from './schema';

package/dist/upsell/index.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpsellApiError = exports.createUpsellClient = void 0;
+var client_1 = require("./client");
+Object.defineProperty(exports, "createUpsellClient", { enumerable: true, get: function () { return client_1.createUpsellClient; } });
+Object.defineProperty(exports, "UpsellApiError", { enumerable: true, get: function () { return client_1.UpsellApiError; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdXBzZWxsL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBLG1DQUFpRjtBQUF4RSw0R0FBQSxrQkFBa0IsT0FBQTtBQUFFLHdHQUFBLGNBQWMsT0FBQSIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGNyZWF0ZVVwc2VsbENsaWVudCwgVXBzZWxsQXBpRXJyb3IsIHR5cGUgVXBzZWxsQ2xpZW50IH0gZnJvbSAnLi9jbGllbnQnO1xuZXhwb3J0IHR5cGUge1xuICBDYXJ0LFxuICBDYXJ0SXRlbSxcbiAgQ2hhbm5lbCxcbiAgS25vd25MYXlvdXQsXG4gIExhZGRlclJ1bmcsXG4gIExheW91dCxcbiAgUGxhY2VtZW50LFxuICBQbGFjZW1lbnREZWxldGVJbnB1dCxcbiAgUGxhY2VtZW50RGlzcGxheSxcbiAgUGxhY2VtZW50UmVjb3JkLFxuICBQbGFjZW1lbnRTY29wZSxcbiAgUGxhY2VtZW50VXBzZXJ0SW5wdXQsXG4gIFBsYWNlbWVudHNRdWVyeSxcbiAgUmVhc29uQ29kZSxcbiAgU3RyYXRlZ3lQYXJhbXMsXG4gIFN1Z2dlc3Rpb25zSW5wdXQsXG4gIFN1Z2dlc3Rpb25zUmVzdWx0LFxuICBUZW5hbnQsXG4gIFRvdWNocG9pbnQsXG4gIFVwc2VsbEV2ZW50LFxuICBVcHNlbGxFdmVudFR5cGUsXG4gIFVwc2VsbEV2ZW50c0lucHV0LFxuICBVcHNlbGxJdGVtLFxuICBVcHNlbGxTdHJhdGVneSxcbn0gZnJvbSAnLi9zY2hlbWEnO1xuIl19

package/dist/upsell/schema.d.ts

@@ -0,0 +1,203 @@
+/**
+ * Type surface for the platform Upsell API.
+ *
+ * Two consumer-facing calls: `placements(...)` (which upsell surfaces a
+ * channel should render for a tenant) and `suggest(...)` (items for one
+ * placement given the live cart). `reportEvents(...)` feeds attach-rate
+ * telemetry. Placement config is managed via the service-actor-only
+ * admin methods.
+ */
+export type Channel = 'mobile_app' | 'kiosk' | 'whitelabel_web' | 'whatsapp' | 'voice';
+/**
+ * A moment in the customer journey — the unit of platform policy
+ * (price band, max items, and later the signal weight profile). A
+ * placement is a channel's journey label pointing at one of these.
+ */
+export type Touchpoint = 'home' | 'menu_browsing' | 'menu_composing' | 'search_no_result' | 'cart' | 'pre_checkout' | 'post_order';
+/**
+ * Rendering hint, owned by the channel frontend — the platform never
+ * interprets it. Known values are listed for editor completion, but any
+ * lowercase identifier is valid so new layouts need no SDK release.
+ */
+export type KnownLayout = 'carousel_2up' | 'horizontal_carousel' | 'grid_2xn_modal' | 'carousel_1up' | 'vertical_list' | 'grid_3xn' | 'compact_list' | 'hero_banner';
+export type Layout = KnownLayout | (string & {});
+/** Why an item was recommended. Channels render these in customer language. */
+export type ReasonCode = 'popular_now' | 'completes_meal' | 'often_ordered_together' | 'your_usual' | 'chefs_pick';
+/** Which rung of the resolution ladder answered the request. */
+export type LadderRung = 'full_engine' | 'band_relaxation' | 'popularity_floor' | 'backup_suggestions' | 'empty_degraded';
+export type UpsellStrategy = 'menu-order-popularity' | 'legacy-catalog-sample';
+export interface PlacementDisplay {
+    title: string;
+    /** Requested count. Touchpoint policy may cap it lower — see `meta.maxItems`. */
+    maxItems: number;
+    layout: Layout;
+}
+/** Resolved public placement (business override > brand > platform default). */
+export interface Placement {
+    key: string;
+    channel: Channel;
+    touchpoint: Touchpoint;
+    enabled: boolean;
+    display: PlacementDisplay;
+    configVersion: string;
+}
+export interface Tenant {
+    parentId: number;
+    businessId: number;
+}
+export interface CartItem {
+    itemId: number;
+    qty: number;
+    unitPrice: number;
+    /** Optional; lets the dietary gate and category no-repeat see cart contents. */
+    itemSlug?: string;
+    sectionName?: string;
+    /** Legacy vegNonvegBoth flag: 1 veg, 2 non-veg, 3 both/egg. */
+    veg?: number;
+}
+export interface Cart {
+    items: CartItem[];
+    subtotal: number;
+}
+export interface SuggestionsInput {
+    channel: Channel;
+    placement: string;
+    tenant: Tenant;
+    context: {
+        cart: Cart;
+        fulfilmentMode?: 'delivery' | 'pickup' | 'dine_in';
+        /**
+         * Optional; unused by the v1 scorers. In the contract from day one
+         * so personalization lands without a break. `id` MUST be the opaque
+         * platform customer id, never a mobile number.
+         */
+        customer?: {
+            id: string;
+        };
+        /**
+         * Optional; not yet acted on. Impression fatigue is session-scoped
+         * and shared across touchpoints — send it now so channels
+         * instrument once rather than twice.
+         */
+        sessionId?: string;
+    };
+}
+export interface UpsellItem {
+    itemId: number;
+    itemName: string;
+    itemSlug: string | null;
+    description: string | null;
+    sectionId: number | null;
+    sectionName: string | null;
+    /** Selling price (INR). */
+    price: number;
+    image: string | null;
+    /** Raw legacy `vegNonvegBoth` flag, passed through untranslated. */
+    veg: number | null;
+    brandId: number | null;
+    reasonCode: ReasonCode;
+}
+export interface SuggestionsResult {
+    placement: string;
+    touchpoint: Touchpoint;
+    items: UpsellItem[];
+    meta: {
+        enabled: boolean;
+        strategy: UpsellStrategy;
+        configVersion: string;
+        /** Which ladder rung produced these items. */
+        rung: LadderRung;
+        /** Effective cap applied: min(display.maxItems, touchpoint policy). */
+        maxItems: number;
+        /** How long the client may reuse this response, in seconds. */
+        ttlSeconds: number;
+        /** True when the candidate source failed and the service degraded to empty. */
+        degraded?: boolean;
+    };
+}
+/** Merchant-controlled selection inputs. */
+export interface StrategyParams {
+    includedItemSlugs?: string[];
+    includedSections?: string[];
+    excludedSections?: string[];
+    /** "Never Suggest These" — absolute, overrides the priority list. */
+    neverSuggestItemSlugs?: string[];
+    /** "My Priority Items" — occupy reserved slots ahead of scored items. */
+    priorityItemSlugs?: string[];
+    /** "Backup Suggestions" — 2-6 items, served when everything else is empty. */
+    backupItemSlugs?: string[];
+    excludeCartItems?: boolean;
+    maxPrice?: number;
+}
+export type PlacementScope = 'default' | 'tenant' | 'business';
+/** Raw admin-plane config row (no precedence merge applied). */
+export interface PlacementRecord {
+    scope: PlacementScope;
+    parentId?: number;
+    businessId?: number;
+    channel: Channel;
+    key: string;
+    touchpoint: Touchpoint;
+    enabled: boolean;
+    display: PlacementDisplay;
+    strategy: UpsellStrategy;
+    strategyParams: StrategyParams;
+    configVersion: string;
+    updatedAt: string;
+    updatedBy: string;
+}
+/**
+ * Admin upsert. Scope is derived: no parentId → platform default;
+ * parentId only → brand row; parentId + businessId → business override.
+ */
+export interface PlacementUpsertInput {
+    parentId?: number;
+    businessId?: number;
+    channel: Channel;
+    key: string;
+    touchpoint: Touchpoint;
+    enabled: boolean;
+    display: PlacementDisplay;
+    strategy?: UpsellStrategy;
+    strategyParams?: StrategyParams;
+}
+export interface PlacementDeleteInput {
+    parentId?: number;
+    businessId?: number;
+    channel: Channel;
+    key: string;
+    /**
+     * Required by the server when `parentId` is omitted, because that call
+     * targets the PLATFORM DEFAULT row and so removes the placement for
+     * every tenant that has not overridden it. Without this the server
+     * rejects the request with 400 rather than guessing that a missing
+     * parentId was deliberate.
+     *
+     * Deliberately not defaulted to `true` here: the whole point of the
+     * flag is that deleting a default must be stated, not inferred from
+     * the shape of the call.
+     */
+    confirmDeleteDefault?: boolean;
+}
+export interface PlacementsQuery {
+    channel: Channel;
+    parentId: number;
+    businessId: number;
+}
+export type UpsellEventType = 'shown' | 'added' | 'ignored';
+export interface UpsellEvent {
+    type: UpsellEventType;
+    itemId: number;
+    reasonCode?: ReasonCode;
+    /** ISO-8601. Defaults to server receive time when omitted. */
+    occurredAt?: string;
+}
+export interface UpsellEventsInput {
+    channel: Channel;
+    placement: string;
+    tenant: Tenant;
+    sessionId?: string;
+    /** Echo `meta.configVersion` from the response being reported on. */
+    configVersion?: string;
+    events: UpsellEvent[];
+}

package/dist/upsell/schema.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Type surface for the platform Upsell API.
+ *
+ * Two consumer-facing calls: `placements(...)` (which upsell surfaces a
+ * channel should render for a tenant) and `suggest(...)` (items for one
+ * placement given the live cart). `reportEvents(...)` feeds attach-rate
+ * telemetry. Placement config is managed via the service-actor-only
+ * admin methods.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"schema.js","sourceRoot":"","sources":["../../src/upsell/schema.ts"],"names":[],"mappings":";AAAA;;;;;;;;GAQG","sourcesContent":["/**\n * Type surface for the platform Upsell API.\n *\n * Two consumer-facing calls: `placements(...)` (which upsell surfaces a\n * channel should render for a tenant) and `suggest(...)` (items for one\n * placement given the live cart). `reportEvents(...)` feeds attach-rate\n * telemetry. Placement config is managed via the service-actor-only\n * admin methods.\n */\n\nexport type Channel = 'mobile_app' | 'kiosk' | 'whitelabel_web' | 'whatsapp' | 'voice';\n\n/**\n * A moment in the customer journey — the unit of platform policy\n * (price band, max items, and later the signal weight profile). A\n * placement is a channel's journey label pointing at one of these.\n */\nexport type Touchpoint =\n  | 'home'\n  | 'menu_browsing'\n  | 'menu_composing'\n  | 'search_no_result'\n  | 'cart'\n  | 'pre_checkout'\n  | 'post_order';\n\n/**\n * Rendering hint, owned by the channel frontend — the platform never\n * interprets it. Known values are listed for editor completion, but any\n * lowercase identifier is valid so new layouts need no SDK release.\n */\nexport type KnownLayout =\n  | 'carousel_2up'\n  | 'horizontal_carousel'\n  | 'grid_2xn_modal'\n  | 'carousel_1up'\n  | 'vertical_list'\n  | 'grid_3xn'\n  | 'compact_list'\n  | 'hero_banner';\n\nexport type Layout = KnownLayout | (string & {});\n\n/** Why an item was recommended. Channels render these in customer language. */\nexport type ReasonCode =\n  | 'popular_now'\n  | 'completes_meal'\n  | 'often_ordered_together'\n  | 'your_usual'\n  | 'chefs_pick';\n\n/** Which rung of the resolution ladder answered the request. */\nexport type LadderRung =\n  | 'full_engine'\n  | 'band_relaxation'\n  | 'popularity_floor'\n  | 'backup_suggestions'\n  | 'empty_degraded';\n\nexport type UpsellStrategy = 'menu-order-popularity' | 'legacy-catalog-sample';\n\nexport interface PlacementDisplay {\n  title: string;\n  /** Requested count. Touchpoint policy may cap it lower — see `meta.maxItems`. */\n  maxItems: number;\n  layout: Layout;\n}\n\n/** Resolved public placement (business override > brand > platform default). */\nexport interface Placement {\n  key: string;\n  channel: Channel;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  configVersion: string;\n}\n\nexport interface Tenant {\n  parentId: number;\n  businessId: number;\n}\n\nexport interface CartItem {\n  itemId: number;\n  qty: number;\n  unitPrice: number;\n  /** Optional; lets the dietary gate and category no-repeat see cart contents. */\n  itemSlug?: string;\n  sectionName?: string;\n  /** Legacy vegNonvegBoth flag: 1 veg, 2 non-veg, 3 both/egg. */\n  veg?: number;\n}\n\nexport interface Cart {\n  items: CartItem[];\n  subtotal: number;\n}\n\nexport interface SuggestionsInput {\n  channel: Channel;\n  placement: string;\n  tenant: Tenant;\n  context: {\n    cart: Cart;\n    fulfilmentMode?: 'delivery' | 'pickup' | 'dine_in';\n    /**\n     * Optional; unused by the v1 scorers. In the contract from day one\n     * so personalization lands without a break. `id` MUST be the opaque\n     * platform customer id, never a mobile number.\n     */\n    customer?: { id: string };\n    /**\n     * Optional; not yet acted on. Impression fatigue is session-scoped\n     * and shared across touchpoints — send it now so channels\n     * instrument once rather than twice.\n     */\n    sessionId?: string;\n  };\n}\n\nexport interface UpsellItem {\n  itemId: number;\n  itemName: string;\n  itemSlug: string | null;\n  description: string | null;\n  sectionId: number | null;\n  sectionName: string | null;\n  /** Selling price (INR). */\n  price: number;\n  image: string | null;\n  /** Raw legacy `vegNonvegBoth` flag, passed through untranslated. */\n  veg: number | null;\n  brandId: number | null;\n  reasonCode: ReasonCode;\n}\n\nexport interface SuggestionsResult {\n  placement: string;\n  touchpoint: Touchpoint;\n  items: UpsellItem[];\n  meta: {\n    enabled: boolean;\n    strategy: UpsellStrategy;\n    configVersion: string;\n    /** Which ladder rung produced these items. */\n    rung: LadderRung;\n    /** Effective cap applied: min(display.maxItems, touchpoint policy). */\n    maxItems: number;\n    /** How long the client may reuse this response, in seconds. */\n    ttlSeconds: number;\n    /** True when the candidate source failed and the service degraded to empty. */\n    degraded?: boolean;\n  };\n}\n\n/** Merchant-controlled selection inputs. */\nexport interface StrategyParams {\n  includedItemSlugs?: string[];\n  includedSections?: string[];\n  excludedSections?: string[];\n  /** \"Never Suggest These\" — absolute, overrides the priority list. */\n  neverSuggestItemSlugs?: string[];\n  /** \"My Priority Items\" — occupy reserved slots ahead of scored items. */\n  priorityItemSlugs?: string[];\n  /** \"Backup Suggestions\" — 2-6 items, served when everything else is empty. */\n  backupItemSlugs?: string[];\n  excludeCartItems?: boolean;\n  maxPrice?: number;\n}\n\nexport type PlacementScope = 'default' | 'tenant' | 'business';\n\n/** Raw admin-plane config row (no precedence merge applied). */\nexport interface PlacementRecord {\n  scope: PlacementScope;\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  strategy: UpsellStrategy;\n  strategyParams: StrategyParams;\n  configVersion: string;\n  updatedAt: string;\n  updatedBy: string;\n}\n\n/**\n * Admin upsert. Scope is derived: no parentId → platform default;\n * parentId only → brand row; parentId + businessId → business override.\n */\nexport interface PlacementUpsertInput {\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  touchpoint: Touchpoint;\n  enabled: boolean;\n  display: PlacementDisplay;\n  strategy?: UpsellStrategy;\n  strategyParams?: StrategyParams;\n}\n\nexport interface PlacementDeleteInput {\n  parentId?: number;\n  businessId?: number;\n  channel: Channel;\n  key: string;\n  /**\n   * Required by the server when `parentId` is omitted, because that call\n   * targets the PLATFORM DEFAULT row and so removes the placement for\n   * every tenant that has not overridden it. Without this the server\n   * rejects the request with 400 rather than guessing that a missing\n   * parentId was deliberate.\n   *\n   * Deliberately not defaulted to `true` here: the whole point of the\n   * flag is that deleting a default must be stated, not inferred from\n   * the shape of the call.\n   */\n  confirmDeleteDefault?: boolean;\n}\n\nexport interface PlacementsQuery {\n  channel: Channel;\n  parentId: number;\n  businessId: number;\n}\n\n// ─── Attach-rate telemetry ─────────────────────────────────────────────────\n\nexport type UpsellEventType = 'shown' | 'added' | 'ignored';\n\nexport interface UpsellEvent {\n  type: UpsellEventType;\n  itemId: number;\n  reasonCode?: ReasonCode;\n  /** ISO-8601. Defaults to server receive time when omitted. */\n  occurredAt?: string;\n}\n\nexport interface UpsellEventsInput {\n  channel: Channel;\n  placement: string;\n  tenant: Tenant;\n  sessionId?: string;\n  /** Echo `meta.configVersion` from the response being reported on. */\n  configVersion?: string;\n  events: UpsellEvent[];\n}\n"]}

package/dist/version.d.ts

@@ -4,5 +4,11 @@
  * value from package.json at runtime would require either a JSON import
  * (TS lib settings dependent) or a build-time replacement, and the
  * cost of one bump-in-two-places per release is small.
+ *
+ * That cost was underestimated once: the publish job verifies
+ * package.json against the release tag but never reads this file, so the
+ * two drifted and 1.0.0 shipped reporting 0.9.1. A test now pins them
+ * together (`test/upsell/client.test.ts`), so forgetting this bump fails
+ * the build instead of the User-Agent.
  */
-export declare const SDK_VERSION = "0.9.1";
+export declare const SDK_VERSION = "2.0.0";

package/dist/version.js

@@ -7,6 +7,12 @@ exports.SDK_VERSION = void 0;
  * value from package.json at runtime would require either a JSON import
  * (TS lib settings dependent) or a build-time replacement, and the
  * cost of one bump-in-two-places per release is small.
+ *
+ * That cost was underestimated once: the publish job verifies
+ * package.json against the release tag but never reads this file, so the
+ * two drifted and 1.0.0 shipped reporting 0.9.1. A test now pins them
+ * together (`test/upsell/client.test.ts`), so forgetting this bump fails
+ * the build instead of the User-Agent.
  */
-exports.SDK_VERSION = '0.9.1';
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7R0FNRztBQUNVLFFBQUEsV0FBVyxHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTWFudWFsbHktbWFpbnRhaW5lZCB2ZXJzaW9uIHN0cmluZyBzdXJmYWNlZCB2aWEgdGhlIGBVc2VyLUFnZW50YFxuICogaGVhZGVyLiBLZXB0IGluIHN5bmMgd2l0aCBgcGFja2FnZS5qc29uYCBieSBoYW5kIGJlY2F1c2UgcHVsbGluZyB0aGVcbiAqIHZhbHVlIGZyb20gcGFja2FnZS5qc29uIGF0IHJ1bnRpbWUgd291bGQgcmVxdWlyZSBlaXRoZXIgYSBKU09OIGltcG9ydFxuICogKFRTIGxpYiBzZXR0aW5ncyBkZXBlbmRlbnQpIG9yIGEgYnVpbGQtdGltZSByZXBsYWNlbWVudCwgYW5kIHRoZVxuICogY29zdCBvZiBvbmUgYnVtcC1pbi10d28tcGxhY2VzIHBlciByZWxlYXNlIGlzIHNtYWxsLlxuICovXG5leHBvcnQgY29uc3QgU0RLX1ZFUlNJT04gPSAnMC45LjEnO1xuIl19
+exports.SDK_VERSION = '2.0.0';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmVyc2lvbi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3NyYy92ZXJzaW9uLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7Ozs7Ozs7Ozs7R0FZRztBQUNVLFFBQUEsV0FBVyxHQUFHLE9BQU8sQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogTWFudWFsbHktbWFpbnRhaW5lZCB2ZXJzaW9uIHN0cmluZyBzdXJmYWNlZCB2aWEgdGhlIGBVc2VyLUFnZW50YFxuICogaGVhZGVyLiBLZXB0IGluIHN5bmMgd2l0aCBgcGFja2FnZS5qc29uYCBieSBoYW5kIGJlY2F1c2UgcHVsbGluZyB0aGVcbiAqIHZhbHVlIGZyb20gcGFja2FnZS5qc29uIGF0IHJ1bnRpbWUgd291bGQgcmVxdWlyZSBlaXRoZXIgYSBKU09OIGltcG9ydFxuICogKFRTIGxpYiBzZXR0aW5ncyBkZXBlbmRlbnQpIG9yIGEgYnVpbGQtdGltZSByZXBsYWNlbWVudCwgYW5kIHRoZVxuICogY29zdCBvZiBvbmUgYnVtcC1pbi10d28tcGxhY2VzIHBlciByZWxlYXNlIGlzIHNtYWxsLlxuICpcbiAqIFRoYXQgY29zdCB3YXMgdW5kZXJlc3RpbWF0ZWQgb25jZTogdGhlIHB1Ymxpc2ggam9iIHZlcmlmaWVzXG4gKiBwYWNrYWdlLmpzb24gYWdhaW5zdCB0aGUgcmVsZWFzZSB0YWcgYnV0IG5ldmVyIHJlYWRzIHRoaXMgZmlsZSwgc28gdGhlXG4gKiB0d28gZHJpZnRlZCBhbmQgMS4wLjAgc2hpcHBlZCByZXBvcnRpbmcgMC45LjEuIEEgdGVzdCBub3cgcGlucyB0aGVtXG4gKiB0b2dldGhlciAoYHRlc3QvdXBzZWxsL2NsaWVudC50ZXN0LnRzYCksIHNvIGZvcmdldHRpbmcgdGhpcyBidW1wIGZhaWxzXG4gKiB0aGUgYnVpbGQgaW5zdGVhZCBvZiB0aGUgVXNlci1BZ2VudC5cbiAqL1xuZXhwb3J0IGNvbnN0IFNES19WRVJTSU9OID0gJzIuMC4wJztcbiJdfQ==

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": "2.0.0",
+  "description": "Client SDK for the uEngage platform API (audit, business, zones, wallet, upsell, 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",