@reactionary/source 0.0.30 → 0.0.32

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

@@ -1,13 +1,13 @@
 import {
   Cart,
   CartItemSchema,
-  CartMutation,
   CartMutationItemAdd,
   CartMutationItemQuantityChange,
   CartMutationItemRemove,
   CartProvider,
-  CartQuery,
+  CartQueryById,
   Session,
+  Cache,
 } from '@reactionary/core';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { z } from 'zod';
@@ -15,102 +15,43 @@ import { CommercetoolsClient } from '../core/client';
 import { Cart as CTCart } from '@commercetools/platform-sdk';
 
 export class CommercetoolsCartProvider<
-  T extends Cart = Cart,
-  Q extends CartQuery = CartQuery,
-  M extends CartMutation = CartMutation
-> extends CartProvider<T, Q, M> {
+  T extends Cart = Cart
+> extends CartProvider<T> {
   protected config: CommercetoolsConfiguration;
 
   constructor(
     config: CommercetoolsConfiguration,
     schema: z.ZodType<T>,
-    querySchema: z.ZodType<Q, Q>,
-    mutationSchema: z.ZodType<M, M>
+    cache: Cache
   ) {
-    super(schema, querySchema, mutationSchema);
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
-    const results = [];
-
-    for (const query of queries) {
-      if (query.cart.key) {
-        const client = this.getClient(session);
-        const remote = await client
-          .withId({ ID: query.cart.key })
-          .get()
-          .execute();
-
-        const result = this.composeCart(remote.body);
-
-        results.push(result);
-      }
-    }
-
-    return results;
-  }
-  protected override async process(
-    mutations: M[],
+  public override async getById(
+    payload: CartQueryById,
     session: Session
   ): Promise<T> {
-    let cart = this.newModel();
-
-    /**
-     * TODO: Optimize this, since CT as a remote provider allows us to forward multiple changes
-     * at once. As part of the current rewrite, this is mostly preserved as was before.
-     */
-    for (const mutation of mutations) {
-      switch (mutation.mutation) {
-        case 'add':
-          cart = await this.add(mutation, session);
-          break;
-        case 'adjustQuantity':
-          cart = await this.adjust(mutation, session);
-          break;
-        case 'remove':
-          cart = await this.remove(mutation, session);
-      }
+    if (!payload.cart.key) {
+      const result = this.newModel();
+      result.meta = {
+        cache: { hit: false, key: 'empty' },
+        placeholder: true
+      };
+      return this.assert(result);
     }
 
-    return cart;
-  }
-
-  protected async adjust(
-    payload: CartMutationItemQuantityChange,
-    session: Session
-  ): Promise<T> {
     const client = this.getClient(session);
-
-    // TODO: Consider whether we can skip this step by proxying the version as part of the CommercetoolsCartIdentifier
-    const existing = await client
-      .withId({ ID: payload.cart.key })
-      .get()
-      .execute();
-
     const remote = await client
       .withId({ ID: payload.cart.key })
-      .post({
-        body: {
-          version: existing.body.version,
-          actions: [
-            {
-              action: 'changeLineItemQuantity',
-              lineItemId: payload.item.key,
-              quantity: payload.quantity,
-            },
-          ],
-        },
-      })
+      .get()
       .execute();
 
-    const result = this.composeCart(remote.body);
-
-    return result;
+    return this.composeCart(remote.body);
   }
 
-    protected async add(
+  public override async add(
     payload: CartMutationItemAdd,
     session: Session
   ): Promise<T> {
@@ -132,10 +73,8 @@ export class CommercetoolsCartProvider<
       id = remoteCart.body.id;
       version = remoteCart.body.version;
     } else {
-        // TODO: Consider whether we can skip this step by proxying the version as part of the CommercetoolsCartIdentifier
-        const existing = await client.withId({ ID: payload.cart.key }).get().execute();
-        
-        version = existing.body.version;
+      const existing = await client.withId({ ID: payload.cart.key }).get().execute();
+      version = existing.body.version;
     }
 
     const remoteAdd = await client
@@ -154,18 +93,15 @@ export class CommercetoolsCartProvider<
       })
       .execute();
 
-    const result = this.composeCart(remoteAdd.body);
-
-    return result;
+    return this.composeCart(remoteAdd.body);
   }
 
-  protected async remove(
+  public override async remove(
     payload: CartMutationItemRemove,
     session: Session
   ): Promise<T> {
     const client = this.getClient(session);
 
-    // TODO: Consider whether we can skip this step by proxying the version as part of the CommercetoolsCartIdentifier
     const existing = await client
       .withId({ ID: payload.cart.key })
       .get()
@@ -186,9 +122,37 @@ export class CommercetoolsCartProvider<
       })
       .execute();
 
-    const result = this.composeCart(remote.body);
+    return this.composeCart(remote.body);
+  }
+
+  public override async changeQuantity(
+    payload: CartMutationItemQuantityChange,
+    session: Session
+  ): Promise<T> {
+    const client = this.getClient(session);
+
+    const existing = await client
+      .withId({ ID: payload.cart.key })
+      .get()
+      .execute();
+
+    const remote = await client
+      .withId({ ID: payload.cart.key })
+      .post({
+        body: {
+          version: existing.body.version,
+          actions: [
+            {
+              action: 'changeLineItemQuantity',
+              lineItemId: payload.item.key,
+              quantity: payload.quantity,
+            },
+          ],
+        },
+      })
+      .execute();
 
-    return result;
+    return this.composeCart(remote.body);
   }
 
   protected getClient(session: Session) {
@@ -218,6 +182,11 @@ export class CommercetoolsCartProvider<
       result.items.push(item);
     }
 
-    return result;
+    result.meta = {
+      cache: { hit: false, key: remote.id },
+      placeholder: false
+    };
+
+    return this.assert(result);
   }
 }

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

@@ -1,66 +1,34 @@
 import {
   Identity,
-  IdentityMutation,
   IdentityMutationLogin,
   IdentityProvider,
-  IdentityQuery,
+  IdentityQuerySelf,
   Session,
+  Cache,
 } from '@reactionary/core';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import z from 'zod';
 import { CommercetoolsClient } from '../core/client';
 
 export class CommercetoolsIdentityProvider<
-  T extends Identity = Identity,
-  Q extends IdentityQuery = IdentityQuery,
-  M extends IdentityMutation = IdentityMutation
-> extends IdentityProvider<T, Q, M> {
+  T extends Identity = Identity
+> extends IdentityProvider<T> {
   protected config: CommercetoolsConfiguration;
 
   constructor(
     config: CommercetoolsConfiguration,
     schema: z.ZodType<T>,
-    querySchema: z.ZodType<Q, Q>,
-    mutationSchema: z.ZodType<M, M>
+    cache: Cache
   ) {
-    super(schema, querySchema, mutationSchema);
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
-    const results = [];
-
-    for (const query of queries) {
-      const result = await this.get(session);
-
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  protected override async process(
-    mutations: M[],
+  public override async getSelf(
+    payload: IdentityQuerySelf,
     session: Session
   ): Promise<T> {
-    let result = this.newModel();
-
-    for (const mutation of mutations) {
-      switch (mutation.mutation) {
-        case 'login':
-          result = await this.login(mutation, session);
-          break;
-        case 'logout':
-          result = await this.logout(session);
-          break;
-      }
-    }
-
-    return result;
-  }
-
-  protected async get(session: Session): Promise<T> {
     const client = new CommercetoolsClient(this.config);
     const base = this.newModel();
 
@@ -71,17 +39,25 @@ export class CommercetoolsIdentityProvider<
         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 base;
+    return this.assert(base);
   }
 
-  protected async login(
+  public override async login(
     payload: IdentityMutationLogin,
     session: Session
   ): Promise<T> {
@@ -98,26 +74,34 @@ export class CommercetoolsIdentityProvider<
       base.type = 'Registered';
     }
 
-    // TODO: error handling
+    base.meta = {
+      cache: { hit: false, key: base.id || 'anonymous' },
+      placeholder: false
+    };
 
     session.identity = base;
 
-    return base;
+    return this.assert(base);
   }
 
-  protected async logout(session: Session): Promise<T> {
+  public override async logout(
+    payload: Record<string, never>,
+    session: Session
+  ): Promise<T> {
     const client = new CommercetoolsClient(this.config);
     const base = this.newModel();
 
     if (session.identity.token) {
-      const remote = await client.logout(session.identity.token);
-
-      // TODO: error handling
+      await client.logout(session.identity.token);
     }
 
+    base.meta = {
+      cache: { hit: false, key: 'anonymous' },
+      placeholder: false
+    };
     session.identity = base;
 
-    return base;
+    return this.assert(base);
   }
 
   protected extractCustomerIdFromScopes(scopes: string) {
@@ -127,4 +111,4 @@ export class CommercetoolsIdentityProvider<
 
     return id || '';
   }
-}
+}

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

@@ -1,59 +1,33 @@
 import {
-  BaseCachingStrategy,
   Inventory,
   InventoryProvider,
   InventoryQuery,
-  RedisCache,
   Session,
+  Cache,
 } from '@reactionary/core';
 import z from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { CommercetoolsClient } from '../core/client';
-import { InventoryMutation } from 'core/src/schemas/mutations/inventory.mutation';
 
 export class CommercetoolsInventoryProvider<
-  T extends Inventory = Inventory,
-  Q extends InventoryQuery = InventoryQuery,
-  M extends InventoryMutation = InventoryMutation
-> extends InventoryProvider<T, Q, M> {
+  T extends Inventory = Inventory
+> extends InventoryProvider<T> {
   protected config: CommercetoolsConfiguration;
-  protected cache = new RedisCache(new BaseCachingStrategy());
 
   constructor(
     config: CommercetoolsConfiguration,
     schema: z.ZodType<T>,
-    querySchema: z.ZodType<Q, Q>,
-    mutationSchema: z.ZodType<M, M>
+    cache: Cache
   ) {
-    super(schema, querySchema, mutationSchema);
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
-    const results = [];
-
-    for (const query of queries) {
-      let result = await this.cache.get(query, session, this.schema);
-      console.log('from cache: ', result);
-
-      if (!result) {
-        result = await this.get(query, session);
-
-        this.cache.put(query, session, result);
-      }
-
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  protected override process(mutations: M[], session: Session): Promise<T> {
-    throw new Error('Method not implemented.');
-  }
-
-  protected async get(query: Q, session: Session): Promise<T> {
+  public override async getBySKU(
+    payload: InventoryQuery,
+    session: Session
+  ): Promise<T> {
     const client = new CommercetoolsClient(this.config).getClient(
       session.identity?.token
     );
@@ -64,7 +38,7 @@ export class CommercetoolsInventoryProvider<
       .get({
         queryArgs: {
           where: 'sku=:sku',
-          'var.sku': query.sku,
+          'var.sku': payload.sku,
         },
       })
       .execute();
@@ -73,10 +47,14 @@ export class CommercetoolsInventoryProvider<
 
     if (remote.body.results.length > 0) {
       const inv = remote.body.results[0];
-
       base.quantity = inv.availableQuantity;
     }
 
-    return base;
+    base.meta = {
+      cache: { hit: false, key: payload.sku },
+      placeholder: false
+    };
+
+    return this.assert(base);
   }
 }

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

@@ -1,30 +1,30 @@
-import { BaseCachingStrategy, BaseMutation, Price, PriceProvider, PriceQuery, RedisCache, Session } from '@reactionary/core';
+import { Price, PriceProvider, PriceQueryBySku, Session, Cache } from '@reactionary/core';
 import z from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { CommercetoolsClient } from '../core/client';
-import { PriceMutation } from 'core/src/schemas/mutations/price.mutation';
 
 export class CommercetoolsPriceProvider<
-  T extends Price = Price,
-  Q extends PriceQuery = PriceQuery,
-  M extends PriceMutation = PriceMutation
-> extends PriceProvider<T, Q, M> {
+  T extends Price = Price
+> extends PriceProvider<T> {
   protected config: CommercetoolsConfiguration;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
+  public override async getBySKU(
+    payload: PriceQueryBySku,
+    session: Session
+  ): Promise<T> {
     const client = new CommercetoolsClient(this.config).getClient(
       session.identity?.token
     );
 
     const queryArgs = {
-      where: 'sku in :skus',
-      'var.skus': queries.map(x => x.sku.key),
+      where: 'sku=:sku',
+      'var.sku': payload.sku.key,
     };
 
     const remote = await client
@@ -35,32 +35,27 @@ export class CommercetoolsPriceProvider<
       })
       .execute();
 
-    const results = new Array<T>();
+    const base = this.newModel();
     
-    for (const query of queries) {
-        const base = this.newModel();
-        const matched = remote.body.results.find(x => x.sku === query.sku.key);
-
-        if (matched) {
-          base.value = {
-            cents: matched.value.centAmount,
-            currency: 'USD',
-          };
-        }
-
-        base.identifier = {
-          sku: {
-            key: query.sku.key
-          }
-        };
-
-        results.push(base);
+    if (remote.body.results.length > 0) {
+      const matched = remote.body.results[0];
+      base.value = {
+        cents: matched.value.centAmount,
+        currency: 'USD',
+      };
     }
 
-    return results;
-  }
+    base.identifier = {
+      sku: {
+        key: payload.sku.key
+      }
+    };
+
+    base.meta = {
+      cache: { hit: false, key: payload.sku.key },
+      placeholder: false
+    };
 
-  protected override process(mutation: BaseMutation[], session: Session): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.assert(base);
   }
-}
+}

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

@@ -1,10 +1,10 @@
 import {
   ProductProvider,
-  ProductQuery,
   Product,
+  ProductQueryById,
+  ProductQueryBySlug,
   Session,
-  BaseMutation,
-  ProductMutation,
+  Cache,
 } from '@reactionary/core';
 import { CommercetoolsClient } from '../core/client';
 import { z } from 'zod';
@@ -12,22 +12,36 @@ import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { ProductProjection } from '@commercetools/platform-sdk';
 
 export class CommercetoolsProductProvider<
-  T extends Product = Product,
-  Q extends ProductQuery = ProductQuery,
-  M extends ProductMutation = ProductMutation
-> extends ProductProvider<T, Q, M> {
+  T extends Product = Product
+> extends ProductProvider<T> {
   protected config: CommercetoolsConfiguration;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: ProductQuery[], session: Session): Promise<T[]> {
-    const ids = queries.filter((x) => x.query === 'id').map((x) => x.id);
-    const slugs = queries.filter((x) => x.query === 'slug').map((x) => x.slug);
+  public override async getById(
+    payload: ProductQueryById,
+    _session: Session
+  ): Promise<T> {
+    const client = new CommercetoolsClient(this.config).createAnonymousClient();
+
+    const remote = await client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .productProjections()
+      .withId({ ID: payload.id })
+      .get()
+      .execute();
+
+    return this.parse(remote.body);
+  }
 
+  public override async getBySlug(
+    payload: ProductQueryBySlug,
+    _session: Session
+  ): Promise<T> {
     const client = new CommercetoolsClient(this.config).createAnonymousClient();
 
     const remote = await client
@@ -35,36 +49,23 @@ export class CommercetoolsProductProvider<
       .productProjections()
       .get({
         queryArgs: {
-          where: 'slug(en-US in :slugs)',
-          'var.slugs': slugs
+          where: 'slug(en-US = :slug)',
+          'var.slug': payload.slug
         }
       })
       .execute();
 
-    console.log('remote: ', remote);
-
-    const results = new Array<T>;
-
-    for (const r of remote.body.results) {
-      const result = this.parse(r);
-
-      results.push(result);
+    if (remote.body.results.length === 0) {
+      throw new Error(`Product with slug '${payload.slug}' not found`);
     }
 
-    return results;
-  }
-
-  protected override process(
-    mutation: BaseMutation[],
-    session: Session
-  ): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.parse(remote.body.results[0]);
   }
 
   protected parse(data: ProductProjection): T {
     const base = this.newModel();
 
-    base.identifier.key = data.id;
+    base.identifier = { key: data.id };
     base.name = data.name['en-US'];
     base.slug = data.slug['en-US'];
 
@@ -72,19 +73,28 @@ export class CommercetoolsProductProvider<
       base.description = data.description['en-US'];
     }
 
-    if (data.masterVariant.images) {
+    if (data.masterVariant.images && data.masterVariant.images.length > 0) {
       base.image = data.masterVariant.images[0].url;
     }
 
+    base.images = [];
+    base.attributes = [];
+    base.skus = [];
+
     const variants = [data.masterVariant, ...data.variants];
     for (const variant of variants) {
-      base.skus.push({
-        identifier: {
-          key: variant.sku || '',
-        },
-      });
+      if (variant.sku) {
+        base.skus.push({
+          identifier: { key: variant.sku },
+        });
+      }
     }
 
-    return base;
+    base.meta = {
+      cache: { hit: false, key: data.id },
+      placeholder: false
+    };
+
+    return this.assert(base);
   }
 }