@reactionary/source 0.0.48 → 0.0.51

package/core/src/schemas/mutations/checkout.mutation.ts

@@ -0,0 +1,50 @@
+import  z from "zod";
+import { CartIdentifierSchema, AddressSchema, PaymentInstructionIdentifierSchema, PaymentInstructionSchema, ShippingInstructionSchema } from "../models";
+import { BaseMutationSchema } from "./base.mutation";
+
+
+export const CheckoutMutationInitiateCheckoutSchema = BaseMutationSchema.extend({
+    cart: CartIdentifierSchema.required(),
+    billingAddress: AddressSchema.omit({identifier: true}).optional(),
+    notificationEmail: z.string().optional(),
+    notificationPhone: z.string().optional(),
+});
+
+export const CheckoutMutationSetShippingAddressSchema = BaseMutationSchema.extend({
+    checkout: CartIdentifierSchema.required(),
+    shippingAddress: AddressSchema.omit({identifier: true}).required(),
+});
+
+
+export const CheckoutMutationFinalizeCheckoutSchema = BaseMutationSchema.extend({
+    checkout: CartIdentifierSchema.required(),
+});
+
+
+export const CheckoutMutationAddPaymentInstruction = BaseMutationSchema.extend({
+    paymentInstruction: PaymentInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
+    checkout: CartIdentifierSchema.required()
+});
+
+export const CheckoutMutationRemovePaymentInstruction = BaseMutationSchema.extend({
+    paymentInstruction: PaymentInstructionIdentifierSchema.required(),
+    checkout: CartIdentifierSchema.required()
+});
+
+
+
+export const CheckoutMutationSetShippingInstruction = BaseMutationSchema.extend({
+    shippingInstruction: ShippingInstructionSchema.omit({ meta: true, status: true, identifier: true }).required(),
+    checkout: CartIdentifierSchema.required()
+});
+
+
+
+
+
+export type CheckoutMutationInitiateCheckout = z.infer<typeof CheckoutMutationInitiateCheckoutSchema>;
+export type CheckoutMutationSetShippingAddress = z.infer<typeof CheckoutMutationSetShippingAddressSchema>;
+export type CheckoutMutationFinalizeCheckout = z.infer<typeof CheckoutMutationFinalizeCheckoutSchema>;
+export type CheckoutMutationAddPaymentInstruction = z.infer<typeof CheckoutMutationAddPaymentInstruction>;
+export type CheckoutMutationRemovePaymentInstruction = z.infer<typeof CheckoutMutationRemovePaymentInstruction>;
+export type CheckoutMutationSetShippingInstruction = z.infer<typeof CheckoutMutationSetShippingInstruction>;

package/core/src/schemas/mutations/index.ts

@@ -1,6 +1,5 @@
 export * from './analytics.mutation';
 export * from './base.mutation';
-export * from './cart-payment.mutation';
 export * from './cart.mutation';
 export * from './identity.mutation';
 export * from './inventory.mutation';
@@ -8,3 +7,4 @@ export * from './price.mutation';
 export * from './product.mutation';
 export * from './profile.mutation';
 export * from './search.mutation';
+export * from './checkout.mutation';

package/core/src/schemas/queries/checkout.query.ts

@@ -0,0 +1,22 @@
+import type { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+import { CartIdentifierSchema, CheckoutIdentifierSchema } from '../models/identifiers.model';
+
+export const CheckoutQueryByIdSchema = BaseQuerySchema.extend({
+    identifier: CheckoutIdentifierSchema.required()
+});
+
+
+export const CheckoutQueryForAvailableShippingMethodsSchema = BaseQuerySchema.extend({
+    checkout: CheckoutIdentifierSchema.required()
+});
+
+export const CheckoutQueryForAvailablePaymentMethodsSchema = BaseQuerySchema.extend({
+    checkout: CheckoutIdentifierSchema.required()
+});
+
+
+
+export type CheckoutQueryForAvailableShippingMethods = z.infer<typeof CheckoutQueryForAvailableShippingMethodsSchema>;
+export type CheckoutQueryForAvailablePaymentMethods = z.infer<typeof CheckoutQueryForAvailablePaymentMethodsSchema>;
+export type CheckoutQueryById = z.infer<typeof CheckoutQueryByIdSchema>;

package/core/src/schemas/queries/index.ts

@@ -1,6 +1,5 @@
 export * from './analytics.query';
 export * from './base.query';
-export * from './cart-payment.query';
 export * from './cart.query';
 export * from './category.query';
 export * from './identity.query';
@@ -9,4 +8,6 @@ export * from './price.query';
 export * from './product.query';
 export * from './profile.query';
 export * from './search.query';
-export * from './store.query';
+export * from './store.query';
+export * from './order.query';
+export * from './checkout.query';

package/core/src/schemas/queries/order.query.ts

@@ -0,0 +1,9 @@
+import type { z } from 'zod';
+import { BaseQuerySchema } from './base.query';
+import { OrderIdentifierSchema } from '../models/identifiers.model';
+
+export const OrderQueryByIdSchema = BaseQuerySchema.extend({
+    order: OrderIdentifierSchema.required()
+});
+
+export type OrderQueryById = z.infer<typeof OrderQueryByIdSchema>;

package/core/src/schemas/queries/product.query.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
+import { SKUIdentifierSchema } from '../models';
 
 export const ProductQueryBySlugSchema = BaseQuerySchema.extend({
     slug: z.string()
@@ -9,5 +10,11 @@ export const ProductQueryByIdSchema = BaseQuerySchema.extend({
     id: z.string()
 });
 
+export const ProductQueryBySKUSchema = BaseQuerySchema.extend({
+    sku: SKUIdentifierSchema.default(() => SKUIdentifierSchema.parse({})),
+});
+
+
 export type ProductQueryBySlug = z.infer<typeof ProductQueryBySlugSchema>;
-export type ProductQueryById = z.infer<typeof ProductQueryByIdSchema>;
+export type ProductQueryById = z.infer<typeof ProductQueryByIdSchema>;
+export type ProductQueryBySKU = z.infer<typeof ProductQueryBySKUSchema>;

package/otel/src/trace-decorator.ts

@@ -85,7 +85,7 @@ function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
  * TypeScript decorator for tracing function execution
  * Automatically creates OpenTelemetry spans for decorated methods
  * Uses Stage 2 (legacy) decorator syntax
- * 
+ *
  * @example
  * ```typescript
  * class MyService {
@@ -116,14 +116,14 @@ export function traced(options: TracedOptions = {}): MethodDecorator {
   ): PropertyDescriptor {
     const originalMethod = descriptor.value;
     const methodName = String(propertyKey);
-    
+
     descriptor.value = createTracedMethod(originalMethod, methodName, {
       captureArgs,
       captureResult,
       spanName,
       spanKind
     });
-    
+
     return descriptor;
   };
 }
@@ -139,7 +139,7 @@ function createTracedMethod(
   }
 ): any {
   const { captureArgs, captureResult, spanName, spanKind } = options;
-  
+
   function tracedMethod(this: any, ...args: any[]): any {
     const tracer = getTracer();
     const className = this?.constructor?.name || 'Unknown';
@@ -174,7 +174,7 @@ function createTracedMethod(
             span.setAttribute('function.result', '[Serialization error]');
           }
         }
-        
+
         if (isError) {
           span.setStatus({
             code: SpanStatusCode.ERROR,
@@ -186,13 +186,13 @@ function createTracedMethod(
         } else {
           span.setStatus({ code: SpanStatusCode.OK });
         }
-        
+
         span.end();
       };
 
       try {
         const result = originalMethod.apply(this, args);
-        
+
         // Handle async functions - await them to keep span open
         if (result instanceof Promise) {
           try {
@@ -205,7 +205,7 @@ function createTracedMethod(
             throw error;
           }
         }
-        
+
         // Handle sync functions
         setSpanResult(result);
         return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.0.48",
+  "version": "0.0.51",
   "license": "MIT",
   "private": false,
   "dependencies": {
@@ -34,6 +34,7 @@
     "algoliasearch": "^5.23.4",
     "connect-redis": "^8.1.0",
     "cors": "^2.8.5",
+    "debug": "^4.4.3",
     "dotenv": "^17.2.2",
     "express": "^5.1.0",
     "express-session": "^1.18.1",
@@ -82,6 +83,7 @@
     "@swc/cli": "~0.6.0",
     "@swc/core": "~1.5.7",
     "@swc/helpers": "~0.5.11",
+    "@types/debug": "^4.1.12",
     "@types/jest": "^29.5.12",
     "@types/node": "18.16.9",
     "@types/react": "19.0.0",

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

@@ -3,7 +3,8 @@ import type {
   ProductQueryById,
   ProductQueryBySlug,
   RequestContext,
-  Cache
+  Cache,
+  ProductQueryBySKU
 } from '@reactionary/core';
 import {
   ProductProvider
@@ -57,4 +58,9 @@ export class AlgoliaProductProvider<
 
     return this.assert(result);
   }
+
+    public override getBySKU(payload: ProductQueryBySKU, reqCtx: RequestContext): Promise<T> {
+      throw new Error('Method not implemented.');
+    }
+
 }

package/providers/commercetools/package.json

@@ -6,6 +6,7 @@
   "dependencies": {
     "@reactionary/core": "0.0.1",
     "@reactionary/otel": "0.0.1",
+    "debug": "^4.4.3",
     "zod": "4.1.9",
     "@commercetools/ts-client": "^4.2.1",
     "@commercetools/platform-sdk": "^8.8.0"

package/providers/commercetools/src/core/client.ts

@@ -7,8 +7,18 @@ import {
 import { createApiBuilderFromCtpClient } from '@commercetools/platform-sdk';
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { randomUUID } from 'crypto';
-import { GuestIdentitySchema, IdentitySchema, type RequestContext } from '@reactionary/core';
+import {
+  AnonymousIdentitySchema,
+  GuestIdentitySchema,
+  RegisteredIdentitySchema,
+  type RequestContext,
+} from '@reactionary/core';
 import * as crypto from 'crypto';
+import createDebug from 'debug'
+const debug = createDebug('commercetools:debug')
+
+
+
 
 export class RequestContextTokenCache implements TokenCache {
   constructor(protected context: RequestContext) {}
@@ -18,15 +28,11 @@ export class RequestContextTokenCache implements TokenCache {
   ): Promise<TokenStore | undefined> {
     const identity = this.context.identity;
 
-    if (identity.type !== 'Anonymous') {
-      return {
-        refreshToken: identity.refresh_token,
-        token: identity.token || '',
-        expirationTime: identity.expiry.getTime(),
-      };
-    }
-
-    return undefined;
+    return {
+      refreshToken: identity.refresh_token,
+      token: identity.token || '',
+      expirationTime: identity.expiry.getTime(),
+    };
   }
 
   public async set(
@@ -41,6 +47,8 @@ export class RequestContextTokenCache implements TokenCache {
   }
 }
 
+
+
 export class CommercetoolsClient {
   protected config: CommercetoolsConfiguration;
 
@@ -57,8 +65,6 @@ export class CommercetoolsClient {
     password: string,
     reqCtx: RequestContext
   ) {
-    const cache = new RequestContextTokenCache(reqCtx);
-
     const registrationBuilder =
       this.createBaseClientBuilder().withAnonymousSessionFlow({
         host: this.config.authUrl,
@@ -68,12 +74,12 @@ export class CommercetoolsClient {
           clientSecret: this.config.clientSecret,
         },
         scopes: this.config.scopes,
-        tokenCache: cache,
       });
 
     const registrationClient = createApiBuilderFromCtpClient(
       registrationBuilder.build()
     );
+
     const registration = await registrationClient
       .withProjectKey({ projectKey: this.config.projectKey })
       .me()
@@ -87,6 +93,8 @@ export class CommercetoolsClient {
       .execute();
 
     const login = await this.login(username, password, reqCtx);
+
+    return login;
   }
 
   public async login(
@@ -95,7 +103,6 @@ export class CommercetoolsClient {
     reqCtx: RequestContext
   ) {
     const cache = new RequestContextTokenCache(reqCtx);
-    const identity = reqCtx.identity;
 
     const loginBuilder = this.createBaseClientBuilder().withPasswordFlow({
       host: this.config.authUrl,
@@ -114,39 +121,52 @@ export class CommercetoolsClient {
     const login = await loginClient
       .withProjectKey({ projectKey: this.config.projectKey })
       .me()
-      .get()
+      .login()
+      .post({
+        body: {
+          email: username,
+          password: password,
+        },
+      })
       .execute();
 
-    identity.type = 'Registered';
-    identity.logonId = username;
-    identity.id = {
-      userId: login.body.id
-    };
+    reqCtx.identity = RegisteredIdentitySchema.parse({
+      ...reqCtx.identity,
+      type: 'Registered',
+      logonId: username,
+      id: {
+        userId: login.body.customer.id,
+      },
+    });
+
+    return reqCtx.identity;
   }
 
   public async logout(reqCtx: RequestContext) {
     const cache = new RequestContextTokenCache(reqCtx);
     await cache.set({ token: '', refreshToken: '', expirationTime: 0 });
 
-    reqCtx.identity = IdentitySchema.parse({});
+    reqCtx.identity = AnonymousIdentitySchema.parse({});
 
     // TODO: We could do token revocation here, if we wanted to. The above simply whacks the session.
+
+    return reqCtx.identity;
   }
 
   protected createClient(reqCtx: RequestContext) {
     const cache = new RequestContextTokenCache(reqCtx);
-    
+
     if (reqCtx.identity.type === 'Anonymous') {
       reqCtx.identity = GuestIdentitySchema.parse({
         id: {
           userId: crypto.randomUUID().toString(),
         },
-        type: 'Guest'
+        type: 'Guest',
       });
     }
 
     const identity = reqCtx.identity;
-    let builder = this.createBaseClientBuilder();
+    let builder = this.createBaseClientBuilder(reqCtx);
 
     if (!identity.token || !identity.refresh_token) {
       builder = builder.withAnonymousSessionFlow({
@@ -175,8 +195,14 @@ export class CommercetoolsClient {
     return createApiBuilderFromCtpClient(builder.build());
   }
 
-  protected createBaseClientBuilder() {
-    const builder = new ClientBuilder()
+
+
+
+
+
+
+  protected createBaseClientBuilder(reqCtx?: RequestContext) {
+    let builder = new ClientBuilder()
       .withProjectKey(this.config.projectKey)
       .withQueueMiddleware({
         concurrency: 20,
@@ -195,10 +221,6 @@ export class CommercetoolsClient {
           return Promise.resolve(body);
         },
       })
-      .withCorrelationIdMiddleware({
-        // ideally this would be pushed in as part of the session context, so we can trace it end-to-end
-        generate: () => `REACTIONARY-${randomUUID()}`,
-      })
       .withHttpMiddleware({
         retryConfig: {
           backoff: true,
@@ -215,8 +237,17 @@ export class CommercetoolsClient {
         httpClient: fetch,
       });
 
-    // CT's telemetry module is currently broken and consequently not included in the above (createTelemetryMiddleware)
+    const correlationId = reqCtx?.correlationId || 'REACTIONARY-' + (typeof crypto !== 'undefined' && 'randomUUID' in crypto ? crypto.randomUUID() : randomUUID());
+    builder = builder.withCorrelationIdMiddleware({
+      generate: () => correlationId,
+    });
+
+    // Note:
 
+    // CT's telemetry module is currently broken and consequently not included in the above (createTelemetryMiddleware)
+    if (debug.enabled) {
+      builder = builder.withLoggerMiddleware();
+    }
     return builder;
   }
 }

package/providers/commercetools/src/core/initialize.ts

@@ -7,7 +7,10 @@ import type {
     InventoryProvider,
     PriceProvider,
     CategoryProvider,
-    StoreProvider} from "@reactionary/core";
+    StoreProvider,
+    CheckoutProvider,
+    OrderProvider
+    } from "@reactionary/core";
 import {
     CartSchema,
     IdentitySchema,
@@ -16,7 +19,7 @@ import {
     ProductSchema,
     SearchResultSchema,
     CategorySchema,
-    CartPaymentInstructionSchema
+    CheckoutSchema
 } from "@reactionary/core";
 import type { CommercetoolsCapabilities } from "../schema/capabilities.schema";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
@@ -27,7 +30,7 @@ import { CommercetoolsCartProvider } from "../providers/cart.provider";
 import { CommercetoolsInventoryProvider } from "../providers/inventory.provider";
 import { CommercetoolsPriceProvider } from "../providers/price.provider";
 import { CommercetoolsCategoryProvider } from "../providers/category.provider";
-import { CommercetoolsCartPaymentProvider } from "../providers/cart-payment.provider";
+import { CommercetoolsCheckoutProvider } from "../providers";
 
 type CommercetoolsClient<T extends CommercetoolsCapabilities> =
     (T['cart'] extends true ? { cart: CartProvider } : object) &
@@ -37,8 +40,9 @@ type CommercetoolsClient<T extends CommercetoolsCapabilities> =
     (T['category'] extends true ? { category: CategoryProvider } : object) &
     (T['inventory'] extends true ? { inventory: InventoryProvider } : object) &
     (T['price'] extends true ? { price: PriceProvider } : object) &
-    (T['store'] extends true ? { store: StoreProvider } : object);
-
+    (T['store'] extends true ? { store: StoreProvider } : object) &
+    (T['order'] extends true ? { order: OrderProvider } : object) &
+    (T['checkout'] extends true ? { checkout: CheckoutProvider } : object) ;
 export function withCommercetoolsCapabilities<T extends CommercetoolsCapabilities>(
     configuration: CommercetoolsConfiguration,
     capabilities: T
@@ -74,8 +78,8 @@ export function withCommercetoolsCapabilities<T extends CommercetoolsCapabilitie
             client.category = new CommercetoolsCategoryProvider(configuration, CategorySchema, cache);
         }
 
-        if (capabilities.cartPayment) {
-          client.cartPayment = new CommercetoolsCartPaymentProvider(configuration, CartPaymentInstructionSchema, cache);
+        if (capabilities.checkout) {
+          client.checkout = new CommercetoolsCheckoutProvider(configuration, CheckoutSchema, cache);
         }
 
 

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

@@ -19,6 +19,7 @@ import type {
 ,
   Cache
 } from '@reactionary/core';
+
 import type { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import type { z } from 'zod';
 import { CommercetoolsClient } from '../core/client';
@@ -156,6 +157,7 @@ export class CommercetoolsCartProvider<
         version: carts.body.version || 0
       });
     } catch (e: any) {
+
       return CommercetoolsCartIdentifierSchema.parse({
         key: '',
       version: 0
@@ -415,7 +417,7 @@ export class CommercetoolsCartProvider<
     const ctId = cart as CommercetoolsCartIdentifier;
 
 
-
+       try {
         const response = await client.carts
           .withId({ ID: ctId.key })
           .post({
@@ -426,7 +428,14 @@ export class CommercetoolsCartProvider<
           })
           .execute();
 
+          if (response.error) {
+            console.error(response.error);
+          }
           return this.parseSingle(response.body, reqCtx);
+       } catch (e: any) {
+        console.error('Error applying actions to cart:', e);
+        throw e;
+       }
 
   }