@reactionary/commercetools 0.6.3

package/capabilities/product-reviews.capability.js

@@ -0,0 +1,193 @@
+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 {
+  ProductReviewsCapability,
+  Reactionary,
+  success,
+  error,
+  ProductReviewSchema,
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema
+} from "@reactionary/core";
+class CommercetoolsProductReviewsCapability extends ProductReviewsCapability {
+  config;
+  commercetools;
+  factory;
+  constructor(config, cache, context, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
+  }
+  async getAdminClient() {
+    const client = await this.commercetools.getAdminClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
+  }
+  async getRatingSummary(query) {
+    const client = await this.getClient();
+    const response = await client.productProjections().withKey({ key: query.product.key }).get().execute().catch((e) => {
+      if (e.statusCode === 404) {
+        return null;
+      }
+      throw e;
+    });
+    if (response && response.body) {
+      const summary = {
+        identifier: {
+          product: query.product
+        },
+        averageRating: 0,
+        totalRatings: 0,
+        ratingDistribution: void 0
+      };
+      if (response.body.reviewRatingStatistics) {
+        summary.averageRating = response.body.reviewRatingStatistics.averageRating;
+        summary.totalRatings = response.body.reviewRatingStatistics.count;
+        summary.ratingDistribution = {
+          "1": response.body.reviewRatingStatistics.ratingsDistribution["1"] ?? 0,
+          "2": response.body.reviewRatingStatistics.ratingsDistribution["2"] ?? 0,
+          "3": response.body.reviewRatingStatistics.ratingsDistribution["3"] ?? 0,
+          "4": response.body.reviewRatingStatistics.ratingsDistribution["4"] ?? 0,
+          "5": response.body.reviewRatingStatistics.ratingsDistribution["5"] ?? 0
+        };
+      }
+      return success(this.factory.parseRatingSummary(this.context, summary));
+    } else {
+      return success(
+        this.factory.parseRatingSummary(
+          this.context,
+          this.createEmptyProductRatingSummary({ product: query.product })
+        )
+      );
+    }
+  }
+  async findReviews(query) {
+    const client = await this.getClient();
+    const pageNumber = query.paginationOptions?.pageNumber ?? 1;
+    const pageSize = query.paginationOptions?.pageSize ?? 20;
+    const offset = (pageNumber - 1) * pageSize;
+    const product = await client.productProjections().withKey({ key: query.product.key }).get().execute().catch((e) => {
+      if (e.statusCode === 404) {
+        return null;
+      }
+      throw e;
+    });
+    if (!product || !product.body) {
+      return success(this.factory.parseReviewPaginatedResult(this.context, {
+        items: [],
+        totalCount: 0,
+        pageSize,
+        pageNumber,
+        totalPages: 0
+      }));
+    }
+    const whereClause = `target(typeId="product" and id="${product.body.id}")`;
+    const sort = ["createdAt desc"];
+    const response = await client.reviews().get({
+      queryArgs: {
+        where: whereClause,
+        limit: pageSize,
+        offset,
+        sort
+      }
+    }).execute();
+    const reviews = response.body.results.map(
+      (review) => this.parseSingle(review, query.product.key)
+    );
+    const returnedResult = {
+      items: reviews,
+      totalCount: response.body.total || reviews.length,
+      pageSize,
+      pageNumber,
+      totalPages: Math.ceil((response.body.total || reviews.length) / Math.max(pageSize, 1))
+    };
+    return success(this.factory.parseReviewPaginatedResult(this.context, returnedResult));
+  }
+  async submitReview(mutation) {
+    if (!(this.context.session.identityContext.identity.type === "Registered")) {
+      return error({ type: "InvalidInput", error: "Only registered users can submit reviews." });
+    }
+    const client = await this.getAdminClient();
+    const response = await client.reviews().post({
+      body: {
+        authorName: mutation.authorName,
+        title: mutation.title,
+        text: mutation.content,
+        rating: mutation.rating,
+        customer: {
+          typeId: "customer",
+          id: this.context.session.identityContext.identity.id.userId
+        },
+        target: {
+          typeId: "product",
+          id: mutation.product.key
+        },
+        locale: this.context.languageContext.locale
+      }
+    }).execute();
+    const review = this.parseSingle(response.body, mutation.product.key);
+    return success(this.factory.parseReview(this.context, review));
+  }
+  parseSingle(review, productKey) {
+    return {
+      identifier: {
+        key: review.key || ""
+      },
+      product: {
+        key: productKey
+      },
+      authorName: review.authorName ?? "Anonymous",
+      authorId: review.customer?.id,
+      rating: review.rating ?? 0,
+      title: review.title ?? "",
+      content: review.text ?? "",
+      createdAt: review.createdAt,
+      updatedAt: review.lastModifiedAt,
+      verified: !!review.customer
+      // Verified if linked to a customer
+    };
+  }
+}
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductRatingSummarySchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], CommercetoolsProductReviewsCapability.prototype, "getRatingSummary", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductReviewPaginatedResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 60,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], CommercetoolsProductReviewsCapability.prototype, "findReviews", 1);
+__decorateClass([
+  Reactionary({
+    outputSchema: ProductReviewSchema,
+    cache: false,
+    cacheTimeToLiveInSeconds: 0,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], CommercetoolsProductReviewsCapability.prototype, "submitReview", 1);
+export {
+  CommercetoolsProductReviewsCapability
+};

package/capabilities/product-search.capability.js

@@ -0,0 +1,297 @@
+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 {
+  FacetValueIdentifierSchema,
+  ProductSearchCapability,
+  ProductSearchQueryByTermSchema,
+  ProductSearchQueryCreateNavigationFilterSchema,
+  ProductSearchResultSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import { CommercetoolsCategoryLookupSchema, CommercetoolsResolveCategoryQueryByKeySchema } from "../schema/commercetools.schema.js";
+const debug = createDebug("reactionary:commercetools:search");
+class CommercetoolsProductSearchCapability extends ProductSearchCapability {
+  config;
+  commercetools;
+  factory;
+  constructor(config, cache, context, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey }).products();
+  }
+  async getFacetQuery(payload, selectedFacetValue) {
+    if (selectedFacetValue.facet.key === "categories") {
+      return {
+        exact: {
+          field: "categoriesSubTree",
+          values: [selectedFacetValue.key],
+          fieldType: "text"
+        }
+      };
+    }
+    return {
+      exact: {
+        field: selectedFacetValue.facet.key,
+        fieldType: "text",
+        value: selectedFacetValue.key
+      }
+    };
+  }
+  async resolveCategoryFromId(payload) {
+    const client = (await this.commercetools.getClient()).withProjectKey({ projectKey: this.config.projectKey });
+    const response = await client.categories().withId({ ID: payload.id }).get().execute();
+    if (!response.body || !response.body.name) {
+      throw new Error(`Category with ID ${payload.id} not found`);
+    }
+    const result = {
+      id: response.body.id,
+      key: response.body.key,
+      name: response.body.name,
+      meta: {
+        cache: {
+          hit: false,
+          key: "commercetools-internal-category-from-id-" + payload.id
+        },
+        placeholder: false
+      }
+    };
+    return result;
+  }
+  async resolveCategoryFromKey(payload) {
+    const client = (await this.commercetools.getClient()).withProjectKey({ projectKey: this.config.projectKey });
+    const response = await client.categories().withKey({ key: payload.key }).get().execute();
+    if (!response.body || !response.body.name) {
+      throw new Error(`Category with key ${payload.key} not found`);
+    }
+    const result = {
+      id: response.body.id,
+      key: response.body.key,
+      name: response.body.name,
+      meta: {
+        cache: {
+          hit: false,
+          key: "commercetools-internal-category-from-key-" + payload.key
+        },
+        placeholder: false
+      }
+    };
+    return result;
+  }
+  async getCategoryFilterExpression(payload) {
+    if (!payload.search.categoryFilter) {
+      return void 0;
+    }
+    if (payload.search.categoryFilter.key) {
+      return {
+        exact: {
+          field: "categoriesSubTree",
+          values: [payload.search.categoryFilter.key],
+          fieldType: "text"
+        }
+      };
+    }
+    return void 0;
+  }
+  async getSearchTermExpression(payload) {
+    if (payload.search.term.trim().length === 0 || payload.search.term === "*") {
+      return void 0;
+    }
+    return {
+      or: [
+        {
+          fullText: {
+            field: "name",
+            language: `${this.context.languageContext.locale}`,
+            value: payload.search.term
+          }
+        },
+        {
+          fullText: {
+            field: "description",
+            language: `${this.context.languageContext.locale}`,
+            value: payload.search.term
+          }
+        },
+        {
+          fullText: {
+            field: "searchKeywords",
+            language: `${this.context.languageContext.locale}`,
+            value: payload.search.term
+          }
+        }
+      ]
+    };
+  }
+  async getFacetsQuery(payload) {
+    if (payload.search.facets.length === 0) {
+      return void 0;
+    }
+    const facetsToApply = await Promise.all(
+      payload.search.facets.map((facet) => this.getFacetQuery(payload, facet))
+    );
+    if (facetsToApply.length === 0) {
+      return void 0;
+    }
+    if (facetsToApply.length === 1) {
+      return facetsToApply[0];
+    }
+    return {
+      and: facetsToApply
+    };
+  }
+  async getFacetsToReturn(payload) {
+    const facetsToReturn = [];
+    const configFacets = ["categories", ...this.config.facetFieldsForSearch];
+    for (const facet of configFacets) {
+      facetsToReturn.push({
+        distinct: {
+          name: facet,
+          field: facet,
+          fieldType: "text",
+          limit: 50
+        }
+      });
+    }
+    return facetsToReturn;
+  }
+  async createCategoryNavigationFilter(payload) {
+    const categoryPath = payload.categoryPath;
+    const deepestCategory = categoryPath[categoryPath.length - 1];
+    const resolvedCategory = await this.resolveCategoryFromKey({ key: deepestCategory.identifier.key });
+    const resolvedId = resolvedCategory?.id;
+    const facetIdentifier = {
+      key: "categories"
+    };
+    const facetValueIdentifier = {
+      facet: facetIdentifier,
+      key: resolvedId || "unknown"
+    };
+    return success(facetValueIdentifier);
+  }
+  async queryByTerm(payload) {
+    const client = await this.getClient();
+    const facetsToReturn = await this.getFacetsToReturn(payload);
+    const facetsToApply = await this.getFacetsQuery(payload);
+    const searchTermExpression = await this.getSearchTermExpression(payload);
+    const categoryFilterExpression = await this.getCategoryFilterExpression(payload);
+    let finalFilterExpression = void 0;
+    if (searchTermExpression) {
+      finalFilterExpression = searchTermExpression;
+    }
+    if (facetsToApply) {
+      if (finalFilterExpression) {
+        finalFilterExpression = {
+          and: [finalFilterExpression, facetsToApply]
+        };
+      } else {
+        finalFilterExpression = facetsToApply;
+      }
+    }
+    if (categoryFilterExpression) {
+      if (finalFilterExpression) {
+        finalFilterExpression = {
+          and: [finalFilterExpression, categoryFilterExpression]
+        };
+      } else {
+        finalFilterExpression = categoryFilterExpression;
+      }
+    }
+    const response = await client.search().post({
+      body: {
+        query: finalFilterExpression,
+        productProjectionParameters: {
+          storeProjection: this.context.storeIdentifier.key
+        },
+        limit: payload.search.paginationOptions.pageSize,
+        offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize,
+        facets: [...facetsToReturn]
+      }
+    }).execute();
+    const responseBody = response.body;
+    const result = this.factory.parseSearchResult(
+      this.context,
+      responseBody,
+      payload
+    );
+    await this.patchCategoryFacetValues(result);
+    for (const selectedFacet of payload.search.facets) {
+      const facet = result.facets.find((f) => f.identifier.key === selectedFacet.facet.key);
+      if (facet) {
+        const value = facet.values.find((v) => v.identifier.key === selectedFacet.key);
+        if (value) {
+          value.active = true;
+        }
+      }
+    }
+    if (debug.enabled) {
+      debug(
+        `Search for term "${payload.search.term}" returned ${responseBody.results.length} products (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
+      );
+    }
+    return success(result);
+  }
+  async patchCategoryFacetValues(result) {
+    const categoryFacet = result.facets.find(
+      (f) => f.identifier.key === "categories"
+    );
+    if (!categoryFacet) {
+      return;
+    }
+    const resolvedCategories = categoryFacet.values.map((facetValue) => this.resolveCategoryFromId({ id: facetValue.identifier.key }));
+    const categories = await Promise.all(resolvedCategories);
+    for (const facetValue of categoryFacet.values) {
+      try {
+        const category = categories.find((c) => c.id === facetValue.identifier.key);
+        if (!category) {
+          continue;
+        }
+        facetValue.name = category.name[this.context.languageContext.locale] || category.id;
+      } catch (error) {
+        if (debug.enabled) {
+          debug(`Error resolving category key for id ${facetValue.identifier.key}:`, error);
+        }
+      }
+    }
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CommercetoolsResolveCategoryQueryByKeySchema,
+    outputSchema: CommercetoolsCategoryLookupSchema
+  })
+], CommercetoolsProductSearchCapability.prototype, "resolveCategoryFromKey", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductSearchQueryCreateNavigationFilterSchema,
+    outputSchema: FacetValueIdentifierSchema
+  })
+], CommercetoolsProductSearchCapability.prototype, "createCategoryNavigationFilter", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductSearchQueryByTermSchema,
+    outputSchema: ProductSearchResultSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], CommercetoolsProductSearchCapability.prototype, "queryByTerm", 1);
+export {
+  CommercetoolsProductSearchCapability
+};

package/capabilities/product.capability.js

@@ -0,0 +1,103 @@
+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 {
+  ProductCapability,
+  ProductQueryByIdSchema,
+  ProductQueryBySKUSchema,
+  ProductQueryBySlugSchema,
+  ProductSchema,
+  Reactionary,
+  success,
+  error
+} from "@reactionary/core";
+class CommercetoolsProductCapability extends ProductCapability {
+  constructor(cache, context, config, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
+  }
+  async getById(payload) {
+    const client = await this.getClient();
+    const remote = await client.withKey({ key: payload.identifier.key }).get().execute();
+    const value = this.factory.parseProduct(this.context, remote.body);
+    return success(value);
+  }
+  async getBySlug(payload) {
+    const client = await this.getClient();
+    const remote = await client.get({
+      queryArgs: {
+        // FIXME: Hardcoded locale
+        where: "slug(en = :slug)",
+        "var.slug": payload.slug
+      }
+    }).execute();
+    if (remote.body.count === 0) {
+      return error({
+        type: "NotFound",
+        identifier: payload.slug
+      });
+    }
+    const result = this.factory.parseProduct(this.context, remote.body.results[0]);
+    return success(result);
+  }
+  async getBySKU(payload) {
+    const client = await this.getClient();
+    const remote = await client.get({
+      queryArgs: {
+        staged: false,
+        limit: 1,
+        where: "variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ",
+        "var.skus": [payload].map((p) => p.variant.sku)
+      }
+    }).execute();
+    const result = this.factory.parseProduct(this.context, remote.body.results[0]);
+    return success(result);
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryByIdSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], CommercetoolsProductCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryBySlugSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], CommercetoolsProductCapability.prototype, "getBySlug", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductQueryBySKUSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
+], CommercetoolsProductCapability.prototype, "getBySKU", 1);
+export {
+  CommercetoolsProductCapability
+};