@friggframework/core 2.0.0--canary.397.1b51778.0 → 2.0.0--canary.397.155fecd.0

package/integrations/tests/use-cases/update-integration-status.test.js

@@ -0,0 +1,103 @@
+const { UpdateIntegrationStatus } = require('../../use-cases/update-integration-status');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+
+describe('UpdateIntegrationStatus Use-Case', () => {
+    let integrationRepository;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        useCase = new UpdateIntegrationStatus({
+            integrationRepository,
+        });
+    });
+
+    describe('happy path', () => {
+        it('updates integration status', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            const result = await useCase.execute(record.id, 'ACTIVE');
+
+            expect(result).toBe(true);
+
+            const updatedRecord = await integrationRepository.findIntegrationById(record.id);
+            expect(updatedRecord.status).toBe('ACTIVE');
+        });
+
+        it('tracks status update operation', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+            integrationRepository.clearHistory();
+
+            await useCase.execute(record.id, 'PAUSED');
+
+            const history = integrationRepository.getOperationHistory();
+            const updateOperation = history.find(op => op.operation === 'updateStatus');
+            expect(updateOperation).toEqual({
+                operation: 'updateStatus',
+                id: record.id,
+                status: 'PAUSED',
+                success: true
+            });
+        });
+
+        it('handles different status values', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            const statuses = ['ACTIVE', 'PAUSED', 'ERROR', 'DISABLED'];
+
+            for (const status of statuses) {
+                await useCase.execute(record.id, status);
+                const updatedRecord = await integrationRepository.findIntegrationById(record.id);
+                expect(updatedRecord.status).toBe(status);
+            }
+        });
+    });
+
+    describe('error cases', () => {
+        it('returns false when integration not found', async () => {
+            const nonExistentId = 'non-existent-id';
+
+            const result = await useCase.execute(nonExistentId, 'ACTIVE');
+
+            expect(result).toBe(false);
+        });
+
+        it('tracks failed update operation', async () => {
+            const nonExistentId = 'non-existent-id';
+            integrationRepository.clearHistory();
+
+            await useCase.execute(nonExistentId, 'ACTIVE');
+
+            const history = integrationRepository.getOperationHistory();
+            const updateOperation = history.find(op => op.operation === 'updateStatus');
+            expect(updateOperation).toEqual({
+                operation: 'updateStatus',
+                id: nonExistentId,
+                status: 'ACTIVE',
+                success: false
+            });
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles null status value', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            const result = await useCase.execute(record.id, null);
+
+            expect(result).toBe(true);
+            const updatedRecord = await integrationRepository.findIntegrationById(record.id);
+            expect(updatedRecord.status).toBeNull();
+        });
+
+        it('handles empty string status', async () => {
+            const record = await integrationRepository.createIntegration(['entity-1'], 'user-1', { type: 'dummy' });
+
+            const result = await useCase.execute(record.id, '');
+
+            expect(result).toBe(true);
+            const updatedRecord = await integrationRepository.findIntegrationById(record.id);
+            expect(updatedRecord.status).toBe('');
+        });
+    });
+});

package/integrations/tests/use-cases/update-integration.test.js

@@ -0,0 +1,134 @@
+const { UpdateIntegration } = require('../../use-cases/update-integration');
+const { TestIntegrationRepository } = require('../doubles/test-integration-repository');
+const { TestModuleFactory } = require('../../../modules/tests/doubles/test-module-factory');
+const { DummyIntegration } = require('../doubles/dummy-integration-class');
+
+describe('UpdateIntegration Use-Case', () => {
+    let integrationRepository;
+    let moduleFactory;
+    let useCase;
+
+    beforeEach(() => {
+        integrationRepository = new TestIntegrationRepository();
+        moduleFactory = new TestModuleFactory();
+        useCase = new UpdateIntegration({
+            integrationRepository,
+            integrationClasses: [DummyIntegration],
+            moduleFactory,
+        });
+    });
+
+    describe('happy path', () => {
+        it('calls on update and returns dto', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
+
+            const newConfig = { type: 'dummy', foo: 'baz' };
+            const dto = await useCase.execute(record.id, 'user-1', newConfig);
+
+            expect(dto.config.foo).toBe('baz');
+            expect(dto.id).toBe(record.id);
+            expect(dto.userId).toBe('user-1');
+        });
+
+        it('triggers ON_UPDATE event with correct payload', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
+            integrationRepository.clearHistory();
+
+            const newConfig = { type: 'dummy', foo: 'updated' };
+            await useCase.execute(record.id, 'user-1', newConfig);
+
+            const history = integrationRepository.getOperationHistory();
+            const findOperation = history.find(op => op.operation === 'findById');
+            expect(findOperation).toEqual({
+                operation: 'findById',
+                id: record.id,
+                found: true
+            });
+        });
+
+        it('updates integration with multiple entities', async () => {
+            const record = await integrationRepository.createIntegration(['e1', 'e2'], 'user-1', { type: 'dummy' });
+
+            const newConfig = { type: 'dummy', updated: true };
+            const dto = await useCase.execute(record.id, 'user-1', newConfig);
+
+            expect(dto.entities).toEqual(['e1', 'e2']);
+            expect(dto.config.updated).toBe(true);
+        });
+    });
+
+    describe('error cases', () => {
+        it('throws error when integration not found', async () => {
+            const nonExistentId = 'non-existent-id';
+            const newConfig = { type: 'dummy', foo: 'baz' };
+
+            await expect(useCase.execute(nonExistentId, 'user-1', newConfig))
+                .rejects
+                .toThrow(`No integration found by the ID of ${nonExistentId}`);
+        });
+
+        it('throws error when integration class not found', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'unknown-type' });
+
+            const newConfig = { type: 'unknown-type', foo: 'baz' };
+
+            await expect(useCase.execute(record.id, 'user-1', newConfig))
+                .rejects
+                .toThrow('No integration class found for type: unknown-type');
+        });
+
+        it('throws error when user does not own integration', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+
+            const newConfig = { type: 'dummy', foo: 'baz' };
+
+            await expect(useCase.execute(record.id, 'different-user', newConfig))
+                .rejects
+                .toThrow(`Integration ${record.id} does not belong to User different-user`);
+        });
+
+        it('throws error when no integration classes provided', async () => {
+            const useCaseWithoutClasses = new UpdateIntegration({
+                integrationRepository,
+                integrationClasses: [],
+                moduleFactory,
+            });
+
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy' });
+            const newConfig = { type: 'dummy', foo: 'baz' };
+
+            await expect(useCaseWithoutClasses.execute(record.id, 'user-1', newConfig))
+                .rejects
+                .toThrow('No integration class found for type: dummy');
+        });
+    });
+
+    describe('edge cases', () => {
+        it('handles config with null values', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', foo: 'bar' });
+
+            const newConfig = { type: 'dummy', foo: null, bar: undefined };
+            const dto = await useCase.execute(record.id, 'user-1', newConfig);
+
+            expect(dto.config.foo).toBeNull();
+            expect(dto.config.bar).toBeUndefined();
+        });
+
+        it('handles deeply nested config updates', async () => {
+            const record = await integrationRepository.createIntegration(['e1'], 'user-1', { type: 'dummy', nested: { old: 'value' } });
+
+            const newConfig = {
+                type: 'dummy',
+                nested: {
+                    new: 'value',
+                    deep: { level: 'test' }
+                }
+            };
+            const dto = await useCase.execute(record.id, 'user-1', newConfig);
+
+            expect(dto.config.nested.new).toBe('value');
+            expect(dto.config.nested.deep.level).toBe('test');
+            expect(dto.config.nested.old).toBeUndefined();
+        });
+    });
+}); 

package/integrations/use-cases/create-integration.js

@@ -1,12 +1,17 @@
 const { Integration } = require('../integration');
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 
+/**
+ * Use case for creating a new integration instance.
+ * @class CreateIntegration
+ */
 class CreateIntegration {
     /**
-     * @param {Object} params
-     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository
-     * @param {import('../integration-classes').IntegrationClasses} params.integrationClasses
-     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory
+     * Creates a new CreateIntegration instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
+     * @param {import('../integration-classes').IntegrationClasses} params.integrationClasses - Array of available integration classes.
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
      */
     constructor({ integrationRepository, integrationClasses, moduleFactory }) {
         this.integrationRepository = integrationRepository;
@@ -14,6 +19,16 @@ class CreateIntegration {
         this.moduleFactory = moduleFactory;
     }
 
+    /**
+     * Executes the integration creation process.
+     * @async
+     * @param {string[]} entities - Array of entity IDs to associate with the integration.
+     * @param {string} userId - ID of the user creating the integration.
+     * @param {Object} config - Configuration object for the integration.
+     * @param {string} config.type - Type of integration to create.
+     * @returns {Promise<Object>} The created integration DTO.
+     * @throws {Error} When integration class is not found for the specified type.
+     */
     async execute(entities, userId, config) {
         const integrationRecord = await this.integrationRepository.createIntegration(entities, userId, config);
 

package/integrations/use-cases/delete-integration-for-user.js

@@ -1,7 +1,17 @@
 const Boom = require('@hapi/boom');
 const { Integration } = require('../integration');
 
+/**
+ * Use case for deleting an integration for a specific user.
+ * @class DeleteIntegrationForUser
+ */
 class DeleteIntegrationForUser {
+    /**
+     * Creates a new DeleteIntegrationForUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     */
     constructor({ integrationRepository, integrationClasses }) {
 
         /**
@@ -11,6 +21,15 @@ class DeleteIntegrationForUser {
         this.integrationClasses = integrationClasses;
     }
 
+    /**
+     * Executes the deletion of an integration for a user.
+     * @async
+     * @param {string} integrationId - ID of the integration to delete.
+     * @param {string} userId - ID of the user requesting the deletion.
+     * @returns {Promise<void>} Resolves when the integration is successfully deleted.
+     * @throws {Boom.notFound} When integration with the specified ID does not exist.
+     * @throws {Error} When the integration doesn't belong to the specified user.
+     */
     async execute(integrationId, userId) {
         const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
 

package/integrations/use-cases/get-integration-for-user.js

@@ -1,7 +1,19 @@
 const { Integration } = require('../integration');
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 
+/**
+ * Use case for retrieving a single integration for a specific user.
+ * @class GetIntegrationForUser
+ */
 class GetIntegrationForUser {
+    /**
+     * Creates a new GetIntegrationForUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
+     * @param {import('../../modules/module-repository').ModuleRepository} params.moduleRepository - Repository for module and entity data operations.
+     */
     constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
 
         /**
@@ -14,9 +26,13 @@ class GetIntegrationForUser {
     }
 
     /**
-     * @param {string} integrationId
-     * @param {string} userId
-     * @returns {Promise<Integration>}
+     * Executes the retrieval of a single integration for a user.
+     * @async
+     * @param {string} integrationId - ID of the integration to retrieve.
+     * @param {string} userId - ID of the user requesting the integration.
+     * @returns {Promise<Object>} The integration DTO for the specified user.
+     * @throws {Boom.notFound} When integration with the specified ID does not exist.
+     * @throws {Boom.forbidden} When user does not have access to the integration.
      */
     async execute(integrationId, userId) {
         const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
@@ -26,7 +42,7 @@ class GetIntegrationForUser {
             throw Boom.notFound(`Integration with id of ${integrationId} does not exist`);
         }
 
-        if (integrationRecord.user.toString() !== userId.toString()) {
+        if (integrationRecord.userId.toString() !== userId.toString()) {
             throw Boom.forbidden('User does not have access to this integration');
         }
 
@@ -38,14 +54,14 @@ class GetIntegrationForUser {
         for (const entity of entities) {
             const moduleInstance = await this.moduleFactory.getModuleInstance(
                 entity._id,
-                integrationRecord.user
+                integrationRecord.userId
             );
             modules.push(moduleInstance);
         }
 
         const integrationInstance = new Integration({
             id: integrationRecord._id,
-            userId: integrationRecord.user,
+            userId: integrationRecord.userId,
             entities: entities,
             config: integrationRecord.config,
             status: integrationRecord.status,

package/integrations/use-cases/get-integration-instance.js

@@ -1,11 +1,14 @@
 const { Integration } = require('../integration');
 
+/**
+ * Use case for retrieving a single integration instance by ID and user.
+ * @class GetIntegrationInstance
+ */
 class GetIntegrationInstance {
 
     /**
-     * @class GetIntegrationInstance
-     * @description Use case for retrieving a single integration instance by ID and user.
-     * @param {Object} params
+     * Creates a new GetIntegrationInstance instance.
+     * @param {Object} params - Configuration parameters.
      * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data access
      * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
      * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management
@@ -20,6 +23,14 @@ class GetIntegrationInstance {
         this.moduleFactory = moduleFactory;
     }
 
+    /**
+     * Executes the retrieval of a single integration instance.
+     * @async
+     * @param {string} integrationId - ID of the integration to retrieve.
+     * @param {string} userId - ID of the user requesting the integration.
+     * @returns {Promise<Integration>} The fully initialized integration instance.
+     * @throws {Error} When integration is not found, doesn't belong to user, or integration class is not found.
+     */
     async execute(integrationId, userId) {
         const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
 

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

@@ -1,7 +1,19 @@
 const { Integration } = require('../integration');
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 
+/**
+ * Use case for retrieving all integrations for a specific user.
+ * @class GetIntegrationsForUser
+ */
 class GetIntegrationsForUser {
+    /**
+     * Creates a new GetIntegrationsForUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
+     * @param {import('../../modules/module-repository').ModuleRepository} params.moduleRepository - Repository for module and entity data operations.
+     */
     constructor({ integrationRepository, integrationClasses, moduleFactory, moduleRepository }) {
 
         /**
@@ -14,8 +26,10 @@ class GetIntegrationsForUser {
     }
 
     /**
-     * @param {string} userId
-     * @returns {Promise<Integration[]>}
+     * Executes the retrieval of all integrations for a user.
+     * @async
+     * @param {string} userId - ID of the user whose integrations to retrieve.
+     * @returns {Promise<Object[]>} Array of integration DTOs for the specified user.
      */
     async execute(userId) {
         const integrationRecords = await this.integrationRepository.findIntegrationsByUserId(userId);
@@ -40,7 +54,7 @@ class GetIntegrationsForUser {
 
             const integrationInstance = new Integration({
                 id: integrationRecord.id,
-                userId: integrationRecord.user,
+                userId: integrationRecord.userId,
                 entities: entities,
                 config: integrationRecord.config,
                 status: integrationRecord.status,

package/integrations/use-cases/get-possible-integrations.js

@@ -1,8 +1,22 @@
+/**
+ * Use case for retrieving all possible integration types that can be created.
+ * @class GetPossibleIntegrations
+ */
 class GetPossibleIntegrations {
+    /**
+     * Creates a new GetPossibleIntegrations instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
+     */
     constructor({ integrationClasses }) {
         this.integrationClasses = integrationClasses;
     }
 
+    /**
+     * Executes the retrieval of all possible integration types.
+     * @async
+     * @returns {Promise<Object[]>} Array of integration option details for all available integration types.
+     */
     async execute() {
         return this.integrationClasses.map((integrationClass) =>
             integrationClass.getOptionDetails()

package/integrations/use-cases/update-integration-messages.js

@@ -1,15 +1,26 @@
+/**
+ * Use case for updating messages associated with an integration.
+ * @class UpdateIntegrationMessages
+ */
 class UpdateIntegrationMessages {
+    /**
+     * Creates a new UpdateIntegrationMessages instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
+     */
     constructor({ integrationRepository }) {
         this.integrationRepository = integrationRepository;
     }
 
     /**
-     * @param {string} integrationId
-     * @param {string} messageType - 'errors', 'warnings', 'info' or 'logs'
-     * @param {string} messageTitle,
-     * @param {string} messageBody,
-     * @param {string} messageTimestamp,
-     * @returns {Promise<Object>}
+     * Executes the integration messages update.
+     * @async
+     * @param {string} integrationId - ID of the integration to update.
+     * @param {string} messageType - Type of message: 'errors', 'warnings', 'info', or 'logs'.
+     * @param {string} messageTitle - Title of the message.
+     * @param {string} messageBody - Body content of the message.
+     * @param {string} messageTimestamp - Timestamp when the message was created.
+     * @returns {Promise<Object>} The updated integration record.
      */
     async execute(integrationId, messageType, messageTitle, messageBody, messageTimestamp) {
         const integration = await this.integrationRepository.updateIntegrationMessages(integrationId, messageType, messageTitle, messageBody, messageTimestamp);

package/integrations/use-cases/update-integration-status.js

@@ -1,8 +1,24 @@
+/**
+ * Use case for updating the status of an integration.
+ * @class UpdateIntegrationStatus
+ */
 class UpdateIntegrationStatus {
+    /**
+     * Creates a new UpdateIntegrationStatus instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data operations.
+     */
     constructor({ integrationRepository }) {
         this.integrationRepository = integrationRepository;
     }
 
+    /**
+     * Executes the integration status update.
+     * @async
+     * @param {string} integrationId - ID of the integration to update.
+     * @param {string} status - New status for the integration (e.g., 'ENABLED', 'DISABLED', 'ERROR').
+     * @returns {Promise<Object>} The updated integration record.
+     */
     async execute(integrationId, status) {
         const integration = await this.integrationRepository.updateIntegrationStatus(integrationId, status);
         return integration;

package/integrations/use-cases/update-integration.js

@@ -1,13 +1,15 @@
 const { Integration } = require('../integration');
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 
-
+/**
+ * Use case for updating a single integration by ID and user.
+ * @class UpdateIntegration
+ */
 class UpdateIntegration {
 
     /**
-     * @class UpdateIntegration
-     * @description Use case for updating a single integration by ID and user.
-     * @param {Object} params
+     * Creates a new UpdateIntegration instance.
+     * @param {Object} params - Configuration parameters.
      * @param {import('../integration-repository').IntegrationRepository} params.integrationRepository - Repository for integration data access
      * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes
      * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management
@@ -22,6 +24,15 @@ class UpdateIntegration {
         this.moduleFactory = moduleFactory;
     }
 
+    /**
+     * Executes the integration update process.
+     * @async
+     * @param {string} integrationId - ID of the integration to update.
+     * @param {string} userId - ID of the user requesting the update.
+     * @param {Object} config - New configuration object for the integration.
+     * @returns {Promise<Object>} The updated integration DTO.
+     * @throws {Error} When integration is not found, doesn't belong to user, or integration class is not found.
+     */
     async execute(integrationId, userId, config) {
         // 1. Get integration record from repository
         const integrationRecord = await this.integrationRepository.findIntegrationById(integrationId);
@@ -56,12 +67,12 @@ class UpdateIntegration {
             modules.push(moduleInstance);
         }
 
-        // 4. Create the Integration domain entity with modules
+        // 4. Create the Integration domain entity with modules and updated config
         const integrationInstance = new Integration({
             id: integrationRecord.id,
             userId: integrationRecord.userId,
             entities: integrationRecord.entitiesIds,
-            config: integrationRecord.config,
+            config: config,
             status: integrationRecord.status,
             version: integrationRecord.version,
             messages: integrationRecord.messages,

package/modules/module-repository.js

@@ -19,26 +19,6 @@ class ModuleRepository {
         };
     }
 
-    async findEntitiesByIds(entitiesIds) {
-        const entitiesRecords = await Entity.find({ _id: { $in: entitiesIds } }, '', { lean: true }).populate('credential');
-
-        // todo: this is a workaround needed while we create an integration with the same entity twice
-        if (entitiesRecords.length !== entitiesIds.length && entitiesIds[0] !== entitiesIds[1]) {
-            throw new Error(`Some entities not found`);
-        }
-
-        return entitiesRecords.map(e => ({
-            id: e._id,
-            accountId: e.accountId,
-            credential: e.credential,
-            userId: e.user.toString(),
-            name: e.name,
-            externalId: e.externalId,
-            type: e.__t,
-            moduleName: e.moduleName,
-        }));
-    }
-
     async findEntitiesByUserId(userId) {
         const entitiesRecords = await Entity.find(
             { user: userId },
@@ -84,7 +64,8 @@ class ModuleRepository {
      * @returns {Promise<import('mongoose').UpdateWriteOpResult>}
      */
     async unsetCredential(entityId) {
-        return Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } });
+        const result = await Entity.updateOne({ _id: entityId }, { $unset: { credential: "" } });
+        return result.acknowledged;
     }
 }
 

package/modules/tests/doubles/test-module-factory.js

@@ -0,0 +1,16 @@
+class TestModuleFactory {
+    constructor() { }
+
+    async getModuleInstance(entityId, userId) {
+        // return minimal stub module with getName and api property
+        return {
+            getName() { return 'stubModule'; },
+            api: {},
+            entityId,
+            userId,
+            testAuth: async () => true,
+        };
+    }
+}
+
+module.exports = { TestModuleFactory }; 

package/modules/tests/doubles/test-module-repository.js

@@ -0,0 +1,19 @@
+class TestModuleRepository {
+    constructor() {
+        this.entities = new Map();
+    }
+
+    addEntity(entity) {
+        this.entities.set(entity.id, entity);
+    }
+
+    async findEntityById(id) {
+        return this.entities.get(id);
+    }
+
+    async findEntitiesByIds(ids) {
+        return ids.map((id) => this.entities.get(id));
+    }
+}
+
+module.exports = { TestModuleRepository };