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

package/integrations/options.js

@@ -4,8 +4,11 @@ const { get } = require('../assertions');
 class Options {
     constructor(params) {
         this.module = get(params, 'module');
-        this.modules = params.modules || {}; // Store modules for requiredEntities extraction
+        this.isMany = Boolean(get(params, 'isMany', false));
         this.hasUserConfig = Boolean(get(params, 'hasUserConfig', false));
+        this.requiresNewEntity = Boolean(
+            get(params, 'requiresNewEntity', false)
+        );
         if (!params.display) {
             throw new RequiredPropertyError({
                 parent: this,
@@ -14,66 +17,36 @@ class Options {
         }
 
         this.display = {};
-        // Required fields
         this.display.name = get(params.display, 'label');
         this.display.description = get(params.display, 'description');
-        // Optional fields - use defaults if not provided
-        this.display.detailsUrl = params.display.detailsUrl || null;
-        this.display.icon = params.display.icon || null;
+        this.display.detailsUrl = get(params.display, 'detailsUrl');
+        this.display.icon = get(params.display, 'icon');
     }
 
     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: moduleType,
+            type: this.module.definition.getName(),
 
             // Flag for if the User can configure any settings
             hasUserConfig: this.hasUserConfig,
 
-            // 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,
+            // 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,
 
             // this is information required for the display side of things on the front end
             display: this.display,
-        };
-    }
-
-    /**
-     * 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';
+            // 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,
+        };
     }
 }
 

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

@@ -29,17 +29,13 @@ 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`);
         }
@@ -51,9 +47,7 @@ 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`);
         }
@@ -85,16 +79,12 @@ 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,
@@ -135,26 +125,17 @@ 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);
@@ -163,9 +144,7 @@ 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;
     }
 
@@ -188,20 +167,15 @@ 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);
@@ -211,9 +185,7 @@ 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,
@@ -223,10 +195,7 @@ 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 ?? [],
@@ -237,3 +206,5 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
 }
 
 module.exports = { IntegrationRepositoryDocumentDB };
+
+

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

@@ -1,9 +1,5 @@
-const {
-    IntegrationRepositoryMongo,
-} = require('./integration-repository-mongo');
-const {
-    IntegrationRepositoryPostgres,
-} = require('./integration-repository-postgres');
+const { IntegrationRepositoryMongo } = require('./integration-repository-mongo');
+const { IntegrationRepositoryPostgres } = require('./integration-repository-postgres');
 const {
     IntegrationRepositoryDocumentDB,
 } = require('./integration-repository-documentdb');

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

@@ -18,9 +18,7 @@ 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');
     }
 
     /**
@@ -31,9 +29,7 @@ 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');
     }
 
     /**
@@ -44,9 +40,7 @@ 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');
     }
 
     /**
@@ -57,9 +51,7 @@ 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');
     }
 
     /**
@@ -71,9 +63,7 @@ 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');
     }
 
     /**
@@ -94,9 +84,7 @@ class IntegrationRepositoryInterface {
         messageBody,
         messageTimestamp
     ) {
-        throw new Error(
-            'Method updateIntegrationMessages must be implemented by subclass'
-        );
+        throw new Error('Method updateIntegrationMessages must be implemented by subclass');
     }
 
     /**
@@ -109,9 +97,7 @@ 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');
     }
 
     /**
@@ -122,9 +108,7 @@ 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');
     }
 
     /**
@@ -136,9 +120,7 @@ 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

@@ -50,3 +50,4 @@ module.exports = {
     ProcessRepositoryPostgres,
     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,9 +54,7 @@ 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');
     }
 
     /**
@@ -65,10 +63,7 @@ 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');
     }
 
@@ -92,3 +87,4 @@ class ProcessRepositoryInterface {
 }
 
 module.exports = { ProcessRepositoryInterface };
+

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

@@ -1,7 +1,5 @@
 const { prisma } = require('../../database/prisma');
-const {
-    ProcessRepositoryInterface,
-} = require('./process-repository-interface');
+const { ProcessRepositoryInterface } = require('./process-repository-interface');
 
 /**
  * MongoDB Process Repository Adapter
@@ -120,10 +118,7 @@ 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,
@@ -192,3 +187,4 @@ 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,15 +11,14 @@ 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;
@@ -39,10 +38,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({})
         };
     }
 
@@ -53,7 +52,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);

package/integrations/tests/doubles/dummy-integration-class.js

@@ -1,9 +1,8 @@
 const { IntegrationBase } = require('../../integration-base');
-const { Options } = require('../../options');
 
 class DummyModule {
     static definition = {
-        getName: () => 'dummy',
+        getName: () => 'dummy'
     };
 }
 
@@ -12,25 +11,21 @@ class DummyIntegration extends IntegrationBase {
         name: 'dummy',
         version: '1.0.0',
         modules: {
-            dummy: DummyModule,
+            dummy: DummyModule
         },
         display: {
             label: 'Dummy Integration',
             description: 'A dummy integration for testing',
             detailsUrl: 'https://example.com',
-            icon: 'dummy-icon',
-        },
+            icon: 'dummy-icon'
+        }
     };
 
     static getOptionDetails() {
-        const options = new Options({
-            module: Object.values(this.Definition.modules)[0],
-            ...this.Definition,
-        });
         return {
             name: this.Definition.name,
             version: this.Definition.version,
-            ...options.get(),
+            display: this.Definition.display
         };
     }
 
@@ -46,11 +41,11 @@ class DummyIntegration extends IntegrationBase {
         };
 
         this.updateIntegrationStatus = {
-            execute: jest.fn().mockResolvedValue({}),
+            execute: jest.fn().mockResolvedValue({})
         };
 
         this.updateIntegrationMessages = {
-            execute: jest.fn().mockResolvedValue({}),
+            execute: jest.fn().mockResolvedValue({})
         };
     }
 
@@ -107,72 +102,4 @@ class DummyIntegration extends IntegrationBase {
     }
 }
 
-class DummyIntegrationWithGlobalEntity extends IntegrationBase {
-    static Definition = {
-        name: 'dummy-with-global',
-        version: '1.0.0',
-        modules: { dummy: DummyModule },
-        display: { label: 'Dummy With Global', description: 'Test' },
-        entities: {
-            sharedService: {
-                type: 'shared-api',
-                global: true,
-                required: true,
-            },
-        },
-    };
-
-    constructor(params) {
-        super(params);
-        this.sendSpy = jest.fn();
-        this.integrationRepository = {
-            updateIntegrationById: jest.fn().mockResolvedValue({}),
-            findIntegrationById: jest.fn().mockResolvedValue({}),
-        };
-        this.updateIntegrationStatus = { execute: jest.fn().mockResolvedValue({}) };
-        this.updateIntegrationMessages = { execute: jest.fn().mockResolvedValue({}) };
-    }
-
-    async loadDynamicUserActions() { return {}; }
-    async send(event, data) { this.sendSpy(event, data); return { event, data }; }
-    async initialize() { return; }
-    async onCreate() { return; }
-}
-
-class DummyIntegrationWithOptionalGlobalEntity extends IntegrationBase {
-    static Definition = {
-        name: 'dummy-with-optional-global',
-        version: '1.0.0',
-        modules: { dummy: DummyModule },
-        display: { label: 'Dummy With Optional Global', description: 'Test' },
-        entities: {
-            optionalService: {
-                type: 'optional-api',
-                global: true,
-                required: false,
-            },
-        },
-    };
-
-    constructor(params) {
-        super(params);
-        this.sendSpy = jest.fn();
-        this.integrationRepository = {
-            updateIntegrationById: jest.fn().mockResolvedValue({}),
-            findIntegrationById: jest.fn().mockResolvedValue({}),
-        };
-        this.updateIntegrationStatus = { execute: jest.fn().mockResolvedValue({}) };
-        this.updateIntegrationMessages = { execute: jest.fn().mockResolvedValue({}) };
-    }
-
-    async loadDynamicUserActions() { return {}; }
-    async send(event, data) { this.sendSpy(event, data); return { event, data }; }
-    async initialize() { return; }
-    async onCreate() { return; }
-}
-
-module.exports = {
-    DummyIntegration,
-    DummyIntegrationWithGlobalEntity,
-    DummyIntegrationWithOptionalGlobalEntity,
-};
+module.exports = { DummyIntegration };