@friggframework/core 2.0.0--canary.461.ec909cf.0 → 2.0.0--canary.461.7b36f0f.0

package/core/Worker.js

@@ -1,10 +1,9 @@
-const AWS = require('aws-sdk');
+const { SQSClient, GetQueueUrlCommand, SendMessageCommand } = require('@aws-sdk/client-sqs');
 const _ = require('lodash');
 const { RequiredPropertyError } = require('../errors');
 const { get } = require('../assertions');
 
-AWS.config.update({ region: process.env.AWS_REGION });
-const sqs = new AWS.SQS({ apiVersion: '2012-11-05' });
+const sqs = new SQSClient({ region: process.env.AWS_REGION });
 
 class Worker {
     async getQueueURL(params) {
@@ -12,15 +11,9 @@ class Worker {
         // let params = {
         //     QueueName:  process.env.QueueName
         // };
-        return new Promise((resolve, reject) => {
-            sqs.getQueueUrl(params, (err, data) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    resolve(data.QueueUrl);
-                }
-            });
-        });
+        const command = new GetQueueUrlCommand(params);
+        const data = await sqs.send(command);
+        return data.QueueUrl;
     }
 
     async run(params, context = {}) {
@@ -54,15 +47,9 @@ class Worker {
     }
 
     async sendAsyncSQSMessage(params) {
-        return new Promise((resolve, reject) => {
-            sqs.sendMessage(params, (err, data) => {
-                if (err) {
-                    reject(err);
-                } else {
-                    resolve(data.MessageId);
-                }
-            });
-        });
+        const command = new SendMessageCommand(params);
+        const data = await sqs.send(command);
+        return data.MessageId;
     }
 
     // Throw an exception if the params do not validate

package/core/Worker.test.js

@@ -0,0 +1,159 @@
+/**
+ * Tests for Worker - AWS SDK v3 Migration
+ * 
+ * Tests SQS Worker operations using aws-sdk-client-mock
+ */
+
+const { mockClient } = require('aws-sdk-client-mock');
+const { SQSClient, GetQueueUrlCommand, SendMessageCommand } = require('@aws-sdk/client-sqs');
+const { Worker } = require('./Worker');
+
+describe('Worker - AWS SDK v3', () => {
+    let sqsMock;
+    let worker;
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        sqsMock = mockClient(SQSClient);
+        worker = new Worker();
+        jest.clearAllMocks();
+        process.env = { ...originalEnv, AWS_REGION: 'us-east-1' };
+    });
+
+    afterEach(() => {
+        sqsMock.reset();
+        process.env = originalEnv;
+    });
+
+    describe('getQueueURL()', () => {
+        it('should get queue URL from SQS', async () => {
+            sqsMock.on(GetQueueUrlCommand).resolves({
+                QueueUrl: 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue',
+            });
+
+            const result = await worker.getQueueURL({ QueueName: 'test-queue' });
+
+            expect(result).toBe('https://sqs.us-east-1.amazonaws.com/123456789/test-queue');
+            expect(sqsMock.calls()).toHaveLength(1);
+            
+            const call = sqsMock.call(0);
+            expect(call.args[0].input).toMatchObject({
+                QueueName: 'test-queue',
+            });
+        });
+
+        it('should handle queue not found error', async () => {
+            sqsMock.on(GetQueueUrlCommand).rejects(new Error('Queue does not exist'));
+
+            await expect(worker.getQueueURL({ QueueName: 'nonexistent-queue' }))
+                .rejects.toThrow('Queue does not exist');
+        });
+    });
+
+    describe('sendAsyncSQSMessage()', () => {
+        it('should send message and return MessageId', async () => {
+            sqsMock.on(SendMessageCommand).resolves({
+                MessageId: 'message-123',
+            });
+
+            const params = {
+                QueueUrl: 'https://queue-url',
+                MessageBody: JSON.stringify({ test: 'data' }),
+            };
+
+            const result = await worker.sendAsyncSQSMessage(params);
+
+            expect(result).toBe('message-123');
+            expect(sqsMock.calls()).toHaveLength(1);
+        });
+
+        it('should handle send errors', async () => {
+            sqsMock.on(SendMessageCommand).rejects(new Error('Send failed'));
+
+            const params = {
+                QueueUrl: 'https://queue-url',
+                MessageBody: 'test',
+            };
+
+            await expect(worker.sendAsyncSQSMessage(params)).rejects.toThrow('Send failed');
+        });
+    });
+
+    describe('send()', () => {
+        it('should validate params and send message with delay', async () => {
+            sqsMock.on(SendMessageCommand).resolves({
+                MessageId: 'delayed-message-id',
+            });
+
+            worker._validateParams = jest.fn();  // Mock validation
+
+            const params = {
+                QueueUrl: 'https://queue-url',
+                data: 'test',
+            };
+
+            const result = await worker.send(params, 5);
+
+            expect(worker._validateParams).toHaveBeenCalledWith(params);
+            expect(result).toBe('delayed-message-id');
+            
+            const call = sqsMock.call(0);
+            expect(call.args[0].input.DelaySeconds).toBe(5);
+        });
+
+        it('should send message with zero delay by default', async () => {
+            sqsMock.on(SendMessageCommand).resolves({
+                MessageId: 'message-id',
+            });
+
+            worker._validateParams = jest.fn();
+
+            const params = {
+                QueueUrl: 'https://queue-url',
+                data: 'test',
+            };
+
+            await worker.send(params);
+
+            const call = sqsMock.call(0);
+            expect(call.args[0].input.DelaySeconds).toBe(0);
+        });
+    });
+
+    describe('run()', () => {
+        it('should process SQS records', async () => {
+            worker._validateParams = jest.fn();
+            worker._run = jest.fn().mockResolvedValue(undefined);
+
+            const params = {
+                Records: [
+                    { body: JSON.stringify({ task: 'test-1' }) },
+                    { body: JSON.stringify({ task: 'test-2' }) },
+                ],
+            };
+
+            await worker.run(params);
+
+            expect(worker._run).toHaveBeenCalledTimes(2);
+            expect(worker._run).toHaveBeenCalledWith({ task: 'test-1' }, {});
+            expect(worker._run).toHaveBeenCalledWith({ task: 'test-2' }, {});
+        });
+
+        it('should pass context to _run method', async () => {
+            worker._validateParams = jest.fn();
+            worker._run = jest.fn().mockResolvedValue(undefined);
+
+            const params = {
+                Records: [
+                    { body: JSON.stringify({ task: 'test' }) },
+                ],
+            };
+            const context = { userId: '123' };
+
+            await worker.run(params, context);
+
+            expect(worker._run).toHaveBeenCalledWith({ task: 'test' }, context);
+        });
+    });
+});
+

package/database/models/WebsocketConnection.js

@@ -1,5 +1,8 @@
 const { mongoose } = require('../mongoose');
-const AWS = require('aws-sdk');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
 
 const schema = new mongoose.Schema({
     connectionId: { type: mongoose.Schema.Types.String },
@@ -17,20 +20,18 @@ schema.statics.getActiveConnections = async function () {
         return connections.map((conn) => ({
             connectionId: conn.connectionId,
             send: async (data) => {
-                const apigwManagementApi = new AWS.ApiGatewayManagementApi({
-                    apiVersion: '2018-11-29',
+                const apigwManagementApi = new ApiGatewayManagementApiClient({
                     endpoint: process.env.WEBSOCKET_API_ENDPOINT,
                 });
 
                 try {
-                    await apigwManagementApi
-                        .postToConnection({
-                            ConnectionId: conn.connectionId,
-                            Data: JSON.stringify(data),
-                        })
-                        .promise();
+                    const command = new PostToConnectionCommand({
+                        ConnectionId: conn.connectionId,
+                        Data: JSON.stringify(data),
+                    });
+                    await apigwManagementApi.send(command);
                 } catch (error) {
-                    if (error.statusCode === 410) {
+                    if (error.statusCode === 410 || error.$metadata?.httpStatusCode === 410) {
                         console.log(`Stale connection ${conn.connectionId}`);
                         await this.deleteOne({
                             connectionId: conn.connectionId,

package/encrypt/Cryptor.js

@@ -17,7 +17,7 @@
  */
 
 const crypto = require('crypto');
-const AWS = require('aws-sdk');
+const { KMSClient, GenerateDataKeyCommand, DecryptCommand } = require('@aws-sdk/client-kms');
 const aes = require('./aes');
 
 class Cryptor {
@@ -27,16 +27,15 @@ class Cryptor {
 
     async generateDataKey() {
         if (this.shouldUseAws) {
-            const kmsClient = new AWS.KMS();
-            const dataKey = await kmsClient
-                .generateDataKey({
-                    KeyId: process.env.KMS_KEY_ARN,
-                    KeySpec: 'AES_256',
-                })
-                .promise();
+            const kmsClient = new KMSClient({});
+            const command = new GenerateDataKeyCommand({
+                KeyId: process.env.KMS_KEY_ARN,
+                KeySpec: 'AES_256',
+            });
+            const dataKey = await kmsClient.send(command);
 
             const keyId = Buffer.from(dataKey.KeyId).toString('base64');
-            const encryptedKey = dataKey.CiphertextBlob.toString('base64');
+            const encryptedKey = Buffer.from(dataKey.CiphertextBlob).toString('base64');
             const plaintext = dataKey.Plaintext;
             return { keyId, encryptedKey, plaintext };
         }
@@ -70,13 +69,12 @@ class Cryptor {
 
     async decryptDataKey(keyId, encryptedKey) {
         if (this.shouldUseAws) {
-            const kmsClient = new AWS.KMS();
-            const dataKey = await kmsClient
-                .decrypt({
-                    KeyId: keyId,
-                    CiphertextBlob: encryptedKey,
-                })
-                .promise();
+            const kmsClient = new KMSClient({});
+            const command = new DecryptCommand({
+                KeyId: keyId,
+                CiphertextBlob: encryptedKey,
+            });
+            const dataKey = await kmsClient.send(command);
 
             return dataKey.Plaintext;
         }

package/encrypt/Cryptor.test.js

@@ -0,0 +1,144 @@
+/**
+ * Tests for Cryptor - AWS SDK v3 Migration
+ * 
+ * Tests KMS encryption/decryption operations using aws-sdk-client-mock
+ */
+
+const { mockClient } = require('aws-sdk-client-mock');
+const { KMSClient, GenerateDataKeyCommand, DecryptCommand } = require('@aws-sdk/client-kms');
+const { Cryptor } = require('./Cryptor');
+
+describe('Cryptor - AWS SDK v3', () => {
+    let kmsMock;
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        kmsMock = mockClient(KMSClient);
+        jest.clearAllMocks();
+        process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+        kmsMock.reset();
+        process.env = originalEnv;
+    });
+
+    describe('KMS Mode (shouldUseAws: true)', () => {
+        beforeEach(() => {
+            process.env.KMS_KEY_ARN = 'arn:aws:kms:us-east-1:123456789:key/test-key-id';
+        });
+
+        describe('encrypt()', () => {
+            it('should encrypt text using KMS data key', async () => {
+                const mockPlaintext = Buffer.from('mock-plaintext-key-32-bytes-long');
+                const mockCiphertextBlob = Buffer.from('mock-encrypted-key');
+
+                kmsMock.on(GenerateDataKeyCommand).resolves({
+                    KeyId: 'test-key-id',
+                    Plaintext: mockPlaintext,
+                    CiphertextBlob: mockCiphertextBlob,
+                });
+
+                const cryptor = new Cryptor({ shouldUseAws: true });
+                const result = await cryptor.encrypt('sensitive-data');
+
+                // Result should be in format: "keyId:encryptedText:encryptedKey"
+                expect(result).toBeDefined();
+                expect(result.split(':').length).toBe(4);  // keyId:iv:ciphertext:encryptedKey format from aes
+
+                expect(kmsMock.calls()).toHaveLength(1);
+                const call = kmsMock.call(0);
+                expect(call.args[0].input).toMatchObject({
+                    KeyId: process.env.KMS_KEY_ARN,
+                    KeySpec: 'AES_256',
+                });
+            });
+
+            it('should handle KMS errors during encryption', async () => {
+                kmsMock.on(GenerateDataKeyCommand).rejects(new Error('KMS unavailable'));
+
+                const cryptor = new Cryptor({ shouldUseAws: true });
+
+                await expect(cryptor.encrypt('sensitive-data')).rejects.toThrow('KMS unavailable');
+            });
+        });
+
+        describe('decrypt()', () => {
+            it('should decrypt text using KMS', async () => {
+                const mockPlaintext = Buffer.from('mock-plaintext-key');
+
+                kmsMock.on(DecryptCommand).resolves({
+                    Plaintext: mockPlaintext,
+                });
+
+                const cryptor = new Cryptor({ shouldUseAws: true });
+                
+                // First encrypt some data
+                const mockDataKey = Buffer.from('test-key-32-bytes-long-exactly');
+                kmsMock.on(GenerateDataKeyCommand).resolves({
+                    KeyId: 'test-key-id',
+                    Plaintext: mockDataKey,
+                    CiphertextBlob: Buffer.from('encrypted-key'),
+                });
+
+                const encrypted = await cryptor.encrypt('test-data');
+                
+                // Then decrypt
+                kmsMock.reset();
+                kmsMock.on(DecryptCommand).resolves({
+                    Plaintext: mockDataKey,
+                });
+
+                const decrypted = await cryptor.decrypt(encrypted);
+                
+                expect(decrypted).toBe('test-data');
+                expect(kmsMock.calls()).toHaveLength(1);
+            });
+
+            it('should handle KMS errors during decryption', async () => {
+                kmsMock.on(DecryptCommand).rejects(new Error('Invalid ciphertext'));
+
+                const cryptor = new Cryptor({ shouldUseAws: true });
+                const fakeEncrypted = Buffer.from('test-key-id').toString('base64') + ':fake:data:' + Buffer.from('fake-key').toString('base64');
+
+                await expect(cryptor.decrypt(fakeEncrypted)).rejects.toThrow('Invalid ciphertext');
+            });
+        });
+    });
+
+    describe('Local Mode (shouldUseAws: false)', () => {
+        beforeEach(() => {
+            process.env.AES_KEY = 'test-aes-key-32-bytes-long-123';
+            process.env.AES_KEY_ID = 'local-key-id';
+        });
+
+        it('should encrypt using local AES key', async () => {
+            const cryptor = new Cryptor({ shouldUseAws: false });
+            const result = await cryptor.encrypt('sensitive-data');
+
+            expect(result).toBeDefined();
+            expect(result.split(':').length).toBeGreaterThanOrEqual(3);
+            expect(kmsMock.calls()).toHaveLength(0);  // Should not call KMS
+        });
+
+        it('should decrypt using local AES key', async () => {
+            const cryptor = new Cryptor({ shouldUseAws: false });
+            
+            const encrypted = await cryptor.encrypt('test-data');
+            const decrypted = await cryptor.decrypt(encrypted);
+
+            expect(decrypted).toBe('test-data');
+            expect(kmsMock.calls()).toHaveLength(0);  // Should not call KMS
+        });
+
+        it('should throw error if encryption key not found', async () => {
+            delete process.env.AES_KEY_ID;
+
+            const cryptor = new Cryptor({ shouldUseAws: false });
+            const fakeEncrypted = 'unknown-key:data:key';
+
+            await expect(cryptor.decrypt(fakeEncrypted)).rejects.toThrow('Encryption key not found');
+        });
+    });
+});
+

package/handlers/database-migration-handler.js

@@ -0,0 +1,227 @@
+/**
+ * Database Migration Handler for AWS Lambda
+ * 
+ * Executes Prisma migrations in a Lambda environment.
+ * Based on AWS best practices for running migrations in serverless environments.
+ * 
+ * Supported Commands:
+ * - deploy: Apply pending migrations to the database (production-safe)
+ * - reset: Reset database and apply all migrations (DANGEROUS - dev only)
+ * 
+ * Usage:
+ *   // Via Lambda invoke
+ *   {
+ *     "command": "deploy"  // or "reset"
+ *   }
+ * 
+ * Requirements:
+ * - Prisma CLI must be included in deployment or Lambda layer
+ * - DATABASE_URL environment variable must be set
+ * - VPC configuration for Aurora access
+ * 
+ * Reference: https://www.prisma.io/docs/guides/deployment/deployment-guides/deploying-to-aws-lambda
+ */
+
+const { execFile } = require('child_process');
+const path = require('path');
+
+/**
+ * Execute Prisma migration command
+ * 
+ * @param {string} command - Migration command ('deploy' or 'reset')
+ * @param {string} schemaPath - Path to Prisma schema file
+ * @returns {Promise<number>} Exit code
+ */
+async function executePrismaMigration(command, schemaPath) {
+    console.log(`Executing Prisma migration: ${command}`);
+    console.log(`Schema path: ${schemaPath}`);
+    console.log(`Database URL: ${process.env.DATABASE_URL ? '[SET]' : '[NOT SET]'}`);
+
+    return new Promise((resolve, reject) => {
+        // Build command arguments
+        const args = ['migrate', command];
+        
+        // Add command-specific options
+        if (command === 'reset') {
+            args.push('--force');           // Skip confirmation prompt
+            args.push('--skip-generate');   // Skip client generation (already done in layer)
+        }
+
+        // Add schema path if provided
+        if (schemaPath) {
+            args.push('--schema', schemaPath);
+        }
+
+        console.log(`Running: prisma ${args.join(' ')}`);
+        
+        // Execute Prisma CLI
+        execFile(
+            path.resolve('./node_modules/prisma/build/index.js'),
+            args,
+            {
+                env: {
+                    ...process.env,
+                    // Ensure Prisma uses the correct binary target
+                    PRISMA_CLI_BINARY_TARGETS: 'rhel-openssl-3.0.x',
+                }
+            },
+            (error, stdout, stderr) => {
+                // Log all output
+                if (stdout) {
+                    console.log('STDOUT:', stdout);
+                }
+                if (stderr) {
+                    console.error('STDERR:', stderr);
+                }
+
+                if (error) {
+                    console.error(`Migration ${command} exited with error:`, error.message);
+                    console.error(`Exit code: ${error.code || 1}`);
+                    resolve(error.code || 1);
+                } else {
+                    console.log(`Migration ${command} completed successfully`);
+                    resolve(0);
+                }
+            }
+        );
+    });
+}
+
+/**
+ * Validate migration command
+ */
+function validateCommand(command) {
+    const validCommands = ['deploy', 'reset'];
+    
+    if (!validCommands.includes(command)) {
+        throw new Error(
+            `Invalid migration command: "${command}". ` +
+            `Valid commands are: ${validCommands.join(', ')}`
+        );
+    }
+
+    // Extra validation for dangerous commands
+    if (command === 'reset') {
+        const stage = process.env.STAGE || process.env.NODE_ENV;
+        if (stage === 'production' || stage === 'prod') {
+            throw new Error(
+                'BLOCKED: "reset" command is not allowed in production environment. ' +
+                'This command would delete all data. Use "deploy" instead.'
+            );
+        }
+        console.warn('⚠️  WARNING: "reset" will DELETE all data and reset the database!');
+    }
+}
+
+/**
+ * Determine which Prisma schema to use based on database type
+ */
+function getSchemaPath() {
+    // In Lambda, schemas are in @friggframework/core/generated/
+    const baseSchemaPath = './node_modules/@friggframework/core/generated';
+    
+    // Check if Postgres is enabled
+    if (process.env.DATABASE_URL?.includes('postgresql') || process.env.DATABASE_URL?.includes('postgres')) {
+        const schemaPath = `${baseSchemaPath}/prisma-postgresql/schema.prisma`;
+        console.log(`Using PostgreSQL schema: ${schemaPath}`);
+        return schemaPath;
+    }
+    
+    // Check if MongoDB is enabled
+    if (process.env.DATABASE_URL?.includes('mongodb')) {
+        const schemaPath = `${baseSchemaPath}/prisma-mongodb/schema.prisma`;
+        console.log(`Using MongoDB schema: ${schemaPath}`);
+        return schemaPath;
+    }
+
+    // Default to PostgreSQL
+    console.log('DATABASE_URL not set or database type unknown, defaulting to PostgreSQL');
+    return `${baseSchemaPath}/prisma-postgresql/schema.prisma`;
+}
+
+/**
+ * Lambda handler for database migrations
+ * 
+ * @param {Object} event - Lambda event
+ * @param {string} event.command - Migration command ('deploy' or 'reset')
+ * @param {Object} context - Lambda context
+ * @returns {Promise<Object>} Migration result
+ */
+exports.handler = async (event, context) => {
+    const startTime = Date.now();
+    
+    console.log('='.repeat(60));
+    console.log('Database Migration Handler');
+    console.log('='.repeat(60));
+    console.log('Event:', JSON.stringify(event, null, 2));
+    console.log('Context:', JSON.stringify({
+        functionName: context.functionName,
+        functionVersion: context.functionVersion,
+        memoryLimitInMB: context.memoryLimitInMB,
+        logGroupName: context.logGroupName,
+    }, null, 2));
+    
+    try {
+        // Get migration command (default to 'deploy')
+        const command = event.command || 'deploy';
+        
+        // Validate command
+        validateCommand(command);
+        
+        // Check required environment variables
+        if (!process.env.DATABASE_URL) {
+            throw new Error(
+                'DATABASE_URL environment variable is not set. ' +
+                'Cannot connect to database for migrations.'
+            );
+        }
+        
+        // Determine schema path
+        const schemaPath = getSchemaPath();
+        
+        // Execute migration
+        const exitCode = await executePrismaMigration(command, schemaPath);
+        
+        const duration = Date.now() - startTime;
+        
+        if (exitCode === 0) {
+            const result = {
+                success: true,
+                command,
+                message: `Migration ${command} completed successfully`,
+                duration: `${duration}ms`,
+                timestamp: new Date().toISOString(),
+            };
+            
+            console.log('='.repeat(60));
+            console.log('Migration completed successfully');
+            console.log(JSON.stringify(result, null, 2));
+            console.log('='.repeat(60));
+            
+            return result;
+        } else {
+            throw new Error(`Migration ${command} failed with exit code ${exitCode}`);
+        }
+        
+    } catch (error) {
+        const duration = Date.now() - startTime;
+        
+        console.error('='.repeat(60));
+        console.error('Migration failed');
+        console.error('Error:', error.message);
+        console.error('Stack:', error.stack);
+        console.error('='.repeat(60));
+        
+        const errorResult = {
+            success: false,
+            command: event.command || 'unknown',
+            error: error.message,
+            duration: `${duration}ms`,
+            timestamp: new Date().toISOString(),
+        };
+        
+        // Return error (don't throw) so Lambda doesn't retry
+        return errorResult;
+    }
+};
+

package/logs/logger.js

@@ -1,5 +1,4 @@
 const util = require('util');
-const aws = require('aws-sdk');
 
 // Except in some outlier circumstances, for example steam or event error handlers, this should be the only place that calls `console.*`.  That way, this file can be modified to log everything properly on a variety of platforms because all the logging code is here in one place.
 /* eslint-disable no-console */
@@ -7,9 +6,6 @@ const aws = require('aws-sdk');
 const logs = [];
 let flushCalled = false;
 
-// Log AWS SDK calls
-aws.config.logger = { log: debug };
-
 function debug(...messages) {
     if (messages.length) {
         const date = new Date();

package/package.json

@@ -1,8 +1,11 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.461.ec909cf.0",
+    "version": "2.0.0--canary.461.7b36f0f.0",
     "dependencies": {
+        "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
+        "@aws-sdk/client-kms": "^3.588.0",
+        "@aws-sdk/client-sqs": "^3.588.0",
         "@hapi/boom": "^10.0.1",
         "bcryptjs": "^2.4.3",
         "body-parser": "^1.20.2",
@@ -23,7 +26,6 @@
     },
     "peerDependencies": {
         "@prisma/client": "^6.16.3",
-        "aws-sdk": "^2.1200.0",
         "prisma": "^6.16.3"
     },
     "peerDependenciesMeta": {
@@ -32,15 +34,12 @@
         },
         "prisma": {
             "optional": true
-        },
-        "aws-sdk": {
-            "optional": true
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.461.ec909cf.0",
-        "@friggframework/prettier-config": "2.0.0--canary.461.ec909cf.0",
-        "@friggframework/test": "2.0.0--canary.461.ec909cf.0",
+        "@friggframework/eslint-config": "2.0.0--canary.461.7b36f0f.0",
+        "@friggframework/prettier-config": "2.0.0--canary.461.7b36f0f.0",
+        "@friggframework/test": "2.0.0--canary.461.7b36f0f.0",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -80,5 +79,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "ec909cf5076fa52ca3e914ee671a1c13c2cb11ee"
+    "gitHead": "7b36f0f437980499b06c66adc4ddbc3e80f6d8e6"
 }

package/queues/queuer-util.js

@@ -1,5 +1,6 @@
 const { v4: uuid } = require('uuid');
-const AWS = require('aws-sdk');
+const { SQSClient, SendMessageCommand, SendMessageBatchCommand } = require('@aws-sdk/client-sqs');
+
 const awsConfigOptions = () => {
     const config = {};
     if (process.env.IS_OFFLINE) {
@@ -10,18 +11,17 @@ const awsConfigOptions = () => {
     }
     return config;
 };
-AWS.config.update(awsConfigOptions());
-const sqs = new AWS.SQS();
+
+const sqs = new SQSClient(awsConfigOptions());
 
 const QueuerUtil = {
     send: async (message, queueUrl) => {
         console.log(`Enqueuing message to SQS queue ${queueUrl}`);
-        return sqs
-            .sendMessage({
-                MessageBody: JSON.stringify(message),
-                QueueUrl: queueUrl,
-            })
-            .promise();
+        const command = new SendMessageCommand({
+            MessageBody: JSON.stringify(message),
+            QueueUrl: queueUrl,
+        });
+        return sqs.send(command);
     },
 
     batchSend: async (entries = [], queueUrl) => {
@@ -39,12 +39,11 @@ const QueuerUtil = {
             // Sends 10, then purges the buffer
             if (buffer.length === batchSize) {
                 console.log('Buffer at 10, sending batch');
-                await sqs
-                    .sendMessageBatch({
-                        Entries: buffer,
-                        QueueUrl: queueUrl,
-                    })
-                    .promise();
+                const command = new SendMessageBatchCommand({
+                    Entries: buffer,
+                    QueueUrl: queueUrl,
+                });
+                await sqs.send(command);
                 // Purge the buffer
                 buffer.splice(0, buffer.length);
             }
@@ -54,12 +53,11 @@ const QueuerUtil = {
         // If any remaining entries under 10 are left in the buffer, send and return
         if (buffer.length > 0) {
             console.log(buffer);
-            return sqs
-                .sendMessageBatch({
-                    Entries: buffer,
-                    QueueUrl: queueUrl,
-                })
-                .promise();
+            const command = new SendMessageBatchCommand({
+                Entries: buffer,
+                QueueUrl: queueUrl,
+            });
+            return sqs.send(command);
         }
 
         // If we're exact... just return an empty object for now

package/queues/queuer-util.test.js

@@ -0,0 +1,132 @@
+/**
+ * Tests for QueuerUtil - AWS SDK v3 Migration
+ * 
+ * Tests SQS operations using aws-sdk-client-mock
+ */
+
+const { mockClient } = require('aws-sdk-client-mock');
+const { SQSClient, SendMessageCommand, SendMessageBatchCommand } = require('@aws-sdk/client-sqs');
+const { QueuerUtil } = require('./queuer-util');
+
+describe('QueuerUtil - AWS SDK v3', () => {
+    let sqsMock;
+
+    beforeEach(() => {
+        sqsMock = mockClient(SQSClient);
+        jest.clearAllMocks();
+    });
+
+    afterEach(() => {
+        sqsMock.reset();
+    });
+
+    describe('send()', () => {
+        it('should send single message to SQS', async () => {
+            sqsMock.on(SendMessageCommand).resolves({ 
+                MessageId: 'test-message-id-123' 
+            });
+
+            const message = { test: 'data', id: 1 };
+            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+
+            const result = await QueuerUtil.send(message, queueUrl);
+
+            expect(result.MessageId).toBe('test-message-id-123');
+            expect(sqsMock.calls()).toHaveLength(1);
+            
+            const call = sqsMock.call(0);
+            expect(call.args[0].input).toMatchObject({
+                MessageBody: JSON.stringify(message),
+                QueueUrl: queueUrl,
+            });
+        });
+
+        it('should handle SQS errors', async () => {
+            sqsMock.on(SendMessageCommand).rejects(new Error('SQS Error'));
+
+            const message = { test: 'data' };
+            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+
+            await expect(QueuerUtil.send(message, queueUrl)).rejects.toThrow('SQS Error');
+        });
+    });
+
+    describe('batchSend()', () => {
+        it('should send batch of messages to SQS', async () => {
+            sqsMock.on(SendMessageBatchCommand).resolves({ 
+                Successful: [{ MessageId: 'msg-1' }],
+                Failed: []
+            });
+
+            const entries = Array(5).fill().map((_, i) => ({ data: `test-${i}` }));
+            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+
+            const result = await QueuerUtil.batchSend(entries, queueUrl);
+
+            expect(sqsMock.calls()).toHaveLength(1);
+            
+            const call = sqsMock.call(0);
+            expect(call.args[0].input.Entries).toHaveLength(5);
+            expect(call.args[0].input.QueueUrl).toBe(queueUrl);
+        });
+
+        it('should send multiple batches for large entry sets (10 per batch)', async () => {
+            sqsMock.on(SendMessageBatchCommand).resolves({ 
+                Successful: [],
+                Failed: []
+            });
+
+            const entries = Array(25).fill().map((_, i) => ({ data: `test-${i}` }));
+            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+
+            await QueuerUtil.batchSend(entries, queueUrl);
+
+            // Should send 3 batches (10 + 10 + 5)
+            expect(sqsMock.calls()).toHaveLength(3);
+            
+            expect(sqsMock.call(0).args[0].input.Entries).toHaveLength(10);
+            expect(sqsMock.call(1).args[0].input.Entries).toHaveLength(10);
+            expect(sqsMock.call(2).args[0].input.Entries).toHaveLength(5);
+        });
+
+        it('should handle empty entries array', async () => {
+            const result = await QueuerUtil.batchSend([], 'https://queue-url');
+
+            expect(result).toEqual({});
+            expect(sqsMock.calls()).toHaveLength(0);
+        });
+
+        it('should send exact batch of 10 without remainder', async () => {
+            sqsMock.on(SendMessageBatchCommand).resolves({ 
+                Successful: [],
+                Failed: []
+            });
+
+            const entries = Array(10).fill().map((_, i) => ({ data: `test-${i}` }));
+            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+
+            const result = await QueuerUtil.batchSend(entries, queueUrl);
+
+            expect(sqsMock.calls()).toHaveLength(1);
+            expect(result).toEqual({});  // Returns empty object when exact batch
+        });
+
+        it('should generate unique IDs for each entry', async () => {
+            sqsMock.on(SendMessageBatchCommand).resolves({ 
+                Successful: [],
+                Failed: []
+            });
+
+            const entries = [{ data: 'test-1' }, { data: 'test-2' }];
+            const queueUrl = 'https://sqs.us-east-1.amazonaws.com/123456789/test-queue';
+
+            await QueuerUtil.batchSend(entries, queueUrl);
+
+            const sentEntries = sqsMock.call(0).args[0].input.Entries;
+            expect(sentEntries[0].Id).toBeDefined();
+            expect(sentEntries[1].Id).toBeDefined();
+            expect(sentEntries[0].Id).not.toBe(sentEntries[1].Id);
+        });
+    });
+});
+

package/types/core/index.d.ts

@@ -1,5 +1,5 @@
 declare module "@friggframework/core" {
-  import { SQS } from "aws-sdk";
+  import type { SendMessageCommandInput } from "@aws-sdk/client-sqs";
 
   export class Delegate implements IFriggDelegate {
     delegate: any;
@@ -50,5 +50,5 @@ declare module "@friggframework/core" {
     QueueOwnerAWSAccountId?: string;
   };
 
-  type SendSQSMessageParams = SQS.SendMessageRequest;
+  type SendSQSMessageParams = SendMessageCommandInput;
 }

package/websocket/repositories/websocket-connection-repository-mongo.js

@@ -1,5 +1,8 @@
 const { prisma } = require('../../database/prisma');
-const AWS = require('aws-sdk');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
 const {
     WebsocketConnectionRepositoryInterface,
 } = require('./websocket-connection-repository-interface');
@@ -74,20 +77,18 @@ class WebsocketConnectionRepositoryMongo extends WebsocketConnectionRepositoryIn
             return connections.map((conn) => ({
                 connectionId: conn.connectionId,
                 send: async (data) => {
-                    const apigwManagementApi = new AWS.ApiGatewayManagementApi({
-                        apiVersion: '2018-11-29',
+                    const apigwManagementApi = new ApiGatewayManagementApiClient({
                         endpoint: process.env.WEBSOCKET_API_ENDPOINT,
                     });
 
                     try {
-                        await apigwManagementApi
-                            .postToConnection({
-                                ConnectionId: conn.connectionId,
-                                Data: JSON.stringify(data),
-                            })
-                            .promise();
+                        const command = new PostToConnectionCommand({
+                            ConnectionId: conn.connectionId,
+                            Data: JSON.stringify(data),
+                        });
+                        await apigwManagementApi.send(command);
                     } catch (error) {
-                        if (error.statusCode === 410) {
+                        if (error.statusCode === 410 || error.$metadata?.httpStatusCode === 410) {
                             console.log(
                                 `Stale connection ${conn.connectionId}`
                             );

package/websocket/repositories/websocket-connection-repository-postgres.js

@@ -1,5 +1,8 @@
 const { prisma } = require('../../database/prisma');
-const AWS = require('aws-sdk');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
 const {
     WebsocketConnectionRepositoryInterface,
 } = require('./websocket-connection-repository-interface');
@@ -108,20 +111,18 @@ class WebsocketConnectionRepositoryPostgres extends WebsocketConnectionRepositor
             return connections.map((conn) => ({
                 connectionId: conn.connectionId,
                 send: async (data) => {
-                    const apigwManagementApi = new AWS.ApiGatewayManagementApi({
-                        apiVersion: '2018-11-29',
+                    const apigwManagementApi = new ApiGatewayManagementApiClient({
                         endpoint: process.env.WEBSOCKET_API_ENDPOINT,
                     });
 
                     try {
-                        await apigwManagementApi
-                            .postToConnection({
-                                ConnectionId: conn.connectionId,
-                                Data: JSON.stringify(data),
-                            })
-                            .promise();
+                        const command = new PostToConnectionCommand({
+                            ConnectionId: conn.connectionId,
+                            Data: JSON.stringify(data),
+                        });
+                        await apigwManagementApi.send(command);
                     } catch (error) {
-                        if (error.statusCode === 410) {
+                        if (error.statusCode === 410 || error.$metadata?.httpStatusCode === 410) {
                             console.log(
                                 `Stale connection ${conn.connectionId}`
                             );

package/websocket/repositories/websocket-connection-repository.js

@@ -1,5 +1,8 @@
 const { prisma } = require('../../database/prisma');
-const AWS = require('aws-sdk');
+const {
+    ApiGatewayManagementApiClient,
+    PostToConnectionCommand,
+} = require('@aws-sdk/client-apigatewaymanagementapi');
 const {
     WebsocketConnectionRepositoryInterface,
 } = require('./websocket-connection-repository-interface');
@@ -79,20 +82,18 @@ class WebsocketConnectionRepository extends WebsocketConnectionRepositoryInterfa
             return connections.map((conn) => ({
                 connectionId: conn.connectionId,
                 send: async (data) => {
-                    const apigwManagementApi = new AWS.ApiGatewayManagementApi({
-                        apiVersion: '2018-11-29',
+                    const apigwManagementApi = new ApiGatewayManagementApiClient({
                         endpoint: process.env.WEBSOCKET_API_ENDPOINT,
                     });
 
                     try {
-                        await apigwManagementApi
-                            .postToConnection({
-                                ConnectionId: conn.connectionId,
-                                Data: JSON.stringify(data),
-                            })
-                            .promise();
+                        const command = new PostToConnectionCommand({
+                            ConnectionId: conn.connectionId,
+                            Data: JSON.stringify(data),
+                        });
+                        await apigwManagementApi.send(command);
                     } catch (error) {
-                        if (error.statusCode === 410) {
+                        if (error.statusCode === 410 || error.$metadata?.httpStatusCode === 410) {
                             console.log(
                                 `Stale connection ${conn.connectionId}`
                             );

package/websocket/repositories/websocket-connection-repository.test.js

@@ -0,0 +1,227 @@
+/**
+ * Tests for WebSocket Connection Repository - AWS SDK v3 Migration
+ * 
+ * Tests API Gateway Management API operations using aws-sdk-client-mock
+ */
+
+const { mockClient } = require('aws-sdk-client-mock');
+const { ApiGatewayManagementApiClient, PostToConnectionCommand } = require('@aws-sdk/client-apigatewaymanagementapi');
+const { WebsocketConnectionRepository } = require('./websocket-connection-repository');
+
+// Mock Prisma
+jest.mock('../../database/prisma', () => ({
+    prisma: {
+        websocketConnection: {
+            create: jest.fn(),
+            delete: jest.fn(),
+            findMany: jest.fn(),
+            findFirst: jest.fn(),
+            findUnique: jest.fn(),
+            deleteMany: jest.fn(),
+        },
+    },
+}));
+
+const { prisma } = require('../../database/prisma');
+
+describe('WebsocketConnectionRepository - AWS SDK v3', () => {
+    let apiGatewayMock;
+    let repository;
+    const originalEnv = process.env;
+
+    beforeEach(() => {
+        apiGatewayMock = mockClient(ApiGatewayManagementApiClient);
+        repository = new WebsocketConnectionRepository();
+        jest.clearAllMocks();
+        process.env = { 
+            ...originalEnv, 
+            WEBSOCKET_API_ENDPOINT: 'https://test.execute-api.us-east-1.amazonaws.com/dev'
+        };
+    });
+
+    afterEach(() => {
+        apiGatewayMock.reset();
+        process.env = originalEnv;
+    });
+
+    describe('createConnection()', () => {
+        it('should create websocket connection record', async () => {
+            const mockConnection = { id: '1', connectionId: 'test-connection-123' };
+            prisma.websocketConnection.create.mockResolvedValue(mockConnection);
+
+            const result = await repository.createConnection('test-connection-123');
+
+            expect(result).toEqual(mockConnection);
+            expect(prisma.websocketConnection.create).toHaveBeenCalledWith({
+                data: { connectionId: 'test-connection-123' },
+            });
+        });
+    });
+
+    describe('deleteConnection()', () => {
+        it('should delete websocket connection', async () => {
+            prisma.websocketConnection.delete.mockResolvedValue({});
+
+            const result = await repository.deleteConnection('test-connection-123');
+
+            expect(result).toEqual({ acknowledged: true, deletedCount: 1 });
+            expect(prisma.websocketConnection.delete).toHaveBeenCalledWith({
+                where: { connectionId: 'test-connection-123' },
+            });
+        });
+
+        it('should handle connection not found', async () => {
+            const error = new Error('Record not found');
+            error.code = 'P2025';
+            prisma.websocketConnection.delete.mockRejectedValue(error);
+
+            const result = await repository.deleteConnection('nonexistent');
+
+            expect(result).toEqual({ acknowledged: true, deletedCount: 0 });
+        });
+    });
+
+    describe('getActiveConnections()', () => {
+        it('should return empty array if no WEBSOCKET_API_ENDPOINT', async () => {
+            delete process.env.WEBSOCKET_API_ENDPOINT;
+
+            const result = await repository.getActiveConnections();
+
+            expect(result).toEqual([]);
+            expect(prisma.websocketConnection.findMany).not.toHaveBeenCalled();
+        });
+
+        it('should get active connections with send capability', async () => {
+            prisma.websocketConnection.findMany.mockResolvedValue([
+                { connectionId: 'conn-1' },
+                { connectionId: 'conn-2' },
+            ]);
+
+            apiGatewayMock.on(PostToConnectionCommand).resolves({});
+
+            const connections = await repository.getActiveConnections();
+
+            expect(connections).toHaveLength(2);
+            expect(connections[0].connectionId).toBe('conn-1');
+            expect(connections[1].connectionId).toBe('conn-2');
+            expect(typeof connections[0].send).toBe('function');
+        });
+
+        it('should send data through API Gateway Management API', async () => {
+            prisma.websocketConnection.findMany.mockResolvedValue([
+                { connectionId: 'conn-test' },
+            ]);
+
+            apiGatewayMock.on(PostToConnectionCommand).resolves({});
+
+            const connections = await repository.getActiveConnections();
+            await connections[0].send({ message: 'hello' });
+
+            expect(apiGatewayMock.calls()).toHaveLength(1);
+            
+            const call = apiGatewayMock.call(0);
+            expect(call.args[0].input).toMatchObject({
+                ConnectionId: 'conn-test',
+                Data: JSON.stringify({ message: 'hello' }),
+            });
+        });
+
+        it('should delete stale connection on 410 error', async () => {
+            prisma.websocketConnection.findMany.mockResolvedValue([
+                { connectionId: 'stale-conn' },
+            ]);
+
+            const error = new Error('Gone');
+            error.statusCode = 410;
+            apiGatewayMock.on(PostToConnectionCommand).rejects(error);
+
+            prisma.websocketConnection.deleteMany.mockResolvedValue({ count: 1 });
+
+            const connections = await repository.getActiveConnections();
+            await connections[0].send({ message: 'test' });
+
+            // Should have called deleteMany to remove stale connection
+            expect(prisma.websocketConnection.deleteMany).toHaveBeenCalledWith({
+                where: { connectionId: 'stale-conn' },
+            });
+        });
+
+        it('should delete stale connection on 410 error (v3 metadata format)', async () => {
+            prisma.websocketConnection.findMany.mockResolvedValue([
+                { connectionId: 'stale-conn' },
+            ]);
+
+            const error = new Error('Gone');
+            error.$metadata = { httpStatusCode: 410 };
+            apiGatewayMock.on(PostToConnectionCommand).rejects(error);
+
+            prisma.websocketConnection.deleteMany.mockResolvedValue({ count: 1 });
+
+            const connections = await repository.getActiveConnections();
+            await connections[0].send({ message: 'test' });
+
+            expect(prisma.websocketConnection.deleteMany).toHaveBeenCalledWith({
+                where: { connectionId: 'stale-conn' },
+            });
+        });
+
+        it('should throw non-410 errors', async () => {
+            prisma.websocketConnection.findMany.mockResolvedValue([
+                { connectionId: 'conn-1' },
+            ]);
+
+            apiGatewayMock.on(PostToConnectionCommand).rejects(new Error('Network error'));
+
+            const connections = await repository.getActiveConnections();
+
+            await expect(connections[0].send({ message: 'test' })).rejects.toThrow('Network error');
+        });
+    });
+
+    describe('findConnection()', () => {
+        it('should find connection by connectionId', async () => {
+            const mockConnection = { id: '1', connectionId: 'conn-123' };
+            prisma.websocketConnection.findFirst.mockResolvedValue(mockConnection);
+
+            const result = await repository.findConnection('conn-123');
+
+            expect(result).toEqual(mockConnection);
+            expect(prisma.websocketConnection.findFirst).toHaveBeenCalledWith({
+                where: { connectionId: 'conn-123' },
+            });
+        });
+
+        it('should return null if not found', async () => {
+            prisma.websocketConnection.findFirst.mockResolvedValue(null);
+
+            const result = await repository.findConnection('nonexistent');
+
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('getAllConnections()', () => {
+        it('should get all connections', async () => {
+            const mockConnections = [
+                { id: '1', connectionId: 'conn-1' },
+                { id: '2', connectionId: 'conn-2' },
+            ];
+            prisma.websocketConnection.findMany.mockResolvedValue(mockConnections);
+
+            const result = await repository.getAllConnections();
+
+            expect(result).toEqual(mockConnections);
+        });
+    });
+
+    describe('deleteAllConnections()', () => {
+        it('should delete all connections', async () => {
+            prisma.websocketConnection.deleteMany.mockResolvedValue({ count: 5 });
+
+            const result = await repository.deleteAllConnections();
+
+            expect(result).toEqual({ acknowledged: true, deletedCount: 5 });
+        });
+    });
+});
+