@reactionary/source 0.3.18 → 0.6.2

package/providers/fake/src/test/order-search.provider.spec.ts

@@ -1,18 +1,14 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
-  CartSchema,
-  IdentitySchema,
   NoOpCache,
+  OrderSearchResultSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakeCartProvider } from '../providers/cart.provider.js';
-import { FakeIdentityProvider } from '../providers/index.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
-import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
-import { FakeOrderProvider } from '../providers/order.provider.js';
 import { FakeOrderSearchProvider } from '../providers/order-search.provider.js';
+import { FakeOrderSearchFactory } from '../factories/index.js';
 
 describe('Fake Order Search Provider', () => {
   let provider: FakeOrderSearchProvider;
@@ -23,7 +19,8 @@ describe('Fake Order Search Provider', () => {
     provider = new FakeOrderSearchProvider(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakeOrderSearchFactory(OrderSearchResultSchema),
     );
   });
 

package/providers/fake/src/test/order.provider.spec.ts

@@ -1,17 +1,14 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
 import {
-  CartSchema,
-  IdentitySchema,
   NoOpCache,
+  OrderSchema,
   createInitialRequestContext,
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
-import { FakeCartProvider } from '../providers/cart.provider.js';
-import { FakeIdentityProvider } from '../providers/index.js';
 import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
-import { FakeCheckoutProvider } from '../providers/checkout.provider.js';
 import { FakeOrderProvider } from '../providers/order.provider.js';
+import { FakeOrderFactory } from '../factories/index.js';
 
 describe('Fake Order Provider', () => {
   let provider: FakeOrderProvider;
@@ -22,7 +19,8 @@ describe('Fake Order Provider', () => {
     provider = new FakeOrderProvider(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakeOrderFactory(OrderSchema),
     );
   });
 

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

@@ -7,6 +7,7 @@ import {
 } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { FakePriceProvider } from '../providers/price.provider.js';
+import { FakePriceFactory } from '../factories/index.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 
 const testData = {
@@ -23,7 +24,8 @@ describe('Fake Price Provider', () => {
     provider = new FakePriceProvider(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakePriceFactory(PriceSchema),
     );
   });
 

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

@@ -1,9 +1,10 @@
 import 'dotenv/config';
 
 import type { RequestContext } from '@reactionary/core';
-import { createInitialRequestContext, MemoryCache } from '@reactionary/core';
+import { createInitialRequestContext, MemoryCache, ProductSchema } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { FakeProductProvider } from '../providers/index.js';
+import { FakeProductFactory } from '../factories/index.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 
 describe('Fake Product Provider', () => {
@@ -12,7 +13,12 @@ describe('Fake Product Provider', () => {
 
   beforeEach( () => {
     reqCtx = createInitialRequestContext();
-    provider = new FakeProductProvider(getFakerTestConfiguration(),  new MemoryCache(), reqCtx);
+    provider = new FakeProductProvider(
+      getFakerTestConfiguration(),
+      new MemoryCache(),
+      reqCtx,
+      new FakeProductFactory(ProductSchema),
+    );
   })
 
   it('should cache repeat product lookups by id', async () => {

package/providers/fake/src/test/profile.provider.spec.ts

@@ -1,9 +1,10 @@
 import 'dotenv/config';
 import type { RequestContext } from '@reactionary/core';
-import { NoOpCache, createInitialRequestContext } from '@reactionary/core';
+import { NoOpCache, ProfileSchema, createInitialRequestContext } from '@reactionary/core';
 import { getFakerTestConfiguration } from './test-utils.js';
 import { describe, expect, it, beforeEach, assert } from 'vitest';
 import { FakeProfileProvider } from '../providers/profile.provider.js';
+import { FakeProfileFactory } from '../factories/index.js';
 
 describe('Fake Profile Provider', () => {
   let provider: FakeProfileProvider;
@@ -14,7 +15,8 @@ describe('Fake Profile Provider', () => {
     provider = new FakeProfileProvider(
       getFakerTestConfiguration(),
       new NoOpCache(),
-      reqCtx
+      reqCtx,
+      new FakeProfileFactory(ProfileSchema),
     );
   });
 

package/providers/google-analytics/src/core/initialize.ts

@@ -1,16 +1,41 @@
-import type { Cache, ClientFromCapabilities, RequestContext } from "@reactionary/core";
-import type { GoogleAnalyticsCapabilities } from "../schema/capabilities.schema.js";
-import type { GoogleAnalyticsConfiguration } from "../schema/configuration.schema.js";
-import { GoogleAnalyticsAnalyticsProvider } from "../providers/analytics.provider.js";
+import type { Cache, RequestContext } from '@reactionary/core';
+import {
+  GoogleAnalyticsCapabilitiesSchema,
+  type GoogleAnalyticsCapabilities,
+} from '../schema/capabilities.schema.js';
+import type { GoogleAnalyticsConfiguration } from '../schema/configuration.schema.js';
+import { GoogleAnalyticsAnalyticsProvider } from '../providers/analytics.provider.js';
+import {
+  type GoogleAnalyticsClientFromCapabilities,
+  resolveProviderOnlyCapability,
+} from './initialize.types.js';
 
-export function googleAnalyticsCapabilities<T extends GoogleAnalyticsCapabilities>(configuration: GoogleAnalyticsConfiguration, capabilities: T) {
-    return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
-        const client: any = {};
+export function withGoogleAnalyticsCapabilities<
+  T extends GoogleAnalyticsCapabilities,
+>(configuration: GoogleAnalyticsConfiguration, capabilities: T) {
+  return (
+    cache: Cache,
+    context: RequestContext,
+  ): GoogleAnalyticsClientFromCapabilities<T> => {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const client: any = {};
+    const caps = GoogleAnalyticsCapabilitiesSchema.parse(capabilities);
 
-        if (capabilities.analytics) {
-            client.analytics = new GoogleAnalyticsAnalyticsProvider(cache, context, configuration);
-        }
+    if (caps.analytics?.enabled) {
+      client.analytics = resolveProviderOnlyCapability(
+        capabilities.analytics,
+        (args) => new GoogleAnalyticsAnalyticsProvider(args.cache, args.context, args.config),
+        {
+          cache,
+          context,
+          config: configuration,
+        },
+      );
+    }
 
-        return client;
-    };
+    return client;
+  };
 }
+
+// Backward-compatibility alias.
+export const googleAnalyticsCapabilities = withGoogleAnalyticsCapabilities;

package/providers/google-analytics/src/core/initialize.types.ts

@@ -0,0 +1,47 @@
+import type { ClientFromCapabilities } from '@reactionary/core';
+import type { GoogleAnalyticsCapabilities } from '../schema/capabilities.schema.js';
+import type { GoogleAnalyticsAnalyticsProvider } from '../providers/analytics.provider.js';
+
+type EnabledCapability<TCapability> =
+  TCapability extends { enabled: true } ? true : false;
+
+type NormalizeConfiguredCapabilities<T extends GoogleAnalyticsCapabilities> =
+  Omit<T, 'analytics'> & {
+    analytics?: EnabledCapability<T['analytics']>;
+  };
+
+type ExtractCapabilityProvider<TCapability, TDefaultProvider> =
+  TCapability extends { enabled: true; provider?: infer TProviderFactory }
+    ? TProviderFactory extends (...args: unknown[]) => infer TProvider
+      ? TProvider
+      : TDefaultProvider
+    : TDefaultProvider;
+
+type CapabilityOverride<
+  TCapability,
+  TKey extends string,
+  TProvider,
+> = TCapability extends { enabled: true }
+  ? { [K in TKey]: TProvider }
+  : Record<never, never>;
+
+type AnalyticsProviderFor<T extends GoogleAnalyticsCapabilities> =
+  ExtractCapabilityProvider<T['analytics'], GoogleAnalyticsAnalyticsProvider>;
+
+export type GoogleAnalyticsClientFromCapabilities<
+  T extends GoogleAnalyticsCapabilities,
+> = Omit<ClientFromCapabilities<NormalizeConfiguredCapabilities<T>>, 'analytics'> &
+  CapabilityOverride<T['analytics'], 'analytics', AnalyticsProviderFor<T>>;
+
+export function resolveProviderOnlyCapability<TProvider, TProviderArgs>(
+  capability:
+    | {
+        provider?: (args: TProviderArgs) => TProvider;
+      }
+    | undefined,
+  defaultProvider: (args: TProviderArgs) => TProvider,
+  args: TProviderArgs,
+): TProvider {
+  const provider = capability?.provider ?? defaultProvider;
+  return provider(args);
+}

package/providers/google-analytics/src/index.ts

@@ -1,4 +1,5 @@
 export * from './core/initialize.js';
+export * from './core/initialize.types.js';
 export * from './providers/analytics.provider.js';
 export * from './schema/capabilities.schema.js';
 export * from './schema/configuration.schema.js';

package/providers/google-analytics/src/schema/capabilities.schema.ts

@@ -1,10 +1,36 @@
+import type { AnalyticsProvider, Cache, RequestContext } from '@reactionary/core';
 import { CapabilitiesSchema } from '@reactionary/core';
-import type * as z from 'zod';
+import type { GoogleAnalyticsConfiguration } from './configuration.schema.js';
+import * as z from 'zod';
+
+const AnalyticsCapabilitySchema = z.looseObject({
+  enabled: z.boolean(),
+  provider: z.unknown().optional(),
+});
 
 export const GoogleAnalyticsCapabilitiesSchema = CapabilitiesSchema.pick({
   analytics: true,
-}).partial();
+})
+  .extend({
+    analytics: AnalyticsCapabilitySchema.optional(),
+  })
+  .partial();
+
+export interface GoogleAnalyticsProviderFactoryArgs {
+  cache: Cache;
+  context: RequestContext;
+  config: GoogleAnalyticsConfiguration;
+}
+
+export interface GoogleAnalyticsAnalyticsCapabilityConfig<
+  TProvider extends AnalyticsProvider = AnalyticsProvider,
+> {
+  enabled: boolean;
+  provider?: (args: GoogleAnalyticsProviderFactoryArgs) => TProvider;
+}
 
-export type GoogleAnalyticsCapabilities = z.infer<
-  typeof GoogleAnalyticsCapabilitiesSchema
->;
+export type GoogleAnalyticsCapabilities<
+  TAnalyticsProvider extends AnalyticsProvider = AnalyticsProvider,
+> = {
+  analytics?: GoogleAnalyticsAnalyticsCapabilityConfig<TAnalyticsProvider>;
+};