@rebuy/rebuy 3.48.1 → 3.49.0

package/dist/index.cjs

@@ -283,6 +283,7 @@ __export(src_exports, {
   RebuyMonetizeV1: () => RebuyMonetizeV1,
   RecordedOfferDeclineSchema: () => RecordedOfferDeclineSchema,
   RecordedPurchaseObservationSchema: () => RecordedPurchaseObservationSchema,
+  RecoveredFollowupsSchema: () => RecoveredFollowupsSchema,
   ReleaseAuthorityRequestSchema: () => ReleaseAuthorityRequestSchema,
   ReleaseAuthorityResponseSchema: () => ReleaseAuthorityResponseSchema,
   ReleaseClaimRequestSchema: () => ReleaseClaimRequestSchema,
@@ -2903,6 +2904,7 @@ var PostPurchaseProductChangeset = import_zod23.z.object({
 // src/schema/postPurchaseAdmission.ts
 var PurchaseAdmissionModeSchema = import_zod24.z.enum(["purchase", "upgrade"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
+var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = import_zod24.z.object({
   buyerConsentToSubscriptions: import_zod24.z.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -2912,6 +2914,11 @@ var PurchaseExpectedSchema = import_zod24.z.object({
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: import_zod24.z.number().int().nonnegative().optional(),
+  /**
+   * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
+   * send its follow-ups with it. Optional: a client from before it was added admits without one.
+   */
+  reportedCalculation: EventCalculationSchema.optional(),
   selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
@@ -2948,7 +2955,6 @@ var PurchaseReceiptSchema = import_zod24.z.object({
 var PurchaseResponseSchema = import_zod24.z.object({ data: PurchaseReceiptSchema, successful: import_zod24.z.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var AcceptedEventOutcomeSchema = import_zod25.z.enum(["acknowledged", "rejected", "skipped", "unknown"]);
 var AttemptProgressSchema = import_zod25.z.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
@@ -4835,17 +4841,38 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
 
 // src/schema/postPurchaseRecovery.ts
 var import_zod83 = require("zod");
+var RecoveredFollowupsSchema = import_zod83.z.strictObject({
+  acceptedEvent: import_zod83.z.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]).nullable(),
+  acceptedMetafield: import_zod83.z.union([AcceptedMetafieldOutcomeSchema, import_zod83.z.literal("attempted")]).nullable()
+});
 var PurchaseRecoveryRequestSchema = DecideRequestSchema.strict();
 var PurchaseRecoveryResponseSchema = import_zod83.z.object({
   data: import_zod83.z.object({
+    /**
+     * Strict, so a client pinned before a new optional field rejects a reply that carries it rather than
+     * stripping it. Release the client before rebuy-api starts emitting a field added here.
+     */
     operation: import_zod83.z.object({
+      /** Absent from a rebuy-api that predates it. */
+      followups: RecoveredFollowupsSchema.optional(),
       observation: RecordedPurchaseObservationSchema.nullable(),
       operationId: PurchaseReceiptSchema.shape.operationId,
+      /** The total the buyer affirmed at admission; absent for an operation admitted without one. */
+      reportedCalculation: EventCalculationSchema.optional(),
       upgrade: UpgradeProgressSchema.optional()
     }).strict().refine(({ operationId, upgrade }) => !upgrade || upgrade.operationId === operationId, {
       message: "Upgrade progress belongs to its operation",
       path: ["upgrade", "operationId"]
-    }).nullable(),
+    }).refine(
+      ({ followups, operationId }) => !followups?.acceptedEvent || followups.acceptedEvent.operationId === operationId,
+      { message: "Follow-up progress belongs to its operation", path: ["followups", "acceptedEvent"] }
+    ).refine(
+      ({ followups, reportedCalculation }) => !followups?.acceptedEvent || !reportedCalculation || followups.acceptedEvent.reportedCalculation.currencyCode === reportedCalculation.currencyCode && followups.acceptedEvent.reportedCalculation.totalMinor === reportedCalculation.totalMinor,
+      {
+        message: "Follow-up progress carries the admitted calculation",
+        path: ["followups", "acceptedEvent", "reportedCalculation"]
+      }
+    ).nullable(),
     progress: PostPurchaseProgressSchema.nullable().optional()
   }),
   successful: import_zod83.z.literal(true)

package/dist/index.mjs

@@ -2432,6 +2432,7 @@ var PostPurchaseProductChangeset = z23.object({
 // src/schema/postPurchaseAdmission.ts
 var PurchaseAdmissionModeSchema = z24.enum(["purchase", "upgrade"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
+var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = z24.object({
   buyerConsentToSubscriptions: z24.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -2441,6 +2442,11 @@ var PurchaseExpectedSchema = z24.object({
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: z24.number().int().nonnegative().optional(),
+  /**
+   * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
+   * send its follow-ups with it. Optional: a client from before it was added admits without one.
+   */
+  reportedCalculation: EventCalculationSchema.optional(),
   selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
@@ -2477,7 +2483,6 @@ var PurchaseReceiptSchema = z24.object({
 var PurchaseResponseSchema = z24.object({ data: PurchaseReceiptSchema, successful: z24.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var AcceptedEventOutcomeSchema = z25.enum(["acknowledged", "rejected", "skipped", "unknown"]);
 var AttemptProgressSchema = z25.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,
@@ -4364,17 +4369,38 @@ var PostPurchaseProductSettings = PostPurchaseSettings.pick({
 
 // src/schema/postPurchaseRecovery.ts
 import { z as z83 } from "zod";
+var RecoveredFollowupsSchema = z83.strictObject({
+  acceptedEvent: z83.union([AcceptedEventAttemptProgressSchema, AcceptedEventResultProgressSchema]).nullable(),
+  acceptedMetafield: z83.union([AcceptedMetafieldOutcomeSchema, z83.literal("attempted")]).nullable()
+});
 var PurchaseRecoveryRequestSchema = DecideRequestSchema.strict();
 var PurchaseRecoveryResponseSchema = z83.object({
   data: z83.object({
+    /**
+     * Strict, so a client pinned before a new optional field rejects a reply that carries it rather than
+     * stripping it. Release the client before rebuy-api starts emitting a field added here.
+     */
     operation: z83.object({
+      /** Absent from a rebuy-api that predates it. */
+      followups: RecoveredFollowupsSchema.optional(),
       observation: RecordedPurchaseObservationSchema.nullable(),
       operationId: PurchaseReceiptSchema.shape.operationId,
+      /** The total the buyer affirmed at admission; absent for an operation admitted without one. */
+      reportedCalculation: EventCalculationSchema.optional(),
       upgrade: UpgradeProgressSchema.optional()
     }).strict().refine(({ operationId, upgrade }) => !upgrade || upgrade.operationId === operationId, {
       message: "Upgrade progress belongs to its operation",
       path: ["upgrade", "operationId"]
-    }).nullable(),
+    }).refine(
+      ({ followups, operationId }) => !followups?.acceptedEvent || followups.acceptedEvent.operationId === operationId,
+      { message: "Follow-up progress belongs to its operation", path: ["followups", "acceptedEvent"] }
+    ).refine(
+      ({ followups, reportedCalculation }) => !followups?.acceptedEvent || !reportedCalculation || followups.acceptedEvent.reportedCalculation.currencyCode === reportedCalculation.currencyCode && followups.acceptedEvent.reportedCalculation.totalMinor === reportedCalculation.totalMinor,
+      {
+        message: "Follow-up progress carries the admitted calculation",
+        path: ["followups", "acceptedEvent", "reportedCalculation"]
+      }
+    ).nullable(),
     progress: PostPurchaseProgressSchema.nullable().optional()
   }),
   successful: z83.literal(true)
@@ -6762,6 +6788,7 @@ export {
   RebuyMonetizeV1,
   RecordedOfferDeclineSchema,
   RecordedPurchaseObservationSchema,
+  RecoveredFollowupsSchema,
   ReleaseAuthorityRequestSchema,
   ReleaseAuthorityResponseSchema,
   ReleaseClaimRequestSchema,

package/dist/schema/postPurchaseAcceptedEvent.d.ts

@@ -1,8 +1,4 @@
 import { z } from 'zod';
-export declare const EventCalculationSchema: z.ZodObject<{
-    currencyCode: z.ZodString;
-    totalMinor: z.ZodNumber;
-}, z.core.$strict>;
 /**
  * apiv2's Flow-trigger bridge outcome, shared by every Flow event (accepted, declined, lifecycle, classification).
  * `skipped` is terminal and intended: apiv2 skips guest orders, whose null customer Flow would refuse.
@@ -72,5 +68,4 @@ export declare const AcceptedEventResponseSchema: z.ZodObject<{
     }, z.core.$strict>]>;
     successful: z.ZodLiteral<true>;
 }, z.core.$strip>;
-export type EventCalculation = z.infer<typeof EventCalculationSchema>;
 export type AcceptedEventOutcome = z.infer<typeof AcceptedEventOutcomeSchema>;

package/dist/schema/postPurchaseAdmission.d.ts

@@ -7,6 +7,11 @@ export declare const PurchaseAdmissionModeSchema: z.ZodEnum<{
     purchase: "purchase";
     upgrade: "upgrade";
 }>;
+/** The buyer's SDK-calculated total for the affirmed terms (`calculateChangeset`), never proof of payment. */
+export declare const EventCalculationSchema: z.ZodObject<{
+    currencyCode: z.ZodString;
+    totalMinor: z.ZodNumber;
+}, z.core.$strict>;
 export declare const PurchaseExpectedSchema: z.ZodObject<{
     buyerConsentToSubscriptions: z.ZodOptional<z.ZodBoolean>;
     changeset: z.ZodObject<{
@@ -65,6 +70,10 @@ export declare const PurchaseExpectedSchema: z.ZodObject<{
         upgrade: "upgrade";
     }>>;
     progressRevision: z.ZodOptional<z.ZodNumber>;
+    reportedCalculation: z.ZodOptional<z.ZodObject<{
+        currencyCode: z.ZodString;
+        totalMinor: z.ZodNumber;
+    }, z.core.$strict>>;
     selection: z.ZodObject<{
         productId: z.ZodNumber;
         quantity: z.ZodNumber;
@@ -133,6 +142,10 @@ export declare const PurchaseRequestSchema: z.ZodObject<{
             upgrade: "upgrade";
         }>>;
         progressRevision: z.ZodOptional<z.ZodNumber>;
+        reportedCalculation: z.ZodOptional<z.ZodObject<{
+            currencyCode: z.ZodString;
+            totalMinor: z.ZodNumber;
+        }, z.core.$strict>>;
         selection: z.ZodObject<{
             productId: z.ZodNumber;
             quantity: z.ZodNumber;
@@ -185,6 +198,7 @@ export declare const PurchaseResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
     successful: z.ZodLiteral<true>;
 }, z.core.$strip>;
+export type EventCalculation = z.infer<typeof EventCalculationSchema>;
 export type PurchaseReceipt = z.infer<typeof PurchaseReceiptSchema>;
 export type PurchaseExpected = z.infer<typeof PurchaseExpectedSchema>;
 export type PurchaseRequest = z.infer<typeof PurchaseRequestSchema>;

package/dist/schema/postPurchaseRecovery.d.ts

@@ -1,4 +1,39 @@
 import { z } from 'zod';
+/**
+ * How far the latest operation's follow-ups got: its accepted Flow event (`null` until one is attempted) and
+ * the status of the saved accepted-metafield write that covers it (`null` until one does). Progress only: a
+ * reloaded client re-runs `/purchases/accepted`, which is idempotent per operation, whatever this says.
+ */
+export declare const RecoveredFollowupsSchema: z.ZodObject<{
+    acceptedEvent: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+        attemptedAt: z.ZodNumber;
+        reportedCalculation: z.ZodObject<{
+            currencyCode: z.ZodString;
+            totalMinor: z.ZodNumber;
+        }, z.core.$strict>;
+        status: z.ZodLiteral<"attempted">;
+        operationId: z.ZodUUID;
+    }, z.core.$strict>, z.ZodObject<{
+        attemptedAt: z.ZodNumber;
+        reportedCalculation: z.ZodObject<{
+            currencyCode: z.ZodString;
+            totalMinor: z.ZodNumber;
+        }, z.core.$strict>;
+        finishedAt: z.ZodNumber;
+        status: z.ZodEnum<{
+            unknown: "unknown";
+            acknowledged: "acknowledged";
+            rejected: "rejected";
+            skipped: "skipped";
+        }>;
+        operationId: z.ZodUUID;
+    }, z.core.$strict>]>>;
+    acceptedMetafield: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+        unknown: "unknown";
+        acknowledged: "acknowledged";
+        rejected: "rejected";
+    }>, z.ZodLiteral<"attempted">]>>;
+}, z.core.$strict>;
 /** A saved observation or its absence, never permission to apply a changeset. */
 export declare const PurchaseRecoveryRequestSchema: z.ZodObject<{
     checkoutToken: z.ZodString;
@@ -7,6 +42,36 @@ export declare const PurchaseRecoveryRequestSchema: z.ZodObject<{
 export declare const PurchaseRecoveryResponseSchema: z.ZodObject<{
     data: z.ZodObject<{
         operation: z.ZodNullable<z.ZodObject<{
+            followups: z.ZodOptional<z.ZodObject<{
+                acceptedEvent: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
+                    attemptedAt: z.ZodNumber;
+                    reportedCalculation: z.ZodObject<{
+                        currencyCode: z.ZodString;
+                        totalMinor: z.ZodNumber;
+                    }, z.core.$strict>;
+                    status: z.ZodLiteral<"attempted">;
+                    operationId: z.ZodUUID;
+                }, z.core.$strict>, z.ZodObject<{
+                    attemptedAt: z.ZodNumber;
+                    reportedCalculation: z.ZodObject<{
+                        currencyCode: z.ZodString;
+                        totalMinor: z.ZodNumber;
+                    }, z.core.$strict>;
+                    finishedAt: z.ZodNumber;
+                    status: z.ZodEnum<{
+                        unknown: "unknown";
+                        acknowledged: "acknowledged";
+                        rejected: "rejected";
+                        skipped: "skipped";
+                    }>;
+                    operationId: z.ZodUUID;
+                }, z.core.$strict>]>>;
+                acceptedMetafield: z.ZodNullable<z.ZodUnion<readonly [z.ZodEnum<{
+                    unknown: "unknown";
+                    acknowledged: "acknowledged";
+                    rejected: "rejected";
+                }>, z.ZodLiteral<"attempted">]>>;
+            }, z.core.$strict>>;
             observation: z.ZodNullable<z.ZodObject<{
                 observation: z.ZodUnion<readonly [z.ZodObject<{
                     changesetApplicationsRemaining: z.ZodNumber;
@@ -39,6 +104,10 @@ export declare const PurchaseRecoveryResponseSchema: z.ZodObject<{
                 recordedAt: z.ZodNumber;
             }, z.core.$strict>>;
             operationId: z.ZodUUID;
+            reportedCalculation: z.ZodOptional<z.ZodObject<{
+                currencyCode: z.ZodString;
+                totalMinor: z.ZodNumber;
+            }, z.core.$strict>>;
             upgrade: z.ZodOptional<z.ZodObject<{
                 compensation: z.ZodNullable<z.ZodUnion<readonly [z.ZodObject<{
                     attemptedAt: z.ZodNumber;
@@ -130,3 +199,5 @@ export declare const PurchaseRecoveryResponseSchema: z.ZodObject<{
     }, z.core.$strip>;
     successful: z.ZodLiteral<true>;
 }, z.core.$strip>;
+export type RecoveredFollowups = z.infer<typeof RecoveredFollowupsSchema>;
+export type PurchaseRecoveryResponse = z.infer<typeof PurchaseRecoveryResponseSchema>;

package/dist/server/index.cjs

@@ -7225,6 +7225,7 @@ var PostPurchaseMemberIdentity = import_zod75.z.object({
 // src/schema/postPurchaseAdmission.ts
 var PurchaseAdmissionModeSchema = import_zod76.z.enum(["purchase", "upgrade"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
+var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = import_zod76.z.object({
   buyerConsentToSubscriptions: import_zod76.z.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -7234,6 +7235,11 @@ var PurchaseExpectedSchema = import_zod76.z.object({
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: import_zod76.z.number().int().nonnegative().optional(),
+  /**
+   * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
+   * send its follow-ups with it. Optional: a client from before it was added admits without one.
+   */
+  reportedCalculation: EventCalculationSchema.optional(),
   selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
@@ -7270,7 +7276,6 @@ var PurchaseReceiptSchema = import_zod76.z.object({
 var PurchaseResponseSchema = import_zod76.z.object({ data: PurchaseReceiptSchema, successful: import_zod76.z.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var AcceptedEventOutcomeSchema = import_zod77.z.enum(["acknowledged", "rejected", "skipped", "unknown"]);
 var AttemptProgressSchema = import_zod77.z.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,

package/dist/server/index.mjs

@@ -7153,6 +7153,7 @@ var PostPurchaseMemberIdentity = z75.object({
 // src/schema/postPurchaseAdmission.ts
 var PurchaseAdmissionModeSchema = z76.enum(["purchase", "upgrade"]);
 var selection = PreparedPostPurchaseProduct.shape.selection;
+var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var PurchaseExpectedSchema = z76.object({
   buyerConsentToSubscriptions: z76.boolean().optional(),
   changeset: PostPurchaseProductChangeset.extend({
@@ -7162,6 +7163,11 @@ var PurchaseExpectedSchema = z76.object({
   member: PostPurchaseMemberIdentity.optional(),
   mode: PurchaseAdmissionModeSchema.optional(),
   progressRevision: z76.number().int().nonnegative().optional(),
+  /**
+   * The total the buyer affirmed, stored with the admitted operation so a reloaded client can still
+   * send its follow-ups with it. Optional: a client from before it was added admits without one.
+   */
+  reportedCalculation: EventCalculationSchema.optional(),
   selection
 }).refine(
   ({ member, progressRevision }) => !member || progressRevision !== void 0,
@@ -7198,7 +7204,6 @@ var PurchaseReceiptSchema = z76.object({
 var PurchaseResponseSchema = z76.object({ data: PurchaseReceiptSchema, successful: z76.literal(true) });
 
 // src/schema/postPurchaseAcceptedEvent.ts
-var EventCalculationSchema = PostPurchaseProductCosts.pick({ currencyCode: true, totalMinor: true }).strict();
 var AcceptedEventOutcomeSchema = z77.enum(["acknowledged", "rejected", "skipped", "unknown"]);
 var AttemptProgressSchema = z77.strictObject({
   attemptedAt: PostPurchaseTimestampSchema,

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@rebuy/rebuy",
-    "version": "3.48.1",
+    "version": "3.49.0",
     "description": "Shared zod schemas, legacy-to-CAB widget transforms, and server orchestrators for Rebuy's Shopify consumers (rebuy-api, admin-nextjs, rebuy-shopify-extensions)",
     "license": "MIT",
     "author": "Rebuy, Inc.",