@rebuy/rebuy 3.40.0 → 3.42.0

package/dist/server/index.cjs

@@ -6473,7 +6473,7 @@ var prepareNormalizedProduct = (normalized, report, quantity2, allowCollection =
 var preparePostPurchaseProduct = (settings, response, report) => prepareNormalizedProduct(normalizePostPurchaseProduct(settings, response), report);
 
 // src/schema/postPurchaseProductView.ts
-var import_zod67 = require("zod");
+var import_zod68 = require("zod");
 
 // src/schema/postPurchaseChoice.ts
 var import_zod64 = require("zod");
@@ -6534,14 +6534,79 @@ var PostPurchaseGroupSelection = import_zod66.z.object({
   productId
 });
 
+// src/schema/postPurchaseProductCalculation.ts
+var import_zod67 = require("zod");
+var MoneyBag = import_zod67.z.object({
+  presentmentMoney: import_zod67.z.object({
+    amount: PostPurchaseAmount,
+    currencyCode: import_zod67.z.string().regex(/^[A-Z]{3}$/)
+  })
+});
+var PostPurchaseProductCalculation = import_zod67.z.object({
+  calculatedPurchase: import_zod67.z.object({
+    addedShippingLines: import_zod67.z.array(import_zod67.z.object({ priceSet: MoneyBag })),
+    addedTaxLines: import_zod67.z.array(import_zod67.z.object({ priceSet: MoneyBag })),
+    totalOutstandingSet: MoneyBag,
+    updatedLineItems: import_zod67.z.array(
+      import_zod67.z.object({
+        priceSet: import_zod67.z.unknown().optional(),
+        productId: import_zod67.z.number().int().positive(),
+        sellingPlanId: import_zod67.z.unknown().optional(),
+        variantId: import_zod67.z.number().int().positive()
+      })
+    )
+  }),
+  errors: import_zod67.z.array(import_zod67.z.unknown()).length(0),
+  status: import_zod67.z.literal("processed")
+});
+var Minor = import_zod67.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
+var PostPurchaseProductCosts = import_zod67.z.object({
+  currencyCode: MoneyBag.shape.presentmentMoney.shape.currencyCode,
+  recurringDisplay: import_zod67.z.object({ shippingMinor: Minor, subtotalMinor: Minor, totalMinor: Minor }).optional(),
+  shippingMinor: Minor,
+  subtotalMinor: Minor,
+  taxesMinor: Minor,
+  totalMinor: Minor
+});
+var ChangesetDiscount = import_zod67.z.object({
+  title: import_zod67.z.string(),
+  value: import_zod67.z.number().nonnegative(),
+  valueType: import_zod67.z.enum(["percentage", "fixed_amount"])
+}).optional();
+var PostPurchaseProductChangeset = import_zod67.z.object({
+  changes: import_zod67.z.array(
+    import_zod67.z.union([
+      import_zod67.z.object({
+        discount: ChangesetDiscount,
+        quantity: import_zod67.z.number().int().positive(),
+        type: import_zod67.z.literal("add_variant"),
+        variantId: import_zod67.z.number().int().positive()
+      }),
+      import_zod67.z.object({ price: import_zod67.z.number().nonnegative(), title: import_zod67.z.string(), type: import_zod67.z.literal("add_shipping_line") }),
+      PostPurchaseSubscriptionTerms.pick({
+        initialShippingPrice: true,
+        recurringShippingPrice: true,
+        shippingOption: true
+      }).extend({
+        discount: ChangesetDiscount,
+        quantity: import_zod67.z.number().int().positive(),
+        sellingPlanId: import_zod67.z.number().int().positive(),
+        type: import_zod67.z.literal("add_subscription"),
+        variantId: import_zod67.z.number().int().positive()
+      })
+    ])
+  )
+});
+
 // src/schema/postPurchaseProductView.ts
-var PostPurchaseProductView = import_zod67.z.union([
-  import_zod67.z.object({
+var PostPurchaseProductView = import_zod68.z.union([
+  import_zod68.z.object({
+    changeset: PostPurchaseProductChangeset.optional(),
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PreparedPostPurchaseProduct.extend({
-      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod67.z.string().nullable() }).refine(
+      display: PreparedPostPurchaseProduct.shape.display.extend({ description: import_zod68.z.string().nullable() }).refine(
         ({ description, descriptionDocument }) => description === null === (descriptionDocument !== void 0),
         "Exactly one of the plain and rich descriptions is shown"
       )
@@ -6550,24 +6615,24 @@ var PostPurchaseProductView = import_zod67.z.union([
     sections: CABRootSection,
     variantCatalog: PostPurchaseVariantCatalog.optional()
   }),
-  import_zod67.z.object({
+  import_zod68.z.object({
     groupCatalog: PostPurchaseGroupCatalog.optional(),
     initialVariant: PostPurchaseVariantSelector.optional(),
     planCatalog: PostPurchasePlanCatalog.nullable().optional(),
     preparation: PostPurchasePreparation.options[1],
     purchaseOptions: PostPurchaseOptions.optional(),
-    sections: import_zod67.z.null(),
+    sections: import_zod68.z.null(),
     variantCatalog: PostPurchaseVariantCatalog.optional()
   })
 ]);
 
 // src/server/postPurchaseOfferCopy.ts
-var import_zod68 = require("zod");
-var Copy = import_zod68.z.object({
+var import_zod69 = require("zod");
+var Copy = import_zod69.z.object({
   superTitle: CalloutBannerBlock.shape.settings.shape.superTitle.unwrap().optional().catch(void 0),
   title: CalloutBannerBlock.shape.settings.shape.title.unwrap().optional().catch(void 0)
 });
-var Callout = import_zod68.z.object({ settings: import_zod68.z.record(import_zod68.z.string(), import_zod68.z.unknown()), type: import_zod68.z.literal("callout_banner") });
+var Callout = import_zod69.z.object({ settings: import_zod69.z.record(import_zod69.z.string(), import_zod69.z.unknown()), type: import_zod69.z.literal("callout_banner") });
 var postPurchaseOfferCopy = (blocks, metadata) => {
   const copy = Copy.safeParse(metadata.widget.language);
   if (!blocks || !copy.success) return blocks;
@@ -6681,98 +6746,36 @@ var import_zod73 = require("zod");
 var import_zod72 = require("zod");
 
 // src/schema/postPurchaseIdentity.ts
-var import_zod69 = require("zod");
+var import_zod70 = require("zod");
 var POST_PURCHASE_ID_MAX = 128;
-var PostPurchaseTimestampSchema = import_zod69.z.number().int().nonnegative();
-var PostPurchaseOrderIdSchema = import_zod69.z.string().regex(/^gid:\/\/shopify\/Order\/[1-9]\d*$/);
-var ShopifyDomainSchema = import_zod69.z.string().max(POST_PURCHASE_ID_MAX).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\.myshopify\.com$/);
-var DecideRequestSchema = import_zod69.z.object({
-  checkoutToken: import_zod69.z.string().min(1).max(POST_PURCHASE_ID_MAX),
+var PostPurchaseTimestampSchema = import_zod70.z.number().int().nonnegative();
+var PostPurchaseOrderIdSchema = import_zod70.z.string().regex(/^gid:\/\/shopify\/Order\/[1-9]\d*$/);
+var ShopifyDomainSchema = import_zod70.z.string().max(POST_PURCHASE_ID_MAX).regex(/^[a-z0-9]([a-z0-9-]*[a-z0-9])?\.myshopify\.com$/);
+var DecideRequestSchema = import_zod70.z.object({
+  checkoutToken: import_zod70.z.string().min(1).max(POST_PURCHASE_ID_MAX),
   shop: ShopifyDomainSchema
 });
-var PostPurchaseAppIdSchema = import_zod69.z.string().min(1).max(POST_PURCHASE_ID_MAX);
-var DecisionEntrySchema = import_zod69.z.object({
-  blockId: import_zod69.z.number().int().positive(),
-  blockIndex: import_zod69.z.string(),
-  blockParentIndex: import_zod69.z.string(),
-  flowId: import_zod69.z.number().int().positive(),
-  sectionId: import_zod69.z.number().int().positive(),
-  widgetId: import_zod69.z.number().int().positive(),
-  widgetTraffic: import_zod69.z.number().min(0).max(100)
+var PostPurchaseAppIdSchema = import_zod70.z.string().min(1).max(POST_PURCHASE_ID_MAX);
+var DecisionEntrySchema = import_zod70.z.object({
+  blockId: import_zod70.z.number().int().positive(),
+  blockIndex: import_zod70.z.string(),
+  blockParentIndex: import_zod70.z.string(),
+  flowId: import_zod70.z.number().int().positive(),
+  sectionId: import_zod70.z.number().int().positive(),
+  widgetId: import_zod70.z.number().int().positive(),
+  widgetTraffic: import_zod70.z.number().min(0).max(100)
 });
 
 // src/schema/postPurchaseMemberIdentity.ts
-var import_zod70 = require("zod");
-var PostPurchaseMemberIdentity = import_zod70.z.object({
-  productId: import_zod70.z.number().int().positive(),
-  productIndex: import_zod70.z.number().int().nonnegative()
-}).strict();
-
-// src/schema/postPurchaseProductCalculation.ts
 var import_zod71 = require("zod");
-var MoneyBag = import_zod71.z.object({
-  presentmentMoney: import_zod71.z.object({
-    amount: PostPurchaseAmount,
-    currencyCode: import_zod71.z.string().regex(/^[A-Z]{3}$/)
-  })
-});
-var PostPurchaseProductCalculation = import_zod71.z.object({
-  calculatedPurchase: import_zod71.z.object({
-    addedShippingLines: import_zod71.z.array(import_zod71.z.object({ priceSet: MoneyBag })),
-    addedTaxLines: import_zod71.z.array(import_zod71.z.object({ priceSet: MoneyBag })),
-    totalOutstandingSet: MoneyBag,
-    updatedLineItems: import_zod71.z.array(
-      import_zod71.z.object({
-        priceSet: import_zod71.z.unknown().optional(),
-        productId: import_zod71.z.number().int().positive(),
-        sellingPlanId: import_zod71.z.unknown().optional(),
-        variantId: import_zod71.z.number().int().positive()
-      })
-    )
-  }),
-  errors: import_zod71.z.array(import_zod71.z.unknown()).length(0),
-  status: import_zod71.z.literal("processed")
-});
-var Minor = import_zod71.z.number().int().nonnegative().max(Number.MAX_SAFE_INTEGER);
-var PostPurchaseProductCosts = import_zod71.z.object({
-  currencyCode: MoneyBag.shape.presentmentMoney.shape.currencyCode,
-  recurringDisplay: import_zod71.z.object({ shippingMinor: Minor, subtotalMinor: Minor, totalMinor: Minor }).optional(),
-  shippingMinor: Minor,
-  subtotalMinor: Minor,
-  taxesMinor: Minor,
-  totalMinor: Minor
-});
-var ChangesetDiscount = import_zod71.z.object({
-  title: import_zod71.z.string(),
-  value: import_zod71.z.number().nonnegative(),
-  valueType: import_zod71.z.enum(["percentage", "fixed_amount"])
-}).optional();
-var PostPurchaseProductChangeset = import_zod71.z.object({
-  changes: import_zod71.z.array(
-    import_zod71.z.union([
-      import_zod71.z.object({
-        discount: ChangesetDiscount,
-        quantity: import_zod71.z.number().int().positive(),
-        type: import_zod71.z.literal("add_variant"),
-        variantId: import_zod71.z.number().int().positive()
-      }),
-      import_zod71.z.object({ price: import_zod71.z.number().nonnegative(), title: import_zod71.z.string(), type: import_zod71.z.literal("add_shipping_line") }),
-      PostPurchaseSubscriptionTerms.pick({
-        initialShippingPrice: true,
-        recurringShippingPrice: true,
-        shippingOption: true
-      }).extend({
-        discount: ChangesetDiscount,
-        quantity: import_zod71.z.number().int().positive(),
-        sellingPlanId: import_zod71.z.number().int().positive(),
-        type: import_zod71.z.literal("add_subscription"),
-        variantId: import_zod71.z.number().int().positive()
-      })
-    ])
-  )
-});
+var PostPurchaseMemberIdentity = import_zod71.z.object({
+  productId: import_zod71.z.number().int().positive(),
+  productIndex: import_zod71.z.number().int().nonnegative()
+}).strict();
 
 // src/schema/postPurchaseAdmission.ts
+var PurchaseAdmissionModeSchema = import_zod72.z.enum(["purchase", "upgrade"]);
+var selection = PreparedPostPurchaseProduct.shape.selection;
 var PurchaseExpectedSchema = import_zod72.z.object({
   buyerConsentToSubscriptions: import_zod72.z.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -6780,16 +6783,20 @@ var PurchaseExpectedSchema = import_zod72.z.object({
   }),
   entry: DecisionEntrySchema,
   member: PostPurchaseMemberIdentity.optional(),
+  mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: import_zod72.z.number().int().nonnegative().optional(),
-  selection: PreparedPostPurchaseProduct.shape.selection
+  selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
   "Captured member requires progress"
-).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection3 }) => {
+).refine(
+  ({ mode, selection: { sellingPlanId } }) => mode !== "upgrade" || sellingPlanId !== void 0,
+  "An upgrade selects a subscription"
+).refine(({ buyerConsentToSubscriptions: consent, changeset, selection: selection4 }) => {
   const [change, shipping] = changeset.changes;
-  if (selection3.sellingPlanId === void 0)
-    return consent !== true && change?.type === "add_variant" && change.variantId === selection3.variantId && change.quantity === selection3.quantity && (shipping === void 0 || shipping.type === "add_shipping_line");
-  return consent === true && changeset.changes.length === 1 && change.type === "add_subscription" && change.sellingPlanId === selection3.sellingPlanId && change.variantId === selection3.variantId && change.quantity === selection3.quantity;
+  if (selection4.sellingPlanId === void 0)
+    return consent !== true && change?.type === "add_variant" && change.variantId === selection4.variantId && change.quantity === selection4.quantity && (shipping === void 0 || shipping.type === "add_shipping_line");
+  return consent === true && changeset.changes.length === 1 && change.type === "add_subscription" && change.sellingPlanId === selection4.sellingPlanId && change.variantId === selection4.variantId && change.quantity === selection4.quantity;
 }, "Selection, change and buyer consent must agree");
 var PurchaseRequestSchema = DecideRequestSchema.extend({
   expected: PurchaseExpectedSchema,
@@ -6798,12 +6805,18 @@ var PurchaseRequestSchema = DecideRequestSchema.extend({
 var PurchaseReceiptSchema = import_zod72.z.object({
   admittedAt: PostPurchaseTimestampSchema,
   changesetToken: import_zod72.z.string().min(1),
+  mode: PurchaseAdmissionModeSchema.optional(),
   operationId: import_zod72.z.uuid(),
+  /** The server-bound one-time line an upgrade refunds; its quantity is the order's, not the selection's. */
+  originalLine: import_zod72.z.strictObject({ quantity: selection.shape.quantity, variantId: selection.shape.variantId }).optional(),
   requiresSubscriptionConsent: import_zod72.z.boolean(),
-  selection: PreparedPostPurchaseProduct.shape.selection
+  selection
 }).refine(
-  ({ requiresSubscriptionConsent, selection: selection3 }) => requiresSubscriptionConsent === (selection3.sellingPlanId !== void 0),
+  ({ requiresSubscriptionConsent, selection: selection4 }) => requiresSubscriptionConsent === (selection4.sellingPlanId !== void 0),
   "Receipt consent must match its selected plan"
+).refine(
+  ({ mode, originalLine, selection: { sellingPlanId, variantId } }) => mode === "upgrade" ? sellingPlanId !== void 0 && originalLine?.variantId === variantId : originalLine === void 0,
+  "An upgrade Receipt binds the original line of its subscribed variant, and only an upgrade does"
 );
 var PurchaseResponseSchema = import_zod72.z.object({ data: PurchaseReceiptSchema, successful: import_zod72.z.literal(true) });
 
@@ -6945,7 +6958,7 @@ var readPostPurchaseQuantity = ({
   data,
   effective,
   original
-}, selection3) => {
+}, selection4) => {
   const positive = PreparedPostPurchaseProduct.shape.selection.shape.quantity;
   for (const config of [original, effective]) {
     if (!config.quantityInputs.enabled) continue;
@@ -6958,7 +6971,7 @@ var readPostPurchaseQuantity = ({
   const policy = PostPurchaseQuantityPolicy.parse(
     effective.quantityInputs.enabled ? { ...effective.quantityInputs, initialQuantity } : { enabled: false, initialQuantity, maxValue: initialQuantity, minValue: initialQuantity }
   );
-  const requested = "quantity" in selection3 ? selection3.quantity : selection3.expectedQuantity === initialQuantity ? void 0 : selection3.expectedQuantity;
+  const requested = "quantity" in selection4 ? selection4.quantity : selection4.expectedQuantity === initialQuantity ? void 0 : selection4.expectedQuantity;
   const quantity2 = positive.parse(requested ?? initialQuantity);
   if (requested !== void 0 && (policy.enabled ? quantity2 < policy.minValue || quantity2 > policy.maxValue : quantity2 !== initialQuantity))
     throw new PostPurchaseQuantityUnavailable("Requested quantity is unavailable");
@@ -7102,12 +7115,12 @@ var preparePostPurchaseMemberAdmissionView = (widgetId, settings, response, requ
 
 // src/server/preparePostPurchaseQuantityView.ts
 var preparePostPurchaseQuantityView = (widgetId, settings, response, requested, report, excludedProductIds, defaults) => {
-  const { quantity: quantity2, ...selection3 } = PostPurchaseQuantityChoice.parse(requested);
+  const { quantity: quantity2, ...selection4 } = PostPurchaseQuantityChoice.parse(requested);
   const prepared = prepareMember(
     widgetId,
     settings,
     response,
-    selection3,
+    selection4,
     report,
     excludedProductIds,
     { quantity: quantity2 },
@@ -7117,9 +7130,9 @@ var preparePostPurchaseQuantityView = (widgetId, settings, response, requested,
 };
 
 // src/server/preparePostPurchaseQuantityAdmissionView.ts
-var selection = PostPurchaseQuantityChoice.required({ quantity: true });
+var selection2 = PostPurchaseQuantityChoice.required({ quantity: true });
 var preparePostPurchaseQuantityAdmissionView = (widgetId, settings, response, expected, report, excludedProductIds, defaults) => {
-  const { quantity: expectedQuantity, ...requested } = selection.parse(expected);
+  const { quantity: expectedQuantity, ...requested } = selection2.parse(expected);
   const prepared = prepareMember(
     widgetId,
     settings,
@@ -7172,12 +7185,12 @@ var readPostPurchaseGroup = (product, settings, excludedProductIds) => {
 
 // src/server/readPostPurchaseGroupSelection.ts
 var readPostPurchaseGroupSelection = (settings, response, requested, excludedProductIds) => {
-  const selection3 = PostPurchaseGroupSelection.parse(requested);
+  const selection4 = PostPurchaseGroupSelection.parse(requested);
   const { members, normalized } = normalizePostPurchaseCollection(settings, response);
-  const member = members.find(({ product }) => product.id === selection3.memberProductId);
+  const member = members.find(({ product }) => product.id === selection4.memberProductId);
   if (!member || !member.product.productGroupVariants.length) return null;
   const group = readPostPurchaseGroup(member.product, normalized.effective, excludedProductIds);
-  const entry = group.entries.find(({ product }) => product.id === selection3.productId);
+  const entry = group.entries.find(({ product }) => product.id === selection4.productId);
   if (!entry) return null;
   return {
     groupCatalog: group.catalog,
@@ -7191,16 +7204,16 @@ var readPostPurchaseGroupSelection = (settings, response, requested, excludedPro
 
 // src/server/preparePostPurchaseGroupView.ts
 var preparePostPurchaseGroupView = (widgetId, settings, response, requested, report, excludedProductIds) => {
-  const { memberProductId, ...selection3 } = PostPurchaseGroupChoice.parse(requested);
+  const { memberProductId, ...selection4 } = PostPurchaseGroupChoice.parse(requested);
   const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
   if (!group) return null;
-  const variantId = selection3.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
+  const variantId = selection4.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
   if (variantId === void 0) return null;
   const prepared = preparePostPurchaseQuantityView(
     widgetId,
     settings,
     group.response,
-    { ...selection3, variantId },
+    { ...selection4, variantId },
     report
   );
   return prepared && {
@@ -7214,16 +7227,16 @@ var preparePostPurchaseGroupView = (widgetId, settings, response, requested, rep
 
 // src/server/preparePostPurchaseGroupAdmissionView.ts
 var preparePostPurchaseGroupAdmissionView = (widgetId, settings, response, requested, report, excludedProductIds) => {
-  const { memberProductId, ...selection3 } = PostPurchaseGroupChoice.required({ quantity: true }).parse(requested);
+  const { memberProductId, ...selection4 } = PostPurchaseGroupChoice.required({ quantity: true }).parse(requested);
   const group = readPostPurchaseGroupSelection(settings, response, requested, excludedProductIds);
   if (!group) return null;
-  const variantId = selection3.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
+  const variantId = selection4.variantId ?? group.variantCatalog.variants.find(({ available }) => available)?.id;
   if (variantId === void 0) return null;
   const prepared = preparePostPurchaseQuantityAdmissionView(
     widgetId,
     settings,
     group.response,
-    { ...selection3, variantId },
+    { ...selection4, variantId },
     report
   );
   return prepared && {
@@ -7342,16 +7355,16 @@ var preparePostPurchaseCollectionView = (widgetId, settings, response, report, r
 
 // src/schema/postPurchaseOfferEligibility.ts
 var import_zod81 = require("zod");
-var selection2 = PreparedPostPurchaseProduct.shape.selection;
+var selection3 = PreparedPostPurchaseProduct.shape.selection;
 var PostPurchaseOfferSkipReason = import_zod81.z.enum(["empty", "no-eligible-subscription"]);
 var PostPurchaseOfferEligibilityContext = import_zod81.z.object({
   excludedProductIds: PostPurchaseExcludedProductIds,
-  originalLineItems: import_zod81.z.array(selection2.pick({ productId: true, sellingPlanId: true, variantId: true }))
+  originalLineItems: import_zod81.z.array(selection3.pick({ productId: true, sellingPlanId: true, variantId: true }))
 });
 var PostPurchaseOfferEligibility = import_zod81.z.discriminatedUnion("status", [
   import_zod81.z.object({
     members: import_zod81.z.array(
-      import_zod81.z.object({ productId: selection2.shape.productId, productIndex: import_zod81.z.number().int().nonnegative() })
+      import_zod81.z.object({ productId: selection3.shape.productId, productIndex: import_zod81.z.number().int().nonnegative() })
     ),
     status: import_zod81.z.literal("retain")
   }),
@@ -7461,12 +7474,12 @@ var Selection = import_zod83.z.object({
   variant: OfferDeclineRequestSchema.shape.variant.unwrap()
 });
 var preparePostPurchaseDeclineDisplay = (settings, response, requested) => {
-  const selection3 = Selection.parse(requested);
+  const selection4 = Selection.parse(requested);
   const { members, normalized } = normalizePostPurchaseCollection(settings, response);
-  const found = members.find(({ product }) => product.id === selection3.productId);
+  const found = members.find(({ product }) => product.id === selection4.productId);
   if (!found) return null;
   const catalog = projectPostPurchaseVariantCatalog(found.product, normalized.effective);
-  const variant2 = catalog.variants.find(({ id }) => id === selection3.variant.variantId);
+  const variant2 = catalog.variants.find(({ id }) => id === selection4.variant.variantId);
   return variant2 ? { productTitle: found.product.title, variantId: variant2.id, variantTitle: variant2.title } : null;
 };