@reactionary/provider-commercetools 0.3.15 → 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/initialize.js

@@ -18,7 +18,8 @@ import {
   CommercetoolsProfileProvider,
   CommercetoolsStoreProvider,
   CommercetoolsProductReviewsProvider,
-  CommercetoolsProductAssociationsProvider
+  CommercetoolsProductAssociationsProvider,
+  CommercetoolsProductListProvider
 } from "../providers/index.js";
 import { CommercetoolsAPI } from "./client.js";
 function withCommercetoolsCapabilities(configuration, capabilities) {
@@ -59,6 +60,14 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
         commercetoolsApi
       );
     }
+    if (caps.productList) {
+      client.productList = new CommercetoolsProductListProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
     if (caps.productReviews) {
       client.productReviews = new CommercetoolsProductReviewsProvider(
         config,

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.15",
+  "version": "0.3.17",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.15",
+    "@reactionary/core": "0.3.17",
     "debug": "^4.4.3",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.2.1",

package/providers/index.js

@@ -5,6 +5,7 @@ export * from "./inventory.provider.js";
 export * from "./order-search.provider.js";
 export * from "./price.provider.js";
 export * from "./product-associations.provider.js";
+export * from "./product-list.provider.js";
 export * from "./product.provider.js";
 export * from "./product-reviews.provider.js";
 export * from "./profile.provider.js";

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/providers/product-list.provider.js

@@ -0,0 +1,389 @@
+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 {
+  error,
+  ProductListItemMutationCreateSchema,
+  ProductListItemMutationDeleteSchema,
+  ProductListItemMutationUpdateSchema,
+  ProductListItemPaginatedResultsSchema,
+  ProductListItemQuerySchema,
+  ProductListItemSchema,
+  ProductListMutationCreateSchema,
+  ProductListMutationDeleteSchema,
+  ProductListMutationUpdateSchema,
+  ProductListPaginatedResultsSchema,
+  ProductListProvider,
+  ProductListQueryByIdSchema,
+  ProductListQuerySchema,
+  ProductListSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+class CommercetoolsProductListProvider extends ProductListProvider {
+  constructor(config, cache, context, commercetools) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+  }
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey }).me();
+  }
+  async getById(payload) {
+    try {
+      const client = await this.getClient();
+      const response = await client.shoppingLists().withId({ ID: payload.identifier.key }).get().execute();
+      return success(this.parseSingle(response.body));
+    } catch (err) {
+      if (err.statusCode === 404) {
+        return error({
+          type: "NotFound",
+          identifier: payload
+        });
+      } else {
+        throw err;
+      }
+    }
+  }
+  async queryLists(payload) {
+    if (this.context.session.identityContext?.identity?.type !== "Registered") {
+      return success({
+        items: [],
+        pageNumber: 1,
+        pageSize: payload.search.paginationOptions.pageSize,
+        totalCount: 0,
+        totalPages: 0,
+        identifier: payload.search
+      });
+    }
+    const client = await this.getClient();
+    const response = await client.shoppingLists().get({
+      queryArgs: {
+        where: `custom(fields(listType=:listType))`,
+        sort: "createdAt desc",
+        "var.listType": payload.search.listType,
+        limit: payload.search.paginationOptions.pageSize,
+        offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize
+      }
+    }).execute();
+    return success({
+      items: response.body.results.map((list) => this.parseSingle(list)),
+      pageNumber: payload.search.paginationOptions.pageNumber,
+      pageSize: payload.search.paginationOptions.pageSize,
+      totalCount: response.body.total || 0,
+      totalPages: Math.ceil((response.body.total || 0) / payload.search.paginationOptions.pageSize),
+      identifier: payload.search
+    });
+  }
+  async addList(mutation) {
+    const client = await this.getClient();
+    const localeString = this.getLocaleString();
+    if (this.context.session.identityContext?.identity?.type !== "Registered") {
+      return error({
+        type: "InvalidInput",
+        error: "Only registered users can have product lists"
+      });
+    }
+    const draft = {
+      name: { [localeString]: mutation.list.name },
+      description: mutation.list.description ? { [localeString]: mutation.list.description } : void 0,
+      custom: {
+        type: {
+          key: "reactionaryShoppingList",
+          typeId: "type"
+        },
+        fields: {
+          listType: mutation.list.type,
+          imageUrl: mutation.list.image ? mutation.list.image.sourceUrl : void 0,
+          publishedDate: mutation.list.publishDate ? new Date(mutation.list.publishDate) : void 0,
+          published: mutation.list.published || true
+        }
+      }
+    };
+    const response = await client.shoppingLists().post({
+      body: draft
+    }).execute();
+    return success(this.parseSingle(response.body));
+  }
+  async updateList(mutation) {
+    const client = await this.getClient();
+    const actions = [];
+    const localeString = this.getLocaleString();
+    if (mutation.name) {
+      actions.push({
+        action: "changeName",
+        name: { [localeString]: mutation.name }
+      });
+    }
+    if (mutation.description !== void 0) {
+      actions.push({
+        action: "setDescription",
+        description: mutation.description ? { [localeString]: mutation.description } : void 0
+      });
+    }
+    if (mutation.published) {
+      actions.push({
+        action: "setCustomField",
+        name: "published",
+        value: mutation.published
+      });
+    }
+    if (mutation.publishDate) {
+      actions.push({
+        action: "setCustomField",
+        name: "publishedDate",
+        value: new Date(mutation.publishDate)
+      });
+    }
+    if (mutation.image) {
+      actions.push({
+        action: "setCustomField",
+        name: "imageUrl",
+        value: mutation.image.sourceUrl
+      });
+    }
+    const update = {
+      version: 0,
+      // The auto-correcting middleware will deal with the version
+      actions
+    };
+    const response = await client.shoppingLists().withId({ ID: mutation.list.key }).post({ body: update }).execute();
+    return success(this.parseSingle(response.body));
+  }
+  async deleteList(mutation) {
+    const client = await this.getClient();
+    const newestVersion = await client.shoppingLists().withId({ ID: mutation.list.key }).get().execute().then((response) => response.body.version);
+    await client.shoppingLists().withId({ ID: mutation.list.key }).delete({
+      queryArgs: {
+        version: newestVersion
+      }
+    }).execute();
+    return success(void 0);
+  }
+  async queryListItems(query) {
+    const client = await this.getClient();
+    const response = await client.shoppingLists().withId({ ID: query.search.list.key }).get({
+      queryArgs: { expand: "lineItems[*].variant" }
+    }).execute();
+    const items = response.body.lineItems.map((lineItem) => this.parseProductListItem(query.search.list, lineItem));
+    return success({
+      items: items.slice((query.search.paginationOptions.pageNumber - 1) * query.search.paginationOptions.pageSize, query.search.paginationOptions.pageNumber * query.search.paginationOptions.pageSize),
+      identifier: query.search,
+      pageNumber: query.search.paginationOptions.pageNumber,
+      pageSize: query.search.paginationOptions.pageSize,
+      totalCount: items.length,
+      totalPages: Math.ceil(items.length / query.search.paginationOptions.pageSize)
+    });
+  }
+  async addItem(mutation) {
+    const client = await this.getClient();
+    const lineItemDraft = {
+      action: "addLineItem",
+      sku: mutation.listItem.variant.sku,
+      quantity: mutation.listItem.quantity,
+      custom: {
+        type: {
+          key: "reactionaryShoppingListItem",
+          typeId: "type"
+        },
+        fields: {
+          notes: mutation.listItem.notes || "",
+          order: mutation.listItem.order || 1
+        }
+      }
+    };
+    const update = {
+      version: 0,
+      // The auto-correcting middleware will deal with the version
+      actions: [lineItemDraft]
+    };
+    const response = await client.shoppingLists().withId({ ID: mutation.list.key }).post({ body: update, queryArgs: { expand: "lineItems[*].variant" } }).execute();
+    const lastItem = response.body.lineItems[response.body.lineItems.length - 1];
+    if (lastItem.variant?.sku !== mutation.listItem.variant.sku) {
+      throw new Error("The added line item is not the last item in the list, cannot reliably determine the identifier of the added item");
+    }
+    return success(this.parseProductListItem(mutation.list, lastItem));
+  }
+  async deleteItem(mutation) {
+    const client = await this.getClient();
+    const update = {
+      version: 0,
+      // The auto-correcting middleware will deal with the version
+      actions: [{
+        action: "removeLineItem",
+        lineItemId: mutation.listItem.key
+      }]
+    };
+    await client.shoppingLists().withId({ ID: mutation.listItem.list.key }).post({ body: update }).execute();
+    return success(void 0);
+  }
+  async updateItem(mutation) {
+    const client = await this.getClient();
+    const actions = [];
+    if (mutation.quantity !== void 0) {
+      actions.push({
+        action: "changeLineItemQuantity",
+        lineItemId: mutation.listItem.key,
+        quantity: mutation.quantity
+      });
+    }
+    if (mutation.notes !== void 0) {
+      actions.push({
+        action: "setLineItemCustomField",
+        lineItemId: mutation.listItem.key,
+        name: "notes",
+        value: mutation.notes
+      });
+    }
+    if (mutation.order !== void 0) {
+      actions.push({
+        action: "setLineItemCustomField",
+        lineItemId: mutation.listItem.key,
+        name: "order",
+        value: mutation.order
+      });
+    }
+    const update = {
+      version: 0,
+      actions
+    };
+    const response = await client.shoppingLists().withId({ ID: mutation.listItem.list.key }).post({ body: update, queryArgs: { expand: "lineItems[*].variant" } }).execute();
+    const updatedLineItem = response.body.lineItems.find((item) => item.id === mutation.listItem.key);
+    if (!updatedLineItem) {
+      throw new Error("Failed to find the updated line item in response");
+    }
+    return success(this.parseProductListItem(mutation.listItem.list, updatedLineItem));
+  }
+  /**
+   * It is not clear to me, why i'd want my CUSTOMER defined resources to be localized, since that means, if he changes visual language,
+   * the names of his lists will disappear, since they are not translated. But maybe there are usecases for this, so we should support it, but default to english.
+   **/
+  getLocaleString() {
+    return "en";
+  }
+  parseSingle(list) {
+    const localeString = this.getLocaleString();
+    const listType = list.custom?.fields["listType"] || "favorite";
+    const image = list.custom?.fields["imageUrl"];
+    const published = list.custom?.fields["published"] && true;
+    const publishDateDate = list.custom?.fields["publishedDate"];
+    let publishedDate;
+    if (publishDateDate) {
+      publishedDate = new Date(publishDateDate).toISOString();
+    }
+    return {
+      identifier: {
+        listType,
+        key: list.id
+      },
+      type: listType,
+      name: list.name[localeString] || "Unnamed List",
+      description: list.description?.[localeString] || "",
+      published,
+      publishDate: publishedDate,
+      image: {
+        sourceUrl: image || "",
+        altText: list.name[localeString] || "List Image"
+      }
+    };
+  }
+  parseProductListItem(listIdentifier, lineItem) {
+    const localeString = this.getLocaleString();
+    return {
+      identifier: {
+        list: listIdentifier,
+        key: lineItem.id
+      },
+      variant: {
+        sku: lineItem.variant?.sku || ""
+      },
+      quantity: lineItem.quantity,
+      notes: lineItem.custom?.fields["notes"] || "",
+      order: lineItem.custom?.fields["order"] || 1
+      // Commercetools doesn't have explicit ordering
+    };
+  }
+}
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
+    inputSchema: ProductListQueryByIdSchema,
+    outputSchema: ProductListSchema
+  })
+], CommercetoolsProductListProvider.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
+    inputSchema: ProductListQuerySchema,
+    outputSchema: ProductListPaginatedResultsSchema
+  })
+], CommercetoolsProductListProvider.prototype, "queryLists", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    // Mutations should not be cached
+    inputSchema: ProductListMutationCreateSchema,
+    outputSchema: ProductListSchema
+  })
+], CommercetoolsProductListProvider.prototype, "addList", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListMutationUpdateSchema,
+    outputSchema: ProductListSchema
+  })
+], CommercetoolsProductListProvider.prototype, "updateList", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListMutationDeleteSchema
+  })
+], CommercetoolsProductListProvider.prototype, "deleteList", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
+    inputSchema: ProductListItemQuerySchema,
+    outputSchema: ProductListItemPaginatedResultsSchema
+  })
+], CommercetoolsProductListProvider.prototype, "queryListItems", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationCreateSchema,
+    outputSchema: ProductListItemSchema
+  })
+], CommercetoolsProductListProvider.prototype, "addItem", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationDeleteSchema
+  })
+], CommercetoolsProductListProvider.prototype, "deleteItem", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationUpdateSchema,
+    outputSchema: ProductListItemSchema
+  })
+], CommercetoolsProductListProvider.prototype, "updateItem", 1);
+export {
+  CommercetoolsProductListProvider
+};

package/schema/capabilities.schema.js

@@ -4,6 +4,7 @@ const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   productSearch: true,
   productAssociations: true,
   productReviews: true,
+  productList: true,
   identity: true,
   cart: true,
   checkout: true,

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/index.d.ts

@@ -5,6 +5,7 @@ export * from './inventory.provider.js';
 export * from './order-search.provider.js';
 export * from './price.provider.js';
 export * from './product-associations.provider.js';
+export * from './product-list.provider.js';
 export * from './product.provider.js';
 export * from './product-reviews.provider.js';
 export * from './profile.provider.js';

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/providers/product-list.provider.d.ts

@@ -0,0 +1,27 @@
+import type { ShoppingList, ShoppingListLineItem } from '@commercetools/platform-sdk';
+import type { Cache, ProductList, ProductListIdentifier, ProductListItem, ProductListItemMutationCreate, ProductListItemMutationDelete, ProductListItemMutationUpdate, ProductListItemPaginatedResult, ProductListItemsQuery, ProductListMutationCreate, ProductListMutationDelete, ProductListMutationUpdate, ProductListPaginatedResult, ProductListQuery, ProductListQueryById, RequestContext, Result } from '@reactionary/core';
+import { ProductListProvider } from '@reactionary/core';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+export declare class CommercetoolsProductListProvider extends ProductListProvider {
+    protected config: CommercetoolsConfiguration;
+    protected commercetools: CommercetoolsAPI;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyMeRequestBuilder>;
+    getById(payload: ProductListQueryById): Promise<Result<ProductList>>;
+    queryLists(payload: ProductListQuery): Promise<Result<ProductListPaginatedResult>>;
+    addList(mutation: ProductListMutationCreate): Promise<Result<ProductList>>;
+    updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductList>>;
+    deleteList(mutation: ProductListMutationDelete): Promise<Result<void>>;
+    queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListItemPaginatedResult>>;
+    addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListItem>>;
+    deleteItem(mutation: ProductListItemMutationDelete): Promise<Result<void>>;
+    updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListItem>>;
+    /**
+     * It is not clear to me, why i'd want my CUSTOMER defined resources to be localized, since that means, if he changes visual language,
+     * the names of his lists will disappear, since they are not translated. But maybe there are usecases for this, so we should support it, but default to english.
+     **/
+    protected getLocaleString(): string;
+    protected parseSingle(list: ShoppingList): ProductList;
+    protected parseProductListItem(listIdentifier: ProductListIdentifier, lineItem: ShoppingListLineItem): ProductListItem;
+}

package/src/schema/capabilities.schema.d.ts

@@ -13,6 +13,7 @@ export declare const CommercetoolsCapabilitiesSchema: z.ZodObject<{
     productSearch: z.ZodOptional<z.ZodBoolean>;
     productAssociations: z.ZodOptional<z.ZodBoolean>;
     productReviews: z.ZodOptional<z.ZodBoolean>;
+    productList: z.ZodOptional<z.ZodBoolean>;
     orderSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;

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>;