@reactionary/source 0.0.52 → 0.2.16

package/providers/commercetools/src/providers/product.provider.ts

@@ -1,74 +1,135 @@
 import {
-  ProductProvider
+  ImageSchema,
+  ProductAttributeIdentifierSchema,
+  ProductAttributeSchema,
+  ProductAttributeValueIdentifierSchema,
+  ProductAttributeValueSchema,
+  ProductProvider,
+  ProductQueryByIdSchema,
+  ProductQueryBySKUSchema,
+  ProductQueryBySlugSchema,
+  ProductSchema,
+  Reactionary,
+  success,
+  error,
 } from '@reactionary/core';
-import { CommercetoolsClient } from '../core/client.js';
-import type { z } from 'zod';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import type { ProductProjection } from '@commercetools/platform-sdk';
-import type { Product, ProductQueryById, ProductQueryBySKU, ProductQueryBySlug, RequestContext } from '@reactionary/core';
-import type { Cache } from '@reactionary/core';
+import type {
+  ProductProjection,
+  ProductVariant as CTProductVariant,
+  Attribute as CTAttribute,
+} from '@commercetools/platform-sdk';
+import type {
+  Product,
+  ProductVariant,
+  ProductQueryById,
+  ProductQueryBySKU,
+  ProductQueryBySlug,
+  ProductVariantIdentifier,
+  RequestContext,
+  ProductAttribute,
+  ProductAttributeIdentifier,
+  ProductAttributeValue,
+  ProductAttributeValueIdentifier,
+  ProductIdentifier,
+  ProductVariantOption,
+  ProductOptionIdentifier,
+  Result,
+} from '@reactionary/core';
+import type { Cache, Image } from '@reactionary/core';
+import type { CommercetoolsAPI } from '../core/client.js';
+import type { NotFoundError } from '@reactionary/core';
 
-export class CommercetoolsProductProvider<
-  T extends Product = Product
-> extends ProductProvider<T> {
+export class CommercetoolsProductProvider extends ProductProvider {
   protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
-    super(schema, cache);
+  constructor(
+    config: CommercetoolsConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
+  ) {
+    super(cache, context);
 
     this.config = config;
+    this.commercetools = commercetools;
   }
 
-  protected async getClient(reqCtx: RequestContext) {
-
-    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
-    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections();
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+    return client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .productProjections();
   }
 
+  @Reactionary({
+    inputSchema: ProductQueryByIdSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
   public override async getById(
-    payload: ProductQueryById,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
-
-    try {
-      const remote = await client
-        .withId({ ID: payload.id })
-        .get()
-        .execute();
-
-      return this.parseSingle(remote.body, reqCtx);
-    } catch(error) {
-      return this.createEmptyProduct(payload.id);
-    }
+    payload: ProductQueryById
+  ): Promise<Result<Product>> {
+    const client = await this.getClient();
+    const remote = await client
+      .withKey({ key: payload.identifier.key })
+      .get()
+      .execute();
+    const value = this.parseSingle(remote.body);
+
+    return success(value);
   }
 
+  @Reactionary({
+    inputSchema: ProductQueryBySlugSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
   public override async getBySlug(
-    payload: ProductQueryBySlug,
-    reqCtx: RequestContext
-  ): Promise<T | null> {
-    const client = await this.getClient(reqCtx);
+    payload: ProductQueryBySlug
+  ): Promise<Result<Product, NotFoundError>> {
+    const client = await this.getClient();
 
     const remote = await client
       .get({
         queryArgs: {
-          where: 'slug(en-US = :slug)',
-          'var.slug': payload.slug
-        }
+          // FIXME: Hardcoded locale
+          where: 'slug(en = :slug)',
+          'var.slug': payload.slug,
+        },
       })
       .execute();
 
     if (remote.body.count === 0) {
-      return null;
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload.slug,
+      });
     }
-    return this.parseSingle(remote.body.results[0], reqCtx);
+    const result = this.parseSingle(remote.body.results[0]);
+
+    return success(result);
   }
 
+  @Reactionary({
+    inputSchema: ProductQueryBySKUSchema,
+    outputSchema: ProductSchema,
+    cache: true,
+    cacheTimeToLiveInSeconds: 300,
+    currencyDependentCaching: false,
+    localeDependentCaching: true
+  })
   public override async getBySKU(
-    payload: ProductQueryBySKU,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const client = await this.getClient(reqCtx);
+    payload: ProductQueryBySKU
+  ): Promise<Result<Product>> {
+    const client = await this.getClient();
 
     const remote = await client
       .get({
@@ -76,53 +137,167 @@ export class CommercetoolsProductProvider<
           staged: false,
           limit: 1,
           where: 'variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ',
-          'var.skus': [payload].map(p => p.sku.key),
-        }
+          'var.skus': [payload].map((p) => p.variant.sku),
+        },
       })
       .execute();
 
-    return this.parseSingle(remote.body.results[0], reqCtx);
-  }
-
-
-  protected override parseSingle(dataIn: unknown, reqCtx: RequestContext): T {
-    const data = dataIn as ProductProjection;
-    const base = this.newModel();
+    const result = this.parseSingle(remote.body.results[0]);
 
+    return success(result);
+  }
 
-    base.identifier = { key: data.id };
-    base.name = data.name[reqCtx.languageContext.locale];
-    base.slug = data.slug[reqCtx.languageContext.locale];
+  protected parseSingle(data: ProductProjection): Product {
+    const identifier = { key: data.key || data.id } satisfies ProductIdentifier;
+    const name = data.name[this.context.languageContext.locale];
+    const slug = data.slug[this.context.languageContext.locale];
 
+    let description = '';
     if (data.description) {
-      base.description = data.description[reqCtx.languageContext.locale];
-    }
-
-    if (data.masterVariant.images && data.masterVariant.images.length > 0) {
-      base.image = data.masterVariant.images[0].url;
+      description = data.description[this.context.languageContext.locale];
     }
 
-    base.images = [];
-    base.attributes = [];
-    base.skus = [];
+    const variantLevelAttributes =
+      data.masterVariant.attributes?.map((x) => this.parseAttribute(x)) || [];
+    const productLevelAttributes =
+      data.attributes.map((x) => this.parseAttribute(x)) || [];
+    const sharedAttributes = [
+      ...productLevelAttributes,
+      ...variantLevelAttributes,
+    ];
+    const mainVariant = this.parseVariant(data.masterVariant, data);
 
-    const variants = [data.masterVariant, ...data.variants];
-    for (const variant of variants) {
-      if (variant.sku) {
-        base.skus.push({
-          identifier: { key: variant.sku },
-        });
+    const otherVariants = [];
+    for (const variant of data.variants || []) {
+      if (variant.id !== data.masterVariant.id) {
+        otherVariants.push(this.parseVariant(variant, data));
       }
     }
 
-    base.meta = {
-      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, reqCtx) },
-      placeholder: false
-    };
+    const result = {
+      identifier,
+      name,
+      slug,
+      description,
+      sharedAttributes,
+      mainVariant,
+      brand: '',
+      longDescription: '',
+      manufacturer: '',
+      options: [],
+      parentCategories: [],
+      published: true,
+      variants: otherVariants,
+    } satisfies Product;
+
+    return result;
+  }
 
-    return this.assert(base);
+  /**
+   * Return true, if the attribute is a defining attribute (ie an option)
+   * @param attr a variant attribute
+   * @returns true if the attribute is an option
+   */
+  protected isVariantAttributeAnOption(attr: CTAttribute): boolean {
+    // for now, the assumption is that any variant attribute is a defining attribute (ie an option)
+    // ideally this should be verified with the product type.
+    return true;
   }
 
+  protected parseVariant(
+    variant: CTProductVariant,
+    product: ProductProjection
+  ): ProductVariant {
+    const identifier = {
+      sku: variant.sku!,
+    } satisfies ProductVariantIdentifier;
+
+    const images = [
+      ...(variant.images || []).map((img) =>
+        ImageSchema.parse({
+          sourceUrl: img.url,
+          altText: img.label || '',
+          width: img.dimensions?.w,
+          height: img.dimensions?.h,
+        } satisfies Image)
+      ),
+    ];
 
+    const options =
+      (variant.attributes ?? [])
+        .filter((attr) => this.isVariantAttributeAnOption(attr))
+        .map((attr) => {
+          const attrVal = this.parseAttributeValue(attr);
+          const optionIdentifier: ProductOptionIdentifier = {
+            key: attr.name,
+          };
+          const option: ProductVariantOption = {
+            identifier: optionIdentifier,
+            name: attr.name,
+            value: {
+              identifier: {
+                key: attrVal.value,
+                option: optionIdentifier,
+              },
+              label: attrVal.label,
+            },
+          };
+          return option;
+        }) || [];
 
+    const result = {
+      identifier,
+      images,
+      barcode: '',
+      ean: '',
+      gtin: '',
+      name: product.name[this.context.languageContext.locale],
+      options,
+      upc: '',
+    } satisfies ProductVariant;
+
+    return result;
+  }
+
+  protected parseAttribute(attr: CTAttribute): ProductAttribute {
+    const result = ProductAttributeSchema.parse({
+      identifier: ProductAttributeIdentifierSchema.parse({
+        key: attr.name,
+      } satisfies Partial<ProductAttributeIdentifier>),
+      group: '',
+      name: attr.name,
+      values: [this.parseAttributeValue(attr)],
+    } satisfies Partial<ProductAttribute>);
+
+    return result;
+  }
+
+  protected parseAttributeValue(attr: CTAttribute): ProductAttributeValue {
+    let attrValue = '';
+    if (attr.value && Array.isArray(attr.value)) {
+      attrValue = attr.value[0];
+    }
+
+    if (attr.value && typeof attr.value === 'object') {
+      if (this.context.languageContext.locale in attr.value) {
+        attrValue = attr.value[this.context.languageContext.locale];
+      } else {
+        attrValue = '-';
+      }
+    }
+
+    if (typeof attr.value === 'string') {
+      attrValue = attr.value;
+    }
+
+    const attrVal = ProductAttributeValueSchema.parse({
+      identifier: ProductAttributeValueIdentifierSchema.parse({
+        key: attrValue,
+      } satisfies Partial<ProductAttributeValueIdentifier>),
+      value: String(attrValue),
+      label: String(attrValue),
+    } satisfies Partial<ProductAttributeValue>);
+
+    return attrVal;
+  }
 }