@rebuy/rebuy 3.17.0-rc.1 → 3.18.0

package/dist/gwp/index.cjs

@@ -20,6 +20,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/gwp/index.ts
 var gwp_exports = {};
 __export(gwp_exports, {
+  GIFT_KINDS: () => GIFT_KINDS,
   getValidGwpProductIds: () => getValidGwpProductIds,
   hasLostDiscount: () => hasLostDiscount,
   hasUnsupportedRuleTypes: () => hasUnsupportedRuleTypes,
@@ -50,3 +51,6 @@ var isDefinitiveRuleAnswer = (metadata) => metadata != null && (metadata.matched
 // src/gwp/shouldRemoveGift.ts
 var hasLostDiscount = (gift) => !gift.discounted && gift.cost > 0;
 var shouldRemoveGift = (gift, validIds) => !validIds.has(gift.productId) || hasLostDiscount(gift);
+
+// src/gwp/types.ts
+var GIFT_KINDS = ["gwp", "sgwp"];

package/dist/gwp/index.mjs

@@ -19,7 +19,11 @@ var isDefinitiveRuleAnswer = (metadata) => metadata != null && (metadata.matched
 // src/gwp/shouldRemoveGift.ts
 var hasLostDiscount = (gift) => !gift.discounted && gift.cost > 0;
 var shouldRemoveGift = (gift, validIds) => !validIds.has(gift.productId) || hasLostDiscount(gift);
+
+// src/gwp/types.ts
+var GIFT_KINDS = ["gwp", "sgwp"];
 export {
+  GIFT_KINDS,
   getValidGwpProductIds,
   hasLostDiscount,
   hasUnsupportedRuleTypes,

package/dist/gwp/types.d.ts

@@ -1,17 +1,39 @@
-/** A gift-with-purchase cart line the client asks the server to validate. */
+/**
+ * The attribution a gift line carries, as the wire tags it: `gwp` = `Rebuy Gift with Purchase`, `sgwp` =
+ * `Rebuy Selectable Gift with Purchase`. `gwp` lines run the GWP rules; `sgwp` lines are judged against their
+ * widget's milestones (REB-24363).
+ */
+export declare const GIFT_KINDS: readonly ["gwp", "sgwp"];
+export type GiftKind = (typeof GIFT_KINDS)[number];
+/**
+ * A gift cart line the client asks the server to validate (GWP or selectable GWP — see {@link GiftKind}).
+ * This is the WIRE shape — what a client sends, `z.input` of the server's `GiftInputSchema` — so the two
+ * REB-24363 fields are optional here: a client that predates them sends GWP lines only, and the schema
+ * defaults fill them (`kind: 'gwp'`, `quantity: 1`) before the server reads either. The parsed twin
+ * (`GiftInput`, `./server`) carries both as required.
+ */
 export type GwpGift = {
     /**
-     * The gift line's total in the buyer's MARKET currency, MAJOR units (e.g. `19.99`) — a
-     * Function-discounted (free) gift is `0`. Only the zero/non-zero distinction is read
-     * (`cost > 0` ⇒ the gift lost its discount), so the exact unit isn't load-bearing; send the
-     * Shopify cart-line total as-is.
+     * The gift line's total in the buyer's MARKET (presentment) currency, MAJOR units (e.g. `19.99`) — a
+     * Function-discounted (free) gift is `0`. Send the Shopify cart-line total as-is; both the unit and the
+     * magnitude are contractual. A `gwp` line only has its zero/non-zero read (`cost > 0` ⇒ the gift lost
+     * its discount), but an `sgwp` line's cost is subtracted from the subtotal its milestones are judged
+     * against (×100, ÷ the FX rate), so a minor-unit or unit-price value there would over-subtract and
+     * silently strip earned gifts (REB-24363).
      */
     cost: number;
     /** Whether the Shopify Function discount is currently allocated to the line. */
     discounted: boolean;
+    /** Which attribution the line carries; omitted by clients that predate the field (reads as `gwp`). */
+    kind?: GiftKind;
     /** Shopify cart-line id to remove. */
     lineId: string;
     productId: number;
+    /**
+     * The line's unit count; the selectable-GWP verdict trims surplus units against milestone capacity.
+     * Omitted by clients that predate the field (reads as one unit — a GWP verdict is whole-line anyway).
+     */
+    quantity?: number;
     /** The Rebuy widget that added the gift (`_widget_id`). */
     widgetId: number;
 };

package/dist/server/analytics.d.ts

@@ -25,7 +25,7 @@ declare const TAXONOMY: {
             element_id: string;
             experiment_type: string;
         };
-        buildTags: ({ experimentId }: Record<string, unknown>) => string[] | undefined;
+        buildTags: ({ experimentId }: Record<string, unknown>, input: AnalyticsInput) => string[] | undefined;
         noun: "cart";
         subject: "abtest";
         usesWidgetId: false;
@@ -37,7 +37,7 @@ declare const TAXONOMY: {
         buildMeta: ({ productId, variantId }: Record<string, unknown>) => {
             [x: string]: true;
         };
-        buildTags: ({ experimentId }: Record<string, unknown>) => string[] | undefined;
+        buildTags: ({ experimentId }: Record<string, unknown>, input: AnalyticsInput) => string[] | undefined;
         /** Under an experiment the add belongs to the VARIANT element, not the placeholder (React parity). */
         buildWidgetId: ({ elementId }: Record<string, unknown>, input: {
             events: {
@@ -49,6 +49,11 @@ declare const TAXONOMY: {
             visitorId: string;
             cartToken?: string | undefined;
             checkoutToken?: string | undefined;
+            segments?: {
+                device?: string | undefined;
+                source?: string | undefined;
+                visitor?: string | undefined;
+            } | undefined;
             widgetId?: string | undefined;
         }) => string | undefined;
         noun: "widget";
@@ -77,7 +82,7 @@ declare const TAXONOMY: {
         verb: "tracking";
     };
     'widget-viewed': {
-        buildTags: ({ experimentId }: Record<string, unknown>) => string[] | undefined;
+        buildTags: ({ experimentId }: Record<string, unknown>, input: AnalyticsInput) => string[] | undefined;
         /** Under an experiment the view belongs to the VARIANT element, not the placeholder (React parity, same as added-to-cart) — else views credit the placeholder while adds credit the variant and per-widget conversion is meaningless. */
         buildWidgetId: ({ elementId }: Record<string, unknown>, input: {
             events: {
@@ -89,6 +94,11 @@ declare const TAXONOMY: {
             visitorId: string;
             cartToken?: string | undefined;
             checkoutToken?: string | undefined;
+            segments?: {
+                device?: string | undefined;
+                source?: string | undefined;
+                visitor?: string | undefined;
+            } | undefined;
             widgetId?: string | undefined;
         }) => string | undefined;
         noun: "widget";

package/dist/server/analyticsSegments.d.ts

@@ -0,0 +1,6 @@
+import { type AnalyticsSegmentsInput } from '../server/requestSchemas';
+/**
+ * One `<baseTag>.<dimension>.<bucket>` tag per segment whose bucket passes {@link SEGMENT_BUCKETS}; invalid
+ * or absent dimensions contribute nothing (so valid siblings still ride along).
+ */
+export declare const segmentTags: (baseTag: string, segments: AnalyticsSegmentsInput | undefined) => string[];

package/dist/server/giftValidation.d.ts

@@ -1,22 +1,20 @@
-import { type GiftValidationInput, type ServerContext } from '../server/shared';
+import { type GiftValidationInput, type GiftValidationResponse, type ServerContext } from '../server/shared';
 /**
- * Validates gift lines per widget and returns the cart-line ids to remove (the complete receipt).
- * Per widget: resolve its data-source path, evaluate its rules against the cart (`limit: 0`), then
- * drop gifts that no longer qualify OR lost their discount.
+ * Validates the gift lines and returns the receipt. The two gift kinds get independent verdicts, each
+ * filling its own list — so a line id can never land in both: GWP (`gwp`) lines are judged whole-line by
+ * their widget's rules and fill `remove` ({@link validateGwpGifts}); selectable GWP (`sgwp`) lines are
+ * trimmed to their widget's milestone capacity and fill `adjust` (target quantity, `0` = remove —
+ * {@link validateSelectableGifts}). A selectable gift may be legitimately priced, so the GWP charged-gift
+ * rule never touches it. Both halves fail safe per widget, so a degraded answer for one widget never
+ * disturbs another's verdict.
  *
- * The two removal reasons are NOT symmetric. **Qualification loss** (a gift's product no longer matches
- * the rules) needs the engine's answer, so it is **fail-safe**: any error, a missing endpoint, a
- * non-definitive rule answer (no metadata, or metadata with neither rule array — the tolerated-empty-2xx
- * path), or unsupported rule types (`url`/`order_tag`) → don't drop on qualification (never remove a
- * genuinely-qualified gift on uncertainty). A definitive answer removes a gift its matched-rule product
- * output omits; when that output yields NO ids at all, only a confirmed miss ({@link isConfirmedRuleMiss}:
- * `unmatchedRules` populated, `matchedRules` empty) removes — a matched rule with a non-product output
- * (collection/endpoint/tag) or a zero-rule ruleset proves nothing, so those keep the gifts (REB-23842,
- * matching the React extension). **Discount loss** ({@link hasLostDiscount}: `!discounted && cost > 0`) is cart-observable
- * and needs NO engine answer, so it removes the gift on EVERY path, degraded or not — a buyer must not keep
- * paying for a "gift" because the rule engine was degraded. (React removed on any successful fetch; this
- * splits the observable discount-loss out of the qualification fail-safe rather than gating both behind it.)
+ * The receipt's one-verdict-per-line invariant (`GiftValidationResponseSchema`) is upheld HERE, not by the
+ * client: nothing stops a buggy watcher sending one `lineId` twice — under both kinds (a line carrying
+ * both attributions, or a double push), or as `sgwp` under two widgets — which would otherwise land it in
+ * both lists, or twice in `adjust` with conflicting targets, and fail the response schema at the route — a
+ * 500 where the feature promises fail-safe. The strictest verdict wins: removal over any target (a removed
+ * line has no quantity left), and the smallest target among duplicates (each is a trim, so the smallest can
+ * never exceed what was sent). `remove` is likewise named once per line (a `gwp` line sent under two
+ * widgets is removed by both legs), so a client issuing one cart mutation per entry never removes twice.
  */
-export declare const validateGifts: (input: GiftValidationInput, ctx: ServerContext) => Promise<{
-    remove: string[];
-}>;
+export declare const validateGifts: (input: GiftValidationInput, ctx: ServerContext) => Promise<GiftValidationResponse>;

package/dist/server/giftWidgets.d.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod';
+import { type GiftKind } from '../gwp';
+import { type GiftInput, type Reporter, type ServerContext } from '../server/shared';
+/**
+ * One selectable-GWP milestone, RAW (snake_case) as the retired React validator read it: `unlock_price` in
+ * shop MAJOR units, `selectable_product_quantity` in units (a non-negative whole count — a fractional or
+ * negative capacity is nonsense, so it is malformed rather than summed).
+ *
+ * `unlock_price` is deliberately NOT bounded below. A negative or zero price is a legitimate "always
+ * unlocked" tier (the progress-bar converter tolerates the same via `Number(...) || 0`), and it only
+ * grants ITS OWN capacity. Rejecting it would mark the whole list malformed, which keeps every gift the
+ * widget added — unlimited capacity, a strictly worse degradation than the one avoided.
+ */
+export declare const SgwpMilestoneSchema: z.ZodObject<{
+    selectable_product_quantity: z.ZodPipe<z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number>>, z.ZodNumber>;
+    unlock_price: z.ZodPipe<z.ZodUnion<readonly [z.ZodNumber, z.ZodString]>, z.ZodCoercedNumber<string | number>>;
+}, z.core.$strip>;
+/** One parsed selectable-GWP milestone: the shop-major-unit unlock price and the gift units it grants. */
+export type SgwpMilestone = z.infer<typeof SgwpMilestoneSchema>;
+/**
+ * One gift widget's raw settings from the engine (the `data` envelope unwrapped, so a deleted widget's
+ * `{ data: null }` reads as `null`). Throws on an upstream failure — every caller fails safe (keeps the
+ * widget's gifts), so the throw is the signal, not a bug.
+ */
+export declare const fetchGiftWidgetSettings: (widgetId: number, shop: string, ctx: ServerContext) => Promise<unknown>;
+/** A GWP widget's data-source path from its raw settings `endpoint` (uniform across widget types). */
+export declare const readDataSourcePath: (settings: unknown) => string | undefined;
+/**
+ * A selectable-GWP widget's milestones from its raw settings. Absent or empty milestones are an empty list
+ * (the widget has nothing to judge against — silent). A MALFORMED list also reads as empty, because the
+ * fail-safe direction is to keep the gifts, but that is a settings-contract drift, so it is reported — with
+ * the first issue's path AND message, since the likeliest real drift (`milestones` is an object, not an
+ * array) fails at the top level, where the path is empty and only the message says what arrived.
+ */
+export declare const readMilestones: (settings: unknown, report?: Reporter) => SgwpMilestone[];
+/** The gifts of one `kind`, grouped by widget in request order (insertion-ordered map; lines keep their order within a widget). */
+export declare const groupGiftsByWidget: (gifts: GiftInput[], kind: GiftKind) => Map<number, GiftInput[]>;