@reactionary/provider-commercetools 0.0.36 → 0.0.38

package/core/initialize.js

@@ -1,10 +1,11 @@
-import { CartSchema, IdentitySchema, InventorySchema, PriceSchema, ProductSchema, SearchResultSchema } from "@reactionary/core";
+import { CartSchema, IdentitySchema, InventorySchema, PriceSchema, ProductSchema, SearchResultSchema, CategorySchema } from "@reactionary/core";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
 import { CommercetoolsProductProvider } from "../providers/product.provider";
 import { CommercetoolsIdentityProvider } from "../providers/identity.provider";
 import { CommercetoolsCartProvider } from "../providers/cart.provider";
 import { CommercetoolsInventoryProvider } from "../providers/inventory.provider";
 import { CommercetoolsPriceProvider } from "../providers/price.provider";
+import { CommercetoolsCategoryProvider } from "../providers/category.provider";
 function withCommercetoolsCapabilities(configuration, capabilities) {
   return (cache) => {
     const client = {};
@@ -26,6 +27,9 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
     if (capabilities.price) {
       client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, cache);
     }
+    if (capabilities.category) {
+      client.category = new CommercetoolsCategoryProvider(configuration, CategorySchema, cache);
+    }
     return client;
   };
 }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@reactionary/provider-commercetools",
-  "version": "0.0.36",
+  "version": "0.0.38",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.0.36",
+    "@reactionary/core": "0.0.38",
+    "@reactionary/otel": "0.0.38",
     "zod": "4.0.0-beta.20250430T185432",
     "@commercetools/ts-client": "^3.2.2",
     "@commercetools/platform-sdk": "^8.8.0"

package/providers/cart.provider.js

@@ -3,11 +3,13 @@ import {
   CartProvider
 } from "@reactionary/core";
 import { CommercetoolsClient } from "../core/client";
+import { traced } from "@reactionary/otel";
 class CommercetoolsCartProvider extends CartProvider {
   constructor(config, schema, cache) {
     super(schema, cache);
     this.config = config;
   }
+  @traced()
   async getById(payload, session) {
     if (!payload.cart.key) {
       const result = this.newModel();
@@ -19,8 +21,9 @@ class CommercetoolsCartProvider extends CartProvider {
     }
     const client = this.getClient(session);
     const remote = await client.withId({ ID: payload.cart.key }).get().execute();
-    return this.composeCart(remote.body);
+    return this.parseSingle(remote.body, session);
   }
+  @traced()
   async add(payload, session) {
     const client = this.getClient(session);
     let id = payload.cart.key;
@@ -28,8 +31,9 @@ class CommercetoolsCartProvider extends CartProvider {
     if (!id) {
       const remoteCart = await client.post({
         body: {
-          currency: "USD",
-          country: "US"
+          currency: session.languageContext.currencyCode || "USD",
+          country: session.languageContext.countryCode || "US",
+          locale: session.languageContext.locale
         }
       }).execute();
       id = remoteCart.body.id;
@@ -50,8 +54,9 @@ class CommercetoolsCartProvider extends CartProvider {
         ]
       }
     }).execute();
-    return this.composeCart(remoteAdd.body);
+    return this.parseSingle(remoteAdd.body, session);
   }
+  @traced()
   async remove(payload, session) {
     const client = this.getClient(session);
     const existing = await client.withId({ ID: payload.cart.key }).get().execute();
@@ -66,8 +71,9 @@ class CommercetoolsCartProvider extends CartProvider {
         ]
       }
     }).execute();
-    return this.composeCart(remote.body);
+    return this.parseSingle(remote.body, session);
   }
+  @traced()
   async changeQuantity(payload, session) {
     const client = this.getClient(session);
     const existing = await client.withId({ ID: payload.cart.key }).get().execute();
@@ -83,8 +89,9 @@ class CommercetoolsCartProvider extends CartProvider {
         ]
       }
     }).execute();
-    return this.composeCart(remote.body);
+    return this.parseSingle(remote.body, session);
   }
+  @traced()
   getClient(session) {
     const client = new CommercetoolsClient(this.config).getClient(
       session.identity.token
@@ -92,18 +99,76 @@ class CommercetoolsCartProvider extends CartProvider {
     const cartClient = client.withProjectKey({ projectKey: this.config.projectKey }).carts();
     return cartClient;
   }
-  composeCart(remote) {
+  @traced()
+  parseSingle(remote, session) {
     const result = this.newModel();
     result.identifier.key = remote.id;
+    result.name = remote.custom?.fields["name"] || "";
+    result.description = remote.custom?.fields["description"] || "";
+    const grandTotal = remote.totalPrice.centAmount || 0;
+    const shippingTotal = remote.shippingInfo?.price.centAmount || 0;
+    const productTotal = grandTotal - shippingTotal;
+    const taxTotal = remote.taxedPrice?.totalTax?.centAmount || 0;
+    const discountTotal = remote.discountOnTotalPrice?.discountedAmount.centAmount || 0;
+    const surchargeTotal = 0;
+    const currency = remote.totalPrice.currencyCode;
+    result.price = {
+      totalTax: {
+        value: taxTotal / 100,
+        currency
+      },
+      totalDiscount: {
+        value: discountTotal / 100,
+        currency
+      },
+      totalSurcharge: {
+        value: surchargeTotal / 100,
+        currency
+      },
+      totalShipping: {
+        value: shippingTotal / 100,
+        currency: remote.shippingInfo?.price.currencyCode
+      },
+      totalProductPrice: {
+        value: productTotal / 100,
+        currency
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency
+      }
+    };
     for (const remoteItem of remote.lineItems) {
       const item = CartItemSchema.parse({});
       item.identifier.key = remoteItem.id;
       item.product.key = remoteItem.productId;
       item.quantity = remoteItem.quantity;
+      const unitPrice = remoteItem.price.value.centAmount;
+      const totalPrice = remoteItem.totalPrice.centAmount || 0;
+      const totalDiscount = remoteItem.price.discounted?.value.centAmount || 0;
+      const unitDiscount = totalDiscount / remoteItem.quantity;
+      item.price = {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency
+        },
+        unitDiscount: {
+          value: unitDiscount / 100,
+          currency
+        },
+        totalPrice: {
+          value: (totalPrice || 0) / 100,
+          currency
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency
+        }
+      };
       result.items.push(item);
     }
     result.meta = {
-      cache: { hit: false, key: remote.id },
+      cache: { hit: false, key: this.generateCacheKeySingle(result.identifier, session) },
       placeholder: false
     };
     return this.assert(result);

package/providers/category.provider.js

@@ -0,0 +1,167 @@
+import { CategoryProvider, createPaginatedResponseSchema } from "@reactionary/core";
+import { CommercetoolsClient } from "../core/client";
+import { traced } from "@reactionary/otel";
+class CommercetoolsCategoryProvider extends CategoryProvider {
+  constructor(config, schema, cache) {
+    super(schema, cache);
+    this.config = config;
+  }
+  getClient(session) {
+    const client = new CommercetoolsClient(this.config).getClient(session.identity.token).withProjectKey({ projectKey: this.config.projectKey }).categories();
+    return client;
+  }
+  @traced()
+  async getById(payload, session) {
+    const client = this.getClient(session);
+    try {
+      const response = await client.withKey({ key: payload.id.key }).get().execute();
+      return this.parseSingle(response.body, session);
+    } catch (error) {
+      console.error(`Error fetching category by ID ${payload.id.key}:`, error);
+      const dummyCategory = this.newModel();
+      dummyCategory.meta.placeholder = true;
+      dummyCategory.identifier = { key: payload.id.key };
+      return dummyCategory;
+    }
+  }
+  @traced()
+  async getBySlug(payload, session) {
+    const client = this.getClient(session);
+    try {
+      const response = await client.get({
+        queryArgs: {
+          where: `slug(${session.languageContext.locale}=:slug)`,
+          "var.slug": payload.slug,
+          storeProjection: session.storeIdentifier.key,
+          limit: 1,
+          withTotal: false
+        }
+      }).execute();
+      if (response.body.results.length === 0) {
+        return null;
+      }
+      return this.parseSingle(response.body.results[0], session);
+    } catch (error) {
+      console.error(`Error fetching category by slug:`, error);
+      return null;
+    }
+  }
+  @traced()
+  async getBreadcrumbPathToCategory(payload, session) {
+    const client = this.getClient(session);
+    const path = [];
+    try {
+      const response = await client.withKey({ key: payload.id.key }).get({
+        queryArgs: {
+          expand: "ancestors[*]"
+        }
+      }).execute();
+      const category = this.parseSingle(response.body, session);
+      for (const anc of response.body.ancestors || []) {
+        if (anc.obj) {
+          const parsedAnc = this.parseSingle(anc.obj, session);
+          path.push(parsedAnc);
+        }
+      }
+      ;
+      path.push(category);
+    } catch (error) {
+      console.error(`Error fetching category path for  ${payload.id.key}:`, error);
+    }
+    return path;
+  }
+  @traced()
+  async findChildCategories(payload, session) {
+    const client = this.getClient(session);
+    try {
+      const parentCategory = await client.withKey({ key: payload.parentId.key }).get().execute();
+      const response = await client.get({
+        queryArgs: {
+          where: "parent(id = :parentId)",
+          "var.parentId": parentCategory.body.id,
+          limit: payload.paginationOptions.pageSize,
+          offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize,
+          sort: "orderHint asc",
+          storeProjection: session.storeIdentifier.key
+        }
+      }).execute();
+      const result = this.parsePaginatedResult(response.body, session);
+      result.meta = {
+        cache: { hit: false, key: this.generateCacheKeyPaginatedResult("children-of-" + payload.parentId.key, result, session) },
+        placeholder: false
+      };
+      return result;
+    } catch (error) {
+      console.error(`Error fetching category path for  ${payload.parentId.key}:`, error);
+    }
+    return createPaginatedResponseSchema(this.schema).parse({});
+  }
+  @traced()
+  async findTopCategories(payload, session) {
+    const client = this.getClient(session);
+    try {
+      const response = await client.get({
+        queryArgs: {
+          where: "parent is not defined",
+          limit: payload.paginationOptions.pageSize,
+          offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize,
+          sort: "orderHint asc",
+          storeProjection: session.storeIdentifier.key
+        }
+      }).execute();
+      const result = this.parsePaginatedResult(response.body, session);
+      result.meta = {
+        cache: { hit: false, key: this.generateCacheKeyPaginatedResult("top", result, session) },
+        placeholder: false
+      };
+      return result;
+    } catch (error) {
+      console.error(`Error fetching category top categories:`, error);
+    }
+    return createPaginatedResponseSchema(this.schema).parse({});
+  }
+  @traced()
+  parseSingle(_body, session) {
+    const body = _body;
+    const languageContext = session.languageContext;
+    const model = this.newModel();
+    model.identifier = { key: body.key };
+    model.name = body.name[languageContext.locale] || "No Name";
+    model.slug = body.slug ? body.slug[languageContext.locale] || "" : "";
+    model.text = body.description ? body.description[languageContext.locale] || "" : "";
+    model.parentCategory = body.parent && body.parent.obj && body.parent.obj?.key ? { key: body.parent.obj.key } : void 0;
+    model.images = (body.assets || []).filter((asset) => asset.sources.length > 0).filter((x) => x.sources[0].contentType?.startsWith("image/")).map((asset) => {
+      return {
+        sourceUrl: asset.sources[0].uri,
+        altText: asset.description?.[languageContext.locale] || asset.name[languageContext.locale] || "",
+        height: asset.sources[0].dimensions?.h || 0,
+        width: asset.sources[0].dimensions?.w || 0
+      };
+    });
+    model.meta = {
+      cache: { hit: false, key: this.generateCacheKeySingle(model.identifier, session) },
+      placeholder: false
+    };
+    return this.assert(model);
+  }
+  @traced()
+  parsePaginatedResult(_body, session) {
+    const body = _body;
+    const items = body.results.map((x) => this.parseSingle(x, session));
+    const result = createPaginatedResponseSchema(this.schema).parse({
+      meta: {
+        cache: { hit: false, key: "unknown" },
+        placeholder: false
+      },
+      pageNumber: Math.floor(body.offset / body.count) + 1,
+      pageSize: body.count,
+      totalCount: body.total || 0,
+      totalPages: Math.ceil((body.total ?? 0) / body.count),
+      items
+    });
+    return result;
+  }
+}
+export {
+  CommercetoolsCategoryProvider
+};

package/providers/index.js

@@ -0,0 +1,7 @@
+export * from "./cart.provider";
+export * from "./category.provider";
+export * from "./identity.provider";
+export * from "./inventory.provider";
+export * from "./price.provider";
+export * from "./product.provider";
+export * from "./search.provider";

package/providers/inventory.provider.js

@@ -13,20 +13,32 @@ class CommercetoolsInventoryProvider extends InventoryProvider {
     );
     const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).inventory().get({
       queryArgs: {
-        where: "sku=:sku",
-        "var.sku": payload.sku
+        where: `sku=${payload.sku}`
       }
     }).execute();
-    const base = this.newModel();
-    if (remote.body.results.length > 0) {
-      const inv = remote.body.results[0];
-      base.quantity = inv.availableQuantity;
+    return this.parseSingle(remote.body, session);
+  }
+  parseSingle(_body, session) {
+    const body = _body;
+    const model = this.newModel();
+    model.identifier = {
+      sku: { key: body.sku },
+      channelId: {
+        key: body.supplyChannel?.id || "online"
+      }
+    };
+    model.sku = body.sku;
+    model.quantity = body.availableQuantity;
+    if (model.quantity > 0) {
+      model.status = "inStock";
+    } else {
+      model.status = "outOfStock";
     }
-    base.meta = {
-      cache: { hit: false, key: payload.sku },
+    model.meta = {
+      cache: { hit: false, key: this.generateCacheKeySingle(model.identifier, session) },
       placeholder: false
     };
-    return this.assert(base);
+    return this.assert(model);
   }
 }
 export {

package/providers/price.provider.js

@@ -1,36 +1,74 @@
-import { PriceProvider } from "@reactionary/core";
+import { PriceProvider, TieredPriceSchema } from "@reactionary/core";
 import { CommercetoolsClient } from "../core/client";
 class CommercetoolsPriceProvider extends PriceProvider {
   constructor(config, schema, cache) {
     super(schema, cache);
     this.config = config;
   }
+  getClient(session) {
+    return new CommercetoolsClient(this.config).getClient(session.identity?.token).withProjectKey({ projectKey: this.config.projectKey }).standalonePrices();
+  }
+  async getBySKUs(payload, session) {
+    const client = this.getClient(session);
+    const queryArgs = {
+      where: "sku in (:skus)",
+      "var.skus": payload.map((p) => p.sku.key)
+    };
+    const response = await client.get({
+      queryArgs
+    }).execute();
+    const result = [];
+    for (const p of payload) {
+      const matched = response.body.results.filter((x) => x.sku === p.sku.key && x.value.currencyCode === session.languageContext.currencyCode);
+      if (matched && matched.length > 0) {
+        result.push(this.parseSingle(matched[0], session));
+      } else {
+        result.push(this.getEmptyPriceResult(p.sku.key, session.languageContext.currencyCode));
+      }
+    }
+    return result;
+  }
   async getBySKU(payload, session) {
-    const client = new CommercetoolsClient(this.config).getClient(
-      session.identity?.token
-    );
+    const client = this.getClient(session);
     const queryArgs = {
       where: "sku=:sku",
       "var.sku": payload.sku.key
     };
-    const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).standalonePrices().get({
+    const remote = await client.get({
       queryArgs
     }).execute();
+    const matched = remote.body.results.filter((x) => x.value.currencyCode === session.languageContext.currencyCode);
+    if (matched && matched.length > 0) {
+      return this.parseSingle(matched[0], session);
+    }
+    return this.getEmptyPriceResult(payload.sku.key, session.languageContext.currencyCode);
+  }
+  parseSingle(_body, session) {
+    const body = _body;
     const base = this.newModel();
-    if (remote.body.results.length > 0) {
-      const matched = remote.body.results[0];
-      base.value = {
-        cents: matched.value.centAmount,
-        currency: "USD"
-      };
+    base.unitPrice = {
+      value: body.value.centAmount / 100,
+      currency: body.value.currencyCode
+    };
+    if (body.tiers && body.tiers.length > 0) {
+      const p = body.tiers.map((x) => {
+        const tp = TieredPriceSchema.parse({});
+        tp.minimumQuantity = x.minimumQuantity;
+        tp.price = {
+          value: x.value.centAmount / 100,
+          currency: x.value.currencyCode
+        };
+        return tp;
+      });
+      base.tieredPrices = p;
     }
     base.identifier = {
       sku: {
-        key: payload.sku.key
+        key: body.sku
       }
     };
     base.meta = {
-      cache: { hit: false, key: payload.sku.key },
+      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, session) },
       placeholder: false
     };
     return this.assert(base);

package/providers/product.provider.js

@@ -7,14 +7,17 @@ class CommercetoolsProductProvider extends ProductProvider {
     super(schema, cache);
     this.config = config;
   }
-  async getById(payload, _session) {
-    const client = new CommercetoolsClient(this.config).createAnonymousClient();
-    const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).productProjections().withId({ ID: payload.id }).get().execute();
-    return this.parse(remote.body);
+  getClient(session) {
+    return new CommercetoolsClient(this.config).getClient(session.identity?.token).withProjectKey({ projectKey: this.config.projectKey }).productProjections();
   }
-  async getBySlug(payload, _session) {
-    const client = new CommercetoolsClient(this.config).createAnonymousClient();
-    const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).productProjections().get({
+  async getById(payload, session) {
+    const client = this.getClient(session);
+    const remote = await client.withId({ ID: payload.id }).get().execute();
+    return this.parseSingle(remote.body, session);
+  }
+  async getBySlug(payload, session) {
+    const client = this.getClient(session);
+    const remote = await client.get({
       queryArgs: {
         where: "slug(en-US = :slug)",
         "var.slug": payload.slug
@@ -23,15 +26,16 @@ class CommercetoolsProductProvider extends ProductProvider {
     if (remote.body.results.length === 0) {
       throw new Error(`Product with slug '${payload.slug}' not found`);
     }
-    return this.parse(remote.body.results[0]);
+    return this.parseSingle(remote.body.results[0], session);
   }
-  parse(data) {
+  parseSingle(dataIn, session) {
+    const data = dataIn;
     const base = this.newModel();
     base.identifier = { key: data.id };
-    base.name = data.name["en-US"];
-    base.slug = data.slug["en-US"];
+    base.name = data.name[session.languageContext.locale];
+    base.slug = data.slug[session.languageContext.locale];
     if (data.description) {
-      base.description = data.description["en-US"];
+      base.description = data.description[session.languageContext.locale];
     }
     if (data.masterVariant.images && data.masterVariant.images.length > 0) {
       base.image = data.masterVariant.images[0].url;
@@ -48,7 +52,7 @@ class CommercetoolsProductProvider extends ProductProvider {
       }
     }
     base.meta = {
-      cache: { hit: false, key: data.id },
+      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, session) },
       placeholder: false
     };
     return this.assert(base);

package/providers/search.provider.js

@@ -7,26 +7,26 @@ class CommercetoolsSearchProvider extends SearchProvider {
     super(schema, cache);
     this.config = config;
   }
-  async queryByTerm(payload, _session) {
+  async queryByTerm(payload, session) {
     const client = new CommercetoolsClient(this.config).createAnonymousClient();
     const remote = await client.withProjectKey({ projectKey: this.config.projectKey }).productProjections().search().get({
       queryArgs: {
         limit: payload.search.pageSize,
-        offset: payload.search.pageSize * payload.search.page,
-        ["text.en-US"]: payload.search.term
+        offset: (payload.search.page - 1) * payload.search.pageSize,
+        [`text.${session.languageContext.locale}`]: payload.search.term
       }
     }).execute();
-    return this.parseSearchResult(remote, payload);
+    return this.parseSearchResult(remote, payload, session);
   }
-  parseSearchResult(remote, payload) {
+  parseSearchResult(remote, payload, session) {
     const result = this.newModel();
     const remoteData = remote;
     result.identifier = payload.search;
     for (const p of remoteData.body.results) {
       const product = {
         identifier: { key: p.id },
-        name: p.name["en-US"],
-        slug: p.slug?.["en-US"] || p.id,
+        name: p.name[session.languageContext.locale] || p.id,
+        slug: p.slug?.[session.languageContext.locale] || p.id,
         image: p.masterVariant.images?.[0]?.url || "https://placehold.co/400"
       };
       result.products.push(product);

package/schema/capabilities.schema.js

@@ -5,7 +5,8 @@ const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   identity: true,
   cart: true,
   inventory: true,
-  price: true
+  price: true,
+  category: true
 }).partial();
 export {
   CommercetoolsCapabilitiesSchema

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

@@ -10,5 +10,5 @@ export declare class CommercetoolsCartProvider<T extends Cart = Cart> extends Ca
     remove(payload: CartMutationItemRemove, session: Session): Promise<T>;
     changeQuantity(payload: CartMutationItemQuantityChange, session: Session): Promise<T>;
     protected getClient(session: Session): import("@commercetools/platform-sdk").ByProjectKeyCartsRequestBuilder;
-    protected composeCart(remote: CTCart): T;
+    protected parseSingle(remote: CTCart, session: Session): T;
 }

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

@@ -0,0 +1,95 @@
+import { CategoryProvider, Cache, Category, Session, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "@reactionary/core";
+import z from "zod";
+import { CommercetoolsConfiguration } from "../schema/configuration.schema";
+import { ByProjectKeyCategoriesRequestBuilder } from "@commercetools/platform-sdk";
+export declare class CommercetoolsCategoryProvider<T extends Category = Category> extends CategoryProvider<T> {
+    protected config: CommercetoolsConfiguration;
+    constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    protected getClient(session: Session): ByProjectKeyCategoriesRequestBuilder;
+    /**
+     * Look it up by the category ID (key in commercetools), and if not there, return a placeholder.
+     * @param id
+     * @param session
+     * @returns
+     */
+    getById(payload: CategoryQueryById, session: Session): Promise<T>;
+    /**
+     * Resolve the category by slug, in the users current locale.
+     * @param slug
+     * @param session
+     * @returns
+     */
+    getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null>;
+    /**
+     * Returns the breadcrumb path to the category, i.e. all parents up to the root.
+     * The returned order is from root to leaf.
+     * @param id
+     * @param session
+     * @returns
+     */
+    getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]>;
+    /**
+     * Returns a page of child categories for the given parent category ID.
+     * You must provide the pagination options to control the size of the result set.
+     * If you expect your frontend will load many many categories, consider adding a "load more" button, or lazy load the next page.
+     *
+     * This is cached by ID + page number + page size + locale + store
+     * @param id
+     * @param paginationOptions
+     * @param session
+     * @returns
+     */
+    findChildCategories(payload: CategoryQueryForChildCategories, session: Session): Promise<{
+        meta: {
+            [x: string]: unknown;
+            cache: {
+                [x: string]: unknown;
+                hit: boolean;
+                key: string;
+            };
+            placeholder: boolean;
+        };
+        pageNumber: number;
+        pageSize: number;
+        totalCount: number;
+        totalPages: number;
+        items: T[];
+    }>;
+    findTopCategories(payload: CategoryQueryForTopCategories, session: Session): Promise<{
+        meta: {
+            [x: string]: unknown;
+            cache: {
+                [x: string]: unknown;
+                hit: boolean;
+                key: string;
+            };
+            placeholder: boolean;
+        };
+        pageNumber: number;
+        pageSize: number;
+        totalCount: number;
+        totalPages: number;
+        items: T[];
+    }>;
+    /**
+   * Handler for parsing a response from a remote provider and converting it
+   * into the typed domain model.
+   */
+    protected parseSingle(_body: unknown, session: Session): T;
+    protected parsePaginatedResult(_body: unknown, session: Session): {
+        meta: {
+            [x: string]: unknown;
+            cache: {
+                [x: string]: unknown;
+                hit: boolean;
+                key: string;
+            };
+            placeholder: boolean;
+        };
+        pageNumber: number;
+        pageSize: number;
+        totalCount: number;
+        totalPages: number;
+        items: T[];
+    };
+}

package/src/providers/index.d.ts

@@ -0,0 +1,7 @@
+export * from './cart.provider';
+export * from './category.provider';
+export * from './identity.provider';
+export * from './inventory.provider';
+export * from './price.provider';
+export * from './product.provider';
+export * from './search.provider';

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

@@ -5,4 +5,5 @@ export declare class CommercetoolsInventoryProvider<T extends Inventory = Invent
     protected config: CommercetoolsConfiguration;
     constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
     getBySKU(payload: InventoryQuery, session: Session): Promise<T>;
+    protected parseSingle(_body: unknown, session: Session): T;
 }

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

@@ -4,5 +4,8 @@ import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 export declare class CommercetoolsPriceProvider<T extends Price = Price> extends PriceProvider<T> {
     protected config: CommercetoolsConfiguration;
     constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
+    getClient(session: Session): import("@commercetools/platform-sdk").ByProjectKeyStandalonePricesRequestBuilder;
+    getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]>;
     getBySKU(payload: PriceQueryBySku, session: Session): Promise<T>;
+    protected parseSingle(_body: unknown, session: Session): T;
 }

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

@@ -1,11 +1,11 @@
 import { ProductProvider, Product, ProductQueryById, ProductQueryBySlug, Session, Cache } from '@reactionary/core';
 import { z } from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
-import { ProductProjection } from '@commercetools/platform-sdk';
 export declare class CommercetoolsProductProvider<T extends Product = Product> extends ProductProvider<T> {
     protected config: CommercetoolsConfiguration;
     constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
-    getById(payload: ProductQueryById, _session: Session): Promise<T>;
-    getBySlug(payload: ProductQueryBySlug, _session: Session): Promise<T>;
-    protected parse(data: ProductProjection): T;
+    getClient(session: Session): import("@commercetools/platform-sdk").ByProjectKeyProductProjectionsRequestBuilder;
+    getById(payload: ProductQueryById, session: Session): Promise<T>;
+    getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T>;
+    protected parseSingle(dataIn: unknown, session: Session): T;
 }

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

@@ -4,6 +4,6 @@ import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 export declare class CommercetoolsSearchProvider<T extends SearchResult = SearchResult> extends SearchProvider<T> {
     protected config: CommercetoolsConfiguration;
     constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache);
-    queryByTerm(payload: SearchQueryByTerm, _session: Session): Promise<T>;
-    protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm): T;
+    queryByTerm(payload: SearchQueryByTerm, session: Session): Promise<T>;
+    protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm, session: Session): T;
 }

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

@@ -1,13 +1,14 @@
 import { z } from 'zod';
 export declare const CommercetoolsCapabilitiesSchema: z.ZodInterface<{
     identity: z.ZodOptional<z.ZodBoolean>;
-    search: z.ZodOptional<z.ZodBoolean>;
     product: z.ZodOptional<z.ZodBoolean>;
-    cart: z.ZodOptional<z.ZodBoolean>;
+    search: z.ZodOptional<z.ZodBoolean>;
     price: z.ZodOptional<z.ZodBoolean>;
+    cart: z.ZodOptional<z.ZodBoolean>;
     inventory: z.ZodOptional<z.ZodBoolean>;
+    category: z.ZodOptional<z.ZodBoolean>;
 }, {
-    optional: "identity" | "search" | "product" | "cart" | "price" | "inventory";
+    optional: "identity" | "product" | "search" | "price" | "cart" | "inventory" | "category";
     defaulted: never;
     extra: Record<string, unknown>;
 }>;