@reactionary/source 0.0.31 → 0.0.32

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

@@ -3,28 +3,22 @@ import { BaseMutationSchema } from './base.mutation';
 import { CartIdentifierSchema, CartItemIdentifierSchema, ProductIdentifierSchema } from '../models/identifiers.model';
 
 export const CartMutationItemAddSchema = BaseMutationSchema.extend({
-    mutation: z.literal('add'),
     cart: CartIdentifierSchema.required(),
     product: ProductIdentifierSchema.required(),
     quantity: z.number()
 });
 
 export const CartMutationItemRemoveSchema = BaseMutationSchema.extend({
-    mutation: z.literal('remove'),
     cart: CartIdentifierSchema.required(),
     item: CartItemIdentifierSchema.required()
 });
 
 export const CartMutationItemQuantityChangeSchema = BaseMutationSchema.extend({
-    mutation: z.literal('adjustQuantity'),
     cart: CartIdentifierSchema.required(),
     item: CartItemIdentifierSchema.required(),
     quantity: z.number()
 });
 
-export const CartMutationSchema = z.union([CartMutationItemAddSchema, CartMutationItemRemoveSchema, CartMutationItemQuantityChangeSchema]);
-
-export type CartMutation = z.infer<typeof CartMutationSchema>;
 export type CartMutationItemAdd = z.infer<typeof CartMutationItemAddSchema>;
 export type CartMutationItemRemove = z.infer<typeof CartMutationItemRemoveSchema>;
 export type CartMutationItemQuantityChange = z.infer<typeof CartMutationItemQuantityChangeSchema>;

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

@@ -2,17 +2,12 @@ import { z } from 'zod';
 import { BaseMutationSchema } from './base.mutation';
 
 export const IdentityMutationLoginSchema = BaseMutationSchema.extend({
-    mutation: z.literal('login'),
     username: z.string(),
     password: z.string()
 });
 
 export const IdentityMutationLogoutSchema = BaseMutationSchema.extend({
-    mutation: z.literal('logout')
 });
 
-export const IdentityMutationSchema = z.union([IdentityMutationLoginSchema, IdentityMutationLogoutSchema]);
-
-export type IdentityMutation = z.infer<typeof IdentityMutationSchema>;
 export type IdentityMutationLogin = z.infer<typeof IdentityMutationLoginSchema>;
 export type IdentityMutationLogout = z.infer<typeof IdentityMutationLogoutSchema>;

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

@@ -1,7 +1,6 @@
 import { z } from 'zod';
 
 export const BaseQuerySchema = z.looseInterface({
-    query: z.ZodLiteral
 });
 
 export type BaseQuery = z.infer<typeof BaseQuerySchema>;

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

@@ -3,10 +3,8 @@ import { BaseQuerySchema } from './base.query';
 import { CartIdentifierSchema } from '../models/identifiers.model';
 
 export const CartQueryByIdSchema = BaseQuerySchema.extend({
-    query: z.literal('id'),
     cart: CartIdentifierSchema.required()
 });
 export const CartQuerySchema = z.union([CartQueryByIdSchema]);
 
-export type CartQueryById = z.infer<typeof CartQueryByIdSchema>;
-export type CartQuery = z.infer<typeof CartQuerySchema>;
+export type CartQueryById = z.infer<typeof CartQueryByIdSchema>;

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

@@ -2,9 +2,7 @@ import { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
 
 export const IdentityQuerySelfSchema = BaseQuerySchema.extend({
-    query: z.literal('self')
+
 });
-export const IdentityQuerySchema = z.union([IdentityQuerySelfSchema]);
 
-export type IdentityQuery = z.infer<typeof IdentityQuerySchema>;
 export type IdentityQuerySelf = z.infer<typeof IdentityQuerySelfSchema>;

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

@@ -2,7 +2,6 @@ import { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
 
 export const InventoryQuerySchema = BaseQuerySchema.extend({
-    query: z.literal('sku'),
     sku: z.string()
 });
 

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

@@ -3,10 +3,7 @@ import { BaseQuerySchema } from './base.query';
 import { SKUIdentifierSchema } from '../models/identifiers.model';
 
 export const PriceQueryBySkuSchema = BaseQuerySchema.extend({
-    query: z.literal('sku'),
     sku: SKUIdentifierSchema.required(),
 });
-export const PriceQuerySchema = z.union([PriceQueryBySkuSchema]);
 
 export type PriceQueryBySku = z.infer<typeof PriceQueryBySkuSchema>;
-export type PriceQuery = z.infer<typeof PriceQuerySchema>;

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

@@ -2,17 +2,12 @@ import { z } from 'zod';
 import { BaseQuerySchema } from './base.query';
 
 export const ProductQueryBySlugSchema = BaseQuerySchema.extend({
-    query: z.literal('slug'),
     slug: z.string()
 });
 
 export const ProductQueryByIdSchema = BaseQuerySchema.extend({
-    query: z.literal('id'),
-    id: z.string() 
+    id: z.string()
 });
 
-export const ProductQuerySchema = z.union([ProductQueryBySlugSchema, ProductQueryByIdSchema]);
-
 export type ProductQueryBySlug = z.infer<typeof ProductQueryBySlugSchema>;
-export type ProductQueryById = z.infer<typeof ProductQueryByIdSchema>;
-export type ProductQuery = z.infer<typeof ProductQuerySchema>;
+export type ProductQueryById = z.infer<typeof ProductQueryByIdSchema>;

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

@@ -3,10 +3,7 @@ import { BaseQuerySchema } from './base.query';
 import { SearchIdentifierSchema } from '../models/identifiers.model';
 
 export const SearchQueryByTermSchema = BaseQuerySchema.extend({
-    query: z.literal('term'),
     search: SearchIdentifierSchema.required()
 });
-export const SearchQuerySchema = z.union([SearchQueryByTermSchema]);
 
-export type SearchQuery = z.infer<typeof SearchQuerySchema>;
 export type SearchQueryByTerm = z.infer<typeof SearchQueryByTermSchema>;

package/examples/node/package.json

@@ -2,9 +2,5 @@
   "name": "@reactionary/examples-node",
   "version": "0.0.1",
   "private": true,
-  "dependencies": {
-    "@reactionary/provider-algolia": "0.0.1",
-    "@reactionary/core": "0.0.1",
-    "zod": "4.0.0-beta.20250430T185432"
-  }
+  "dependencies": {}
 }

package/examples/node/src/basic/basic-node-provider-model-extension.spec.ts

@@ -0,0 +1,97 @@
+import {
+  ClientBuilder,
+  Cache,
+  NoOpCache,
+  ProductSchema,
+  SessionSchema,
+  ProductQueryById,
+  ProductQueryBySlug,
+} from '@reactionary/core';
+import {
+  FakeProductProvider,
+  withFakeCapabilities,
+} from '@reactionary/provider-fake';
+import z from 'zod';
+
+describe('basic node provider extension (models)', () => {
+  const session = SessionSchema.parse({
+    id: '1234567890',
+  });
+
+  const ExtendedProductModel = ProductSchema.extend({
+    gtin: z.string().default('gtin-default'),
+  });
+  type ExtendedProduct = z.infer<typeof ExtendedProductModel>;
+
+  class ExtendedProductProvider extends FakeProductProvider<ExtendedProduct> {
+    protected override parseSingle(body: ProductQueryById | ProductQueryBySlug): ExtendedProduct {
+      const model = super.parseSingle(body);
+
+      if (body.id) {
+        model.gtin = 'gtin-1234';
+      }
+
+      return this.assert(model);
+    }
+  }
+
+  function withExtendedCapabilities() {
+    return (cache: Cache) => {
+      const client = {
+        product: new ExtendedProductProvider(
+          { jitter: { mean: 0, deviation: 0 } },
+          ExtendedProductModel,
+          cache
+        ),
+      };
+
+      return client;
+    };
+  }
+
+  const client = new ClientBuilder()
+    .withCapability(
+      withFakeCapabilities(
+        {
+          jitter: {
+            mean: 0,
+            deviation: 0,
+          },
+        },
+        { search: true, product: false, identity: false }
+      )
+    )
+    .withCapability(withExtendedCapabilities())
+    .withCache(new NoOpCache())
+    .build();
+
+  it('should get the enabled set of capabilities across providers', async () => {
+    expect(client.product).toBeDefined();
+    expect(client.search).toBeDefined();
+    expect(client.identity).toBeUndefined();
+  });
+
+  it('should be able to call the regular methods and get the default value', async () => {
+    const product = await client.product.getBySlug(
+      {
+        slug: '1234',
+      },
+      session
+    );
+
+    expect(product).toBeDefined();
+    expect(product.gtin).toBe('gtin-default');
+  });
+
+  it('should be able to get serialized value from the extended provider', async () => {
+    const product = await client.product.getById(
+      {
+        id: '1234',
+      },
+      session
+    );
+
+    expect(product).toBeDefined();
+    expect(product.gtin).toBe('gtin-1234');
+  });
+});

package/examples/node/src/basic/basic-node-provider-query-extension.spec.ts

@@ -0,0 +1,84 @@
+import {
+  ClientBuilder,
+  Cache,
+  NoOpCache,
+  ProductSchema,
+  Product,
+} from '@reactionary/core';
+import {
+  FakeProductProvider,
+  withFakeCapabilities,
+} from '@reactionary/provider-fake';
+import z from 'zod';
+
+describe('basic node provider extension (models)', () => {
+  const ExtendedProductModel = ProductSchema.extend({
+    gtin: z.string().default('gtin-default'),
+  });
+
+  class ExtendedProductProvider extends FakeProductProvider {
+
+    public async getByCustom(_custom: string): Promise<Product> {
+      // Lets say we called somewhere...
+      const data = {
+        id: 'foo',
+        name: 'bar'
+      };
+
+      const model = this.parseItem(data);
+
+      return model;
+    }
+
+    protected parseItem(data: unknown): Product {
+      // In the real world, call super
+      // super.parseItem(data);
+      // Which would start by doing
+      const item = this.newModel();
+    
+      if (data) {
+        item.name = (data as { name: string }).name;
+      }
+      
+
+      return this.assert(item);
+    }
+  }
+
+  function withExtendedCapabilities() {
+    return (cache: Cache) => {
+      const client = {
+        product: new ExtendedProductProvider(
+          { jitter: { mean: 0, deviation: 0 } },
+          ExtendedProductModel,
+          cache
+        ),
+      };
+
+      return client;
+    };
+  }
+
+  const client = new ClientBuilder()
+    .withCapability(
+      withFakeCapabilities(
+        {
+          jitter: {
+            mean: 0,
+            deviation: 0,
+          },
+        },
+        { search: true, product: false, identity: false }
+      )
+    )
+    .withCapability(withExtendedCapabilities())
+    .withCache(new NoOpCache())
+    .build();
+
+  it('should be able to call a custom query method on the provider', async () => {
+    const product = await client.product.getByCustom('1234');
+
+    expect(product.name).toBe('bar');
+  });
+
+});

package/examples/node/src/basic/basic-node-setup.spec.ts

@@ -0,0 +1,40 @@
+import { buildClient, NoOpCache, SessionSchema } from '@reactionary/core';
+import { withFakeCapabilities } from '@reactionary/provider-fake';
+
+describe('basic node setup', () => {
+  const client = buildClient(
+    [
+      withFakeCapabilities(
+        {
+          jitter: {
+            mean: 0,
+            deviation: 0,
+          },
+        },
+        { search: true, product: true, identity: false }
+      ),
+    ],
+    {
+      cache: new NoOpCache(),
+    }
+  );
+
+  const session = SessionSchema.parse({
+    id: '1234567890'
+  });
+
+  it('should only get back the enabled capabilities', async () => {
+    expect(client.product).toBeDefined();
+    expect(client.search).toBeDefined();
+    expect(client.identity).toBeUndefined();
+  });
+
+  it('should be able to call the enabled capabilities', async () => {
+    const product = await client.product.getBySlug({
+        slug: '1234'
+    }, session);
+
+    expect(product).toBeDefined();
+    expect(product.slug).toBe('1234');
+  });
+});

package/otel/src/index.ts

@@ -5,5 +5,8 @@
 export { createTRPCTracing } from './trpc-middleware';
 export { createProviderInstrumentation } from './provider-instrumentation';
 
+// Decorator for tracing functions
+export { traced, TracedOptions } from './trace-decorator';
+
 // Graceful shutdown for process termination
 export { shutdownOtel } from './sdk';

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.31",
+  "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, Cache } 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";
@@ -10,11 +10,11 @@ export function withAlgoliaCapabilities(configuration: AlgoliaConfiguration, cap
         const client: Partial<Client> = {};
 
         if (capabilities.product) {
-            client.product = new AlgoliaProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema, cache);
+            client.product = new AlgoliaProductProvider(configuration, ProductSchema, cache);
         }
 
         if (capabilities.search) {
-            client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, SearchQuerySchema, SearchMutationSchema, cache);
+            client.search = new AlgoliaSearchProvider(configuration, AlgoliaSearchResultSchema, cache);
         }
 
         return client;