@friggframework/core 2.0.0--canary.548.c8ae0ca.0 → 2.0.0--canary.545.c40eca4.0

package/integrations/options.js

@@ -4,11 +4,8 @@ const { get } = require('../assertions');
 class Options {
     constructor(params) {
         this.module = get(params, 'module');
-        this.isMany = Boolean(get(params, 'isMany', false));
+        this.modules = params.modules || {}; // Store modules for requiredEntities extraction
         this.hasUserConfig = Boolean(get(params, 'hasUserConfig', false));
-        this.requiresNewEntity = Boolean(
-            get(params, 'requiresNewEntity', false)
-        );
         if (!params.display) {
             throw new RequiredPropertyError({
                 parent: this,
@@ -17,37 +14,67 @@ class Options {
         }
 
         this.display = {};
+        // Required fields
         this.display.name = get(params.display, 'label');
         this.display.description = get(params.display, 'description');
-        this.display.detailsUrl = get(params.display, 'detailsUrl');
-        this.display.icon = get(params.display, 'icon');
+        // Optional fields - use defaults if not provided
+        this.display.detailsUrl = params.display.detailsUrl || null;
+        this.display.icon = params.display.icon || null;
     }
 
     get() {
+        // Extract module names from the modules object to determine required entities
+        const requiredEntities = this.modules ? Object.keys(this.modules) : [];
+
+        // Get module type name - handle both getName() method and moduleName property
+        const moduleType = this._getModuleTypeName();
+
         return {
-            type: this.module.definition.getName(),
+            type: moduleType,
 
             // Flag for if the User can configure any settings
             hasUserConfig: this.hasUserConfig,
 
-            // if this integration can be used multiple times with the same integration pair. For example I want to
-            // connect two different Etsy shops to the same Freshbooks account.
-            isMany: this.isMany,
-
-            // if this is true it means we need to create a new entity for every integration pair and not use an
-            // existing one. This would be true for scenarios where the client wishes to have individual control over
-            // the integerations it has connected to its app. They would want this to let their users only delete
-            // single integrations without notifying our server.
-            requiresNewEntity: this.requiresNewEntity,
+            // Array of module/entity type names required for this integration (e.g., ['nagaris', 'creditorwatch'])
+            // UI uses this to check if user has connected the necessary accounts before creating integration
+            requiredEntities: requiredEntities,
 
             // this is information required for the display side of things on the front end
             display: this.display,
-
-            // this is information for post-authentication config, using jsonSchema and uiSchema for display on the frontend
-            // Maybe include but probably not, I like making someone make a follow-on request
-            // configOptions: this.configOptions,
         };
     }
+
+    /**
+     * Get the module type name from the module definition.
+     * Supports both:
+     * - getName() method (standard Frigg API modules)
+     * - moduleName property (custom API modules)
+     * @returns {string} The module type name
+     * @private
+     */
+    _getModuleTypeName() {
+        const definition = this.module?.definition;
+        if (!definition) {
+            return 'unknown';
+        }
+
+        // Try getName() method first (standard pattern)
+        if (typeof definition.getName === 'function') {
+            return definition.getName();
+        }
+
+        // Fall back to moduleName property
+        if (definition.moduleName) {
+            return definition.moduleName;
+        }
+
+        // Last resort - try name property
+        if (definition.name) {
+            return definition.name;
+        }
+
+        return 'unknown';
+    }
 }
 
 module.exports = { Options };

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

@@ -1,12 +1,6 @@
-const {
-    IntegrationMappingRepositoryMongo,
-} = require('./integration-mapping-repository-mongo');
 const {
     IntegrationMappingRepositoryPostgres,
 } = require('./integration-mapping-repository-postgres');
-const {
-    IntegrationMappingRepositoryDocumentDB,
-} = require('./integration-mapping-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -33,12 +27,14 @@ function createIntegrationMappingRepository() {
 
     switch (dbType) {
         case 'mongodb':
+            const { IntegrationMappingRepositoryMongo } = require('./integration-mapping-repository-mongo');
             return new IntegrationMappingRepositoryMongo();
 
         case 'postgresql':
             return new IntegrationMappingRepositoryPostgres();
 
         case 'documentdb':
+            const { IntegrationMappingRepositoryDocumentDB } = require('./integration-mapping-repository-documentdb');
             return new IntegrationMappingRepositoryDocumentDB();
 
         default:
@@ -51,7 +47,7 @@ function createIntegrationMappingRepository() {
 module.exports = {
     createIntegrationMappingRepository,
     // Export adapters for direct testing
-    IntegrationMappingRepositoryMongo,
+    get IntegrationMappingRepositoryMongo() { return require('./integration-mapping-repository-mongo').IntegrationMappingRepositoryMongo; },
     IntegrationMappingRepositoryPostgres,
-    IntegrationMappingRepositoryDocumentDB,
+    get IntegrationMappingRepositoryDocumentDB() { return require('./integration-mapping-repository-documentdb').IntegrationMappingRepositoryDocumentDB; },
 };

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

@@ -29,13 +29,17 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     async deleteIntegrationById(integrationId) {
         const objectId = toObjectId(integrationId);
         if (!objectId) return { acknowledged: true, deletedCount: 0 };
-        const result = await deleteOne(this.prisma, 'Integration', { _id: objectId });
+        const result = await deleteOne(this.prisma, 'Integration', {
+            _id: objectId,
+        });
         const deleted = result?.n ?? 0;
         return { acknowledged: true, deletedCount: deleted };
     }
 
     async findIntegrationByName(name) {
-        const doc = await findOne(this.prisma, 'Integration', { 'config.type': name });
+        const doc = await findOne(this.prisma, 'Integration', {
+            'config.type': name,
+        });
         if (!doc) {
             throw new Error(`Integration with name ${name} not found`);
         }
@@ -47,7 +51,9 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         if (!objectId) {
             throw new Error(`Integration with id ${id} not found`);
         }
-        const doc = await findOne(this.prisma, 'Integration', { _id: objectId });
+        const doc = await findOne(this.prisma, 'Integration', {
+            _id: objectId,
+        });
         if (!doc) {
             throw new Error(`Integration with id ${id} not found`);
         }
@@ -79,12 +85,16 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         if (!objectId) {
             throw new Error(`Integration ${integrationId} not found`);
         }
-        const existing = await findOne(this.prisma, 'Integration', { _id: objectId });
+        const existing = await findOne(this.prisma, 'Integration', {
+            _id: objectId,
+        });
         if (!existing) {
             throw new Error(`Integration ${integrationId} not found`);
         }
         const messages = this._extractMessages(existing);
-        const list = Array.isArray(messages[messageType]) ? [...messages[messageType]] : [];
+        const list = Array.isArray(messages[messageType])
+            ? [...messages[messageType]]
+            : [];
         list.push({
             title: messageTitle ?? null,
             message: messageBody,
@@ -125,17 +135,26 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
             createdAt: now,
             updatedAt: now,
         };
-        const insertedId = await insertOne(this.prisma, 'Integration', document);
-        const created = await findOne(this.prisma, 'Integration', { _id: insertedId });
+        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,
-            });
+            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.'
+                    'This indicates a database consistency issue.'
             );
         }
         return this._mapIntegration(created);
@@ -144,7 +163,9 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     async findIntegrationByUserId(userId) {
         const objectId = toObjectId(userId);
         if (!objectId) return null;
-        const doc = await findOne(this.prisma, 'Integration', { userId: objectId });
+        const doc = await findOne(this.prisma, 'Integration', {
+            userId: objectId,
+        });
         return doc ? this._mapIntegration(doc) : null;
     }
 
@@ -167,15 +188,20 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
                 },
             }
         );
-        const updated = await findOne(this.prisma, 'Integration', { _id: objectId });
+        const updated = await findOne(this.prisma, 'Integration', {
+            _id: objectId,
+        });
         if (!updated) {
-            console.error('[IntegrationRepositoryDocumentDB] Integration not found after update', {
-                integrationId: fromObjectId(objectId),
-                config,
-            });
+            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.'
+                    'This indicates a database consistency issue.'
             );
         }
         return this._mapIntegration(updated);
@@ -185,7 +211,9 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         const messages = this._extractMessages(doc);
         return {
             id: fromObjectId(doc?._id),
-            entitiesIds: (doc?.entityIds || []).map((value) => fromObjectId(value)),
+            entitiesIds: (doc?.entityIds || []).map((value) =>
+                fromObjectId(value)
+            ),
             userId: fromObjectId(doc?.userId),
             config: doc?.config ?? null,
             version: doc?.version ?? null,
@@ -195,7 +223,10 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     }
 
     _extractMessages(doc) {
-        const base = doc?.messages && typeof doc.messages === 'object' ? doc.messages : {};
+        const base =
+            doc?.messages && typeof doc.messages === 'object'
+                ? doc.messages
+                : {};
         return {
             errors: base.errors ?? doc?.errors ?? [],
             warnings: base.warnings ?? doc?.warnings ?? [],
@@ -206,5 +237,3 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
 }
 
 module.exports = { IntegrationRepositoryDocumentDB };
-
-

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

@@ -1,8 +1,6 @@
-const { IntegrationRepositoryMongo } = require('./integration-repository-mongo');
-const { IntegrationRepositoryPostgres } = require('./integration-repository-postgres');
 const {
-    IntegrationRepositoryDocumentDB,
-} = require('./integration-repository-documentdb');
+    IntegrationRepositoryPostgres,
+} = require('./integration-repository-postgres');
 const config = require('../../database/config');
 
 /**
@@ -27,12 +25,14 @@ function createIntegrationRepository() {
 
     switch (dbType) {
         case 'mongodb':
+            const { IntegrationRepositoryMongo } = require('./integration-repository-mongo');
             return new IntegrationRepositoryMongo();
 
         case 'postgresql':
             return new IntegrationRepositoryPostgres();
 
         case 'documentdb':
+            const { IntegrationRepositoryDocumentDB } = require('./integration-repository-documentdb');
             return new IntegrationRepositoryDocumentDB();
 
         default:
@@ -45,7 +45,7 @@ function createIntegrationRepository() {
 module.exports = {
     createIntegrationRepository,
     // Export adapters for direct testing
-    IntegrationRepositoryMongo,
+    get IntegrationRepositoryMongo() { return require('./integration-repository-mongo').IntegrationRepositoryMongo; },
     IntegrationRepositoryPostgres,
-    IntegrationRepositoryDocumentDB,
+    get IntegrationRepositoryDocumentDB() { return require('./integration-repository-documentdb').IntegrationRepositoryDocumentDB; },
 };

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

@@ -18,7 +18,9 @@ class IntegrationRepositoryInterface {
      * @abstract
      */
     async findIntegrationsByUserId(userId) {
-        throw new Error('Method findIntegrationsByUserId must be implemented by subclass');
+        throw new Error(
+            'Method findIntegrationsByUserId must be implemented by subclass'
+        );
     }
 
     /**
@@ -29,7 +31,9 @@ class IntegrationRepositoryInterface {
      * @abstract
      */
     async deleteIntegrationById(integrationId) {
-        throw new Error('Method deleteIntegrationById must be implemented by subclass');
+        throw new Error(
+            'Method deleteIntegrationById must be implemented by subclass'
+        );
     }
 
     /**
@@ -40,7 +44,9 @@ class IntegrationRepositoryInterface {
      * @abstract
      */
     async findIntegrationByName(name) {
-        throw new Error('Method findIntegrationByName must be implemented by subclass');
+        throw new Error(
+            'Method findIntegrationByName must be implemented by subclass'
+        );
     }
 
     /**
@@ -51,7 +57,9 @@ class IntegrationRepositoryInterface {
      * @abstract
      */
     async findIntegrationById(id) {
-        throw new Error('Method findIntegrationById must be implemented by subclass');
+        throw new Error(
+            'Method findIntegrationById must be implemented by subclass'
+        );
     }
 
     /**
@@ -63,7 +71,9 @@ class IntegrationRepositoryInterface {
      * @abstract
      */
     async updateIntegrationStatus(integrationId, status) {
-        throw new Error('Method updateIntegrationStatus must be implemented by subclass');
+        throw new Error(
+            'Method updateIntegrationStatus must be implemented by subclass'
+        );
     }
 
     /**
@@ -84,7 +94,9 @@ class IntegrationRepositoryInterface {
         messageBody,
         messageTimestamp
     ) {
-        throw new Error('Method updateIntegrationMessages must be implemented by subclass');
+        throw new Error(
+            'Method updateIntegrationMessages must be implemented by subclass'
+        );
     }
 
     /**
@@ -97,7 +109,9 @@ class IntegrationRepositoryInterface {
      * @abstract
      */
     async createIntegration(entities, userId, config) {
-        throw new Error('Method createIntegration must be implemented by subclass');
+        throw new Error(
+            'Method createIntegration must be implemented by subclass'
+        );
     }
 
     /**
@@ -108,7 +122,9 @@ class IntegrationRepositoryInterface {
      * @abstract
      */
     async findIntegrationByUserId(userId) {
-        throw new Error('Method findIntegrationByUserId must be implemented by subclass');
+        throw new Error(
+            'Method findIntegrationByUserId must be implemented by subclass'
+        );
     }
 
     /**
@@ -120,7 +136,9 @@ class IntegrationRepositoryInterface {
      * @abstract
      */
     async updateIntegrationConfig(integrationId, config) {
-        throw new Error('Method updateIntegrationConfig must be implemented by subclass');
+        throw new Error(
+            'Method updateIntegrationConfig must be implemented by subclass'
+        );
     }
 }
 

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

@@ -49,12 +49,12 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
             ...integration,
             id: integration.id?.toString(),
             userId: integration.userId?.toString(),
-            entities: integration.entities?.map(e => ({
+            entities: integration.entities?.map((e) => ({
                 ...e,
                 id: e.id?.toString(),
                 userId: e.userId?.toString(),
-                credentialId: e.credentialId?.toString()
-            }))
+                credentialId: e.credentialId?.toString(),
+            })),
         };
     }
 

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

@@ -1,8 +1,4 @@
-const { ProcessRepositoryMongo } = require('./process-repository-mongo');
 const { ProcessRepositoryPostgres } = require('./process-repository-postgres');
-const {
-    ProcessRepositoryDocumentDB,
-} = require('./process-repository-documentdb');
 const config = require('../../database/config');
 
 /**
@@ -28,12 +24,14 @@ function createProcessRepository() {
 
     switch (dbType) {
         case 'mongodb':
+            const { ProcessRepositoryMongo } = require('./process-repository-mongo');
             return new ProcessRepositoryMongo();
 
         case 'postgresql':
             return new ProcessRepositoryPostgres();
 
         case 'documentdb':
+            const { ProcessRepositoryDocumentDB } = require('./process-repository-documentdb');
             return new ProcessRepositoryDocumentDB();
 
         default:
@@ -46,8 +44,7 @@ function createProcessRepository() {
 module.exports = {
     createProcessRepository,
     // Export adapters for direct testing
-    ProcessRepositoryMongo,
+    get ProcessRepositoryMongo() { return require('./process-repository-mongo').ProcessRepositoryMongo; },
     ProcessRepositoryPostgres,
-    ProcessRepositoryDocumentDB,
+    get ProcessRepositoryDocumentDB() { return require('./process-repository-documentdb').ProcessRepositoryDocumentDB; },
 };
-

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

@@ -1,9 +1,9 @@
 /**
  * ProcessRepository Interface
- * 
+ *
  * Defines the contract for Process data access operations.
  * Implementations must provide concrete methods for all operations.
- * 
+ *
  * This interface supports the Hexagonal Architecture pattern by:
  * - Defining clear boundaries between domain logic and data access
  * - Allowing multiple implementations (MongoDB, PostgreSQL, in-memory)
@@ -54,7 +54,9 @@ class ProcessRepositoryInterface {
      * @returns {Promise<Array>} Array of process records
      */
     async findByIntegrationAndType(integrationId, type) {
-        throw new Error('Method findByIntegrationAndType() must be implemented');
+        throw new Error(
+            'Method findByIntegrationAndType() must be implemented'
+        );
     }
 
     /**
@@ -63,7 +65,10 @@ class ProcessRepositoryInterface {
      * @param {string[]} [excludeStates=['COMPLETED', 'ERROR']] - States to exclude
      * @returns {Promise<Array>} Array of active process records
      */
-    async findActiveProcesses(integrationId, excludeStates = ['COMPLETED', 'ERROR']) {
+    async findActiveProcesses(
+        integrationId,
+        excludeStates = ['COMPLETED', 'ERROR']
+    ) {
         throw new Error('Method findActiveProcesses() must be implemented');
     }
 
@@ -87,4 +92,3 @@ class ProcessRepositoryInterface {
 }
 
 module.exports = { ProcessRepositoryInterface };
-

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

@@ -1,5 +1,7 @@
 const { prisma } = require('../../database/prisma');
-const { ProcessRepositoryInterface } = require('./process-repository-interface');
+const {
+    ProcessRepositoryInterface,
+} = require('./process-repository-interface');
 
 /**
  * MongoDB Process Repository Adapter
@@ -118,7 +120,10 @@ class ProcessRepositoryMongo extends ProcessRepositoryInterface {
      * @param {string[]} [excludeStates=['COMPLETED', 'ERROR']] - States to exclude
      * @returns {Promise<Array>} Array of active process records
      */
-    async findActiveProcesses(integrationId, excludeStates = ['COMPLETED', 'ERROR']) {
+    async findActiveProcesses(
+        integrationId,
+        excludeStates = ['COMPLETED', 'ERROR']
+    ) {
         const processes = await this.prisma.process.findMany({
             where: {
                 integrationId,
@@ -187,4 +192,3 @@ class ProcessRepositoryMongo extends ProcessRepositoryInterface {
 }
 
 module.exports = { ProcessRepositoryMongo };
-

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

@@ -199,8 +199,8 @@ class ProcessRepositoryPostgres extends ProcessRepositoryInterface {
             results: process.results,
             childProcesses: Array.isArray(process.childProcesses)
                 ? process.childProcesses.length > 0 &&
-                    typeof process.childProcesses[0] === 'object' &&
-                    process.childProcesses[0] !== null
+                  typeof process.childProcesses[0] === 'object' &&
+                  process.childProcesses[0] !== null
                     ? process.childProcesses.map((child) => String(child.id))
                     : process.childProcesses
                 : [],

package/integrations/tests/doubles/config-capturing-integration.js

@@ -2,7 +2,7 @@ const { IntegrationBase } = require('../../integration-base');
 
 class ConfigCapturingModule {
     static definition = {
-        getName: () => 'config-capturing-module'
+        getName: () => 'config-capturing-module',
     };
 }
 
@@ -11,14 +11,15 @@ class ConfigCapturingIntegration extends IntegrationBase {
         name: 'config-capturing',
         version: '1.0.0',
         modules: {
-            primary: ConfigCapturingModule
+            primary: ConfigCapturingModule,
         },
         display: {
             label: 'Config Capturing Integration',
-            description: 'Test double for capturing config state during updates',
+            description:
+                'Test double for capturing config state during updates',
             detailsUrl: 'https://example.com',
-            icon: 'test-icon'
-        }
+            icon: 'test-icon',
+        },
     };
 
     static _capturedOnUpdateState = null;
@@ -38,10 +39,10 @@ class ConfigCapturingIntegration extends IntegrationBase {
             findIntegrationById: jest.fn().mockResolvedValue({}),
         };
         this.updateIntegrationStatus = {
-            execute: jest.fn().mockResolvedValue({})
+            execute: jest.fn().mockResolvedValue({}),
         };
         this.updateIntegrationMessages = {
-            execute: jest.fn().mockResolvedValue({})
+            execute: jest.fn().mockResolvedValue({}),
         };
     }
 
@@ -52,7 +53,7 @@ class ConfigCapturingIntegration extends IntegrationBase {
     async onUpdate(params) {
         ConfigCapturingIntegration._capturedOnUpdateState = {
             thisConfig: JSON.parse(JSON.stringify(this.config)),
-            paramsConfig: params.config
+            paramsConfig: params.config,
         };
 
         this.config = this._deepMerge(this.config, params.config);