@reactionary/source 0.0.30 → 0.0.32

package/otel/src/trace-decorator.ts

@@ -0,0 +1,246 @@
+import { SpanKind, SpanStatusCode } from '@opentelemetry/api';
+import { getTracer } from './tracer';
+
+/**
+ * Options for the @traced decorator
+ */
+export interface TracedOptions {
+  /** Whether to capture function arguments as span attributes (default: true) */
+  captureArgs?: boolean;
+  /** Whether to capture the return value as a span attribute (default: true) */
+  captureResult?: boolean;
+  /** Custom span name to use instead of the function name */
+  spanName?: string;
+  /** OpenTelemetry SpanKind (default: INTERNAL) */
+  spanKind?: SpanKind;
+}
+
+/**
+ * Safely serializes a value for use as a span attribute
+ * Handles circular references and large objects
+ */
+function safeSerialize(value: unknown, maxDepth = 3, currentDepth = 0): string {
+  if (currentDepth >= maxDepth) {
+    return '[Max depth reached]';
+  }
+
+  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 => 
+        safeSerialize(item, maxDepth, currentDepth + 1)
+      ));
+    } catch {
+      return '[Array - circular reference]';
+    }
+  }
+  
+  if (type === 'object') {
+    try {
+      const keys = Object.keys(value as object);
+      if (keys.length > 20) {
+        return `[Object with ${keys.length} keys]`;
+      }
+      const simplified: Record<string, unknown> = {};
+      for (const key of keys.slice(0, 10)) {
+        simplified[key] = safeSerialize(
+          (value as Record<string, unknown>)[key], 
+          maxDepth, 
+          currentDepth + 1
+        );
+      }
+      return JSON.stringify(simplified);
+    } catch {
+      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
+ * 
+ * @example
+ * ```typescript
+ * class MyService {
+ *   @traced()
+ *   async fetchData(id: string): Promise<Data> {
+ *     // method implementation
+ *   }
+ * 
+ *   @traced({ spanName: 'custom-operation', captureResult: false })
+ *   processData(data: Data): void {
+ *     // method implementation
+ *   }
+ * }
+ * ```
+ */
+export function traced(options: TracedOptions = {}): any {
+  const {
+    captureArgs = true,
+    captureResult = true,
+    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
+      });
+    }
+    
+    // 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;
+    }
+    
+    return target;
+  };
+}
+
+function createTracedMethod(
+  originalMethod: (...args: any[]) => any,
+  methodName: string,
+  options: {
+    captureArgs: boolean;
+    captureResult: boolean;
+    spanName?: string;
+    spanKind: SpanKind;
+  }
+): any {
+  const { captureArgs, captureResult, spanName, spanKind } = options;
+  
+  function tracedMethod(this: any, ...args: any[]): any {
+    const tracer = getTracer();
+    const className = this?.constructor?.name || 'Unknown';
+    const effectiveSpanName = spanName || `${className}.${methodName}`;
+    
+    // Start the span
+    const span = tracer.startSpan(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);
+    }
+
+    // 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]');
+        }
+      }
+      
+      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 });
+      }
+      
+      span.end();
+    };
+
+    try {
+      const result = originalMethod.apply(this, args);
+      
+      // Handle async functions
+      if (result instanceof Promise) {
+        return result
+          .then((value) => {
+            finalizeSpan(value);
+            return value;
+          })
+          .catch((error) => {
+            finalizeSpan(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
+  Object.defineProperty(tracedMethod, 'name', {
+    value: methodName,
+    configurable: true
+  });
+
+  return tracedMethod;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reactionary/source",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "license": "MIT",
   "private": false,
   "dependencies": {
@@ -40,6 +40,7 @@
     "posthog-node": "^4.18.0",
     "react": "19.0.0",
     "react-dom": "19.0.0",
+    "reflect-metadata": "^0.2.2",
     "rxjs": "~7.8.0",
     "search-insights": "^2.17.3",
     "superjson": "^2.2.2",

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

@@ -1,4 +1,4 @@
-import { Client, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema } from "@reactionary/core";
+import { Client, ProductSchema, Cache } from "@reactionary/core";
 import { AlgoliaProductProvider } from "../providers/product.provider";
 import { AlgoliaSearchProvider } from "../providers/search.provider";
 import { AlgoliaCapabilities } from "../schema/capabilities.schema";
@@ -6,15 +6,17 @@ import { AlgoliaConfiguration } from "../schema/configuration.schema";
 import { AlgoliaSearchResultSchema } from "../schema/search.schema";
 
 export function withAlgoliaCapabilities(configuration: AlgoliaConfiguration, capabilities: AlgoliaCapabilities) {
-    const client: Partial<Client> = {};
+    return (cache: Cache) => {
+        const client: Partial<Client> = {};
 
-    if (capabilities.product) {
-        client.product = new AlgoliaProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
-    }
+        if (capabilities.product) {
+            client.product = new AlgoliaProductProvider(configuration, ProductSchema, cache);
+        }
 
-    if (capabilities.search) {
-        client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, SearchQuerySchema, SearchMutationSchema);
-    }
+        if (capabilities.search) {
+            client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, cache);
+        }
 
-    return client;
+        return client;
+    };
 }

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

@@ -1,25 +1,58 @@
-import { BaseMutation, Product, ProductMutation, ProductProvider, ProductQuery, Session } from '@reactionary/core';
+import { 
+  Product, 
+  ProductProvider, 
+  ProductQueryById, 
+  ProductQueryBySlug, 
+  Session,
+  Cache 
+} from '@reactionary/core';
 import { z } from 'zod';
 import { AlgoliaConfiguration } from '../schema/configuration.schema';
 
 export class AlgoliaProductProvider<
-  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: AlgoliaConfiguration;
 
-  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
-    return [];
+  public override async getById(
+    payload: ProductQueryById,
+    _session: Session
+  ): Promise<T> {
+    // TODO: Implement Algolia product fetch by ID
+    const result = this.newModel();
+    result.identifier = { key: payload.id };
+    result.name = `Algolia Product ${payload.id}`;
+    result.slug = payload.id;
+    result.description = 'Product from Algolia';
+    result.meta = {
+      cache: { hit: false, key: payload.id },
+      placeholder: true
+    };
+    
+    return this.assert(result);
   }
 
-  protected override process(mutation: BaseMutation[], session: Session): Promise<T> {
-    throw new Error('Method not implemented.');
+  public override async getBySlug(
+    payload: ProductQueryBySlug,
+    _session: Session
+  ): Promise<T> {
+    // TODO: Implement Algolia product fetch by slug
+    const result = this.newModel();
+    result.identifier = { key: payload.slug };
+    result.name = `Algolia Product ${payload.slug}`;
+    result.slug = payload.slug;
+    result.description = 'Product from Algolia';
+    result.meta = {
+      cache: { hit: false, key: payload.slug },
+      placeholder: true
+    };
+    
+    return this.assert(result);
   }
 }

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

@@ -1,125 +1,106 @@
 import {
-  SearchIdentifier,
-  SearchMutation,
   SearchProvider,
-  SearchQuery,
+  SearchQueryByTerm,
   SearchResult,
-  SearchResultFacetSchema,
-  SearchResultFacetValueSchema,
+  SearchResultFacet,
+  SearchResultProduct,
   Session,
+  Cache,
 } from '@reactionary/core';
 import { algoliasearch } from 'algoliasearch';
 import { z } from 'zod';
 import { AlgoliaConfiguration } from '../schema/configuration.schema';
 
 export class AlgoliaSearchProvider<
-  T extends SearchResult = SearchResult,
-  Q extends SearchQuery = SearchQuery,
-  M extends SearchMutation = SearchMutation
-> extends SearchProvider<T, Q, M> {
+  T extends SearchResult = SearchResult
+> extends SearchProvider<T> {
   protected config: AlgoliaConfiguration;
 
-  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: AlgoliaConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    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(query.search);
-
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  protected override process(mutations: M[], session: Session): Promise<T> {
-    throw new Error('Method not implemented.');
-  }
-
-  protected async get(identifier: SearchIdentifier): Promise<T> {
+  public override async queryByTerm(
+    payload: SearchQueryByTerm,
+    _session: Session
+  ): Promise<SearchResult> {
     const client = algoliasearch(this.config.appId, this.config.apiKey);
     const remote = await client.search<unknown>({
       requests: [
         {
           indexName: this.config.indexName,
-          query: identifier.term,
-          page: identifier.page,
-          hitsPerPage: identifier.pageSize,
+          query: payload.search.term,
+          page: payload.search.page,
+          hitsPerPage: payload.search.pageSize,
           facets: ['*'],
           analytics: true,
           clickAnalytics: true,
-          facetFilters: identifier.facets.map(
+          facetFilters: payload.search.facets.map(
             (x) => `${encodeURIComponent(x.facet.key)}:${x.key}`
           ),
         },
       ],
     });
 
-    const parsed = this.parse(remote, identifier);
-
-    return parsed;
+    return this.parseSearchResult(remote, payload);
   }
 
-  protected parse(remote: any, query: SearchIdentifier): T {
+  protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm): T {
     const result = this.newModel();
+    const remoteData = remote as { results: Array<{ facets: Record<string, Record<string, number>>; hits: Array<{ objectID: string; slug?: string; name?: string; image?: string }>; index: string; queryID: string; nbPages: number }> };
+    const remoteProducts = remoteData.results[0];
 
-    const remoteProducts = remote.results[0];
-
+    // Parse facets
     for (const id in remoteProducts.facets) {
       const f = remoteProducts.facets[id];
 
-      const facet = SearchResultFacetSchema.parse({});
-      facet.identifier.key = id;
-      facet.name = id;
+      const facet = {
+        identifier: { key: id },
+        name: id,
+        values: []
+      } as SearchResultFacet;
 
       for (const vid in f) {
         const fv = f[vid];
-
-        const facetValue = SearchResultFacetValueSchema.parse({});
-        facetValue.count = fv;
-        facetValue.name = vid;
-        facetValue.identifier.key = vid;
-        facetValue.identifier.facet = facet.identifier;
-
-        if (
-          query.facets.find(
-            (x) =>
-              x.facet.key == facetValue.identifier.facet.key &&
-              x.key == facetValue.identifier.key
-          )
-        ) {
-          facetValue.active = true;
-        }
-
-        facet.values.push(facetValue);
+        const isActive = payload.search.facets.find(
+          (x) => x.facet.key === id && x.key === vid
+        );
+
+        facet.values.push({
+          identifier: { key: vid, facet: { key: id } },
+          count: fv,
+          name: vid,
+          active: !!isActive
+        });
       }
 
       result.facets.push(facet);
     }
 
+    // Parse products
     for (const p of remoteProducts.hits) {
       result.products.push({
-        identifier: {
-          key: p.objectID,
-        },
+        identifier: { key: p.objectID },
         slug: p.slug,
         name: p.name,
-        image: p.image,
-      });
+        image: p.image
+      } as SearchResultProduct);
     }
 
+    // Set result metadata
     result.identifier = {
-      ...query,
+      ...payload.search,
       index: remoteProducts.index,
       key: remoteProducts.queryID
     };
     result.pages = remoteProducts.nbPages;
+    result.meta = {
+      cache: { hit: false, key: payload.search.term },
+      placeholder: false
+    };
 
-    return result;
+    return this.assert(result);
   }
 }

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

@@ -1,7 +1,6 @@
 import { ClientBuilder } from '@commercetools/ts-client';
 import { createApiBuilderFromCtpClient } from '@commercetools/platform-sdk';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
-import { Session } from '@reactionary/core';
 
 const ANONYMOUS_SCOPES = ['view_published_products', 'manage_shopping_lists', 'view_shipping_methods', 'manage_customers', 'view_product_selections', 'view_categories', 'view_project_settings', 'manage_order_edits', 'view_sessions', 'view_standalone_prices', 'manage_orders', 'view_tax_categories', 'view_cart_discounts', 'view_discount_codes', 'create_anonymous_token', 'manage_sessions', 'view_products', 'view_types'];
 const GUEST_SCOPES = [...ANONYMOUS_SCOPES];

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

@@ -1,4 +1,4 @@
-import { CartMutationSchema, CartQuerySchema, CartSchema, Client, IdentityMutationSchema, IdentityQuerySchema, IdentitySchema, InventoryQuerySchema, InventorySchema, PriceMutationSchema, PriceQuerySchema, PriceSchema, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema, SearchResultSchema } from "@reactionary/core";
+import { CartSchema, Client, IdentitySchema, InventorySchema, PriceSchema, ProductSchema, SearchResultSchema, Cache } from "@reactionary/core";
 import { CommercetoolsCapabilities } from "../schema/capabilities.schema";
 import { CommercetoolsSearchProvider } from "../providers/search.provider";
 import { CommercetoolsProductProvider } from '../providers/product.provider';
@@ -7,34 +7,38 @@ 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 { InventoryMutationSchema } from "core/src/schemas/mutations/inventory.mutation";
 
-export function withCommercetoolsCapabilities(configuration: CommercetoolsConfiguration, capabilities: CommercetoolsCapabilities) {
-    const client: Partial<Client> = {};
+export function withCommercetoolsCapabilities(
+    configuration: CommercetoolsConfiguration, 
+    capabilities: CommercetoolsCapabilities
+) {
+    return (cache: Cache) => {
+        const client: Partial<Client> = {};
 
-    if (capabilities.product) {
-        client.product = new CommercetoolsProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
-    }
+        if (capabilities.product) {
+            client.product = new CommercetoolsProductProvider(configuration, ProductSchema, cache);
+        }
 
-    if (capabilities.search) {
-        client.search = new CommercetoolsSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema);
-    }
+        if (capabilities.search) {
+            client.search = new CommercetoolsSearchProvider(configuration, SearchResultSchema, cache);
+        }
 
-    if (capabilities.identity) {
-        client.identity = new CommercetoolsIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema);
-    }
+        if (capabilities.identity) {
+            client.identity = new CommercetoolsIdentityProvider(configuration, IdentitySchema, cache);
+        }
 
-    if (capabilities.cart) {
-        client.cart = new CommercetoolsCartProvider(configuration, CartSchema, CartQuerySchema, CartMutationSchema);
-    }
+        if (capabilities.cart) {
+            client.cart = new CommercetoolsCartProvider(configuration, CartSchema, cache);
+        }
 
-    if (capabilities.inventory) {
-        client.inventory = new CommercetoolsInventoryProvider(configuration, InventorySchema, InventoryQuerySchema, InventoryMutationSchema);
-    }
+        if (capabilities.inventory) {
+            client.inventory = new CommercetoolsInventoryProvider(configuration, InventorySchema, cache);
+        }
 
-    if (capabilities.price) {
-        client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, PriceQuerySchema, PriceMutationSchema);
-    }
+        if (capabilities.price) {
+            client.price = new CommercetoolsPriceProvider(configuration, PriceSchema, cache);
+        }
 
-    return client;
-}
+        return client;
+    };
+}