@reactionary/source 0.0.37 → 0.0.39

package/otel/src/trace-decorator.ts

@@ -26,38 +26,38 @@ function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
 
   if (value === null) return 'null';
   if (value === undefined) return 'undefined';
-  
+
   const type = typeof value;
-  
+
   if (type === 'string' || type === 'number' || type === 'boolean') {
     return String(value);
   }
-  
+
   if (type === 'function') {
     return `[Function: ${(value as { name?: string }).name || 'anonymous'}]`;
   }
-  
+
   if (value instanceof Date) {
     return value.toISOString();
   }
-  
+
   if (value instanceof Error) {
     return `[Error: ${value.message}]`;
   }
-  
+
   if (Array.isArray(value)) {
     if (value.length > 10) {
       return `[Array(${value.length})]`;
     }
     try {
-      return JSON.stringify(value.map(item => 
+      return JSON.stringify(value.map(item =>
         safeSerialize(item, maxDepth, currentDepth + 1)
       ));
     } catch {
       return '[Array - circular reference]';
     }
   }
-  
+
   if (type === 'object') {
     try {
       const keys = Object.keys(value as object);
@@ -67,8 +67,8 @@ function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
       const simplified: Record<string, unknown> = {};
       for (const key of keys.slice(0, 10)) {
         simplified[key] = safeSerialize(
-          (value as Record<string, unknown>)[key], 
-          maxDepth, 
+          (value as Record<string, unknown>)[key],
+          maxDepth,
           currentDepth + 1
         );
       }
@@ -77,14 +77,14 @@ function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
       return '[Object - circular reference]';
     }
   }
-  
+
   return String(value);
 }
 
 /**
  * TypeScript decorator for tracing function execution
  * Automatically creates OpenTelemetry spans for decorated methods
- * Supports both Stage 2 (legacy) and Stage 3 decorator syntax
+ * Uses Stage 2 (legacy) decorator syntax
  * 
  * @example
  * ```typescript
@@ -93,7 +93,7 @@ function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
  *   async fetchData(id: string): Promise<Data> {
  *     // method implementation
  *   }
- * 
+ *
  *   @traced({ spanName: 'custom-operation', captureResult: false })
  *   processData(data: Data): void {
  *     // method implementation
@@ -101,50 +101,30 @@ function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
  * }
  * ```
  */
-export function traced(options: TracedOptions = {}): any {
+export function traced(options: TracedOptions = {}): MethodDecorator {
   const {
-    captureArgs = true,
-    captureResult = true,
+    captureArgs = false,
+    captureResult = false,
     spanName,
     spanKind = SpanKind.INTERNAL
   } = options;
 
-  // Stage 2 (legacy) decorator
   return function (
     target: any,
-    propertyKey?: string | symbol,
-    descriptor?: PropertyDescriptor
-  ): any {
-    // Handle Stage 3 decorator (when called with context)
-    if (typeof propertyKey === 'object' && propertyKey && 'kind' in propertyKey) {
-      const context = propertyKey as any;
-      const originalMethod = target;
-      const methodName = String(context.name);
-      
-      return createTracedMethod(originalMethod, methodName, {
-        captureArgs,
-        captureResult,
-        spanName,
-        spanKind
-      });
-    }
+    propertyKey: string | symbol,
+    descriptor: PropertyDescriptor
+  ): PropertyDescriptor {
+    const originalMethod = descriptor.value;
+    const methodName = String(propertyKey);
     
-    // Handle Stage 2 decorator
-    if (descriptor && typeof descriptor.value === 'function') {
-      const originalMethod = descriptor.value;
-      const methodName = String(propertyKey);
-      
-      descriptor.value = createTracedMethod(originalMethod, methodName, {
-        captureArgs,
-        captureResult,
-        spanName,
-        spanKind
-      });
-      
-      return descriptor;
-    }
+    descriptor.value = createTracedMethod(originalMethod, methodName, {
+      captureArgs,
+      captureResult,
+      spanName,
+      spanKind
+    });
     
-    return target;
+    return descriptor;
   };
 }
 
@@ -160,80 +140,79 @@ function createTracedMethod(
 ): any {
   const { captureArgs, captureResult, spanName, spanKind } = options;
   
-  function tracedMethod(this: any, ...args: any[]): any {
+  async function tracedMethod(this: any, ...args: any[]): Promise<any> {
     const tracer = getTracer();
     const className = this?.constructor?.name || 'Unknown';
     const effectiveSpanName = spanName || `${className}.${methodName}`;
-    
-    // Start the span
-    const span = tracer.startSpan(effectiveSpanName, {
+
+    // Use startActiveSpan to ensure proper context propagation
+    return tracer.startActiveSpan(effectiveSpanName, {
       kind: spanKind,
       attributes: {
         'function.name': methodName,
         'function.class': className,
       }
-    });
-
-    // Capture arguments if enabled
-    if (captureArgs && args.length > 0) {
-      args.forEach((arg, index) => {
-        try {
-          span.setAttribute(`function.args.${index}`, safeSerialize(arg));
-        } catch {
-          span.setAttribute(`function.args.${index}`, '[Serialization error]');
-        }
-      });
-      span.setAttribute('function.args.count', args.length);
-    }
+    }, async (span) => {
+      // Capture arguments if enabled
+      if (captureArgs && args.length > 0) {
+        args.forEach((arg, index) => {
+          try {
+            span.setAttribute(`function.args.${index}`, safeSerialize(arg));
+          } catch {
+            span.setAttribute(`function.args.${index}`, '[Serialization error]');
+          }
+        });
+        span.setAttribute('function.args.count', args.length);
+      }
 
-    // Helper function to finalize span with result
-    const finalizeSpan = (result: unknown, isError = false) => {
-      if (!isError && captureResult && result !== undefined) {
-        try {
-          span.setAttribute('function.result', safeSerialize(result));
-        } catch {
-          span.setAttribute('function.result', '[Serialization error]');
+      // Helper function to set span attributes and status
+      const setSpanResult = (result: unknown, isError = false) => {
+        if (!isError && captureResult && result !== undefined) {
+          try {
+            span.setAttribute('function.result', safeSerialize(result));
+          } catch {
+            span.setAttribute('function.result', '[Serialization error]');
+          }
         }
-      }
-      
-      if (isError) {
-        span.setStatus({
-          code: SpanStatusCode.ERROR,
-          message: result instanceof Error ? result.message : String(result)
-        });
-        if (result instanceof Error) {
-          span.recordException(result);
+        
+        if (isError) {
+          span.setStatus({
+            code: SpanStatusCode.ERROR,
+            message: result instanceof Error ? result.message : String(result)
+          });
+          if (result instanceof Error) {
+            span.recordException(result);
+          }
+        } else {
+          span.setStatus({ code: SpanStatusCode.OK });
         }
-      } else {
-        span.setStatus({ code: SpanStatusCode.OK });
-      }
-      
-      span.end();
-    };
+        
+        span.end();
+      };
 
-    try {
-      const result = originalMethod.apply(this, args);
-      
-      // Handle async functions
-      if (result instanceof Promise) {
-        return result
-          .then((value) => {
-            finalizeSpan(value);
+      try {
+        const result = originalMethod.apply(this, args);
+        
+        // Handle async functions - await them to keep span open
+        if (result instanceof Promise) {
+          try {
+            const value = await result;
+            setSpanResult(value);
             return value;
-          })
-          .catch((error) => {
-            finalizeSpan(error, true);
+          } catch (error) {
+            setSpanResult(error, true);
             throw error;
-          });
+          }
+        }
+        
+        // Handle sync functions
+        setSpanResult(result);
+        return result;
+      } catch (error) {
+        setSpanResult(error, true);
+        throw error;
       }
-      
-      // Handle sync functions
-      finalizeSpan(result);
-      return result;
-    } catch (error) {
-      finalizeSpan(error, true);
-      throw error;
-    }
+    });
   }
 
   // Preserve the original function's name and properties
@@ -243,4 +222,4 @@ function createTracedMethod(
   });
 
   return tracedMethod;
-}
+}

package/otel/src/tracer.ts

@@ -8,7 +8,6 @@ import {
   SpanOptions,
   Attributes,
 } from '@opentelemetry/api';
-import { isOtelInitialized } from './sdk';
 
 const TRACER_NAME = '@reactionary/otel';
 const TRACER_VERSION = '0.0.1';
@@ -17,8 +16,9 @@ let globalTracer: Tracer | null = null;
 
 export function getTracer(): Tracer {
   if (!globalTracer) {
-    // Ensure OTEL is initialized before creating tracer
-    isOtelInitialized();
+    // Simply get the tracer from the API
+    // If the SDK is not initialized by the host application,
+    // this will return a ProxyTracer that produces NonRecordingSpans
     globalTracer = trace.getTracer(TRACER_NAME, TRACER_VERSION);
   }
   return globalTracer;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.0.37",
+  "version": "0.0.39",
   "license": "MIT",
   "private": false,
   "dependencies": {
@@ -33,6 +33,7 @@
     "algoliasearch": "^5.23.4",
     "connect-redis": "^8.1.0",
     "cors": "^2.8.5",
+    "dotenv": "^17.2.2",
     "express": "^5.1.0",
     "express-session": "^1.18.1",
     "ioredis": "^5.6.1",

package/providers/commercetools/package.json

@@ -5,6 +5,7 @@
   "types": "src/index.d.ts",
   "dependencies": {
     "@reactionary/core": "0.0.1",
+    "@reactionary/otel": "0.0.1",
     "zod": "4.0.0-beta.20250430T185432",
     "@commercetools/ts-client": "^3.2.2",
     "@commercetools/platform-sdk": "^8.8.0"

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

@@ -1,4 +1,4 @@
-import { CartSchema, Client, IdentitySchema, InventorySchema, PriceSchema, ProductSchema, SearchResultSchema, Cache } from "@reactionary/core";
+import { CartSchema, Client, IdentitySchema, InventorySchema, PriceSchema, ProductSchema, SearchResultSchema, Cache, CategorySchema } from "@reactionary/core";
 import { CommercetoolsCapabilities } from "../schema/capabilities.schema";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
 import { CommercetoolsProductProvider } from '../providers/product.provider';
@@ -7,9 +7,10 @@ import { CommercetoolsIdentityProvider } from "../providers/identity.provider";
 import { CommercetoolsCartProvider } from "../providers/cart.provider";
 import { CommercetoolsInventoryProvider } from "../providers/inventory.provider";
 import { CommercetoolsPriceProvider } from "../providers/price.provider";
+import { CommercetoolsCategoryProvider } from "../providers/category.provider";
 
 export function withCommercetoolsCapabilities(
-    configuration: CommercetoolsConfiguration, 
+    configuration: CommercetoolsConfiguration,
     capabilities: CommercetoolsCapabilities
 ) {
     return (cache: Cache) => {
@@ -38,7 +39,10 @@ export function withCommercetoolsCapabilities(
         if (capabilities.price) {
             client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, cache);
         }
+        if (capabilities.category) {
+          client.category = new CommercetoolsCategoryProvider(configuration, CategorySchema, cache);
+        }
 
         return client;
     };
-}
+}

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

@@ -8,11 +8,14 @@ import {
   CartQueryById,
   Session,
   Cache,
+  Currency,
 } from '@reactionary/core';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 import { z } from 'zod';
 import { CommercetoolsClient } from '../core/client';
 import { Cart as CTCart } from '@commercetools/platform-sdk';
+import { traced } from '@reactionary/otel';
+
 
 export class CommercetoolsCartProvider<
   T extends Cart = Cart
@@ -29,6 +32,7 @@ export class CommercetoolsCartProvider<
     this.config = config;
   }
 
+  @traced()
   public override async getById(
     payload: CartQueryById,
     session: Session
@@ -48,9 +52,10 @@ export class CommercetoolsCartProvider<
       .get()
       .execute();
 
-    return this.composeCart(remote.body);
+    return this.parseSingle(remote.body, session);
   }
 
+  @traced()
   public override async add(
     payload: CartMutationItemAdd,
     session: Session
@@ -64,8 +69,9 @@ export class CommercetoolsCartProvider<
       const remoteCart = await client
         .post({
           body: {
-            currency: 'USD',
-            country: 'US',
+            currency: session.languageContext.currencyCode || 'USD',
+            country: session.languageContext.countryCode || 'US',
+            locale: session.languageContext.locale,
           },
         })
         .execute();
@@ -93,9 +99,10 @@ export class CommercetoolsCartProvider<
       })
       .execute();
 
-    return this.composeCart(remoteAdd.body);
+    return this.parseSingle(remoteAdd.body, session);
   }
 
+  @traced()
   public override async remove(
     payload: CartMutationItemRemove,
     session: Session
@@ -122,9 +129,10 @@ export class CommercetoolsCartProvider<
       })
       .execute();
 
-    return this.composeCart(remote.body);
+    return this.parseSingle(remote.body, session);
   }
 
+  @traced()
   public override async changeQuantity(
     payload: CartMutationItemQuantityChange,
     session: Session
@@ -152,9 +160,10 @@ export class CommercetoolsCartProvider<
       })
       .execute();
 
-    return this.composeCart(remote.body);
+    return this.parseSingle(remote.body, session  );
   }
 
+  @traced()
   protected getClient(session: Session) {
     const client = new CommercetoolsClient(this.config).getClient(
       session.identity.token
@@ -167,11 +176,51 @@ export class CommercetoolsCartProvider<
     return cartClient;
   }
 
-  protected composeCart(remote: CTCart): T {
+  @traced()
+  protected override parseSingle(remote: CTCart, session: Session): T {
     const result = this.newModel();
 
     result.identifier.key = remote.id;
 
+
+    result.name = remote.custom?.fields['name'] || '';
+    result.description = remote.custom?.fields['description'] || '';
+
+    const grandTotal = remote.totalPrice.centAmount || 0;
+    const shippingTotal = remote.shippingInfo?.price.centAmount || 0;
+    const productTotal = grandTotal - shippingTotal;
+    const taxTotal = remote.taxedPrice?.totalTax?.centAmount || 0;
+    const discountTotal = remote.discountOnTotalPrice?.discountedAmount.centAmount || 0;
+    const surchargeTotal = 0;
+    const currency = remote.totalPrice.currencyCode as Currency;
+
+    result.price = {
+      totalTax: {
+        value: taxTotal / 100,
+        currency
+      },
+      totalDiscount: {
+        value: discountTotal/ 100,
+        currency
+      },
+      totalSurcharge: {
+        value: surchargeTotal / 100,
+        currency
+      },
+      totalShipping: {
+        value: shippingTotal / 100,
+        currency: remote.shippingInfo?.price.currencyCode as Currency,
+      },
+      totalProductPrice: {
+        value: productTotal  / 100,
+        currency
+      },
+      grandTotal: {
+        value: grandTotal / 100,
+        currency
+      }
+    }
+
     for (const remoteItem of remote.lineItems) {
       const item = CartItemSchema.parse({});
 
@@ -179,14 +228,41 @@ export class CommercetoolsCartProvider<
       item.product.key = remoteItem.productId;
       item.quantity = remoteItem.quantity;
 
+      const unitPrice = remoteItem.price.value.centAmount;
+      const totalPrice = remoteItem.totalPrice.centAmount || 0;
+      const totalDiscount = remoteItem.price.discounted?.value.centAmount || 0;
+      const unitDiscount = totalDiscount / remoteItem.quantity;
+
+
+      item.price = {
+        unitPrice: {
+          value: unitPrice / 100,
+          currency
+        },
+        unitDiscount: {
+          value: (unitDiscount / 100),
+          currency
+        },
+        totalPrice: {
+          value: (totalPrice || 0) / 100,
+          currency
+        },
+        totalDiscount: {
+          value: totalDiscount / 100,
+          currency
+        },
+      }
+
       result.items.push(item);
     }
 
     result.meta = {
-      cache: { hit: false, key: remote.id },
+      cache: { hit: false, key: this.generateCacheKeySingle(result.identifier, session) },
       placeholder: false
     };
 
     return this.assert(result);
   }
+
+
 }