@reactionary/ucp 0.10.35 → 0.10.37

package/lib/reactionary-ucp-discounts.js

@@ -0,0 +1,88 @@
+import * as z from "zod";
+import {
+  createUcpWarning,
+  getLineDiscount,
+  getMoneyValue
+} from "./reactionary-ucp-mapping.js";
+const DiscountsRequestSchema = z.looseObject({
+  codes: z.array(z.string()).optional()
+});
+function getRequestedDiscountCodes(body) {
+  const discounts = DiscountsRequestSchema.safeParse(body["discounts"]);
+  return discounts.success ? discounts.data.codes : void 0;
+}
+async function applyDiscountCodes(client, cart, codes) {
+  const cartCapability = client.cart;
+  const messages = [];
+  let current = cart;
+  if (!cartCapability?.applyCouponCode || !cartCapability.removeCouponCode) {
+    return { cart, messages: codes.map((code, index) => rejectedCode(code, index)) };
+  }
+  const requested = new Set(codes.map((code) => code.toUpperCase()));
+  for (const code of getAppliedCodes(current)) {
+    if (!requested.has(code.toUpperCase())) {
+      const removed = await cartCapability.removeCouponCode({ cart: current.identifier, couponCode: code });
+      if (removed.success) {
+        current = removed.value;
+      }
+    }
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const [index, code] of codes.entries()) {
+    const normalized = code.toUpperCase();
+    const applied = getAppliedCodes(current).some((candidate) => candidate.toUpperCase() === normalized);
+    if (seen.has(normalized) || applied) {
+      seen.add(normalized);
+      continue;
+    }
+    seen.add(normalized);
+    const result = await applyCode(cartCapability, current, code);
+    if (result) {
+      current = result;
+    } else {
+      messages.push(rejectedCode(code, index));
+    }
+  }
+  return { cart: current, messages };
+}
+async function applyCode(cartCapability, cart, code) {
+  for (const candidate of /* @__PURE__ */ new Set([code, code.toUpperCase()])) {
+    const result = await cartCapability.applyCouponCode?.({ cart: cart.identifier, couponCode: candidate });
+    if (result?.success) {
+      return result.value;
+    }
+  }
+  return void 0;
+}
+function toUcpDiscounts(cart) {
+  const promotions = cart.appliedPromotions;
+  const lineDiscounts = cart.items.map(getLineDiscount);
+  const itemsDiscount = lineDiscounts.reduce((sum, amount) => sum + amount, 0);
+  const totalDiscount = Math.max(Math.abs(getMoneyValue(cart.price.totalDiscount)), itemsDiscount);
+  const soleLineAllocated = promotions.length === 1 && totalDiscount === itemsDiscount && itemsDiscount > 0;
+  return {
+    discounts: {
+      codes: getAppliedCodes(cart),
+      applied: promotions.map((promotion) => ({
+        ...promotion.isCouponCode ? { code: promotion.code } : {},
+        title: promotion.name || promotion.code || "Discount",
+        amount: promotion.amount ? Math.abs(getMoneyValue(promotion.amount)) : promotions.length === 1 ? totalDiscount : 0,
+        automatic: !promotion.isCouponCode,
+        ...soleLineAllocated ? {
+          allocations: lineDiscounts.flatMap((amount, index) => amount > 0 ? [{ path: `$.line_items[${index}]`, amount }] : [])
+        } : {}
+      }))
+    }
+  };
+}
+function getAppliedCodes(cart) {
+  return cart.appliedPromotions.filter((promotion) => promotion.isCouponCode && promotion.code).map((promotion) => promotion.code);
+}
+function rejectedCode(code, index) {
+  return createUcpWarning("discount_code_invalid", `Discount code '${code}' could not be applied.`, `$.discounts.codes[${index}]`);
+}
+export {
+  applyDiscountCodes,
+  getRequestedDiscountCodes,
+  toUcpDiscounts
+};

package/lib/reactionary-ucp-http.js

@@ -1,3 +1,4 @@
+import { createHash, timingSafeEqual } from "node:crypto";
 const UCP_SESSION_ID_HEADER = "ucp-session-id";
 function getSessionId(request) {
   return request.headers.get(UCP_SESSION_ID_HEADER) ?? void 0;
@@ -70,10 +71,16 @@ async function sendWebResponse(response, webResponse) {
   const body = Buffer.from(await webResponse.arrayBuffer());
   response.end(body);
 }
+function secureEquals(left, right) {
+  const leftDigest = createHash("sha256").update(left).digest();
+  const rightDigest = createHash("sha256").update(right).digest();
+  return timingSafeEqual(leftDigest, rightDigest);
+}
 export {
   UCP_SESSION_ID_HEADER,
   getOrCreateSessionId,
   jsonResponse,
+  secureEquals,
   sendWebResponse,
   toWebRequest
 };

package/lib/reactionary-ucp-identity.js

@@ -1,7 +1,7 @@
 import { SessionSchema } from "@reactionary/core";
-import { createHash, randomBytes, timingSafeEqual } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import * as z from "zod";
-import { jsonResponse } from "./reactionary-ucp-http.js";
+import { jsonResponse, secureEquals } from "./reactionary-ucp-http.js";
 import {
   hashIdentityToken,
   ReactionaryUCPIdentityState,
@@ -404,11 +404,6 @@ function verifyPkce(codeVerifier, codeChallenge) {
   const computed = createHash("sha256").update(codeVerifier).digest("base64url");
   return secureEquals(computed, codeChallenge);
 }
-function secureEquals(left, right) {
-  const leftDigest = createHash("sha256").update(left).digest();
-  const rightDigest = createHash("sha256").update(right).digest();
-  return timingSafeEqual(leftDigest, rightDigest);
-}
 function redirectResponse(location) {
   return new Response(null, {
     status: 302,

package/lib/reactionary-ucp-localization.js

@@ -0,0 +1,92 @@
+import { LanguageContextSchema } from "@reactionary/core";
+const DEFAULT_UCP_LOCALIZATION_RULES = [
+  { country: "SE", languageContext: { locale: "sv-SE", currencyCode: "SEK" } },
+  { country: "NO", languageContext: { locale: "nb-NO", currencyCode: "NOK" } },
+  { country: "DK", languageContext: { locale: "da-DK", currencyCode: "DKK" } },
+  { country: "FI", languageContext: { locale: "fi-FI", currencyCode: "EUR" } },
+  { language: "sv", languageContext: { locale: "sv-SE", currencyCode: "SEK" } },
+  { language: "nb", languageContext: { locale: "nb-NO", currencyCode: "NOK" } },
+  { language: "nn", languageContext: { locale: "nb-NO", currencyCode: "NOK" } },
+  { language: "no", languageContext: { locale: "nb-NO", currencyCode: "NOK" } },
+  { language: "da", languageContext: { locale: "da-DK", currencyCode: "DKK" } },
+  { language: "fi", languageContext: { locale: "fi-FI", currencyCode: "EUR" } },
+  { language: "en", languageContext: { locale: "en-US", currencyCode: "USD" } }
+];
+const SESSION_LANGUAGE_CONTEXT_KEY = "dev.ucp.languageContext";
+async function resolveLanguageContext(request, session, options) {
+  if (!options) {
+    return void 0;
+  }
+  const stored = LanguageContextSchema.safeParse(session[SESSION_LANGUAGE_CONTEXT_KEY]);
+  if (stored.success) {
+    return stored.data;
+  }
+  const resolved = await negotiateLanguageContext(request, options);
+  if (resolved) {
+    session[SESSION_LANGUAGE_CONTEXT_KEY] = resolved;
+  }
+  return resolved;
+}
+async function negotiateLanguageContext(request, options) {
+  const country = await peekContextCountry(request);
+  if (country) {
+    const byCountry = options.rules.find(
+      (rule) => rule.country && rule.country.toUpperCase() === country
+    );
+    if (byCountry) {
+      return byCountry.languageContext;
+    }
+  }
+  for (const language of parseAcceptLanguage(request.headers.get("accept-language"))) {
+    const byLanguage = options.rules.find(
+      (rule) => rule.language && languageMatches(rule.language, language)
+    );
+    if (byLanguage) {
+      return byLanguage.languageContext;
+    }
+  }
+  return options.fallback;
+}
+async function peekContextCountry(request) {
+  if (request.method !== "POST" && request.method !== "PUT" || !request.body) {
+    return void 0;
+  }
+  try {
+    const body = await request.clone().json();
+    if (typeof body !== "object" || body === null) {
+      return void 0;
+    }
+    const context = body["context"];
+    if (typeof context !== "object" || context === null) {
+      return void 0;
+    }
+    const countryValue = context["address_country"];
+    return typeof countryValue === "string" && countryValue.length > 0 ? countryValue.toUpperCase() : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function parseAcceptLanguage(header) {
+  if (!header) {
+    return [];
+  }
+  return header.split(",").map((entry) => {
+    const [tag, ...parameters] = entry.trim().split(";");
+    const qualityParameter = parameters.map((parameter) => parameter.trim()).find((parameter) => parameter.startsWith("q="));
+    const quality = qualityParameter ? Number.parseFloat(qualityParameter.slice(2)) : 1;
+    return {
+      tag: tag.trim(),
+      quality: Number.isFinite(quality) ? quality : 0
+    };
+  }).filter((entry) => entry.tag.length > 0 && entry.tag !== "*" && entry.quality > 0).sort((left, right) => right.quality - left.quality).map((entry) => entry.tag);
+}
+function languageMatches(ruleLanguage, acceptedTag) {
+  const rule = ruleLanguage.toLowerCase();
+  const tag = acceptedTag.toLowerCase();
+  return rule === tag || tag.startsWith(`${rule}-`) || rule.startsWith(`${tag}-`);
+}
+export {
+  DEFAULT_UCP_LOCALIZATION_RULES,
+  parseAcceptLanguage,
+  resolveLanguageContext
+};

package/lib/reactionary-ucp-mapping.js

@@ -0,0 +1,186 @@
+const UCP_VERSION = "2026-08-25";
+function getSelectedPaymentInstrument(checkout) {
+  const instruments = checkout.payment?.instruments ?? [];
+  return instruments.find((instrument) => instrument.selected) ?? instruments[0];
+}
+function toOrderPermalinkUrl(merchantUrl, orderId) {
+  if (!merchantUrl) {
+    return "";
+  }
+  return `${merchantUrl.replace(/\/+$/, "")}/orders/${encodeURIComponent(orderId)}`;
+}
+function toReactionaryAddress(address) {
+  return {
+    firstName: address.first_name ?? "",
+    lastName: address.last_name ?? "",
+    streetAddress: address.street_address ?? "",
+    streetNumber: "",
+    city: address.address_locality ?? "",
+    region: address.address_region ?? "",
+    postalCode: address.postal_code ?? "",
+    countryCode: address.address_country ?? ""
+  };
+}
+function getLineSubtotal(lineItem) {
+  return getMoneyValue({
+    value: lineItem.price.unitPrice.value * lineItem.quantity,
+    currency: lineItem.price.unitPrice.currency
+  });
+}
+function getLineDiscount(lineItem) {
+  return Math.abs(getMoneyValue(lineItem.price.totalDiscount));
+}
+function toUcpCartLineItem(lineItem) {
+  const sku = lineItem.variant.sku || lineItem.identifier.key;
+  const discount = getLineDiscount(lineItem);
+  return {
+    id: lineItem.identifier.key,
+    item: {
+      id: sku,
+      title: sku,
+      price: getMoneyValue(lineItem.price.unitPrice)
+    },
+    quantity: lineItem.quantity,
+    totals: [
+      { type: "subtotal", amount: getLineSubtotal(lineItem) },
+      ...discount > 0 ? [{ type: "items_discount", amount: -discount }] : [],
+      ...toUcpTotals(lineItem.price.totalPrice)
+    ]
+  };
+}
+function toUcpCostTotals(price, items = []) {
+  const subtotal = items.length > 0 ? items.reduce((sum, item) => sum + getLineSubtotal(item), 0) : getMoneyValue(price.totalProductPrice);
+  const itemsDiscount = items.reduce((sum, item) => sum + getLineDiscount(item), 0);
+  const orderDiscount = Math.max(Math.abs(getMoneyValue(price.totalDiscount)) - itemsDiscount, 0);
+  const shipping = getMoneyValue(price.totalShipping);
+  const fee = getMoneyValue(price.totalSurcharge);
+  const grandTotal = getMoneyValue(price.grandTotal);
+  const taxIncluded = subtotal - itemsDiscount - orderDiscount + shipping + fee === grandTotal;
+  const totals = [
+    { type: "subtotal", amount: subtotal }
+  ];
+  const optionalTotals = [
+    ["items_discount", -itemsDiscount],
+    ["discount", -orderDiscount],
+    ["fulfillment", shipping],
+    ["tax", taxIncluded ? 0 : getMoneyValue(price.totalTax)],
+    ["fee", fee]
+  ];
+  for (const [type, amount] of optionalTotals) {
+    if (amount !== 0) {
+      totals.push({ type, amount });
+    }
+  }
+  totals.push({ type: "total", amount: grandTotal });
+  return totals;
+}
+function toUcpTotals(amount) {
+  return [
+    {
+      type: "total",
+      amount: getMoneyValue(amount)
+    }
+  ];
+}
+const CURRENCY_EXPONENTS = {
+  BIF: 0,
+  CLP: 0,
+  DJF: 0,
+  GNF: 0,
+  ISK: 0,
+  JPY: 0,
+  KMF: 0,
+  KRW: 0,
+  PYG: 0,
+  RWF: 0,
+  UGX: 0,
+  UYI: 0,
+  VND: 0,
+  VUV: 0,
+  XAF: 0,
+  XOF: 0,
+  XPF: 0,
+  BHD: 3,
+  IQD: 3,
+  JOD: 3,
+  KWD: 3,
+  LYD: 3,
+  OMR: 3,
+  TND: 3
+};
+function getMoneyValue(amount) {
+  const exponent = CURRENCY_EXPONENTS[amount.currency] ?? 2;
+  return Math.round(amount.value * 10 ** exponent);
+}
+function getMoneyCurrency(amount) {
+  return amount.currency;
+}
+function createUcpSuccessMetadata() {
+  return {
+    version: UCP_VERSION,
+    status: "success"
+  };
+}
+function createUcpCheckoutSuccessMetadata(paymentHandlers) {
+  const candidate = paymentHandlers;
+  return {
+    version: UCP_VERSION,
+    status: "success",
+    payment_handlers: isUcpCheckoutPaymentHandlers(candidate) ? candidate : {}
+  };
+}
+function isUcpCheckoutPaymentHandlers(value) {
+  return typeof value === "object" && value !== null && Object.values(value).every(
+    (handlers) => Array.isArray(handlers) && handlers.every(
+      (handler) => typeof handler === "object" && handler !== null && typeof Reflect.get(handler, "version") === "string"
+    )
+  );
+}
+function createUcpErrorMessage(code, message, path) {
+  const unrecoverable = code.endsWith("not_found") || code === "not_available" || code === "not_implemented";
+  return {
+    type: "error",
+    code,
+    ...path ? { path } : {},
+    content_type: "plain",
+    content: message,
+    severity: unrecoverable ? "unrecoverable" : "recoverable"
+  };
+}
+function createUCPError(code, message, path) {
+  return {
+    ucp: {
+      version: UCP_VERSION,
+      status: "error"
+    },
+    messages: [createUcpErrorMessage(code, message, path)]
+  };
+}
+function createUcpWarning(code, content, path) {
+  return {
+    type: "warning",
+    code,
+    path,
+    content,
+    content_type: "plain",
+    presentation: "notice"
+  };
+}
+export {
+  UCP_VERSION,
+  createUCPError,
+  createUcpCheckoutSuccessMetadata,
+  createUcpErrorMessage,
+  createUcpSuccessMetadata,
+  createUcpWarning,
+  getLineDiscount,
+  getLineSubtotal,
+  getMoneyCurrency,
+  getMoneyValue,
+  getSelectedPaymentInstrument,
+  toOrderPermalinkUrl,
+  toReactionaryAddress,
+  toUcpCartLineItem,
+  toUcpCostTotals,
+  toUcpTotals
+};

package/lib/reactionary-ucp-order.js

@@ -0,0 +1,152 @@
+import * as z from "zod";
+import {
+  createUCPError,
+  createUcpSuccessMetadata,
+  getMoneyCurrency,
+  toOrderPermalinkUrl,
+  toUcpCartLineItem,
+  toUcpCostTotals
+} from "./reactionary-ucp-mapping.js";
+import {
+  UCPAdjustmentSchema,
+  UCPFulfillmentEventSchema
+} from "./reactionary-ucp-session-store.js";
+const UCPOrderUpdateSchema = z.looseObject({
+  fulfillment: z.looseObject({
+    events: z.array(UCPFulfillmentEventSchema).optional()
+  }).optional(),
+  adjustments: z.array(UCPAdjustmentSchema).optional()
+});
+async function getOrder(context, orderId) {
+  const result = await getBackendOrder(context, orderId);
+  if (!("identifier" in result)) {
+    return result;
+  }
+  return toUcpOrder(context, result, await context.store.getOrder(orderId));
+}
+async function updateOrder(context, orderId, update) {
+  const result = await getBackendOrder(context, orderId);
+  const state = await context.store.getOrder(orderId);
+  if (!("identifier" in result)) {
+    return result;
+  }
+  if (!state) {
+    return createUCPError("not_found", `Order was not placed through a UCP checkout session: ${orderId}`);
+  }
+  const updated = {
+    ...state,
+    ...update.fulfillment?.events ? { events: update.fulfillment.events } : {},
+    ...update.adjustments ? { adjustments: update.adjustments } : {}
+  };
+  await context.store.putOrder(updated);
+  const order = toUcpOrder(context, result, updated);
+  notifyOrder(context, updated, order);
+  return order;
+}
+async function simulateShipping(context, orderId) {
+  const result = await getBackendOrder(context, orderId);
+  const state = await context.store.getOrder(orderId);
+  if (!("identifier" in result)) {
+    return result;
+  }
+  if (!state) {
+    return createUCPError("not_found", `Order was not placed through a UCP checkout session: ${orderId}`);
+  }
+  return updateOrder(context, orderId, {
+    fulfillment: {
+      events: [
+        ...state.events,
+        {
+          id: `evt_${crypto.randomUUID()}`,
+          occurred_at: (/* @__PURE__ */ new Date()).toISOString(),
+          type: "shipped",
+          line_items: result.items.filter((item) => item.quantity > 0).map((item) => ({ id: item.identifier.key, quantity: item.quantity })),
+          tracking_number: `SIM-${orderId}`,
+          description: "Simulated shipment"
+        }
+      ]
+    }
+  });
+}
+async function notifyOrderPlaced(context, orderId) {
+  const state = await context.store.getOrder(orderId);
+  if (!context.webhooks || !state?.agentProfile) {
+    return;
+  }
+  const webhookUrl = await context.webhooks.resolveOrderWebhookUrl(state.agentProfile);
+  if (!webhookUrl) {
+    return;
+  }
+  const placed = { ...state, webhookUrl };
+  await context.store.putOrder(placed);
+  const order = await getOrder(context, orderId);
+  if ("id" in order) {
+    notifyOrder(context, placed, order);
+  }
+}
+function notifyOrder(context, state, order) {
+  if (context.webhooks && state.webhookUrl) {
+    context.webhooks.deliver(state.webhookUrl, order);
+  }
+}
+async function getBackendOrder(context, orderId) {
+  if (!context.client.order) {
+    return createUCPError("not_available", "Order capability is not available.");
+  }
+  const result = await context.client.order.getById({ order: { key: orderId } });
+  return result.success ? result.value : createUCPError("not_found", `Order was not found: ${orderId}`);
+}
+function toUcpOrder(context, order, state) {
+  const events = state?.events ?? [];
+  const lineItems = order.items.map((item) => {
+    const total = item.quantity;
+    const shipped = events.filter((event) => event.type === "shipped").flatMap((event) => event.line_items).filter((reference) => reference.id === item.identifier.key).reduce((sum, reference) => sum + reference.quantity, 0);
+    const fulfilled = Math.min(shipped, total);
+    return {
+      ...toUcpCartLineItem(item),
+      quantity: { original: total, total, fulfilled },
+      status: total === 0 ? "removed" : fulfilled === total ? "fulfilled" : fulfilled > 0 ? "partial" : "processing"
+    };
+  });
+  const destination = order.shippingAddress ? toUcpPostalAddress(order.shippingAddress) : state?.destination;
+  const description = state?.fulfillmentTitle ?? order.shippingMethod?.name;
+  return {
+    ucp: createUcpSuccessMetadata(),
+    id: order.identifier.key,
+    checkout_id: state?.checkoutSessionId ?? "",
+    permalink_url: toOrderPermalinkUrl(context.merchantUrl, order.identifier.key),
+    line_items: lineItems,
+    currency: getMoneyCurrency(order.price.grandTotal),
+    totals: toUcpCostTotals(order.price, order.items),
+    fulfillment: {
+      expectations: destination ? [{
+        id: "expectation_1",
+        line_items: lineItems.map((lineItem) => ({ id: lineItem.id, quantity: lineItem.quantity.total })),
+        method_type: "shipping",
+        destination,
+        ...description ? { description } : {},
+        fulfillable_on: "now"
+      }] : [],
+      events
+    },
+    adjustments: state?.adjustments ?? []
+  };
+}
+function toUcpPostalAddress(address) {
+  return {
+    first_name: address.firstName,
+    last_name: address.lastName,
+    street_address: [address.streetAddress, address.streetNumber].filter(Boolean).join(" "),
+    address_locality: address.city,
+    address_region: address.region,
+    postal_code: address.postalCode,
+    address_country: address.countryCode
+  };
+}
+export {
+  UCPOrderUpdateSchema,
+  getOrder,
+  notifyOrderPlaced,
+  simulateShipping,
+  updateOrder
+};

package/lib/reactionary-ucp-profile.js

@@ -64,13 +64,20 @@ function createUcpCapabilities(client) {
   }
   if (hasCapability(client, "cart")) {
     capabilities["dev.ucp.shopping.cart"] = [createUcpCapability("cart", "cart")];
-    const cart = getCapability(client, "cart");
-    if (cart && typeof Reflect.get(cart, "applyCouponCode") === "function") {
-      capabilities["dev.ucp.shopping.discount"] = [createUcpCapability("extensions/discount", "discount")];
-    }
   }
   if (hasCapability(client, "checkout")) {
     capabilities["dev.ucp.shopping.checkout"] = [createUcpCapability("checkout", "checkout")];
+    const checkout = getCapability(client, "checkout");
+    if (checkout && typeof Reflect.get(checkout, "getAvailableShippingMethods") === "function") {
+      capabilities["dev.ucp.shopping.fulfillment"] = [createUcpCapability("extensions/fulfillment", "fulfillment")];
+    }
+    const cart = getCapability(client, "cart");
+    if (cart && typeof Reflect.get(cart, "applyCouponCode") === "function") {
+      capabilities["dev.ucp.shopping.discount"] = [{
+        ...createUcpCapability("extensions/discount", "discount"),
+        extends: "dev.ucp.shopping.checkout"
+      }];
+    }
   }
   if (hasCapability(client, "order")) {
     capabilities["dev.ucp.shopping.order"] = [createUcpCapability("order", "order")];