@reactionary/provider-commercetools 0.0.41 → 0.0.48

package/README.md

@@ -9,3 +9,30 @@ Run `nx build provider-commercetools` to build the library.
 ## Running unit tests
 
 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
+- [ ] Figure out if we are actually running as anonymous user towards CT. It feels weird right now.
+
+### Price
+- [ ] PriceProvider should be able to use both embedded and standalone prices? Possible by querying through product-projection maybe?
+- [ ] If not, using product-projection, the logic in https://docs.commercetools.com/api/pricing-and-discounts-overview#price-selection should be replicated
+- [ ] add list price by convention. Like key: LP-<sku> or something.
+
+
+### Inventory
+- [ ] Be traced and cached
+
+
+
+

package/core/client.js

@@ -1,120 +1,141 @@
-import { ClientBuilder } from "@commercetools/ts-client";
+import {
+  ClientBuilder
+} from "@commercetools/ts-client";
 import { createApiBuilderFromCtpClient } from "@commercetools/platform-sdk";
-const ANONYMOUS_SCOPES = [
-  "view_published_products",
-  "manage_shopping_lists",
-  "view_shipping_methods",
-  "manage_customers",
-  "view_product_selections",
-  "view_categories",
-  "view_project_settings",
-  "manage_order_edits",
-  "view_sessions",
-  "view_standalone_prices",
-  "manage_orders",
-  "view_tax_categories",
-  "view_cart_discounts",
-  "view_discount_codes",
-  "create_anonymous_token",
-  "manage_sessions",
-  "view_products",
-  "view_types"
-];
-const GUEST_SCOPES = [...ANONYMOUS_SCOPES];
-const REGISTERED_SCOPES = [...GUEST_SCOPES];
-class CommercetoolsClient {
-  constructor(config) {
-    this.config = config;
+import { randomUUID } from "crypto";
+import { GuestIdentitySchema, IdentitySchema } from "@reactionary/core";
+import * as crypto from "crypto";
+class RequestContextTokenCache {
+  constructor(context) {
+    this.context = context;
   }
-  getClient(token) {
-    if (token) {
-      return this.createClientWithToken(token);
+  async get(tokenCacheOptions) {
+    const identity = this.context.identity;
+    if (identity.type !== "Anonymous") {
+      return {
+        refreshToken: identity.refresh_token,
+        token: identity.token || "",
+        expirationTime: identity.expiry.getTime()
+      };
     }
-    return this.createAnonymousClient();
+    return void 0;
   }
-  async login(username, password) {
-    const scopes = REGISTERED_SCOPES.map(
-      (scope) => `${scope}:${this.config.projectKey}`
-    ).join(" ");
-    const queryParams = new URLSearchParams({
-      grant_type: "password",
-      username,
-      password,
-      scope: scopes
-    });
-    const url = `${this.config.authUrl}/oauth/${this.config.projectKey}/customers/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 guest() {
-    const scopes = GUEST_SCOPES.map(
-      (scope) => `${scope}:${this.config.projectKey}`
-    ).join(" ");
-    const queryParams = new URLSearchParams({
-      grant_type: "client_credentials",
-      scope: scopes
-    });
-    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;
+}
+class CommercetoolsClient {
+  constructor(config) {
+    this.config = config;
   }
-  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;
+  async getClient(reqCtx) {
+    return this.createClient(reqCtx);
   }
-  async introspect(token) {
-    const queryParams = new URLSearchParams({
-      token
+  async register(username, password, reqCtx) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    const registrationBuilder = this.createBaseClientBuilder().withAnonymousSessionFlow({
+      host: this.config.authUrl,
+      projectKey: this.config.projectKey,
+      credentials: {
+        clientId: this.config.clientId,
+        clientSecret: this.config.clientSecret
+      },
+      scopes: this.config.scopes,
+      tokenCache: cache
     });
-    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;
+    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);
   }
-  createAnonymousClient() {
-    const scopes = ANONYMOUS_SCOPES.map(
-      (scope) => `${scope}:${this.config.projectKey}`
-    ).join(" ");
-    const builder = this.createBaseClientBuilder().withClientCredentialsFlow({
+  async login(username, password, reqCtx) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    const identity = reqCtx.identity;
+    const loginBuilder = this.createBaseClientBuilder().withPasswordFlow({
       host: this.config.authUrl,
       projectKey: this.config.projectKey,
       credentials: {
         clientId: this.config.clientId,
-        clientSecret: this.config.clientSecret
+        clientSecret: this.config.clientSecret,
+        user: { username, password }
       },
-      scopes: [scopes]
+      tokenCache: cache,
+      scopes: this.config.scopes
     });
-    return createApiBuilderFromCtpClient(builder.build());
+    const loginClient = createApiBuilderFromCtpClient(loginBuilder.build());
+    const login = await loginClient.withProjectKey({ projectKey: this.config.projectKey }).me().get().execute();
+    identity.type = "Registered";
+    identity.logonId = username;
+    identity.id = {
+      userId: login.body.id
+    };
   }
-  createClientWithToken(token) {
-    const builder = this.createBaseClientBuilder().withExistingTokenFlow(
-      `Bearer ${token}`,
-      { force: true }
-    );
+  async logout(reqCtx) {
+    const cache = new RequestContextTokenCache(reqCtx);
+    await cache.set({ token: "", refreshToken: "", expirationTime: 0 });
+    reqCtx.identity = IdentitySchema.parse({});
+  }
+  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();
+    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({
       concurrency: 20
+    }).withConcurrentModificationMiddleware({
+      concurrentModificationHandlerFn: (version, request) => {
+        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,
@@ -134,5 +155,6 @@ class CommercetoolsClient {
   }
 }
 export {
-  CommercetoolsClient
+  CommercetoolsClient,
+  RequestContextTokenCache
 };

package/core/initialize.js

@@ -5,7 +5,8 @@ import {
   PriceSchema,
   ProductSchema,
   SearchResultSchema,
-  CategorySchema
+  CategorySchema,
+  CartPaymentInstructionSchema
 } from "@reactionary/core";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
 import { CommercetoolsProductProvider } from "../providers/product.provider";
@@ -14,6 +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";
 function withCommercetoolsCapabilities(configuration, capabilities) {
   return (cache) => {
     const client = {};
@@ -38,6 +40,9 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
     if (capabilities.category) {
       client.category = new CommercetoolsCategoryProvider(configuration, CategorySchema, cache);
     }
+    if (capabilities.cartPayment) {
+      client.cartPayment = new CommercetoolsCartPaymentProvider(configuration, CartPaymentInstructionSchema, cache);
+    }
     return client;
   };
 }

package/package.json

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

package/providers/cart-payment.provider.js

@@ -0,0 +1,149 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+import { CommercetoolsClient } from "../core/client";
+import { traced } from "@reactionary/otel";
+import { CommercetoolsCartIdentifierSchema, CommercetoolsCartPaymentInstructionIdentifierSchema } from "../schema/commercetools.schema";
+import { CartPaymentProvider, PaymentMethodIdentifierSchema } from "@reactionary/core";
+class CommercetoolsCartPaymentProvider extends CartPaymentProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+  async getClient(reqCtx) {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+    return {
+      payments: client.withProjectKey({ projectKey: this.config.projectKey }).me().payments(),
+      carts: client.withProjectKey({ projectKey: this.config.projectKey }).me().carts()
+    };
+  }
+  async getByCartIdentifier(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const ctId = payload.cart;
+    const ctVersion = ctId.version || 0;
+    const cart = await client.carts.withId({ ID: ctId.key }).get({
+      queryArgs: {
+        expand: "paymentInfo.payments[*]"
+      }
+    }).execute();
+    let payments = (cart.body.paymentInfo?.payments || []).map((x) => x.obj).filter((x) => x);
+    if (payload.status) {
+      payments = payments.filter((payment) => payload.status.some((status) => payment.paymentStatus?.interfaceCode === status));
+    }
+    const parsedPayments = payments.map((payment) => this.parseSingle(payment, reqCtx));
+    const returnPayments = parsedPayments.map((x) => {
+      x.cart = { key: cart.body.id, version: cart.body.version || 0 };
+      return x;
+    });
+    return returnPayments;
+  }
+  async initiatePaymentForCart(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const cartId = payload.cart;
+    const response = await client.payments.post({
+      body: {
+        amountPlanned: {
+          centAmount: Math.round(payload.paymentInstruction.amount.value * 100),
+          currencyCode: payload.paymentInstruction.amount.currency
+        },
+        paymentMethodInfo: {
+          method: payload.paymentInstruction.paymentMethod.method,
+          name: {
+            [reqCtx.languageContext.locale]: payload.paymentInstruction.paymentMethod.name
+          },
+          paymentInterface: payload.paymentInstruction.paymentMethod.paymentProcessor
+        },
+        custom: {
+          type: {
+            typeId: "type",
+            key: "reactionaryPaymentCustomFields"
+          },
+          fields: {
+            cartId: cartId.key,
+            cartVersion: cartId.version + ""
+          }
+        }
+      }
+    }).execute();
+    const ctId = payload.cart;
+    const updatedCart = await client.carts.withId({ ID: ctId.key }).post({
+      body: {
+        version: ctId.version,
+        actions: [
+          {
+            "action": "addPayment",
+            "payment": {
+              "typeId": "payment",
+              "id": response.body.id
+            }
+          }
+        ]
+      }
+    }).execute();
+    const payment = this.parseSingle(response.body, reqCtx);
+    payment.cart = CommercetoolsCartIdentifierSchema.parse({
+      key: updatedCart.body.id,
+      version: updatedCart.body.version || 0
+    });
+    return payment;
+  }
+  async cancelPaymentInstruction(payload, reqCtx) {
+    const client = await this.getClient(reqCtx);
+    const newestVersion = await client.payments.withId({ ID: payload.paymentInstruction.key }).get().execute();
+    const response = await client.payments.withId({ ID: payload.paymentInstruction.key }).post({
+      body: {
+        version: newestVersion.body.version,
+        actions: [
+          {
+            action: "changeAmountPlanned",
+            amount: {
+              centAmount: 0,
+              currencyCode: newestVersion.body.amountPlanned.currencyCode
+            }
+          }
+        ]
+      }
+    }).execute();
+    const payment = this.parseSingle(response.body, reqCtx);
+    payment.cart = payload.cart;
+    return payment;
+  }
+  parseSingle(_body, reqCtx) {
+    const body = _body;
+    const base = this.newModel();
+    base.identifier = CommercetoolsCartPaymentInstructionIdentifierSchema.parse({
+      key: body.id,
+      version: body.version || 0
+    });
+    base.amount = {
+      value: body.amountPlanned.centAmount / 100,
+      currency: body.amountPlanned.currencyCode
+    };
+    base.paymentMethod = PaymentMethodIdentifierSchema.parse({
+      key: body.paymentMethodInfo?.method
+    });
+    base.status = body.paymentStatus?.interfaceCode;
+    base.cart = { key: "", version: 0 };
+    return this.assert(base);
+  }
+}
+__decorateClass([
+  traced()
+], CommercetoolsCartPaymentProvider.prototype, "getByCartIdentifier", 1);
+__decorateClass([
+  traced()
+], CommercetoolsCartPaymentProvider.prototype, "cancelPaymentInstruction", 1);
+__decorateClass([
+  traced()
+], CommercetoolsCartPaymentProvider.prototype, "parseSingle", 1);
+export {
+  CommercetoolsCartPaymentProvider
+};