@auto-engineer/pipeline 0.0.1

package/src/testing/snapshot-sanitize.specs.ts

@@ -0,0 +1,131 @@
+import type { Event } from '@auto-engineer/message-bus';
+import { describe, expect, it } from 'vitest';
+import { type SanitizedEvent, sanitizeEvent, sanitizeEvents } from './snapshot-sanitize';
+
+describe('snapshot-sanitize', () => {
+  describe('sanitizeEvent', () => {
+    it('should preserve type and data', () => {
+      const event: Event = {
+        type: 'TestEvent',
+        data: { foo: 'bar', count: 42 },
+      };
+
+      const sanitized = sanitizeEvent(event);
+
+      expect(sanitized.type).toBe('TestEvent');
+      expect(sanitized.data).toEqual({ foo: 'bar', count: 42 });
+    });
+
+    it('should strip timestamp', () => {
+      const event: Event = {
+        type: 'TestEvent',
+        data: {},
+        timestamp: new Date('2025-01-01T00:00:00.000Z'),
+      };
+
+      const sanitized = sanitizeEvent(event);
+
+      expect(sanitized).not.toHaveProperty('timestamp');
+    });
+
+    it('should strip requestId', () => {
+      const event: Event = {
+        type: 'TestEvent',
+        data: {},
+        requestId: 'req-12345',
+      };
+
+      const sanitized = sanitizeEvent(event);
+
+      expect(sanitized).not.toHaveProperty('requestId');
+    });
+
+    it('should strip correlationId', () => {
+      const event: Event = {
+        type: 'TestEvent',
+        data: {},
+        correlationId: 'corr-67890',
+      };
+
+      const sanitized = sanitizeEvent(event);
+
+      expect(sanitized).not.toHaveProperty('correlationId');
+    });
+
+    it('should strip all volatile fields at once', () => {
+      const event: Event = {
+        type: 'CompleteEvent',
+        data: { result: 'success' },
+        timestamp: new Date('2025-01-01T00:00:00.000Z'),
+        requestId: 'req-abc',
+        correlationId: 'corr-xyz',
+      };
+
+      const sanitized = sanitizeEvent(event);
+
+      expect(sanitized).toEqual({
+        type: 'CompleteEvent',
+        data: { result: 'success' },
+      });
+    });
+
+    it('should return a new object (not mutate original)', () => {
+      const testDate = new Date('2025-01-01T00:00:00.000Z');
+      const event: Event = {
+        type: 'TestEvent',
+        data: { value: 1 },
+        timestamp: testDate,
+      };
+
+      const sanitized = sanitizeEvent(event);
+
+      expect(event.timestamp).toBe(testDate);
+      expect(sanitized).not.toBe(event);
+    });
+  });
+
+  describe('sanitizeEvents', () => {
+    it('should sanitize empty array', () => {
+      const result = sanitizeEvents([]);
+      expect(result).toEqual([]);
+    });
+
+    it('should sanitize multiple events', () => {
+      const events: Event[] = [
+        { type: 'First', data: { a: 1 }, timestamp: new Date(), requestId: 'r1' },
+        { type: 'Second', data: { b: 2 }, correlationId: 'c2' },
+        { type: 'Third', data: { c: 3 } },
+      ];
+
+      const sanitized = sanitizeEvents(events);
+
+      expect(sanitized).toEqual([
+        { type: 'First', data: { a: 1 } },
+        { type: 'Second', data: { b: 2 } },
+        { type: 'Third', data: { c: 3 } },
+      ]);
+    });
+
+    it('should preserve event order', () => {
+      const events: Event[] = [
+        { type: 'A', data: {} },
+        { type: 'B', data: {} },
+        { type: 'C', data: {} },
+      ];
+
+      const sanitized = sanitizeEvents(events);
+
+      expect(sanitized.map((e) => e.type)).toEqual(['A', 'B', 'C']);
+    });
+  });
+
+  describe('SanitizedEvent type', () => {
+    it('should be assignable from sanitizeEvent result', () => {
+      const event: Event = { type: 'Test', data: { x: 1 } };
+      const sanitized: SanitizedEvent = sanitizeEvent(event);
+
+      expect(sanitized.type).toBe('Test');
+      expect(sanitized.data).toEqual({ x: 1 });
+    });
+  });
+});

package/src/testing/snapshot-sanitize.ts

@@ -0,0 +1,17 @@
+import type { Event } from '@auto-engineer/message-bus';
+
+export interface SanitizedEvent {
+  type: string;
+  data: Record<string, unknown>;
+}
+
+export function sanitizeEvent(event: Event): SanitizedEvent {
+  return {
+    type: event.type,
+    data: event.data,
+  };
+}
+
+export function sanitizeEvents(events: Event[]): SanitizedEvent[] {
+  return events.map(sanitizeEvent);
+}

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "./dist",
+    "types": ["vitest/globals", "node"],
+    "lib": ["ES2022", "DOM"],
+    "composite": true
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules", "dist"]
+}

package/tsconfig.test.json

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "composite": false,
+    "types": ["vitest/globals", "node"]
+  },
+  "include": ["src/**/*", "**/*.specs.ts", "**/*.spec.ts", "**/*.test.ts"],
+  "exclude": ["node_modules", "dist"]
+}

package/vitest.config.ts

@@ -0,0 +1,29 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    include: ['src/**/*.specs.ts'],
+    exclude: ['src/**/*.e2e.specs.ts'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      thresholds: {
+        lines: 100,
+        functions: 100,
+        branches: 100,
+        statements: 100,
+      },
+      include: ['src/**/*.ts'],
+      exclude: [
+        'src/**/*.specs.ts',
+        'src/index.ts',
+        'src/core/descriptors.ts',
+        'src/graph/types.ts',
+        'src/runtime/context.ts',
+        'src/testing/fixtures/**/*.ts',
+      ],
+    },
+  },
+});