@reactionary/source 0.0.37 → 0.0.39

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

@@ -0,0 +1,244 @@
+import { CategoryProvider, Cache, Category, Session, CategoryIdentifier,  PaginationOptions,  createPaginatedResponseSchema, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "@reactionary/core";
+import z from "zod";
+import { CommercetoolsConfiguration } from "../schema/configuration.schema";
+import { CommercetoolsClient } from "../core/client";
+import { ByProjectKeyCategoriesRequestBuilder, CategoryPagedQueryResponse, Category as CTCategory } from "@commercetools/platform-sdk";
+import { traced } from "@reactionary/otel";
+
+export class CommercetoolsCategoryProvider<
+  T extends Category = Category,
+> extends CategoryProvider<T> {
+
+  protected config: CommercetoolsConfiguration;
+
+  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
+
+    this.config = config;
+  }
+
+  protected getClient(session: Session): ByProjectKeyCategoriesRequestBuilder {
+    const client = new CommercetoolsClient(this.config).getClient(session.identity.token).withProjectKey({ projectKey: this.config.projectKey }).categories();
+    return client;
+  }
+
+  /**
+   * Look it up by the category ID (key in commercetools), and if not there, return a placeholder.
+   * @param id
+   * @param session
+   * @returns
+   */
+  @traced()
+  public override async getById(payload: CategoryQueryById, session: Session): Promise<T> {
+    const client = this.getClient(session);
+    try {
+      const response = await client.withKey({ key: payload.id.key }).get().execute();
+      return this.parseSingle(response.body, session);
+    } catch (error) {
+      console.error(`Error fetching category by ID ${payload.id.key}:`, error);
+      const dummyCategory = this.newModel();
+      dummyCategory.meta.placeholder = true;
+      dummyCategory.identifier = { key: payload.id.key };
+      return dummyCategory;
+    }
+  }
+
+  /**
+   * Resolve the category by slug, in the users current locale.
+   * @param slug
+   * @param session
+   * @returns
+   */
+  @traced()
+  public override async getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null> {
+    const client = this.getClient(session);
+    try {
+      const response = await client.get({
+        queryArgs: {
+          where: `slug(${session.languageContext.locale}=:slug)`,
+          'var.slug': payload.slug,
+          storeProjection: session.storeIdentifier.key ,
+          limit: 1,
+          withTotal: false,
+        }
+      }).execute();
+      if (response.body.results.length === 0) {
+        return null;
+      }
+      return this.parseSingle(response.body.results[0], session);
+    } catch (error) {
+      console.error(`Error fetching category by slug:`, error);
+      return null;
+    }
+  }
+
+  /**
+   * Returns the breadcrumb path to the category, i.e. all parents up to the root.
+   * The returned order is from root to leaf.
+   * @param id
+   * @param session
+   * @returns
+   */
+  @traced()
+  public override async getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]> {
+    const client = this.getClient(session);
+    const path: T[] = [];
+    try {
+      const response = await client.withKey({ key: payload.id.key }).get({
+        queryArgs: {
+          expand: 'ancestors[*]'
+        }
+      }).execute();
+
+      const category = this.parseSingle(response.body, session);
+      for(const anc of response.body.ancestors || []) {
+        if (anc.obj) {
+          const parsedAnc = this.parseSingle(anc.obj, session);
+          path.push(parsedAnc);
+        }
+      };
+      path.push(category);
+    } catch (error) {
+      console.error(`Error fetching category path for  ${payload.id.key}:`, error);
+    }
+    return path;
+  }
+
+
+  /**
+   * Returns a page of child categories for the given parent category ID.
+   * You must provide the pagination options to control the size of the result set.
+   * If you expect your frontend will load many many categories, consider adding a "load more" button, or lazy load the next page.
+   *
+   * This is cached by ID + page number + page size + locale + store
+   * @param id
+   * @param paginationOptions
+   * @param session
+   * @returns
+   */
+  @traced()
+  public override async findChildCategories(payload: CategoryQueryForChildCategories, session: Session) {
+
+    // ok, so for Commercetools we can't actually query by the parents key, so we have to first resolve the key to an ID, then query by that.
+    // This is a bit of a pain, but we can cache the result of the first lookup for a short period to mitigate it.
+
+    const client = this.getClient(session);
+
+    try {
+      const parentCategory = await client.withKey({ key: payload.parentId.key }).get().execute();
+
+      // it is true, we could just do a withKey and get the children directly, but that would not be paginated.
+      // So we do it the hard way, and query by parent ID instead.
+      // This also means we can sort the results, which is nice.
+
+      const response = await client.get({
+          queryArgs: {
+            where: 'parent(id = :parentId)',
+            'var.parentId': parentCategory.body.id,
+            limit: payload.paginationOptions.pageSize,
+            offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize,
+            sort: 'orderHint asc',
+            storeProjection: session.storeIdentifier.key ,
+          },
+        })
+        .execute();
+
+      const result = this.parsePaginatedResult(response.body, session);
+      result.meta = {
+        cache: { hit: false, key: this.generateCacheKeyPaginatedResult('children-of-' + payload.parentId.key, result, session) },
+        placeholder: false
+      };
+      return result;
+    } catch (error) {
+      console.error(`Error fetching category path for  ${payload.parentId.key}:`, error);
+    }
+    return createPaginatedResponseSchema(this.schema).parse({});
+  }
+
+  @traced()
+  public override async findTopCategories(payload: CategoryQueryForTopCategories, session: Session) {
+
+    const client = this.getClient(session);
+    try {
+      const response = await client.get({
+          queryArgs: {
+            where: 'parent is not defined',
+            limit: payload.paginationOptions.pageSize,
+            offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize,
+            sort: 'orderHint asc',
+            storeProjection: session.storeIdentifier.key ,
+          },
+        })
+        .execute();
+
+      const result = this.parsePaginatedResult(response.body, session);
+      result.meta = {
+        cache: { hit: false, key: this.generateCacheKeyPaginatedResult('top', result, session) },
+        placeholder: false
+      };
+      return result;
+    } catch (error) {
+      console.error(`Error fetching category top categories:`, error);
+    }
+    return createPaginatedResponseSchema(this.schema).parse({});
+  }
+
+
+
+
+    /**
+   * Handler for parsing a response from a remote provider and converting it
+   * into the typed domain model.
+   */
+  @traced()
+  protected override parseSingle(_body: unknown, session: Session): T {
+    const body = _body as CTCategory;
+    const languageContext = session.languageContext;
+
+    const model = this.newModel();
+
+    model.identifier = { key: body.key! };
+    model.name = body.name[languageContext.locale] || 'No Name';
+    model.slug = body.slug ? (body.slug[languageContext.locale] || '') : '';
+    model.text = body.description ? (body.description[languageContext.locale] || '') : '';
+
+    model.parentCategory = body.parent && body.parent.obj  && body.parent.obj?.key ? { key: body.parent.obj.key } : undefined;
+
+    model.images = (body.assets || []).filter(asset => asset.sources.length > 0).filter(x => x.sources[0].contentType?.startsWith('image/')).map( (asset) => {
+      return {
+        sourceUrl: asset.sources[0].uri,
+        altText: asset.description?.[languageContext.locale] || asset.name[languageContext.locale] || '',
+        height: asset.sources[0].dimensions?.h || 0,
+        width: asset.sources[0].dimensions?.w || 0,
+      }
+    });
+
+    model.meta = {
+      cache: { hit: false, key: this.generateCacheKeySingle(model.identifier, session) },
+      placeholder: false
+    };
+
+    return this.assert(model);
+  }
+
+
+  @traced()
+  protected override parsePaginatedResult(_body: unknown, session: Session) {
+    const body = _body as  CategoryPagedQueryResponse;
+
+    const items = body.results.map(x => this.parseSingle(x, session));
+
+    const result = createPaginatedResponseSchema(this.schema).parse({
+      meta: {
+        cache: { hit: false, key: 'unknown' },
+        placeholder: false
+      },
+      pageNumber: Math.floor(body.offset / body.count) + 1,
+      pageSize: body.count,
+      totalCount: body.total || 0,
+      totalPages: Math.ceil((body.total ?? 0) / body.count),
+      items: items
+    });
+    return result;
+  }
+}

package/providers/commercetools/src/providers/index.ts

@@ -0,0 +1,7 @@
+export * from './cart.provider';
+export * from './category.provider';
+export * from './identity.provider';
+export * from './inventory.provider';
+export * from './price.provider';
+export * from './product.provider';
+export * from './search.provider';

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

@@ -4,11 +4,12 @@ import {
   InventoryQuery,
   Session,
   Cache,
+  LanguageContext,
 } from '@reactionary/core';
 import z from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { CommercetoolsClient } from '../core/client';
-
+import { InventoryEntry as CTInventory } from '@commercetools/platform-sdk';
 export class CommercetoolsInventoryProvider<
   T extends Inventory = Inventory
 > extends InventoryProvider<T> {
@@ -37,24 +38,40 @@ export class CommercetoolsInventoryProvider<
       .inventory()
       .get({
         queryArgs: {
-          where: 'sku=:sku',
-          'var.sku': payload.sku,
+          where: `sku=${payload.sku}`,
         },
       })
       .execute();
 
-    const base = this.newModel();
+    return this.parseSingle(remote.body, session);
+  }
+
+  protected override parseSingle(_body: unknown, session: Session): T {
+      const body = _body as CTInventory;
+      const model = this.newModel();
 
-    if (remote.body.results.length > 0) {
-      const inv = remote.body.results[0];
-      base.quantity = inv.availableQuantity;
-    }
+      model.identifier = {
+        sku: { key: body.sku },
+        channelId: {
+          key: body.supplyChannel?.id || 'online'
+        },
+      };
+      model.sku = body.sku;
+      model.quantity = body.availableQuantity;
 
-    base.meta = {
-      cache: { hit: false, key: payload.sku },
-      placeholder: false
-    };
+      if (model.quantity > 0 ) {
+        model.status = 'inStock';
+      } else {
+        model.status = 'outOfStock';
+      }
 
-    return this.assert(base);
+      model.meta = {
+        cache: { hit: false, key: this.generateCacheKeySingle(model.identifier, session) },
+        placeholder: false
+      };
+
+      return this.assert(model);
   }
-}
+
+
+}

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

@@ -1,8 +1,8 @@
-import { Price, PriceProvider, PriceQueryBySku, Session, Cache } from '@reactionary/core';
+import { Price, PriceProvider, PriceQueryBySku, Session, Cache, Currency, TieredPriceSchema, MonetaryAmountSchema, TieredPrice } from '@reactionary/core';
 import z from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { CommercetoolsClient } from '../core/client';
-
+import { StandalonePrice as CTPrice } from '@commercetools/platform-sdk';
 export class CommercetoolsPriceProvider<
   T extends Price = Price
 > extends PriceProvider<T> {
@@ -14,48 +14,104 @@ export class CommercetoolsPriceProvider<
     this.config = config;
   }
 
+  public getClient(session: Session) {
+    return new CommercetoolsClient(this.config).getClient(session.identity?.token).withProjectKey({ projectKey: this.config.projectKey }).standalonePrices();
+  }
+
+
+  public override async getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]> {
+
+    const client = this.getClient(session);
+
+    //  AND (validFrom is not defined OR validFrom <= now()) AND (validUntil is not defined OR validUntil >= now())
+    const queryArgs = {
+      where: 'sku in (:skus)',
+      'var.skus': payload.map(p => p.sku.key),
+    };
+
+
+    const response = await client.get({
+      queryArgs,
+    }).execute();
+
+    const result = [];
+    for(const p of payload) {
+      const matched = response.body.results.filter(x => x.sku === p.sku.key && x.value.currencyCode === session.languageContext.currencyCode);
+      if (matched && matched.length > 0) {
+        result.push(this.parseSingle(matched[0], session));
+      } else {
+        result.push(this.getEmptyPriceResult(p.sku.key, session.languageContext.currencyCode ));
+      }
+    }
+
+    return result;
+  }
+
+
   public override async getBySKU(
     payload: PriceQueryBySku,
     session: Session
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config).getClient(
-      session.identity?.token
-    );
-
+    const client = this.getClient(session);
+    //  AND (validFrom is not defined OR validFrom <= now()) AND (validUntil is not defined OR validUntil >= now())
     const queryArgs = {
       where: 'sku=:sku',
       'var.sku': payload.sku.key,
     };
 
     const remote = await client
-      .withProjectKey({ projectKey: this.config.projectKey })
-      .standalonePrices()
       .get({
         queryArgs,
       })
       .execute();
 
+
+      const matched = remote.body.results.filter(x => x.value.currencyCode === session.languageContext.currencyCode);
+      if (matched && matched.length > 0) {
+        return this.parseSingle(matched[0], session);
+      }
+      return this.getEmptyPriceResult(payload.sku.key, session.languageContext.currencyCode );
+  }
+
+
+
+  protected override parseSingle(_body: unknown, session: Session): T {
+    const body = _body as CTPrice;
+
     const base = this.newModel();
-    
-    if (remote.body.results.length > 0) {
-      const matched = remote.body.results[0];
-      base.value = {
-        cents: matched.value.centAmount,
-        currency: 'USD',
-      };
+
+    base.unitPrice = {
+      value: (body.value.centAmount / 100),
+      currency: body.value.currencyCode as Currency,
+    };
+
+    if (body.tiers && body.tiers.length > 0) {
+      const p  = body.tiers.map(x => {
+        const tp: TieredPrice = TieredPriceSchema.parse({});
+        tp.minimumQuantity = x.minimumQuantity;
+        tp.price = {
+          value: (x.value.centAmount / 100),
+          currency: x.value.currencyCode as Currency,
+        };
+        return tp;
+      });
+      base.tieredPrices = p;
     }
 
     base.identifier = {
       sku: {
-        key: payload.sku.key
+        key: body.sku
       }
     };
 
     base.meta = {
-      cache: { hit: false, key: payload.sku.key },
+      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, session) },
       placeholder: false
     };
 
     return this.assert(base);
+
   }
-}
+
+
+}

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

@@ -22,31 +22,31 @@ export class CommercetoolsProductProvider<
     this.config = config;
   }
 
+  public getClient(session: Session) {
+    return new CommercetoolsClient(this.config).getClient(session.identity?.token).withProjectKey({ projectKey: this.config.projectKey }).productProjections();
+  }
+
   public override async getById(
     payload: ProductQueryById,
-    _session: Session
+    session: Session
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+    const client = this.getClient(session);
 
     const remote = await client
-      .withProjectKey({ projectKey: this.config.projectKey })
-      .productProjections()
       .withId({ ID: payload.id })
       .get()
       .execute();
 
-    return this.parse(remote.body);
+    return this.parseSingle(remote.body, session);
   }
 
   public override async getBySlug(
     payload: ProductQueryBySlug,
-    _session: Session
+    session: Session
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+    const client = this.getClient(session);
 
     const remote = await client
-      .withProjectKey({ projectKey: this.config.projectKey })
-      .productProjections()
       .get({
         queryArgs: {
           where: 'slug(en-US = :slug)',
@@ -59,18 +59,19 @@ export class CommercetoolsProductProvider<
       throw new Error(`Product with slug '${payload.slug}' not found`);
     }
 
-    return this.parse(remote.body.results[0]);
+    return this.parseSingle(remote.body.results[0], session);
   }
 
-  protected parse(data: ProductProjection): T {
+  protected override parseSingle(dataIn: unknown, session: Session): T {
+    const data = dataIn as ProductProjection;
     const base = this.newModel();
 
     base.identifier = { key: data.id };
-    base.name = data.name['en-US'];
-    base.slug = data.slug['en-US'];
+    base.name = data.name[session.languageContext.locale];
+    base.slug = data.slug[session.languageContext.locale];
 
     if (data.description) {
-      base.description = data.description['en-US'];
+      base.description = data.description[session.languageContext.locale];
     }
 
     if (data.masterVariant.images && data.masterVariant.images.length > 0) {
@@ -91,10 +92,13 @@ export class CommercetoolsProductProvider<
     }
 
     base.meta = {
-      cache: { hit: false, key: data.id },
+      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, session) },
       placeholder: false
     };
 
     return this.assert(base);
   }
+
+
+
 }

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

@@ -23,7 +23,7 @@ export class CommercetoolsSearchProvider<
 
   public override async queryByTerm(
     payload: SearchQueryByTerm,
-    _session: Session
+    session: Session
   ): Promise<T> {
     const client = new CommercetoolsClient(this.config).createAnonymousClient();
 
@@ -34,16 +34,16 @@ export class CommercetoolsSearchProvider<
       .get({
         queryArgs: {
           limit: payload.search.pageSize,
-          offset: payload.search.pageSize * payload.search.page,
-          ['text.en-US']: payload.search.term,
+          offset: (payload.search.page - 1) * payload.search.pageSize,
+          [`text.${session.languageContext.locale}`]: payload.search.term,
         },
       })
       .execute();
 
-    return this.parseSearchResult(remote, payload);
+    return this.parseSearchResult(remote, payload, session);
   }
 
-  protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm): T {
+  protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm, session: Session): T {
     const result = this.newModel();
     const remoteData = remote as { body: { results: Array<{ id: string; name: Record<string, string>; slug?: Record<string, string>; masterVariant: { images?: Array<{ url?: string }> } }>; total?: number } };
 
@@ -52,8 +52,8 @@ export class CommercetoolsSearchProvider<
     for (const p of remoteData.body.results) {
       const product: SearchResultProduct = {
         identifier: { key: p.id },
-        name: p.name['en-US'],
-        slug: p.slug?.['en-US'] || p.id,
+        name: p.name[session.languageContext.locale] || p.id,
+        slug: p.slug?.[session.languageContext.locale] || p.id,
         image: p.masterVariant.images?.[0]?.url || 'https://placehold.co/400'
       };
 
@@ -68,4 +68,6 @@ export class CommercetoolsSearchProvider<
 
     return this.assert(result);
   }
+
+
 }

package/providers/commercetools/src/schema/capabilities.schema.ts

@@ -7,7 +7,8 @@ export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({
     identity: true,
     cart: true,
     inventory: true,
-    price: true
+    price: true,
+    category: true,
 }).partial();
 
 export type CommercetoolsCapabilities = z.infer<typeof CommercetoolsCapabilitiesSchema>;

package/providers/commercetools/src/schema/configuration.schema.ts

@@ -8,4 +8,4 @@ export const CommercetoolsConfigurationSchema = z.looseInterface({
     clientSecret: z.string()
 });
 
-export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;
+export type CommercetoolsConfiguration = z.infer<typeof CommercetoolsConfigurationSchema>;