@reactionary/source 0.3.0 → 0.3.1

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

@@ -0,0 +1,16 @@
+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";
+
+export function googleAnalyticsCapabilities<T extends GoogleAnalyticsCapabilities>(configuration: GoogleAnalyticsConfiguration, capabilities: T) {
+    return (cache: Cache, context: RequestContext): ClientFromCapabilities<T> => {
+        const client: any = {};
+
+        if (capabilities.analytics) {
+            client.analytics = new GoogleAnalyticsAnalyticsProvider(cache, context, configuration);
+        }
+
+        return client;
+    };
+}

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

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

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

@@ -0,0 +1,162 @@
+import {
+  AnalyticsProvider,
+  type RequestContext,
+  type Cache,
+  type AnalyticsMutationProductSummaryViewEvent,
+  type AnalyticsMutationProductSummaryClickEvent,
+  type AnalyticsMutationProductDetailsViewEvent,
+  type AnalyticsMutationProductAddToCartEvent,
+  type AnalyticsMutationPurchaseEvent,
+} from '@reactionary/core';
+import type { GoogleAnalyticsConfiguration } from '../schema/configuration.schema.js';
+
+export class GoogleAnalyticsAnalyticsProvider extends AnalyticsProvider {
+  protected config: GoogleAnalyticsConfiguration;
+
+  constructor(
+    cache: Cache,
+    context: RequestContext,
+    configuration: GoogleAnalyticsConfiguration
+  ) {
+    super(cache, context);
+
+    this.config = configuration;
+  }
+
+  protected override async processProductSummaryView(
+    event: AnalyticsMutationProductSummaryViewEvent
+  ) {
+    const gaEvent = {
+      client_id: this.context.session.identityContext.personalizationKey,
+      user_id: this.context.session.identityContext.personalizationKey,
+      events: [
+        {
+          name: 'view_item_list',
+          params: {
+            currency: this.context.languageContext.currencyCode,
+            items: event.products.map((x) => {
+              return {
+                item_id: x.key,
+              };
+            }),
+          },
+        },
+      ],
+    };
+
+    await this.sendEvent(gaEvent);
+  }
+
+  protected override async processProductSummaryClick(
+    event: AnalyticsMutationProductSummaryClickEvent
+  ) {
+    const gaEvent = {
+      client_id: this.context.session.identityContext.personalizationKey,
+      user_id: this.context.session.identityContext.personalizationKey,
+      events: [
+        {
+          name: 'select_item',
+          params: {
+            currency: this.context.languageContext.currencyCode,
+            items: [
+              {
+                item_id: event.product.key,
+                index: event.position,
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    await this.sendEvent(gaEvent);
+  }
+
+  protected override async processProductDetailsView(
+    event: AnalyticsMutationProductDetailsViewEvent
+  ) {
+    const gaEvent = {
+      client_id: this.context.session.identityContext.personalizationKey,
+      user_id: this.context.session.identityContext.personalizationKey,
+      events: [
+        {
+          name: 'view_item',
+          params: {
+            currency: this.context.languageContext.currencyCode,
+            items: [
+              {
+                item_id: event.product.key,
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    await this.sendEvent(gaEvent);
+  }
+
+  protected override async processProductAddToCart(
+    event: AnalyticsMutationProductAddToCartEvent
+  ) {
+    const gaEvent = {
+      client_id: this.context.session.identityContext.personalizationKey,
+      user_id: this.context.session.identityContext.personalizationKey,
+      events: [
+        {
+          name: 'add_to_cart',
+          params: {
+            currency: this.context.languageContext.currencyCode,
+            items: [
+              {
+                item_id: event.product.key,
+              },
+            ],
+          },
+        },
+      ],
+    };
+
+    await this.sendEvent(gaEvent);
+  }
+
+  protected override async processPurchase(
+    event: AnalyticsMutationPurchaseEvent
+  ) {
+    const gaEvent = {
+      client_id: this.context.session.identityContext.personalizationKey,
+      user_id: this.context.session.identityContext.personalizationKey,
+      events: [
+        {
+          name: 'purchase',
+          params: {
+            currency: this.context.languageContext.currencyCode,
+            transaction_id: event.order.identifier.key,
+            value: event.order.price.grandTotal.value,
+            tax: event.order.price.totalTax.value,
+            shipping: event.order.price.totalShipping.value,
+            items: event.order.items.map((item) => ({
+              item_id: item.variant.sku,
+              quantity: item.quantity,
+              price: item.price.unitPrice.value,
+            })),
+          },
+        },
+      ],
+    };
+
+    await this.sendEvent(gaEvent);
+  }
+
+  protected async sendEvent(event: unknown) {
+    const url = `${this.config.url}?measurement_id=${this.config.measurementId}&api_secret=${this.config.apiSecret}`;
+
+    await fetch(url, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify(event),
+    });
+  }
+}

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

@@ -0,0 +1,10 @@
+import { CapabilitiesSchema } from '@reactionary/core';
+import type { z } from 'zod';
+
+export const GoogleAnalyticsCapabilitiesSchema = CapabilitiesSchema.pick({
+  analytics: true,
+}).partial();
+
+export type GoogleAnalyticsCapabilities = z.infer<
+  typeof GoogleAnalyticsCapabilitiesSchema
+>;

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

@@ -0,0 +1,9 @@
+import { z } from 'zod';
+
+export const GoogleAnalyticsConfigurationSchema = z.looseObject({
+    url: z.string(),
+    measurementId: z.string(),
+    apiSecret: z.string()
+});
+
+export type GoogleAnalyticsConfiguration = z.infer<typeof GoogleAnalyticsConfigurationSchema>;

package/providers/google-analytics/src/test/analytics.provider.spec.ts

@@ -0,0 +1,93 @@
+import 'dotenv/config';
+import type { AnalyticsMutationProductSummaryViewEvent, AnalyticsMutationPurchaseEvent, RequestContext } from '@reactionary/core';
+import {
+  CartSchema,
+  IdentitySchema,
+  NoOpCache,
+  createInitialRequestContext,
+} from '@reactionary/core';
+import { describe, expect, it, beforeAll, beforeEach, assert } from 'vitest';
+import { GoogleAnalyticsAnalyticsProvider } from '../providers/analytics.provider.js';
+import type { GoogleAnalyticsConfiguration } from '../schema/configuration.schema.js';
+
+describe('Google Analytics Analytics Provider', () => {
+  let provider: GoogleAnalyticsAnalyticsProvider;
+  let reqCtx: RequestContext;
+
+  beforeEach(() => {
+    reqCtx = createInitialRequestContext();
+    const config = {
+      apiSecret: process.env['GOOGLE_ANALYTICS_API_SECRET'] || '',
+      measurementId: process.env['GOOGLE_ANALYTICS_MEASUREMENT_ID'] || '',
+      url: process.env['GOOGLE_ANALYTICS_URL'] || '',
+    } satisfies GoogleAnalyticsConfiguration;
+
+    provider = new GoogleAnalyticsAnalyticsProvider(
+      new NoOpCache(),
+      reqCtx,
+      config
+    );
+  });
+
+  describe('tracking', () => {
+    it('should be able to add an item to a cart', async () => {
+        const event = {
+            event: 'product-summary-view',
+            products: [{
+                key: 'P-5000'
+            }]
+        } satisfies AnalyticsMutationProductSummaryViewEvent;
+
+        const result = await provider.track(event);
+    });
+
+    it('should be able to track a purchase', async () => {
+        const event = {
+            event: 'purchase',
+            order: {
+                identifier: { key: 'ORDER-12345' },
+                userId: { userId: 'test-user-123' },
+                items: [
+                    {
+                        identifier: { key: 'item-1' },
+                        variant: { sku: 'SKU-001' },
+                        quantity: 2,
+                        price: {
+                            unitPrice: { value: 29.99, currency: 'EUR' },
+                            unitDiscount: { value: 0, currency: 'EUR' },
+                            totalPrice: { value: 59.98, currency: 'EUR' },
+                            totalDiscount: { value: 0, currency: 'EUR' },
+                        },
+                        inventoryStatus: 'Allocated',
+                    },
+                    {
+                        identifier: { key: 'item-2' },
+                        variant: { sku: 'SKU-002' },
+                        quantity: 1,
+                        price: {
+                            unitPrice: { value: 49.99, currency: 'EUR' },
+                            unitDiscount: { value: 5, currency: 'EUR' },
+                            totalPrice: { value: 44.99, currency: 'EUR' },
+                            totalDiscount: { value: 5, currency: 'EUR' },
+                        },
+                        inventoryStatus: 'Allocated',
+                    },
+                ],
+                price: {
+                    totalTax: { value: 21.99, currency: 'EUR' },
+                    totalDiscount: { value: 5, currency: 'EUR' },
+                    totalSurcharge: { value: 0, currency: 'EUR' },
+                    totalShipping: { value: 4.99, currency: 'EUR' },
+                    totalProductPrice: { value: 104.97, currency: 'EUR' },
+                    grandTotal: { value: 126.95, currency: 'EUR' },
+                },
+                orderStatus: 'AwaitingPayment',
+                inventoryStatus: 'Allocated',
+                paymentInstructions: [],
+            },
+        } satisfies AnalyticsMutationPurchaseEvent;
+
+        await provider.track(event);
+    });
+  });
+});

package/providers/google-analytics/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "module": "nodenext",
+    "moduleResolution": "nodenext",
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "importHelpers": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noFallthroughCasesInSwitch": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/providers/google-analytics/tsconfig.lib.json

@@ -0,0 +1,23 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "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"
+  ]
+}

package/providers/google-analytics/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/providers/google-analytics/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/providers/google-analytics',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  // Uncomment this if you are using workers.
+  // worker: {
+  //   plugins: () => [ nxViteTsPaths() ],
+  // },
+  test: {
+    name: 'google-analytics',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/providers/google-analytics',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/providers/google-analytics/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/providers/google-analytics',
+  plugins: [nxViteTsPaths(), nxCopyAssetsPlugin(['*.md'])],
+  test: {
+    name: 'google-analytics',
+    watch: false,
+    globals: true,
+    environment: 'node',
+    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
+    reporters: ['default'],
+    coverage: {
+      reportsDirectory: '../../coverage/providers/google-analytics',
+      provider: 'v8' as const,
+    },
+  },
+}));

package/providers/medusa/package.json

@@ -5,18 +5,11 @@
   "main": "index.js",
   "types": "src/index.d.ts",
   "dependencies": {
-    "zod": "4.1.9",
+    "@medusajs/js-sdk": "^2.13.0",
     "@reactionary/core": "0.0.1",
-    "@medusajs/js-sdk": "^2.0.0",
-    "debug": "^4.3.4",
+    "debug": "^4.4.3",
     "@medusajs/types": "^2.11.0",
-    "dotenv": "^17.2.2"
-  },
-  "devDependencies": {
-    "vitest": "*",
-    "@vitest/ui": "*",
-    "@vitest/coverage-v8": "*",
-    "vite-tsconfig-paths": "*"
+    "zod": "4.1.9"
   },
   "sideEffects": false
 }

package/providers/medusa/project.json

@@ -1,5 +1,5 @@
 {
-  "name": "provider-medusa",
+  "name": "medusa",
   "$schema": "../../node_modules/nx/schemas/project-schema.json",
   "sourceRoot": "providers/medusa/src",
   "projectType": "library",

package/providers/medusa/src/providers/profile.provider.ts

@@ -129,9 +129,7 @@ export class MedusaProfileProvider extends ProfileProvider {
     if (existingAddress) {
       return error<InvalidInputError>({
         type: 'InvalidInput',
-        error: {
-          message: 'Address with the same nickname already exists',
-        }
+        error: 'Address with the same nickname already exists'
       });
     }
 
@@ -139,9 +137,7 @@ export class MedusaProfileProvider extends ProfileProvider {
     if (!response.customer) {
       return error<InvalidInputError>({
         type: 'InvalidInput',
-        error: {
-          message: 'Failed to add shipping address',
-        }
+        error: 'Failed to add shipping address'
       });
     }
 
@@ -180,9 +176,7 @@ export class MedusaProfileProvider extends ProfileProvider {
     if (!response.customer) {
       return error<InvalidInputError>({
         type: 'InvalidInput',
-        error: {
-          message: 'Failed to add shipping address',
-        }
+        error: 'Failed to add shipping address'
       })
     }
 
@@ -221,9 +215,7 @@ export class MedusaProfileProvider extends ProfileProvider {
     if (!response.deleted) {
       return error<InvalidInputError>({
         type: 'InvalidInput',
-        error: {
-          message: 'Failed to delete shipping address',
-        }
+        error: 'Failed to delete shipping address'
       });
     }
 
@@ -292,9 +284,7 @@ export class MedusaProfileProvider extends ProfileProvider {
     if (existingAddressWithNickname && !existingAddressWithNickname.is_default_billing) {
       return error<InvalidInputError>({
         type: 'InvalidInput',
-        error: {
-          message: 'Another address with the same nickname already exists',
-        }
+        error: 'Another address with the same nickname already exists'
       });
     }
 

package/providers/medusa/src/test/test-utils.ts

@@ -1,4 +1,3 @@
-import 'dotenv/config';
 
 import { MedusaConfigurationSchema, type MedusaConfiguration } from '../schema/configuration.schema.js';
 

package/providers/medusa/tsconfig.json

@@ -16,6 +16,9 @@
   "references": [
     {
       "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
     }
   ]
 }

package/providers/medusa/tsconfig.lib.json

@@ -5,5 +5,20 @@
     "declaration": true,
     "types": ["node"]
   },
-  "include": ["src/**/*.ts"]
+  "include": ["src/**/*.ts"],
+  "exclude": [
+    "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/test/**/*.ts"
+  ]
 }

package/providers/meilisearch/project.json

@@ -1,5 +1,5 @@
 {
-  "name": "provider-meilisearch",
+  "name": "meilisearch",
   "$schema": "../../node_modules/nx/schemas/project-schema.json",
   "sourceRoot": "providers/meilisearch/src",
   "projectType": "library",

package/providers/posthog/project.json

@@ -1,5 +1,5 @@
 {
-  "name": "provider-posthog",
+  "name": "posthog",
   "$schema": "../../node_modules/nx/schemas/project-schema.json",
   "sourceRoot": "providers/posthog/src",
   "projectType": "library",

package/tsconfig.base.json

@@ -27,7 +27,10 @@
         "providers/commercetools/src/index.ts"
       ],
       "@reactionary/provider-fake": ["providers/fake/src/index.ts"],
-      "@reactionary/provider-posthog": ["providers/posthog/src/index.ts"]
+      "@reactionary/provider-posthog": ["providers/posthog/src/index.ts"],
+      "@reactionary/google-analytics": [
+        "providers/google-analytics/src/index.ts"
+      ]
     },
     "verbatimModuleSyntax": true
   },

package/.claude/settings.local.json

@@ -1,28 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(npx nx build:*)",
-      "Bash(npx tsc:*)",
-      "Bash(npx nx lint:*)",
-      "Bash(npx nx test:*)",
-      "Bash(npx nx run:*)",
-      "Bash(npx ts-node:*)",
-      "Bash(npx tsx:*)",
-      "Bash(grep:*)",
-      "Bash(pnpm list:*)",
-      "Bash(npx nx affected:build:*)",
-      "Bash(npx nx affected:lint:*)",
-      "Bash(cat:*)",
-      "Bash(npx nx show projects:*)",
-      "Bash(npx nx g:*)",
-      "Bash(pnpm add:*)",
-      "Bash(npx nx show project:*)",
-      "Bash(npx nx reset:*)",
-      "WebSearch",
-      "Bash(node:*)",
-      "Bash(npm view:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}

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

@@ -1,23 +0,0 @@
-import { z } from 'zod';
-import { BaseMutationSchema } from './base.mutation.js';
-import { ProductIdentifierSchema, ProductSearchIdentifierSchema } from '../models/identifiers.model.js';
-import type { InferType } from '../../zod-utils.js';
-
-export const AnalyticsMutationSearchEventSchema = BaseMutationSchema.extend({
-    mutation: z.literal('search'),
-    search: ProductSearchIdentifierSchema,
-    products: z.array(ProductIdentifierSchema),
-});
-
-export const AnalyticsMutationSearchProductClickEventSchema = BaseMutationSchema.extend({
-    mutation: z.literal('product-search-click'),
-    search: ProductSearchIdentifierSchema,
-    product: ProductIdentifierSchema,
-    position: z.number().min(0)
-});
-
-export const AnalyticsMutationSchema = z.union([AnalyticsMutationSearchEventSchema, AnalyticsMutationSearchProductClickEventSchema]);
-
-export type AnalyticsMutation = InferType<typeof AnalyticsMutationSchema>;
-export type AnalyticsMutationSearchEvent = InferType<typeof AnalyticsMutationSearchEventSchema>;
-export type AnalyticsMutationSearchProductClickEvent = InferType<typeof AnalyticsMutationSearchProductClickEventSchema>;

package/providers/algolia/src/test/test-utils.ts

@@ -1,31 +0,0 @@
-import type { Session } from "@reactionary/core";
-
-export function createAnonymousTestSession(): Session {
-  return {
-    id: 'test-session-id',
-    identity: {
-      type: 'Anonymous',
-      meta: {
-        cache: { hit: false, key: '' },
-        placeholder: false,
-      },
-      id: { userId: 'anonymous' },
-      token: undefined,
-      issued: new Date(),
-      expiry: new Date(new Date().getTime() + 3600 * 1000),
-      logonId: "",
-      createdAt: "",
-      updatedAt: "",
-      keyring: [],
-      currentService: undefined
-    },
-    languageContext: {
-      locale: 'en-US',
-      currencyCode: 'USD',
-      countryCode: 'US',
-    },
-    storeIdentifier: {
-      key: 'the-good-store',
-    },
-  };
-}