@reactionary/provider-commercetools 0.3.15 → 0.3.16

package/core/initialize.js

@@ -18,7 +18,8 @@ import {
   CommercetoolsProfileProvider,
   CommercetoolsStoreProvider,
   CommercetoolsProductReviewsProvider,
-  CommercetoolsProductAssociationsProvider
+  CommercetoolsProductAssociationsProvider,
+  CommercetoolsProductListProvider
 } from "../providers/index.js";
 import { CommercetoolsAPI } from "./client.js";
 function withCommercetoolsCapabilities(configuration, capabilities) {
@@ -59,6 +60,14 @@ function withCommercetoolsCapabilities(configuration, capabilities) {
         commercetoolsApi
       );
     }
+    if (caps.productList) {
+      client.productList = new CommercetoolsProductListProvider(
+        config,
+        cache,
+        context,
+        commercetoolsApi
+      );
+    }
     if (caps.productReviews) {
       client.productReviews = new CommercetoolsProductReviewsProvider(
         config,

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@reactionary/provider-commercetools",
-  "version": "0.3.15",
+  "version": "0.3.16",
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "@reactionary/core": "0.3.15",
+    "@reactionary/core": "0.3.16",
     "debug": "^4.4.3",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.2.1",

package/providers/index.js

@@ -5,6 +5,7 @@ export * from "./inventory.provider.js";
 export * from "./order-search.provider.js";
 export * from "./price.provider.js";
 export * from "./product-associations.provider.js";
+export * from "./product-list.provider.js";
 export * from "./product.provider.js";
 export * from "./product-reviews.provider.js";
 export * from "./profile.provider.js";

package/providers/product-list.provider.js

@@ -0,0 +1,389 @@
+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,
+  ProductListProvider,
+  ProductListQueryByIdSchema,
+  ProductListQuerySchema,
+  ProductListSchema,
+  Reactionary,
+  success
+} from "@reactionary/core";
+class CommercetoolsProductListProvider extends ProductListProvider {
+  constructor(config, cache, context, commercetools) {
+    super(cache, context);
+    this.config = config;
+    this.commercetools = commercetools;
+  }
+  async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey }).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.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({
+        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({
+      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.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.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({
+      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.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.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
+  })
+], CommercetoolsProductListProvider.prototype, "getById", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
+    inputSchema: ProductListQuerySchema,
+    outputSchema: ProductListPaginatedResultsSchema
+  })
+], CommercetoolsProductListProvider.prototype, "queryLists", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    // Mutations should not be cached
+    inputSchema: ProductListMutationCreateSchema,
+    outputSchema: ProductListSchema
+  })
+], CommercetoolsProductListProvider.prototype, "addList", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListMutationUpdateSchema,
+    outputSchema: ProductListSchema
+  })
+], CommercetoolsProductListProvider.prototype, "updateList", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListMutationDeleteSchema
+  })
+], CommercetoolsProductListProvider.prototype, "deleteList", 1);
+__decorateClass([
+  Reactionary({
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: false,
+    inputSchema: ProductListItemQuerySchema,
+    outputSchema: ProductListItemPaginatedResultsSchema
+  })
+], CommercetoolsProductListProvider.prototype, "queryListItems", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationCreateSchema,
+    outputSchema: ProductListItemSchema
+  })
+], CommercetoolsProductListProvider.prototype, "addItem", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationDeleteSchema
+  })
+], CommercetoolsProductListProvider.prototype, "deleteItem", 1);
+__decorateClass([
+  Reactionary({
+    cache: false,
+    inputSchema: ProductListItemMutationUpdateSchema,
+    outputSchema: ProductListItemSchema
+  })
+], CommercetoolsProductListProvider.prototype, "updateItem", 1);
+export {
+  CommercetoolsProductListProvider
+};

package/schema/capabilities.schema.js

@@ -4,6 +4,7 @@ const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
   productSearch: true,
   productAssociations: true,
   productReviews: true,
+  productList: true,
   identity: true,
   cart: true,
   checkout: true,

package/src/providers/index.d.ts

@@ -5,6 +5,7 @@ export * from './inventory.provider.js';
 export * from './order-search.provider.js';
 export * from './price.provider.js';
 export * from './product-associations.provider.js';
+export * from './product-list.provider.js';
 export * from './product.provider.js';
 export * from './product-reviews.provider.js';
 export * from './profile.provider.js';

package/src/providers/product-list.provider.d.ts

@@ -0,0 +1,27 @@
+import type { ShoppingList, ShoppingListLineItem } from '@commercetools/platform-sdk';
+import type { Cache, ProductList, ProductListIdentifier, ProductListItem, ProductListItemMutationCreate, ProductListItemMutationDelete, ProductListItemMutationUpdate, ProductListItemPaginatedResult, ProductListItemsQuery, ProductListMutationCreate, ProductListMutationDelete, ProductListMutationUpdate, ProductListPaginatedResult, ProductListQuery, ProductListQueryById, RequestContext, Result } from '@reactionary/core';
+import { ProductListProvider } from '@reactionary/core';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+export declare class CommercetoolsProductListProvider extends ProductListProvider {
+    protected config: CommercetoolsConfiguration;
+    protected commercetools: CommercetoolsAPI;
+    constructor(config: CommercetoolsConfiguration, cache: Cache, context: RequestContext, commercetools: CommercetoolsAPI);
+    protected getClient(): Promise<import("@commercetools/platform-sdk").ByProjectKeyMeRequestBuilder>;
+    getById(payload: ProductListQueryById): Promise<Result<ProductList>>;
+    queryLists(payload: ProductListQuery): Promise<Result<ProductListPaginatedResult>>;
+    addList(mutation: ProductListMutationCreate): Promise<Result<ProductList>>;
+    updateList(mutation: ProductListMutationUpdate): Promise<Result<ProductList>>;
+    deleteList(mutation: ProductListMutationDelete): Promise<Result<void>>;
+    queryListItems(query: ProductListItemsQuery): Promise<Result<ProductListItemPaginatedResult>>;
+    addItem(mutation: ProductListItemMutationCreate): Promise<Result<ProductListItem>>;
+    deleteItem(mutation: ProductListItemMutationDelete): Promise<Result<void>>;
+    updateItem(mutation: ProductListItemMutationUpdate): Promise<Result<ProductListItem>>;
+    /**
+     * 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.
+     **/
+    protected getLocaleString(): string;
+    protected parseSingle(list: ShoppingList): ProductList;
+    protected parseProductListItem(listIdentifier: ProductListIdentifier, lineItem: ShoppingListLineItem): ProductListItem;
+}

package/src/schema/capabilities.schema.d.ts

@@ -13,6 +13,7 @@ export declare const CommercetoolsCapabilitiesSchema: z.ZodObject<{
     productSearch: z.ZodOptional<z.ZodBoolean>;
     productAssociations: z.ZodOptional<z.ZodBoolean>;
     productReviews: z.ZodOptional<z.ZodBoolean>;
+    productList: z.ZodOptional<z.ZodBoolean>;
     orderSearch: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$loose>;
 export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;