@friggframework/core 2.0.0-next.54 → 2.0.0-next.56

package/integrations/repositories/integration-mapping-repository-documentdb.js

@@ -12,74 +12,167 @@ const {
 const {
     IntegrationMappingRepositoryInterface,
 } = require('./integration-mapping-repository-interface');
-
+const {
+    DocumentDBEncryptionService,
+} = require('../../database/documentdb-encryption-service');
 class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositoryInterface {
     constructor() {
         super();
         this.prisma = prisma;
+        this.encryptionService = new DocumentDBEncryptionService();
     }
 
     async findMappingBy(integrationId, sourceId) {
         const filter = this._compositeFilter(integrationId, sourceId);
         const doc = await findOne(this.prisma, 'IntegrationMapping', filter);
-        return doc ? this._mapMapping(doc) : null;
+        if (!doc) return null;
+
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            doc
+        );
+        return this._mapMapping(decryptedMapping);
     }
 
     async upsertMapping(integrationId, sourceId, mapping) {
         const filter = this._compositeFilter(integrationId, sourceId);
-        const existing = await findOne(this.prisma, 'IntegrationMapping', filter);
+        const existing = await findOne(
+            this.prisma,
+            'IntegrationMapping',
+            filter
+        );
         const now = new Date();
 
         if (existing) {
+            const decryptedExisting =
+                await this.encryptionService.decryptFields(
+                    'IntegrationMapping',
+                    existing
+                );
+
+            const updateDocument = {
+                mapping,
+                updatedAt: now,
+            };
+
+            const encryptedUpdate = await this.encryptionService.encryptFields(
+                'IntegrationMapping',
+                { mapping: updateDocument.mapping }
+            );
+
             await updateOne(
                 this.prisma,
                 'IntegrationMapping',
                 { _id: existing._id },
                 {
                     $set: {
-                        mapping,
-                        updatedAt: now,
+                        mapping: encryptedUpdate.mapping,
+                        updatedAt: updateDocument.updatedAt,
                     },
                 }
             );
-            const updated = await findOne(this.prisma, 'IntegrationMapping', { _id: existing._id });
-            return this._mapMapping(updated);
+
+            const updated = await findOne(this.prisma, 'IntegrationMapping', {
+                _id: existing._id,
+            });
+            if (!updated) {
+                console.error(
+                    '[IntegrationMappingRepositoryDocumentDB] Mapping not found after update',
+                    {
+                        mappingId: fromObjectId(existing._id),
+                        integrationId,
+                        sourceId,
+                    }
+                );
+                throw new Error(
+                    'Failed to update mapping: Document not found after update. ' +
+                        'This indicates a database consistency issue.'
+                );
+            }
+            const decryptedMapping = await this.encryptionService.decryptFields(
+                'IntegrationMapping',
+                updated
+            );
+            return this._mapMapping(decryptedMapping);
         }
 
-        const document = {
-            integrationId: toObjectId(integrationId),
-            sourceId: sourceId === null || sourceId === undefined ? null : String(sourceId),
+        const plainDocument = {
+            integrationId: integrationId,
+            sourceId:
+                sourceId === null || sourceId === undefined
+                    ? null
+                    : String(sourceId),
             mapping,
             createdAt: now,
             updatedAt: now,
         };
-        const insertedId = await insertOne(this.prisma, 'IntegrationMapping', document);
-        const created = await findOne(this.prisma, 'IntegrationMapping', { _id: insertedId });
-        return this._mapMapping(created);
+
+        const encryptedDocument = await this.encryptionService.encryptFields(
+            'IntegrationMapping',
+            plainDocument
+        );
+
+        const insertedId = await insertOne(
+            this.prisma,
+            'IntegrationMapping',
+            encryptedDocument
+        );
+
+        const created = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: insertedId,
+        });
+        if (!created) {
+            console.error(
+                '[IntegrationMappingRepositoryDocumentDB] Mapping not found after insert',
+                {
+                    insertedId: fromObjectId(insertedId),
+                    integrationId,
+                    sourceId,
+                }
+            );
+            throw new Error(
+                'Failed to create mapping: Document not found after insert. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            created
+        );
+        return this._mapMapping(decryptedMapping);
     }
 
     async findMappingsByIntegration(integrationId) {
         const filter = {};
-        const integrationObjectId = toObjectId(integrationId);
-        if (integrationObjectId) filter.integrationId = integrationObjectId;
+        if (integrationId) filter.integrationId = integrationId;
         const docs = await findMany(this.prisma, 'IntegrationMapping', filter);
-        return docs.map((doc) => this._mapMapping(doc));
+
+        const decryptedDocs = await Promise.all(
+            docs.map((doc) =>
+                this.encryptionService.decryptFields('IntegrationMapping', doc)
+            )
+        );
+
+        return decryptedDocs.map((doc) => this._mapMapping(doc));
     }
 
     async deleteMapping(integrationId, sourceId) {
         const filter = this._compositeFilter(integrationId, sourceId);
-        const result = await deleteOne(this.prisma, 'IntegrationMapping', filter);
+        const result = await deleteOne(
+            this.prisma,
+            'IntegrationMapping',
+            filter
+        );
         const deleted = result?.n ?? 0;
         return { acknowledged: true, deletedCount: deleted };
     }
 
     async deleteMappingsByIntegration(integrationId) {
-        const integrationObjectId = toObjectId(integrationId);
-        if (!integrationObjectId) {
+        if (!integrationId) {
             return { acknowledged: true, deletedCount: 0 };
         }
         const result = await deleteMany(this.prisma, 'IntegrationMapping', {
-            integrationId: integrationObjectId,
+            integrationId: integrationId,
         });
         const deleted = result?.n ?? 0;
         return { acknowledged: true, deletedCount: deleted };
@@ -88,32 +181,84 @@ class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositor
     async findMappingById(id) {
         const objectId = toObjectId(id);
         if (!objectId) return null;
-        const doc = await findOne(this.prisma, 'IntegrationMapping', { _id: objectId });
-        return doc ? this._mapMapping(doc) : null;
+        const doc = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!doc) return null;
+
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            doc
+        );
+        return this._mapMapping(decryptedMapping);
     }
 
     async updateMapping(id, updates) {
         const objectId = toObjectId(id);
         if (!objectId) return null;
+
+        const existing = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!existing) return null;
+
+        const decryptedExisting = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            existing
+        );
+
+        const mergedMapping =
+            updates.mapping !== undefined
+                ? updates.mapping
+                : decryptedExisting.mapping;
+
+        const updateDocument = {
+            ...updates,
+            updatedAt: new Date(),
+        };
+
+        if (mergedMapping !== undefined) {
+            const encryptedUpdate = await this.encryptionService.encryptFields(
+                'IntegrationMapping',
+                { mapping: mergedMapping }
+            );
+            updateDocument.mapping = encryptedUpdate.mapping;
+        }
+
         await updateOne(
             this.prisma,
             'IntegrationMapping',
             { _id: objectId },
             {
-                $set: {
-                    ...updates,
-                    updatedAt: new Date(),
-                },
+                $set: updateDocument,
             }
         );
-        const updated = await findOne(this.prisma, 'IntegrationMapping', { _id: objectId });
-        return updated ? this._mapMapping(updated) : null;
+
+        const updated = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: objectId,
+        });
+        if (!updated) {
+            console.error(
+                '[IntegrationMappingRepositoryDocumentDB] Mapping not found after update',
+                {
+                    mappingId: fromObjectId(objectId),
+                }
+            );
+            throw new Error(
+                'Failed to update mapping: Document not found after update. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedMapping = await this.encryptionService.decryptFields(
+            'IntegrationMapping',
+            updated
+        );
+        return this._mapMapping(decryptedMapping);
     }
 
     _compositeFilter(integrationId, sourceId) {
         const filter = {};
-        const integrationObjectId = toObjectId(integrationId);
-        if (integrationObjectId) filter.integrationId = integrationObjectId;
+        if (integrationId) filter.integrationId = integrationId;
         if (sourceId !== undefined) {
             filter.sourceId = sourceId === null ? null : String(sourceId);
         }
@@ -123,13 +268,13 @@ class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositor
     _mapMapping(doc) {
         return {
             id: fromObjectId(doc?._id),
-            integrationId: fromObjectId(doc?.integrationId),
+            integrationId: doc?.integrationId ?? null,
             sourceId: doc?.sourceId ?? null,
             mapping: doc?.mapping ?? null,
+            createdAt: doc?.createdAt,
+            updatedAt: doc?.updatedAt,
         };
     }
 }
 
 module.exports = { IntegrationMappingRepositoryDocumentDB };
-
-

package/integrations/repositories/integration-repository-documentdb.js

@@ -127,6 +127,17 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         };
         const insertedId = await insertOne(this.prisma, 'Integration', document);
         const created = await findOne(this.prisma, 'Integration', { _id: insertedId });
+        if (!created) {
+            console.error('[IntegrationRepositoryDocumentDB] Integration not found after insert', {
+                insertedId: fromObjectId(insertedId),
+                userId,
+                config,
+            });
+            throw new Error(
+                'Failed to create integration: Document not found after insert. ' +
+                'This indicates a database consistency issue.'
+            );
+        }
         return this._mapIntegration(created);
     }
 
@@ -157,6 +168,16 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
             }
         );
         const updated = await findOne(this.prisma, 'Integration', { _id: objectId });
+        if (!updated) {
+            console.error('[IntegrationRepositoryDocumentDB] Integration not found after update', {
+                integrationId: fromObjectId(objectId),
+                config,
+            });
+            throw new Error(
+                'Failed to update integration: Document not found after update. ' +
+                'This indicates a database consistency issue.'
+            );
+        }
         return this._mapIntegration(updated);
     }
 

package/integrations/repositories/process-repository-documentdb.js

@@ -8,17 +8,23 @@ const {
     updateOne,
     deleteOne,
 } = require('../../database/documentdb-utils');
-const { ProcessRepositoryInterface } = require('./process-repository-interface');
+const {
+    ProcessRepositoryInterface,
+} = require('./process-repository-interface');
+const {
+    DocumentDBEncryptionService,
+} = require('../../database/documentdb-encryption-service');
 
 class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
     constructor() {
         super();
         this.prisma = prisma;
+        this.encryptionService = new DocumentDBEncryptionService();
     }
 
     async create(processData) {
         const now = new Date();
-        const document = {
+        const plainDocument = {
             userId: toObjectId(processData.userId),
             integrationId: toObjectId(processData.integrationId),
             name: processData.name,
@@ -26,45 +32,127 @@ class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
             state: processData.state || 'INITIALIZING',
             context: processData.context || {},
             results: processData.results || {},
-            childProcesses: (processData.childProcesses || []).map((id) => toObjectId(id)).filter(Boolean),
-            parentProcessId: processData.parentProcessId ? toObjectId(processData.parentProcessId) : null,
+            childProcesses: (processData.childProcesses || [])
+                .map((id) => toObjectId(id))
+                .filter(Boolean),
+            parentProcessId: processData.parentProcessId
+                ? toObjectId(processData.parentProcessId)
+                : null,
             createdAt: now,
             updatedAt: now,
         };
-        const insertedId = await insertOne(this.prisma, 'Process', document);
-        const created = await findOne(this.prisma, 'Process', { _id: insertedId });
-        return this._mapProcess(created);
+
+        const encryptedDocument = await this.encryptionService.encryptFields(
+            'Process',
+            plainDocument
+        );
+
+        const insertedId = await insertOne(
+            this.prisma,
+            'Process',
+            encryptedDocument
+        );
+
+        const created = await findOne(this.prisma, 'Process', {
+            _id: insertedId,
+        });
+        if (!created) {
+            console.error(
+                '[ProcessRepositoryDocumentDB] Process not found after insert',
+                {
+                    insertedId: fromObjectId(insertedId),
+                    processData: {
+                        userId: processData.userId,
+                        integrationId: processData.integrationId,
+                        name: processData.name,
+                        type: processData.type,
+                    },
+                }
+            );
+            throw new Error(
+                'Failed to create process: Document not found after insert. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedProcess = await this.encryptionService.decryptFields(
+            'Process',
+            created
+        );
+        return this._mapProcess(decryptedProcess);
     }
 
     async findById(processId) {
         const objectId = toObjectId(processId);
         if (!objectId) return null;
         const doc = await findOne(this.prisma, 'Process', { _id: objectId });
-        return doc ? this._mapProcess(doc) : null;
+        if (!doc) return null;
+
+        const decryptedProcess = await this.encryptionService.decryptFields(
+            'Process',
+            doc
+        );
+        return this._mapProcess(decryptedProcess);
     }
 
     async update(processId, updates) {
         const objectId = toObjectId(processId);
         if (!objectId) return null;
+
+        const existing = await findOne(this.prisma, 'Process', {
+            _id: objectId,
+        });
+        if (!existing) return null;
+
         const updatePayload = {};
         if (updates.state !== undefined) updatePayload.state = updates.state;
-        if (updates.context !== undefined) updatePayload.context = updates.context;
-        if (updates.results !== undefined) updatePayload.results = updates.results;
+        if (updates.context !== undefined)
+            updatePayload.context = updates.context;
+        if (updates.results !== undefined)
+            updatePayload.results = updates.results;
         if (updates.childProcesses !== undefined) {
-            updatePayload.childProcesses = (updates.childProcesses || []).map((id) => toObjectId(id)).filter(Boolean);
+            updatePayload.childProcesses = (updates.childProcesses || [])
+                .map((id) => toObjectId(id))
+                .filter(Boolean);
         }
         if (updates.parentProcessId !== undefined) {
-            updatePayload.parentProcessId = updates.parentProcessId ? toObjectId(updates.parentProcessId) : null;
+            updatePayload.parentProcessId = updates.parentProcessId
+                ? toObjectId(updates.parentProcessId)
+                : null;
         }
         updatePayload.updatedAt = new Date();
+
+        const encryptedUpdate = await this.encryptionService.encryptFields(
+            'Process',
+            updatePayload
+        );
+
         await updateOne(
             this.prisma,
             'Process',
             { _id: objectId },
-            { $set: updatePayload }
+            { $set: encryptedUpdate }
+        );
+
+        const updated = await findOne(this.prisma, 'Process', {
+            _id: objectId,
+        });
+        if (!updated) {
+            console.error(
+                '[ProcessRepositoryDocumentDB] Process not found after update',
+                {
+                    processId: fromObjectId(objectId),
+                }
+            );
+            throw new Error(
+                'Failed to update process: Document not found after update. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        const decryptedProcess = await this.encryptionService.decryptFields(
+            'Process',
+            updated
         );
-        const updated = await findOne(this.prisma, 'Process', { _id: objectId });
-        return updated ? this._mapProcess(updated) : null;
+        return this._mapProcess(decryptedProcess);
     }
 
     async findByIntegrationAndType(integrationId, type) {
@@ -76,30 +164,36 @@ class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
         const docs = await findMany(this.prisma, 'Process', filter, {
             sort: { createdAt: -1 },
         });
-        return docs.map((doc) => this._mapProcess(doc));
+
+        const decryptedDocs = await Promise.all(
+            docs.map((doc) =>
+                this.encryptionService.decryptFields('Process', doc)
+            )
+        );
+
+        return decryptedDocs.map((doc) => this._mapProcess(doc));
     }
 
-    async findActiveProcesses(integrationId, excludeStates = ['COMPLETED', 'ERROR']) {
+    async findActiveProcesses(
+        integrationId,
+        excludeStates = ['COMPLETED', 'ERROR']
+    ) {
         const integrationObjectId = toObjectId(integrationId);
-        const pipeline = [
-            {
-                $match: {
-                    integrationId: integrationObjectId,
-                },
-            },
-            {
-                $match: {
-                    state: { $nin: excludeStates },
-                },
-            },
-            { $sort: { createdAt: -1 } },
-        ];
-        const docs = await this.prisma.$runCommandRaw({
-            aggregate: 'Process',
-            pipeline,
-            cursor: {},
-        }).then((res) => res?.cursor?.firstBatch || []);
-        return docs.map((doc) => this._mapProcess(doc));
+        const filter = {
+            integrationId: integrationObjectId,
+            state: { $nin: excludeStates },
+        };
+        const docs = await findMany(this.prisma, 'Process', filter, {
+            sort: { createdAt: -1 },
+        });
+
+        const decryptedDocs = await Promise.all(
+            docs.map((doc) =>
+                this.encryptionService.decryptFields('Process', doc)
+            )
+        );
+
+        return decryptedDocs.map((doc) => this._mapProcess(doc));
     }
 
     async findByName(name) {
@@ -109,7 +203,13 @@ class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
             { name },
             { sort: { createdAt: -1 } }
         );
-        return doc ? this._mapProcess(doc) : null;
+        if (!doc) return null;
+
+        const decryptedProcess = await this.encryptionService.decryptFields(
+            'Process',
+            doc
+        );
+        return this._mapProcess(decryptedProcess);
     }
 
     async deleteById(processId) {
@@ -128,8 +228,12 @@ class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
             state: doc?.state ?? null,
             context: doc?.context ?? {},
             results: doc?.results ?? {},
-            childProcesses: (doc?.childProcesses || []).map((id) => fromObjectId(id)),
-            parentProcessId: doc?.parentProcessId ? fromObjectId(doc.parentProcessId) : null,
+            childProcesses: (doc?.childProcesses || []).map((id) =>
+                fromObjectId(id)
+            ),
+            parentProcessId: doc?.parentProcessId
+                ? fromObjectId(doc.parentProcessId)
+                : null,
             createdAt: doc?.createdAt ? new Date(doc.createdAt) : null,
             updatedAt: doc?.updatedAt ? new Date(doc.updatedAt) : null,
         };
@@ -137,5 +241,3 @@ class ProcessRepositoryDocumentDB extends ProcessRepositoryInterface {
 }
 
 module.exports = { ProcessRepositoryDocumentDB };
-
-

package/modules/requester/api-key.js

@@ -1,4 +1,5 @@
 const { Requester } = require('./requester');
+const { get } = require('../../assertions');
 const { ModuleConstants } = require('../ModuleConstants');
 
 
@@ -9,27 +10,42 @@ class ApiKeyRequester extends Requester {
     constructor(params) {
         super(params);
         this.requesterType = 'apiKey';
-        this.API_KEY_NAME = 'key';
-        this.API_KEY_VALUE = null;
+
+        // Use snake_case convention consistent with OAuth2Requester and BasicAuthRequester
+        this.api_key_name = get(params, 'api_key_name', 'key');
+        this.api_key = get(params, 'api_key', null);
+
+        // Backward compatibility: support old naming convention
+        if (!this.api_key && params.API_KEY_VALUE) {
+            this.api_key = params.API_KEY_VALUE;
+        }
+        if (!this.api_key_name && params.API_KEY_NAME) {
+            this.api_key_name = params.API_KEY_NAME;
+        }
     }
 
     async addAuthHeaders(headers) {
-        if (this.API_KEY_VALUE) {
-            headers[this.API_KEY_NAME] = this.API_KEY_VALUE;
+        if (this.api_key) {
+            headers[this.api_key_name] = this.api_key;
         }
         return headers;
     }
 
     isAuthenticated() {
         return (
-            this.API_KEY_VALUE !== null &&
-            this.API_KEY_VALUE !== undefined &&
-            this.API_KEY_VALUE.trim().length() > 0
+            this.api_key !== null &&
+            this.api_key !== undefined &&
+            typeof this.api_key === 'string' &&
+            this.api_key.trim().length > 0
         );
     }
 
     setApiKey(api_key) {
-        this.API_KEY_VALUE = api_key;
+        this.api_key = api_key;
+    }
+
+    setApiKeyName(api_key_name) {
+        this.api_key_name = api_key_name;
     }
 }
 

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@friggframework/core",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0-next.54",
+    "version": "2.0.0-next.56",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
@@ -38,9 +38,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0-next.54",
-        "@friggframework/prettier-config": "2.0.0-next.54",
-        "@friggframework/test": "2.0.0-next.54",
+        "@friggframework/eslint-config": "2.0.0-next.56",
+        "@friggframework/prettier-config": "2.0.0-next.56",
+        "@friggframework/test": "2.0.0-next.56",
         "@prisma/client": "^6.17.0",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -80,5 +80,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "d72f0af6966a5701fe2a4257139d40292972f92a"
+    "gitHead": "5551318d5c45913810a6b03a5ea19c72b5c4cb2f"
 }