@reactionary/source 0.0.30 → 0.0.32

package/core/src/providers/price.provider.ts

@@ -1,10 +1,10 @@
 import { Price } from '../schemas/models/price.model';
-import { PriceMutation } from '../schemas/mutations/price.mutation';
-import { PriceQuery } from '../schemas/queries/price.query';
+import { PriceQueryBySku } from '../schemas/queries/price.query';
+import { Session } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 
 export abstract class PriceProvider<
-  T extends Price = Price,
-  Q extends PriceQuery = PriceQuery,
-  M extends PriceMutation = PriceMutation
-> extends BaseProvider<T, Q, M> {}
+  T extends Price = Price
+> extends BaseProvider<T> {
+  public abstract getBySKU(payload: PriceQueryBySku, session: Session): Promise<T>;
+}

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

@@ -1,11 +1,11 @@
 import { Product } from '../schemas/models/product.model';
-import { ProductMutation } from '../schemas/mutations/product.mutation';
-import { ProductQuery } from '../schemas/queries/product.query';
 import { BaseProvider } from './base.provider';
+import { Session } from '../schemas/session.schema';
+import { ProductQueryById, ProductQueryBySlug } from '../schemas/queries/product.query';
 
 export abstract class ProductProvider<
-  T extends Product = Product,
-  Q extends ProductQuery = ProductQuery,
-  M extends ProductMutation = ProductMutation
-> extends BaseProvider<T, Q, M> {
+  T extends Product = Product
+> extends BaseProvider<T> {
+  public abstract getById(payload: ProductQueryById, session: Session): Promise<T>;
+  public abstract getBySlug(payload: ProductQueryBySlug, session: Session): Promise<T>;
 }

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

@@ -1,12 +1,12 @@
 import { SearchResult } from '../schemas/models/search.model';
-import { SearchQuery } from '../schemas/queries/search.query';
-import { SearchMutation } from '../schemas/mutations/search.mutation';
+import { SearchQueryByTerm } from '../schemas/queries/search.query';
+import { Session } from '../schemas/session.schema';
 import { BaseProvider } from './base.provider';
 
 export abstract class SearchProvider<
-  T extends SearchResult = SearchResult,
-  Q extends SearchQuery = SearchQuery,
-  M extends SearchMutation = SearchMutation
-> extends BaseProvider<T, Q, M> {}
+  T extends SearchResult = SearchResult
+> extends BaseProvider<T> {
+  public abstract queryByTerm(payload: SearchQueryByTerm, session: Session): Promise<SearchResult>;
+}
 
 

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

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

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/mutations/product.mutation.ts

@@ -1,5 +1,4 @@
 import { z } from 'zod';
-import { BaseMutationSchema } from './base.mutation';
 
 export const ProductMutationSchema = z.union([]);
 

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';