@friggframework/core 2.0.0--canary.522.cbd3d5a.0 → 2.0.0--canary.517.35ee143.0

package/core/Worker.js

@@ -1,8 +1,4 @@
-const {
-    SQSClient,
-    GetQueueUrlCommand,
-    SendMessageCommand,
-} = require('@aws-sdk/client-sqs');
+const { SQSClient, GetQueueUrlCommand, SendMessageCommand } = require('@aws-sdk/client-sqs');
 const _ = require('lodash');
 const { RequiredPropertyError } = require('../errors');
 const { get } = require('../assertions');

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

@@ -3,7 +3,6 @@ const {
     toObjectId,
     fromObjectId,
     findOne,
-    findMany,
     insertOne,
     updateOne,
     deleteOne,
@@ -107,10 +106,7 @@ class CredentialRepositoryDocumentDB extends CredentialRepositoryInterface {
             const updateDocument = {
                 userId: existing.userId,
                 externalId: existing.externalId,
-                authIsValid:
-                    authIsValid !== undefined
-                        ? authIsValid
-                        : existing.authIsValid,
+                authIsValid: authIsValid !== undefined ? authIsValid : existing.authIsValid,
                 data: mergedData,
                 updatedAt: now,
             };
@@ -176,50 +172,8 @@ class CredentialRepositoryDocumentDB extends CredentialRepositoryInterface {
         return this._mapCredential(decryptedCredential);
     }
 
-    /**
-     * Find credential(s) by filter criteria
-     *
-     * When filter includes only userId, returns an array of all credentials for that user
-     * When filter includes credentialId or externalId, returns a single credential or null
-     *
-     * @param {Object} filter
-     * @param {string} [filter.userId] - User ID
-     * @param {string} [filter.externalId] - External ID
-     * @param {string} [filter.credentialId] - Credential ID
-     * @returns {Promise<Array|Object|null>} Credential array, single credential, or null
-     */
     async findCredential(filter) {
         const query = this._buildFilter(filter);
-
-        // If filtering by userId only, return all credentials for that user
-        const hasOnlyUserId =
-            filter.userId &&
-            !filter.credentialId &&
-            !filter.externalId &&
-            !filter.id;
-
-        if (hasOnlyUserId) {
-            const credentials = await findMany(
-                this.prisma,
-                'Credential',
-                query
-            );
-
-            const decryptedCredentials = await Promise.all(
-                credentials.map(async (credential) => {
-                    const decrypted =
-                        await this.encryptionService.decryptFields(
-                            'Credential',
-                            credential
-                        );
-                    return this._mapCredentialWithMetadata(decrypted);
-                })
-            );
-
-            return decryptedCredentials;
-        }
-
-        // Otherwise, find single credential
         const credential = await findOne(this.prisma, 'Credential', query);
         if (!credential) return null;
 
@@ -345,30 +299,6 @@ class CredentialRepositoryDocumentDB extends CredentialRepositoryInterface {
             ...data,
         };
     }
-
-    /**
-     * Map credential document with metadata (for list views)
-     * Includes timestamps and additional fields needed by API
-     * @private
-     */
-    _mapCredentialWithMetadata(doc) {
-        const data = doc?.data || {};
-        const id = fromObjectId(doc?._id);
-        const userId = doc?.userId;
-        return {
-            id,
-            type: doc?.type,
-            userId,
-            externalId: doc?.externalId ?? null,
-            authIsValid: doc?.authIsValid ?? null,
-            entityCount: doc?.entityCount,
-            createdAt: doc?.createdAt,
-            updatedAt: doc?.updatedAt,
-            access_token: data.access_token,
-            refresh_token: data.refresh_token,
-            ...data,
-        };
-    }
 }
 
 module.exports = { CredentialRepositoryDocumentDB };

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

@@ -68,16 +68,10 @@ class CredentialRepositoryInterface {
     }
 
     /**
-     * Find credential(s) by filter criteria
-     *
-     * When filter includes only userId, returns an array of all credentials for that user
-     * When filter includes credentialId or externalId, returns a single credential or null
+     * Find a credential by filter criteria
      *
      * @param {Object} filter - Filter criteria
-     * @param {string} [filter.userId] - User ID
-     * @param {string} [filter.externalId] - External ID
-     * @param {string} [filter.credentialId] - Credential ID
-     * @returns {Promise<Array|Object|null>} Credential array, single credential, or null
+     * @returns {Promise<Object|null>} Credential object or null if not found
      * @abstract
      */
     async findCredential(filter) {

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

@@ -121,10 +121,7 @@ class CredentialRepositoryMongo extends CredentialRepositoryInterface {
                 data: {
                     userId: existing.userId,
                     externalId: existing.externalId,
-                    authIsValid:
-                        authIsValid !== undefined
-                            ? authIsValid
-                            : existing.authIsValid,
+                    authIsValid: authIsValid !== undefined ? authIsValid : existing.authIsValid,
                     data: mergedData,
                 },
             });
@@ -157,52 +154,18 @@ class CredentialRepositoryMongo extends CredentialRepositoryInterface {
     }
 
     /**
-     * Find credential(s) by filter criteria
-     * Replaces: Credential.find(query) or Credential.findOne(query)
-     *
-     * When filter includes only userId, returns an array of all credentials for that user
-     * When filter includes credentialId or externalId, returns a single credential or null
+     * 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<Array|Object|null>} Credential array, single credential, or null
+     * @returns {Promise<Object|null>} Credential object or null if not found
      */
     async findCredential(filter) {
         const where = this._convertFilterToWhere(filter);
 
-        // If filtering by userId only, return all credentials for that user
-        const hasOnlyUserId =
-            filter.userId &&
-            !filter.credentialId &&
-            !filter.externalId &&
-            !filter.id;
-
-        if (hasOnlyUserId) {
-            const credentials = await this.prisma.credential.findMany({
-                where,
-            });
-
-            return credentials.map((credential) => {
-                const data = credential.data || {};
-                return {
-                    id: credential.id,
-                    type: credential.type,
-                    userId: credential.userId,
-                    externalId: credential.externalId,
-                    authIsValid: credential.authIsValid,
-                    entityCount: credential.entityCount,
-                    createdAt: credential.createdAt,
-                    updatedAt: credential.updatedAt,
-                    access_token: data.access_token,
-                    refresh_token: data.refresh_token,
-                    ...data,
-                };
-            });
-        }
-
-        // Otherwise, find single credential
         const credential = await this.prisma.credential.findFirst({
             where,
         });
@@ -215,13 +178,9 @@ class CredentialRepositoryMongo extends CredentialRepositoryInterface {
 
         return {
             id: credential.id,
-            type: credential.type,
             userId: credential.userId,
             externalId: credential.externalId,
             authIsValid: credential.authIsValid,
-            entityCount: credential.entityCount,
-            createdAt: credential.createdAt,
-            updatedAt: credential.updatedAt,
             access_token: data.access_token,
             refresh_token: data.refresh_token,
             ...data,

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

@@ -139,10 +139,7 @@ class CredentialRepositoryPostgres extends CredentialRepositoryInterface {
                 data: {
                     userId: this._convertId(existing.userId),
                     externalId: existing.externalId,
-                    authIsValid:
-                        authIsValid !== undefined
-                            ? authIsValid
-                            : existing.authIsValid,
+                    authIsValid: authIsValid !== undefined ? authIsValid : existing.authIsValid,
                     data: mergedData,
                 },
             });
@@ -176,51 +173,17 @@ class CredentialRepositoryPostgres extends CredentialRepositoryInterface {
     }
 
     /**
-     * Find credential(s) by filter criteria
-     *
-     * When filter includes only userId, returns an array of all credentials for that user
-     * When filter includes credentialId or externalId, returns a single credential or null
+     * Find a credential by filter criteria
      *
      * @param {Object} filter
      * @param {string} [filter.userId] - User ID (string from application layer)
      * @param {string} [filter.externalId] - External ID
      * @param {string} [filter.credentialId] - Credential ID (string from application layer)
-     * @returns {Promise<Array|Object|null>} Credential array, single credential with string IDs, or null
+     * @returns {Promise<Object|null>} Credential object with string IDs or null if not found
      */
     async findCredential(filter) {
         const where = this._convertFilterToWhere(filter);
 
-        // If filtering by userId only, return all credentials for that user
-        const hasOnlyUserId =
-            filter.userId &&
-            !filter.credentialId &&
-            !filter.externalId &&
-            !filter.id;
-
-        if (hasOnlyUserId) {
-            const credentials = await this.prisma.credential.findMany({
-                where,
-            });
-
-            return credentials.map((credential) => {
-                const data = credential.data || {};
-                return {
-                    id: credential.id.toString(),
-                    type: credential.type,
-                    userId: credential.userId?.toString(),
-                    externalId: credential.externalId,
-                    authIsValid: credential.authIsValid,
-                    entityCount: credential.entityCount,
-                    createdAt: credential.createdAt,
-                    updatedAt: credential.updatedAt,
-                    access_token: data.access_token,
-                    refresh_token: data.refresh_token,
-                    ...data,
-                };
-            });
-        }
-
-        // Otherwise, find single credential
         const credential = await this.prisma.credential.findFirst({
             where,
         });
@@ -233,13 +196,9 @@ class CredentialRepositoryPostgres extends CredentialRepositoryInterface {
 
         return {
             id: credential.id.toString(),
-            type: credential.type,
             userId: credential.userId?.toString(),
             externalId: credential.externalId,
             authIsValid: credential.authIsValid,
-            entityCount: credential.entityCount,
-            createdAt: credential.createdAt,
-            updatedAt: credential.updatedAt,
             access_token: data.access_token,
             refresh_token: data.refresh_token,
             ...data,

package/credential/repositories/credential-repository.js

@@ -114,7 +114,7 @@ class CredentialRepository extends CredentialRepositoryInterface {
             userId,
             externalId,
             authIsValid,
-
+            
             ...oauthData
         } = details;
 
@@ -156,7 +156,7 @@ class CredentialRepository extends CredentialRepositoryInterface {
                 userId: userId || user,
                 externalId,
                 authIsValid: authIsValid,
-
+                
                 data: oauthData,
             },
         });
@@ -229,7 +229,7 @@ class CredentialRepository extends CredentialRepositoryInterface {
             userId,
             externalId,
             authIsValid,
-
+            
             ...oauthData
         } = updates;
 
@@ -243,9 +243,7 @@ class CredentialRepository extends CredentialRepositoryInterface {
                 externalId:
                     externalId !== undefined ? externalId : existing.externalId,
                 authIsValid:
-                    authIsValid !== undefined
-                        ? authIsValid
-                        : existing.authIsValid,
+                    authIsValid !== undefined ? authIsValid : existing.authIsValid,
                 data: mergedData,
             },
         });

package/credential/use-cases/get-credential-for-user.js

@@ -1,38 +1,20 @@
-const Boom = require('@hapi/boom');
-
-/**
- * Get Credential For User Use Case
- * Retrieves a single credential after verifying ownership
- *
- * Business Logic:
- * - Verify credential exists
- * - Verify credential belongs to user (authorization)
- * - Return credential
- */
 class GetCredentialForUser {
     constructor({ credentialRepository }) {
         this.credentialRepository = credentialRepository;
     }
 
-    /**
-     * Execute the use case
-     * @param {string} credentialId - Credential ID
-     * @param {string} userId - User ID (for ownership verification)
-     * @returns {Promise<Object>} Credential object
-     */
     async execute(credentialId, userId) {
         const credential = await this.credentialRepository.findCredentialById(
             credentialId
         );
 
         if (!credential) {
-            throw Boom.notFound(`Credential ${credentialId} not found`);
+            throw new Error(`Credential with id ${credentialId} not found`);
         }
 
-        // Verify ownership - compare as strings to handle both MongoDB and PostgreSQL
         if (credential.userId.toString() !== userId.toString()) {
-            throw Boom.forbidden(
-                'You do not have permission to access this credential'
+            throw new Error(
+                `Credential ${credentialId} does not belong to user ${userId}`
             );
         }
 

package/credential/use-cases/update-authentication-status.js

@@ -8,11 +8,8 @@ class UpdateAuthenticationStatus {
      * @param {boolean} authIsValid
      */
     async execute(credentialId, authIsValid) {
-        await this.credentialRepository.updateAuthenticationStatus(
-            credentialId,
-            authIsValid
-        );
+        await this.credentialRepository.updateAuthenticationStatus(credentialId, authIsValid);
     }
 }
 
-module.exports = { UpdateAuthenticationStatus };
+module.exports = { UpdateAuthenticationStatus };

package/database/MONGODB_TRANSACTION_FIX.md

@@ -15,9 +15,9 @@ MongoDB does not allow creating collections (namespaces) inside multi-document t
 
 ### Technical Details
 
--   **MongoDB Constraint**: Collections must exist before being used in multi-document transactions
--   **Prisma Behavior**: Prisma may implicitly use transactions for certain operations
--   **Impact**: Health checks fail on fresh databases or when collections haven't been created yet
+- **MongoDB Constraint**: Collections must exist before being used in multi-document transactions
+- **Prisma Behavior**: Prisma may implicitly use transactions for certain operations
+- **Impact**: Health checks fail on fresh databases or when collections haven't been created yet
 
 ## Solution
 
@@ -37,34 +37,30 @@ This follows the **"fail fast"** principle and ensures consistent state across a
 ### Changes Made
 
 1. **Created MongoDB Schema Initialization** (`packages/core/database/utils/mongodb-schema-init.js`)
-
-    - `initializeMongoDBSchema()` - Ensures all Prisma collections exist at startup
-    - `getPrismaCollections()` - Returns list of all Prisma collection names
-    - `PRISMA_COLLECTIONS` - Constant array of all 13 Prisma collections
-    - Only runs for MongoDB (skips PostgreSQL)
-    - Fails fast if database not connected
+   - `initializeMongoDBSchema()` - Ensures all Prisma collections exist at startup
+   - `getPrismaCollections()` - Returns list of all Prisma collection names
+   - `PRISMA_COLLECTIONS` - Constant array of all 13 Prisma collections
+   - Only runs for MongoDB (skips PostgreSQL)
+   - Fails fast if database not connected
 
 2. **Created MongoDB Collection Utilities** (`packages/core/database/utils/mongodb-collection-utils.js`)
-
-    - `ensureCollectionExists(collectionName)` - Ensures a single collection exists
-    - `ensureCollectionsExist(collectionNames)` - Batch creates multiple collections
-    - `collectionExists(collectionName)` - Checks if a collection exists
-    - Handles race conditions gracefully (NamespaceExists errors)
+   - `ensureCollectionExists(collectionName)` - Ensures a single collection exists
+   - `ensureCollectionsExist(collectionNames)` - Batch creates multiple collections
+   - `collectionExists(collectionName)` - Checks if a collection exists
+   - Handles race conditions gracefully (NamespaceExists errors)
 
 3. **Integrated into Database Connection** (`packages/core/database/prisma.js`)
-
-    - Modified `connectPrisma()` to call `initializeMongoDBSchema()` after connection
-    - Ensures all collections exist before application handles requests
+   - Modified `connectPrisma()` to call `initializeMongoDBSchema()` after connection
+   - Ensures all collections exist before application handles requests
 
 4. **Updated Health Check Repository** (`packages/core/database/repositories/health-check-repository-mongodb.js`)
-
-    - Removed per-operation collection existence checks
-    - Added documentation noting schema is initialized at startup
+   - Removed per-operation collection existence checks
+   - Added documentation noting schema is initialized at startup
 
 5. **Added Comprehensive Tests**
-    - `mongodb-schema-init.test.js` - Tests schema initialization system
-    - `mongodb-collection-utils.test.js` - Tests collection utility functions
-    - Tests error handling, race conditions, and edge cases
+   - `mongodb-schema-init.test.js` - Tests schema initialization system
+   - `mongodb-collection-utils.test.js` - Tests collection utility functions
+   - Tests error handling, race conditions, and edge cases
 
 ### Implementation Flow
 
@@ -97,26 +93,23 @@ await prisma.credential.create({ data: {...} }); // Works without namespace erro
 ## Benefits
 
 ### Immediate Benefits
-
--   ✅ Fixes encryption health check failures on fresh databases
--   ✅ Prevents transaction namespace errors across **all** Prisma operations
--   ✅ No per-operation overhead - collections created once at startup
--   ✅ Fail fast - database issues discovered immediately at startup
--   ✅ Idempotent - safe to run multiple times and across multiple instances
+- ✅ Fixes encryption health check failures on fresh databases
+- ✅ Prevents transaction namespace errors across **all** Prisma operations
+- ✅ No per-operation overhead - collections created once at startup
+- ✅ Fail fast - database issues discovered immediately at startup
+- ✅ Idempotent - safe to run multiple times and across multiple instances
 
 ### Architectural Benefits
-
--   ✅ **Clean separation of concerns**: Schema initialization is infrastructure concern, handled at startup
--   ✅ **Follows DDD/Hexagonal Architecture**: Infrastructure layer handles database setup, repositories focus on business operations
--   ✅ **Consistent across all environments**: Dev, test, staging, production all follow same pattern
--   ✅ **No repository-level checks needed**: All repositories benefit automatically
--   ✅ **Well-tested and documented**: Comprehensive test coverage and documentation
+- ✅ **Clean separation of concerns**: Schema initialization is infrastructure concern, handled at startup
+- ✅ **Follows DDD/Hexagonal Architecture**: Infrastructure layer handles database setup, repositories focus on business operations
+- ✅ **Consistent across all environments**: Dev, test, staging, production all follow same pattern
+- ✅ **No repository-level checks needed**: All repositories benefit automatically
+- ✅ **Well-tested and documented**: Comprehensive test coverage and documentation
 
 ### Operational Benefits
-
--   ✅ **Predictable startup**: Clear logging of schema initialization
--   ✅ **Zero runtime overhead**: Collections created once, not on every operation
--   ✅ **Production-ready**: Handles race conditions, errors, and edge cases gracefully
+- ✅ **Predictable startup**: Clear logging of schema initialization
+- ✅ **Zero runtime overhead**: Collections created once, not on every operation
+- ✅ **Production-ready**: Handles race conditions, errors, and edge cases gracefully
 
 ## Design Decisions
 
@@ -125,19 +118,16 @@ await prisma.credential.create({ data: {...} }); // Works without namespace erro
 We considered two approaches:
 
 **❌ Per-Operation Checks (Initial approach)**
-
 ```javascript
 async createCredential(data) {
     await ensureCollectionExists('Credential'); // Check every time
     return await prisma.credential.create({ data });
 }
 ```
-
--   Pros: Guarantees collection exists before each operation
--   Cons: Runtime overhead, repeated checks, scattered logic
+- Pros: Guarantees collection exists before each operation
+- Cons: Runtime overhead, repeated checks, scattered logic
 
 **✅ Startup Initialization (Final approach)**
-
 ```javascript
 // Once at startup
 await connectPrisma(); // Initializes all collections
@@ -147,9 +137,8 @@ async createCredential(data) {
     return await prisma.credential.create({ data }); // No checks needed
 }
 ```
-
--   Pros: Zero runtime overhead, centralized logic, fail fast, consistent
--   Cons: Requires database connection at startup (already required)
+- Pros: Zero runtime overhead, centralized logic, fail fast, consistent
+- Cons: Requires database connection at startup (already required)
 
 ### Benefits of Startup Approach
 
@@ -170,7 +159,6 @@ MongoDB schema initialization complete - 13 collections verified (45ms)
 ```
 
 On subsequent startups (collections already exist):
-
 ```
 Initializing MongoDB schema - ensuring all collections exist...
 MongoDB schema initialization complete - 13 collections verified (12ms)
@@ -178,41 +166,33 @@ MongoDB schema initialization complete - 13 collections verified (12ms)
 
 ## References
 
--   [Prisma Issue #8305](https://github.com/prisma/prisma/issues/8305) - MongoDB "Cannot create namespace" error
--   [Mongoose Issue #6699](https://github.com/Automattic/mongoose/issues/6699) - Similar issue in Mongoose
--   [MongoDB Transactions Documentation](https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations) - Operations allowed in transactions
--   [Prisma MongoDB Guide](https://www.prisma.io/docs/guides/database/mongodb) - Using Prisma with MongoDB
+- [Prisma Issue #8305](https://github.com/prisma/prisma/issues/8305) - MongoDB "Cannot create namespace" error
+- [Mongoose Issue #6699](https://github.com/Automattic/mongoose/issues/6699) - Similar issue in Mongoose
+- [MongoDB Transactions Documentation](https://www.mongodb.com/docs/manual/core/transactions/#transactions-and-operations) - Operations allowed in transactions
+- [Prisma MongoDB Guide](https://www.prisma.io/docs/guides/database/mongodb) - Using Prisma with MongoDB
 
 ## Future Considerations
 
 ### Automatic Schema Sync
-
 Consider enhancing the system to:
-
--   Parse Prisma schema file dynamically to extract collection names
--   Auto-detect schema changes and create new collections
--   Provide CLI command for manual schema initialization
+- Parse Prisma schema file dynamically to extract collection names
+- Auto-detect schema changes and create new collections
+- Provide CLI command for manual schema initialization
 
 ### Migration Support
-
 For production deployments with existing data:
-
--   Document migration procedures for new collections
--   Consider pre-migration scripts for blue-green deployments
--   Add health check for schema initialization status
+- Document migration procedures for new collections
+- Consider pre-migration scripts for blue-green deployments
+- Add health check for schema initialization status
 
 ### Multi-Database Support
-
 The system already handles:
-
--   ✅ MongoDB - Full schema initialization
--   ✅ PostgreSQL - Skips initialization (uses Prisma migrations)
--   Consider adding explicit migration support for DocumentDB-specific features
+- ✅ MongoDB - Full schema initialization
+- ✅ PostgreSQL - Skips initialization (uses Prisma migrations)
+- Consider adding explicit migration support for DocumentDB-specific features
 
 ### Index Creation
-
 Future enhancement could also create indexes at startup:
-
--   Parse Prisma schema for `@@index` directives
--   Create indexes if they don't exist
--   Provide index health checks
+- Parse Prisma schema for `@@index` directives
+- Create indexes if they don't exist
+- Provide index health checks

package/database/adapters/lambda-invoker.js

@@ -1,7 +1,7 @@
 /**
  * Lambda Invoker Adapter
  * Infrastructure layer - handles AWS Lambda function invocations
- *
+ * 
  * Part of Hexagonal Architecture:
  * - Infrastructure Layer adapter for AWS SDK
  * - Used by Domain Layer use cases
@@ -25,7 +25,7 @@ class LambdaInvocationError extends Error {
 
 /**
  * Adapter for invoking AWS Lambda functions
- *
+ * 
  * Infrastructure layer - handles AWS SDK communication
  * Converts AWS SDK responses to domain-friendly formats
  */
@@ -39,7 +39,7 @@ class LambdaInvoker {
 
     /**
      * Invoke Lambda function synchronously
-     *
+     * 
      * @param {string} functionName - Lambda function name or ARN
      * @param {Object} payload - Event payload to send to Lambda
      * @returns {Promise<Object>} Parsed response body
@@ -74,8 +74,7 @@ class LambdaInvoker {
             }
 
             // Lambda returned error status
-            const errorMessage =
-                result.body?.error || 'Lambda invocation failed';
+            const errorMessage = result.body?.error || 'Lambda invocation failed';
             throw new LambdaInvocationError(
                 `Lambda ${functionName} returned error: ${errorMessage}`,
                 functionName,
@@ -88,11 +87,11 @@ class LambdaInvoker {
             }
 
             // Wrap AWS SDK errors
-            throw new Error(
-                `Failed to invoke Lambda ${functionName}: ${error.message}`
-            );
+            throw new Error(`Failed to invoke Lambda ${functionName}: ${error.message}`);
         }
     }
 }
 
 module.exports = { LambdaInvoker, LambdaInvocationError };
+
+