@friggframework/core 2.0.0--canary.702.3f342da.0 → 2.0.0--canary.689.f2e7e1d.0

package/CLAUDE.md

@@ -206,11 +206,51 @@ packages/core/
 - `delete-integration-for-user.js` - Remove integration
 - `get-integration-instance.js` - Load integration with modules
 - `load-integration-context.js` - Full integration context loading
+- `add-entities-to-integration.js` / `remove-entities-from-integration.js` - Attach or detach entities on an existing integration
 
 **Repositories**:
 - `integration-repository-factory.js` - Creates database-specific repositories
 - `integration-repository-mongo.js` - MongoDB implementation
 - `integration-repository-postgres.js` - PostgreSQL implementation
+- `addEntitiesToIntegration(integrationId, entityIds)` /
+  `removeEntitiesFromIntegration(integrationId, entityIds)` change the entity
+  set of an existing integration (all three adapters; `null` for an unknown
+  integration). Reach them through the `addEntitiesToIntegration` /
+  `removeEntitiesFromIntegration` commands. The add use case
+  (`add-entities-to-integration.js`) rejects unknown entities
+  (`ENTITIES_NOT_FOUND`, 404), entities of another user
+  (`ENTITY_USER_MISMATCH`, 403) and entities of a module the integration does
+  not already hold (`ENTITY_MODULE_MISMATCH`, 400). The remove use case
+  (`remove-entities-from-integration.js`) refuses to leave a module with no
+  entity (`LAST_ENTITY_OF_MODULE`, 409). Re-adding an attached entity or
+  removing a detached one changes nothing; a detached entity is not deleted.
+  `integration-repository-entities-parity.test.js` runs every adapter against
+  real databases when `INTEGRATION_ENTITIES_PARITY_MONGO_URL` /
+  `INTEGRATION_ENTITIES_PARITY_POSTGRES_URL` are set. The DocumentDB adapter
+  writes only `Integration.entityIds` (as its `createIntegration` does), not
+  `Entity.integrationIds`.
+  **One credential, many accounts**: when one credential covers several
+  provider accounts, give each account its own entity (externalId = account
+  id) and attach them all to one integration; webhooks then route with
+  `findIntegrationByEntityExternalId`. Traps:
+  (1) `IntegrationBase` keys modules by module name, so `this.<moduleKey>`
+  holds only one entity's module, and on the queue/webhook path
+  (`get-integration-instance.js`) `this.entities` holds entity **ids**, not
+  records. For per-account work (a webhook for one account, teardown of every
+  account in `onDelete`), load
+  `this.commands.loadIntegrationContextById(this.id)` and use
+  `context.modules`: one module per entity, each with its record on
+  `module.entity` (pick by `module.entity.externalId`).
+  (2) `findIntegrationByEntityExternalId` counts every entity with that
+  externalId, attached or not, across users: reuse an existing entity
+  (`findEntity`) when an account comes back, or delete it when it is revoked,
+  never create a second one.
+  (3) `createIntegration` reuses an existing integration of the same user
+  and type whose entities include all requested ones (an exact match wins),
+  so a reconnect that sends the original entities finds the integration that
+  now holds more.
+  (4) Every module's delegate is the integration: an auth failure on any
+  account marks the shared credential invalid and the integration ERROR.
 - `integration-mapping-repository-*.js` - Mapping data persistence.
   `queryMappings(integrationId, { where, orderBy, skip, take, omit })`
   returns `{ mappings, total }`: one filtered, ordered page of an

package/application/commands/integration-commands.js

@@ -29,6 +29,12 @@ const {
 const {
     PatchIntegrationConfig,
 } = require('../../integrations/use-cases/patch-integration-config');
+const {
+    AddEntitiesToIntegration,
+} = require('../../integrations/use-cases/add-entities-to-integration');
+const {
+    RemoveEntitiesFromIntegration,
+} = require('../../integrations/use-cases/remove-entities-from-integration');
 const {
     getModulesDefinitionFromIntegrationClasses,
 } = require('../../integrations/utils/map-integration-dto');
@@ -40,6 +46,11 @@ const ERROR_CODE_MAP = {
     EXTERNAL_ID_REQUIRED: 400,
     TYPE_REQUIRED: 400,
     INTEGRATION_RECORD_NOT_FOUND: 404,
+    INVALID_INTEGRATION_DATA: 400,
+    ENTITIES_NOT_FOUND: 404,
+    ENTITY_USER_MISMATCH: 403,
+    ENTITY_MODULE_MISMATCH: 400,
+    LAST_ENTITY_OF_MODULE: 409,
 };
 
 function mapErrorToResponse(error) {
@@ -163,6 +174,17 @@ function createIntegrationCommands({ integrationClass } = {}) {
         integrationRepository,
     });
 
+    const addEntitiesToIntegrationUseCase = new AddEntitiesToIntegration({
+        integrationRepository,
+        moduleRepository,
+    });
+
+    const removeEntitiesFromIntegrationUseCase =
+        new RemoveEntitiesFromIntegration({
+            integrationRepository,
+            moduleRepository,
+        });
+
     return {
         findIntegrationById,
         listIntegrations,
@@ -307,6 +329,47 @@ function createIntegrationCommands({ integrationClass } = {}) {
             }
         },
 
+        /**
+         * Attach entities to an existing integration. Every entity must
+         * exist, belong to the integration's user, and be of a module the
+         * integration already holds; entities that are already attached are
+         * left as they are.
+         * @param {Object} params
+         * @param {string} params.integrationId - Integration ID
+         * @param {Array<string>} params.entityIds - Entity IDs to attach
+         * @returns {Promise<Object>} Updated integration
+         */
+        async addEntitiesToIntegration({ integrationId, entityIds }) {
+            try {
+                return await addEntitiesToIntegrationUseCase.execute(
+                    integrationId,
+                    entityIds
+                );
+            } catch (error) {
+                return mapErrorToResponse(error);
+            }
+        },
+
+        /**
+         * Detach entities from an integration. Entities that are not
+         * attached are ignored; detached entities are not deleted. Each
+         * module must keep at least one entity.
+         * @param {Object} params
+         * @param {string} params.integrationId - Integration ID
+         * @param {Array<string>} params.entityIds - Entity IDs to detach
+         * @returns {Promise<Object>} Updated integration
+         */
+        async removeEntitiesFromIntegration({ integrationId, entityIds }) {
+            try {
+                return await removeEntitiesFromIntegrationUseCase.execute(
+                    integrationId,
+                    entityIds
+                );
+            } catch (error) {
+                return mapErrorToResponse(error);
+            }
+        },
+
         /**
          * Delete an integration by ID
          * @param {string} integrationId - Integration ID to delete

package/handlers/app-definition-loader.js

@@ -1,9 +1,6 @@
 const { findNearestBackendPackageJson } = require('@friggframework/core/utils');
 const path = require('node:path');
 const fs = require('fs-extra');
-const {
-    applyAppDefinitionDefaults,
-} = require('@friggframework/schemas/app-definition');
 const { resolveTelemetryConfig } = require('../telemetry/telemetry-config');
 const { registerDeniedKeys } = require('../logs/denied-keys');
 const {
@@ -36,9 +33,7 @@ function registerCredentialLogKeys(appDefinition, integrations) {
  * @function loadAppDefinition
  * @description Searches for the nearest backend package.json, loads the corresponding index.js file,
  * and extracts the application definition containing integrations and user configuration.
- * The defaults declared in the app-definition schema are applied first (ADR-051), so
- * `userConfig` always holds a complete user config, also when the app omits `user`.
- * @returns {{integrations: Array<object>, userConfig: object, adminScripts: Array<object>, reports: Array<object>, admin: object, telemetry: object, logging: object | null}} An object containing the application definition.
+ * @returns {{integrations: Array<object>, userConfig: object | null, adminScripts: Array<object>, reports: Array<object>, admin: object, telemetry: object, logging: object | null}} An object containing the application definition.
  * @throws {Error} Throws error if backend package.json cannot be found.
  * @throws {Error} Throws error if index.js file cannot be found in the backend directory.
  * @example
@@ -58,9 +53,7 @@ function loadAppDefinition() {
     }
 
     const backendJsFile = require(backendFilePath);
-    // The one place schema defaults are applied at runtime (ADR-051): a
-    // default in app-definition.schema.json is the value core sees.
-    const appDefinition = applyAppDefinitionDefaults(backendJsFile.Definition);
+    const appDefinition = backendJsFile.Definition;
 
     const {
         integrations = [],

package/infrastructure/scheduler/eventbridge-scheduler-adapter.js

@@ -11,65 +11,19 @@
  * This adapter implements SchedulerServiceInterface for AWS EventBridge Scheduler.
  */
 
-const { SchedulerServiceInterface } = require('./scheduler-service-interface');
-
-const SCHEDULER_SDK = '@aws-sdk/client-scheduler';
+const {
+    SchedulerClient,
+    CreateScheduleCommand,
+    DeleteScheduleCommand,
+    GetScheduleCommand,
+    ResourceNotFoundException,
+} = require('@aws-sdk/client-scheduler');
 
-/**
- * Lazily load the AWS EventBridge Scheduler SDK.
- *
- * Requiring `@aws-sdk/client-scheduler` at module top level would put the AWS
- * SDK on the load path of every consumer of `@friggframework/core`, including
- * those using the mock scheduler or no scheduler at all. Loading it here, on
- * construction of the EventBridge adapter, keeps it out of the module-load
- * path. The adapter calls it exactly once, in its constructor, and keeps the
- * classes its methods need on the instance.
- *
- * Only a MODULE_NOT_FOUND for the scheduler SDK itself is rewritten into an
- * actionable message; any other failure (including a missing transitive
- * dependency) is rethrown unchanged so the real cause is not masked.
- *
- * @returns {object} The relevant exports from `@aws-sdk/client-scheduler`.
- */
-function loadSchedulerSdk() {
-    try {
-        // Keep the literal specifier so bundlers (esbuild) can resolve it.
-        return require('@aws-sdk/client-scheduler');
-    } catch (error) {
-        const isSchedulerSdkMissing =
-            error &&
-            error.code === 'MODULE_NOT_FOUND' &&
-            typeof error.message === 'string' &&
-            error.message.includes(SCHEDULER_SDK);
-        if (isSchedulerSdkMissing) {
-            throw new Error(
-                `The EventBridge scheduler requires the "${SCHEDULER_SDK}" package, ` +
-                    `which is not installed. Install it (\`npm install ${SCHEDULER_SDK}\`) ` +
-                    'to use the EventBridge scheduler provider, or use the mock scheduler provider ' +
-                    '(SCHEDULER_PROVIDER=mock) for local development.',
-                { cause: error }
-            );
-        }
-        throw error;
-    }
-}
+const { SchedulerServiceInterface } = require('./scheduler-service-interface');
 
 class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
     constructor({ region } = {}) {
         super();
-        const {
-            SchedulerClient,
-            CreateScheduleCommand,
-            DeleteScheduleCommand,
-            GetScheduleCommand,
-            ResourceNotFoundException,
-        } = loadSchedulerSdk();
-        this.sdk = {
-            CreateScheduleCommand,
-            DeleteScheduleCommand,
-            GetScheduleCommand,
-            ResourceNotFoundException,
-        };
         this.client = new SchedulerClient({
             region: region || process.env.AWS_REGION || 'us-east-1',
         });
@@ -88,12 +42,7 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
      * @param {Object} params.payload - Message payload
      * @returns {Promise<{scheduledJobId: string, scheduledAt: string}>}
      */
-    async scheduleOneTime({
-        scheduleName,
-        scheduleAt,
-        queueResourceId,
-        payload,
-    }) {
+    async scheduleOneTime({ scheduleName, scheduleAt, queueResourceId, payload }) {
         if (!scheduleName) {
             throw new Error('scheduleName is required');
         }
@@ -110,11 +59,8 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
         }
 
         // Format date to AWS schedule expression (at(yyyy-mm-ddThh:mm:ss))
-        const scheduleExpression = `at(${scheduleAt
-            .toISOString()
-            .replace(/\.\d{3}Z$/, '')})`;
+        const scheduleExpression = `at(${scheduleAt.toISOString().replace(/\.\d{3}Z$/, '')})`;
 
-        const { CreateScheduleCommand } = this.sdk;
         const command = new CreateScheduleCommand({
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
@@ -161,7 +107,6 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
             throw new Error('scheduleName is required');
         }
 
-        const { DeleteScheduleCommand, ResourceNotFoundException } = this.sdk;
         const command = new DeleteScheduleCommand({
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
@@ -196,7 +141,6 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
             throw new Error('scheduleName is required');
         }
 
-        const { GetScheduleCommand, ResourceNotFoundException } = this.sdk;
         const command = new GetScheduleCommand({
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
@@ -209,7 +153,9 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
             // Format: at(yyyy-mm-ddThh:mm:ss)
             let scheduledAt = null;
             if (response.ScheduleExpression) {
-                const match = response.ScheduleExpression.match(/^at\((.+)\)$/);
+                const match = response.ScheduleExpression.match(
+                    /^at\((.+)\)$/
+                );
                 if (match) {
                     scheduledAt = new Date(match[1] + 'Z').toISOString();
                 }

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

@@ -164,6 +164,38 @@ 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,6 +184,36 @@ 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,6 +338,58 @@ 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')

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

@@ -365,6 +365,64 @@ 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/use-cases/add-entities-to-integration.js

@@ -0,0 +1,91 @@
+const {
+    assertEntityIdsInput,
+    integrationNotFound,
+} = require('../utils/assert-entity-ids-input');
+
+/**
+ * Attaches entities to an existing integration, e.g. when a user grants
+ * access to more accounts after the integration was created. Every entity
+ * must exist, belong to the integration's user, and be of a module the
+ * integration already holds (so hydration can load it). Entities that are
+ * already attached are left as they are.
+ * @class AddEntitiesToIntegration
+ */
+class AddEntitiesToIntegration {
+    /**
+     * @param {Object} params
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository
+     * @param {import('../../modules/repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository
+     */
+    constructor({ integrationRepository, moduleRepository }) {
+        this.integrationRepository = integrationRepository;
+        this.moduleRepository = moduleRepository;
+    }
+
+    /**
+     * @param {string} integrationId
+     * @param {string[]} entityIds
+     * @returns {Promise<Object>} The updated integration record.
+     */
+    async execute(integrationId, entityIds) {
+        assertEntityIdsInput(integrationId, entityIds);
+
+        const integration = await this.integrationRepository
+            .findIntegrationById(integrationId)
+            .catch(() => null);
+        if (!integration) throw integrationNotFound(integrationId);
+
+        const entities = await this.moduleRepository.findEntitiesByIds(
+            entityIds
+        );
+        const foundIds = new Set(entities.map((e) => String(e.id)));
+        const missing = entityIds.filter((id) => !foundIds.has(String(id)));
+        if (missing.length > 0) {
+            const error = new Error(
+                `Entities not found: ${missing.join(', ')}`
+            );
+            error.code = 'ENTITIES_NOT_FOUND';
+            throw error;
+        }
+
+        const foreign = entities.filter(
+            (e) => String(e.userId) !== String(integration.userId)
+        );
+        if (foreign.length > 0) {
+            const error = new Error(
+                `Entities do not belong to the integration's user: ${foreign
+                    .map((e) => e.id)
+                    .join(', ')}`
+            );
+            error.code = 'ENTITY_USER_MISMATCH';
+            throw error;
+        }
+
+        const attached = await this.moduleRepository.findEntitiesByIds(
+            integration.entitiesIds ?? []
+        );
+        const heldModules = new Set(attached.map((e) => e.moduleName));
+        const otherModules = entities.filter(
+            (e) => !heldModules.has(e.moduleName)
+        );
+        if (otherModules.length > 0) {
+            const error = new Error(
+                `Entities belong to a module the integration does not hold: ${otherModules
+                    .map((e) => `${e.id} (${e.moduleName})`)
+                    .join(', ')}`
+            );
+            error.code = 'ENTITY_MODULE_MISMATCH';
+            throw error;
+        }
+
+        const updated =
+            await this.integrationRepository.addEntitiesToIntegration(
+                integrationId,
+                entityIds
+            );
+        if (!updated) throw integrationNotFound(integrationId);
+        return updated;
+    }
+}
+
+module.exports = { AddEntitiesToIntegration };

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

@@ -138,28 +138,44 @@ class CreateIntegration {
     async _findDuplicate(userId, type, entityIds) {
         const candidates =
             await this.integrationRepository.findIntegrationsByUserId(userId);
-        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();
+        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);
             return (
-                current.length === target.length &&
-                current.every((id, index) => id === target[index])
+                current.size === target.size &&
+                [...target].every((id) => current.has(id))
             );
         });
-
-        return matches.length ? this._pickOldest(matches) : null;
+        if (exact.length) return this._pickOldest(exact);
+
+        // 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 target.size && supersets.length
+            ? this._pickOldest(supersets)
+            : null;
     }
 
     _pickOldest(records) {

package/integrations/use-cases/remove-entities-from-integration.js

@@ -0,0 +1,69 @@
+const {
+    assertEntityIdsInput,
+    integrationNotFound,
+} = require('../utils/assert-entity-ids-input');
+
+/**
+ * Detaches entities from an integration. Entities that are not attached are
+ * ignored, and detached entities are not deleted. Every module the
+ * integration holds must keep at least one entity, so the integration can
+ * still hydrate each of its modules.
+ * @class RemoveEntitiesFromIntegration
+ */
+class RemoveEntitiesFromIntegration {
+    /**
+     * @param {Object} params
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository
+     * @param {import('../../modules/repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository
+     */
+    constructor({ integrationRepository, moduleRepository }) {
+        this.integrationRepository = integrationRepository;
+        this.moduleRepository = moduleRepository;
+    }
+
+    /**
+     * @param {string} integrationId
+     * @param {string[]} entityIds
+     * @returns {Promise<Object>} The updated integration record.
+     */
+    async execute(integrationId, entityIds) {
+        assertEntityIdsInput(integrationId, entityIds);
+
+        const integration = await this.integrationRepository
+            .findIntegrationById(integrationId)
+            .catch(() => null);
+        if (!integration) throw integrationNotFound(integrationId);
+
+        const removing = new Set(entityIds.map(String));
+        const attached = await this.moduleRepository.findEntitiesByIds(
+            integration.entitiesIds ?? []
+        );
+        const emptied = [...new Set(attached.map((e) => e.moduleName))].filter(
+            (moduleName) =>
+                !attached.some(
+                    (e) =>
+                        e.moduleName === moduleName &&
+                        !removing.has(String(e.id))
+                )
+        );
+        if (emptied.length > 0) {
+            const error = new Error(
+                `Removing these entities would leave no entity for module(s): ${emptied.join(
+                    ', '
+                )}`
+            );
+            error.code = 'LAST_ENTITY_OF_MODULE';
+            throw error;
+        }
+
+        const updated =
+            await this.integrationRepository.removeEntitiesFromIntegration(
+                integrationId,
+                entityIds
+            );
+        if (!updated) throw integrationNotFound(integrationId);
+        return updated;
+    }
+}
+
+module.exports = { RemoveEntitiesFromIntegration };

package/integrations/utils/assert-entity-ids-input.js

@@ -0,0 +1,23 @@
+/**
+ * Throws INVALID_INTEGRATION_DATA unless an integration id and a non-empty
+ * list of entity ids are given.
+ * @param {string} integrationId
+ * @param {string[]} entityIds
+ */
+function assertEntityIdsInput(integrationId, entityIds) {
+    if (!integrationId || !Array.isArray(entityIds) || entityIds.length === 0) {
+        const error = new Error(
+            'integrationId and a non-empty entityIds array are required'
+        );
+        error.code = 'INVALID_INTEGRATION_DATA';
+        throw error;
+    }
+}
+
+function integrationNotFound(integrationId) {
+    const error = new Error(`Integration ${integrationId} not found`);
+    error.code = 'INTEGRATION_NOT_FOUND';
+    return error;
+}
+
+module.exports = { assertEntityIdsInput, integrationNotFound };

package/package.json

@@ -1,18 +1,15 @@
 {
     "name": "@friggframework/core",
-    "description": "",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.702.3f342da.0",
+    "version": "2.0.0--canary.689.f2e7e1d.0",
     "dependencies": {
         "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
         "@aws-sdk/client-kms": "^3.588.0",
         "@aws-sdk/client-lambda": "^3.714.0",
         "@aws-sdk/client-s3": "^3.588.0",
-        "@aws-sdk/client-scheduler": "^3.1153.0",
         "@aws-sdk/client-sqs": "^3.588.0",
         "@aws-sdk/client-ssm": "^3.588.0",
         "@aws-sdk/s3-request-presigner": "^3.588.0",
-        "@friggframework/schemas": "2.0.0--canary.702.3f342da.0",
         "@hapi/boom": "^10.0.1",
         "@opentelemetry/api": "^1.9.1",
         "@opentelemetry/context-async-hooks": "^2.9.0",
@@ -50,9 +47,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.702.3f342da.0",
-        "@friggframework/prettier-config": "2.0.0--canary.702.3f342da.0",
-        "@friggframework/test": "2.0.0--canary.702.3f342da.0",
+        "@friggframework/eslint-config": "2.0.0--canary.689.f2e7e1d.0",
+        "@friggframework/prettier-config": "2.0.0--canary.689.f2e7e1d.0",
+        "@friggframework/test": "2.0.0--canary.689.f2e7e1d.0",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -88,8 +85,9 @@
         "url": "https://github.com/friggframework/frigg/issues"
     },
     "homepage": "https://github.com/friggframework/frigg#readme",
+    "description": "",
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "3f342daf8aac3124f25936bb8b327b447024ca4c"
+    "gitHead": "f2e7e1d56cdcc9d6a267ff02714ad8fdad86051f"
 }