@reactionary/source 0.0.31 → 0.0.32

package/providers/fake/src/providers/identity.provider.ts

@@ -1,92 +1,102 @@
 import {
   Identity,
-  IdentityMutation,
-  IdentityMutationLogin,
   IdentityProvider,
-  IdentityQuery,
+  IdentityQuerySelf,
+  IdentityMutationLogin,
+  IdentityMutationLogout,
   Session,
+  Cache,
 } from '@reactionary/core';
-import { FakeConfiguration } from '../schema/configuration.schema';
 import z from 'zod';
-import { faker } from '@faker-js/faker';
+import { FakeConfiguration } from '../schema/configuration.schema';
+import { base, en, Faker } from '@faker-js/faker';
 
 export class FakeIdentityProvider<
-  T extends Identity = Identity,
-  Q extends IdentityQuery = IdentityQuery,
-  M extends IdentityMutation = IdentityMutation
-> extends IdentityProvider<T, Q, M> {
+  T extends Identity = Identity
+> extends IdentityProvider<T> {
   protected config: FakeConfiguration;
+  private currentIdentity: T | null = null;
 
-  constructor(
-    config: FakeConfiguration,
-    schema: z.ZodType<T>,
-    querySchema: z.ZodType<Q, Q>,
-    mutationSchema: z.ZodType<M, M>,
-    cache: any
-  ) {
-    super(schema, querySchema, mutationSchema, cache);
+  constructor(config: FakeConfiguration, 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(session);
-
-      results.push(result);
-    }
-
-    return results;
-  }
-
-  protected override async process(
-    mutations: M[],
-    session: Session
+  public override async getSelf(
+    _payload: IdentityQuerySelf,
+    _session: Session
   ): Promise<T> {
-    let result = this.newModel();
-
-    for (const mutation of mutations) {
-      switch (mutation.mutation) {
-        case 'login':
-          result = await this.login(mutation, session);
-          break;
-        case 'logout':
-          result = await this.logout(session);
-          break;
-      }
+    if (!this.currentIdentity) {
+      const model = this.newModel();
+      Object.assign(model, {
+        id: 'anonymous',
+        type: 'Anonymous',
+        issued: new Date(),
+        expiry: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
+        meta: {
+          cache: {
+            hit: false,
+            key: 'anonymous',
+          },
+          placeholder: false,
+        },
+      });
+      this.currentIdentity = this.assert(model);
     }
 
-    return result;
+    return this.currentIdentity;
   }
 
-  protected async login(
+  public override async login(
     payload: IdentityMutationLogin,
-    session: Session
+    _session: Session
   ): Promise<T> {
-    const base = this.newModel();
-
-    base.id = faker.string.uuid();
-    base.token = faker.string.uuid();
-    base.issued = faker.date.recent();
-    base.issued = faker.date.soon();
-    base.type = 'Registered';
-
-    return base;
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base],
+    });
+
+    const model = this.newModel();
+    Object.assign(model, {
+      id: generator.string.uuid(),
+      type: 'Registered',
+      token: generator.string.alphanumeric(32),
+      issued: new Date(),
+      expiry: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000), // 7 days from now
+      meta: {
+        cache: {
+          hit: false,
+          key: payload.username,
+        },
+        placeholder: false,
+      },
+    });
+    
+    this.currentIdentity = this.assert(model);
+    return this.currentIdentity;
   }
 
-  protected async get(session: Session): Promise<T> {
-    const base = this.schema.parse(session.identity);
-
-    return base;
-  }
-
-  protected async logout(session: Session): Promise<T> {
-    const base = this.newModel();
-
-    session.identity = base;
-
-    return base;
+  public override async logout(
+    _payload: IdentityMutationLogout,
+    _session: Session
+  ): Promise<T> {
+    const model = this.newModel();
+    Object.assign(model, {
+      id: 'anonymous',
+      type: 'Anonymous',
+      issued: new Date(),
+      expiry: new Date(Date.now() + 24 * 60 * 60 * 1000), // 24 hours from now
+      meta: {
+        cache: {
+          hit: false,
+          key: 'anonymous',
+        },
+        placeholder: false,
+      },
+    });
+    
+    this.currentIdentity = this.assert(model);
+    return this.currentIdentity;
   }
-}
+}

package/providers/fake/src/providers/inventory.provider.ts

@@ -0,0 +1,54 @@
+import {
+  Inventory,
+  InventoryProvider,
+  InventoryQuery,
+  Session,
+  Cache,
+} from '@reactionary/core';
+import z from 'zod';
+import { FakeConfiguration } from '../schema/configuration.schema';
+import { base, en, Faker } from '@faker-js/faker';
+
+export class FakeInventoryProvider<
+  T extends Inventory = Inventory
+> extends InventoryProvider<T> {
+  protected config: FakeConfiguration;
+
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
+
+    this.config = config;
+  }
+
+  public override async getBySKU(
+    payload: InventoryQuery,
+    _session: Session
+  ): Promise<T> {
+    // Generate a simple hash from the SKU string for seeding
+    let hash = 0;
+    const skuString = payload.sku;
+    for (let i = 0; i < skuString.length; i++) {
+      hash = ((hash << 5) - hash) + skuString.charCodeAt(i);
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    
+    const generator = new Faker({
+      seed: hash || 42,
+      locale: [en, base],
+    });
+
+    const model = this.newModel();
+    Object.assign(model, {
+      quantity: generator.number.int({ min: 0, max: 100 }),
+      meta: {
+        cache: {
+          hit: false,
+          key: payload.sku,
+        },
+        placeholder: false,
+      },
+    });
+
+    return this.assert(model);
+  }
+}

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

@@ -0,0 +1,60 @@
+import {
+  Price,
+  PriceProvider,
+  PriceQueryBySku,
+  Session,
+  Cache,
+} from '@reactionary/core';
+import z from 'zod';
+import { FakeConfiguration } from '../schema/configuration.schema';
+import { base, en, Faker } from '@faker-js/faker';
+
+export class FakePriceProvider<
+  T extends Price = Price
+> extends PriceProvider<T> {
+  protected config: FakeConfiguration;
+
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
+
+    this.config = config;
+  }
+
+  public override async getBySKU(
+    payload: PriceQueryBySku,
+    _session: Session
+  ): Promise<T> {
+    // Generate a simple hash from the SKU key string for seeding
+    let hash = 0;
+    const skuString = payload.sku.key;
+    for (let i = 0; i < skuString.length; i++) {
+      hash = ((hash << 5) - hash) + skuString.charCodeAt(i);
+      hash = hash & hash; // Convert to 32bit integer
+    }
+    
+    const generator = new Faker({
+      seed: hash || 42,
+      locale: [en, base],
+    });
+
+    const model = this.newModel();
+    Object.assign(model, {
+      identifier: {
+        sku: payload.sku,
+      },
+      value: {
+        cents: generator.number.int({ min: 100, max: 100000 }),
+        currency: 'USD',
+      },
+      meta: {
+        cache: {
+          hit: false,
+          key: payload.sku,
+        },
+        placeholder: false,
+      },
+    });
+
+    return this.assert(model);
+  }
+}

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

@@ -1,73 +1,77 @@
 import {
-  BaseMutation,
   Product,
-  ProductMutation,
   ProductProvider,
-  ProductQuery,
+  ProductQueryById,
+  ProductQueryBySlug,
   Session,
+  Cache as ReactinaryCache,
 } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
 import { base, en, Faker } from '@faker-js/faker';
+import { traced } from '@reactionary/otel';
 
 export class FakeProductProvider<
-  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: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
-    super(schema, querySchema, mutationSchema, cache);
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactinaryCache) {
+    super(schema, cache);
 
     this.config = config;
   }
 
-  protected override async fetch(queries: Q[], session: Session): Promise<T[]> {
-    const results = new Array<T>();
+  @traced()
+  public override async getById(
+    payload: ProductQueryById,
+    _session: Session
+  ): Promise<T> {
+    return this.parseSingle(payload);
+  }
 
-    for (const query of queries) {
-      const generator = new Faker({
-        seed: 42,
-        locale: [en, base],
-      });
+  public override async getBySlug(
+    payload: ProductQueryBySlug,
+    _session: Session
+  ): Promise<T> {
+    return this.parseSingle(payload);
+  }
 
-      const key = (query.id as string) || generator.commerce.isbn();
-      const slug = (query.slug as string) || generator.lorem.slug();
+  protected override parseSingle(body: ProductQueryById | ProductQueryBySlug): T {
+    const generator = new Faker({
+      seed: 42,
+      locale: [en, base],
+    });
 
-      const product: Product = {
-        identifier: {
-          key: key,
-        },
-        name: generator.commerce.productName(),
-        slug: slug,
-        attributes: [],
-        description: generator.commerce.productDescription(),
-        image: generator.image.urlPicsumPhotos({
-          width: 600,
-          height: 600,
-        }),
-        images: [],
-        meta: {
-          cache: {
-            hit: false,
-            key: key,
-          },
-          placeholder: false
-        },
-        skus: [],
-      };
+    const key = body.slug || body.id;
 
-      results.push(product as T);
-    }
+    // Create a model instance based on the schema
+    const model = this.newModel();
 
-    return results;
-  }
+    // Merge the generated data into the model
+    Object.assign(model, {
+      identifier: {
+        key: key,
+      },
+      name: generator.commerce.productName(),
+      slug: key,
+      attributes: [],
+      description: generator.commerce.productDescription(),
+      image: generator.image.urlPicsumPhotos({
+        width: 600,
+        height: 600,
+      }),
+      images: [],
+      meta: {
+        cache: {
+          hit: false,
+          key: key,
+        },
+        placeholder: false,
+      },
+      skus: [],
+    });
 
-  protected override process(
-    mutation: BaseMutation[],
-    session: Session
-  ): Promise<T> {
-    throw new Error('Method not implemented.');
+    return this.assert(model);
   }
 }

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

@@ -1,12 +1,11 @@
 import {
-  SearchIdentifier,
-  SearchMutation,
   SearchProvider,
-  SearchQuery,
+  SearchQueryByTerm,
   SearchResult,
   SearchResultFacet,
   SearchResultProduct,
   Session,
+  Cache as ReactinaryCache,
 } from '@reactionary/core';
 import z from 'zod';
 import { FakeConfiguration } from '../schema/configuration.schema';
@@ -14,41 +13,24 @@ import { Faker, en, base } from '@faker-js/faker';
 import { jitter } from '../utilities/jitter';
 
 export class FakeSearchProvider<
-  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: FakeConfiguration;
 
-  constructor(config: FakeConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>, cache: any) {
-    super(schema, querySchema, mutationSchema, cache);
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: ReactinaryCache) {
+    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.');
-  }
-
-  public async get(identifier: SearchIdentifier): Promise<T> {
+  public override async queryByTerm(
+    payload: SearchQueryByTerm,
+    _session: Session
+  ): Promise<SearchResult> {
     await jitter(this.config.jitter.mean, this.config.jitter.deviation);
 
-    return this.parse({}, identifier);
-  }
+    const query = payload.search;
 
-  public parse(data: unknown, query: SearchIdentifier): T {
     const querySpecificity =
       20 - query.term.length - query.page - query.facets.length;
     const totalProducts = 10 * querySpecificity;
@@ -77,7 +59,7 @@ export class FakeSearchProvider<
           height: 300,
           width: 300,
           grayscale: true,
-          blur: 8
+          blur: 8,
         }),
         name: productGenerator.commerce.productName(),
         slug: productGenerator.lorem.slug(),
@@ -131,10 +113,10 @@ export class FakeSearchProvider<
       meta: {
         cache: {
           hit: false,
-          key: ''
+          key: '',
         },
-        placeholder: false
-      }
+        placeholder: false,
+      },
     } satisfies SearchResult;
 
     return this.schema.parse(result);

package/trpc/__mocks__/superjson.js

@@ -0,0 +1,25 @@
+// Mock superjson for Jest testing
+module.exports = {
+  default: {
+    stringify: JSON.stringify,
+    parse: JSON.parse,
+    serialize: (obj) => ({ json: obj, meta: undefined }),
+    deserialize: (data) => data.json,
+    output: {
+      serialize: (obj) => ({ json: obj, meta: undefined })
+    },
+    input: {
+      deserialize: (data) => data.json
+    }
+  },
+  stringify: JSON.stringify,
+  parse: JSON.parse,
+  serialize: (obj) => ({ json: obj, meta: undefined }),
+  deserialize: (data) => data.json,
+  output: {
+    serialize: (obj) => ({ json: obj, meta: undefined })
+  },
+  input: {
+    deserialize: (data) => data.json
+  }
+};

package/trpc/jest.config.ts

@@ -0,0 +1,14 @@
+export default {
+  displayName: 'trpc',
+  preset: '../jest.preset.js',
+  testEnvironment: 'node',
+  testTimeout: 15000,
+  transform: {
+    '^.+\\.[tj]s$': ['ts-jest', { tsconfig: '<rootDir>/tsconfig.spec.json' }],
+  },
+  moduleFileExtensions: ['ts', 'js', 'html'],
+  moduleNameMapper: {
+    '^superjson$': '<rootDir>/__mocks__/superjson.js',
+  },
+  coverageDirectory: '../coverage/trpc',
+};

package/trpc/package.json

@@ -9,6 +9,7 @@
     "@reactionary/core": "0.0.1",
     "@reactionary/otel": "0.0.1",
     "superjson": "^2.2.2",
-    "zod": "4.0.0-beta.20250430T185432"
+    "zod": "4.0.0-beta.20250430T185432",
+    "@trpc/client": "^11.1.2"
   }
 }