autotel-subscribers 40.0.0 → 41.0.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autotel-subscribers",
-  "version": "40.0.0",
+  "version": "41.0.0",
   "description": "Write Once, Observe Anywhere - Event subscribers for autotel (PostHog, Mixpanel, Amplitude, Segment)",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -75,7 +75,6 @@
   },
   "files": [
     "dist",
-    "src",
     "examples",
     "README.md",
     "skills"
@@ -101,7 +100,7 @@
     "slow-redact": "^0.3.2"
   },
   "peerDependencies": {
-    "autotel": "4.1.0"
+    "autotel": "4.2.0"
   },
   "peerDependenciesMeta": {
     "posthog-node": {
@@ -138,7 +137,7 @@
     "typescript": "^6.0.3",
     "typescript-eslint": "^8.60.1",
     "vitest": "^4.1.8",
-    "autotel": "4.1.0"
+    "autotel": "4.2.0"
   },
   "repository": {
     "type": "git",

package/src/amplitude.test.ts

@@ -1,229 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { AmplitudeSubscriber } from './amplitude';
-
-// Hoist mocks so they exist when vi.mock factory runs (factory is hoisted before other code)
-const mockTrack = vi.hoisted(() => vi.fn());
-const mockInit = vi.hoisted(() => vi.fn());
-const mockFlush = vi.hoisted(() => vi.fn(() => Promise.resolve()));
-
-vi.mock('@amplitude/analytics-node', () => ({
-  init: mockInit,
-  track: mockTrack,
-  flush: mockFlush,
-}));
-
-// Prime the mocked module so the first dynamic import in AmplitudeSubscriber gets the mock (avoids CI race)
-import '@amplitude/analytics-node';
-
-describe('AmplitudeSubscriber', () => {
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockTrack.mockClear();
-    mockInit.mockClear();
-    mockFlush.mockClear();
-  });
-
-  describe('initialization', () => {
-    it('should initialize with valid config', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(adapter).toBeDefined();
-    });
-
-    it('should not initialize when disabled', () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-        enabled: false,
-      });
-
-      expect(adapter).toBeDefined();
-    });
-  });
-
-  describe('trackEvent', () => {
-    it('should track event with attributes', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      await adapter.trackEvent('order.completed', {
-        userId: 'user-123',
-        amount: 99.99,
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(mockTrack).toHaveBeenCalledWith({
-        event_type: 'order.completed',
-        user_id: 'user-123',
-        event_properties: {
-          userId: 'user-123',
-          amount: 99.99,
-        },
-      });
-    });
-
-    it('should use user_id if userId is not present', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      await adapter.trackEvent('order.completed', {
-        user_id: 'user-456',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(mockTrack).toHaveBeenCalledWith({
-        event_type: 'order.completed',
-        user_id: 'user-456',
-        event_properties: {
-          user_id: 'user-456',
-        },
-      });
-    });
-
-    it('should use anonymous if no userId is present', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      await adapter.trackEvent('page.viewed');
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(mockTrack).toHaveBeenCalledWith({
-        event_type: 'page.viewed',
-        user_id: 'anonymous',
-        event_properties: undefined,
-      });
-    });
-
-    it('should not track when disabled', () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-        enabled: false,
-      });
-
-      adapter.trackEvent('order.completed', { userId: 'user-123' });
-
-      // Should not throw
-      expect(true).toBe(true);
-    });
-  });
-
-  describe('trackFunnelStep', () => {
-    it('should track funnel step', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      await adapter.trackFunnelStep('checkout', 'started', {
-        userId: 'user-123',
-        cartValue: 150,
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(mockTrack).toHaveBeenCalledWith({
-        event_type: 'checkout.started',
-        user_id: 'user-123',
-        event_properties: {
-          funnel: 'checkout',
-          step: 'started',
-          userId: 'user-123',
-          cartValue: 150,
-        },
-      });
-    });
-  });
-
-  describe('trackOutcome', () => {
-    it('should track outcome', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      await adapter.trackOutcome('payment.processing', 'success', {
-        userId: 'user-123',
-        transactionId: 'txn-789',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(mockTrack).toHaveBeenCalledWith({
-        event_type: 'payment.processing.success',
-        user_id: 'user-123',
-        event_properties: {
-          operation: 'payment.processing',
-          outcome: 'success',
-          userId: 'user-123',
-          transactionId: 'txn-789',
-        },
-      });
-    });
-  });
-
-  describe('trackValue', () => {
-    it('should track value', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      await adapter.trackValue('revenue', 99.99, {
-        userId: 'user-123',
-        currency: 'USD',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-
-      expect(mockTrack).toHaveBeenCalledWith({
-        event_type: 'revenue',
-        user_id: 'user-123',
-        event_properties: {
-          value: 99.99,
-          userId: 'user-123',
-          currency: 'USD',
-        },
-      });
-    });
-  });
-
-  describe('shutdown', () => {
-    it('should call flush on Amplitude instance', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-      });
-
-      await new Promise((resolve) => setTimeout(resolve, 100));
-      await adapter.shutdown();
-
-      expect(mockFlush).toHaveBeenCalled();
-    });
-
-    it('should not throw when shutting down disabled adapter', async () => {
-      const adapter = new AmplitudeSubscriber({
-        apiKey: 'test_api_key',
-        enabled: false,
-      });
-
-      await expect(adapter.shutdown()).resolves.not.toThrow();
-    });
-  });
-});

package/src/amplitude.ts

@@ -1,150 +0,0 @@
-/**
- * Amplitude Subscriber for autotel
- *
- * Send events to Amplitude for product events.
- *
- * @example
- * ```typescript
- * import { Events } from 'autotel/events';
- * import { AmplitudeSubscriber } from 'autotel-subscribers/amplitude';
- *
- * const events = new Events('checkout', {
- *   subscribers: [
- *     new AmplitudeSubscriber({
- *       apiKey: process.env.AMPLITUDE_API_KEY!
- *     })
- *   ]
- * });
- *
- * events.trackEvent('order.completed', { userId: '123', amount: 99.99 });
- * ```
- */
-
-import type {
-  EventSubscriber,
-  EventAttributes,
-  FunnelStatus,
-  OutcomeStatus,
-} from 'autotel/event-subscriber';
-
-export interface AmplitudeConfig {
-  /** Amplitude API key */
-  apiKey: string;
-  /** Enable/disable the subscriber */
-  enabled?: boolean;
-}
-
-export class AmplitudeSubscriber implements EventSubscriber {
-  readonly name = 'AmplitudeSubscriber';
-  readonly version = '1.0.0';
-
-  private amplitudeModule: any = null;
-  private enabled: boolean;
-  private config: AmplitudeConfig;
-  private initPromise: Promise<void> | null = null;
-
-  constructor(config: AmplitudeConfig) {
-    this.enabled = config.enabled ?? true;
-    this.config = config;
-
-    if (this.enabled) {
-      // Start initialization immediately but don't block constructor
-      this.initPromise = this.initialize();
-    }
-  }
-
-  private async initialize(): Promise<void> {
-    try {
-      // Dynamic import to avoid adding @amplitude/analytics-node as a hard dependency
-      // The SDK exports init(), track(), flush() as separate functions
-      const amplitude = await import('@amplitude/analytics-node');
-      amplitude.init(this.config.apiKey);
-      this.amplitudeModule = amplitude;
-    } catch (error) {
-      console.error(
-        'Amplitude subscriber failed to initialize. Install @amplitude/analytics-node: pnpm add @amplitude/analytics-node',
-        error,
-      );
-      this.enabled = false;
-    }
-  }
-
-  private async ensureInitialized(): Promise<void> {
-    if (this.initPromise) {
-      await this.initPromise;
-      this.initPromise = null;
-    }
-  }
-
-  async trackEvent(name: string, attributes?: EventAttributes): Promise<void> {
-    if (!this.enabled) return;
-
-    await this.ensureInitialized();
-    this.amplitudeModule?.track({
-      event_type: name,
-      user_id: attributes?.userId || attributes?.user_id || 'anonymous',
-      event_properties: attributes,
-    });
-  }
-
-  async trackFunnelStep(
-    funnelName: string,
-    step: FunnelStatus,
-    attributes?: EventAttributes,
-  ): Promise<void> {
-    if (!this.enabled) return;
-
-    await this.ensureInitialized();
-    this.amplitudeModule?.track({
-      event_type: `${funnelName}.${step}`,
-      user_id: attributes?.userId || attributes?.user_id || 'anonymous',
-      event_properties: {
-        funnel: funnelName,
-        step,
-        ...attributes,
-      },
-    });
-  }
-
-  async trackOutcome(
-    operationName: string,
-    outcome: OutcomeStatus,
-    attributes?: EventAttributes,
-  ): Promise<void> {
-    if (!this.enabled) return;
-
-    await this.ensureInitialized();
-    this.amplitudeModule?.track({
-      event_type: `${operationName}.${outcome}`,
-      user_id: attributes?.userId || attributes?.user_id || 'anonymous',
-      event_properties: {
-        operation: operationName,
-        outcome,
-        ...attributes,
-      },
-    });
-  }
-
-  async trackValue(name: string, value: number, attributes?: EventAttributes): Promise<void> {
-    if (!this.enabled) return;
-
-    await this.ensureInitialized();
-    this.amplitudeModule?.track({
-      event_type: name,
-      user_id: attributes?.userId || attributes?.user_id || 'anonymous',
-      event_properties: {
-        value,
-        ...attributes,
-      },
-    });
-  }
-
-  /** Flush pending events before shutdown */
-  async shutdown(): Promise<void> {
-    await this.ensureInitialized();
-    if (this.amplitudeModule) {
-      await this.amplitudeModule.flush();
-    }
-  }
-}
-

package/src/architecture-snapshot.test.ts

@@ -1,220 +0,0 @@
-import { mkdtemp, readFile, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import path from 'node:path';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import {
-  ArchitectureSnapshotSubscriber,
-  extractFieldPaths,
-  ARCHITECTURE_SNAPSHOT_SPEC,
-} from './architecture-snapshot';
-import type { EventPayload } from './event-subscriber-base';
-
-const FIXED_NOW = () => new Date('2026-05-21T18:04:00.000Z');
-
-function event(
-  name: string,
-  attributes: Record<string, unknown> = {},
-  options: { traceId?: string; at?: string } = {},
-): EventPayload {
-  return {
-    type: 'event',
-    name,
-    attributes,
-    timestamp: options.at ?? '2026-05-21T18:00:00.000Z',
-    autotel: options.traceId
-      ? { trace_id: options.traceId, correlation_id: 'corr-1' }
-      : undefined,
-  };
-}
-
-describe('extractFieldPaths', () => {
-  it('collapses array items under `[]`', () => {
-    expect(
-      extractFieldPaths({
-        items: [{ sku: 'a', quantity: 1 }, { sku: 'b' }],
-      }),
-    ).toEqual(['items', 'items[].quantity', 'items[].sku']);
-  });
-
-  it('returns empty for primitives at the root', () => {
-    expect(extractFieldPaths('x')).toEqual([]);
-    expect(extractFieldPaths(42)).toEqual([]);
-    expect(extractFieldPaths(null)).toEqual([]);
-    // eslint-disable-next-line unicorn/no-useless-undefined
-    expect(extractFieldPaths(undefined)).toEqual([]);
-  });
-
-  it('handles nested objects', () => {
-    expect(
-      extractFieldPaths({ a: { b: { c: 1 } } }),
-    ).toEqual(['a', 'a.b', 'a.b.c']);
-  });
-});
-
-describe('ArchitectureSnapshotSubscriber', () => {
-  let sub: ArchitectureSnapshotSubscriber;
-
-  beforeEach(() => {
-    sub = new ArchitectureSnapshotSubscriber({ service: 'orders' });
-  });
-
-  it('records a new event on first observation', async () => {
-    await sub.trackEvent('order.placed', {
-      orderId: 'o-1',
-      items: [{ sku: 'sku-1', quantity: 2 }],
-    });
-
-    const snap = sub.toSnapshot({ now: FIXED_NOW });
-    expect(snap.spec).toBe(ARCHITECTURE_SNAPSHOT_SPEC);
-    expect(snap.service).toBe('orders');
-    expect(snap.events['order.placed']).toMatchObject({
-      name: 'order.placed',
-      observedCount: 1,
-      fieldPaths: ['items', 'items[].quantity', 'items[].sku', 'orderId'],
-      fieldStats: {
-        orderId: { types: ['string'], sampleValues: ['o-1'] },
-        items: { types: ['array'], sampleValues: [] },
-        'items[].sku': { types: ['string'], sampleValues: ['sku-1'] },
-        'items[].quantity': { types: ['number'], sampleValues: [2] },
-      },
-    });
-  });
-
-  it('accumulates count, lastSeen, and merges field paths across calls', async () => {
-    await sub.trackEvent('order.placed', { orderId: 'o-1' });
-    // Second call adds a new field path.
-    await sub.trackEvent('order.placed', {
-      orderId: 'o-2',
-      shipping: { addressId: 'addr_1' },
-    });
-
-    const obs = sub.toSnapshot({ now: FIXED_NOW }).events['order.placed'];
-    expect(obs.observedCount).toBe(2);
-    expect(obs.fieldPaths).toEqual([
-      'orderId',
-      'shipping',
-      'shipping.addressId',
-    ]);
-  });
-
-  it('reads channel and producer from the _autotel namespace', async () => {
-    await sub.trackEvent('order.placed', {
-      orderId: 'o-1',
-      _autotel: {
-        channel: 'orders.events',
-        producer: 'OrdersService',
-        consumers: ['PaymentService'],
-      },
-    });
-
-    const obs = sub.toSnapshot({ now: FIXED_NOW }).events['order.placed'];
-    expect(obs.channel).toBe('orders.events');
-    expect(obs.producer).toBe('OrdersService');
-    expect(obs.consumers).toEqual(['PaymentService']);
-    // _autotel must not leak into the captured field paths.
-    expect(obs.fieldPaths).toEqual(['orderId']);
-  });
-
-  it('captures schema metadata passed at track() call sites', async () => {
-    await sub.trackEvent(
-      'order.placed',
-      { orderId: 'o-1' },
-      {
-        schema: {
-          source: 'zod',
-          jsonSchema: {
-            type: 'object',
-            properties: { orderId: { type: 'string' } },
-            required: ['orderId'],
-          },
-          hash: 'abc123',
-        },
-      },
-    );
-
-    const obs = sub.toSnapshot({ now: FIXED_NOW }).events['order.placed'];
-    expect(obs.schema).toEqual({
-      source: 'zod',
-      jsonSchema: {
-        type: 'object',
-        properties: { orderId: { type: 'string' } },
-        required: ['orderId'],
-      },
-      hash: 'abc123',
-    });
-  });
-
-  it('collects up to maxSampleTraceIds distinct trace ids', async () => {
-    const limited = new ArchitectureSnapshotSubscriber({
-      service: 'orders',
-      maxSampleTraceIds: 2,
-    });
-    for (const id of ['t-1', 't-2', 't-3', 't-1']) {
-      await (limited as unknown as { sendToDestination(p: EventPayload): Promise<void> })
-        .sendToDestination(event('order.placed', {}, { traceId: id }));
-    }
-    const obs = limited.toSnapshot({ now: FIXED_NOW }).events['order.placed'];
-    expect(obs.sampleTraceIds).toEqual(['t-1', 't-2']);
-  });
-
-  it('ignores non-event payload types', async () => {
-    await sub.trackEvent('order.placed', { orderId: 'o-1' });
-    await sub.trackOutcome('checkout', 'success');
-    await sub.trackValue('revenue', 99);
-
-    const snap = sub.toSnapshot({ now: FIXED_NOW });
-    expect(Object.keys(snap.events)).toEqual(['order.placed']);
-  });
-
-  it('produces deterministic output for identical inputs', async () => {
-    // Freeze the clock so the firstSeen/lastSeen timestamps assigned to
-    // subscriber `b`'s events match subscriber `a`'s exactly. Without this
-    // the two subscribers can land in different ms ticks and the byte-for-
-    // byte JSON comparison flakes in CI.
-    vi.useFakeTimers();
-    vi.setSystemTime(new Date('2026-05-21T18:00:00.000Z'));
-    try {
-      const a = new ArchitectureSnapshotSubscriber({ service: 'orders' });
-      const b = new ArchitectureSnapshotSubscriber({ service: 'orders' });
-      const payload = { orderId: 'o-1', items: [{ sku: 'a' }, { sku: 'b' }] };
-
-      await a.trackEvent('order.placed', payload);
-      await a.trackEvent('payment.captured', { orderId: 'o-1' });
-      // Same events, reversed order.
-      await b.trackEvent('payment.captured', { orderId: 'o-1' });
-      await b.trackEvent('order.placed', payload);
-
-      const at = () => new Date('2026-05-21T18:04:00.000Z');
-      expect(JSON.stringify(a.toSnapshot({ now: at }))).toBe(
-        JSON.stringify(b.toSnapshot({ now: at })),
-      );
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it('writeToFile creates parent dirs and writes JSON with trailing newline', async () => {
-    const dir = await mkdtemp(path.join(tmpdir(), 'autotel-arch-snap-'));
-    try {
-      const target = path.join(dir, 'nested', 'snap.json');
-      const fresh = new ArchitectureSnapshotSubscriber({ service: 'orders' });
-      await fresh.trackEvent('order.placed', { orderId: 'o-1' });
-      await fresh.writeToFile(target, { now: FIXED_NOW });
-
-      const body = await readFile(target, 'utf8');
-      expect(body.endsWith('\n')).toBe(true);
-      expect(JSON.parse(body)).toMatchObject({
-        spec: ARCHITECTURE_SNAPSHOT_SPEC,
-        service: 'orders',
-      });
-    } finally {
-      await rm(dir, { recursive: true, force: true });
-    }
-  });
-
-  it('reset() clears all accumulated observations', async () => {
-    await sub.trackEvent('order.placed', { orderId: 'o-1' });
-    sub.reset();
-    expect(sub.toSnapshot({ now: FIXED_NOW }).events).toEqual({});
-  });
-});