@friggframework/core 2.0.0--canary.710.91495fa.0 → 2.0.0--canary.667.f74cf3b.0

package/integrations/integration-router.js

@@ -42,6 +42,9 @@ const {
 } = require('../modules/use-cases/get-entity-options-by-type');
 const { TestModuleAuth } = require('../modules/use-cases/test-module-auth');
 const { GetModule } = require('../modules/use-cases/get-module');
+const {
+    CreateEntityFromCredential,
+} = require('../modules/use-cases/create-entity-from-credential');
 const {
     GetEntityOptionsById,
 } = require('../modules/use-cases/get-entity-options-by-id');
@@ -198,6 +201,13 @@ function createIntegrationRouter() {
             getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
+    const createEntityFromCredential = new CreateEntityFromCredential({
+        processAuthorizationCallback,
+        credentialRepository,
+        moduleDefinitions:
+            getModulesDefinitionFromIntegrationClasses(integrationClasses),
+    });
+
     const router = express();
 
     setIntegrationRoutes(router, authenticateUser, {
@@ -218,6 +228,7 @@ function createIntegrationRouter() {
         getEntityOptionsById,
         refreshEntityOptions,
         processAuthorizationCallback,
+        createEntityFromCredential,
     });
     return router;
 }
@@ -502,6 +513,7 @@ function setEntityRoutes(router, authenticateUser, useCases) {
         getEntityOptionsById,
         refreshEntityOptions,
         processAuthorizationCallback,
+        createEntityFromCredential,
     } = useCases;
 
     router.route('/api/authorize').get(
@@ -566,35 +578,19 @@ function setEntityRoutes(router, authenticateUser, useCases) {
     router.route('/api/entity').post(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
-            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entityType',
                 'data',
             ]);
             checkRequiredParams(req.body.data, ['credential_id']);
 
-            // May want to pass along the user ID as well so credential ID's can't be fished???
-            const credential = await getCredentialForUser.execute(
-                params.data.credential_id,
-                userId
-            );
-
-            if (!credential) {
-                throw Boom.badRequest('Invalid credential ID');
-            }
-
-            const module = await getModuleInstanceFromType.execute(
-                userId,
-                params.entityType
+            res.json(
+                await createEntityFromCredential.execute({
+                    user,
+                    entityType: params.entityType,
+                    credentialId: params.data.credential_id,
+                })
             );
-            const entityDetails = await module.getEntityDetails(
-                module.api,
-                null,
-                null,
-                userId
-            );
-
-            res.json(await module.findOrCreateEntity(entityDetails));
         })
     );
 

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

@@ -1,5 +1,4 @@
 const { prisma } = require('../../database/prisma');
-const { MappingAlreadyExistsError } = require('../../errors');
 const {
     toObjectId,
     fromObjectId,
@@ -181,55 +180,6 @@ class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositor
         return this._mapMapping(decryptedMapping);
     }
 
-    async createMapping(integrationId, sourceId, mapping) {
-        const now = new Date();
-        const encryptedDocument = await this.encryptionService.encryptFields(
-            'IntegrationMapping',
-            {
-                integrationId,
-                sourceId:
-                    sourceId === null || sourceId === undefined
-                        ? null
-                        : String(sourceId),
-                mapping,
-                createdAt: now,
-                updatedAt: now,
-            }
-        );
-
-        let insertedId;
-        try {
-            insertedId = await insertOne(
-                this.prisma,
-                'IntegrationMapping',
-                encryptedDocument
-            );
-        } catch (error) {
-            if (error.code === 11000) {
-                throw new MappingAlreadyExistsError(integrationId, sourceId, {
-                    cause: error,
-                });
-            }
-            throw error;
-        }
-
-        const created = await findOne(this.prisma, 'IntegrationMapping', {
-            _id: insertedId,
-        });
-        if (!created) {
-            throw new Error(
-                'Failed to create mapping: Document not found after insert. ' +
-                    'This indicates a database consistency issue.'
-            );
-        }
-        return this._mapMapping(
-            await this.encryptionService.decryptFields(
-                'IntegrationMapping',
-                created
-            )
-        );
-    }
-
     async findMappingsByIntegration(integrationId) {
         const filter = {};
         if (integrationId) filter.integrationId = integrationId;

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

@@ -39,21 +39,6 @@ class IntegrationMappingRepositoryInterface {
         throw new Error('Method upsertMapping must be implemented by subclass');
     }
 
-    /**
-     * Insert a mapping, failing if one already exists for the
-     * (integrationId, sourceId) pair. Atomic: usable as a claim/lock row.
-     *
-     * @param {string|number} integrationId - The integration ID
-     * @param {string} sourceId - The source ID for lookup
-     * @param {Object} mapping - The mapping data
-     * @returns {Promise<Object>} The created mapping document
-     * @throws {MappingAlreadyExistsError} If the pair already exists
-     * @abstract
-     */
-    async createMapping(integrationId, sourceId, mapping) {
-        throw new Error('createMapping must be implemented by subclass');
-    }
-
     /**
      * Find all mappings for an integration
      *

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

@@ -1,5 +1,4 @@
 const { prisma } = require('../../database/prisma');
-const { MappingAlreadyExistsError } = require('../../errors');
 const {
     assertMappingWrittenUnencrypted,
     decryptQueriedMappings,
@@ -94,34 +93,6 @@ class IntegrationMappingRepositoryMongo extends IntegrationMappingRepositoryInte
         });
     }
 
-    /**
-     * Insert a mapping; fails if (integrationId, sourceId) already exists
-     *
-     * @param {string} integrationId - The integration ID
-     * @param {string} sourceId - The source ID
-     * @param {Object} mapping - The mapping data
-     * @returns {Promise<Object>} The created mapping document
-     * @throws {MappingAlreadyExistsError} If the pair already exists
-     */
-    async createMapping(integrationId, sourceId, mapping) {
-        try {
-            return await this.prisma.integrationMapping.create({
-                data: {
-                    integrationId,
-                    sourceId: this._toString(sourceId),
-                    mapping,
-                },
-            });
-        } catch (error) {
-            if (error.code === 'P2002') {
-                throw new MappingAlreadyExistsError(integrationId, sourceId, {
-                    cause: error,
-                });
-            }
-            throw error;
-        }
-    }
-
     /**
      * Find all mappings for an integration
      * Replaces: IntegrationMapping.find({ integration: integrationId })

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

@@ -1,5 +1,4 @@
 const { prisma } = require('../../database/prisma');
-const { MappingAlreadyExistsError } = require('../../errors');
 const {
     assertMappingWrittenUnencrypted,
     decryptQueriedMappings,
@@ -151,35 +150,6 @@ class IntegrationMappingRepositoryPostgres extends IntegrationMappingRepositoryI
         return this._convertMappingIds(result);
     }
 
-    /**
-     * Insert a mapping; fails if (integrationId, sourceId) already exists
-     *
-     * @param {string} integrationId - The integration ID
-     * @param {string} sourceId - The source ID
-     * @param {Object} mapping - The mapping data
-     * @returns {Promise<Object>} The created mapping document
-     * @throws {MappingAlreadyExistsError} If the pair already exists
-     */
-    async createMapping(integrationId, sourceId, mapping) {
-        try {
-            const created = await this.prisma.integrationMapping.create({
-                data: {
-                    integrationId: this._stringToInt(integrationId),
-                    sourceId: this._toString(sourceId),
-                    mapping,
-                },
-            });
-            return this._convertMappingIds(created);
-        } catch (error) {
-            if (error.code === 'P2002') {
-                throw new MappingAlreadyExistsError(integrationId, sourceId, {
-                    cause: error,
-                });
-            }
-            throw error;
-        }
-    }
-
     /**
      * Find all mappings for an integration
      * Replaces: IntegrationMapping.find({ integration: integrationId })

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

@@ -1,5 +1,4 @@
 const { prisma } = require('../../database/prisma');
-const { MappingAlreadyExistsError } = require('../../errors');
 const {
     IntegrationMappingRepositoryInterface,
 } = require('./integration-mapping-repository-interface');
@@ -70,34 +69,6 @@ class IntegrationMappingRepository extends IntegrationMappingRepositoryInterface
         });
     }
 
-    /**
-     * Insert a mapping; fails if (integrationId, sourceId) already exists
-     *
-     * @param {string} integrationId - The integration ID
-     * @param {string} sourceId - The source ID
-     * @param {Object} mapping - The mapping data
-     * @returns {Promise<Object>} The created mapping document
-     * @throws {MappingAlreadyExistsError} If the pair already exists
-     */
-    async createMapping(integrationId, sourceId, mapping) {
-        try {
-            return await this.prisma.integrationMapping.create({
-                data: {
-                    integrationId,
-                    sourceId,
-                    mapping,
-                },
-            });
-        } catch (error) {
-            if (error.code === 'P2002') {
-                throw new MappingAlreadyExistsError(integrationId, sourceId, {
-                    cause: error,
-                });
-            }
-            throw error;
-        }
-    }
-
     /**
      * Find all mappings for an integration
      * Replaces: IntegrationMapping.find({ integration: integrationId })

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

@@ -164,38 +164,6 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         return this._mapIntegration(created);
     }
 
-    async addEntitiesToIntegration(integrationId, entityIds) {
-        const objectId = toObjectId(integrationId);
-        if (!objectId) return null;
-        const result = await updateOne(
-            this.prisma,
-            'Integration',
-            { _id: objectId },
-            {
-                $addToSet: { entityIds: { $each: toObjectIdArray(entityIds) } },
-                $set: { updatedAt: { $date: new Date().toISOString() } },
-            }
-        );
-        if (!result?.n) return null;
-        return this.findIntegrationById(integrationId);
-    }
-
-    async removeEntitiesFromIntegration(integrationId, entityIds) {
-        const objectId = toObjectId(integrationId);
-        if (!objectId) return null;
-        const result = await updateOne(
-            this.prisma,
-            'Integration',
-            { _id: objectId },
-            {
-                $pullAll: { entityIds: toObjectIdArray(entityIds) },
-                $set: { updatedAt: { $date: new Date().toISOString() } },
-            }
-        );
-        if (!result?.n) return null;
-        return this.findIntegrationById(integrationId);
-    }
-
     async findIntegrationByUserId(userId) {
         const objectId = toObjectId(userId);
         if (!objectId) return null;

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

@@ -184,36 +184,6 @@ class IntegrationRepositoryInterface {
             'Method findIntegrationsByEntityId must be implemented by subclass'
         );
     }
-
-    /**
-     * Attach entities to an existing integration. Entities that are already
-     * attached are left as they are.
-     *
-     * @param {string|number} integrationId - Integration ID
-     * @param {Array<string|number>} entityIds - Entity IDs to attach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     * @abstract
-     */
-    async addEntitiesToIntegration(integrationId, entityIds) {
-        throw new Error(
-            'Method addEntitiesToIntegration must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Detach entities from an integration. Entities that are not attached
-     * are ignored; the entities themselves are not deleted.
-     *
-     * @param {string|number} integrationId - Integration ID
-     * @param {Array<string|number>} entityIds - Entity IDs to detach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     * @abstract
-     */
-    async removeEntitiesFromIntegration(integrationId, entityIds) {
-        throw new Error(
-            'Method removeEntitiesFromIntegration must be implemented by subclass'
-        );
-    }
 }
 
 module.exports = { IntegrationRepositoryInterface };

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

@@ -338,58 +338,6 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         };
     }
 
-    /**
-     * Attach entities to an existing integration. Entities already attached
-     * are left as they are.
-     *
-     * @param {string} integrationId - Integration ID
-     * @param {Array<string>} entityIds - Entity IDs to attach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     */
-    async addEntitiesToIntegration(integrationId, entityIds) {
-
-        try {
-            await this.prisma.integration.update({
-                where: { id: integrationId },
-                data: {
-                    entities: {
-                        connect: entityIds.map((id) => ({ id })),
-                    },
-                },
-            });
-        } catch (error) {
-            if (error.code === 'P2025') return null;
-            throw error;
-        }
-        return this.findIntegrationById(integrationId);
-    }
-
-    /**
-     * Detach entities from an integration. Entities that are not attached
-     * are ignored. The entities themselves are not deleted.
-     *
-     * @param {string} integrationId - Integration ID
-     * @param {Array<string>} entityIds - Entity IDs to detach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     */
-    async removeEntitiesFromIntegration(integrationId, entityIds) {
-
-        try {
-            await this.prisma.integration.update({
-                where: { id: integrationId },
-                data: {
-                    entities: {
-                        disconnect: entityIds.map((id) => ({ id })),
-                    },
-                },
-            });
-        } catch (error) {
-            if (error.code === 'P2025') return null;
-            throw error;
-        }
-        return this.findIntegrationById(integrationId);
-    }
-
     /**
      * Find integration by user ID (returns single integration)
      * Replaces: IntegrationModel.findOne({ user: userId }).populate('entities')
@@ -471,7 +419,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         for (const [key, value] of Object.entries(patch)) {
             $set[`config.${key}`] = value;
         }
-        $set.updatedAt = { $date: new Date().toISOString() };
+        $set.updatedAt = new Date();
 
         const result = await this.prisma.$runCommandRaw({
             findAndModify: 'Integration',

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

@@ -365,64 +365,6 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         };
     }
 
-    /**
-     * Attach entities to an existing integration. Entities already attached
-     * are left as they are.
-     *
-     * @param {string} integrationId - Integration ID (string from application layer)
-     * @param {Array<string>} entityIds - Entity IDs to attach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     */
-    async addEntitiesToIntegration(integrationId, entityIds) {
-        const intId = this._convertId(integrationId);
-
-        try {
-            await this.prisma.integration.update({
-                where: { id: intId },
-                data: {
-                    entities: {
-                        connect: entityIds.map((id) => ({
-                            id: this._convertId(id),
-                        })),
-                    },
-                },
-            });
-        } catch (error) {
-            if (error.code === 'P2025') return null;
-            throw error;
-        }
-        return this.findIntegrationById(integrationId);
-    }
-
-    /**
-     * Detach entities from an integration. Entities that are not attached
-     * are ignored. The entities themselves are not deleted.
-     *
-     * @param {string} integrationId - Integration ID (string from application layer)
-     * @param {Array<string>} entityIds - Entity IDs to detach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     */
-    async removeEntitiesFromIntegration(integrationId, entityIds) {
-        const intId = this._convertId(integrationId);
-
-        try {
-            await this.prisma.integration.update({
-                where: { id: intId },
-                data: {
-                    entities: {
-                        disconnect: entityIds.map((id) => ({
-                            id: this._convertId(id),
-                        })),
-                    },
-                },
-            });
-        } catch (error) {
-            if (error.code === 'P2025') return null;
-            throw error;
-        }
-        return this.findIntegrationById(integrationId);
-    }
-
     /**
      * Find integration by user ID (returns single integration)
      *

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

@@ -120,7 +120,7 @@ class ProcessRepositoryMongo extends ProcessRepositoryInterface {
         if (normalized.newState !== null) {
             $set.state = normalized.newState;
         }
-        $set.updatedAt = { $date: new Date().toISOString() };
+        $set.updatedAt = new Date();
         update.$set = $set;
 
         if (Object.keys(normalized.pushSlice).length > 0) {

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

@@ -62,7 +62,7 @@ class CreateIntegration {
 
         // A concurrent request may have created a matching row between the
         // lookup above and this insert; re-check before any side effects run.
-        const survivor = await this._findSurvivor(
+        const survivor = await this._findDuplicate(
             userId,
             config?.type,
             entities
@@ -135,68 +135,30 @@ class CreateIntegration {
         return mapIntegrationClassToIntegrationDTO(integrationInstance);
     }
 
-    async _findMatches(userId, type, entityIds) {
+    async _findDuplicate(userId, type, entityIds) {
         const candidates =
             await this.integrationRepository.findIntegrationsByUserId(userId);
-        const target = new Set((entityIds ?? []).map(String));
-
-        const live = candidates.filter(
-            (integration) =>
-                // An IN_DELETION row is either mid-teardown or a zombie left
-                // behind by a failed deleteIntegrationById call — never a live
-                // integration. Treating it as a duplicate would hand a
-                // reinstall attempt a row nothing will ever move out of
-                // IN_DELETION, silently discarded by the queue worker forever.
-                // Let a fresh create proceed instead; the zombie is cleaned up
-                // out-of-band, matching how teardown failures are already
-                // handled here.
-                integration.status !== 'IN_DELETION' &&
-                integration.config?.type === type
-        );
-        const entitySet = (integration) =>
-            new Set((integration.entitiesIds ?? []).map(String));
-
-        const exact = live.filter((integration) => {
-            const current = entitySet(integration);
+        const target = [...(entityIds ?? [])].map(String).sort();
+
+        const matches = candidates.filter((integration) => {
+            // An IN_DELETION row is either mid-teardown or a zombie left
+            // behind by a failed deleteIntegrationById call — never a live
+            // integration. Treating it as a duplicate would hand a reinstall
+            // attempt a row nothing will ever move out of IN_DELETION,
+            // silently discarded by the queue worker forever. Let a fresh
+            // create proceed instead; the zombie is cleaned up out-of-band,
+            // matching how teardown failures are already handled here.
+            if (integration.status === 'IN_DELETION') return false;
+            if (integration.config?.type !== type) return false;
+            const current = [...(integration.entitiesIds ?? [])]
+                .map(String)
+                .sort();
             return (
-                current.size === target.size &&
-                [...target].every((id) => current.has(id))
+                current.length === target.length &&
+                current.every((id, index) => id === target[index])
             );
         });
 
-        // Entities may have been attached after create (addEntitiesToIntegration),
-        // so a reconnect that sends the original entities must still find the
-        // integration that now holds them, instead of creating a second one
-        // that would share those entities.
-        const supersets = live.filter((integration) => {
-            const current = entitySet(integration);
-            return [...target].every((id) => current.has(id));
-        });
-        return { exact, supersets: target.size ? supersets : [] };
-    }
-
-    async _findDuplicate(userId, type, entityIds) {
-        const { exact, supersets } = await this._findMatches(
-            userId,
-            type,
-            entityIds
-        );
-        if (exact.length) return this._pickOldest(exact);
-        return supersets.length ? this._pickOldest(supersets) : null;
-    }
-
-    // After an insert the new row is itself an exact match, so the survivor
-    // is the oldest of every exact or superset match (the new row included):
-    // an older integration that already holds these entities always wins.
-    async _findSurvivor(userId, type, entityIds) {
-        const { exact, supersets } = await this._findMatches(
-            userId,
-            type,
-            entityIds
-        );
-        // supersets includes the exact matches; it is empty only for an
-        // empty entity set, where exact matching alone applies.
-        const matches = supersets.length ? supersets : exact;
         return matches.length ? this._pickOldest(matches) : null;
     }
 

package/jest-setup.js

@@ -1,13 +1,2 @@
-// Core's unit suites must not need a database, so this global setup only
-// sets the test environment. It deliberately does not start an in-memory
-// MongoDB (as @friggframework/test's globalSetup does): nothing in the default
-// suite talks to a live server, and a binary that failed to start used to stop
-// every core suite from running. Suites that need a real database are
-// `*.db.test.js` files, run by `npm run test:db` (see jest.db.config.js).
-const { overrideEnvironment } = require('@friggframework/test');
-
-module.exports = async function () {
-    if (!process.env.STAGE) {
-        overrideEnvironment({ STAGE: 'dev' });
-    }
-};
+const {globalSetup} = require('@friggframework/test');
+module.exports = globalSetup;

package/jest-teardown.js

@@ -1,5 +1,2 @@
-const { restoreEnvironment } = require('@friggframework/test');
-
-module.exports = async function () {
-    restoreEnvironment();
-};
+const {globalTeardown} = require('@friggframework/test');
+module.exports = globalTeardown;

package/jest.config.js

@@ -20,8 +20,4 @@ module.exports = {
     globalTeardown: './jest-teardown.js',
 
     setupFilesAfterEnv: ['./logs/jest-logger-setup.js'],
-
-    // `*.db.test.js` suites talk to a real MongoDB replica set / PostgreSQL
-    // and run separately via `npm run test:db` (jest.db.config.js).
-    testPathIgnorePatterns: ['/node_modules/', '\\.db\\.test\\.js$'],
 };