@reactionary/source 0.0.30 → 0.0.32

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

@@ -1,46 +1,30 @@
 import {
-  SearchIdentifier,
-  SearchMutation,
   SearchProvider,
-  SearchQuery,
+  SearchQueryByTerm,
   SearchResult,
-  SearchResultProductSchema,
+  SearchResultProduct,
   Session,
+  Cache,
 } from '@reactionary/core';
 import { CommercetoolsClient } from '../core/client';
 import z from 'zod';
 import { CommercetoolsConfiguration } from '../schema/configuration.schema';
 
 export class CommercetoolsSearchProvider<
-  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: CommercetoolsConfiguration;
 
-  constructor(config: CommercetoolsConfiguration, schema: z.ZodType<T>, querySchema: z.ZodType<Q, Q>, mutationSchema: z.ZodType<M, M>) {
-    super(schema, querySchema, mutationSchema);
+  constructor(config: CommercetoolsConfiguration, 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.');
-  }
-
-  public async get(identifier: SearchIdentifier): Promise<T> {
+  public override async queryByTerm(
+    payload: SearchQueryByTerm,
+    _session: Session
+  ): Promise<T> {
     const client = new CommercetoolsClient(this.config).createAnonymousClient();
 
     const remote = await client
@@ -49,38 +33,39 @@ export class CommercetoolsSearchProvider<
       .search()
       .get({
         queryArgs: {
-          limit: identifier.pageSize,
-          offset: identifier.pageSize * identifier.page,
-          ['text.en-US']: identifier.term,
+          limit: payload.search.pageSize,
+          offset: payload.search.pageSize * payload.search.page,
+          ['text.en-US']: payload.search.term,
         },
       })
       .execute();
 
-    const parsed = this.parse(remote, identifier);
-
-    return parsed;
+    return this.parseSearchResult(remote, payload);
   }
 
-  public parse(remote: any, query: SearchIdentifier): T {
-    const result = super.newModel();
-
-    result.identifier = query;
-
-    for (const p of remote.body.results) {
-      const product = SearchResultProductSchema.parse({});
+  protected parseSearchResult(remote: unknown, payload: SearchQueryByTerm): T {
+    const result = this.newModel();
+    const remoteData = remote as { body: { results: Array<{ id: string; name: Record<string, string>; slug?: Record<string, string>; masterVariant: { images?: Array<{ url?: string }> } }>; total?: number } };
 
-      product.identifier.key = p.id;
-      product.name = p.name['en-US'];
+    result.identifier = payload.search;
 
-      if (p.masterVariant.images) {
-        product.image = p.masterVariant.images[0].url;
-      }
+    for (const p of remoteData.body.results) {
+      const product: SearchResultProduct = {
+        identifier: { key: p.id },
+        name: p.name['en-US'],
+        slug: p.slug?.['en-US'] || p.id,
+        image: p.masterVariant.images?.[0]?.url || 'https://placehold.co/400'
+      };
 
       result.products.push(product);
     }
 
-    result.pages = Math.ceil((remote.body.total || 0) / query.pageSize);
+    result.pages = Math.ceil((remoteData.body.total || 0) / payload.search.pageSize);
+    result.meta = {
+      cache: { hit: false, key: payload.search.term },
+      placeholder: false
+    };
 
-    return result;
+    return this.assert(result);
   }
 }

package/providers/commercetools/src/schema/capabilities.schema.ts

@@ -1,4 +1,4 @@
-import { CapabilitiesSchema, Price, PriceQuery } from "@reactionary/core";
+import { CapabilitiesSchema } from "@reactionary/core";
 import { z } from 'zod';
 
 export const CommercetoolsCapabilitiesSchema = CapabilitiesSchema.pick({

package/providers/fake/package.json

@@ -3,6 +3,7 @@
   "version": "0.0.1",
   "dependencies": {
     "@reactionary/core": "0.0.1",
+    "@reactionary/otel": "0.0.1",
     "zod": "4.0.0-beta.20250430T185432",
     "@faker-js/faker": "^9.8.0"
   }

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

@@ -1,24 +1,27 @@
-import { Client, IdentityMutationSchema, IdentityQuerySchema, IdentitySchema, ProductMutationSchema, ProductQuerySchema, ProductSchema, SearchMutationSchema, SearchQuerySchema, SearchResultSchema } from "@reactionary/core";
+import { ProductSchema, SearchResultSchema, Cache as ReactinaryCache, ProductProvider, SearchProvider, IdentityProvider } from "@reactionary/core";
 import { FakeProductProvider } from "../providers/product.provider";
 import { FakeSearchProvider } from "../providers/search.provider";
 import { FakeConfiguration } from "../schema/configuration.schema";
 import { FakeCapabilities } from "../schema/capabilities.schema";
-import { FakeIdentityProvider } from "../providers/identity.provider";
 
-export function withFakeCapabilities(configuration: FakeConfiguration, capabilities: FakeCapabilities) {
-    const client = {} as Partial<Client>;
+type FakeClient<T extends FakeCapabilities> = Partial<{
+    product: T['product'] extends true ? ProductProvider : never;
+    search: T['search'] extends true ? SearchProvider : never;
+    identity: T['identity'] extends true ? IdentityProvider : never;
+}>;
 
-    if (capabilities.product) {
-        client.product = new FakeProductProvider(configuration, ProductSchema, ProductQuerySchema, ProductMutationSchema);
-    }
+export function withFakeCapabilities<T extends FakeCapabilities>(configuration: FakeConfiguration, capabilities: T) {
+    return (cache: ReactinaryCache): FakeClient<T> => {
+        const client: any = {};
 
-    if (capabilities.search) {
-        client.search = new FakeSearchProvider(configuration, SearchResultSchema, SearchQuerySchema, SearchMutationSchema);
-    }
+        if (capabilities.product) {
+            client.product = new FakeProductProvider(configuration, ProductSchema, cache);
+        }
 
-    if (capabilities.identity) {
-        client.identity = new FakeIdentityProvider(configuration, IdentitySchema, IdentityQuerySchema, IdentityMutationSchema);
-    }
+        if (capabilities.search) {
+            client.search = new FakeSearchProvider(configuration, SearchResultSchema, cache);
+        }
 
-    return client;
+        return client;
+    };
 }

package/providers/fake/src/index.ts

@@ -1,6 +1,10 @@
 export * from './core/initialize';
 
+export * from './providers/analytics.provider';
+export * from './providers/cart.provider';
 export * from './providers/identity.provider';
+export * from './providers/inventory.provider';
+export * from './providers/price.provider';
 export * from './providers/product.provider';
 export * from './providers/search.provider';
 

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

@@ -0,0 +1,19 @@
+import {
+  AnalyticsProvider,
+  BaseModel,
+  Cache,
+} from '@reactionary/core';
+import z from 'zod';
+import { FakeConfiguration } from '../schema/configuration.schema';
+
+export class FakeAnalyticsProvider<
+  T extends BaseModel = BaseModel
+> extends AnalyticsProvider<T> {
+  protected config: FakeConfiguration;
+
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
+
+    this.config = config;
+  }
+}

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

@@ -0,0 +1,107 @@
+import {
+  Cart,
+  CartProvider,
+  CartQueryById,
+  CartMutationItemAdd,
+  CartMutationItemRemove,
+  CartMutationItemQuantityChange,
+  Session,
+  Cache,
+} from '@reactionary/core';
+import z from 'zod';
+import { FakeConfiguration } from '../schema/configuration.schema';
+
+export class FakeCartProvider<
+  T extends Cart = Cart
+> extends CartProvider<T> {
+  protected config: FakeConfiguration;
+  private carts: Map<string, T> = new Map();
+
+  constructor(config: FakeConfiguration, schema: z.ZodType<T>, cache: Cache) {
+    super(schema, cache);
+
+    this.config = config;
+  }
+
+  public override async getById(
+    payload: CartQueryById,
+    _session: Session
+  ): Promise<T> {
+    const cartId = payload.cart.key;
+    
+    if (!this.carts.has(cartId)) {
+      const model = this.newModel();
+      Object.assign(model, {
+        identifier: { key: cartId },
+        items: [],
+        meta: {
+          cache: {
+            hit: false,
+            key: cartId,
+          },
+          placeholder: false,
+        },
+      });
+      this.carts.set(cartId, this.assert(model));
+    }
+    
+    const cart = this.carts.get(cartId);
+    if (!cart) {
+      throw new Error(`Cart with id ${cartId} not found`);
+    }
+    return cart;
+  }
+
+  public override async add(
+    payload: CartMutationItemAdd,
+    session: Session
+  ): Promise<T> {
+    const cart = await this.getById({ cart: payload.cart }, session);
+    
+    const existingItemIndex = cart.items.findIndex(
+      item => item.product.key === payload.product.key
+    );
+    
+    if (existingItemIndex >= 0) {
+      cart.items[existingItemIndex].quantity += payload.quantity;
+    } else {
+      cart.items.push({
+        identifier: { key: `item-${Date.now()}` },
+        product: payload.product,
+        quantity: payload.quantity,
+      });
+    }
+    
+    return this.assert(cart);
+  }
+
+  public override async remove(
+    payload: CartMutationItemRemove,
+    session: Session
+  ): Promise<T> {
+    const cart = await this.getById({ cart: payload.cart }, session);
+    
+    cart.items = cart.items.filter(
+      item => item.identifier.key !== payload.item.key
+    );
+    
+    return this.assert(cart);
+  }
+
+  public override async changeQuantity(
+    payload: CartMutationItemQuantityChange,
+    session: Session
+  ): Promise<T> {
+    const cart = await this.getById({ cart: payload.cart }, session);
+    
+    const item = cart.items.find(
+      item => item.identifier.key === payload.item.key
+    );
+    
+    if (item) {
+      item.quantity = payload.quantity;
+    }
+    
+    return this.assert(cart);
+  }
+}

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

@@ -1,91 +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>
-  ) {
-    super(schema, querySchema, mutationSchema);
+  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);
+  }
+}