umami

2026-01-24 22:03:06 +01:00
parent 7e94feaf19
commit 72711c74ba
14 changed files with 3056 additions and 13 deletions
--- a/lib/services/analytics/README.md
+++ b/lib/services/analytics/README.md
@@ -0,0 +1,430 @@
+# Analytics Service Layer
+
+This directory contains the service layer implementation for analytics tracking in the KLZ Cables application.
+
+## Overview
+
+The analytics service layer provides a clean abstraction over different analytics implementations (Umami, Google Analytics, etc.) while maintaining a consistent API.
+
+## Architecture
+
+```
+lib/services/analytics/
+├── analytics-service.ts          # Interface definition
+├── umami-analytics-service.ts    # Umami implementation
+├── noop-analytics-service.ts     # No-op fallback implementation
+└── README.md                     # This file
+```
+
+## Components
+
+### 1. AnalyticsService Interface (`analytics-service.ts`)
+
+Defines the contract for all analytics services:
+
+```typescript
+export interface AnalyticsService {
+  track(eventName: string, props?: AnalyticsEventProperties): void;
+  trackPageview(url?: string): void;
+}
+```
+
+**Key Features:**
+- Type-safe event properties
+- Consistent API across implementations
+- Well-documented with JSDoc comments
+
+### 2. UmamiAnalyticsService (`umami-analytics-service.ts`)
+
+Implements the `AnalyticsService` interface for Umami analytics.
+
+**Features:**
+- Type-safe event tracking
+- Automatic pageview tracking
+- Browser environment detection
+- Graceful error handling
+- Comprehensive JSDoc documentation
+
+**Usage:**
+```typescript
+import { UmamiAnalyticsService } from '@/lib/services/analytics/umami-analytics-service';
+
+const service = new UmamiAnalyticsService({ enabled: true });
+service.track('button_click', { button_id: 'cta' });
+service.trackPageview('/products/123');
+```
+
+### 3. NoopAnalyticsService (`noop-analytics-service.ts`)
+
+A no-op implementation used as a fallback when analytics are disabled.
+
+**Features:**
+- Maintains the same API as other services
+- Safe to call even when analytics are disabled
+- No performance impact
+- Comprehensive JSDoc documentation
+
+**Usage:**
+```typescript
+import { NoopAnalyticsService } from '@/lib/services/analytics/noop-analytics-service';
+
+const service = new NoopAnalyticsService();
+service.track('button_click', { button_id: 'cta' }); // Does nothing
+service.trackPageview('/products/123'); // Does nothing
+```
+
+## Service Selection
+
+The service layer automatically selects the appropriate implementation based on environment variables:
+
+```typescript
+// In lib/services/create-services.ts
+const umamiEnabled = Boolean(process.env.NEXT_PUBLIC_UMAMI_WEBSITE_ID);
+
+const analytics = umamiEnabled
+  ? new UmamiAnalyticsService({ enabled: true })
+  : new NoopAnalyticsService();
+```
+
+## Environment Variables
+
+### Required for Umami
+
+```bash
+NEXT_PUBLIC_UMAMI_WEBSITE_ID=59a7db94-0100-4c7e-98ef-99f45b17f9c3
+```
+
+### Optional (defaults provided)
+
+```bash
+NEXT_PUBLIC_UMAMI_SCRIPT_URL=https://analytics.infra.mintel.me/script.js
+```
+
+## API Reference
+
+### AnalyticsService Interface
+
+#### `track(eventName: string, props?: AnalyticsEventProperties): void`
+
+Track a custom event with optional properties.
+
+**Parameters:**
+- `eventName` - The name of the event to track
+- `props` - Optional event properties (metadata)
+
+**Example:**
+```typescript
+service.track('product_add_to_cart', {
+  product_id: '123',
+  product_name: 'Cable',
+  price: 99.99,
+  quantity: 1,
+});
+```
+
+#### `trackPageview(url?: string): void`
+
+Track a pageview.
+
+**Parameters:**
+- `url` - The URL to track (defaults to current location)
+
+**Example:**
+```typescript
+// Track current page
+service.trackPageview();
+
+// Track custom URL
+service.trackPageview('/products/123?category=cables');
+```
+
+### UmamiAnalyticsService
+
+#### Constructor
+
+```typescript
+new UmamiAnalyticsService(options: UmamiAnalyticsServiceOptions)
+```
+
+**Options:**
+- `enabled: boolean` - Whether analytics are enabled
+
+**Example:**
+```typescript
+const service = new UmamiAnalyticsService({ enabled: true });
+```
+
+### NoopAnalyticsService
+
+#### Constructor
+
+```typescript
+new NoopAnalyticsService()
+```
+
+**Example:**
+```typescript
+const service = new NoopAnalyticsService();
+```
+
+## Type Definitions
+
+### AnalyticsEventProperties
+
+```typescript
+type AnalyticsEventProperties = Record<
+  string,
+  string | number | boolean | null | undefined
+>;
+```
+
+**Example:**
+```typescript
+const properties: AnalyticsEventProperties = {
+  product_id: '123',
+  product_name: 'Cable',
+  price: 99.99,
+  quantity: 1,
+  in_stock: true,
+  discount: null,
+};
+```
+
+### UmamiAnalyticsServiceOptions
+
+```typescript
+type UmamiAnalyticsServiceOptions = {
+  enabled: boolean;
+};
+```
+
+## Best Practices
+
+### 1. Use the Service Layer
+
+Always use the service layer instead of calling Umami directly:
+
+```typescript
+// ✅ Good
+import { getAppServices } from '@/lib/services/create-services';
+
+const services = getAppServices();
+services.analytics.track('button_click', { button_id: 'cta' });
+
+// ❌ Avoid
+(window as any).umami?.track('button_click', { button_id: 'cta' });
+```
+
+### 2. Check Environment
+
+The service layer automatically handles environment detection:
+
+```typescript
+// ✅ Safe - works in both server and client
+const services = getAppServices();
+services.analytics.track('event', { prop: 'value' });
+
+// ❌ Unsafe - may fail in server environment
+if (typeof window !== 'undefined') {
+  window.umami?.track('event', { prop: 'value' });
+}
+```
+
+### 3. Use Type-Safe Events
+
+Import events from the centralized definitions:
+
+```typescript
+import { AnalyticsEvents } from '@/components/analytics/analytics-events';
+
+// ✅ Type-safe
+services.analytics.track(AnalyticsEvents.BUTTON_CLICK, {
+  button_id: 'cta',
+});
+
+// ❌ Prone to typos
+services.analytics.track('button_click', {
+  button_id: 'cta',
+});
+```
+
+### 4. Handle Disabled Analytics
+
+The service layer gracefully handles disabled analytics:
+
+```typescript
+// When NEXT_PUBLIC_UMAMI_WEBSITE_ID is not set:
+// - NoopAnalyticsService is used
+// - All calls are safe (no-op)
+// - No errors are thrown
+
+const services = getAppServices();
+services.analytics.track('event', { prop: 'value' }); // Safe, does nothing
+```
+
+## Testing
+
+### Mocking for Tests
+
+```typescript
+// __tests__/analytics-mock.ts
+export const mockAnalytics = {
+  track: jest.fn(),
+  trackPageview: jest.fn(),
+};
+
+jest.mock('@/lib/services/create-services', () => ({
+  getAppServices: () => ({
+    analytics: mockAnalytics,
+  }),
+}));
+
+// Usage in tests
+import { mockAnalytics } from './analytics-mock';
+
+test('tracks button click', () => {
+  // ... test code ...
+  expect(mockAnalytics.track).toHaveBeenCalledWith('button_click', {
+    button_id: 'cta',
+  });
+});
+```
+
+### Development Mode
+
+In development, the service layer logs to console:
+
+```bash
+# Console output:
+[Umami] Tracked event: button_click { button_id: 'cta' }
+[Umami] Tracked pageview: /products/123
+```
+
+## Error Handling
+
+The service layer includes built-in error handling:
+
+1. **Environment Detection** - Checks for browser environment
+2. **Service Availability** - Checks if Umami is loaded
+3. **Graceful Degradation** - Falls back to NoopAnalyticsService if needed
+
+```typescript
+// These are all safe:
+const services = getAppServices();
+services.analytics.track('event', { prop: 'value' }); // Works or does nothing
+services.analytics.trackPageview('/path'); // Works or does nothing
+```
+
+## Performance
+
+### Singleton Pattern
+
+The service layer uses a singleton pattern for performance:
+
+```typescript
+// First call creates the singleton
+const services1 = getAppServices();
+
+// Subsequent calls return the cached singleton
+const services2 = getAppServices();
+
+// services1 === services2 (same instance)
+```
+
+### Lazy Initialization
+
+Services are only created when first accessed:
+
+```typescript
+// Services are not created until getAppServices() is called
+// This keeps initial bundle size minimal
+```
+
+## Integration with Components
+
+### Client Components
+
+```typescript
+'use client';
+
+import { getAppServices } from '@/lib/services/create-services';
+
+function MyComponent() {
+  const handleClick = () => {
+    const services = getAppServices();
+    services.analytics.track('button_click', { button_id: 'my-button' });
+  };
+
+  return <button onClick={handleClick}>Click Me</button>;
+}
+```
+
+### Server Components
+
+```typescript
+import { getAppServices } from '@/lib/services/create-services';
+
+async function MyServerComponent() {
+  const services = getAppServices();
+  
+  // Note: Analytics won't work in server components
+  // Use client components for analytics tracking
+  // But you can still access other services like cache
+  
+  const data = await services.cache.get('key');
+  
+  return <div>{data}</div>;
+}
+```
+
+## Troubleshooting
+
+### Analytics Not Working
+
+1. **Check environment variables:**
+   ```bash
+   echo $NEXT_PUBLIC_UMAMI_WEBSITE_ID
+   ```
+
+2. **Verify service selection:**
+   ```typescript
+   import { getAppServices } from '@/lib/services/create-services';
+   
+   const services = getAppServices();
+   console.log(services.analytics); // Should be UmamiAnalyticsService
+   ```
+
+3. **Check Umami dashboard:**
+   - Log into Umami
+   - Verify website ID matches
+   - Check if data is being received
+
+### Common Issues
+
+| Issue | Solution |
+|-------|----------|
+| No data in Umami | Check website ID and script URL |
+| Events not tracking | Verify service is being used |
+| Script not loading | Check network connection, CORS |
+| Wrong data | Verify event properties are correct |
+
+## Related Files
+
+- [`components/analytics/useAnalytics.ts`](../components/analytics/useAnalytics.ts) - Custom hook for easy event tracking
+- [`components/analytics/analytics-events.ts`](../components/analytics/analytics-events.ts) - Event definitions
+- [`components/analytics/UmamiScript.tsx`](../components/analytics/UmamiScript.tsx) - Script loader component
+- [`components/analytics/AnalyticsProvider.tsx`](../components/analytics/AnalyticsProvider.tsx) - Route change tracker
+- [`lib/services/create-services.ts`](../lib/services/create-services.ts) - Service factory
+
+## Summary
+
+The analytics service layer provides:
+
+- ✅ **Type-safe API** - TypeScript throughout
+- ✅ **Clean abstraction** - Easy to switch analytics providers
+- ✅ **Graceful degradation** - Safe no-op fallback
+- ✅ **Comprehensive documentation** - JSDoc comments and examples
+- ✅ **Performance optimized** - Singleton pattern, lazy initialization
+- ✅ **Error handling** - Safe in all environments
+
+This layer is the foundation for all analytics tracking in the application.
--- a/lib/services/analytics/analytics-service.ts
+++ b/lib/services/analytics/analytics-service.ts
@@ -1,10 +1,77 @@
+/**
+ * Type definition for analytics event properties.
+ *
+ * @example
+ * ```typescript
+ * const properties: AnalyticsEventProperties = {
+ *   product_id: '123',
+ *   product_name: 'Cable',
+ *   price: 99.99,
+ *   quantity: 1,
+ *   in_stock: true,
+ * };
+ * ```
+ */
 export type AnalyticsEventProperties = Record<
  string,
  string | number | boolean | null | undefined
 >;

+/**
+ * Interface for analytics service implementations.
+ *
+ * This interface defines the contract for all analytics services,
+ * allowing for different implementations (Umami, Google Analytics, etc.)
+ * while maintaining a consistent API.
+ *
+ * @example
+ * ```typescript
+ * // Using the service directly
+ * const service = new UmamiAnalyticsService({ enabled: true });
+ * service.track('button_click', { button_id: 'cta' });
+ * service.trackPageview('/products/123');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using the useAnalytics hook (recommended)
+ * const { trackEvent, trackPageview } = useAnalytics();
+ * trackEvent('button_click', { button_id: 'cta' });
+ * trackPageview('/products/123');
+ * ```
+ */
 export interface AnalyticsService {
+  /**
+   * Track a custom event with optional properties.
+   *
+   * @param eventName - The name of the event to track
+   * @param props - Optional event properties (metadata)
+   *
+   * @example
+   * ```typescript
+   * track('product_add_to_cart', {
+   *   product_id: '123',
+   *   product_name: 'Cable',
+   *   price: 99.99,
+   * });
+   * ```
+   */
  track(eventName: string, props?: AnalyticsEventProperties): void;
+
+  /**
+   * Track a pageview.
+   *
+   * @param url - The URL to track (defaults to current location)
+   *
+   * @example
+   * ```typescript
+   * // Track current page
+   * trackPageview();
+   *
+   * // Track custom URL
+   * trackPageview('/products/123?category=cables');
+   * ```
+   */
  trackPageview(url?: string): void;
 }

--- a/lib/services/analytics/noop-analytics-service.ts
+++ b/lib/services/analytics/noop-analytics-service.ts
@@ -1,11 +1,67 @@
 import type { AnalyticsEventProperties, AnalyticsService } from './analytics-service';

+/**
+ * No-op Analytics Service Implementation.
+ *
+ * This service implements the AnalyticsService interface but does nothing.
+ * It's used as a fallback when analytics are disabled or not configured.
+ *
+ * @example
+ * ```typescript
+ * // Service creation (usually done by create-services.ts)
+ * const service = new NoopAnalyticsService();
+ *
+ * // These calls do nothing but are safe to execute
+ * service.track('button_click', { button_id: 'cta' });
+ * service.trackPageview('/products/123');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Automatic fallback in create-services.ts
+ * const umamiEnabled = Boolean(process.env.NEXT_PUBLIC_UMAMI_WEBSITE_ID);
+ * const analytics = umamiEnabled
+ *   ? new UmamiAnalyticsService({ enabled: true })
+ *   : new NoopAnalyticsService(); // Fallback when no website ID
+ * ```
+ */
 export class NoopAnalyticsService implements AnalyticsService {
+  /**
+   * No-op implementation of track.
+   *
+   * This method does nothing but maintains the same signature as other
+   * analytics services for consistency.
+   *
+   * @param _eventName - Event name (ignored)
+   * @param _props - Event properties (ignored)
+   *
+   * @example
+   * ```typescript
+   * // Safe to call even when analytics are disabled
+   * service.track('button_click', { button_id: 'cta' });
+   * // No error, no action taken
+   * ```
+   */
  track(_eventName: string, _props?: AnalyticsEventProperties) {
-    // intentionally noop
+    // intentionally noop - analytics are disabled
  }

+  /**
+   * No-op implementation of trackPageview.
+   *
+   * This method does nothing but maintains the same signature as other
+   * analytics services for consistency.
+   *
+   * @param _url - URL to track (ignored)
+   *
+   * @example
+   * ```typescript
+   * // Safe to call even when analytics are disabled
+   * service.trackPageview('/products/123');
+   * // No error, no action taken
+   * ```
+   */
  trackPageview(_url?: string) {
-    // intentionally noop
+    // intentionally noop - analytics are disabled
  }
 }
--- a/lib/services/analytics/umami-analytics-service.ts
+++ b/lib/services/analytics/umami-analytics-service.ts
@@ -1,16 +1,74 @@
 import type { AnalyticsEventProperties, AnalyticsService } from './analytics-service';

+/**
+ * Type definition for the Umami global object.
+ *
+ * This represents the `window.umami` object that the Umami script exposes.
+ * The `track` function can accept either an event name or a URL.
+ */
 type UmamiGlobal = {
  track?: (eventOrUrl: string, props?: AnalyticsEventProperties) => void;
 };

+/**
+ * Configuration options for UmamiAnalyticsService.
+ *
+ * @property enabled - Whether analytics are enabled
+ */
 export type UmamiAnalyticsServiceOptions = {
  enabled: boolean;
 };

+/**
+ * Umami Analytics Service Implementation.
+ *
+ * This service implements the AnalyticsService interface for Umami analytics.
+ * It provides type-safe event tracking and pageview tracking.
+ *
+ * @example
+ * ```typescript
+ * // Service creation (usually done by create-services.ts)
+ * const service = new UmamiAnalyticsService({ enabled: true });
+ *
+ * // Track events
+ * service.track('button_click', { button_id: 'cta' });
+ * service.trackPageview('/products/123');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Using through the service layer (recommended)
+ * import { getAppServices } from '@/lib/services/create-services';
+ *
+ * const services = getAppServices();
+ * services.analytics.track('product_add_to_cart', {
+ *   product_id: '123',
+ *   price: 99.99,
+ * });
+ * ```
+ */
 export class UmamiAnalyticsService implements AnalyticsService {
  constructor(private readonly options: UmamiAnalyticsServiceOptions) {}

+  /**
+   * Track a custom event with optional properties.
+   *
+   * This method checks if analytics are enabled and if we're in a browser environment
+   * before attempting to track the event.
+   *
+   * @param eventName - The name of the event to track
+   * @param props - Optional event properties
+   *
+   * @example
+   * ```typescript
+   * service.track('product_add_to_cart', {
+   *   product_id: '123',
+   *   product_name: 'Cable',
+   *   price: 99.99,
+   *   quantity: 1,
+   * });
+   * ```
+   */
  track(eventName: string, props?: AnalyticsEventProperties) {
    if (!this.options.enabled) return;
    if (typeof window === 'undefined') return;
@@ -19,6 +77,26 @@ export class UmamiAnalyticsService implements AnalyticsService {
    umami?.track?.(eventName, props);
  }

+  /**
+   * Track a pageview.
+   *
+   * This method checks if analytics are enabled and if we're in a browser environment
+   * before attempting to track the pageview.
+   *
+   * Umami treats `track(url)` as a pageview override, so we can use the same
+   * `track` function for both events and pageviews.
+   *
+   * @param url - The URL to track (defaults to current location)
+   *
+   * @example
+   * ```typescript
+   * // Track current page
+   * service.trackPageview();
+   *
+   * // Track custom URL
+   * service.trackPageview('/products/123?category=cables');
+   * ```
+   */
  trackPageview(url?: string) {
    if (!this.options.enabled) return;
    if (typeof window === 'undefined') return;
--- a/lib/services/create-services.ts
+++ b/lib/services/create-services.ts
@@ -5,22 +5,80 @@ import { MemoryCacheService } from './cache/memory-cache-service';
 import { GlitchtipErrorReportingService } from './errors/glitchtip-error-reporting-service';
 import { NoopErrorReportingService } from './errors/noop-error-reporting-service';

+/**
+ * Singleton instance of AppServices.
+ *
+ * In Next.js, module singletons are per-process (server) and per-tab (client).
+ * This is sufficient for a small service layer and provides better performance
+ * than creating new instances on every request.
+ *
+ * @private
+ */
 let singleton: AppServices | undefined;

+/**
+ * Get the application services singleton.
+ *
+ * This function creates and caches the application services, including:
+ * - Analytics service (Umami or no-op)
+ * - Error reporting service (GlitchTip/Sentry or no-op)
+ * - Cache service (in-memory)
+ *
+ * The services are configured based on environment variables:
+ * - `NEXT_PUBLIC_UMAMI_WEBSITE_ID` - Enables Umami analytics
+ * - `NEXT_PUBLIC_SENTRY_DSN` - Enables client-side error reporting
+ * - `SENTRY_DSN` - Enables server-side error reporting
+ *
+ * @returns {AppServices} The application services singleton
+ *
+ * @example
+ * ```typescript
+ * // Get services in a client component
+ * import { getAppServices } from '@/lib/services/create-services';
+ *
+ * const services = getAppServices();
+ * services.analytics.track('button_click', { button_id: 'cta' });
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Get services in a server component or API route
+ * import { getAppServices } from '@/lib/services/create-services';
+ *
+ * const services = getAppServices();
+ * await services.cache.set('key', 'value');
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Automatic service selection based on environment
+ * // If NEXT_PUBLIC_UMAMI_WEBSITE_ID is set:
+ * //   services.analytics = UmamiAnalyticsService
+ * // If not set:
+ * //   services.analytics = NoopAnalyticsService (safe no-op)
+ * ```
+ *
+ * @see {@link UmamiAnalyticsService} for analytics implementation
+ * @see {@link NoopAnalyticsService} for no-op fallback
+ * @see {@link GlitchtipErrorReportingService} for error reporting
+ * @see {@link MemoryCacheService} for caching
+ */
 export function getAppServices(): AppServices {
-  // In Next.js, module singletons are per-process (server) and per-tab (client).
-  // This is good enough for a small service layer.
+  // Return cached instance if available
  if (singleton) return singleton;

+  // Determine which services to enable based on environment variables
  const umamiEnabled = Boolean(process.env.NEXT_PUBLIC_UMAMI_WEBSITE_ID);
  const sentryClientEnabled = Boolean(process.env.NEXT_PUBLIC_SENTRY_DSN);
  const sentryServerEnabled = Boolean(process.env.SENTRY_DSN);

+  // Create analytics service (Umami or no-op)
  const analytics = umamiEnabled
    ? new UmamiAnalyticsService({ enabled: true })
    : new NoopAnalyticsService();

-  // Enable GlitchTip/Sentry only when a DSN is present for the active runtime.
+  // Create error reporting service (GlitchTip/Sentry or no-op)
+  // Server-side and client-side have separate DSNs
  const errors =
    typeof window === 'undefined'
      ? sentryServerEnabled
@@ -35,6 +93,7 @@ export function getAppServices(): AppServices {
  // Use [`getServerAppServices()`](lib/services/create-services.server.ts:1) on the server.
  const cache = new MemoryCacheService();

+  // Create and cache the singleton
  singleton = new AppServices(analytics, errors, cache);
  return singleton;
 }