@reactionary/source 0.0.52 → 0.2.16

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

@@ -6,57 +6,78 @@ import {
   type Cache,
   IdentityProvider,
   type IdentityMutationRegister,
+  Reactionary,
+  IdentityQuerySelfSchema,
+  IdentitySchema,
+  IdentityMutationRegisterSchema,
+  IdentityMutationLoginSchema,
+  type Result,
+  success,
 } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
 import type z from 'zod';
-import { CommercetoolsClient } from '../core/client.js';
+import type { CommercetoolsAPI } from '../core/client.js';
 
-export class CommercetoolsIdentityProvider<
-  T extends Identity = Identity
-> extends IdentityProvider<T> {
+export class CommercetoolsIdentityProvider extends IdentityProvider {
   protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
 
   constructor(
     config: CommercetoolsConfiguration,
-    schema: z.ZodType<T>,
-    cache: Cache
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
   ) {
-    super(schema, cache);
+    super(cache, context);
 
     this.config = config;
+    this.commercetools = commercetools;
   }
 
-  public override async getSelf(
-    payload: IdentityQuerySelf,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    return this.assert(reqCtx.identity as T);
+  @Reactionary({
+    inputSchema: IdentityQuerySelfSchema,
+    outputSchema: IdentitySchema,
+  })
+  public override async getSelf(payload: IdentityQuerySelf): Promise<Result<Identity>> {
+    const identity = await this.commercetools.introspect();
+
+    return success(identity);
   }
 
-  public override async login(
-    payload: IdentityMutationLogin,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const identity = await new CommercetoolsClient(this.config).login(payload.username, payload.password, reqCtx);
+  @Reactionary({
+    inputSchema: IdentityMutationLoginSchema,
+    outputSchema: IdentitySchema,
+  })
+  public override async login(payload: IdentityMutationLogin): Promise<Result<Identity>> {
+    const identity = await this.commercetools.login(
+      payload.username,
+      payload.password
+    );
 
-    return identity as T;
+    return success(identity);
   }
 
-  public override async logout(
-    payload: Record<string, never>,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const identity = await new CommercetoolsClient(this.config).logout(reqCtx);
+  @Reactionary({
+    outputSchema: IdentitySchema,
+  })
+  public override async logout(payload: Record<string, never>): Promise<Result<Identity>> {
+    const identity = await this.commercetools.logout();
 
-    return identity as T;
+    return success(identity);
   }
 
+  @Reactionary({
+    inputSchema: IdentityMutationRegisterSchema,
+    outputSchema: IdentitySchema,
+  })
   public override async register(
-    payload: IdentityMutationRegister,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    const identity = await new CommercetoolsClient(this.config).register(payload.username, payload.password, reqCtx);
+    payload: IdentityMutationRegister
+  ): Promise<Result<Identity>> {
+    const identity = await this.commercetools.register(
+      payload.username,
+      payload.password
+    );
 
-    return identity as T;
+    return success(identity);
   }
 }

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

@@ -2,11 +2,11 @@ export * from './cart.provider.js';
 export * from './category.provider.js';
 export * from './identity.provider.js';
 export * from './inventory.provider.js';
+export * from './order-search.provider.js';
 export * from './price.provider.js';
 export * from './product.provider.js';
 export * from './profile.provider.js';
-export * from './search.provider.js';
+export * from './product-search.provider.js';
 export * from './store.provider.js';
-
 export * from './order.provider.js';
 export * from './checkout.provider.js';

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

@@ -3,102 +3,104 @@ import type {
   RequestContext,
   Cache,
   InventoryQueryBySKU,
+  InventoryIdentifier,
+  InventoryStatus,
+  Result,
+  NotFoundError,
 } from '@reactionary/core';
-import { InventoryProvider } from '@reactionary/core';
-import type z from 'zod';
+import { InventoryProvider, InventoryQueryBySKUSchema, InventorySchema, Reactionary, success, error } from '@reactionary/core';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
-import { CommercetoolsClient } from '../core/client.js';
-import type {
-  InventoryEntry,
-} from '@commercetools/platform-sdk';
-export class CommercetoolsInventoryProvider<
-  T extends Inventory = Inventory
-> extends InventoryProvider<T> {
+import type { InventoryEntry } from '@commercetools/platform-sdk';
+import type { CommercetoolsAPI } from '../core/client.js';
+
+export class CommercetoolsInventoryProvider extends InventoryProvider {
   protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
 
   constructor(
     config: CommercetoolsConfiguration,
-    schema: z.ZodType<T>,
-    cache: Cache
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
   ) {
-    super(schema, cache);
+    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 })
-      .inventory();
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+    return client.withProjectKey({ projectKey: this.config.projectKey });
   }
 
-  public override async getBySKU(
-    payload: InventoryQueryBySKU,
-    reqCtx: RequestContext
-  ): Promise<T> {
-    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=:sku AND supplyChannel(id=:channel)',
-          'var.sku': payload.sku.key,
-          'var.channel': channelId,
-          expand: 'supplyChannel'
-        },
-      })
-      .execute();
-
-    const result = remote.body.results[0];
-
-    const model = this.parseSingle(result, reqCtx);
-
-    return model;
+  @Reactionary({
+    inputSchema: InventoryQueryBySKUSchema,
+    outputSchema: InventorySchema,
+  })
+  public override async getBySKU(payload: InventoryQueryBySKU): Promise<Result<Inventory, NotFoundError>> {
+    const client = await this.getClient();
+
+    try {
+
+      // 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
+        .channels()
+        .withKey({ key: payload.fulfilmentCenter.key })
+        .get()
+        .execute();
+
+      const channelId = channel.body.id;
+
+      const remote = await client
+        .inventory()
+        .get({
+          queryArgs: {
+            where: 'sku=:sku AND supplyChannel(id=:channel)',
+            'var.sku': payload.variant.sku,
+            'var.channel': channelId,
+            expand: 'supplyChannel',
+          },
+        })
+        .execute();
+
+      const result = remote.body.results[0];
+
+      const model = this.parseSingle(result);
+
+
+      return success(model);
+    } catch (err) {
+      console.error('Error fetching inventory by SKU and Fulfillment Center:', error, payload);
+      return error<NotFoundError>({
+        type: 'NotFound',
+        identifier: payload
+      });
+    }
   }
 
-  protected override parseSingle(
-    body: InventoryEntry,
-    reqCtx: RequestContext
-  ): T {
-    const model = this.newModel();
-
-    model.identifier = {
-      sku: { key: body.sku || '' },
+  protected parseSingle(body: InventoryEntry): Inventory {
+    const identifier = {
+      variant: { sku: body.sku || '' },
       fulfillmentCenter: {
         key: body.supplyChannel?.obj?.key || '',
       },
-    };
+    } satisfies InventoryIdentifier;
 
-    model.quantity = body.availableQuantity || 0;
+    const quantity = body.availableQuantity || 0;
+    let status: InventoryStatus = 'outOfStock';
 
-    if (model.quantity > 0) {
-      model.status = 'inStock';
-    } else {
-      model.status = 'outOfStock';
+    if (quantity > 0) {
+      status = 'inStock';
     }
 
-    model.meta = {
-      cache: {
-        hit: false,
-        key: this.generateCacheKeySingle(model.identifier, reqCtx),
-      },
-      placeholder: false,
-    };
+    const result = {
+      identifier,
+      quantity,
+      status,
+    } satisfies Inventory;
 
-    return this.assert(model);
+    return result;
   }
 }

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

@@ -0,0 +1,220 @@
+import type {
+  RequestContext,
+  Cache,
+  OrderSearchQueryByTerm,
+  OrderSearchResult,
+  Result,
+  OrderSearchIdentifier,
+  MonetaryAmount,
+  Currency,
+  IdentityIdentifier,
+  Address,
+  OrderStatus,
+} from '@reactionary/core';
+import {
+  OrderSearchProvider,
+  OrderSearchQueryByTermSchema,
+  OrderSearchResultSchema,
+  type OrderSearchResultItem,
+  Reactionary,
+  success,
+} from '@reactionary/core';
+import type { CommercetoolsConfiguration } from '../schema/configuration.schema.js';
+import type { CommercetoolsAPI } from '../core/client.js';
+import createDebug from 'debug';
+import type { Order as CTOrder, OrderPagedSearchResponse , Address as CTAddress, OrderPagedQueryResponse} from '@commercetools/platform-sdk';
+
+const debug = createDebug('reactionary:commercetools:order-search');
+
+export class CommercetoolsOrderSearchProvider extends OrderSearchProvider {
+  protected config: CommercetoolsConfiguration;
+  protected commercetools: CommercetoolsAPI;
+
+  constructor(
+    config: CommercetoolsConfiguration,
+    cache: Cache,
+    context: RequestContext,
+    commercetools: CommercetoolsAPI
+  ) {
+    super(cache, context);
+
+    this.config = config;
+    this.commercetools = commercetools;
+  }
+
+  protected async getClient() {
+    const client = await this.commercetools.getClient();
+    return client
+      .withProjectKey({ projectKey: this.config.projectKey })
+      .me()
+      .orders();
+  }
+
+  @Reactionary({
+    inputSchema: OrderSearchQueryByTermSchema,
+    outputSchema: OrderSearchResultSchema,
+  })
+  public async queryByTerm(payload: OrderSearchQueryByTerm): Promise<Result<OrderSearchResult>> {
+    debug('queryByTerm', payload);
+
+    const client = await this.getClient();
+    const where: string[] = [];
+    if (payload.search) {
+      if (payload.search.term) {
+        debug('Search by term is not implemented yet in CommercetoolsOrderSearchProvider');
+      }
+
+      if (payload.search.partNumber) {
+        for (const partNumber of payload.search.partNumber) {
+          where.push(`lineItems(variant(sku="${partNumber}"))`);
+        }
+      }
+
+      if (payload.search.user && payload.search.user.userId) {
+        where.push(`customerId="${payload.search.user.userId}"`);
+      }
+
+      if (payload.search.orderStatus) {
+        const orderStatusWhere = payload.search.orderStatus.map(x => {
+          if (x === 'AwaitingPayment') {
+            return `Open`
+          }
+          if (x === 'ReleasedToFulfillment') {
+            return `Confirmed`
+          }
+          if (x === 'Shipped') {
+            return `Completed`
+          }
+          if (x === 'Cancelled') {
+            return `Cancelled`
+          }
+          return `orderState="${x}"`
+        }).join(' OR ');
+        where.push(orderStatusWhere);
+      }
+
+      if (payload.search.startDate) {
+        where.push(`createdAt >= "${payload.search.startDate}"`);
+      }
+
+      if (payload.search.endDate) {
+        where.push(`createdAt <= "${payload.search.endDate}"`);
+      }
+    }
+
+    const response = await client.get({
+      queryArgs: {
+        where: where,
+        withTotal: true,
+          limit: payload.search.paginationOptions.pageSize,
+          offset:
+            (payload.search.paginationOptions.pageNumber - 1) *
+            payload.search.paginationOptions.pageSize,
+      }
+    }).execute();
+
+    const responseBody = response.body;
+    const result = this.parsePaginatedResult(
+      responseBody,
+      payload
+    ) as OrderSearchResult;
+
+    if (debug.enabled) {
+      debug(
+        `Search for term "${payload.search.term}" returned ${responseBody.results.length} orders (page ${payload.search.paginationOptions.pageNumber} of ${result.totalPages})`
+      );
+    }
+
+    return success(result);
+  }
+
+  protected parseAddress(remote: CTAddress) {
+    return {
+      countryCode: remote.country || '',
+      firstName: remote.firstName || '',
+      lastName: remote.lastName || '',
+      streetAddress: remote.streetName || '',
+      streetNumber: remote.streetNumber || '',
+      postalCode: remote.postalCode || '',
+      city: remote.city || '',
+      identifier: {
+        nickName: '',
+      },
+      region: '',
+    } satisfies Address;
+  }
+
+
+  protected parseSingle(body: CTOrder) {
+    const identifier = { key: body.id };
+    const userId: IdentityIdentifier = {
+      userId: body.customerId || body.anonymousId || '',
+    };
+    const customerName = `${body.billingAddress?.firstName} ${body.billingAddress?.lastName}`;
+    const shippingAddress = this.parseAddress(body.shippingAddress!);
+    const orderDate = body.createdAt;
+   let orderStatus: OrderStatus = 'AwaitingPayment';
+    if (body.paymentState === 'Pending' && body.orderState === 'Open') {
+      orderStatus = 'AwaitingPayment';
+    } else if (
+      body.paymentState === 'Paid' &&
+      body.orderState === 'Confirmed'
+    ) {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (body.shipmentState === 'Ready' && body.orderState === 'Confirmed') {
+      orderStatus = 'ReleasedToFulfillment';
+    }
+    if (
+      (body.shipmentState === 'Shipped' ||
+        body.shipmentState === 'Delivered') &&
+      body.orderState === 'Completed'
+    ) {
+      orderStatus = 'Shipped';
+    }
+    const inventoryStatus = body.shipmentState as OrderSearchResultItem['inventoryStatus'];
+    const totalAmount: MonetaryAmount = {
+      currency: body.totalPrice ? body.totalPrice.currencyCode as Currency : this.context.languageContext.currencyCode,
+      value: body.totalPrice ? body.totalPrice.centAmount / 100 : 0
+    };
+
+    const order = {
+      identifier,
+      userId,
+      customerName,
+      shippingAddress,
+      orderDate,
+      orderStatus,
+      inventoryStatus,
+      totalAmount
+    } satisfies OrderSearchResultItem;
+
+    return order;
+  }
+
+  protected parsePaginatedResult(
+    body: OrderPagedQueryResponse,
+    query: OrderSearchQueryByTerm
+  ) {
+    const identifier = {
+      ...query.search,
+    } satisfies OrderSearchIdentifier;
+
+    const orders: OrderSearchResultItem[] = body.results.map((o) => {
+      return this.parseSingle(o);
+    })
+
+    const result = {
+      identifier,
+      pageNumber: (Math.ceil(body.offset / body.limit) || 0) + 1,
+      pageSize: body.limit,
+      totalCount: body.total || 0,
+      totalPages: Math.ceil((body.total || 0) / body.limit || 0) + 1,
+      items: orders,
+    } satisfies OrderSearchResult;
+
+    return result;
+  }
+
+
+}