@friggframework/core 2.0.0--canary.711.f8b6445.0 → 2.0.0--canary.667.f74cf3b.0

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/modules/use-cases/create-entity-from-credential.js

@@ -0,0 +1,105 @@
+const Boom = require('@hapi/boom');
+const { Module } = require('../module');
+
+const sameId = (a, b) =>
+    a !== undefined &&
+    a !== null &&
+    b !== undefined &&
+    b !== null &&
+    String(a) === String(b);
+
+/**
+ * Creates (or finds) the entity for a credential the caller already holds:
+ * the v1 `POST /api/entity`.
+ *
+ * The module is built with the stored credential loaded, so the API can call
+ * the provider and a token refresh during `getEntityDetails` updates that
+ * credential. Persistence reuses `ProcessAuthorizationCallback.findOrCreateEntity`,
+ * the same find-or-create (and credential repointing) the authorization flow
+ * uses, so the two paths cannot drift.
+ */
+class CreateEntityFromCredential {
+    /**
+     * @param {Object} params
+     * @param {import('./process-authorization-callback').ProcessAuthorizationCallback} params.processAuthorizationCallback
+     * @param {Object} params.credentialRepository
+     * @param {Array<Object>} params.moduleDefinitions
+     * @param {Function} [params.createModule] - builds a Module; injectable for tests
+     */
+    constructor({
+        processAuthorizationCallback,
+        credentialRepository,
+        moduleDefinitions,
+        createModule,
+    }) {
+        this.processAuthorizationCallback = processAuthorizationCallback;
+        this.credentialRepository = credentialRepository;
+        this.moduleDefinitions = moduleDefinitions || [];
+        this.createModule = createModule || ((params) => new Module(params));
+    }
+
+    /**
+     * @param {Object} params
+     * @param {Object} params.user - authenticated User
+     * @param {string} params.entityType
+     * @param {string} params.credentialId
+     * @returns {Promise<Object>} the persisted entity
+     */
+    async execute({ user, entityType, credentialId }) {
+        const userId = user?.getId?.();
+        if (userId === undefined || userId === null) {
+            throw Boom.unauthorized('No authenticated user');
+        }
+
+        const definition = this.moduleDefinitions.find(
+            (def) => def && def.moduleName === entityType
+        );
+        if (!definition) {
+            throw Boom.badRequest(`Unknown entity type ${entityType}`, {
+                code: 'ENTITY_TYPE_NOT_FOUND',
+            });
+        }
+
+        const credential =
+            await this.credentialRepository.findCredentialById(credentialId);
+        // A missing credential and someone else's get the same answer, so
+        // credential ids cannot be probed.
+        if (!credential || !sameId(credential.userId, userId)) {
+            throw Boom.badRequest('Invalid credential ID', {
+                code: 'INVALID_CREDENTIAL',
+            });
+        }
+
+        // The repository returns the tokens flat; a Module reads them from
+        // `credential.data`.
+        const { id, userId: ownerId, externalId, authIsValid, ...data } =
+            credential;
+        const module = this.createModule({
+            userId,
+            definition,
+            entity: {
+                credential: { id, userId: ownerId, externalId, authIsValid, data },
+            },
+        });
+
+        const entityDetails =
+            await definition.requiredAuthMethods.getEntityDetails(
+                module.api,
+                null,
+                null,
+                userId
+            );
+        Object.assign(
+            entityDetails.details,
+            module.apiParamsFromEntity(module.api)
+        );
+
+        return this.processAuthorizationCallback.findOrCreateEntity(
+            entityDetails,
+            definition.moduleName,
+            credential.id
+        );
+    }
+}
+
+module.exports = { CreateEntityFromCredential };

package/modules/use-cases/get-entity-options-by-id.js

@@ -1,4 +1,7 @@
 const { Module } = require('../module');
+const {
+    findModuleDefinitionForEntity,
+} = require('../utils/find-module-definition');
 
 class GetEntityOptionsById {
     /**
@@ -45,11 +48,10 @@ class GetEntityOptionsById {
         }
 
         const entityType = entity.moduleName;
-        const moduleDefinition = this.moduleDefinitions.find((def) => {
-            const modelName =
-                Module.getEntityModelFromDefinition(def).modelName;
-            return entityType === modelName;
-        });
+        const moduleDefinition = findModuleDefinitionForEntity(
+            this.moduleDefinitions,
+            entity
+        );
 
         if (!moduleDefinition) {
             throw new Error(

package/modules/use-cases/get-module.js

@@ -1,4 +1,7 @@
 const { Module } = require('../module');
+const {
+    findModuleDefinitionForEntity,
+} = require('../utils/find-module-definition');
 
 class GetModule {
     constructor({ moduleRepository, moduleDefinitions }) {
@@ -42,10 +45,10 @@ class GetModule {
         }
 
         const entityType = entity.moduleName;
-        const moduleDefinition = this.moduleDefinitions.find((def) => {
-            const modelName = Module.getEntityModelFromDefinition(def).modelName;
-            return entityType === modelName;
-        });
+        const moduleDefinition = findModuleDefinitionForEntity(
+            this.moduleDefinitions,
+            entity
+        );
 
         if (!moduleDefinition) {
             throw new Error(
@@ -59,15 +62,33 @@ class GetModule {
             definition: moduleDefinition,
         });
 
-        // todo: this properties should be methods in the Module class
+        // The credential itself (tokens, API keys) never leaves the server:
+        // the response names it and says whether it still works, as the v2
+        // entity DTO does.
+        const credential = module.credential;
+        const credentialId =
+            credential && typeof credential === 'object'
+                ? credential.id
+                : credential;
+        const ownerId = module.entity.userId ?? module.entity.user;
         return {
             id: module.entity.id,
             name: module.entity.name,
             moduleName: module.entity.moduleName,
-            credential: module.credential,
+            credentialId:
+                credentialId === undefined || credentialId === null
+                    ? null
+                    : String(credentialId),
+            authIsValid:
+                typeof credential?.authIsValid === 'boolean'
+                    ? credential.authIsValid
+                    : null,
             externalId: module.entity.externalId,
-            userId: module.entity.user.toString(),
-        }
+            userId:
+                ownerId === undefined || ownerId === null
+                    ? null
+                    : String(ownerId),
+        };
     }
 }
 

package/modules/use-cases/refresh-entity-options.js

@@ -1,4 +1,7 @@
 const { Module } = require('../module');
+const {
+    findModuleDefinitionForEntity,
+} = require('../utils/find-module-definition');
 
 class RefreshEntityOptions {
     /**
@@ -46,11 +49,10 @@ class RefreshEntityOptions {
         }
 
         const entityType = entity.moduleName;
-        const moduleDefinition = this.moduleDefinitions.find((def) => {
-            const modelName =
-                Module.getEntityModelFromDefinition(def).modelName;
-            return entityType === modelName;
-        });
+        const moduleDefinition = findModuleDefinitionForEntity(
+            this.moduleDefinitions,
+            entity
+        );
 
         if (!moduleDefinition) {
             throw new Error(