@friggframework/core 2.0.0--canary.710.91495fa.0 → 2.0.0--canary.702.ef0dc8c.0

package/CLAUDE.md

@@ -206,51 +206,11 @@ 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.db.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
@@ -266,7 +226,7 @@ packages/core/
   mapping keys to leave out of the rows; never write such rows back. Path
   segments must match `^[A-Za-z_][A-Za-z0-9_]*$`. The PostgreSQL, MongoDB and
   DocumentDB adapters give the same pages and totals;
-  `integration-mapping-repository-query-parity.db.test.js` checks that against
+  `integration-mapping-repository-query-parity.test.js` checks that against
   real databases when `QUERY_MAPPINGS_PARITY_MONGO_URL` /
   `QUERY_MAPPINGS_PARITY_POSTGRES_URL` are set. Two orderings still differ:
   strings compare by the database collation on PostgreSQL and by code point

package/application/commands/README.md

@@ -67,10 +67,9 @@ class MyIntegration extends IntegrationBase {
     async hydrateFromExternalUser(externalUserId) {
         // Find integration context by external entity ID
         const result =
-            await this.commands.findIntegrationContextByExternalEntityId({
-                externalId: externalUserId,
-                type: 'my-integration', // integration config.type to match
-            });
+            await this.commands.findIntegrationContextByExternalEntityId(
+                externalUserId
+            );
 
         if (result.error) {
             return { error: result.error };
@@ -232,10 +231,9 @@ Manage integration records and load full integration contexts.
 ```javascript
 // Find integration context by external entity ID
 // Returns { context, error } where context includes record + hydrated modules
-const result = await commands.findIntegrationContextByExternalEntityId({
-    externalId: 'external-user-or-workspace-id',
-    type: 'my-integration', // integration config.type to match
-});
+const result = await commands.findIntegrationContextByExternalEntityId(
+    'external-user-or-workspace-id'
+);
 
 if (!result.error) {
     integration.setIntegrationRecord(result.context);
@@ -301,10 +299,7 @@ try {
 For integration context operations, errors are returned in the result:
 
 ```javascript
-const result = await commands.findIntegrationContextByExternalEntityId({
-    externalId: userId,
-    type: 'my-integration',
-});
+const result = await commands.findIntegrationContextByExternalEntityId(userId);
 
 if (result.error) {
     return { error: result.error };
@@ -354,10 +349,9 @@ const result =
 const { createFriggCommands } = require('@friggframework/core');
 
 this.commands = createFriggCommands({ integrationClass: MyIntegration });
-const result = await this.commands.findIntegrationContextByExternalEntityId({
-    externalId: userId,
-    type: 'my-integration',
-});
+const result = await this.commands.findIntegrationContextByExternalEntityId(
+    userId
+);
 ```
 
 ## Best Practices
@@ -439,7 +433,7 @@ if (!user) {
 |                 | `findEntitiesByIds(ids)`                                | Find multiple by IDs                      |
 |                 | `updateEntity(id, updates)`                             | Update entity properties                  |
 |                 | `deleteEntity(id)`                                      | Delete entity                             |
-| **Integration** | `findIntegrationContextByExternalEntityId({ externalId, type })` | Load integration + modules by external ID |
+| **Integration** | `findIntegrationContextByExternalEntityId(externalId)`  | Load integration + modules by external ID |
 |                 | `loadIntegrationContextById(integrationId)`             | Load integration + modules by ID          |
 
 ## Support

package/application/commands/entity-commands.js

@@ -1,24 +1,12 @@
 const {
     createModuleRepository,
 } = require('../../modules/repositories/module-repository-factory');
-const { toCredentialId } = require('../../modules/utils/to-credential-id');
 
 const ERROR_CODE_MAP = {
     ENTITY_NOT_FOUND: 404,
     INVALID_ENTITY_DATA: 400,
 };
 
-function toEntityDto(entity) {
-    return {
-        id: entity.id,
-        userId: entity.userId,
-        externalId: entity.externalId,
-        name: entity.name,
-        moduleName: entity.moduleName,
-        credentialId: toCredentialId(entity.credential),
-    };
-}
-
 function mapErrorToResponse(error) {
     const status = ERROR_CODE_MAP[error?.code] || 500;
     return {
@@ -78,7 +66,16 @@ function createEntityCommands() {
 
                 const entity = await moduleRepo.createEntity(entityData);
 
-                return toEntityDto(entity);
+                return {
+                    id: entity.id,
+                    userId: entity.userId,
+                    externalId: entity.externalId,
+                    name: entity.name,
+                    moduleName: entity.moduleName,
+                    credentialId: entity.credential?._id
+                        ? entity.credential._id.toString()
+                        : entity.credential,
+                };
             } catch (error) {
                 return mapErrorToResponse(error);
             }
@@ -112,7 +109,16 @@ function createEntityCommands() {
                     return null;
                 }
 
-                return toEntityDto(entity);
+                return {
+                    id: entity.id,
+                    userId: entity.userId,
+                    externalId: entity.externalId,
+                    name: entity.name,
+                    moduleName: entity.moduleName,
+                    credentialId: entity.credential?._id
+                        ? entity.credential._id.toString()
+                        : entity.credential,
+                };
             } catch (error) {
                 return mapErrorToResponse(error);
             }
@@ -133,7 +139,16 @@ function createEntityCommands() {
 
                 const entities = await moduleRepo.findEntitiesByUserId(userId);
 
-                return entities.map((entity) => toEntityDto(entity));
+                return entities.map((entity) => ({
+                    id: entity.id,
+                    userId: entity.userId,
+                    externalId: entity.externalId,
+                    name: entity.name,
+                    moduleName: entity.moduleName,
+                    credentialId: entity.credential?._id
+                        ? entity.credential._id.toString()
+                        : entity.credential,
+                }));
             } catch (error) {
                 if (error.code) {
                     return mapErrorToResponse(error);
@@ -165,7 +180,16 @@ function createEntityCommands() {
                         moduleName
                     );
 
-                return entities.map((entity) => toEntityDto(entity));
+                return entities.map((entity) => ({
+                    id: entity.id,
+                    userId: entity.userId,
+                    externalId: entity.externalId,
+                    name: entity.name,
+                    moduleName: entity.moduleName,
+                    credentialId: entity.credential?._id
+                        ? entity.credential._id.toString()
+                        : entity.credential,
+                }));
             } catch (error) {
                 if (error.code) {
                     return mapErrorToResponse(error);
@@ -189,7 +213,16 @@ function createEntityCommands() {
 
                 const entity = await moduleRepo.findEntityById(entityId);
 
-                return toEntityDto(entity);
+                return {
+                    id: entity.id,
+                    userId: entity.userId,
+                    externalId: entity.externalId,
+                    name: entity.name,
+                    moduleName: entity.moduleName,
+                    credentialId: entity.credential?._id
+                        ? entity.credential._id.toString()
+                        : entity.credential,
+                };
             } catch (error) {
                 return mapErrorToResponse(error);
             }
@@ -217,7 +250,16 @@ function createEntityCommands() {
                     throw error;
                 }
 
-                return toEntityDto(entity);
+                return {
+                    id: entity.id,
+                    userId: entity.userId,
+                    externalId: entity.externalId,
+                    name: entity.name,
+                    moduleName: entity.moduleName,
+                    credentialId: entity.credential?._id
+                        ? entity.credential._id.toString()
+                        : entity.credential,
+                };
             } catch (error) {
                 return mapErrorToResponse(error);
             }

package/application/commands/integration-commands.js

@@ -29,12 +29,6 @@ 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');
@@ -46,11 +40,6 @@ 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) {
@@ -174,17 +163,6 @@ function createIntegrationCommands({ integrationClass } = {}) {
         integrationRepository,
     });
 
-    const addEntitiesToIntegrationUseCase = new AddEntitiesToIntegration({
-        integrationRepository,
-        moduleRepository,
-    });
-
-    const removeEntitiesFromIntegrationUseCase =
-        new RemoveEntitiesFromIntegration({
-            integrationRepository,
-            moduleRepository,
-        });
-
     return {
         findIntegrationById,
         listIntegrations,
@@ -329,47 +307,6 @@ 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/database/encryption/README.md

@@ -508,9 +508,9 @@ return entities.map((e) => ({
 
 **Verified:**
 
--   ✅ `postgres-relation-decryption.db.test.js` - Proves the bug exists
--   ✅ `postgres-decryption-fix-verification.db.test.js` - Verifies separate queries work
--   ✅ `mongo-decryption-fix-verification.db.test.js` - Verifies fix for MongoDB
+-   ✅ `postgres-relation-decryption.test.js` - Proves the bug exists
+-   ✅ `postgres-decryption-fix-verification.test.js` - Verifies separate queries work
+-   ✅ `mongo-decryption-fix-verification.test.js` - Verifies fix for MongoDB
 
 **Implementation Examples:**
 

package/database/encryption/encryption-schema-registry.js

@@ -174,46 +174,26 @@ function loadModuleEncryptionSchemas(integrations) {
         return;
     }
 
-    const { getModulesDefinitionFromIntegrationClasses } = require('../../integrations/utils/map-integration-dto');
+    const { getModulesDefinitionFromIntegrationClasses } = require('../integrations/utils/map-integration-dto');
 
-    // Integrations without modules contribute no credential fields.
-    const integrationsWithModules = integrations.filter(
-        (integration) => integration?.Definition?.modules
-    );
-    const moduleDefinitions = getModulesDefinitionFromIntegrationClasses(
-        integrationsWithModules
-    );
-
-    // Fields the core schema already encrypts (e.g. data.api_key) are
-    // covered; registering them again would fail validation and drop every
-    // other module field with them.
-    const coreCredentialFields = CORE_ENCRYPTION_SCHEMA.Credential.fields;
-    const credentialFields = extractCredentialFieldsFromModules(
-        moduleDefinitions
-    ).filter((field) => !coreCredentialFields.includes(field));
+    const moduleDefinitions = getModulesDefinitionFromIntegrationClasses(integrations);
+    const credentialFields = extractCredentialFieldsFromModules(moduleDefinitions);
 
     if (credentialFields.length === 0) {
         return;
     }
 
-    // Merge with whatever custom schema the app already registered rather
-    // than replacing it (registerCustomSchema overwrites).
-    const existingCredentialFields = customSchema.Credential?.fields || [];
-    const mergedSchema = {
-        ...customSchema,
+    const moduleSchema = {
         Credential: {
-            ...customSchema.Credential,
-            fields: [
-                ...new Set([...existingCredentialFields, ...credentialFields]),
-            ],
-        },
+            fields: credentialFields
+        }
     };
 
     logger.info(
         `Registering module-level encryption for ${credentialFields.length} credential fields`
     );
 
-    registerCustomSchema(mergedSchema);
+    registerCustomSchema(moduleSchema);
 }
 
 /**

package/handlers/app-definition-loader.js

@@ -1,6 +1,9 @@
 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 {
@@ -33,7 +36,9 @@ 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.
- * @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.
+ * 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.
  * @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
@@ -53,7 +58,9 @@ function loadAppDefinition() {
     }
 
     const backendJsFile = require(backendFilePath);
-    const appDefinition = backendJsFile.Definition;
+    // 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 {
         integrations = [],

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')

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/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$'],
 };

package/modules/utils/map-module-dto.js

@@ -1,5 +1,3 @@
-const { toCredentialId } = require('./to-credential-id');
-
 /**
  * @param {import('../module').Module} moduleInstance
  * Convert a Module domain instance to a plain DTO suitable for JSON responses.
@@ -12,9 +10,9 @@ function mapModuleClassToModuleDTO(moduleInstance) {
         name: moduleInstance.name,
         userId: moduleInstance.userId,
         entity: moduleInstance.entity,
-        credentialId: toCredentialId(moduleInstance.credential),
-        type: moduleInstance.getName(),
+        credentialId: moduleInstance.credential?._id?.toString(),
+        type: moduleInstance.getName()
     };
 }
 
-module.exports = { mapModuleClassToModuleDTO };
+module.exports = { mapModuleClassToModuleDTO }; 

package/package.json

@@ -1,16 +1,18 @@
 {
     "name": "@friggframework/core",
+    "description": "",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.710.91495fa.0",
+    "version": "2.0.0--canary.702.ef0dc8c.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.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.ef0dc8c.0",
         "@hapi/boom": "^10.0.1",
         "@opentelemetry/api": "^1.9.1",
         "@opentelemetry/context-async-hooks": "^2.9.0",
@@ -48,9 +50,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.710.91495fa.0",
-        "@friggframework/prettier-config": "2.0.0--canary.710.91495fa.0",
-        "@friggframework/test": "2.0.0--canary.710.91495fa.0",
+        "@friggframework/eslint-config": "2.0.0--canary.702.ef0dc8c.0",
+        "@friggframework/prettier-config": "2.0.0--canary.702.ef0dc8c.0",
+        "@friggframework/test": "2.0.0--canary.702.ef0dc8c.0",
         "@prisma/client": "^6.19.3",
         "@types/lodash": "4.17.15",
         "@typescript-eslint/eslint-plugin": "^8.0.0",
@@ -68,7 +70,6 @@
     "scripts": {
         "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
         "test": "jest --passWithNoTests # TODO",
-        "test:db": "jest --config jest.db.config.js --runInBand",
         "prisma:generate:mongo": "npx prisma generate --schema ./prisma-mongodb/schema.prisma",
         "prisma:generate:postgres": "npx prisma generate --schema ./prisma-postgresql/schema.prisma",
         "prisma:generate": "npm run prisma:generate:mongo && npm run prisma:generate:postgres",
@@ -87,9 +88,8 @@
         "url": "https://github.com/friggframework/frigg/issues"
     },
     "homepage": "https://github.com/friggframework/frigg#readme",
-    "description": "",
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "91495fa7fd4cc9e0da6709172c245e97ee06daf4"
+    "gitHead": "ef0dc8cb6c6f56048a61b6759faad7322046925d"
 }

package/queues/queuer-util.js

@@ -97,17 +97,16 @@ const QueuerUtil = {
                 Id: uuid(),
                 MessageBody: JSON.stringify(entry),
             });
-            // Sends 10, then starts a fresh buffer. Each command gets its own
-            // array: clearing the shared buffer in place would also empty the
-            // Entries of a command that was already sent.
+            // Sends 10, then purges the buffer
             if (buffer.length === batchSize) {
-                const batch = buffer.splice(0, buffer.length);
                 const command = new SendMessageBatchCommand({
-                    Entries: batch,
+                    Entries: buffer,
                     QueueUrl: queueUrl,
                 });
                 const result = await sqs.send(command);
-                inspectBatchResult(result, queueUrl, batch);
+                inspectBatchResult(result, queueUrl, buffer);
+                // Purge the buffer
+                buffer.splice(0, buffer.length);
             }
         }
 

package/user/tests/doubles/test-user-repository.js

@@ -23,7 +23,7 @@ class TestUserRepository {
 
     async createToken(userId, rawToken, minutes = 120) {
         const token = `token-for-${userId}-for-${minutes}-mins`;
-        this.tokens.set(token, { id: token, userId, rawToken });
+        this.tokens.set(token, { user: userId, rawToken });
         return token;
     }
 

package/user/use-cases/get-user-from-bearer-token.js

@@ -40,13 +40,8 @@ class GetUserFromBearerToken {
             throw Boom.unauthorized('Session Token Not Found');
         }
 
-        const tokenUserId = sessionToken.userId;
-        if (!tokenUserId) {
-            throw Boom.unauthorized('Session Token Has No User');
-        }
-
         if (this.userConfig.primary === 'organization') {
-            const organizationUserData = await this.userRepository.findOrganizationUserById(tokenUserId);
+            const organizationUserData = await this.userRepository.findOrganizationUserById(sessionToken.user);
 
             if (!organizationUserData) {
                 throw Boom.unauthorized('Organization User Not Found');
@@ -62,7 +57,7 @@ class GetUserFromBearerToken {
             );
         }
 
-        const individualUserData = await this.userRepository.findIndividualUserById(tokenUserId);
+        const individualUserData = await this.userRepository.findIndividualUserById(sessionToken.user);
 
         if (!individualUserData) {
             throw Boom.unauthorized('Individual User Not Found');

package/integrations/use-cases/add-entities-to-integration.js

@@ -1,92 +0,0 @@
-const {
-    assertEntityIdsInput,
-    integrationNotFound,
-    loadIntegration,
-} = 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 loadIntegration(
-            this.integrationRepository,
-            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/remove-entities-from-integration.js

@@ -1,70 +0,0 @@
-const {
-    assertEntityIdsInput,
-    integrationNotFound,
-    loadIntegration,
-} = 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 loadIntegration(
-            this.integrationRepository,
-            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

@@ -1,42 +0,0 @@
-/**
- * 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;
-}
-
-/**
- * Loads an integration, mapping the repositories' "not found" error to
- * INTEGRATION_NOT_FOUND. Any other failure (connection, invalid id) is
- * rethrown unchanged.
- * @param {Object} integrationRepository
- * @param {string} integrationId
- * @returns {Promise<Object>} The integration record.
- */
-async function loadIntegration(integrationRepository, integrationId) {
-    try {
-        return await integrationRepository.findIntegrationById(integrationId);
-    } catch (error) {
-        if (/^Integration with id .* not found$/.test(error?.message)) {
-            throw integrationNotFound(integrationId);
-        }
-        throw error;
-    }
-}
-
-module.exports = { assertEntityIdsInput, integrationNotFound, loadIntegration };

package/jest.db.config.js

@@ -1,23 +0,0 @@
-/*
- * Database integration suites (`*.db.test.js`).
- *
- * These talk to real databases instead of mocking Prisma, so they are kept
- * out of the default `npm test` run and executed with `npm run test:db`.
- * They need generated Prisma clients (`npm run prisma:generate`) and:
- *   - a MongoDB replica set (Prisma requires one for MongoDB writes):
- *     FRIGG_TEST_MONGODB_URL, default
- *     mongodb://localhost:27017/frigg?replicaSet=rs0
- *   - PostgreSQL with the prisma-postgresql migrations applied:
- *     FRIGG_TEST_POSTGRES_URL, default
- *     postgresql://postgres:postgres@localhost:5432/frigg?schema=public
- * The repository parity suites skip themselves unless their own URLs are
- * set (INTEGRATION_ENTITIES_PARITY_* / QUERY_MAPPINGS_PARITY_*).
- */
-const base = require('./jest.config');
-
-module.exports = {
-    ...base,
-    coverageThreshold: undefined,
-    testMatch: ['**/*.db.test.js'],
-    testPathIgnorePatterns: ['/node_modules/'],
-};

package/modules/utils/to-credential-id.js

@@ -1,14 +0,0 @@
-/**
- * Resolve the credential id from an entity's or module's `credential`, which
- * repositories return as the decrypted credential object (or a bare id).
- * @param {Object|string|number|null|undefined} credential
- * @returns {string|null}
- */
-function toCredentialId(credential) {
-    if (credential && typeof credential === 'object') {
-        return credential.id?.toString() ?? null;
-    }
-    return credential?.toString() ?? null;
-}
-
-module.exports = { toCredentialId };