@reactionary/hcl 0.9.12 → 0.9.14

package/capabilities/product-list.capability.js

@@ -0,0 +1,665 @@
+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 {
+  ProductListCapability,
+  ProductListItemMutationCreateSchema,
+  ProductListItemMutationDeleteSchema,
+  ProductListItemMutationUpdateSchema,
+  ProductListItemPaginatedResultsSchema,
+  ProductListItemQuerySchema,
+  ProductListItemSchema,
+  ProductListMutationCreateSchema,
+  ProductListMutationDeleteSchema,
+  ProductListMutationUpdateSchema,
+  ProductListPaginatedResultsSchema,
+  ProductListQueryByIdSchema,
+  ProductListQuerySchema,
+  ProductListSchema,
+  Reactionary,
+  error,
+  success
+} from "@reactionary/core";
+import createDebug from "debug";
+import { encodeWishlistType } from "../factories/product-list/product-list.factory.js";
+const debug = createDebug("reactionary:hcl:product-list");
+function isRequisitionList(listType) {
+  return listType === "requisition";
+}
+class HclProductListCapability extends ProductListCapability {
+  config;
+  client;
+  factory;
+  constructor(cache, context, config, client, factory) {
+    super(cache, context);
+    this.config = config;
+    this.client = client;
+    this.factory = factory;
+  }
+  /**
+   * Returns the factory cast to include the HCL-specific requisition list parse methods.
+   * Subclasses can override this if they provide a custom factory.
+   */
+  get requisitionFactory() {
+    return this.factory;
+  }
+  async getById(payload) {
+    debug(
+      "getById %s (type=%s)",
+      payload.identifier.key,
+      payload.identifier.listType
+    );
+    const itemsQuery = {
+      search: {
+        list: payload.identifier,
+        paginationOptions: { pageSize: 100, pageNumber: 1 }
+      }
+    };
+    let wishlist;
+    if (isRequisitionList(payload.identifier.listType)) {
+      const response = await this.client.callGet(
+        this.getRequisitionListItemsUrl(payload.identifier.key),
+        this.getRequisitionListItemsParams(itemsQuery),
+        { allowUndefined: true }
+      );
+      const raw = response?.resultList?.[0];
+      if (!raw)
+        return error({
+          type: "NotFound",
+          identifier: payload.identifier
+        });
+      return success(
+        this.requisitionFactory.parseRequisitionList(
+          this.context,
+          raw
+        )
+      );
+    } else {
+      const response = await this.client.callGet(
+        this.getWishlistItemsUrl(payload.identifier.key),
+        this.getWishlistItemsParams(itemsQuery),
+        { allowUndefined: true }
+      );
+      wishlist = response?.GiftList?.[0];
+    }
+    if (!wishlist) {
+      return error({
+        type: "NotFound",
+        identifier: payload.identifier
+      });
+    }
+    return success(this.factory.parseProductList(this.context, wishlist));
+  }
+  async queryLists(query) {
+    debug("queryLists listType=%s", query.search.listType);
+    if (isRequisitionList(query.search.listType)) {
+      const response2 = await this.client.callGet(
+        this.getRequisitionListsUrl(),
+        void 0,
+        { allowUndefined: true }
+      );
+      return success(
+        this.requisitionFactory.parseRequisitionListPaginatedResult(
+          this.context,
+          response2 ?? {},
+          query
+        )
+      );
+    }
+    const response = await this.client.callGet(
+      this.getWishlistsUrl(),
+      void 0,
+      { allowUndefined: true }
+    );
+    const data = {
+      GiftList: response?.GiftList ?? [],
+      recordSetTotal: response?.recordSetTotal ?? "0"
+    };
+    return success(
+      this.factory.parseProductListPaginatedResult(this.context, data, query)
+    );
+  }
+  async addList(mutation) {
+    debug("addList name=%s type=%s", mutation.list.name, mutation.list.type);
+    let listId;
+    if (isRequisitionList(mutation.list.type)) {
+      const response = await this.client.callPost(
+        this.getRequisitionListsUrl(),
+        this.getCreateRequisitionListBody(mutation)
+      );
+      listId = response.requisitionListId ?? "";
+      const fetchedResponse = await this.client.callGet(
+        this.getRequisitionListItemsUrl(listId),
+        this.getRequisitionListItemsParams({
+          search: {
+            list: { key: listId, listType: mutation.list.type },
+            paginationOptions: { pageSize: 1, pageNumber: 1 }
+          }
+        }),
+        { allowUndefined: true }
+      );
+      const raw = fetchedResponse?.resultList?.[0] ?? {
+        requisitionListId: listId,
+        name: mutation.list.name,
+        description: mutation.list.description
+      };
+      return success(
+        this.requisitionFactory.parseRequisitionList(
+          this.context,
+          raw
+        )
+      );
+    } else {
+      const response = await this.client.callPost(
+        this.getWishlistsUrl(),
+        this.getCreateWishlistBody(mutation)
+      );
+      listId = response.uniqueID ?? response.externalIdentifier ?? "";
+      const fetchedResponse = await this.client.callGet(
+        this.getWishlistItemsUrl(listId),
+        this.getWishlistItemsParams({
+          search: {
+            list: { key: listId, listType: mutation.list.type },
+            paginationOptions: { pageSize: 1, pageNumber: 1 }
+          }
+        }),
+        { allowUndefined: true }
+      );
+      const wishlist = fetchedResponse?.GiftList?.[0] ?? {
+        uniqueID: listId,
+        externalIdentifier: response.externalIdentifier,
+        descriptionName: mutation.list.name,
+        description: encodeWishlistType(
+          mutation.list.type,
+          mutation.list.description
+        )
+      };
+      return success(this.factory.parseProductList(this.context, wishlist));
+    }
+  }
+  async updateList(mutation) {
+    debug("updateList %s (type=%s)", mutation.list.key, mutation.list.listType);
+    const itemsQuery = {
+      search: {
+        list: mutation.list,
+        paginationOptions: { pageSize: 1, pageNumber: 1 }
+      }
+    };
+    if (isRequisitionList(mutation.list.listType)) {
+      await this.client.callPut(
+        this.getRequisitionListUrl(mutation.list.key),
+        this.getUpdateRequisitionListBody(mutation)
+      );
+      const response = await this.client.callGet(
+        this.getRequisitionListItemsUrl(mutation.list.key),
+        this.getRequisitionListItemsParams(itemsQuery),
+        { allowUndefined: true }
+      );
+      const raw = response?.resultList?.[0];
+      if (!raw)
+        return error({
+          type: "NotFound",
+          identifier: mutation.list
+        });
+      return success(
+        this.requisitionFactory.parseRequisitionList(
+          this.context,
+          raw
+        )
+      );
+    } else {
+      await this.client.callPut(
+        this.getWishlistUrl(mutation.list.key),
+        this.getUpdateWishlistBody(mutation)
+      );
+      const response = await this.client.callGet(
+        this.getWishlistItemsUrl(mutation.list.key),
+        this.getWishlistItemsParams(itemsQuery),
+        { allowUndefined: true }
+      );
+      if (!response?.GiftList?.[0])
+        return error({
+          type: "NotFound",
+          identifier: mutation.list
+        });
+      return success(
+        this.factory.parseProductList(this.context, response.GiftList[0])
+      );
+    }
+  }
+  async deleteList(mutation) {
+    debug("deleteList %s (type=%s)", mutation.list.key, mutation.list.listType);
+    if (isRequisitionList(mutation.list.listType)) {
+      await this.client.callDelete(
+        this.getRequisitionListUrl(mutation.list.key),
+        { ignore404: false }
+      );
+    } else {
+      await this.client.callDelete(this.getWishlistUrl(mutation.list.key), {
+        ignore404: false
+      });
+    }
+    return success(void 0);
+  }
+  async queryListItems(query) {
+    debug(
+      "queryListItems list=%s (type=%s)",
+      query.search.list.key,
+      query.search.list.listType
+    );
+    if (isRequisitionList(query.search.list.listType)) {
+      const response = await this.client.callGet(
+        this.getRequisitionListItemsUrl(query.search.list.key),
+        this.getRequisitionListItemsParams(query),
+        { allowUndefined: true }
+      );
+      return success(
+        this.requisitionFactory.parseRequisitionListItemPaginatedResult(
+          this.context,
+          response ?? {},
+          query
+        )
+      );
+    } else {
+      const response = await this.client.callGet(
+        this.getWishlistItemsUrl(query.search.list.key),
+        this.getWishlistItemsParams(query),
+        { allowUndefined: true }
+      );
+      const data = response ?? {
+        GiftList: [],
+        recordSetTotal: "0"
+      };
+      return success(
+        this.factory.parseProductListItemPaginatedResult(
+          this.context,
+          data,
+          query
+        )
+      );
+    }
+  }
+  async addItem(mutation) {
+    debug(
+      "addItem list=%s sku=%s",
+      mutation.list.key,
+      mutation.listItem.variant.sku
+    );
+    if (isRequisitionList(mutation.list.listType)) {
+      const params = this.getRequisitionAddItemParams();
+      const url = `${this.getRequisitionListUrl(mutation.list.key)}?${params.toString()}`;
+      await this.client.callPut(
+        url,
+        this.getRequisitionAddItemBody(mutation)
+      );
+      const response = await this.client.callGet(
+        this.getRequisitionListItemsUrl(mutation.list.key),
+        this.getRequisitionListItemsParams({
+          search: {
+            list: mutation.list,
+            paginationOptions: { pageSize: 100, pageNumber: 1 }
+          }
+        }),
+        { allowUndefined: true }
+      );
+      const sku = mutation.listItem.variant.sku;
+      const raw = response?.resultList?.[0]?.item?.find(
+        (i) => i.productId === sku || i.partNumber === sku
+      );
+      if (!raw)
+        return error({
+          type: "NotFound",
+          identifier: { key: sku, list: mutation.list }
+        });
+      const input = {
+        item: raw,
+        list: mutation.list
+      };
+      return success(
+        this.requisitionFactory.parseRequisitionListItem(
+          this.context,
+          input
+        )
+      );
+    } else {
+      const params = this.getAddItemParams();
+      const url = `${this.getWishlistUrl(mutation.list.key)}?${params.toString()}`;
+      await this.client.callPut(
+        url,
+        this.getAddItemBody(mutation)
+      );
+      const listResponse = await this.client.callGet(
+        this.getWishlistItemsUrl(mutation.list.key),
+        this.getWishlistItemsParams({
+          search: {
+            list: mutation.list,
+            paginationOptions: { pageSize: 100, pageNumber: 1 }
+          }
+        }),
+        { allowUndefined: true }
+      );
+      const sku = mutation.listItem.variant.sku;
+      const item = listResponse?.GiftList?.[0]?.item?.find(
+        (i) => i.productId === sku || i.partNumber === sku
+      );
+      if (!item)
+        return error({
+          type: "NotFound",
+          identifier: { key: sku, list: mutation.list }
+        });
+      const input = { item, list: mutation.list };
+      return success(this.factory.parseProductListItem(this.context, input));
+    }
+  }
+  async updateItem(mutation) {
+    debug(
+      "updateItem list=%s item=%s",
+      mutation.listItem.list.key,
+      mutation.listItem.key
+    );
+    const listType = mutation.listItem.list.listType;
+    const listId = mutation.listItem.list.key;
+    const fetchQuery = {
+      search: {
+        list: mutation.listItem.list,
+        paginationOptions: { pageSize: 100, pageNumber: 1 }
+      }
+    };
+    if (isRequisitionList(listType)) {
+      const response = await this.client.callGet(
+        this.getRequisitionListItemsUrl(listId),
+        this.getRequisitionListItemsParams(fetchQuery),
+        { allowUndefined: true }
+      );
+      const existing = response?.resultList?.[0]?.item?.find(
+        (i) => i.requisitionListItemId === mutation.listItem.key
+      );
+      if (!existing)
+        return error({
+          type: "NotFound",
+          identifier: mutation.listItem
+        });
+      const params = this.getRequisitionAddItemParams();
+      const url = `${this.getRequisitionListUrl(listId)}?${params.toString()}`;
+      await this.client.callPut(url, {
+        item: [
+          {
+            location: "online",
+            productId: existing.productId ?? existing.partNumber,
+            quantity: String(
+              mutation.quantity ?? Number(existing.quantity ?? 1)
+            )
+          }
+        ]
+      });
+      const updated = await this.client.callGet(
+        this.getRequisitionListItemsUrl(listId),
+        this.getRequisitionListItemsParams(fetchQuery),
+        { allowUndefined: true }
+      );
+      const updatedRaw = updated?.resultList?.[0]?.item?.find(
+        (i) => i.requisitionListItemId === mutation.listItem.key
+      );
+      if (!updatedRaw)
+        return error({
+          type: "NotFound",
+          identifier: mutation.listItem
+        });
+      const input = {
+        item: updatedRaw,
+        list: mutation.listItem.list
+      };
+      return success(
+        this.requisitionFactory.parseRequisitionListItem(
+          this.context,
+          input
+        )
+      );
+    } else {
+      const listResponse = await this.client.callGet(
+        this.getWishlistItemsUrl(listId),
+        this.getWishlistItemsParams(fetchQuery),
+        { allowUndefined: true }
+      );
+      const existing = listResponse?.GiftList?.[0]?.item?.find(
+        (i) => i.giftListItemID === mutation.listItem.key
+      );
+      if (!existing)
+        return error({
+          type: "NotFound",
+          identifier: mutation.listItem
+        });
+      const params = this.getAddItemParams();
+      const url = `${this.getWishlistUrl(listId)}?${params.toString()}`;
+      await this.client.callPut(url, {
+        item: [
+          {
+            location: "online",
+            productId: existing.productId ?? existing.partNumber,
+            quantityRequested: String(
+              mutation.quantity ?? Number(existing.quantityRequested ?? 1)
+            )
+          }
+        ]
+      });
+      const updated = await this.client.callGet(
+        this.getWishlistItemsUrl(listId),
+        this.getWishlistItemsParams(fetchQuery),
+        { allowUndefined: true }
+      );
+      const updatedItem = updated?.GiftList?.[0]?.item?.find(
+        (i) => i.giftListItemID === mutation.listItem.key
+      );
+      if (!updatedItem)
+        return error({
+          type: "NotFound",
+          identifier: mutation.listItem
+        });
+      const input = {
+        item: updatedItem,
+        list: mutation.listItem.list
+      };
+      return success(this.factory.parseProductListItem(this.context, input));
+    }
+  }
+  async deleteItem(mutation) {
+    debug(
+      "deleteItem list=%s item=%s",
+      mutation.listItem.list.key,
+      mutation.listItem.key
+    );
+    if (isRequisitionList(mutation.listItem.list.listType)) {
+      await this.client.callDelete(
+        this.getRequisitionListItemUrl(
+          mutation.listItem.list.key,
+          mutation.listItem.key
+        ),
+        { ignore404: true }
+      );
+    } else {
+      await this.client.callDelete(
+        this.getWishlistItemUrl(
+          mutation.listItem.list.key,
+          mutation.listItem.key
+        ),
+        { ignore404: true }
+      );
+    }
+    return success(void 0);
+  }
+  // ---------------------------------------------------------------------------
+  // Extension points — wishlist (non-requisition)
+  // ---------------------------------------------------------------------------
+  getWishlistsUrl() {
+    return `${this.client.transactionBaseUrl}/wishlist`;
+  }
+  getWishlistUrl(listId) {
+    return `${this.client.transactionBaseUrl}/wishlist/${encodeURIComponent(listId)}`;
+  }
+  getWishlistItemsUrl(listId) {
+    return `${this.client.transactionBaseUrl}/wishlist/${encodeURIComponent(listId)}/item`;
+  }
+  getWishlistItemUrl(listId, itemId) {
+    return `${this.client.transactionBaseUrl}/wishlist/${encodeURIComponent(listId)}/item/${encodeURIComponent(itemId)}`;
+  }
+  getWishlistItemsParams(query) {
+    const params = new URLSearchParams();
+    params.set("pageNumber", String(query.search.paginationOptions.pageNumber));
+    params.set("pageSize", String(query.search.paginationOptions.pageSize));
+    return params;
+  }
+  getCreateWishlistBody(mutation) {
+    return {
+      descriptionName: mutation.list.name,
+      // Encode the listType into description so it can be read back on query.
+      description: encodeWishlistType(
+        mutation.list.type,
+        mutation.list.description
+      ),
+      giftCardAccepted: "false",
+      accessSpecifier: "Private"
+    };
+  }
+  getUpdateWishlistBody(mutation) {
+    const body = {};
+    if (mutation.name !== void 0)
+      body["descriptionName"] = mutation.name;
+    if (mutation.description !== void 0) {
+      body["description"] = encodeWishlistType(
+        mutation.list.listType,
+        mutation.description
+      );
+    }
+    return body;
+  }
+  getAddItemParams() {
+    const params = new URLSearchParams();
+    params.set("addItem", "true");
+    return params;
+  }
+  getAddItemBody(mutation) {
+    return {
+      item: [
+        {
+          location: "online",
+          productId: mutation.listItem.variant.sku,
+          quantityRequested: String(mutation.listItem.quantity ?? 1)
+        }
+      ]
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Extension points — requisition list
+  // ---------------------------------------------------------------------------
+  getRequisitionListsUrl() {
+    return `${this.client.transactionBaseUrl}/requisitionList`;
+  }
+  getRequisitionListUrl(listId) {
+    return `${this.client.transactionBaseUrl}/requisitionList/${encodeURIComponent(listId)}`;
+  }
+  getRequisitionListItemsUrl(listId) {
+    return `${this.client.transactionBaseUrl}/requisitionList/${encodeURIComponent(listId)}`;
+  }
+  getRequisitionListItemUrl(listId, itemId) {
+    return `${this.client.transactionBaseUrl}/requisitionList/${encodeURIComponent(listId)}/requisitionListItem/${encodeURIComponent(itemId)}`;
+  }
+  getRequisitionListItemsParams(query) {
+    const params = new URLSearchParams();
+    params.set("pageNumber", String(query.search.paginationOptions.pageNumber));
+    params.set("pageSize", String(query.search.paginationOptions.pageSize));
+    return params;
+  }
+  getCreateRequisitionListBody(mutation) {
+    return {
+      name: mutation.list.name,
+      description: mutation.list.description ?? ""
+    };
+  }
+  getUpdateRequisitionListBody(mutation) {
+    const body = {};
+    if (mutation.name !== void 0)
+      body["name"] = mutation.name;
+    if (mutation.description !== void 0)
+      body["description"] = mutation.description;
+    return body;
+  }
+  getRequisitionAddItemParams() {
+    const params = new URLSearchParams();
+    params.set("addItem", "true");
+    return params;
+  }
+  getRequisitionAddItemBody(mutation) {
+    return {
+      item: [
+        {
+          location: "online",
+          productId: mutation.listItem.variant.sku,
+          quantity: String(mutation.listItem.quantity ?? 1)
+        }
+      ]
+    };
+  }
+}
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListQueryByIdSchema,
+    outputSchema: ProductListSchema
+  })
+], HclProductListCapability.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListQuerySchema,
+    outputSchema: ProductListPaginatedResultsSchema
+  })
+], HclProductListCapability.prototype, "queryLists", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListMutationCreateSchema,
+    outputSchema: ProductListSchema
+  })
+], HclProductListCapability.prototype, "addList", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListMutationUpdateSchema,
+    outputSchema: ProductListSchema
+  })
+], HclProductListCapability.prototype, "updateList", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListMutationDeleteSchema
+  })
+], HclProductListCapability.prototype, "deleteList", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListItemQuerySchema,
+    outputSchema: ProductListItemPaginatedResultsSchema
+  })
+], HclProductListCapability.prototype, "queryListItems", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListItemMutationCreateSchema,
+    outputSchema: ProductListItemSchema
+  })
+], HclProductListCapability.prototype, "addItem", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListItemMutationUpdateSchema,
+    outputSchema: ProductListItemSchema
+  })
+], HclProductListCapability.prototype, "updateItem", 1);
+__decorateClass([
+  Reactionary({
+    inputSchema: ProductListItemMutationDeleteSchema
+  })
+], HclProductListCapability.prototype, "deleteItem", 1);
+export {
+  HclProductListCapability
+};