@reactionary/provider-commercetools 0.3.13 → 0.3.15

package/core/initialize.js

@@ -17,7 +17,8 @@ import {
   CommercetoolsOrderSearchProvider,
   CommercetoolsProfileProvider,
   CommercetoolsStoreProvider,
-  CommercetoolsProductReviewsProvider
+  CommercetoolsProductReviewsProvider,
+  CommercetoolsProductAssociationsProvider
 } from "../providers/index.js";
 import { CommercetoolsAPI } from "./client.js";
 function withCommercetoolsCapabilities(configuration, capabilities) {
@@ -50,6 +51,14 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
         commercetoolsApi
       );
     }
+    if (caps.productAssociations) {
+      client.productAssociations = new CommercetoolsProductAssociationsProvider(
+        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.13",
+  "version": "0.3.15",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.13",
+    "@reactionary/core": "0.3.15",
     "debug": "^4.4.3",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.2.1",

package/providers/index.js

@@ -4,6 +4,7 @@ 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.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.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,6 +2,7 @@ import { CapabilitiesSchema } from "@reactionary/core";
 const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   product: true,
   productSearch: true,
+  productAssociations: true,
   productReviews: true,
   identity: true,
   cart: 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,7 @@ 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.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/schema/capabilities.schema.d.ts

@@ -11,6 +11,7 @@ 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>;
     orderSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;