@reactionary/source 0.0.41 → 0.0.48

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

@@ -1,9 +1,9 @@
-import { CategoryProvider, Cache, Category, createPaginatedResponseSchema } from "@reactionary/core";
-import type { Session, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories } from "@reactionary/core";
-import z from "zod";
-import { CommercetoolsConfiguration } from "../schema/configuration.schema";
+import { CategoryProvider, createPaginatedResponseSchema } from "@reactionary/core";
+import type { Session, CategoryQueryById, CategoryQueryBySlug, CategoryQueryForBreadcrumb, CategoryQueryForChildCategories, CategoryQueryForTopCategories, RequestContext , Cache, Category} from "@reactionary/core";
+import type z from "zod";
+import type { CommercetoolsConfiguration } from "../schema/configuration.schema";
 import { CommercetoolsClient } from "../core/client";
-import { ByProjectKeyCategoriesRequestBuilder, CategoryPagedQueryResponse, Category as CTCategory } from "@commercetools/platform-sdk";
+import type { ByProjectKeyCategoriesRequestBuilder, CategoryPagedQueryResponse, Category as CTCategory } from "@commercetools/platform-sdk";
 import { traced } from "@reactionary/otel";
 
 export class CommercetoolsCategoryProvider<
@@ -18,9 +18,9 @@ export class CommercetoolsCategoryProvider<
     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;
+  protected async getClient(reqCtx: RequestContext): Promise<ByProjectKeyCategoriesRequestBuilder> {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+    return client.withProjectKey({ projectKey: this.config.projectKey }).categories();
   }
 
   /**
@@ -30,11 +30,11 @@ export class CommercetoolsCategoryProvider<
    * @returns
    */
   @traced()
-  public override async getById(payload: CategoryQueryById, session: Session): Promise<T> {
-    const client = this.getClient(session);
+  public override async getById(payload: CategoryQueryById, reqCtx: RequestContext): Promise<T> {
+    const client = await this.getClient(reqCtx);
     try {
       const response = await client.withKey({ key: payload.id.key }).get().execute();
-      return this.parseSingle(response.body, session);
+      return this.parseSingle(response.body, reqCtx);
     } catch (error) {
       const dummyCategory = this.newModel();
       dummyCategory.meta.placeholder = true;
@@ -50,14 +50,14 @@ export class CommercetoolsCategoryProvider<
    * @returns
    */
   @traced()
-  public override async getBySlug(payload: CategoryQueryBySlug, session: Session): Promise<T | null> {
-    const client = this.getClient(session);
+  public override async getBySlug(payload: CategoryQueryBySlug, reqCtx: RequestContext): Promise<T | null> {
+    const client = await this.getClient(reqCtx);
     try {
       const response = await client.get({
         queryArgs: {
-          where: `slug(${session.languageContext.locale}=:slug)`,
+          where: `slug(${reqCtx.languageContext.locale}=:slug)`,
           'var.slug': payload.slug,
-          storeProjection: session.storeIdentifier.key ,
+          storeProjection: reqCtx.storeIdentifier.key ,
           limit: 1,
           withTotal: false,
         }
@@ -65,7 +65,7 @@ export class CommercetoolsCategoryProvider<
       if (response.body.results.length === 0) {
         return null;
       }
-      return this.parseSingle(response.body.results[0], session);
+      return this.parseSingle(response.body.results[0], reqCtx);
     } catch (error) {
       console.error(`Error fetching category by slug:`, error);
       return null;
@@ -80,8 +80,8 @@ export class CommercetoolsCategoryProvider<
    * @returns
    */
   @traced()
-  public override async getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, session: Session): Promise<T[]> {
-    const client = this.getClient(session);
+  public override async getBreadcrumbPathToCategory(payload: CategoryQueryForBreadcrumb, reqCtx: RequestContext): Promise<T[]> {
+    const client = await this.getClient(reqCtx);
     const path: T[] = [];
     try {
       const response = await client.withKey({ key: payload.id.key }).get({
@@ -90,10 +90,10 @@ export class CommercetoolsCategoryProvider<
         }
       }).execute();
 
-      const category = this.parseSingle(response.body, session);
+      const category = this.parseSingle(response.body, reqCtx);
       for(const anc of response.body.ancestors || []) {
         if (anc.obj) {
-          const parsedAnc = this.parseSingle(anc.obj, session);
+          const parsedAnc = this.parseSingle(anc.obj, reqCtx);
           path.push(parsedAnc);
         }
       };
@@ -117,12 +117,12 @@ export class CommercetoolsCategoryProvider<
    * @returns
    */
   @traced()
-  public override async findChildCategories(payload: CategoryQueryForChildCategories, session: Session) {
+  public override async findChildCategories(payload: CategoryQueryForChildCategories, reqCtx: RequestContext) {
 
     // 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);
+    const client = await this.getClient(reqCtx);
 
     try {
       const parentCategory = await client.withKey({ key: payload.parentId.key }).get().execute();
@@ -138,14 +138,14 @@ export class CommercetoolsCategoryProvider<
             limit: payload.paginationOptions.pageSize,
             offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize,
             sort: 'orderHint asc',
-            storeProjection: session.storeIdentifier.key ,
+            storeProjection: reqCtx.storeIdentifier.key ,
           },
         })
         .execute();
 
-      const result = this.parsePaginatedResult(response.body, session);
+      const result = this.parsePaginatedResult(response.body, reqCtx);
       result.meta = {
-        cache: { hit: false, key: this.generateCacheKeyPaginatedResult('children-of-' + payload.parentId.key, result, session) },
+        cache: { hit: false, key: this.generateCacheKeyPaginatedResult('children-of-' + payload.parentId.key, result, reqCtx) },
         placeholder: false
       };
       return result;
@@ -156,9 +156,9 @@ export class CommercetoolsCategoryProvider<
   }
 
   @traced()
-  public override async findTopCategories(payload: CategoryQueryForTopCategories, session: Session) {
+  public override async findTopCategories(payload: CategoryQueryForTopCategories, reqCtx: RequestContext) {
 
-    const client = this.getClient(session);
+    const client = await this.getClient(reqCtx);
     try {
       const response = await client.get({
           queryArgs: {
@@ -166,14 +166,14 @@ export class CommercetoolsCategoryProvider<
             limit: payload.paginationOptions.pageSize,
             offset: (payload.paginationOptions.pageNumber - 1) * payload.paginationOptions.pageSize,
             sort: 'orderHint asc',
-            storeProjection: session.storeIdentifier.key ,
+            storeProjection: reqCtx.storeIdentifier.key ,
           },
         })
         .execute();
 
-      const result = this.parsePaginatedResult(response.body, session);
+      const result = this.parsePaginatedResult(response.body, reqCtx);
       result.meta = {
-        cache: { hit: false, key: this.generateCacheKeyPaginatedResult('top', result, session) },
+        cache: { hit: false, key: this.generateCacheKeyPaginatedResult('top', result, reqCtx) },
         placeholder: false
       };
       return result;
@@ -191,9 +191,9 @@ export class CommercetoolsCategoryProvider<
    * into the typed domain model.
    */
   @traced()
-  protected override parseSingle(_body: unknown, session: Session): T {
+  protected override parseSingle(_body: unknown, reqCtx: RequestContext): T {
     const body = _body as CTCategory;
-    const languageContext = session.languageContext;
+    const languageContext = reqCtx.languageContext;
 
     const model = this.newModel();
 
@@ -214,7 +214,7 @@ export class CommercetoolsCategoryProvider<
     });
 
     model.meta = {
-      cache: { hit: false, key: this.generateCacheKeySingle(model.identifier, session) },
+      cache: { hit: false, key: this.generateCacheKeySingle(model.identifier, reqCtx) },
       placeholder: false
     };
 
@@ -223,10 +223,10 @@ export class CommercetoolsCategoryProvider<
 
 
   @traced()
-  protected override parsePaginatedResult(_body: unknown, session: Session) {
+  protected override parsePaginatedResult(_body: unknown, reqCtx: RequestContext) {
     const body = _body as  CategoryPagedQueryResponse;
 
-    const items = body.results.map(x => this.parseSingle(x, session));
+    const items = body.results.map(x => this.parseSingle(x, reqCtx));
 
     const result = createPaginatedResponseSchema(this.schema).parse({
       meta: {

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

@@ -1,13 +1,14 @@
 import {
-  Identity,
-  IdentityMutationLogin,
+  type Identity,
+  type IdentityMutationLogin,
+  type IdentityQuerySelf,
+  type RequestContext,
+  type Cache,
   IdentityProvider,
-  IdentityQuerySelf,
-  Session,
-  Cache,
+  type IdentityMutationRegister,
 } from '@reactionary/core';
-import { CommercetoolsConfiguration } from '../schema/configuration.schema';
-import z from 'zod';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import type z from 'zod';
 import { CommercetoolsClient } from '../core/client';
 
 export class CommercetoolsIdentityProvider<
@@ -27,88 +28,35 @@ export class CommercetoolsIdentityProvider<
 
   public override async getSelf(
     payload: IdentityQuerySelf,
-    session: Session
+    reqCtx: RequestContext
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config);
-    const base = this.newModel();
-
-    if (session.identity.token) {
-      const remote = await client.introspect(session.identity.token);
-
-      if (remote.active) {
-        const current = this.schema.safeParse(session.identity);
-
-        if (current.success) {
-          current.data.meta = {
-            cache: { hit: false, key: session.identity.id || 'anonymous' },
-            placeholder: false
-          };
-          return current.data;
-        }
-      }
-    }
-
-    base.meta = {
-      cache: { hit: false, key: 'anonymous' },
-      placeholder: false
-    };
-    session.identity = base;
-
-    return this.assert(base);
+    return this.assert(reqCtx.identity as T);
   }
 
   public override async login(
     payload: IdentityMutationLogin,
-    session: Session
+    reqCtx: RequestContext
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config);
-    const remote = await client.login(payload.username, payload.password);
-    const base = this.newModel();
-
-    if (remote && remote.access_token) {
-      base.issued = new Date();
-      base.expiry = new Date();
-      base.expiry.setSeconds(base.expiry.getSeconds() + remote.expires_in);
-      base.id = this.extractCustomerIdFromScopes(remote.scope);
-      base.token = remote.access_token;
-      base.type = 'Registered';
-    }
+    await new CommercetoolsClient(this.config).login(payload.username, payload.password, reqCtx);
 
-    base.meta = {
-      cache: { hit: false, key: base.id || 'anonymous' },
-      placeholder: false
-    };
-
-    session.identity = base;
-
-    return this.assert(base);
+    return this.getSelf({}, reqCtx);
   }
 
   public override async logout(
     payload: Record<string, never>,
-    session: Session
+    reqCtx: RequestContext
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config);
-    const base = this.newModel();
-
-    if (session.identity.token) {
-      await client.logout(session.identity.token);
-    }
+    await new CommercetoolsClient(this.config).logout(reqCtx);
 
-    base.meta = {
-      cache: { hit: false, key: 'anonymous' },
-      placeholder: false
-    };
-    session.identity = base;
-
-    return this.assert(base);
+    return this.getSelf({}, reqCtx);
   }
 
-  protected extractCustomerIdFromScopes(scopes: string) {
-    const scopeList = scopes.split(' ');
-    const customerScope = scopeList.find((x) => x.startsWith('customer_id'));
-    const id = customerScope?.split(':')[1];
+  public override async register(
+    payload: IdentityMutationRegister,
+    reqCtx: RequestContext
+  ): Promise<T> {
+    await new CommercetoolsClient(this.config).register(payload.username, payload.password, reqCtx);
 
-    return id || '';
+    return this.getSelf({}, reqCtx);
   }
-}
+}

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

@@ -4,4 +4,6 @@ export * from './identity.provider';
 export * from './inventory.provider';
 export * from './price.provider';
 export * from './product.provider';
+export * from './profile.provider';
 export * from './search.provider';
+export * from './store.provider';

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

@@ -1,15 +1,18 @@
-import {
+import type {
   Inventory,
-  InventoryProvider,
-  InventoryQuery,
-  Session,
+  RequestContext,
   Cache,
-  LanguageContext,
+  InventoryQueryBySKU,
 } from '@reactionary/core';
-import z from 'zod';
-import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { InventoryProvider } from '@reactionary/core';
+import type z from 'zod';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { CommercetoolsClient } from '../core/client';
-import { InventoryEntry as CTInventory } from '@commercetools/platform-sdk';
+import type {
+  InventoryEntry,
+  ProductVariant,
+  ProductVariantAvailability,
+} from '@commercetools/platform-sdk';
 export class CommercetoolsInventoryProvider<
   T extends Inventory = Inventory
 > extends InventoryProvider<T> {
@@ -25,53 +28,79 @@ export class CommercetoolsInventoryProvider<
     this.config = config;
   }
 
+  protected async getClient(reqCtx: RequestContext) {
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+    return client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .inventory();
+  }
+
   public override async getBySKU(
-    payload: InventoryQuery,
-    session: Session
+    payload: InventoryQueryBySKU,
+    reqCtx: RequestContext
   ): Promise<T> {
-    const client = new CommercetoolsClient(this.config).getClient(
-      session.identity?.token
-    );
+    const client = await new CommercetoolsClient(this.config).getClient(reqCtx);
+
+    // TODO: We can't query by supplyChannel.key, so we have to resolve it first.
+    // This is probably a good candidate for internal data caching at some point.
+    const channel = await client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .channels()
+      .withKey({ key: payload.fulfilmentCenter.key })
+      .get()
+      .execute();
+
+    const channelId = channel.body.id;
 
     const remote = await client
       .withProjectKey({ projectKey: this.config.projectKey })
       .inventory()
       .get({
         queryArgs: {
-          where: `sku=${payload.sku}`,
+          where: 'sku=:sku AND supplyChannel(id=:channel)',
+          'var.sku': payload.sku.key,
+          'var.channel': channelId,
+          expand: 'supplyChannel'
         },
       })
       .execute();
 
-    return this.parseSingle(remote.body, session);
-  }
+    const result = remote.body.results[0];
 
-  protected override parseSingle(_body: unknown, session: Session): T {
-      const body = _body as CTInventory;
-      const model = this.newModel();
+    const model = this.parseSingle(result, reqCtx);
 
-      model.identifier = {
-        sku: { key: body.sku },
-        channelId: {
-          key: body.supplyChannel?.id || 'online'
-        },
-      };
-      model.sku = body.sku;
-      model.quantity = body.availableQuantity;
-
-      if (model.quantity > 0 ) {
-        model.status = 'inStock';
-      } else {
-        model.status = 'outOfStock';
-      }
-
-      model.meta = {
-        cache: { hit: false, key: this.generateCacheKeySingle(model.identifier, session) },
-        placeholder: false
-      };
-
-      return this.assert(model);
+    return model;
   }
 
+  protected override parseSingle(
+    body: InventoryEntry,
+    reqCtx: RequestContext
+  ): T {
+    const model = this.newModel();
+
+    model.identifier = {
+      sku: { key: body.sku || '' },
+      fulfillmentCenter: {
+        key: body.supplyChannel?.obj?.key || '',
+      },
+    };
+
+    model.quantity = body.availableQuantity || 0;
 
+    if (model.quantity > 0) {
+      model.status = 'inStock';
+    } else {
+      model.status = 'outOfStock';
+    }
+
+    model.meta = {
+      cache: {
+        hit: false,
+        key: this.generateCacheKeySingle(model.identifier, reqCtx),
+      },
+      placeholder: false,
+    };
+
+    return this.assert(model);
+  }
 }

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

@@ -1,47 +1,64 @@
-import { Price, PriceProvider, Cache, Currency, TieredPriceSchema, TieredPrice } from '@reactionary/core';
-import type { PriceQueryBySku, Session } from '@reactionary/core';
-import z from 'zod';
-import { CommercetoolsConfiguration } from '../schema/configuration.schema';
+import { PriceProvider, TieredPriceSchema } from '@reactionary/core';
+import type { PriceQueryBySku, RequestContext , Price, Cache, Currency, TieredPrice } from '@reactionary/core';
+import type z from 'zod';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { CommercetoolsClient } from '../core/client';
-import { StandalonePrice as CTPrice } from '@commercetools/platform-sdk';
+import type { Price as CTPrice, ProductVariant as CTProductVariant } from '@commercetools/platform-sdk';
 export class CommercetoolsPriceProvider<
   T extends Price = Price
 > extends PriceProvider<T> {
   protected config: CommercetoolsConfiguration;
 
+
+
   constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
     super(schema, cache);
 
     this.config = config;
   }
 
-  public getClient(session: Session) {
-    return new CommercetoolsClient(this.config).getClient(session.identity?.token).withProjectKey({ projectKey: this.config.projectKey }).standalonePrices();
+
+  protected async getClient(reqCtx: RequestContext) {
+    const client = await new CommercetoolsClient(this.config).getClient(
+      reqCtx
+    );
+    return client.withProjectKey({ projectKey: this.config.projectKey }).productProjections()
   }
 
 
-  public override async getBySKUs(payload: PriceQueryBySku[], session: Session): Promise<T[]> {
 
-    const client = this.getClient(session);
+  public override async getBySKUs(payload: PriceQueryBySku[], reqCtx: RequestContext): Promise<T[]> {
+
+    const client = await this.getClient(reqCtx);
 
     //  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 channels = await this.getChannels(reqCtx);
 
     const response = await client.get({
-      queryArgs,
+      queryArgs: {
+        staged: false,
+        priceCountry: 'US',
+        priceCustomerGroup: undefined,
+        priceChannel: channels.offerChannelGUID,
+        priceCurrency: reqCtx.languageContext.currencyCode,
+       // storeProjection: reqCtx.storeIdentifier?.key || undefined,
+        where: 'variants(sku in (:skus)) OR (masterVariant(sku in (:skus))) ',
+        'var.skus': payload.map(p => p.sku.key),
+        limit: payload.length,
+      },
     }).execute();
 
     const result = [];
+    const allReturnedVariants = [...response.body.results.map(x => x.variants).flat(), ...response.body.results.map(x => x.masterVariant).flat()];
+    // Now we need to match the skus requested with the prices returned.
     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));
+      const foundSku = allReturnedVariants.find(v => v.sku === p.sku.key);
+
+      if (!foundSku) {
+        result.push(this.createEmptyPriceResult(p.sku.key, reqCtx.languageContext.currencyCode ));
       } else {
-        result.push(this.getEmptyPriceResult(p.sku.key, session.languageContext.currencyCode ));
+        result.push(this.parseSingle(foundSku, reqCtx));
       }
     }
 
@@ -51,43 +68,29 @@ export class CommercetoolsPriceProvider<
 
   public override async getBySKU(
     payload: PriceQueryBySku,
-    session: Session
+    reqCtx: RequestContext
   ): 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=:sku',
-      'var.sku': payload.sku.key,
-    };
-
-    const remote = await client
-      .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 );
+    return this.getBySKUs([payload], reqCtx).then(r => r[0]);
   }
 
 
 
-  protected override parseSingle(_body: unknown, session: Session): T {
-    const body = _body as CTPrice;
+  protected override parseSingle(_body: unknown, reqCtx: RequestContext): T {
+    const body = _body as CTProductVariant;
+    const price = body.price as CTPrice | undefined;
 
-    const base = this.newModel();
+    if (!price) {
+      return this.createEmptyPriceResult(body.sku!, reqCtx.languageContext.currencyCode);
+    }
 
+    const base = this.newModel();
     base.unitPrice = {
-      value: (body.value.centAmount / 100),
-      currency: body.value.currencyCode as Currency,
+      value: (price.value.centAmount / 100),
+      currency: price.value.currencyCode as Currency,
     };
 
-    if (body.tiers && body.tiers.length > 0) {
-      const p  = body.tiers.map(x => {
+    if (price.tiers && price.tiers.length > 0) {
+      const p  = price.tiers.map(x => {
         const tp: TieredPrice = TieredPriceSchema.parse({});
         tp.minimumQuantity = x.minimumQuantity;
         tp.price = {
@@ -101,12 +104,12 @@ export class CommercetoolsPriceProvider<
 
     base.identifier = {
       sku: {
-        key: body.sku
+        key: body.sku!
       }
     };
 
     base.meta = {
-      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, session) },
+      cache: { hit: false, key: this.generateCacheKeySingle(base.identifier, reqCtx) },
       placeholder: false
     };
 
@@ -114,5 +117,34 @@ export class CommercetoolsPriceProvider<
 
   }
 
+  protected async getChannels(reqCtx: RequestContext) {
+
+    if (!(reqCtx.session['commercetools'] && reqCtx.session['commercetools'].offerChannelGUID && reqCtx.session['commercetools'].listChannelGUID)) {
+
+      /**
+       * Bah - have to be an admin to call these....
+       * So either we cache them in the session, or we make the user provide them in the config.
+       */
+
+   /*
+        const configClient = await new CommercetoolsClient(this.config).getClient(reqCtx);
+        const offerPriceChannelPromise = configClient.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key: 'Offer Price'}).get().execute();
+        const listPriceChannelPromise = configClient.withProjectKey({ projectKey: this.config.projectKey }).channels().withKey({ key: 'List Price'}).get().execute();
+
+        const [offerChannel, listChannel] = await Promise.all([offerPriceChannelPromise, listPriceChannelPromise]);
+    */
 
+        reqCtx.session['commercetools'] = {
+          ...reqCtx.session['commercetools'],
+          offerChannelGUID: undefined,
+          listChannelGUID: undefined
+        };
+    }
+
+
+    return {
+      offerChannelGUID: reqCtx.session['commercetools'].offerChannelGUID,
+      listChannelGUID: reqCtx.session['commercetools'].listChannelGUID
+    }
+  }
 }