@reactionary/commercetools 0.6.3

package/core/client.js

@@ -0,0 +1,318 @@
+import { ClientBuilder } from "@commercetools/ts-client";
+import {
+  createApiBuilderFromCtpClient
+} from "@commercetools/platform-sdk";
+import { randomUUID } from "crypto";
+import {
+  AnonymousIdentitySchema,
+  RegisteredIdentitySchema
+} from "@reactionary/core";
+import * as crypto from "crypto";
+import createDebug from "debug";
+import { RequestContextTokenCache } from "./token-cache.js";
+import { CommercetoolsSessionSchema } from "../schema/session.schema.js";
+const debug = createDebug("reactionary:commercetools");
+const PROVIDER_SESSION_KEY = "COMMERCETOOLS_PROVIDER";
+class CommercetoolsAPI {
+  config;
+  context;
+  tokenCache;
+  client;
+  adminClient;
+  constructor(config, context) {
+    this.config = config;
+    this.context = context;
+    this.tokenCache = new RequestContextTokenCache(this.context, PROVIDER_SESSION_KEY);
+  }
+  async getClient() {
+    if (!this.client) {
+      this.client = this.createClient();
+    }
+    return this.client;
+  }
+  async getAdminClient() {
+    if (!this.adminClient) {
+      this.adminClient = this.createAdminClient();
+    }
+    return this.adminClient;
+  }
+  getSessionData() {
+    return this.context.session[PROVIDER_SESSION_KEY] ? this.context.session[PROVIDER_SESSION_KEY] : CommercetoolsSessionSchema.parse({});
+  }
+  setSessionData(sessionData) {
+    const existingData = this.context.session[PROVIDER_SESSION_KEY];
+    this.context.session[PROVIDER_SESSION_KEY] = {
+      ...existingData,
+      ...sessionData
+    };
+  }
+  /**
+   * Only caches it pr session for now...... but still better than every call
+   * @param key
+   * @returns
+   */
+  async resolveChannelIdByKey(key) {
+    const sessionData = this.getSessionData();
+    const cacheKey = `___channel_${key}`;
+    const cachedValue = sessionData[cacheKey];
+    if (cachedValue) {
+      if (debug.enabled) {
+        debug(`Resolved channel ${key} from cache`);
+      }
+      return cachedValue + "";
+    }
+    const client = await this.getAdminClient();
+    const response = await client.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key }).get().execute();
+    const channel = response.body;
+    this.setSessionData({
+      cacheKey: channel.id
+    });
+    if (debug.enabled) {
+      debug(`Resolved channel ${key} from API and cached it`);
+    }
+    return channel.id;
+  }
+  /**
+   * Only caches it pr session for now...... but still better than every call
+   * @param key
+   * @returns
+   */
+  async resolveChannelIdByRole(role) {
+    const sessionData = this.getSessionData();
+    const cacheKey = `___channel_role_${role}`;
+    const cachedValue = sessionData[cacheKey];
+    if (cachedValue) {
+      if (debug.enabled) {
+        debug(`Resolved channel ${role} from cache`);
+      }
+      return cachedValue + "";
+    }
+    const client = await this.getAdminClient();
+    const response = await client.withProjectKey({ projectKey: this.config.projectKey }).channels().get({
+      queryArgs: {
+        where: `roles contains any (:role)`,
+        "var.role": role
+      }
+    }).execute();
+    const channels = response.body;
+    if (channels.results.length === 0) {
+      throw new Error(`No channel found with role ${role}`);
+    }
+    const channel = channels.results[0];
+    this.setSessionData({
+      [cacheKey]: channel.id
+    });
+    if (debug.enabled) {
+      debug(`Resolved channel ${role} from API and cached it`);
+    }
+    return channel.id;
+  }
+  async createAdminClient() {
+    let builder = this.createBaseClientBuilder();
+    builder = builder.withAnonymousSessionFlow({
+      credentials: {
+        clientId: this.config.clientId,
+        clientSecret: this.config.clientSecret
+      },
+      host: this.config.authUrl,
+      projectKey: this.config.projectKey
+    });
+    return createApiBuilderFromCtpClient(builder.build());
+  }
+  async createClient() {
+    let session = await this.tokenCache.get();
+    const isNewSession = !session || !session.refreshToken;
+    if (isNewSession) {
+      await this.becomeGuest();
+      session = await this.tokenCache.get();
+    }
+    let builder = this.createBaseClientBuilder();
+    builder = builder.withRefreshTokenFlow({
+      credentials: {
+        clientId: this.config.clientId,
+        clientSecret: this.config.clientSecret
+      },
+      host: this.config.authUrl,
+      projectKey: this.config.projectKey,
+      refreshToken: session?.refreshToken || "",
+      tokenCache: this.tokenCache
+    });
+    return createApiBuilderFromCtpClient(builder.build());
+  }
+  async register(username, password) {
+    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
+    });
+    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);
+    return login;
+  }
+  async login(username, password) {
+    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: this.tokenCache,
+      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();
+    const self = await loginClient.withProjectKey({ projectKey: this.config.projectKey }).me().get({}).execute();
+    return RegisteredIdentitySchema.parse({
+      type: "Registered",
+      id: {
+        userId: self.body.id
+      }
+    });
+  }
+  async logout() {
+    await this.tokenCache.set({ token: "", refreshToken: "", expirationTime: 0 });
+    const identity = {
+      type: "Anonymous"
+    };
+    return identity;
+  }
+  // FIXME: This can fail if the short-lived access token has expired. In other words, probably missing a token refresh.
+  async introspect() {
+    const session = await this.tokenCache.get();
+    if (!session || !session.token) {
+      const identity = {
+        type: "Anonymous"
+      };
+      return identity;
+    }
+    const authHeader = "Basic " + Buffer.from(
+      `${this.config.clientId}:${this.config.clientSecret}`
+    ).toString("base64");
+    const introspectionUrl = `${this.config.authUrl}/oauth/introspect`;
+    const response = await fetch(introspectionUrl, {
+      method: "POST",
+      headers: {
+        Authorization: authHeader,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      body: new URLSearchParams({
+        token: session.token
+      })
+    });
+    const body = await response.json();
+    if (!body) {
+      return AnonymousIdentitySchema.parse({});
+    }
+    const scopes = body.scope + "";
+    if (scopes.indexOf("anonymous_id") > -1) {
+      const s = scopes.split(" ");
+      const idScope = s.find((x) => x.startsWith("anonymous_id"));
+      const id = idScope?.split(":")[1] || "";
+      const identity = {
+        id: {
+          userId: id
+        },
+        type: "Guest"
+      };
+      return identity;
+    }
+    if (scopes.indexOf("customer_id") > -1) {
+      const s = scopes.split(" ");
+      const idScope = s.find((x) => x.startsWith("customer_id"));
+      const id = idScope?.split(":")[1] || "";
+      const identity = {
+        id: {
+          userId: id
+        },
+        type: "Registered"
+      };
+      return identity;
+    }
+    return {
+      type: "Anonymous"
+    };
+  }
+  async becomeGuest() {
+    const credentials = Buffer.from(
+      `${this.config.clientId}:${this.config.clientSecret}`
+    ).toString("base64");
+    const response = await fetch(
+      `${this.config.authUrl}/oauth/${this.config.projectKey}/anonymous/token?grant_type=client_credentials`,
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Basic ${credentials}`,
+          "Content-Type": "application/x-www-form-urlencoded"
+        },
+        body: new URLSearchParams({
+          grant_type: "client_credentials"
+        })
+      }
+    );
+    const result = await response.json();
+    this.tokenCache.set({
+      expirationTime: Date.now() + Number(result.expires_in) * 1e3 - 5 * 60 * 1e3,
+      token: result.access_token,
+      refreshToken: result.refresh_token
+    });
+  }
+  createBaseClientBuilder() {
+    let 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);
+      }
+    }).withHttpMiddleware({
+      retryConfig: {
+        backoff: true,
+        maxRetries: 3,
+        retryDelay: 500,
+        retryOnAbort: true,
+        retryCodes: [500, 429, 420],
+        maxDelay: 5e3
+      },
+      enableRetry: true,
+      includeResponseHeaders: true,
+      maskSensitiveHeaderData: false,
+      host: this.config.apiUrl,
+      httpClient: fetch
+    });
+    const correlationId = this.context.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 {
+  CommercetoolsAPI,
+  PROVIDER_SESSION_KEY
+};

package/core/initialize.js

@@ -0,0 +1,47 @@
+import {
+  CommercetoolsCapabilitiesSchema
+} from "../schema/capabilities.schema.js";
+import {
+  CommercetoolsConfigurationSchema
+} from "../schema/configuration.schema.js";
+import { CommercetoolsAPI } from "./client.js";
+import {
+  capabilityDescriptors,
+  capabilityKeys
+} from "./capability-descriptors.js";
+import {
+  resolveCapabilityWithFactory
+} from "./initialize.types.js";
+function withCommercetoolsCapabilities(configuration, capabilities) {
+  return (cache, context) => {
+    const client = {};
+    const config = CommercetoolsConfigurationSchema.parse(configuration);
+    const caps = CommercetoolsCapabilitiesSchema.parse(capabilities);
+    const commercetoolsApi = new CommercetoolsAPI(config, context);
+    const buildCapabilityArgs = (factory) => ({
+      cache,
+      context,
+      config,
+      commercetoolsApi,
+      factory
+    });
+    for (const key of capabilityKeys) {
+      const descriptor = capabilityDescriptors[key];
+      if (!descriptor.isEnabled(caps)) {
+        continue;
+      }
+      client[key] = resolveCapabilityWithFactory(
+        descriptor.getOverride(capabilities),
+        {
+          factory: descriptor.createDefaultFactory(),
+          capability: descriptor.createDefaultCapability
+        },
+        buildCapabilityArgs
+      );
+    }
+    return client;
+  };
+}
+export {
+  withCommercetoolsCapabilities
+};

package/core/initialize.types.js

@@ -0,0 +1,8 @@
+function resolveCapabilityWithFactory(capability, defaults, buildCapabilityArgs) {
+  const factory = capability?.factory ?? defaults.factory;
+  const capabilityFactory = capability?.capability ?? defaults.capability;
+  return capabilityFactory(buildCapabilityArgs(factory));
+}
+export {
+  resolveCapabilityWithFactory
+};

package/core/token-cache.js

@@ -0,0 +1,36 @@
+import { CommercetoolsSessionSchema } from "../schema/session.schema.js";
+class RequestContextTokenCache {
+  constructor(context, sessionProviderKey) {
+    this.context = context;
+    this.sessionProviderKey = sessionProviderKey;
+  }
+  async get(tokenCacheOptions) {
+    const session = CommercetoolsSessionSchema.parse(
+      this.context.session[this.sessionProviderKey] || {}
+    );
+    if (!session) {
+      return {
+        refreshToken: void 0,
+        token: "",
+        expirationTime: (/* @__PURE__ */ new Date()).getTime()
+      };
+    }
+    return {
+      refreshToken: session.refreshToken,
+      token: session.token,
+      expirationTime: session.expirationTime
+    };
+  }
+  async set(cache, tokenCacheOptions) {
+    const session = CommercetoolsSessionSchema.parse(
+      this.context.session[this.sessionProviderKey] || {}
+    );
+    this.context.session[this.sessionProviderKey] = session;
+    session.refreshToken = cache.refreshToken;
+    session.token = cache.token;
+    session.expirationTime = cache.expirationTime;
+  }
+}
+export {
+  RequestContextTokenCache
+};

package/factories/cart/cart.factory.js

@@ -0,0 +1,110 @@
+import {
+  CartItemSchema
+} from "@reactionary/core";
+class CommercetoolsCartFactory {
+  cartSchema;
+  cartIdentifierSchema;
+  constructor(cartSchema, cartIdentifierSchema) {
+    this.cartSchema = cartSchema;
+    this.cartIdentifierSchema = cartIdentifierSchema;
+  }
+  parseCartIdentifier(_context, data) {
+    return this.cartIdentifierSchema.parse({
+      key: data.key || ""
+    });
+  }
+  parseCart(context, data) {
+    const identifier = this.parseCartIdentifier(context, {
+      key: data.id
+    });
+    const grandTotal = data.totalPrice.centAmount || 0;
+    const shippingTotal = data.shippingInfo?.price.centAmount || 0;
+    const productTotal = grandTotal - shippingTotal;
+    const taxTotal = data.taxedPrice?.totalTax?.centAmount || 0;
+    const discountTotal = data.discountOnTotalPrice?.discountedAmount.centAmount || 0;
+    const surchargeTotal = 0;
+    const currency = data.totalPrice.currencyCode;
+    const price = {
+      totalTax: {
+        value: taxTotal / 100,
+        currency
+      },
+      totalDiscount: {
+        value: discountTotal / 100,
+        currency
+      },
+      totalSurcharge: {
+        value: surchargeTotal / 100,
+        currency
+      },
+      totalShipping: {
+        value: shippingTotal / 100,
+        currency
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency
+      }
+    };
+    const items = [];
+    for (const lineItem of data.lineItems) {
+      items.push(this.parseCartItem(lineItem));
+    }
+    const result = {
+      identifier,
+      userId: {
+        userId: "???"
+      },
+      name: data.custom?.fields["name"] || "",
+      description: data.custom?.fields["description"] || "",
+      price,
+      items,
+      appliedPromotions: []
+    };
+    return this.cartSchema.parse(result);
+  }
+  parseCartItem(lineItem) {
+    const unitPrice = lineItem.price.value.centAmount;
+    const totalPrice = lineItem.totalPrice.centAmount || 0;
+    const totalDiscount = lineItem.price.discounted?.value.centAmount || 0;
+    const unitDiscount = totalDiscount / lineItem.quantity;
+    const currency = lineItem.price.value.currencyCode.toUpperCase();
+    return CartItemSchema.parse({
+      identifier: {
+        key: lineItem.id
+      },
+      product: {
+        key: lineItem.productId
+      },
+      variant: {
+        sku: lineItem.variant.sku || ""
+      },
+      quantity: lineItem.quantity,
+      price: {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency
+        },
+        unitDiscount: {
+          value: unitDiscount / 100,
+          currency
+        },
+        totalPrice: {
+          value: totalPrice / 100,
+          currency
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency
+        }
+      }
+    });
+  }
+}
+export {
+  CommercetoolsCartFactory
+};

package/factories/category/category.factory.js

@@ -0,0 +1,40 @@
+import {
+} from "@reactionary/core";
+class CommercetoolsCategoryFactory {
+  categorySchema;
+  categoryPaginatedResultSchema;
+  constructor(categorySchema, categoryPaginatedResultSchema) {
+    this.categorySchema = categorySchema;
+    this.categoryPaginatedResultSchema = categoryPaginatedResultSchema;
+  }
+  parseCategory(context, data) {
+    const identifier = { key: data.key || "" };
+    const result = {
+      identifier,
+      name: data.name[context.languageContext.locale] || "No Name",
+      slug: data.slug ? data.slug[context.languageContext.locale] || "" : "",
+      text: data.description ? data.description[context.languageContext.locale] || "" : "",
+      parentCategory: data.parent && data.parent.obj && data.parent.obj?.key ? { key: data.parent.obj.key } : void 0,
+      images: (data.assets || []).filter((asset) => asset.sources.length > 0).filter((asset) => asset.sources[0].contentType?.startsWith("image/")).map((asset) => ({
+        sourceUrl: asset.sources[0].uri,
+        altText: asset.description?.[context.languageContext.locale] || asset.name[context.languageContext.locale] || "",
+        height: asset.sources[0].dimensions?.h || 0,
+        width: asset.sources[0].dimensions?.w || 0
+      }))
+    };
+    return this.categorySchema.parse(result);
+  }
+  parseCategoryPaginatedResult(context, data) {
+    const result = {
+      pageNumber: Math.floor(data.offset / data.count) + 1,
+      pageSize: data.count,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total ?? 0) / data.count),
+      items: data.results.map((category) => this.parseCategory(context, category))
+    };
+    return this.categoryPaginatedResultSchema.parse(result);
+  }
+}
+export {
+  CommercetoolsCategoryFactory
+};

package/factories/checkout/checkout-initializer-overrides.example.js

@@ -0,0 +1,67 @@
+import {
+  CheckoutSchema,
+  PaymentMethodSchema,
+  ShippingMethodSchema,
+  unwrapValue
+} from "@reactionary/core";
+import { withCommercetoolsCapabilities } from "../../core/initialize.js";
+import { CommercetoolsCheckoutCapability } from "../../capabilities/checkout.capability.js";
+import { assertNotAny, assertType } from "../product/utils.example.js";
+import { CommercetoolsCheckoutFactory } from "./checkout.factory.js";
+import * as z from "zod";
+const cache = {};
+const context = {};
+const config = {};
+const ExtendedCheckoutSchema = CheckoutSchema.safeExtend({
+  extendedValue: z.string().default("")
+});
+class ExtendedCommercetoolsCheckoutFactory extends CommercetoolsCheckoutFactory {
+  constructor() {
+    super(ExtendedCheckoutSchema, ShippingMethodSchema, PaymentMethodSchema);
+  }
+  parseCheckout(context2, data) {
+    const base = super.parseCheckout(context2, data);
+    return {
+      ...base,
+      extendedValue: "from-factory"
+    };
+  }
+}
+class ExtendedCommercetoolsCheckoutCapability extends CommercetoolsCheckoutCapability {
+  async getByIdOrThrow(payload) {
+    const result = await this.getById(payload);
+    return unwrapValue(result);
+  }
+}
+const extendedFactory = new ExtendedCommercetoolsCheckoutFactory();
+const capabilityFactory = withCommercetoolsCapabilities(config, {
+  checkout: {
+    enabled: true,
+    factory: extendedFactory,
+    capability: ({ cache: cache2, context: context2, config: config2, commercetoolsApi }) => new ExtendedCommercetoolsCheckoutCapability(
+      config2,
+      cache2,
+      context2,
+      commercetoolsApi,
+      extendedFactory
+    )
+  }
+});
+const client = capabilityFactory(cache, context);
+client.checkout.getById({
+  identifier: { key: "checkout-1" }
+}).then((result) => {
+  assertNotAny(result);
+  if (result.success) {
+    assertNotAny(result.value);
+    assertNotAny(result.value.extendedValue);
+    assertType(result.value.extendedValue);
+  }
+});
+client.checkout.getByIdOrThrow({
+  identifier: { key: "checkout-2" }
+}).then((checkout) => {
+  assertNotAny(checkout);
+  assertNotAny(checkout.extendedValue);
+  assertType(checkout.extendedValue);
+});