@friggframework/core 2.0.0-next.5 → 2.0.0-next.50

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/create-handler.js

@@ -1,7 +1,7 @@
 // This line should be at the top of the webpacked output, so be sure to require createHandler first in any handlers.  "Soon" sourcemaps will be built into Node... after that, this package won't be needed.
-require('source-map-support').install();
+// REMOVING FOR NOW UNTIL WE ADD WEBPACK BACK IN
+// require('source-map-support').install();
 
-const { connectToDatabase } = require('../database/mongo');
 const { initDebugLog, flushDebugLog } = require('../logs');
 const { secretsToEnv } = require('./secrets-to-env');
 
@@ -10,7 +10,6 @@ const createHandler = (optionByName = {}) => {
         eventName = 'Event',
         isUserFacingResponse = true,
         method,
-        shouldUseDatabase = true,
     } = optionByName;
 
     if (!method) {
@@ -33,10 +32,6 @@ const createHandler = (optionByName = {}) => {
             // Helps mongoose reuse the connection.  Lowers response times.
             context.callbackWaitsForEmptyEventLoop = false;
 
-            if (shouldUseDatabase) {
-                await connectToDatabase();
-            }
-
             // Run the Lambda
             return await method(event, context);
         } catch (error) {

package/credential/repositories/credential-repository-factory.js

@@ -0,0 +1,47 @@
+const { CredentialRepositoryMongo } = require('./credential-repository-mongo');
+const {
+    CredentialRepositoryPostgres,
+} = require('./credential-repository-postgres');
+const config = require('../../database/config');
+
+/**
+ * Credential Repository Factory
+ * Creates the appropriate repository adapter based on database type
+ *
+ * Database-specific implementations:
+ * - MongoDB: Uses String IDs (ObjectId), no conversion needed
+ * - PostgreSQL: Uses Int IDs, converts String ↔ Int
+ *
+ * All repository methods return String IDs regardless of database type,
+ * ensuring application layer consistency.
+ *
+ * Usage:
+ * ```javascript
+ * const repository = createCredentialRepository();
+ * ```
+ *
+ * @returns {CredentialRepositoryInterface} Configured repository adapter
+ */
+function createCredentialRepository() {
+    const dbType = config.DB_TYPE;
+
+    switch (dbType) {
+        case 'mongodb':
+            return new CredentialRepositoryMongo();
+
+        case 'postgresql':
+            return new CredentialRepositoryPostgres();
+
+        default:
+            throw new Error(
+                `Unsupported database type: ${dbType}. Supported values: 'mongodb', 'postgresql'`
+            );
+    }
+}
+
+module.exports = {
+    createCredentialRepository,
+    // Export adapters for direct testing
+    CredentialRepositoryMongo,
+    CredentialRepositoryPostgres,
+};

package/credential/repositories/credential-repository-interface.js

@@ -0,0 +1,98 @@
+/**
+ * Credential Repository Interface
+ * Abstract base class defining the contract for credential persistence adapters
+ *
+ * This follows the Port in Hexagonal Architecture:
+ * - Domain layer depends on this abstraction
+ * - Concrete adapters implement this interface
+ * - Use cases receive repositories via dependency injection
+ *
+ * Note: Currently, Credential model has identical structure across MongoDB and PostgreSQL,
+ * so CredentialRepository serves both. This interface exists for consistency and
+ * future-proofing if database-specific implementations become needed.
+ *
+ * @abstract
+ */
+class CredentialRepositoryInterface {
+    /**
+     * Find credential by ID
+     *
+     * @param {string|number} id - Credential ID
+     * @returns {Promise<Object|null>} Credential object or null
+     * @abstract
+     */
+    async findCredentialById(id) {
+        throw new Error(
+            'Method findCredentialById must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Update authentication status
+     *
+     * @param {string|number} credentialId - Credential ID
+     * @param {boolean} authIsValid - Authentication validity status
+     * @returns {Promise<Object>} Update result
+     * @abstract
+     */
+    async updateAuthenticationStatus(credentialId, authIsValid) {
+        throw new Error(
+            'Method updateAuthenticationStatus must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Permanently remove a credential document
+     *
+     * @param {string|number} credentialId - Credential ID
+     * @returns {Promise<Object>} Deletion result
+     * @abstract
+     */
+    async deleteCredentialById(credentialId) {
+        throw new Error(
+            'Method deleteCredentialById must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Create or update credential matching identifiers
+     *
+     * @param {{identifiers: Object, details: Object}} credentialDetails
+     * @returns {Promise<Object>} The persisted credential
+     * @abstract
+     */
+    async upsertCredential(credentialDetails) {
+        throw new Error(
+            'Method upsertCredential must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Find a credential by filter criteria
+     *
+     * @param {Object} filter - Filter criteria
+     * @returns {Promise<Object|null>} Credential object or null if not found
+     * @abstract
+     */
+    async findCredential(filter) {
+        throw new Error(
+            'Method findCredential must be implemented by subclass'
+        );
+    }
+
+    /**
+     * Update a credential by ID
+     *
+     * @param {string|number} credentialId - Credential ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object|null>} Updated credential object or null if not found
+     * @abstract
+     */
+    async updateCredential(credentialId, updates) {
+        throw new Error(
+            'Method updateCredential must be implemented by subclass'
+        );
+    }
+}
+
+module.exports = { CredentialRepositoryInterface };

package/credential/repositories/credential-repository-mongo.js

@@ -0,0 +1,307 @@
+const { prisma } = require('../../database/prisma');
+const {
+    CredentialRepositoryInterface,
+} = require('./credential-repository-interface');
+
+/**
+ * MongoDB Credential Repository Adapter
+ * Handles OAuth credentials and API tokens persistence with MongoDB
+ *
+ * MongoDB-specific characteristics:
+ * - Uses String IDs (ObjectId)
+ * - No ID conversion needed (IDs are already strings)
+ * - Dynamic schema support via JSON field
+ */
+class CredentialRepositoryMongo extends CredentialRepositoryInterface {
+    constructor() {
+        super();
+        this.prisma = prisma;
+    }
+
+    /**
+     * Find credential by ID
+     * Replaces: Credential.findById(id)
+     *
+     * @param {string} id - Credential ID
+     * @returns {Promise<Object|null>} Credential object or null
+     */
+    async findCredentialById(id) {
+        const credential = await this.prisma.credential.findUnique({
+            where: { id },
+        });
+
+        if (!credential) {
+            return null;
+        }
+
+        // Extract data from JSON field
+        const data = credential.data || {};
+
+        return {
+            _id: credential.id,
+            id: credential.id,
+            user: credential.userId,
+            userId: credential.userId,
+            externalId: credential.externalId,
+            authIsValid: credential.authIsValid,
+            ...data, // Spread OAuth tokens from JSON field
+        };
+    }
+
+    /**
+     * Update authentication status
+     * Replaces: Credential.updateOne({ _id: credentialId }, { $set: { authIsValid } })
+     *
+     * @param {string} credentialId - Credential ID
+     * @param {boolean} authIsValid - Authentication validity status
+     * @returns {Promise<Object>} Update result
+     */
+    async updateAuthenticationStatus(credentialId, authIsValid) {
+        await this.prisma.credential.update({
+            where: { id: credentialId },
+            data: { authIsValid },
+        });
+
+        return { acknowledged: true, modifiedCount: 1 };
+    }
+
+    /**
+     * Permanently remove a credential document
+     * Replaces: Credential.deleteOne({ _id: credentialId })
+     *
+     * @param {string} credentialId - Credential ID
+     * @returns {Promise<Object>} Deletion result
+     */
+    async deleteCredentialById(credentialId) {
+        try {
+            await this.prisma.credential.delete({
+                where: { id: credentialId },
+            });
+            return { acknowledged: true, deletedCount: 1 };
+        } catch (error) {
+            if (error.code === 'P2025') {
+                // Record not found
+                return { acknowledged: true, deletedCount: 0 };
+            }
+            throw error;
+        }
+    }
+
+    /**
+     * Create or update credential matching identifiers
+     * Replaces: Credential.findOneAndUpdate(query, update, { upsert: true })
+     *
+     * @param {{identifiers: Object, details: Object}} credentialDetails
+     * @returns {Promise<Object>} The persisted credential
+     */
+    async upsertCredential(credentialDetails) {
+        const { identifiers, details } = credentialDetails;
+        if (!identifiers)
+            throw new Error('identifiers required to upsert credential');
+
+        if (!identifiers.user && !identifiers.userId) {
+            throw new Error('user or userId required in identifiers');
+        }
+        if (!identifiers.externalId) {
+            throw new Error(
+                'externalId required in identifiers to prevent credential collision. ' +
+                'When multiple credentials exist for the same user, both userId and externalId ' +
+                'are needed to uniquely identify which credential to update.'
+            );
+        }
+
+        // Build where clause from identifiers
+        const where = this._convertIdentifiersToWhere(identifiers);
+
+        // Separate schema fields from dynamic OAuth data
+        const {
+            user,
+            userId,
+            externalId,
+            authIsValid,
+            
+            ...oauthData
+        } = details;
+
+        // Find existing credential
+        const existing = await this.prisma.credential.findFirst({ where });
+
+        if (existing) {
+            // Update existing - merge OAuth data into existing data JSON
+            const mergedData = { ...(existing.data || {}), ...oauthData };
+
+            const updated = await this.prisma.credential.update({
+                where: { id: existing.id },
+                data: {
+                    userId: userId || user || existing.userId,
+                    externalId:
+                        externalId !== undefined
+                            ? externalId
+                            : existing.externalId,
+                    authIsValid:
+                        authIsValid !== undefined
+                            ? authIsValid
+                            : existing.authIsValid,
+                    data: mergedData,
+                },
+            });
+
+            return {
+                id: updated.id,
+                externalId: updated.externalId,
+                userId: updated.userId,
+                authIsValid: updated.authIsValid,
+                ...(updated.data || {}),
+            };
+        }
+
+        // Create new credential
+        const created = await this.prisma.credential.create({
+            data: {
+                userId: userId || user,
+                externalId,
+                authIsValid: authIsValid,
+                
+                data: oauthData,
+            },
+        });
+
+        return {
+            id: created.id,
+            externalId: created.externalId,
+            userId: created.userId,
+            authIsValid: created.authIsValid,
+            ...(created.data || {}),
+        };
+    }
+
+    /**
+     * Find a credential by filter criteria
+     * Replaces: Credential.findOne(query)
+     *
+     * @param {Object} filter
+     * @param {string} [filter.userId] - User ID
+     * @param {string} [filter.externalId] - External ID
+     * @param {string} [filter.credentialId] - Credential ID
+     * @returns {Promise<Object|null>} Credential object or null if not found
+     */
+    async findCredential(filter) {
+        const where = this._convertFilterToWhere(filter);
+
+        const credential = await this.prisma.credential.findFirst({
+            where,
+        });
+
+        if (!credential) {
+            return null;
+        }
+
+        const data = credential.data || {};
+
+        return {
+            id: credential.id,
+            userId: credential.userId,
+            externalId: credential.externalId,
+            authIsValid: credential.authIsValid,
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            domain: data.domain,
+            ...data,
+        };
+    }
+
+    /**
+     * Update a credential by ID
+     * Replaces: Credential.findByIdAndUpdate(credentialId, { $set: updates })
+     *
+     * @param {string} credentialId - Credential ID
+     * @param {Object} updates - Fields to update
+     * @returns {Promise<Object|null>} Updated credential object or null if not found
+     */
+    async updateCredential(credentialId, updates) {
+        // Get existing credential to merge OAuth data
+        const existing = await this.prisma.credential.findUnique({
+            where: { id: credentialId },
+        });
+
+        if (!existing) {
+            return null;
+        }
+
+        // Separate schema fields from OAuth data
+        const {
+            user,
+            userId,
+            externalId,
+            authIsValid,
+            
+            ...oauthData
+        } = updates;
+
+        // Merge OAuth data with existing
+        const mergedData = { ...(existing.data || {}), ...oauthData };
+
+        const updated = await this.prisma.credential.update({
+            where: { id: credentialId },
+            data: {
+                userId: userId || user || existing.userId,
+                externalId:
+                    externalId !== undefined ? externalId : existing.externalId,
+                authIsValid:
+                    authIsValid !== undefined ? authIsValid : existing.authIsValid,
+                data: mergedData,
+            },
+        });
+
+        const data = updated.data || {};
+
+        return {
+            id: updated.id,
+            userId: updated.userId,
+            externalId: updated.externalId,
+            authIsValid: updated.authIsValid,
+            access_token: data.access_token,
+            refresh_token: data.refresh_token,
+            domain: data.domain,
+            ...data,
+        };
+    }
+
+    /**
+     * Convert identifiers to Prisma where clause
+     * @private
+     * @param {Object} identifiers - Identifier fields
+     * @returns {Object} Prisma where clause
+     */
+    _convertIdentifiersToWhere(identifiers) {
+        const where = {};
+
+        if (identifiers._id) where.id = identifiers._id;
+        if (identifiers.id) where.id = identifiers.id;
+        if (identifiers.user) where.userId = identifiers.user;
+        if (identifiers.userId) where.userId = identifiers.userId;
+        if (identifiers.externalId) where.externalId = identifiers.externalId;
+
+        return where;
+    }
+
+    /**
+     * Convert filter to Prisma where clause
+     * @private
+     * @param {Object} filter - Filter criteria
+     * @returns {Object} Prisma where clause
+     */
+    _convertFilterToWhere(filter) {
+        const where = {};
+
+        if (filter.credentialId) where.id = filter.credentialId;
+        if (filter.id) where.id = filter.id;
+        if (filter.user) where.userId = filter.user;
+        if (filter.userId) where.userId = filter.userId;
+        if (filter.externalId) where.externalId = filter.externalId;
+
+        return where;
+    }
+}
+
+module.exports = { CredentialRepositoryMongo };