@reactionary/provider-commercetools 0.3.16 → 0.3.17

package/core/client.js

@@ -10,12 +10,14 @@ import {
 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 {
   constructor(config, context) {
     this.config = config;
     this.context = context;
-    this.cache = new RequestContextTokenCache(this.context);
+    this.tokenCache = new RequestContextTokenCache(this.context, PROVIDER_SESSION_KEY);
   }
   async getClient() {
     if (!this.client) {
@@ -29,6 +31,77 @@ class CommercetoolsAPI {
     }
     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({
@@ -42,11 +115,11 @@ class CommercetoolsAPI {
     return createApiBuilderFromCtpClient(builder.build());
   }
   async createClient() {
-    let session = await this.cache.get();
+    let session = await this.tokenCache.get();
     const isNewSession = !session || !session.refreshToken;
     if (isNewSession) {
       await this.becomeGuest();
-      session = await this.cache.get();
+      session = await this.tokenCache.get();
     }
     let builder = this.createBaseClientBuilder();
     builder = builder.withRefreshTokenFlow({
@@ -57,7 +130,7 @@ class CommercetoolsAPI {
       host: this.config.authUrl,
       projectKey: this.config.projectKey,
       refreshToken: session?.refreshToken || "",
-      tokenCache: this.cache
+      tokenCache: this.tokenCache
     });
     return createApiBuilderFromCtpClient(builder.build());
   }
@@ -92,7 +165,7 @@ class CommercetoolsAPI {
         clientSecret: this.config.clientSecret,
         user: { username, password }
       },
-      tokenCache: this.cache,
+      tokenCache: this.tokenCache,
       scopes: this.config.scopes
     });
     const loginClient = createApiBuilderFromCtpClient(loginBuilder.build());
@@ -111,7 +184,7 @@ class CommercetoolsAPI {
     });
   }
   async logout() {
-    await this.cache.set({ token: "", refreshToken: "", expirationTime: 0 });
+    await this.tokenCache.set({ token: "", refreshToken: "", expirationTime: 0 });
     const identity = {
       type: "Anonymous"
     };
@@ -119,7 +192,7 @@ class CommercetoolsAPI {
   }
   // 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.cache.get();
+    const session = await this.tokenCache.get();
     if (!session || !session.token) {
       const identity = {
         type: "Anonymous"
@@ -191,7 +264,7 @@ class CommercetoolsAPI {
       }
     );
     const result = await response.json();
-    this.cache.set({
+    this.tokenCache.set({
       expirationTime: Date.now() + Number(result.expires_in) * 1e3 - 5 * 60 * 1e3,
       token: result.access_token,
       refreshToken: result.refresh_token
@@ -235,5 +308,6 @@ class CommercetoolsAPI {
   }
 }
 export {
-  CommercetoolsAPI
+  CommercetoolsAPI,
+  PROVIDER_SESSION_KEY
 };

package/core/token-cache.js

@@ -1,12 +1,12 @@
 import { CommercetoolsSessionSchema } from "../schema/session.schema.js";
-const PROVIDER_COMMERCETOOLS_SESSION_KEY = "PROVIDER_COMMERCETOOLS";
 class RequestContextTokenCache {
-  constructor(context) {
+  constructor(context, sessionProviderKey) {
     this.context = context;
+    this.sessionProviderKey = sessionProviderKey;
   }
   async get(tokenCacheOptions) {
     const session = CommercetoolsSessionSchema.parse(
-      this.context.session[PROVIDER_COMMERCETOOLS_SESSION_KEY] || {}
+      this.context.session[this.sessionProviderKey] || {}
     );
     if (!session) {
       return {
@@ -23,15 +23,14 @@ class RequestContextTokenCache {
   }
   async set(cache, tokenCacheOptions) {
     const session = CommercetoolsSessionSchema.parse(
-      this.context.session[PROVIDER_COMMERCETOOLS_SESSION_KEY] || {}
+      this.context.session[this.sessionProviderKey] || {}
     );
-    this.context.session[PROVIDER_COMMERCETOOLS_SESSION_KEY] = session;
+    this.context.session[this.sessionProviderKey] = session;
     session.refreshToken = cache.refreshToken;
     session.token = cache.token;
     session.expirationTime = cache.expirationTime;
   }
 }
 export {
-  PROVIDER_COMMERCETOOLS_SESSION_KEY,
   RequestContextTokenCache
 };

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@reactionary/provider-commercetools",
-  "version": "0.3.16",
+  "version": "0.3.17",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.16",
+    "@reactionary/core": "0.3.17",
     "debug": "^4.4.3",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.2.1",

package/providers/inventory.provider.js

@@ -23,8 +23,7 @@ class CommercetoolsInventoryProvider extends InventoryProvider {
   async getBySKU(payload) {
     const client = await this.getClient();
     try {
-      const channel = await client.channels().withKey({ key: payload.fulfilmentCenter.key }).get().execute();
-      const channelId = channel.body.id;
+      const channelId = await this.commercetools.resolveChannelIdByKey(payload.fulfilmentCenter.key);
       const remote = await client.inventory().get({
         queryArgs: {
           where: "sku=:sku AND supplyChannel(id=:channel)",
@@ -66,6 +65,10 @@ class CommercetoolsInventoryProvider extends InventoryProvider {
 }
 __decorateClass([
   Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
     inputSchema: InventoryQueryBySKUSchema,
     outputSchema: InventorySchema
   })

package/providers/price.provider.js

@@ -25,7 +25,12 @@ class CommercetoolsPriceProvider extends PriceProvider {
   }
   async getCustomerPrice(payload) {
     const client = await this.getClient();
-    const priceChannelId = "ee6e75e9-c9ab-4e2f-85f1-d8c734d0cb86";
+    let priceChannelId;
+    if (this.config.customerPriceChannelKey) {
+      priceChannelId = await this.commercetools.resolveChannelIdByKey(this.config.customerPriceChannelKey);
+    } else {
+      priceChannelId = await this.commercetools.resolveChannelIdByRole("Primary");
+    }
     const response = await client.productProjections().get({
       queryArgs: {
         staged: false,
@@ -46,7 +51,12 @@ class CommercetoolsPriceProvider extends PriceProvider {
   }
   async getListPrice(payload) {
     const client = await this.getClient();
-    const priceChannelId = "ee6e75e9-c9ab-4e2f-85f1-d8c734d0cb86";
+    let priceChannelId;
+    if (this.config.listPriceChannelKey) {
+      priceChannelId = await this.commercetools.resolveChannelIdByKey(this.config.listPriceChannelKey);
+    } else {
+      priceChannelId = await this.commercetools.resolveChannelIdByRole("Primary");
+    }
     const response = await client.productProjections().get({
       queryArgs: {
         staged: false,
@@ -79,8 +89,12 @@ class CommercetoolsPriceProvider extends PriceProvider {
       value: price.value.centAmount / 100,
       currency: price.value.currencyCode
     };
+    let isOnSale = false;
     if (options.includeDiscounts) {
       const discountedPrice = price.discounted?.value || price.value;
+      if (price.discounted) {
+        isOnSale = true;
+      }
       unitPrice = {
         value: discountedPrice.centAmount / 100,
         currency: price.value.currencyCode
@@ -94,23 +108,11 @@ class CommercetoolsPriceProvider extends PriceProvider {
     const result = {
       identifier,
       tieredPrices: [],
-      unitPrice
+      unitPrice,
+      onSale: isOnSale
     };
     return result;
   }
-  async getChannels() {
-    const adminClient = await this.commercetools.getAdminClient();
-    const offerPriceChannelPromise = adminClient.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key: "Offer Price" }).get().execute();
-    const listPriceChannelPromise = adminClient.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key: "List Price" }).get().execute();
-    const [offerChannel, listChannel] = await Promise.all([
-      offerPriceChannelPromise,
-      listPriceChannelPromise
-    ]);
-    return {
-      offer: offerChannel.body.id,
-      list: listChannel.body.id
-    };
-  }
 }
 __decorateClass([
   Reactionary({

package/schema/configuration.schema.js

@@ -7,8 +7,12 @@ const CommercetoolsConfigurationSchema = z.looseObject({
   clientId: z.string(),
   clientSecret: z.string(),
   scopes: z.array(z.string()).default(() => []),
+  adminClientId: z.string().optional(),
+  adminClientSecret: z.string().optional(),
   paymentMethods: PaymentMethodSchema.array().optional().default(() => []),
-  facetFieldsForSearch: z.array(z.string()).default(() => [])
+  facetFieldsForSearch: z.array(z.string()).default(() => []),
+  listPriceChannelKey: z.string().optional(),
+  customerPriceChannelKey: z.string().optional()
 });
 export {
   CommercetoolsConfigurationSchema

package/src/core/client.d.ts

@@ -3,15 +3,31 @@ import { type ApiRoot } from '@commercetools/platform-sdk';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import { type AnonymousIdentity, type GuestIdentity, type RegisteredIdentity, type RequestContext } from '@reactionary/core';
 import { RequestContextTokenCache } from './token-cache.js';
+import { type CommercetoolsSession } from '../schema/session.schema.js';
+export declare const PROVIDER_SESSION_KEY = "COMMERCETOOLS_PROVIDER";
 export declare class CommercetoolsAPI {
     protected config: CommercetoolsConfiguration;
     protected context: RequestContext;
-    protected cache: RequestContextTokenCache;
+    protected tokenCache: RequestContextTokenCache;
     protected client: Promise<ApiRoot> | undefined;
     protected adminClient: Promise<ApiRoot> | undefined;
     constructor(config: CommercetoolsConfiguration, context: RequestContext);
     getClient(): Promise<ApiRoot>;
     getAdminClient(): Promise<ApiRoot>;
+    getSessionData(): CommercetoolsSession;
+    setSessionData(sessionData: Partial<CommercetoolsSession>): void;
+    /**
+     * Only caches it pr session for now...... but still better than every call
+     * @param key
+     * @returns
+     */
+    resolveChannelIdByKey(key: string): Promise<string>;
+    /**
+     * Only caches it pr session for now...... but still better than every call
+     * @param key
+     * @returns
+     */
+    resolveChannelIdByRole(role: string): Promise<string>;
     protected createAdminClient(): Promise<ApiRoot>;
     protected createClient(): Promise<ApiRoot>;
     register(username: string, password: string): Promise<{

package/src/core/token-cache.d.ts

@@ -1,9 +1,9 @@
 import type { TokenCache, TokenCacheOptions, TokenStore } from "@commercetools/ts-client";
 import type { RequestContext } from "@reactionary/core";
-export declare const PROVIDER_COMMERCETOOLS_SESSION_KEY = "PROVIDER_COMMERCETOOLS";
 export declare class RequestContextTokenCache implements TokenCache {
     protected context: RequestContext;
-    constructor(context: RequestContext);
+    protected sessionProviderKey: string;
+    constructor(context: RequestContext, sessionProviderKey: string);
     get(tokenCacheOptions?: TokenCacheOptions): Promise<TokenStore | undefined>;
     set(cache: TokenStore, tokenCacheOptions?: TokenCacheOptions): Promise<void>;
 }

package/src/providers/price.provider.d.ts

@@ -12,8 +12,4 @@ export declare class CommercetoolsPriceProvider extends PriceProvider {
     protected parseSingle(_body: unknown, options?: {
         includeDiscounts: boolean;
     }): Price;
-    protected getChannels(): Promise<{
-        offer: string;
-        list: string;
-    }>;
 }

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

@@ -6,6 +6,8 @@ export declare const CommercetoolsConfigurationSchema: z.ZodObject<{
     clientId: z.ZodString;
     clientSecret: z.ZodString;
     scopes: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    adminClientId: z.ZodOptional<z.ZodString>;
+    adminClientSecret: z.ZodOptional<z.ZodString>;
     paymentMethods: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodObject<{
         identifier: z.ZodObject<{
             method: z.ZodString;
@@ -22,5 +24,7 @@ export declare const CommercetoolsConfigurationSchema: z.ZodObject<{
         isPunchOut: z.ZodBoolean;
     }, z.core.$loose>>>>;
     facetFieldsForSearch: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    listPriceChannelKey: z.ZodOptional<z.ZodString>;
+    customerPriceChannelKey: z.ZodOptional<z.ZodString>;
 }, z.core.$loose>;
 export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;

package/src/schema/session.schema.d.ts

@@ -4,3 +4,4 @@ export declare const CommercetoolsSessionSchema: z.ZodObject<{
     refreshToken: z.ZodOptional<z.ZodString>;
     expirationTime: z.ZodDefault<z.ZodNumber>;
 }, z.core.$loose>;
+export type CommercetoolsSession = z.infer<typeof CommercetoolsSessionSchema>;