serverless-plugin-module-registry 1.0.12 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "serverless-plugin-module-registry",
-  "version": "1.0.12",
+  "version": "1.0.13",
   "description": "A Serverless Framework plugin that scans module registry files and stores feature mappings in DynamoDB for cross-module discovery",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -50,6 +50,7 @@
     "dist/**/*",
     "src/service.js",
     "src/service.d.ts",
+    "src/internal-infrastructure/**/*",
     "README.md",
     "LICENSE"
   ],
@@ -110,4 +111,4 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   }
-}
+}

package/src/internal-infrastructure/__tests__/custom-stream-enabler.test.ts

@@ -0,0 +1,214 @@
+/**
+ * Custom Stream Enabler Handler Tests
+ * Tests for the DynamoDB Streams enablement custom resource handler
+ */
+
+// Mock AWS SDK before imports
+const mockSend = jest.fn()
+jest.mock('@aws-sdk/client-dynamodb', () => ({
+  DynamoDBClient: jest.fn(() => ({
+    send: mockSend
+  })),
+  DescribeTableCommand: jest.fn((input) => input),
+  UpdateTableCommand: jest.fn((input) => input)
+}))
+
+// Mock https
+const mockHttpsRequest = jest.fn()
+jest.mock('https', () => ({
+  request: mockHttpsRequest
+}))
+
+// Mock url
+jest.mock('url', () => ({
+  parse: jest.fn(() => ({
+    hostname: 'test.com',
+    path: '/test'
+  }))
+}))
+
+import { handler } from '../handlers/custom-stream-enabler'
+
+describe('Custom Stream Enabler Handler', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+    mockSend.mockReset()
+    mockHttpsRequest.mockReset()
+
+    // Setup default https mock
+    mockHttpsRequest.mockImplementation((options, callback) => {
+      const mockResponse = {}
+      if (callback) callback(mockResponse)
+      return {
+        on: jest.fn(),
+        write: jest.fn(),
+        end: jest.fn()
+      }
+    })
+  })
+
+  describe('Create/Update requests', () => {
+    it('should enable streams when not already enabled', async () => {
+      const event = {
+        RequestType: 'Create' as const,
+        ResponseURL: 'https://test.com/response',
+        StackId: 'stack-123',
+        RequestId: 'request-123',
+        ResourceType: 'Custom::DynamoDBStreams',
+        LogicalResourceId: 'EnableTableStreams',
+        ResourceProperties: {
+          ServiceToken: 'arn:aws:lambda:us-east-1:123456789012:function:stream-enabler',
+          TableName: 'test-table',
+          StreamViewType: 'NEW_AND_OLD_IMAGES' as const
+        }
+      }
+
+      const context = {
+        logStreamName: 'test-log-stream'
+      }
+
+      // Mock DescribeTable - streams not enabled
+      mockSend
+        .mockResolvedValueOnce({
+          Table: {
+            StreamSpecification: {
+              StreamEnabled: false
+            }
+          }
+        })
+        // Mock UpdateTable
+        .mockResolvedValueOnce({})
+        // Mock DescribeTable - after update
+        .mockResolvedValueOnce({
+          Table: {
+            LatestStreamArn: 'arn:aws:dynamodb:us-east-1:123456789012:table/test-table/stream/2024-01-01'
+          }
+        })
+
+      await handler(event, context)
+
+      expect(mockSend).toHaveBeenCalledTimes(3)
+      expect(mockHttpsRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'PUT'
+        }),
+        expect.any(Function)
+      )
+    })
+
+    it('should skip enabling streams if already enabled (idempotent)', async () => {
+      const event = {
+        RequestType: 'Update' as const,
+        ResponseURL: 'https://test.com/response',
+        StackId: 'stack-123',
+        RequestId: 'request-123',
+        ResourceType: 'Custom::DynamoDBStreams',
+        LogicalResourceId: 'EnableTableStreams',
+        ResourceProperties: {
+          ServiceToken: 'arn:aws:lambda:us-east-1:123456789012:function:stream-enabler',
+          TableName: 'test-table',
+          StreamViewType: 'NEW_AND_OLD_IMAGES' as const
+        }
+      }
+
+      const context = {
+        logStreamName: 'test-log-stream'
+      }
+
+      // Mock DescribeTable - streams already enabled
+      mockSend.mockResolvedValueOnce({
+        Table: {
+          StreamSpecification: {
+            StreamEnabled: true
+          },
+          LatestStreamArn: 'arn:aws:dynamodb:us-east-1:123456789012:table/test-table/stream/2024-01-01'
+        }
+      })
+
+      await handler(event, context)
+
+      // Should only call DescribeTable once
+      expect(mockSend).toHaveBeenCalledTimes(1)
+      expect(mockHttpsRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'PUT'
+        }),
+        expect.any(Function)
+      )
+    })
+  })
+
+  describe('Delete requests', () => {
+    it('should leave streams enabled on delete for safety', async () => {
+      const event = {
+        RequestType: 'Delete' as const,
+        ResponseURL: 'https://test.com/response',
+        StackId: 'stack-123',
+        RequestId: 'request-123',
+        ResourceType: 'Custom::DynamoDBStreams',
+        LogicalResourceId: 'EnableTableStreams',
+        PhysicalResourceId: 'test-table',
+        ResourceProperties: {
+          ServiceToken: 'arn:aws:lambda:us-east-1:123456789012:function:stream-enabler',
+          TableName: 'test-table',
+          StreamViewType: 'NEW_AND_OLD_IMAGES' as const
+        }
+      }
+
+      const context = {
+        logStreamName: 'test-log-stream'
+      }
+
+      await handler(event, context)
+
+      // Should not call DynamoDB (no disable operation)
+      expect(mockSend).not.toHaveBeenCalled()
+      expect(mockHttpsRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'PUT'
+        }),
+        expect.any(Function)
+      )
+    })
+  })
+
+  describe('Error handling', () => {
+    it('should send FAILED response on error', async () => {
+      const event = {
+        RequestType: 'Create' as const,
+        ResponseURL: 'https://test.com/response',
+        StackId: 'stack-123',
+        RequestId: 'request-123',
+        ResourceType: 'Custom::DynamoDBStreams',
+        LogicalResourceId: 'EnableTableStreams',
+        ResourceProperties: {
+          ServiceToken: 'arn:aws:lambda:us-east-1:123456789012:function:stream-enabler',
+          TableName: 'test-table',
+          StreamViewType: 'NEW_AND_OLD_IMAGES' as const
+        }
+      }
+
+      const context = {
+        logStreamName: 'test-log-stream'
+      }
+
+      // Mock error
+      mockSend.mockRejectedValueOnce(new Error('DynamoDB error'))
+
+      await handler(event, context)
+
+      expect(mockHttpsRequest).toHaveBeenCalledWith(
+        expect.objectContaining({
+          method: 'PUT'
+        }),
+        expect.any(Function)
+      )
+
+      // Verify FAILED status in response body
+      const writeCall = mockHttpsRequest.mock.results[0].value.write
+      expect(writeCall).toHaveBeenCalledWith(
+        expect.stringContaining('"Status":"FAILED"')
+      )
+    })
+  })
+})

package/src/internal-infrastructure/__tests__/eventbridge-config.test.ts

@@ -0,0 +1,135 @@
+/**
+ * EventBridge Infrastructure Configuration Tests
+ *
+ * Validates that the EventBridge infrastructure is properly configured
+ * in the serverless.yml and resource files.
+ */
+
+import { readFileSync } from 'fs'
+import { resolve } from 'path'
+
+describe('EventBridge Infrastructure Configuration', () => {
+  const basePath = resolve(__dirname, '..')
+
+  let eventbridgeContent: string
+  let iamContent: string
+  let serverlessContent: string
+
+  beforeAll(() => {
+    // Load resource files as strings to handle CloudFormation intrinsic functions
+    eventbridgeContent = readFileSync(
+      resolve(basePath, 'resources/eventbridge.yml'),
+      'utf8'
+    )
+
+    iamContent = readFileSync(
+      resolve(basePath, 'resources/iam.yml'),
+      'utf8'
+    )
+
+    serverlessContent = readFileSync(
+      resolve(basePath, 'serverless.yml'),
+      'utf8'
+    )
+  })
+
+  describe('EventBridge EventBus Resource', () => {
+    it('should define ModuleRegistryEventBus resource', () => {
+      expect(eventbridgeContent).toContain('ModuleRegistryEventBus:')
+      expect(eventbridgeContent).toContain('Type: AWS::Events::EventBus')
+    })
+
+    it('should have stage-parameterized name', () => {
+      expect(eventbridgeContent).toContain('Name: module-registry-events-${self:provider.stage}')
+    })
+
+    it('should have proper tags', () => {
+      expect(eventbridgeContent).toContain('Key: Module')
+      expect(eventbridgeContent).toContain('Value: module-registry')
+      expect(eventbridgeContent).toContain('Key: Purpose')
+      expect(eventbridgeContent).toContain('Value: EventBus')
+      expect(eventbridgeContent).toContain('Key: ManagedBy')
+      expect(eventbridgeContent).toContain('Value: Serverless')
+    })
+  })
+
+  describe('EventBridge CloudFormation Outputs', () => {
+    it('should export EventBusArn with proper export name', () => {
+      expect(eventbridgeContent).toContain('EventBusArn:')
+      expect(eventbridgeContent).toContain('Description: Module Registry EventBridge EventBus ARN')
+      expect(eventbridgeContent).toContain('!GetAtt ModuleRegistryEventBus.Arn')
+      expect(eventbridgeContent).toContain('Name: ${self:provider.stackName}-EventBusArn')
+    })
+
+    it('should export EventBusName with proper export name', () => {
+      expect(eventbridgeContent).toContain('EventBusName:')
+      expect(eventbridgeContent).toContain('Description: Module Registry EventBridge EventBus Name')
+      expect(eventbridgeContent).toContain('!Ref ModuleRegistryEventBus')
+      expect(eventbridgeContent).toContain('Name: ${self:provider.stackName}-EventBusName')
+    })
+  })
+
+  describe('StreamProcessor IAM Permissions', () => {
+    it('should have events:PutEvents permission', () => {
+      expect(iamContent).toContain('StreamProcessorRole:')
+      expect(iamContent).toContain('- events:PutEvents')
+    })
+
+    it('should reference ModuleRegistryEventBus ARN', () => {
+      expect(iamContent).toContain('!GetAtt ModuleRegistryEventBus.Arn')
+    })
+
+    it('should maintain existing SQS permissions', () => {
+      expect(iamContent).toContain('- sqs:SendMessage')
+      expect(iamContent).toContain('!GetAtt RoleUpdateQueue.Arn')
+    })
+
+    it('should maintain existing DynamoDB permissions', () => {
+      expect(iamContent).toContain('- dynamodb:DescribeStream')
+      expect(iamContent).toContain('- dynamodb:GetRecords')
+      expect(iamContent).toContain('- dynamodb:GetShardIterator')
+      expect(iamContent).toContain('- dynamodb:ListStreams')
+    })
+  })
+
+  describe('Serverless Configuration', () => {
+    it('should include eventbridge.yml in resources', () => {
+      expect(serverlessContent).toContain('${file(resources/eventbridge.yml)}')
+    })
+
+    it('should include eventbridge.yml before iam.yml', () => {
+      const eventbridgeIndex = serverlessContent.indexOf('${file(resources/eventbridge.yml)}')
+      const iamIndex = serverlessContent.indexOf('${file(resources/iam.yml)}')
+
+      expect(eventbridgeIndex).toBeGreaterThan(-1)
+      expect(iamIndex).toBeGreaterThan(-1)
+      expect(eventbridgeIndex).toBeLessThan(iamIndex)
+    })
+
+    it('should configure EVENT_BUS_NAME environment variable', () => {
+      expect(serverlessContent).toContain('streamProcessor:')
+      expect(serverlessContent).toContain('EVENT_BUS_NAME: !Ref ModuleRegistryEventBus')
+    })
+
+    it('should maintain existing QUEUE_URL environment variable', () => {
+      expect(serverlessContent).toContain('QUEUE_URL: !Ref RoleUpdateQueue')
+    })
+
+    it('should maintain existing DynamoDB stream event', () => {
+      expect(serverlessContent).toContain('- stream:')
+      expect(serverlessContent).toContain('type: dynamodb')
+      expect(serverlessContent).toContain('arn: !GetAtt EnableTableStreams.StreamArn')
+    })
+  })
+
+  describe('File Existence', () => {
+    it('should have eventbridge.yml file', () => {
+      expect(eventbridgeContent.length).toBeGreaterThan(0)
+    })
+
+    it('should have valid YAML structure in eventbridge.yml', () => {
+      expect(eventbridgeContent).toContain('Resources:')
+      expect(eventbridgeContent).toContain('Outputs:')
+    })
+  })
+})