@reactionary/provider-commercetools 0.3.14 → 0.3.16

package/core/initialize.js

@@ -17,7 +17,9 @@ import {
   CommercetoolsOrderSearchProvider,
   CommercetoolsProfileProvider,
   CommercetoolsStoreProvider,
-  CommercetoolsProductReviewsProvider
+  CommercetoolsProductReviewsProvider,
+  CommercetoolsProductAssociationsProvider,
+  CommercetoolsProductListProvider
 } from "../providers/index.js";
 import { CommercetoolsAPI } from "./client.js";
 function withCommercetoolsCapabilities(configuration, capabilities) {
@@ -50,6 +52,22 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
         commercetoolsApi
       );
     }
+    if (caps.productAssociations) {
+      client.productAssociations = new CommercetoolsProductAssociationsProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
+    if (caps.productList) {
+      client.productList = new CommercetoolsProductListProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
     if (caps.productReviews) {
       client.productReviews = new CommercetoolsProductReviewsProvider(
         config,

package/index.js

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

package/package.json

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

package/providers/index.js

@@ -4,6 +4,8 @@ export * from "./identity.provider.js";
 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/product-associations.provider.js

@@ -0,0 +1,164 @@
+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 {
+  ProductAssociationsProvider,
+  Reactionary,
+  ImageSchema,
+  ProductVariantOptionSchema,
+  ProductOptionIdentifierSchema,
+  ProductSearchResultItemVariantSchema,
+  ProductVariantIdentifierSchema,
+  success,
+  error
+} from "@reactionary/core";
+class CommercetoolsProductAssociationsProvider extends ProductAssociationsProvider {
+  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 });
+  }
+  async fetchAssociatedProductsFor(productKey, maxNumberOfAssociations, attributeName) {
+    const client = await this.getClient();
+    const product = await client.productProjections().withKey({ key: productKey.key }).get().execute().catch((e) => {
+      if (e.statusCode === 404) {
+        return null;
+      }
+      throw e;
+    });
+    if (!product || !product.body) {
+      return [];
+    }
+    const associatedProducts = [];
+    const associationsAttr = product.body.attributes.find((attr) => attr.name === attributeName);
+    if (!associationsAttr) {
+      return [];
+    }
+    const associatedProductSearchItems = [];
+    const allAssociatedProductPromises = associationsAttr.value.map(async (associatedProductId) => {
+      const associatedProduct = client.productProjections().withKey({ key: associatedProductId }).get().execute().catch(() => null);
+      return associatedProduct;
+    });
+    const associatedProductsResults = await Promise.all(allAssociatedProductPromises);
+    const validAssociatedProductsResults = associatedProductsResults.filter((result) => !!result).slice(0, maxNumberOfAssociations);
+    for (const associatedProductResult of validAssociatedProductsResults) {
+      const resultItem = this.parseSingle(associatedProductResult.body);
+      if (resultItem) {
+        associatedProductSearchItems.push(resultItem);
+      }
+    }
+    return associatedProductSearchItems;
+  }
+  parseSingle(body) {
+    const identifier = { key: body.id };
+    const name = body.name[this.context.languageContext.locale] || body.id;
+    const slug = body.slug?.[this.context.languageContext.locale] || body.id;
+    const variants = [body.masterVariant, ...body.variants].map(
+      (variant) => this.parseVariant(variant, body)
+    );
+    const product = {
+      identifier,
+      name,
+      slug,
+      variants
+    };
+    return product;
+  }
+  async getAccessories(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfAccessories || 4, "reactionaryaccessories");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-accessory-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result);
+  }
+  async getSpareparts(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfSpareparts || 4, "reactionaryspareparts");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-sparepart-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result);
+  }
+  async getReplacements(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfReplacements || 4, "reactionaryreplacements");
+    const result = associatedProducts.map((product) => ({
+      associationIdentifier: {
+        key: `${query.forProduct.key}-replacement-${product.identifier.key}`
+      },
+      associationReturnType: "productSearchResultItem",
+      product
+    }));
+    return success(result);
+  }
+  parseVariant(variant, product) {
+    const sourceImage = variant.images?.[0];
+    const img = ImageSchema.parse({
+      sourceUrl: sourceImage?.url || "",
+      height: sourceImage?.dimensions.h || void 0,
+      width: sourceImage?.dimensions.w || void 0,
+      altText: sourceImage?.label || product.name[this.context.languageContext.locale] || void 0
+    });
+    const mappedOptions = variant.attributes?.filter((x) => x.name === "Color").map(
+      (opt) => ProductVariantOptionSchema.parse({
+        identifier: ProductOptionIdentifierSchema.parse({
+          key: opt.name
+        }),
+        name: opt.value || ""
+      })
+    ) || [];
+    const mappedOption = mappedOptions?.[0];
+    return ProductSearchResultItemVariantSchema.parse({
+      variant: ProductVariantIdentifierSchema.parse({
+        sku: variant.sku || ""
+      }),
+      image: img,
+      options: mappedOption
+    });
+  }
+}
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], CommercetoolsProductAssociationsProvider.prototype, "getAccessories", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], CommercetoolsProductAssociationsProvider.prototype, "getSpareparts", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], CommercetoolsProductAssociationsProvider.prototype, "getReplacements", 1);
+export {
+  CommercetoolsProductAssociationsProvider
+};

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

@@ -80,7 +80,12 @@ class CommercetoolsProductProvider extends ProductProvider {
       description = data.description[this.context.languageContext.locale];
     }
     const variantLevelAttributes = data.masterVariant.attributes?.map((x) => this.parseAttribute(x)) || [];
-    const productLevelAttributes = data.attributes.map((x) => this.parseAttribute(x)) || [];
+    const specialAttributes = [
+      "reactionaryaccessories",
+      "reactionaryspareparts",
+      "reactionaryreplacements"
+    ];
+    const productLevelAttributes = data.attributes.filter((x) => !specialAttributes.includes(x.name)).map((x) => this.parseAttribute(x)) || [];
     const sharedAttributes = [
       ...productLevelAttributes,
       ...variantLevelAttributes

package/schema/capabilities.schema.js

@@ -2,7 +2,9 @@ import { CapabilitiesSchema } from "@reactionary/core";
 const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   product: true,
   productSearch: true,
+  productAssociations: true,
   productReviews: true,
+  productList: true,
   identity: true,
   cart: true,
   checkout: true,

package/src/index.d.ts

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

package/src/providers/index.d.ts

@@ -4,6 +4,8 @@ export * from './identity.provider.js';
 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/product-associations.provider.d.ts

@@ -0,0 +1,24 @@
+import { ProductAssociationsProvider } from '@reactionary/core';
+import type { ProductIdentifier, ProductAssociation, ProductSearchResultItem, ProductSearchResultItemVariant, ProductAssociationsGetAccessoriesQuery, ProductAssociationsGetSparepartsQuery, ProductAssociationsGetReplacementsQuery, Result, RequestContext, Cache } from '@reactionary/core';
+import type { ProductProjection, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+export declare class CommercetoolsProductAssociationsProvider extends ProductAssociationsProvider {
+    protected config: CommercetoolsConfiguration;
+    protected commercetools: CommercetoolsAPI;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyRequestBuilder>;
+    protected fetchAssociatedProductsFor(productKey: ProductIdentifier, maxNumberOfAssociations: number, attributeName: string): Promise<ProductSearchResultItem[]>;
+    protected parseSingle(body: ProductProjection): {
+        identifier: {
+            key: string;
+        };
+        name: string;
+        slug: string;
+        variants: ProductSearchResultItemVariant[];
+    };
+    getAccessories(query: ProductAssociationsGetAccessoriesQuery): Promise<Result<ProductAssociation[]>>;
+    getSpareparts(query: ProductAssociationsGetSparepartsQuery): Promise<Result<ProductAssociation[]>>;
+    getReplacements(query: ProductAssociationsGetReplacementsQuery): Promise<Result<ProductAssociation[]>>;
+    protected parseVariant(variant: CTProductVariant, product: ProductProjection): ProductSearchResultItemVariant;
+}

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

@@ -11,7 +11,9 @@ export declare const CommercetoolsCapabilitiesSchema: z.ZodObject<{
     profile: z.ZodOptional<z.ZodBoolean>;
     store: z.ZodOptional<z.ZodBoolean>;
     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>;