@reactionary/provider-commercetools 0.0.42 → 0.0.51

package/README.md

@@ -11,6 +11,14 @@ Run `nx build provider-commercetools` to build the library.
 Run `nx test provider-commercetools` to execute the unit tests via [Jest](https://jestjs.io).
 
 
+# ASSUMPTIONS for backend config
+
+- You will have 2 different channels for prices, one called `Offer Price` and one called `List Price`
+- ProductVariants will all have unique SKU values.
+- Your Supply Channels double as Store Locations
+
+
+
 ## TODO List
 
 ### Core
@@ -25,3 +33,6 @@ Run `nx test provider-commercetools` to execute the unit tests via [Jest](https:
 ### Inventory
 - [ ] Be traced and cached
 
+
+
+

package/core/client.js

@@ -1,99 +1,149 @@
-import { ClientBuilder } from "@commercetools/ts-client";
+import {
+  ClientBuilder
+} from "@commercetools/ts-client";
 import { createApiBuilderFromCtpClient } from "@commercetools/platform-sdk";
 import { randomUUID } from "crypto";
-class CommercetoolsClient {
-  constructor(config) {
-    this.config = config;
-  }
-  getClient(token) {
-    if (token) {
-      return this.createClientWithToken(token);
-    }
-    return this.createAnonymousClient();
+import {
+  AnonymousIdentitySchema,
+  GuestIdentitySchema,
+  RegisteredIdentitySchema
+} from "@reactionary/core";
+import * as crypto from "crypto";
+import createDebug from "debug";
+const debug = createDebug("commercetools:debug");
+class RequestContextTokenCache {
+  constructor(context) {
+    this.context = context;
   }
-  async login(username, password) {
-    const queryParams = new URLSearchParams({
-      grant_type: "password",
-      username,
-      password
-    });
-    const url = `${this.config.authUrl}/oauth/${this.config.projectKey}/customers/token?${queryParams.toString()}`;
-    const headers = {
-      Authorization: "Basic " + btoa(this.config.clientId + ":" + this.config.clientSecret)
+  async get(tokenCacheOptions) {
+    const identity = this.context.identity;
+    return {
+      refreshToken: identity.refresh_token,
+      token: identity.token || "",
+      expirationTime: identity.expiry.getTime()
     };
-    const remote = await fetch(url, { method: "POST", headers });
-    const json = await remote.json();
-    return json;
   }
-  async guest() {
-    const queryParams = new URLSearchParams({
-      grant_type: "client_credentials"
-    });
-    const url = `${this.config.authUrl}/oauth/${this.config.projectKey}/anonymous/token?${queryParams.toString()}`;
-    const headers = {
-      Authorization: "Basic " + btoa(this.config.clientId + ":" + this.config.clientSecret)
-    };
-    const remote = await fetch(url, { method: "POST", headers });
-    const json = await remote.json();
-    return json;
+  async set(cache, tokenCacheOptions) {
+    const identity = this.context.identity;
+    identity.refresh_token = cache.refreshToken;
+    identity.token = cache.token;
+    identity.expiry = new Date(cache.expirationTime);
   }
-  async logout(token) {
-    const queryParams = new URLSearchParams({
-      token,
-      token_type_hint: "access_token"
-    });
-    const url = `${this.config.authUrl}/oauth/token/revoke?${queryParams.toString()}`;
-    const headers = {
-      Authorization: "Basic " + btoa(this.config.clientId + ":" + this.config.clientSecret)
-    };
-    const remote = await fetch(url, { method: "POST", headers });
-    return remote;
+}
+class CommercetoolsClient {
+  constructor(config) {
+    this.config = config;
   }
-  async introspect(token) {
-    const queryParams = new URLSearchParams({
-      token
-    });
-    const url = `${this.config.authUrl}/oauth/introspect?` + queryParams;
-    const headers = {
-      Authorization: "Basic " + btoa(this.config.clientId + ":" + this.config.clientSecret)
-    };
-    const remote = await fetch(url, { method: "POST", headers });
-    const json = await remote.json();
-    return json;
+  async getClient(reqCtx) {
+    return this.createClient(reqCtx);
   }
-  createAnonymousClient() {
-    const scopes = this.config.scopes;
-    const builder = this.createBaseClientBuilder().withClientCredentialsFlow({
+  async register(username, password, reqCtx) {
+    const registrationBuilder = this.createBaseClientBuilder().withAnonymousSessionFlow({
       host: this.config.authUrl,
       projectKey: this.config.projectKey,
       credentials: {
         clientId: this.config.clientId,
         clientSecret: this.config.clientSecret
       },
-      scopes: [...scopes]
+      scopes: this.config.scopes
     });
-    return createApiBuilderFromCtpClient(builder.build());
-  }
-  createClientWithToken(token) {
-    const builder = this.createBaseClientBuilder().withExistingTokenFlow(
-      `Bearer ${token}`,
-      { force: true }
+    const registrationClient = createApiBuilderFromCtpClient(
+      registrationBuilder.build()
     );
+    const registration = await registrationClient.withProjectKey({ projectKey: this.config.projectKey }).me().signup().post({
+      body: {
+        email: username,
+        password
+      }
+    }).execute();
+    const login = await this.login(username, password, reqCtx);
+    return login;
+  }
+  async login(username, password, reqCtx) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    const loginBuilder = this.createBaseClientBuilder().withPasswordFlow({
+      host: this.config.authUrl,
+      projectKey: this.config.projectKey,
+      credentials: {
+        clientId: this.config.clientId,
+        clientSecret: this.config.clientSecret,
+        user: { username, password }
+      },
+      tokenCache: cache,
+      scopes: this.config.scopes
+    });
+    const loginClient = createApiBuilderFromCtpClient(loginBuilder.build());
+    const login = await loginClient.withProjectKey({ projectKey: this.config.projectKey }).me().login().post({
+      body: {
+        email: username,
+        password
+      }
+    }).execute();
+    reqCtx.identity = RegisteredIdentitySchema.parse({
+      ...reqCtx.identity,
+      type: "Registered",
+      logonId: username,
+      id: {
+        userId: login.body.customer.id
+      }
+    });
+    return reqCtx.identity;
+  }
+  async logout(reqCtx) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    await cache.set({ token: "", refreshToken: "", expirationTime: 0 });
+    reqCtx.identity = AnonymousIdentitySchema.parse({});
+    return reqCtx.identity;
+  }
+  createClient(reqCtx) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    if (reqCtx.identity.type === "Anonymous") {
+      reqCtx.identity = GuestIdentitySchema.parse({
+        id: {
+          userId: crypto.randomUUID().toString()
+        },
+        type: "Guest"
+      });
+    }
+    const identity = reqCtx.identity;
+    let builder = this.createBaseClientBuilder(reqCtx);
+    if (!identity.token || !identity.refresh_token) {
+      builder = builder.withAnonymousSessionFlow({
+        host: this.config.authUrl,
+        projectKey: this.config.projectKey,
+        credentials: {
+          clientId: this.config.clientId,
+          clientSecret: this.config.clientSecret,
+          anonymousId: identity.id.userId
+        },
+        tokenCache: cache
+      });
+    } else {
+      builder = builder.withRefreshTokenFlow({
+        credentials: {
+          clientId: this.config.clientId,
+          clientSecret: this.config.clientSecret
+        },
+        host: this.config.authUrl,
+        projectKey: this.config.projectKey,
+        refreshToken: identity.refresh_token || "",
+        tokenCache: cache
+      });
+    }
     return createApiBuilderFromCtpClient(builder.build());
   }
-  createBaseClientBuilder() {
-    const builder = new ClientBuilder().withProjectKey(this.config.projectKey).withQueueMiddleware({
+  createBaseClientBuilder(reqCtx) {
+    let builder = new ClientBuilder().withProjectKey(this.config.projectKey).withQueueMiddleware({
       concurrency: 20
     }).withConcurrentModificationMiddleware({
       concurrentModificationHandlerFn: (version, request) => {
-        console.log(`Concurrent modification error, retry with version ${version}`);
+        console.log(
+          `Concurrent modification error, retry with version ${version}`
+        );
         const body = request.body;
         body["version"] = version;
         return Promise.resolve(body);
       }
-    }).withCorrelationIdMiddleware({
-      // ideally this would be pushed in as part of the session context, so we can trace it end-to-end
-      generate: () => `REACTIONARY-${randomUUID()}`
     }).withHttpMiddleware({
       retryConfig: {
         backoff: true,
@@ -109,9 +159,17 @@ class CommercetoolsClient {
       host: this.config.apiUrl,
       httpClient: fetch
     });
+    const correlationId = reqCtx?.correlationId || "REACTIONARY-" + (typeof crypto !== "undefined" && "randomUUID" in crypto ? crypto.randomUUID() : randomUUID());
+    builder = builder.withCorrelationIdMiddleware({
+      generate: () => correlationId
+    });
+    if (debug.enabled) {
+      builder = builder.withLoggerMiddleware();
+    }
     return builder;
   }
 }
 export {
-  CommercetoolsClient
+  CommercetoolsClient,
+  RequestContextTokenCache
 };

package/core/initialize.js

@@ -6,7 +6,7 @@ import {
   ProductSchema,
   SearchResultSchema,
   CategorySchema,
-  CartPaymentInstructionSchema
+  CheckoutSchema
 } from "@reactionary/core";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
 import { CommercetoolsProductProvider } from "../providers/product.provider";
@@ -15,7 +15,7 @@ import { CommercetoolsCartProvider } from "../providers/cart.provider";
 import { CommercetoolsInventoryProvider } from "../providers/inventory.provider";
 import { CommercetoolsPriceProvider } from "../providers/price.provider";
 import { CommercetoolsCategoryProvider } from "../providers/category.provider";
-import { CommercetoolsCartPaymentProvider } from "../providers/cart-payment.provider";
+import { CommercetoolsCheckoutProvider } from "../providers";
 function withCommercetoolsCapabilities(configuration, capabilities) {
   return (cache) => {
     const client = {};
@@ -40,8 +40,8 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
     if (capabilities.category) {
       client.category = new CommercetoolsCategoryProvider(configuration, CategorySchema, cache);
     }
-    if (capabilities.cartPayment) {
-      client.cartPayment = new CommercetoolsCartPaymentProvider(configuration, CartPaymentInstructionSchema, cache);
+    if (capabilities.checkout) {
+      client.checkout = new CommercetoolsCheckoutProvider(configuration, CheckoutSchema, cache);
     }
     return client;
   };

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@reactionary/provider-commercetools",
-  "version": "0.0.42",
+  "version": "0.0.51",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.0.42",
-    "@reactionary/otel": "0.0.42",
+    "@reactionary/core": "0.0.51",
+    "@reactionary/otel": "0.0.51",
+    "debug": "^4.4.3",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.2.1",
     "@commercetools/platform-sdk": "^8.8.0"

package/providers/cart.provider.js

@@ -24,21 +24,21 @@ class CommercetoolsCartProvider extends CartProvider {
     super(schema, cache);
     this.config = config;
   }
-  async getById(payload, session) {
+  async getById(payload, reqCtx) {
     try {
-      const client = this.getClient(session);
+      const client = await this.getClient(reqCtx);
       const ctId = payload.cart;
-      const remote = await client.withId({ ID: ctId.key }).get().execute();
-      return this.parseSingle(remote.body, session);
+      const remote = await client.carts.withId({ ID: ctId.key }).get().execute();
+      return this.parseSingle(remote.body, reqCtx);
     } catch (e) {
       return this.createEmptyCart();
     }
   }
-  async add(payload, session) {
-    const client = this.getClient(session);
+  async add(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
     let cartIdentifier = payload.cart;
     if (!cartIdentifier.key) {
-      cartIdentifier = await this.createCart(session);
+      cartIdentifier = await this.createCart(reqCtx);
     }
     return this.applyActions(
       cartIdentifier,
@@ -52,10 +52,10 @@ class CommercetoolsCartProvider extends CartProvider {
           action: "recalculate"
         }
       ],
-      session
+      reqCtx
     );
   }
-  async remove(payload, session) {
+  async remove(payload, reqCtx) {
     return this.applyActions(
       payload.cart,
       [
@@ -67,12 +67,12 @@ class CommercetoolsCartProvider extends CartProvider {
           action: "recalculate"
         }
       ],
-      session
+      reqCtx
     );
   }
-  async changeQuantity(payload, session) {
+  async changeQuantity(payload, reqCtx) {
     if (payload.quantity === 0) {
-      return this.getById({ cart: payload.cart }, session);
+      return this.getById({ cart: payload.cart }, reqCtx);
     }
     return this.applyActions(
       payload.cart,
@@ -86,19 +86,13 @@ class CommercetoolsCartProvider extends CartProvider {
           action: "recalculate"
         }
       ],
-      session
+      reqCtx
     );
   }
-  async getActiveCartId(session) {
-    const client = this.getClient(session);
+  async getActiveCartId(reqCtx) {
+    const client = await this.getClient(reqCtx);
     try {
-      const carts = await client.withCustomerId({ customerId: session.id }).get({
-        queryArgs: {
-          limit: 1,
-          sort: "lastModifiedAt desc",
-          where: 'cartState="Active"'
-        }
-      }).execute();
+      const carts = await client.activeCart.get().execute();
       return CommercetoolsCartIdentifierSchema.parse({
         key: carts.body.id,
         version: carts.body.version || 0
@@ -110,22 +104,22 @@ class CommercetoolsCartProvider extends CartProvider {
       });
     }
   }
-  async deleteCart(payload, session) {
-    const client = this.getClient(session);
+  async deleteCart(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
     if (payload.cart.key) {
       const ctId = payload.cart;
-      await client.withId({ ID: ctId.key }).delete({
+      await client.carts.withId({ ID: ctId.key }).delete({
         queryArgs: {
           version: ctId.version,
           dataErasure: false
         }
       }).execute();
     }
-    const activeCartId = await this.getActiveCartId(session);
-    return this.getById({ cart: activeCartId }, session);
+    const activeCartId = await this.getActiveCartId(reqCtx);
+    return this.getById({ cart: activeCartId }, reqCtx);
   }
-  setShippingInfo(payload, session) {
-    const client = this.getClient(session);
+  async setShippingInfo(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
     const ctId = payload.cart;
     const actions = new Array();
     if (payload.shippingMethod) {
@@ -141,7 +135,7 @@ class CommercetoolsCartProvider extends CartProvider {
       actions.push({
         action: "setShippingAddress",
         address: {
-          country: payload.shippingAddress.countryCode || "US",
+          country: payload.shippingAddress.countryCode || reqCtx.taxJurisdiction.countryCode || "US",
           firstName: payload.shippingAddress.firstName,
           lastName: payload.shippingAddress.lastName,
           city: payload.shippingAddress.city,
@@ -151,9 +145,9 @@ class CommercetoolsCartProvider extends CartProvider {
         }
       });
     }
-    return this.applyActions(payload.cart, actions, session);
+    return this.applyActions(payload.cart, actions, reqCtx);
   }
-  setBillingAddress(payload, session) {
+  setBillingAddress(payload, reqCtx) {
     return this.applyActions(
       payload.cart,
       [
@@ -162,7 +156,7 @@ class CommercetoolsCartProvider extends CartProvider {
           address: {
             email: payload.notificationEmailAddress,
             mobile: payload.notificationPhoneNumber,
-            country: payload.billingAddress.countryCode || "US",
+            country: payload.billingAddress.countryCode || reqCtx.taxJurisdiction.countryCode || "US",
             firstName: payload.billingAddress.firstName,
             lastName: payload.billingAddress.lastName,
             city: payload.billingAddress.city,
@@ -177,13 +171,13 @@ class CommercetoolsCartProvider extends CartProvider {
         },
         {
           action: "setCountry",
-          country: payload.billingAddress.countryCode || "US"
+          country: payload.billingAddress.countryCode || reqCtx.taxJurisdiction.countryCode || "US"
         }
       ],
-      session
+      reqCtx
     );
   }
-  applyCouponCode(payload, session) {
+  applyCouponCode(payload, reqCtx) {
     return this.applyActions(
       payload.cart,
       [
@@ -195,10 +189,10 @@ class CommercetoolsCartProvider extends CartProvider {
           action: "recalculate"
         }
       ],
-      session
+      reqCtx
     );
   }
-  removeCouponCode(payload, session) {
+  removeCouponCode(payload, reqCtx) {
     return this.applyActions(
       payload.cart,
       [
@@ -213,19 +207,16 @@ class CommercetoolsCartProvider extends CartProvider {
           action: "recalculate"
         }
       ],
-      session
+      reqCtx
     );
   }
-  async checkout(payload, session) {
-    const client = this.getOrderClient(session);
+  async checkout(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
     const ctId = payload.cart;
-    const orderResponse = await client.post({
+    const orderResponse = await client.orders.post({
       body: {
         version: ctId.version,
-        cart: {
-          typeId: "cart",
-          id: ctId.key
-        }
+        id: ctId.key
       }
     }).execute();
     return CommercetoolsOrderIdentifierSchema.parse({
@@ -233,14 +224,13 @@ class CommercetoolsCartProvider extends CartProvider {
       version: orderResponse.body.version || 0
     });
   }
-  async changeCurrency(payload, session) {
-    const client = this.getClient(session);
-    const currentCart = await client.withId({ ID: payload.cart.key }).get().execute();
-    const newCart = await client.post({
+  async changeCurrency(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const currentCart = await client.carts.withId({ ID: payload.cart.key }).get().execute();
+    const newCart = await client.carts.post({
       body: {
         currency: payload.newCurrency,
-        country: session.languageContext.countryCode || "US",
-        locale: session.languageContext.locale
+        locale: reqCtx.languageContext.locale
       }
     }).execute();
     const newCartId = CommercetoolsCartIdentifierSchema.parse({
@@ -262,9 +252,9 @@ class CommercetoolsCartProvider extends CartProvider {
           action: "recalculate"
         }
       ],
-      session
+      reqCtx
     );
-    await client.withId({ ID: payload.cart.key }).delete({
+    await client.carts.withId({ ID: payload.cart.key }).delete({
       queryArgs: {
         version: currentCart.body.version || 0,
         dataErasure: false
@@ -272,13 +262,13 @@ class CommercetoolsCartProvider extends CartProvider {
     }).execute();
     return response;
   }
-  async createCart(session) {
-    const client = this.getClient(session);
-    const response = await client.post({
+  async createCart(reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const response = await client.carts.post({
       body: {
-        currency: session.languageContext.currencyCode || "USD",
-        country: session.languageContext.countryCode || "US",
-        locale: session.languageContext.locale
+        currency: reqCtx.languageContext.currencyCode || "USD",
+        country: reqCtx.taxJurisdiction.countryCode || "US",
+        locale: reqCtx.languageContext.locale
       }
     }).execute();
     return CommercetoolsCartIdentifierSchema.parse({
@@ -286,42 +276,35 @@ class CommercetoolsCartProvider extends CartProvider {
       version: response.body.version || 0
     });
   }
-  async applyActions(cart, actions, session) {
-    const client = this.getClient(session);
+  async applyActions(cart, actions, reqCtx) {
+    const client = await this.getClient(reqCtx);
     const ctId = cart;
-    const response = await client.withId({ ID: ctId.key }).post({
-      body: {
-        version: ctId.version,
-        actions
+    try {
+      const response = await client.carts.withId({ ID: ctId.key }).post({
+        body: {
+          version: ctId.version,
+          actions
+        }
+      }).execute();
+      if (response.error) {
+        console.error(response.error);
       }
-    }).execute();
-    return this.parseSingle(response.body, session);
-  }
-  getClient(session) {
-    const token = session.identity.keyring.find(
-      (x) => x.service === "commercetools"
-    )?.token;
-    const client = new CommercetoolsClient(this.config).getClient(token);
-    const cartClient = client.withProjectKey({ projectKey: this.config.projectKey }).carts();
-    return cartClient;
-  }
-  getOrderClient(session) {
-    const token = session.identity.keyring.find(
-      (x) => x.service === "commercetools"
-    )?.token;
-    const client = new CommercetoolsClient(this.config).getClient(token);
-    const orderClient = client.withProjectKey({ projectKey: this.config.projectKey }).orders();
-    return orderClient;
+      return this.parseSingle(response.body, reqCtx);
+    } catch (e) {
+      console.error("Error applying actions to cart:", e);
+      throw e;
+    }
   }
-  getPaymentClient(session) {
-    const token = session.identity.keyring.find(
-      (x) => x.service === "commercetools"
-    )?.token;
-    const client = new CommercetoolsClient(this.config).getClient(token);
-    const paymentClient = client.withProjectKey({ projectKey: this.config.projectKey }).payments();
-    return paymentClient;
+  async getClient(reqCtx) {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+    const clientWithProject = client.withProjectKey({ projectKey: this.config.projectKey });
+    return {
+      carts: clientWithProject.me().carts(),
+      activeCart: clientWithProject.me().activeCart(),
+      orders: clientWithProject.me().orders()
+    };
   }
-  parseSingle(remote, session) {
+  parseSingle(remote, reqCtx) {
     const result = this.newModel();
     result.identifier = CommercetoolsCartIdentifierSchema.parse({
       key: remote.id,
@@ -395,7 +378,7 @@ class CommercetoolsCartProvider extends CartProvider {
     result.meta = {
       cache: {
         hit: false,
-        key: this.generateCacheKeySingle(result.identifier, session)
+        key: this.generateCacheKeySingle(result.identifier, reqCtx)
       },
       placeholder: false
     };
@@ -441,9 +424,6 @@ __decorateClass([
 __decorateClass([
   traced()
 ], CommercetoolsCartProvider.prototype, "getClient", 1);
-__decorateClass([
-  traced()
-], CommercetoolsCartProvider.prototype, "getPaymentClient", 1);
 export {
   CommercetoolsCartProvider
 };