@reactionary/commercetools 0.6.3

package/capabilities/price.capability.js

@@ -0,0 +1,114 @@
+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 {
+  CustomerPriceQuerySchema,
+  ListPriceQuerySchema,
+  PriceCapability,
+  PriceSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+class CommercetoolsPriceCapability extends PriceCapability {
+  config;
+  commercetools;
+  factory;
+  constructor(config, cache, context, commercetools, factory) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+    this.factory = factory;
+  }
+  async getCustomerPrice(payload) {
+    const client = await this.getClient();
+    let priceChannelId;
+    if (this.config.customerPriceChannelKey) {
+      priceChannelId = await this.commercetools.resolveChannelIdByKey(this.config.customerPriceChannelKey);
+    } else {
+      priceChannelId = await this.commercetools.resolveChannelIdByRole("Primary");
+    }
+    const response = await client.productProjections().get({
+      queryArgs: {
+        staged: false,
+        priceCountry: this.context.taxJurisdiction.countryCode,
+        priceCustomerGroup: void 0,
+        priceChannel: priceChannelId,
+        priceCurrency: this.context.languageContext.currencyCode,
+        where: "variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ",
+        "var.skus": [payload.variant.sku],
+        limit: 1
+      }
+    }).execute();
+    const result = response.body.results[0];
+    const sku = [result.masterVariant, ...result.variants].find(
+      (x) => x.sku === payload.variant.sku
+    );
+    return success(this.factory.parsePrice(this.context, sku, { includeDiscounts: true }));
+  }
+  async getListPrice(payload) {
+    const client = await this.getClient();
+    let priceChannelId;
+    if (this.config.listPriceChannelKey) {
+      priceChannelId = await this.commercetools.resolveChannelIdByKey(this.config.listPriceChannelKey);
+    } else {
+      priceChannelId = await this.commercetools.resolveChannelIdByRole("Primary");
+    }
+    const response = await client.productProjections().get({
+      queryArgs: {
+        staged: false,
+        priceCountry: this.context.taxJurisdiction.countryCode,
+        priceCustomerGroup: void 0,
+        priceChannel: priceChannelId,
+        priceCurrency: this.context.languageContext.currencyCode,
+        where: "variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ",
+        "var.skus": [payload.variant.sku],
+        limit: 1
+      }
+    }).execute();
+    const result = response.body.results[0];
+    const sku = [result.masterVariant, ...result.variants].find(
+      (x) => x.sku === payload.variant.sku
+    );
+    return success(this.factory.parsePrice(this.context, sku));
+  }
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
+  }
+  async getChannels() {
+    const adminClient = await this.commercetools.getAdminClient();
+    const offerPriceChannelPromise = adminClient.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key: "Offer Price" }).get().execute();
+    const listPriceChannelPromise = adminClient.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key: "List Price" }).get().execute();
+    const [offerChannel, listChannel] = await Promise.all([
+      offerPriceChannelPromise,
+      listPriceChannelPromise
+    ]);
+    return {
+      offer: offerChannel.body.id,
+      list: listChannel.body.id
+    };
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: CustomerPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+], CommercetoolsPriceCapability.prototype, "getCustomerPrice", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ListPriceQuerySchema,
+    outputSchema: PriceSchema
+  })
+], CommercetoolsPriceCapability.prototype, "getListPrice", 1);
+export {
+  CommercetoolsPriceCapability
+};

package/capabilities/product-associations.capability.js

@@ -0,0 +1,120 @@
+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 {
+  ProductAssociationsCapability,
+  Reactionary,
+  success,
+  error
+} from "@reactionary/core";
+class CommercetoolsProductAssociationsCapability extends ProductAssociationsCapability {
+  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 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) {
+      associatedProductSearchItems.push(associatedProductResult.body);
+    }
+    return associatedProductSearchItems;
+  }
+  async getAccessories(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfAccessories || 4, "reactionaryaccessories");
+    const result = associatedProducts.map(
+      (product) => this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: "accessory",
+        product
+      })
+    );
+    return success(result);
+  }
+  async getSpareparts(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfSpareparts || 4, "reactionaryspareparts");
+    const result = associatedProducts.map(
+      (product) => this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: "sparepart",
+        product
+      })
+    );
+    return success(result);
+  }
+  async getReplacements(query) {
+    const associatedProducts = await this.fetchAssociatedProductsFor(query.forProduct, query.numberOfReplacements || 4, "reactionaryreplacements");
+    const result = associatedProducts.map(
+      (product) => this.factory.parseAssociation(this.context, {
+        sourceProductKey: query.forProduct.key,
+        relation: "replacement",
+        product
+      })
+    );
+    return success(result);
+  }
+}
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], CommercetoolsProductAssociationsCapability.prototype, "getAccessories", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], CommercetoolsProductAssociationsCapability.prototype, "getSpareparts", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false
+  })
+], CommercetoolsProductAssociationsCapability.prototype, "getReplacements", 1);
+export {
+  CommercetoolsProductAssociationsCapability
+};

package/capabilities/product-list.capability.js

@@ -0,0 +1,393 @@
+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,
+  ProductListCapability,
+  ProductListQueryByIdSchema,
+  ProductListQuerySchema,
+  ProductListSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+class CommercetoolsProductListCapability extends ProductListCapability {
+  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 }).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.factory.parseProductList(this.context, 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(this.factory.parseProductListPaginatedResult(this.context, {
+        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(this.factory.parseProductListPaginatedResult(this.context, {
+      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.factory.parseProductList(this.context, 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.factory.parseProductList(this.context, 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(this.factory.parseProductListItemPaginatedResult(this.context, {
+      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.factory.parseProductListItem(this.context, 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.factory.parseProductListItem(this.context, 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
+  })
+], CommercetoolsProductListCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
+    inputSchema: ProductListQuerySchema,
+    outputSchema: ProductListPaginatedResultsSchema
+  })
+], CommercetoolsProductListCapability.prototype, "queryLists", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    // Mutations should not be cached
+    inputSchema: ProductListMutationCreateSchema,
+    outputSchema: ProductListSchema
+  })
+], CommercetoolsProductListCapability.prototype, "addList", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListMutationUpdateSchema,
+    outputSchema: ProductListSchema
+  })
+], CommercetoolsProductListCapability.prototype, "updateList", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListMutationDeleteSchema
+  })
+], CommercetoolsProductListCapability.prototype, "deleteList", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
+    inputSchema: ProductListItemQuerySchema,
+    outputSchema: ProductListItemPaginatedResultsSchema
+  })
+], CommercetoolsProductListCapability.prototype, "queryListItems", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationCreateSchema,
+    outputSchema: ProductListItemSchema
+  })
+], CommercetoolsProductListCapability.prototype, "addItem", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationDeleteSchema
+  })
+], CommercetoolsProductListCapability.prototype, "deleteItem", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationUpdateSchema,
+    outputSchema: ProductListItemSchema
+  })
+], CommercetoolsProductListCapability.prototype, "updateItem", 1);
+export {
+  CommercetoolsProductListCapability
+};