@reactionary/commercetools 0.6.9 → 0.7.0

package/capabilities/product-list.capability.js

@@ -11,6 +11,7 @@ var __decorateClass = (decorators, target, key, kind) => {
 };
 import {
   error,
+  ProductListCapability,
   ProductListItemMutationCreateSchema,
   ProductListItemMutationDeleteSchema,
   ProductListItemMutationUpdateSchema,
@@ -21,7 +22,6 @@ import {
   ProductListMutationDeleteSchema,
   ProductListMutationUpdateSchema,
   ProductListPaginatedResultsSchema,
-  ProductListCapability,
   ProductListQueryByIdSchema,
   ProductListQuerySchema,
   ProductListSchema,
@@ -38,15 +38,62 @@ class CommercetoolsProductListCapability extends ProductListCapability {
     this.commercetools = commercetools;
     this.factory = factory;
   }
-  async getClient() {
-    const client = await this.commercetools.getClient();
-    return client.withProjectKey({ projectKey: this.config.projectKey }).me();
+  /**
+   * Creates a new Commercetools client, optionally upgrading it from Anonymous mode to Guest mode.
+   * For now, any Query or Mutation will require an upgrade to Guest mode.
+   * In the future, maybe we can delay this upgrade until we actually need it.
+   */
+  async getClient(companyIdentifier) {
+    let client;
+    if (companyIdentifier) {
+      client = await this.commercetools.getClientForCompany(companyIdentifier);
+    } else {
+      client = (await this.commercetools.getClient()).withProjectKey({ projectKey: this.config.projectKey }).me();
+    }
+    return client;
+  }
+  async isMine(listIdentifier) {
+    if (this.context.session.identityContext?.identity.type !== "Registered") {
+      return false;
+    }
+    if (this.context.session.identityContext?.identity.id.userId === listIdentifier.user?.userId) {
+      return true;
+    }
+    return false;
+  }
+  async getCompanyForList(listIdentifier) {
+    if ("version" in listIdentifier && "company" in listIdentifier) {
+      return listIdentifier.company;
+    }
+    const client = await this.getClient();
+    try {
+      const listResponse = await client.shoppingLists().withId({ ID: listIdentifier.key }).get().execute();
+      if (listResponse.body.businessUnit) {
+        return {
+          taxIdentifier: listResponse.body.businessUnit.key
+        };
+      }
+      return void 0;
+    } catch (e) {
+      console.error("Error fetching list for company information:", e);
+      return void 0;
+    }
   }
   async getById(payload) {
     try {
-      const client = await this.getClient();
+      const companyIdentifier = await this.getCompanyForList(payload.identifier);
+      const client = await this.getClient(companyIdentifier);
       const response = await client.shoppingLists().withId({ ID: payload.identifier.key }).get().execute();
-      return success(this.factory.parseProductList(this.context, this.parseSingle(response.body)));
+      const payloadResult = this.factory.parseProductList(this.context, response.body);
+      if (!await this.isMine(payloadResult.identifier)) {
+        if (!payloadResult.published) {
+          return error({
+            type: "NotFound",
+            identifier: payload.identifier
+          });
+        }
+      }
+      return success(payloadResult);
     } catch (err) {
       if (err.statusCode === 404) {
         return error({
@@ -61,65 +108,101 @@ class CommercetoolsProductListCapability extends ProductListCapability {
   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
-      }));
+        limit: payload.search.paginationOptions.pageSize,
+        offset: (payload.search.paginationOptions.pageNumber - 1) * payload.search.paginationOptions.pageSize,
+        count: payload.search.paginationOptions.pageSize,
+        results: [],
+        total: 0
+      }, payload));
     }
-    const client = await this.getClient();
+    const client = await this.getClient(payload.search.company);
+    let where = ``;
+    const listTypeFilter = `custom(fields(listType=:listType))`;
+    const allOfMineFilter = `(customer(id=:customerId))`;
+    const othersFilter = `(customer(id != :customerId) and custom(fields(published=true)))`;
+    let companyFilter = `businessUnit is not defined`;
+    if (payload.search.company) {
+      companyFilter = `businessUnit(key=:companyKey)`;
+    }
+    where = `((${listTypeFilter}) and (${companyFilter})) and (${allOfMineFilter} or ${othersFilter})`;
+    const customerId = this.context.session.identityContext?.identity.type === "Registered" ? this.context.session.identityContext?.identity.id.userId : "anonymous";
+    const companyKey = payload.search.company?.taxIdentifier || void 0;
     const response = await client.shoppingLists().get({
       queryArgs: {
-        where: `custom(fields(listType=:listType))`,
+        where,
         sort: "createdAt desc",
         "var.listType": payload.search.listType,
+        "var.published": true,
+        "var.customerId": customerId,
+        "var.companyKey": companyKey,
         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
-    }));
+    return success(this.factory.parseProductListPaginatedResult(this.context, response.body, payload));
   }
-  async addList(mutation) {
-    const client = await this.getClient();
+  addListPayload(payload) {
     const localeString = this.getLocaleString();
+    let businessUnitReference = void 0;
+    let customerReference = void 0;
+    if (payload.company) {
+      businessUnitReference = {
+        typeId: "business-unit",
+        key: payload.company.taxIdentifier
+      };
+      if (this.context.session.identityContext?.identity.type === "Registered" && this.context.session.identityContext?.identity.id) {
+        customerReference = {
+          typeId: "customer",
+          id: this.context.session.identityContext?.identity.id.userId
+        };
+      }
+    }
+    const customFields = {
+      type: {
+        typeId: "type",
+        key: "reactionaryShoppingList"
+      },
+      fields: {
+        listType: payload.list.type,
+        imageUrl: payload.list.image ? payload.list.image.sourceUrl : void 0,
+        publishedDate: payload.list.publishDate ? new Date(payload.list.publishDate) : void 0,
+        published: payload.list.published && true
+      }
+    };
+    const draft = {
+      name: { [localeString]: payload.list.name },
+      businessUnit: businessUnitReference,
+      customer: customerReference,
+      description: payload.list.description ? { [localeString]: payload.list.description } : void 0,
+      custom: customFields
+    };
+    return draft;
+  }
+  async addList(mutation) {
+    const client = await this.getClient(mutation.company);
     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 list = this.addListPayload(mutation);
     const response = await client.shoppingLists().post({
-      body: draft
+      body: list
     }).execute();
-    return success(this.factory.parseProductList(this.context, this.parseSingle(response.body)));
+    return success(this.factory.parseProductList(this.context, response.body));
   }
   async updateList(mutation) {
-    const client = await this.getClient();
+    const companyIdentifier = await this.getCompanyForList(mutation.list);
+    const client = await this.getClient(companyIdentifier);
+    if (!await this.isMine(mutation.list)) {
+      if (await this.isUnpublished(mutation.list, client)) {
+        return error({
+          type: "InvalidInput",
+          error: "Cannot update a list that is not yours, unless it is published"
+        });
+      }
+    }
     const actions = [];
     const localeString = this.getLocaleString();
     if (mutation.name) {
@@ -161,10 +244,19 @@ class CommercetoolsProductListCapability extends ProductListCapability {
       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)));
+    return success(this.factory.parseProductList(this.context, response.body));
   }
   async deleteList(mutation) {
-    const client = await this.getClient();
+    const companyIdentifier = await this.getCompanyForList(mutation.list);
+    const client = await this.getClient(companyIdentifier);
+    if (!await this.isMine(mutation.list)) {
+      if (await this.isUnpublished(mutation.list, client)) {
+        return error({
+          type: "InvalidInput",
+          error: "Cannot delete from a list that is not yours, unless it is published"
+        });
+      }
+    }
     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: {
@@ -174,22 +266,25 @@ class CommercetoolsProductListCapability extends ProductListCapability {
     return success(void 0);
   }
   async queryListItems(query) {
-    const client = await this.getClient();
+    const companyIdentifier = await this.getCompanyForList(query.search.list);
+    const client = await this.getClient(companyIdentifier);
     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)
-    }));
+    return success(this.factory.parseProductListItemPaginatedResult(this.context, response.body, query));
   }
   async addItem(mutation) {
-    const client = await this.getClient();
+    const companyIdentifier = await this.getCompanyForList(mutation.list);
+    const client = await this.getClient(companyIdentifier);
+    const myList = await this.isMine(mutation.list);
+    if (!myList) {
+      if (await this.isUnpublished(mutation.list, client)) {
+        return error({
+          type: "InvalidInput",
+          error: "Cannot add items to a list that is not yours, unless it is published"
+        });
+      }
+    }
     const lineItemDraft = {
       action: "addLineItem",
       sku: mutation.listItem.variant.sku,
@@ -215,10 +310,24 @@ class CommercetoolsProductListCapability extends ProductListCapability {
     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)));
+    return success(this.factory.parseProductListItem(this.context, { listIdentifier: mutation.list, lineItem: lastItem }));
+  }
+  async isUnpublished(list, client) {
+    const response = await client.shoppingLists().withId({ ID: list.key }).get().execute();
+    const isPublished = response.body.custom?.fields["published"] && true;
+    return !isPublished;
   }
   async deleteItem(mutation) {
-    const client = await this.getClient();
+    const companyIdentifier = await this.getCompanyForList(mutation.listItem.list);
+    const client = await this.getClient(companyIdentifier);
+    if (!await this.isMine(mutation.listItem.list)) {
+      if (await this.isUnpublished(mutation.listItem.list, client)) {
+        return error({
+          type: "InvalidInput",
+          error: "Cannot delete items to a list that is not yours, unless it is published"
+        });
+      }
+    }
     const update = {
       version: 0,
       // The auto-correcting middleware will deal with the version
@@ -231,7 +340,16 @@ class CommercetoolsProductListCapability extends ProductListCapability {
     return success(void 0);
   }
   async updateItem(mutation) {
-    const client = await this.getClient();
+    const companyIdentifier = await this.getCompanyForList(mutation.listItem.list);
+    const client = await this.getClient(companyIdentifier);
+    if (!await this.isMine(mutation.listItem.list)) {
+      if (await this.isUnpublished(mutation.listItem.list, client)) {
+        return error({
+          type: "InvalidInput",
+          error: "Cannot update items in a list that is not yours, unless it is published"
+        });
+      }
+    }
     const actions = [];
     if (mutation.quantity !== void 0) {
       actions.push({
@@ -265,7 +383,7 @@ class CommercetoolsProductListCapability extends ProductListCapability {
     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)));
+    return success(this.factory.parseProductListItem(this.context, { listIdentifier: mutation.listItem.list, lineItem: 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,
@@ -274,48 +392,6 @@ class CommercetoolsProductListCapability extends ProductListCapability {
   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({

package/core/capability-descriptors.js

@@ -26,7 +26,8 @@ import {
   ProfileSchema,
   PriceSchema,
   ShippingMethodSchema,
-  StoreSchema
+  StoreSchema,
+  CartPaginatedSearchResultSchema
 } from "@reactionary/core";
 import {
 } from "../schema/capabilities.schema.js";
@@ -186,7 +187,7 @@ const capabilityDescriptors = {
   cart: {
     isEnabled: (caps) => caps.cart?.enabled,
     getOverride: (caps) => caps.cart,
-    createDefaultFactory: () => new CommercetoolsCartFactory(CartSchema, CartIdentifierSchema),
+    createDefaultFactory: () => new CommercetoolsCartFactory(CartSchema, CartIdentifierSchema, CartPaginatedSearchResultSchema),
     createDefaultCapability: (args) => new CommercetoolsCartCapability(
       args.config,
       args.cache,

package/core/client.js

@@ -10,7 +10,9 @@ import {
 import * as crypto from "crypto";
 import createDebug from "debug";
 import { RequestContextTokenCache } from "./token-cache.js";
-import { CommercetoolsSessionSchema } from "../schema/session.schema.js";
+import {
+  CommercetoolsSessionSchema
+} from "../schema/session.schema.js";
 const debug = createDebug("reactionary:commercetools");
 const PROVIDER_SESSION_KEY = "COMMERCETOOLS_PROVIDER";
 class CommercetoolsAPI {
@@ -22,7 +24,10 @@ class CommercetoolsAPI {
   constructor(config, context) {
     this.config = config;
     this.context = context;
-    this.tokenCache = new RequestContextTokenCache(this.context, PROVIDER_SESSION_KEY);
+    this.tokenCache = new RequestContextTokenCache(
+      this.context,
+      PROVIDER_SESSION_KEY
+    );
   }
   async getClient() {
     if (!this.client) {
@@ -30,6 +35,17 @@ class CommercetoolsAPI {
     }
     return this.client;
   }
+  async getClientForCompany(company) {
+    if (this.context.session.identityContext.identity.type !== "Registered") {
+      throw new Error("Only registered identities can have company clients");
+    }
+    const companyClient = (await this.getAdminClient()).withProjectKey({ projectKey: this.config.projectKey }).asAssociate().withAssociateIdValue({
+      associateId: this.context.session.identityContext.identity.id.userId
+    }).inBusinessUnitKeyWithBusinessUnitKeyValue({
+      businessUnitKey: company.taxIdentifier
+    });
+    return companyClient;
+  }
   async getAdminClient() {
     if (!this.adminClient) {
       this.adminClient = this.createAdminClient();
@@ -189,7 +205,11 @@ class CommercetoolsAPI {
     });
   }
   async logout() {
-    await this.tokenCache.set({ token: "", refreshToken: "", expirationTime: 0 });
+    await this.tokenCache.set({
+      token: "",
+      refreshToken: "",
+      expirationTime: 0
+    });
     const identity = {
       type: "Anonymous"
     };

package/factories/cart/cart.factory.js

@@ -4,21 +4,64 @@ import {
 class CommercetoolsCartFactory {
   cartSchema;
   cartIdentifierSchema;
-  constructor(cartSchema, cartIdentifierSchema) {
+  cartPaginatedSearchResultSchema;
+  constructor(cartSchema, cartIdentifierSchema, cartPaginatedSearchResultSchema) {
     this.cartSchema = cartSchema;
     this.cartIdentifierSchema = cartIdentifierSchema;
+    this.cartPaginatedSearchResultSchema = cartPaginatedSearchResultSchema;
+  }
+  parseCartPaginatedSearchResult(_context, data, _query) {
+    const result = {
+      pageNumber: _query.search.paginationOptions.pageNumber,
+      pageSize: _query.search.paginationOptions.pageSize,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil(
+        (data.total || 0) / _query.search.paginationOptions.pageSize
+      ),
+      items: data.results.map(
+        (cart) => this.parseCartSearchResultItem(_context, cart)
+      ),
+      identifier: _query.search
+    };
+    return this.cartPaginatedSearchResultSchema.parse(result);
   }
   parseCartIdentifier(_context, data) {
     return this.cartIdentifierSchema.parse({
-      key: data.key || "",
-      version: data.version || 0
+      key: data.id || "",
+      version: data.version || 0,
+      company: data.businessUnit ? { taxIdentifier: data.businessUnit.key } : void 0
     });
   }
+  parseCartSearchResultItem(context, data) {
+    const identifier = this.parseCartIdentifier(context, data);
+    const numItems = data.lineItems.length;
+    const lastModifiedDate = data.lastModifiedAt;
+    let company;
+    if (data.businessUnit) {
+      company = {
+        taxIdentifier: data.businessUnit.key
+      };
+    }
+    const result = {
+      identifier,
+      user: {
+        userId: data.customerId || data.anonymousId || "???"
+      },
+      company,
+      name: data.custom?.fields["name"] || "",
+      numItems,
+      lastModifiedDate
+    };
+    return result;
+  }
   parseCart(context, data) {
-    const identifier = this.parseCartIdentifier(context, {
-      key: data.id,
-      version: data.version
-    });
+    const identifier = this.parseCartIdentifier(context, data);
+    let company;
+    if (data.businessUnit) {
+      company = {
+        taxIdentifier: data.businessUnit.key
+      };
+    }
     const items = [];
     for (const lineItem of data.lineItems) {
       items.push(this.parseCartItem(lineItem));
@@ -73,9 +116,10 @@ class CommercetoolsCartFactory {
     }
     const result = {
       identifier,
-      userId: {
-        userId: "???"
+      user: {
+        userId: data.customerId || data.anonymousId || "???"
       },
+      company,
       name: data.custom?.fields["name"] || "",
       description: data.custom?.fields["description"] || "",
       price,
@@ -104,7 +148,13 @@ class CommercetoolsCartFactory {
     const currency = lineItem.price.value.currencyCode.toUpperCase();
     return CartItemSchema.parse({
       identifier: {
-        key: lineItem.id
+        key: lineItem.id,
+        ...lineItem.priceMode === "ExternalPrice" && {
+          originalPrice: {
+            value: lineItem.price.value.centAmount / 100,
+            currency
+          }
+        }
       },
       product: {
         key: lineItem.productId

package/factories/product-list/product-list.factory.js

@@ -11,53 +11,88 @@ class CommercetoolsProductListFactory {
     this.productListPaginatedSchema = productListPaginatedSchema;
     this.productListItemPaginatedSchema = productListItemPaginatedSchema;
   }
-  parseProductList(_context, data) {
-    return this.productListSchema.parse(data);
-  }
-  parseProductListItem(_context, data) {
-    return this.productListItemSchema.parse(data);
-  }
-  parseProductListPaginatedResult(_context, data) {
-    return this.productListPaginatedSchema.parse(data);
-  }
-  parseProductListItemPaginatedResult(_context, data) {
-    return this.productListItemPaginatedSchema.parse(data);
+  /**
+   * This is a customer owned resource, so we just use english as otherwise it will fail if he changes the visual language settings.
+   * @returns
+   */
+  getLocaleString() {
+    return "en";
   }
-  parseListFromCommercetools(list) {
-    const listType = list.custom?.fields["listType"] || "favorite";
-    const image = list.custom?.fields["imageUrl"];
-    const published = list.custom?.fields["published"] && true;
-    const publishDateValue = list.custom?.fields["publishedDate"];
-    const publishDate = publishDateValue ? new Date(publishDateValue).toISOString() : void 0;
-    return this.productListSchema.parse({
+  parseProductList(_context, data) {
+    const localeString = this.getLocaleString();
+    const listType = data.custom?.fields["listType"] || "favorite";
+    const image = data.custom?.fields["imageUrl"];
+    const published = data.custom?.fields["published"] && true;
+    const publishDateDate = data.custom?.fields["publishedDate"];
+    let publishedDate;
+    if (publishDateDate) {
+      publishedDate = new Date(publishDateDate).toISOString();
+    }
+    const result = {
       identifier: {
         listType,
-        key: list.id
+        key: data.id,
+        user: data.customer ? {
+          userId: data.customer.id
+        } : void 0,
+        version: Number(data.version),
+        company: data.businessUnit ? { taxIdentifier: data.businessUnit.key } : void 0
       },
       type: listType,
-      name: list.name["en"] || "Unnamed List",
-      description: list.description?.["en"] || "",
+      name: data.name[localeString] || "Unnamed List",
+      description: data.description?.[localeString] || "",
       published,
-      publishDate,
+      publishDate: publishedDate,
       image: {
         sourceUrl: image || "",
-        altText: list.name["en"] || "List Image"
+        altText: data.name[localeString] || "List Image"
       }
-    });
+    };
+    return this.productListSchema.parse(result);
   }
-  parseListItemFromCommercetools(listIdentifier, lineItem) {
-    return this.productListItemSchema.parse({
+  parseProductListItem(_context, data) {
+    const localeString = this.getLocaleString();
+    const result = {
       identifier: {
-        list: listIdentifier,
-        key: lineItem.id
+        list: data.listIdentifier,
+        key: data.lineItem.id
       },
       variant: {
-        sku: lineItem.variant?.sku || ""
+        sku: data.lineItem.variant?.sku || ""
       },
-      quantity: lineItem.quantity,
-      notes: lineItem.custom?.fields["notes"] || "",
-      order: lineItem.custom?.fields["order"] || 1
-    });
+      quantity: data.lineItem.quantity,
+      notes: data.lineItem.custom?.fields["notes"] || "",
+      order: data.lineItem.custom?.fields["order"] || 1
+      // Commercetools doesn't have explicit ordering
+    };
+    return this.productListItemSchema.parse(result);
+  }
+  parseProductListPaginatedResult(context, data, query) {
+    const result = {
+      items: (data.results || []).map((list) => this.parseProductList(context, list)),
+      pageNumber: query.search.paginationOptions.pageNumber,
+      pageSize: query.search.paginationOptions.pageSize,
+      totalCount: data.total || 0,
+      totalPages: Math.ceil((data.total || 0) / query.search.paginationOptions.pageSize),
+      identifier: query.search
+    };
+    return this.productListPaginatedSchema.parse(result);
+  }
+  parseProductListItemPaginatedResult(context, data, query) {
+    const originalItemCount = data.lineItems.length;
+    const items = (data.lineItems || []).slice((query.search.paginationOptions.pageNumber - 1) * query.search.paginationOptions.pageSize, query.search.paginationOptions.pageNumber * query.search.paginationOptions.pageSize);
+    const result = {
+      items: items.map((x) => this.parseProductListItem(context, {
+        listIdentifier: query.search.list,
+        lineItem: x
+      })),
+      identifier: query.search,
+      pageNumber: query.search.paginationOptions.pageNumber,
+      pageSize: query.search.paginationOptions.pageSize,
+      totalCount: originalItemCount,
+      totalPages: Math.ceil(originalItemCount / query.search.paginationOptions.pageSize)
+    };
+    return this.productListItemPaginatedSchema.parse(result);
   }
 }
 export {