@auriclabs/events 0.2.0 → 0.4.0

package/src/stream-handler.test.ts

@@ -32,7 +32,7 @@ import { SendMessageBatchCommand } from '@aws-sdk/client-sqs';
 
 import { createStreamHandler } from './stream-handler';
 
-import type { DynamoDBStreamEvent } from 'aws-lambda';
+import type { DynamoDBRecord, DynamoDBStreamEvent } from 'aws-lambda';
 
 const makeEventRecord = (overrides = {}) => ({
   pk: 'AGG#order#o-1',
@@ -42,6 +42,7 @@ const makeEventRecord = (overrides = {}) => ({
   aggregateId: 'o-1',
   aggregateType: 'order',
   version: 1,
+  tenantId: 'tenant-1',
   eventId: 'evt-1',
   eventType: 'OrderCreated',
   schemaVersion: 1,
@@ -50,11 +51,18 @@ const makeEventRecord = (overrides = {}) => ({
   ...overrides,
 });
 
-const makeStreamRecord = (eventName: string, newImage: object | undefined = {}) => ({
+const makeStreamRecord = (
+  eventName: string,
+  newImage: object | undefined = {},
+): DynamoDBRecord => ({
   eventID: '1',
   eventVersion: '1.1',
   dynamodb: {
-    NewImage: newImage,
+    NewImage: newImage as DynamoDBRecord['dynamodb'] extends infer D
+      ? D extends { NewImage?: infer N }
+        ? N
+        : never
+      : never,
     StreamViewType: 'NEW_IMAGE',
   },
   awsRegion: 'us-east-1',
@@ -63,6 +71,25 @@ const makeStreamRecord = (eventName: string, newImage: object | undefined = {})
   eventSource: 'aws:dynamodb',
 });
 
+interface SqsBatchInput {
+  QueueUrl?: string;
+  Entries?: {
+    Id?: string;
+    MessageBody: string;
+    MessageGroupId?: string;
+    MessageDeduplicationId?: string;
+  }[];
+}
+
+interface EbPutEventsInput {
+  Entries?: {
+    EventBusName?: string;
+    DetailType?: string;
+    Source?: string;
+    Detail: string;
+  }[];
+}
+
 describe('stream-handler', () => {
   const config = {
     busName: 'test-bus',
@@ -90,7 +117,7 @@ describe('stream-handler', () => {
         makeStreamRecord('INSERT', { data: { S: 'x' } }),
         makeStreamRecord('MODIFY', { data: { S: 'y' } }),
         makeStreamRecord('REMOVE', undefined),
-      ] as any,
+      ],
     };
 
     await handler(event);
@@ -110,16 +137,16 @@ describe('stream-handler', () => {
       Records: [
         makeStreamRecord('INSERT', { a: { S: '1' } }),
         makeStreamRecord('INSERT', { b: { S: '2' } }),
-      ] as any,
+      ],
     };
 
     await handler(event);
 
     // Only eventRecord (itemType='event') should be sent
     expect(SendMessageBatchCommand).toHaveBeenCalledTimes(1);
-    const sqsInput = vi.mocked(SendMessageBatchCommand).mock.calls[0][0];
+    const sqsInput = vi.mocked(SendMessageBatchCommand).mock.calls[0][0] as SqsBatchInput;
     expect(sqsInput.Entries).toHaveLength(1);
-    expect(JSON.parse(sqsInput.Entries![0].MessageBody)).toEqual(eventRecord);
+    expect(JSON.parse(sqsInput.Entries?.[0]?.MessageBody ?? '')).toEqual(eventRecord);
   });
 
   it('sends to all configured queues', async () => {
@@ -136,14 +163,14 @@ describe('stream-handler', () => {
 
     const handler = createStreamHandler(multiQueueConfig);
     const event: DynamoDBStreamEvent = {
-      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })] as any,
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
     };
 
     await handler(event);
 
     expect(SendMessageBatchCommand).toHaveBeenCalledTimes(2);
-    const call1 = vi.mocked(SendMessageBatchCommand).mock.calls[0][0];
-    const call2 = vi.mocked(SendMessageBatchCommand).mock.calls[1][0];
+    const call1 = vi.mocked(SendMessageBatchCommand).mock.calls[0][0] as SqsBatchInput;
+    const call2 = vi.mocked(SendMessageBatchCommand).mock.calls[1][0] as SqsBatchInput;
     expect(call1.QueueUrl).toBe('https://sqs.us-east-1.amazonaws.com/123/queue-1');
     expect(call2.QueueUrl).toBe('https://sqs.us-east-1.amazonaws.com/123/queue-2');
   });
@@ -154,18 +181,18 @@ describe('stream-handler', () => {
 
     const handler = createStreamHandler(config);
     const event: DynamoDBStreamEvent = {
-      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })] as any,
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
     };
 
     await handler(event);
 
     expect(PutEventsCommand).toHaveBeenCalledTimes(1);
-    const ebInput = vi.mocked(PutEventsCommand).mock.calls[0][0];
+    const ebInput = vi.mocked(PutEventsCommand).mock.calls[0][0] as EbPutEventsInput;
     expect(ebInput.Entries).toHaveLength(1);
-    expect(ebInput.Entries![0].EventBusName).toBe('test-bus');
-    expect(ebInput.Entries![0].DetailType).toBe('CreditAdded');
-    expect(ebInput.Entries![0].Source).toBe('billing');
-    expect(JSON.parse(ebInput.Entries![0].Detail)).toEqual(eventRecord);
+    expect(ebInput.Entries?.[0]?.EventBusName).toBe('test-bus');
+    expect(ebInput.Entries?.[0]?.DetailType).toBe('CreditAdded');
+    expect(ebInput.Entries?.[0]?.Source).toBe('billing');
+    expect(JSON.parse(ebInput.Entries?.[0]?.Detail ?? '')).toEqual(eventRecord);
   });
 
   it('uses kebabCase of aggregateType as source fallback when source is undefined', async () => {
@@ -174,14 +201,14 @@ describe('stream-handler', () => {
 
     const handler = createStreamHandler(config);
     const event: DynamoDBStreamEvent = {
-      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })] as any,
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
     };
 
     await handler(event);
 
-    const ebInput = vi.mocked(PutEventsCommand).mock.calls[0][0];
+    const ebInput = vi.mocked(PutEventsCommand).mock.calls[0][0] as EbPutEventsInput;
     // kebabCase splits on '.', takes first part 'Order', which becomes 'order'
-    expect(ebInput.Entries![0].Source).toBe('order');
+    expect(ebInput.Entries?.[0]?.Source).toBe('order');
   });
 
   it('uses aggregateId as MessageGroupId', async () => {
@@ -190,13 +217,13 @@ describe('stream-handler', () => {
 
     const handler = createStreamHandler(config);
     const event: DynamoDBStreamEvent = {
-      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })] as any,
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
     };
 
     await handler(event);
 
-    const sqsInput = vi.mocked(SendMessageBatchCommand).mock.calls[0][0];
-    expect(sqsInput.Entries![0].MessageGroupId).toBe('agg-123');
+    const sqsInput = vi.mocked(SendMessageBatchCommand).mock.calls[0][0] as SqsBatchInput;
+    expect(sqsInput.Entries?.[0]?.MessageGroupId).toBe('agg-123');
   });
 
   it('uses eventId as MessageDeduplicationId', async () => {
@@ -205,37 +232,35 @@ describe('stream-handler', () => {
 
     const handler = createStreamHandler(config);
     const event: DynamoDBStreamEvent = {
-      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })] as any,
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
     };
 
     await handler(event);
 
-    const sqsInput = vi.mocked(SendMessageBatchCommand).mock.calls[0][0];
-    expect(sqsInput.Entries![0].MessageDeduplicationId).toBe('evt-dedup-1');
+    const sqsInput = vi.mocked(SendMessageBatchCommand).mock.calls[0][0] as SqsBatchInput;
+    expect(sqsInput.Entries?.[0]?.MessageDeduplicationId).toBe('evt-dedup-1');
   });
 
   it('batches correctly (respects BATCH_SIZE of 10)', async () => {
     // Create 12 event records to trigger 2 batches
     const records = Array.from({ length: 12 }, (_, i) =>
-      makeEventRecord({ eventId: `evt-${i}`, version: i + 1 }),
+      makeEventRecord({ eventId: `evt-${String(i)}`, version: i + 1 }),
     );
 
-    mockUnmarshall.mockImplementation((_, i) => records[i]);
-    // Reset to return each record in sequence
     mockUnmarshall.mockReset();
     records.forEach((r) => mockUnmarshall.mockReturnValueOnce(r));
 
     const handler = createStreamHandler(config);
     const event: DynamoDBStreamEvent = {
-      Records: records.map((_, i) => makeStreamRecord('INSERT', { idx: { N: String(i) } })) as any,
+      Records: records.map((_r, i) => makeStreamRecord('INSERT', { idx: { N: String(i) } })),
     };
 
     await handler(event);
 
     // 2 batches for SQS (10 + 2), 1 queue = 2 calls
     expect(SendMessageBatchCommand).toHaveBeenCalledTimes(2);
-    const firstBatch = vi.mocked(SendMessageBatchCommand).mock.calls[0][0];
-    const secondBatch = vi.mocked(SendMessageBatchCommand).mock.calls[1][0];
+    const firstBatch = vi.mocked(SendMessageBatchCommand).mock.calls[0][0] as SqsBatchInput;
+    const secondBatch = vi.mocked(SendMessageBatchCommand).mock.calls[1][0] as SqsBatchInput;
     expect(firstBatch.Entries).toHaveLength(10);
     expect(secondBatch.Entries).toHaveLength(2);
 
@@ -250,13 +275,13 @@ describe('stream-handler', () => {
 
     const handler = createStreamHandler(config);
     const event: DynamoDBStreamEvent = {
-      Records: [makeStreamRecord('INSERT', { bad: { S: 'data' } })] as any,
+      Records: [makeStreamRecord('INSERT', { bad: { S: 'data' } })],
     };
 
     await handler(event);
 
     expect(logger.error).toHaveBeenCalledWith(
-      expect.objectContaining({ error: expect.any(Error) }),
+      expect.objectContaining({ error: expect.any(Error) as unknown }),
       'Error unmarshalling event record',
     );
     // Should not send to queues since no valid records
@@ -281,13 +306,48 @@ describe('stream-handler', () => {
 
     const handler = createStreamHandler(config);
     const event: DynamoDBStreamEvent = {
-      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })] as any,
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
     };
 
     await expect(handler(event)).rejects.toThrow('SQS error');
     expect(logger.error).toHaveBeenCalled();
   });
 
+  it('skips EventBridge when busName is omitted', async () => {
+    const eventRecord = makeEventRecord();
+    mockUnmarshall.mockReturnValue(eventRecord);
+
+    const handler = createStreamHandler({
+      queueUrls: ['https://sqs.us-east-1.amazonaws.com/123/queue-1'],
+    });
+    const event: DynamoDBStreamEvent = {
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
+    };
+
+    await handler(event);
+
+    expect(SendMessageBatchCommand).toHaveBeenCalledTimes(1);
+    expect(PutEventsCommand).not.toHaveBeenCalled();
+  });
+
+  it('skips EventBridge when busName is empty string', async () => {
+    const eventRecord = makeEventRecord();
+    mockUnmarshall.mockReturnValue(eventRecord);
+
+    const handler = createStreamHandler({
+      busName: '',
+      queueUrls: ['https://sqs.us-east-1.amazonaws.com/123/queue-1'],
+    });
+    const event: DynamoDBStreamEvent = {
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
+    };
+
+    await handler(event);
+
+    expect(SendMessageBatchCommand).toHaveBeenCalledTimes(1);
+    expect(PutEventsCommand).not.toHaveBeenCalled();
+  });
+
   it('re-throws EventBridge send errors', async () => {
     const eventRecord = makeEventRecord();
     mockUnmarshall.mockReturnValue(eventRecord);
@@ -295,7 +355,7 @@ describe('stream-handler', () => {
 
     const handler = createStreamHandler(config);
     const event: DynamoDBStreamEvent = {
-      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })] as any,
+      Records: [makeStreamRecord('INSERT', { a: { S: '1' } })],
     };
 
     await expect(handler(event)).rejects.toThrow();

package/src/stream-handler.ts

@@ -11,7 +11,7 @@ import { AggregateHead, EventRecord } from './types';
 const BATCH_SIZE = 10;
 
 export interface CreateStreamHandlerConfig {
-  busName: string;
+  busName?: string;
   queueUrls: string[];
 }
 
@@ -102,7 +102,11 @@ export function createStreamHandler(config: CreateStreamHandlerConfig) {
       .filter((eventRecord): eventRecord is EventRecord => eventRecord?.itemType === 'event');
 
     if (eventRecords.length > 0) {
-      await Promise.all([sendToBusBatch(eventRecords), sendToQueuesBatch(eventRecords)]);
+      const tasks: Promise<void>[] = [sendToQueuesBatch(eventRecords)];
+      if (config.busName) {
+        tasks.push(sendToBusBatch(eventRecords));
+      }
+      await Promise.all(tasks);
     }
   };
 }

package/src/types.ts

@@ -23,6 +23,9 @@ export interface EventRecord<P = unknown> {
   aggregateType: AggregateType;
   version: number; // post-apply version
 
+  /** Tenant isolation */
+  tenantId: string;
+
   /** Event identity & semantics */
   eventId: EventId; // string (ULID/UUID), not number
   eventType: string;

package/tsconfig.test.json

@@ -1,7 +1,8 @@
 {
   "extends": "./tsconfig.json",
   "compilerOptions": {
-    "noEmit": true
+    "noEmit": true,
+    "types": ["vitest/globals"]
   },
   "include": ["src", "vitest.config.ts"],
   "exclude": ["dist", "node_modules"]