fix(workers): reject events with non-object payload to avoid corrupted DB records

lib/utils/validateEventStructure.test.ts

@@ -0,0 +1,296 @@
+import { validateEventStructure } from './validateEventStructure';
+
+describe('validateEventStructure', () => {
+  describe('Basic type validation', () => {
+    test('should reject null payload', () => {
+      const result = validateEventStructure(null);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBe('Invalid payload type: null');
+    });
+
+    test('should reject array payload', () => {
+      const result = validateEventStructure([]);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('expected object, got array');
+    });
+
+    test('should reject string payload', () => {
+      const result = validateEventStructure('invalid');
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('expected object, got string');
+    });
+
+    test('should reject number payload', () => {
+      const result = validateEventStructure(123);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('expected object, got number');
+    });
+
+    test('should reject undefined payload', () => {
+      const result = validateEventStructure(undefined);
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('expected object, got undefined');
+    });
+  });
+
+  describe('Required fields validation', () => {
+    test('should reject payload without title', () => {
+      const result = validateEventStructure({
+        backtrace: [],
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('Event title is required');
+    });
+
+    test('should reject payload with empty title', () => {
+      const result = validateEventStructure({
+        title: '',
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('Event title is required');
+    });
+
+    test('should reject payload with non-string title', () => {
+      const result = validateEventStructure({
+        title: 123,
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('title');
+    });
+
+    test('should accept payload with only title', () => {
+      const result = validateEventStructure({
+        title: 'Error occurred',
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+  });
+
+  describe('Optional fields validation', () => {
+    test('should accept valid payload with all optional fields', () => {
+      const result = validateEventStructure({
+        title: 'TypeError: Cannot read property',
+        type: 'TypeError',
+        backtrace: [
+          {
+            file: '/path/to/file.js',
+            line: 42,
+            column: 10,
+            function: 'myFunction',
+          },
+        ],
+        breadcrumbs: [
+          {
+            timestamp: Date.now(),
+            type: 'navigation',
+            message: 'User navigated to /home',
+          },
+        ],
+        release: 'v1.0.0',
+        user: {
+          id: 'user123',
+          name: 'John Doe',
+        },
+        context: {
+          customKey: 'customValue',
+        },
+        addons: {
+          vue: {
+            version: '3.0.0',
+          },
+        },
+        catcherVersion: '3.2.0',
+      });
+
+      expect(result.isValid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    test('should accept payload with optional backtrace', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        backtrace: [
+          {
+            file: 'file.js',
+            line: 1,
+          },
+        ],
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should accept payload with optional breadcrumbs', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        breadcrumbs: [
+          {
+            timestamp: 1234567890,
+            message: 'User clicked button',
+          },
+        ],
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should accept payload with optional user', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        user: {
+          id: 'user123',
+        },
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should accept payload with context as object', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        context: {
+          key: 'value',
+        },
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should accept payload with context as string', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        context: 'string context',
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should accept payload with addons', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        addons: {
+          vue: {
+            componentName: 'MyComponent',
+          },
+        },
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+  });
+
+  describe('Type validation for optional fields', () => {
+    test('should reject backtrace if not array', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        backtrace: 'invalid',
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('backtrace');
+    });
+
+    test('should reject breadcrumbs if not array', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        breadcrumbs: 'invalid',
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('breadcrumbs');
+    });
+
+    test('should reject breadcrumbs with missing timestamp', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        breadcrumbs: [
+          {
+            message: 'test',
+          },
+        ],
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('timestamp');
+    });
+
+    test('should reject release if not string', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        release: 123,
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('release');
+    });
+
+    test('should reject type if not string', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        type: 123,
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toContain('type');
+    });
+  });
+
+  describe('Edge cases', () => {
+    test('should accept empty backtrace array', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        backtrace: [],
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should accept empty breadcrumbs array', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        breadcrumbs: [],
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should accept empty context object', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        context: {},
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should accept empty addons object', () => {
+      const result = validateEventStructure({
+        title: 'Error',
+        addons: {},
+      });
+
+      expect(result.isValid).toBe(true);
+    });
+
+    test('should handle multiple validation errors', () => {
+      const result = validateEventStructure({
+        title: 123,
+        backtrace: 'invalid',
+        breadcrumbs: 'invalid',
+      });
+
+      expect(result.isValid).toBe(false);
+      expect(result.error).toBeTruthy();
+    });
+  });
+});