@reactionary/commercetools 0.10.52 → 0.10.54

package/capabilities/checkout.capability.js

@@ -9,6 +9,12 @@ var __decorateClass = (decorators, target, key, kind) => {
   return result;
 };
 import { PROTOCOL_DATA_FIELD, serializeProtocolData } from "../core/payment-protocol-data.js";
+import {
+  PICKUP_STORE_FIELD,
+  SHIPPING_PROTOCOL_DATA_FIELD,
+  serializeShippingProtocolData
+} from "../core/shipping-protocol-data.js";
+import { resolveShippingFulfillmentType } from "../core/shipping-fulfillment.js";
 import {
   CheckoutMutationAddPaymentInstructionSchema,
   CheckoutMutationFinalizeCheckoutSchema,
@@ -174,10 +180,25 @@ class CommercetoolsCheckoutCapability extends CheckoutCapability {
       client.carts.withId({ ID: payload.checkout.key }).get().execute()
     ]);
     const result = shippingMethodsResponse.body.results.map(
-      (shippingMethod) => this.factory.parseShippingMethod(this.context, this.withFreeShipping(shippingMethod, cartResponse.body))
+      (shippingMethod) => this.withFulfillmentType(
+        this.factory.parseShippingMethod(this.context, this.withFreeShipping(shippingMethod, cartResponse.body)),
+        shippingMethod
+      )
     );
     return success(result);
   }
+  /**
+   * Tags a parsed shipping method with its fulfillment type: methods whose
+   * key is listed in the `bopis.shippingMethodKeys` configuration are
+   * in-store pickup (BOPIS), everything else is a delivery. The tagging lives
+   * here rather than in the factory, so factories stay configuration-free.
+   */
+  withFulfillmentType(shippingMethod, remote) {
+    return {
+      ...shippingMethod,
+      fulfillmentType: resolveShippingFulfillmentType(remote, this.config.bopis?.shippingMethodKeys)
+    };
+  }
   /**
    * Quotes the matching shipping rates as free where the cart reaches the
    * rate's free-above threshold. commercetools' matching-cart query returns
@@ -289,6 +310,20 @@ class CommercetoolsCheckoutCapability extends CheckoutCapability {
       name: "pickupPointId",
       value: payload.shippingInstruction.pickupPoint
     });
+    if (payload.shippingInstruction.store?.key) {
+      actions.push({
+        action: "setCustomField",
+        name: PICKUP_STORE_FIELD,
+        value: payload.shippingInstruction.store.key
+      });
+    }
+    if (payload.shippingInstruction.protocolData && payload.shippingInstruction.protocolData.length > 0) {
+      actions.push({
+        action: "setCustomField",
+        name: SHIPPING_PROTOCOL_DATA_FIELD,
+        value: serializeShippingProtocolData(payload.shippingInstruction.protocolData)
+      });
+    }
     const result = await this.applyActions(
       payload.checkout,
       actions

package/capabilities/store.capability.js

@@ -8,7 +8,17 @@ var __decorateClass = (decorators, target, key, kind) => {
   if (kind && result) __defProp(target, key, result);
   return result;
 };
-import { Reactionary, StoreCapability, StoreQueryByProximitySchema, StoreSchema, success, error } from "@reactionary/core";
+import {
+  Reactionary,
+  StoreCapability,
+  StorePaginatedResultSchema,
+  StoreQueryByIdSchema,
+  StoreQueryByProximitySchema,
+  StoreQueryForListSchema,
+  StoreSchema,
+  success,
+  error
+} from "@reactionary/core";
 import * as z from "zod";
 class CommercetoolsStoreCapability extends StoreCapability {
   config;
@@ -38,6 +48,48 @@ class CommercetoolsStoreCapability extends StoreCapability {
     }
     return success(results);
   }
+  /**
+   * The channel predicate selecting the channels that represent the brand's
+   * own stores. Override in a subclass if a project models stores differently.
+   */
+  getStoreChannelPredicate() {
+    return 'roles contains any ("InventorySupply")';
+  }
+  async list(payload) {
+    const client = await this.getClient();
+    const { pageNumber, pageSize } = payload.paginationOptions;
+    const remote = await client.channels().get({
+      queryArgs: {
+        limit: pageSize,
+        offset: (pageNumber - 1) * pageSize,
+        withTotal: true,
+        where: this.getStoreChannelPredicate()
+      }
+    }).execute();
+    const totalCount = remote.body.total ?? remote.body.results.length;
+    return success({
+      pageNumber,
+      pageSize,
+      totalCount,
+      totalPages: Math.ceil(totalCount / pageSize),
+      items: remote.body.results.map((r) => this.factory.parseStore(this.context, r))
+    });
+  }
+  async getById(payload) {
+    const client = await this.getClient();
+    const remote = await client.channels().get({
+      queryArgs: {
+        limit: 1,
+        where: `key = :key AND ${this.getStoreChannelPredicate()}`,
+        "var.key": payload.identifier.key
+      }
+    }).execute();
+    const channel = remote.body.results[0];
+    if (!channel) {
+      return error({ type: "NotFound", identifier: payload.identifier });
+    }
+    return success(this.factory.parseStore(this.context, channel));
+  }
 }
 __decorateClass([
   Reactionary({
@@ -45,6 +97,18 @@ __decorateClass([
     outputSchema: z.array(StoreSchema)
   })
 ], CommercetoolsStoreCapability.prototype, "queryByProximity", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryForListSchema,
+    outputSchema: StorePaginatedResultSchema
+  })
+], CommercetoolsStoreCapability.prototype, "list", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: StoreQueryByIdSchema,
+    outputSchema: StoreSchema
+  })
+], CommercetoolsStoreCapability.prototype, "getById", 1);
 export {
   CommercetoolsStoreCapability
 };

package/core/shipping-fulfillment.js

@@ -0,0 +1,6 @@
+function resolveShippingFulfillmentType(shippingMethod, bopisShippingMethodKeys) {
+  return shippingMethod.key && (bopisShippingMethodKeys || []).includes(shippingMethod.key) ? "pickup" : "delivery";
+}
+export {
+  resolveShippingFulfillmentType
+};

package/core/shipping-protocol-data.js

@@ -0,0 +1,33 @@
+const SHIPPING_PROTOCOL_DATA_FIELD = "shippingProtocolData";
+const PICKUP_STORE_FIELD = "pickupStoreKey";
+function serializeShippingProtocolData(entries) {
+  return JSON.stringify(Object.fromEntries(entries.map((entry) => [entry.key, entry.value])));
+}
+function parseShippingProtocolDataField(value) {
+  if (typeof value !== "string" || value.length === 0) {
+    return void 0;
+  }
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+      return void 0;
+    }
+    const entries = [];
+    for (const [key, entry] of Object.entries(parsed)) {
+      if (typeof entry === "string") {
+        entries.push({ key, value: entry });
+      } else if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+        entries.push({ key, value: entry });
+      }
+    }
+    return entries.length > 0 ? entries : void 0;
+  } catch {
+    return void 0;
+  }
+}
+export {
+  PICKUP_STORE_FIELD,
+  SHIPPING_PROTOCOL_DATA_FIELD,
+  parseShippingProtocolDataField,
+  serializeShippingProtocolData
+};

package/factories/checkout/checkout.factory.js

@@ -3,6 +3,11 @@ import {
   CheckoutItemSchema
 } from "@reactionary/core";
 import { getLanguageCodeFromLocale } from "../../core/locale-utils.js";
+import {
+  PICKUP_STORE_FIELD,
+  SHIPPING_PROTOCOL_DATA_FIELD,
+  parseShippingProtocolDataField
+} from "../../core/shipping-protocol-data.js";
 class CommercetoolsCheckoutFactory {
   checkoutSchema;
   shippingMethodSchema;
@@ -221,13 +226,20 @@ class CommercetoolsCheckoutFactory {
     const instructions = data.custom?.fields["shippingInstruction"] || "";
     const consentForUnattendedDelivery = data.custom?.fields["consentForUnattendedDelivery"] === "true";
     const pickupPoint = data.custom?.fields["pickupPointId"] || "";
+    const pickupStoreKey = data.custom?.fields[PICKUP_STORE_FIELD];
+    const store = typeof pickupStoreKey === "string" && pickupStoreKey.length > 0 ? { key: pickupStoreKey } : void 0;
+    const protocolData = parseShippingProtocolDataField(
+      data.custom?.fields[SHIPPING_PROTOCOL_DATA_FIELD]
+    );
     const result = {
       shippingMethod: {
         key: data.shippingInfo.shippingMethod?.obj?.key || ""
       },
       pickupPoint,
       instructions,
-      consentForUnattendedDelivery
+      consentForUnattendedDelivery,
+      store,
+      protocolData
     };
     return result;
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/commercetools",
-  "version": "0.10.52",
+  "version": "0.10.54",
   "type": "module",
   "main": "./index.js",
   "types": "./src/index.d.ts",
@@ -9,7 +9,7 @@
     "url": "git+https://github.com/Solteq/reactionary.git"
   },
   "dependencies": {
-    "@reactionary/core": "0.10.52",
+    "@reactionary/core": "0.10.54",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.9.1",
     "@commercetools/platform-sdk": "^8.25.0",

package/schema/configuration.schema.js

@@ -12,7 +12,10 @@ const CommercetoolsConfigurationSchema = z.looseObject({
   paymentMethods: PaymentMethodSchema.array().optional().default(() => []),
   facetFieldsForSearch: z.array(z.string()).default(() => []),
   listPriceChannelKey: z.string().optional(),
-  customerPriceChannelKey: z.string().optional()
+  customerPriceChannelKey: z.string().optional(),
+  bopis: z.looseObject({
+    shippingMethodKeys: z.array(z.string()).default(() => []).meta({ description: 'The keys of the commercetools shipping methods that represent in-store pickup (BOPIS). Shipping methods with these keys are tagged with fulfillmentType "pickup"; all others are tagged "delivery".' })
+  }).optional().meta({ description: "Optional buy-online-pickup-in-store (BOPIS) configuration." })
 });
 export {
   CommercetoolsConfigurationSchema

package/src/capabilities/checkout.capability.d.ts

@@ -23,6 +23,13 @@ export declare class CommercetoolsCheckoutCapability<TFactory extends CheckoutFa
     getById(payload: CheckoutQueryById): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>, NotFoundError>>;
     setShippingAddress(payload: CheckoutMutationSetShippingAddress): Promise<Result<CheckoutFactoryCheckoutOutput<TFactory>>>;
     getAvailableShippingMethods(payload: CheckoutQueryForAvailableShippingMethods): Promise<Result<CheckoutFactoryShippingMethodOutput<TFactory>[]>>;
+    /**
+     * Tags a parsed shipping method with its fulfillment type: methods whose
+     * key is listed in the `bopis.shippingMethodKeys` configuration are
+     * in-store pickup (BOPIS), everything else is a delivery. The tagging lives
+     * here rather than in the factory, so factories stay configuration-free.
+     */
+    protected withFulfillmentType(shippingMethod: CheckoutFactoryShippingMethodOutput<TFactory>, remote: CTShippingMethod): CheckoutFactoryShippingMethodOutput<TFactory>;
     /**
      * Quotes the matching shipping rates as free where the cart reaches the
      * rate's free-above threshold. commercetools' matching-cart query returns

package/src/capabilities/store.capability.d.ts

@@ -1,4 +1,4 @@
-import type { RequestContext, Cache, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StoreQueryByProximity, Result } from '@reactionary/core';
+import type { RequestContext, Cache, NotFoundError, StoreFactory, StoreFactoryOutput, StoreFactoryWithOutput, StorePaginatedResult, StoreQueryById, StoreQueryByProximity, StoreQueryForList, Result } from '@reactionary/core';
 import { StoreCapability } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type { CommercetoolsAPI } from '../core/client.js';
@@ -10,4 +10,11 @@ export declare class CommercetoolsStoreCapability<TFactory extends StoreFactory
     constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI, factory: StoreFactoryWithOutput<TFactory>);
     protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
     queryByProximity(payload: StoreQueryByProximity): Promise<Result<Array<StoreFactoryOutput<TFactory>>>>;
+    /**
+     * The channel predicate selecting the channels that represent the brand's
+     * own stores. Override in a subclass if a project models stores differently.
+     */
+    protected getStoreChannelPredicate(): string;
+    list(payload: StoreQueryForList): Promise<Result<StorePaginatedResult>>;
+    getById(payload: StoreQueryById): Promise<Result<StoreFactoryOutput<TFactory>, NotFoundError>>;
 }

package/src/core/shipping-fulfillment.d.ts

@@ -0,0 +1,8 @@
+import type { ShippingMethod as CTShippingMethod } from '@commercetools/platform-sdk';
+import type { ShippingFulfillmentType } from '@reactionary/core';
+/**
+ * Resolves the core fulfillment type of a commercetools shipping method from
+ * the `bopis.shippingMethodKeys` configuration: shipping methods whose key is
+ * listed are in-store pickup (BOPIS), everything else is a delivery.
+ */
+export declare function resolveShippingFulfillmentType(shippingMethod: CTShippingMethod, bopisShippingMethodKeys: string[] | undefined): ShippingFulfillmentType;

package/src/core/shipping-protocol-data.d.ts

@@ -0,0 +1,16 @@
+import type { ShippingProtocolData } from '@reactionary/core';
+/**
+ * The cart custom field carrying the shipping instruction's protocol data,
+ * following the same one-declared-JSON-field mechanism as the payment
+ * protocol data (see payment-protocol-data.ts): commercetools rejects
+ * undeclared custom fields, so one declared field carries arbitrary keys.
+ */
+export declare const SHIPPING_PROTOCOL_DATA_FIELD = "shippingProtocolData";
+/**
+ * The cart custom field carrying the key of the brand's own store selected
+ * for in-store pickup (BOPIS). Distinct from `pickupPointId`, which is
+ * reserved for third-party carrier service points.
+ */
+export declare const PICKUP_STORE_FIELD = "pickupStoreKey";
+export declare function serializeShippingProtocolData(entries: ShippingProtocolData[]): string;
+export declare function parseShippingProtocolDataField(value: unknown): ShippingProtocolData[] | undefined;

package/src/schema/configuration.schema.d.ts

@@ -26,5 +26,8 @@ export declare const CommercetoolsConfigurationSchema: z.ZodObject<{
     facetFieldsForSearch: z.ZodDefault<z.ZodArray<z.ZodString>>;
     listPriceChannelKey: z.ZodOptional<z.ZodString>;
     customerPriceChannelKey: z.ZodOptional<z.ZodString>;
+    bopis: z.ZodOptional<z.ZodObject<{
+        shippingMethodKeys: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    }, z.core.$loose>>;
 }, z.core.$loose>;
 export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;