@reactionary/source 0.6.1 → 0.6.3

package/packages/core/src/factories/product-reviews.factory.ts

@@ -0,0 +1,58 @@
+import type * as z from 'zod';
+import type {
+  ProductRatingSummarySchema,
+  ProductReviewPaginatedResultSchema,
+  ProductReviewSchema,
+} from '../schemas/models/product-reviews.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+
+export type AnyProductRatingSummarySchema = z.ZodType<
+  z.output<typeof ProductRatingSummarySchema>
+>;
+export type AnyProductReviewSchema = z.ZodType<z.output<typeof ProductReviewSchema>>;
+export type AnyProductReviewPaginatedSchema = z.ZodType<
+  z.output<typeof ProductReviewPaginatedResultSchema>
+>;
+
+export interface ProductReviewsFactory<
+  TRatingSummarySchema extends AnyProductRatingSummarySchema = AnyProductRatingSummarySchema,
+  TReviewSchema extends AnyProductReviewSchema = AnyProductReviewSchema,
+  TReviewPaginatedSchema extends AnyProductReviewPaginatedSchema = AnyProductReviewPaginatedSchema,
+> {
+  ratingSummarySchema: TRatingSummarySchema;
+  reviewSchema: TReviewSchema;
+  reviewPaginatedSchema: TReviewPaginatedSchema;
+  parseRatingSummary(
+    context: RequestContext,
+    data: unknown,
+  ): z.output<TRatingSummarySchema>;
+  parseReview(context: RequestContext, data: unknown): z.output<TReviewSchema>;
+  parseReviewPaginatedResult(
+    context: RequestContext,
+    data: unknown,
+  ): z.output<TReviewPaginatedSchema>;
+}
+
+export type ProductReviewsFactoryRatingOutput<TFactory extends ProductReviewsFactory> =
+  ReturnType<TFactory['parseRatingSummary']>;
+export type ProductReviewsFactoryReviewOutput<TFactory extends ProductReviewsFactory> =
+  ReturnType<TFactory['parseReview']>;
+export type ProductReviewsFactoryReviewPaginatedOutput<
+  TFactory extends ProductReviewsFactory,
+> = ReturnType<TFactory['parseReviewPaginatedResult']>;
+
+export type ProductReviewsFactoryWithOutput<TFactory extends ProductReviewsFactory> =
+  Omit<TFactory, 'parseRatingSummary' | 'parseReview' | 'parseReviewPaginatedResult'> & {
+    parseRatingSummary(
+      context: RequestContext,
+      data: unknown,
+    ): ProductReviewsFactoryRatingOutput<TFactory>;
+    parseReview(
+      context: RequestContext,
+      data: unknown,
+    ): ProductReviewsFactoryReviewOutput<TFactory>;
+    parseReviewPaginatedResult(
+      context: RequestContext,
+      data: unknown,
+    ): ProductReviewsFactoryReviewPaginatedOutput<TFactory>;
+  };

package/packages/core/src/factories/product-search.factory.ts

@@ -0,0 +1,31 @@
+import type * as z from 'zod';
+import type { ProductSearchResultSchema } from '../schemas/models/product-search.model.js';
+import type { ProductSearchQueryByTerm } from '../schemas/queries/product-search.query.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+
+export type AnyProductSearchResultSchema = z.ZodType<
+  z.output<typeof ProductSearchResultSchema>
+>;
+
+export interface ProductSearchFactory<
+  TProductSearchResultSchema extends AnyProductSearchResultSchema = AnyProductSearchResultSchema,
+> {
+  productSearchResultSchema: TProductSearchResultSchema;
+  parseSearchResult(
+    context: RequestContext,
+    data: unknown,
+    query: ProductSearchQueryByTerm,
+  ): z.output<TProductSearchResultSchema>;
+}
+
+export type ProductSearchFactoryOutput<TFactory extends ProductSearchFactory> =
+  ReturnType<TFactory['parseSearchResult']>;
+
+export type ProductSearchFactoryWithOutput<TFactory extends ProductSearchFactory> =
+  Omit<TFactory, 'parseSearchResult'> & {
+    parseSearchResult(
+      context: RequestContext,
+      data: unknown,
+      query: ProductSearchQueryByTerm,
+    ): ProductSearchFactoryOutput<TFactory>;
+  };

package/packages/core/src/factories/product.factory.ts

@@ -0,0 +1,21 @@
+import type * as z from 'zod';
+import type { ProductSchema } from '../schemas/models/product.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+
+export type AnyProductSchema = z.ZodType<z.output<typeof ProductSchema>>;
+
+export interface ProductFactory<TProductSchema extends AnyProductSchema = AnyProductSchema> {
+  productSchema: TProductSchema;
+  parseProduct(context: RequestContext, data: unknown): z.output<TProductSchema>;
+}
+
+export type ProductFactoryOutput<TFactory extends ProductFactory> = ReturnType<
+  TFactory['parseProduct']
+>;
+
+export type ProductFactoryWithOutput<TFactory extends ProductFactory> = Omit<
+  TFactory,
+  'parseProduct'
+> & {
+  parseProduct(context: RequestContext, data: unknown): ProductFactoryOutput<TFactory>;
+};

package/packages/core/src/factories/profile.factory.ts

@@ -0,0 +1,23 @@
+import type * as z from 'zod';
+import type { ProfileSchema } from '../schemas/models/profile.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+
+export type AnyProfileSchema = z.ZodType<z.output<typeof ProfileSchema>>;
+
+export interface ProfileFactory<
+  TProfileSchema extends AnyProfileSchema = AnyProfileSchema,
+> {
+  profileSchema: TProfileSchema;
+  parseProfile(context: RequestContext, data: unknown): z.output<TProfileSchema>;
+}
+
+export type ProfileFactoryOutput<TFactory extends ProfileFactory> = ReturnType<
+  TFactory['parseProfile']
+>;
+
+export type ProfileFactoryWithOutput<TFactory extends ProfileFactory> = Omit<
+  TFactory,
+  'parseProfile'
+> & {
+  parseProfile(context: RequestContext, data: unknown): ProfileFactoryOutput<TFactory>;
+};

package/packages/core/src/factories/store.factory.ts

@@ -0,0 +1,21 @@
+import type * as z from 'zod';
+import type { StoreSchema } from '../schemas/models/store.model.js';
+import type { RequestContext } from '../schemas/session.schema.js';
+
+export type AnyStoreSchema = z.ZodType<z.output<typeof StoreSchema>>;
+
+export interface StoreFactory<TStoreSchema extends AnyStoreSchema = AnyStoreSchema> {
+  storeSchema: TStoreSchema;
+  parseStore(context: RequestContext, data: unknown): z.output<TStoreSchema>;
+}
+
+export type StoreFactoryOutput<TFactory extends StoreFactory> = ReturnType<
+  TFactory['parseStore']
+>;
+
+export type StoreFactoryWithOutput<TFactory extends StoreFactory> = Omit<
+  TFactory,
+  'parseStore'
+> & {
+  parseStore(context: RequestContext, data: unknown): StoreFactoryOutput<TFactory>;
+};

package/packages/core/src/index.ts

@@ -0,0 +1,8 @@
+export * from './cache/index.js';
+export * from './client/index.js';
+export * from './decorators/index.js';
+export * from './factories/index.js';
+export * from './capabilities/index.js';
+export * from './schemas/index.js';
+export * from './initialization.js';
+export type { InferType } from './zod-utils.js';

package/packages/core/src/test/client-builder.spec.ts

@@ -0,0 +1,141 @@
+import { describe, expect, it } from "vitest";
+import type { Capabilities, ClientFromCapabilities } from "../schemas/capabilities.schema.js";
+import type { Cache } from '../cache/cache.interface.js';
+import type { RequestContext } from "../schemas/session.schema.js";
+import { AnalyticsCapability } from "../capabilities/analytics.capability.js";
+import type { AnalyticsMutation } from "../schemas/index.js";
+import { NoOpCache } from "../cache/noop-cache.js";
+import { createInitialRequestContext } from "../initialization.js";
+import { ClientBuilder } from "../client/client-builder.js";
+import type { Client } from "../client/client.js";
+import { ProductCapability } from "../capabilities/product.capability.js";
+
+export class MockAnalyticsCapability extends AnalyticsCapability {
+    public events: Array<AnalyticsMutation> = [];
+
+    public override async track(event: AnalyticsMutation): Promise<void> {
+        this.events.push(event);
+    }
+}
+
+export interface MockConfiguration {
+    mock?: string;
+}
+
+export function withMockCapabilities<T extends Partial<Capabilities>>(
+  client: Partial<Client>
+) {
+  return (
+    cache: Cache,
+    context: RequestContext
+  ): ClientFromCapabilities<T> => {
+    return client as ClientFromCapabilities<T>
+  }
+};
+
+describe('Client Builder', () => {
+  it('should properly multicast analytics events to all analytics providers that register themselves', async () => {
+    const cache = new NoOpCache();
+    const context = createInitialRequestContext();
+    const builder = new ClientBuilder(context);
+    const analyticsCapability = new MockAnalyticsCapability(cache, context);
+    const secondaryAnalyticsCapability = new MockAnalyticsCapability(cache, context);
+    const client = builder
+        .withCache(cache)
+        .withCapability(withMockCapabilities({ analytics: analyticsCapability }))
+        .withCapability(withMockCapabilities({ analytics: secondaryAnalyticsCapability }))
+        .build();
+
+    const track = await client.analytics.track({
+        event: 'product-details-view',
+        product: {
+          key: 'P-1000'
+        }
+    });
+
+    expect(analyticsCapability.events.length).toBe(1);
+    expect(analyticsCapability.events[0].event).toBe('product-details-view');
+    expect(secondaryAnalyticsCapability.events.length).toBe(1);
+    expect(secondaryAnalyticsCapability.events[0].event).toBe('product-details-view');
+  });
+
+  it('supports capability factories with args object signature', () => {
+    const cache = new NoOpCache();
+    const context = createInitialRequestContext();
+    const builder = new ClientBuilder(context);
+    const analyticsCapability = new MockAnalyticsCapability(cache, context);
+
+    const client = builder
+      .withCache(cache)
+      .withCapability(({ cache: sharedCache, context: sharedContext }) => {
+        expect(sharedCache).toBe(cache);
+        expect(sharedContext).toBe(context);
+        return { analytics: analyticsCapability };
+      })
+      .build();
+
+    expect(client.analytics).toBeDefined();
+  });
+
+  it('supports throw collision strategy', () => {
+    const cache = new NoOpCache();
+    const context = createInitialRequestContext();
+    const builder = new ClientBuilder(context);
+
+    class TestProductCapability extends ProductCapability {
+      public override async getById(): Promise<any> {
+        throw new Error('not implemented');
+      }
+      public override async getBySlug(): Promise<any> {
+        throw new Error('not implemented');
+      }
+      public override async getBySKU(): Promise<any> {
+        throw new Error('not implemented');
+      }
+    }
+
+    expect(() =>
+      builder
+        .withCache(cache)
+        .withCollisionStrategy('throw')
+        .withCapability(() => ({ product: new TestProductCapability(cache, context) }))
+        .withCapability(() => ({ product: new TestProductCapability(cache, context) }))
+        .build(),
+    ).toThrow(/Capability collision detected for "product"/);
+  });
+
+  it('supports first-wins collision strategy', () => {
+    const cache = new NoOpCache();
+    const context = createInitialRequestContext();
+    const builder = new ClientBuilder(context);
+
+    class TestProductCapability extends ProductCapability {
+      public name: string;
+      constructor(cache: Cache, context: RequestContext, name: string) {
+        super(cache, context);
+        this.name = name;
+      }
+      public override async getById(): Promise<any> {
+        throw new Error('not implemented');
+      }
+      public override async getBySlug(): Promise<any> {
+        throw new Error('not implemented');
+      }
+      public override async getBySKU(): Promise<any> {
+        throw new Error('not implemented');
+      }
+    }
+
+    const first = new TestProductCapability(cache, context, 'first');
+    const second = new TestProductCapability(cache, context, 'second');
+
+    const client = builder
+      .withCache(cache)
+      .withCollisionStrategy('first-wins')
+      .withCapability(() => ({ product: first }))
+      .withCapability(() => ({ product: second }))
+      .build();
+
+    expect((client.product as TestProductCapability).name).toBe('first');
+  });
+});

package/{core → packages/core}/src/test/reactionary.decorator.spec.ts

@@ -1,5 +1,5 @@
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { BaseProvider } from '../providers/base.provider.js';
+import { BaseCapability } from '../capabilities/base.capability.js';
 import type { RequestContext } from '../schemas/session.schema.js';
 import type { Cache } from '../cache/cache.interface.js';
 import {
@@ -18,11 +18,11 @@ import { NodeTracerProvider } from '@opentelemetry/sdk-trace-node';
 import { SpanStatusCode, trace } from '@opentelemetry/api';
 import { hrTimeToMilliseconds } from '@opentelemetry/core';
 
-export function createTestableProvider(
+export function createTestableCapability(
   decoratorOptions: Partial<ReactionaryDecoratorOptions>,
   fn?: any
 ) {
-  class TestableProvider extends BaseProvider {
+  class TestableCapability extends BaseCapability {
     constructor(
       public override cache: Cache,
       public override context: RequestContext
@@ -53,36 +53,36 @@ export function createTestableProvider(
     }
 
     public getResourceName(): string {
-      return 'TestableProvider';
+      return 'TestableCapability';
     }
   }
 
   const cache = new MemoryCache();
   const context = createInitialRequestContext();
 
-  return new TestableProvider(cache, context);
+  return new TestableCapability(cache, context);
 }
 
 describe('@Reactionary decorator', () => {
   describe('Input validation', () => {
     it('should reject invalid input with a failure', async () => {
-      const provider = createTestableProvider({
+      const capability = createTestableCapability({
         cache: false,
         inputSchema: z.string(),
       });
 
-      const result = await provider.decoratedFunction(42);
+      const result = await capability.decoratedFunction(42);
 
       expect(result.success).toBe(false);
     });
 
     it('should allow valid input through with a success', async () => {
-      const provider = createTestableProvider({
+      const capability = createTestableCapability({
         cache: false,
         inputSchema: z.string(),
       });
 
-      const result = await provider.decoratedFunction('42');
+      const result = await capability.decoratedFunction('42');
 
       expect(result.success).toBe(true);
     });
@@ -90,7 +90,7 @@ describe('@Reactionary decorator', () => {
 
   describe('Output validation', () => {
     it('should reject invalid output with a failure', async () => {
-      const provider = createTestableProvider(
+      const capability = createTestableCapability(
         {
           cache: false,
           outputSchema: z.string(),
@@ -100,13 +100,13 @@ describe('@Reactionary decorator', () => {
         }
       );
 
-      const result = await provider.decoratedFunction();
+      const result = await capability.decoratedFunction();
 
       expect(result.success).toBe(false);
     });
 
     it('should allow valid output with a success', async () => {
-      const provider = createTestableProvider(
+      const capability = createTestableCapability(
         {
           cache: false,
           outputSchema: z.string(),
@@ -116,7 +116,7 @@ describe('@Reactionary decorator', () => {
         }
       );
 
-      const result = await provider.decoratedFunction();
+      const result = await capability.decoratedFunction();
 
       expect(result.success).toBe(true);
     });
@@ -124,11 +124,11 @@ describe('@Reactionary decorator', () => {
 
   describe('Error handling', () => {
     it('will wrap errors thrown by the provider in a GenericError', async () => {
-      const provider = createTestableProvider({}, function () {
+      const capability = createTestableCapability({}, function () {
         throw new Error('42');
       });
 
-      const result = await provider.decoratedFunction();
+      const result = await capability.decoratedFunction();
 
       if (result.success) {
         assert.fail();
@@ -157,14 +157,14 @@ describe('@Reactionary decorator', () => {
     });
 
     it('records a timed span for entering the decorated function', async () => {
-      const provider = createTestableProvider({
+      const capability = createTestableCapability({
         cache: false,
       }, async function() { 
         await new Promise(resolve => setTimeout(resolve, 200));
 
         return "42";
       });
-      const result = await provider.decoratedFunction();
+      const result = await capability.decoratedFunction();
       const spans = exporter.getFinishedSpans();
 
       expect(spans.length).toBe(1);
@@ -176,20 +176,20 @@ describe('@Reactionary decorator', () => {
 
       console.log('unset expected: ', status);
 
-      expect(name).toBe('TestableProvider.decoratedFunction');
+      expect(name).toBe('TestableCapability.decoratedFunction');
       expect(duration).toBeGreaterThanOrEqual(200);
       expect(duration).toBeLessThanOrEqual(300);
       expect(status.code).toBe(SpanStatusCode.UNSET);
     });
 
     it('records exceptions as events and marks the span as an error', async () => {
-      const provider = createTestableProvider({
+      const capability = createTestableCapability({
         cache: false,
       }, async function() { 
         throw new Error('42');
       });
 
-      const result = await provider.decoratedFunction();
+      const result = await capability.decoratedFunction();
       const spans = exporter.getFinishedSpans();
 
       expect(spans.length).toBe(1);
@@ -198,17 +198,17 @@ describe('@Reactionary decorator', () => {
       const name = span.name;
       const status = span.status;
 
-      expect(name).toBe('TestableProvider.decoratedFunction');
+      expect(name).toBe('TestableCapability.decoratedFunction');
       expect(status.code).toBe(SpanStatusCode.ERROR);
     });
   });
 
   describe('Caching', () => {
     it('should not cache repeat lookups if the decorator is set to uncached', async () => {
-      const provider = createTestableProvider({
+      const capability = createTestableCapability({
         cache: false,
       });
-      const result = await provider.decoratedFunction();
+      const result = await capability.decoratedFunction();
 
       if (!result.success) {
         assert.fail();
@@ -216,7 +216,7 @@ describe('@Reactionary decorator', () => {
 
       expect(result.meta.cache.hit).toBe(false);
 
-      const secondResult = await provider.decoratedFunction();
+      const secondResult = await capability.decoratedFunction();
 
       if (!secondResult.success) {
         assert.fail();
@@ -226,10 +226,10 @@ describe('@Reactionary decorator', () => {
     });
 
     it('should cache repeat lookups if the decorator is set to cached', async () => {
-      const provider = createTestableProvider({
+      const capability = createTestableCapability({
         cache: true,
       });
-      const result = await provider.decoratedFunction();
+      const result = await capability.decoratedFunction();
 
       if (!result.success) {
         assert.fail();
@@ -237,7 +237,7 @@ describe('@Reactionary decorator', () => {
 
       expect(result.meta.cache.hit).toBe(false);
 
-      const secondResult = await provider.decoratedFunction();
+      const secondResult = await capability.decoratedFunction();
 
       if (!secondResult.success) {
         assert.fail();

package/{providers/meilisearch → packages/core}/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "module": "NodeNext",
+    "module": "nodenext",
     "moduleResolution": "nodenext",
     "forceConsistentCasingInFileNames": true,
     "strict": true,

package/{providers/medusa → packages/core}/tsconfig.lib.json

@@ -18,7 +18,6 @@
     "src/**/*.test.js",
     "src/**/*.spec.js",
     "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/test/**/*.ts"
+    "src/**/*.spec.jsx"
   ]
 }

package/packages/core/tsconfig.spec.json

@@ -0,0 +1,28 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "types": [
+      "vitest/globals",
+      "vitest/importMeta",
+      "vite/client",
+      "node",
+      "vitest"
+    ]
+  },
+  "include": [
+    "vite.config.ts",
+    "vite.config.mts",
+    "vitest.config.ts",
+    "vitest.config.mts",
+    "src/**/*.test.ts",
+    "src/**/*.spec.ts",
+    "src/**/*.test.tsx",
+    "src/**/*.spec.tsx",
+    "src/**/*.test.js",
+    "src/**/*.spec.js",
+    "src/**/*.test.jsx",
+    "src/**/*.spec.jsx",
+    "src/**/*.d.ts"
+  ]
+}

package/packages/core/vite.config.ts

@@ -0,0 +1,26 @@
+/// <reference types='vitest' />
+import { defineConfig } from 'vite';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: import.meta.dirname,
+  cacheDir: '../../node_modules/.vite/packages/core',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //   plugins: () => [ nxViteTsPaths() ],
+  // },
+  test: {
+    name: 'core',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/packages/core',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/core/vitest.config.mts

@@ -0,0 +1,21 @@
+import { defineConfig } from 'vitest/config';
+import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
+import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
+
+export default defineConfig(() => ({
+  root: __dirname,
+  cacheDir: '../../node_modules/.vite/packages/core',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'core',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/packages/core',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/packages/fake/README.md

@@ -0,0 +1,11 @@
+# fake
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build fake` to build the library.
+
+## Running unit tests
+
+Run `nx test fake` to execute the unit tests via [Vitest](https://vitest.dev/).

package/{providers/algolia → packages/fake}/eslint.config.mjs

@@ -9,8 +9,9 @@ export default [
         'error',
         {
           ignoredFiles: [
-            '{projectRoot}/eslint.config.{js,cjs,mjs}',
+            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
             '{projectRoot}/esbuild.config.{js,ts,mjs,mts}',
+            '{projectRoot}/vite.config.{js,ts,mjs,mts}',
           ],
         },
       ],

package/{providers → packages}/fake/package.json

@@ -1,13 +1,15 @@
 {
-  "name": "@reactionary/provider-fake",
+  "name": "@reactionary/fake",
   "version": "0.0.1",
-  "main": "index.js",
-  "types": "src/index.d.ts",
+  "type": "module",
+  "main": "./index.js",
+  "types": "./src/index.d.ts",
   "dependencies": {
+    "vitest": "^4.0.9",
+    "@nx/vite": "22.4.5",
     "@reactionary/core": "0.0.1",
     "zod": "4.1.9",
     "@faker-js/faker": "^9.8.0"
   },
-  "type": "module",
   "sideEffects": false
 }