@friggframework/core 2.0.0--canary.711.f8b6445.0 → 2.0.0--canary.667.f74cf3b.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.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/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/documentdb-utils.js

@@ -58,10 +58,7 @@ async function insertOne(client, collection, document) {
 
         // Provide helpful context for common errors
         if (error.code === 11000) {
-            throw Object.assign(
-                new Error(`${errorMsg} - Duplicate key violation`),
-                { code: 11000 }
-            );
+            throw new Error(`${errorMsg} - Duplicate key violation`);
         }
         throw new Error(errorMsg);
     }

package/errors/index.js

@@ -6,9 +6,6 @@ const {
     ParameterTypeError,
 } = require('./validation-errors');
 const { ClientSafeError } = require('./client-safe-error');
-const {
-    MappingAlreadyExistsError,
-} = require('./mapping-already-exists-error');
 
 module.exports = {
     BaseError,
@@ -17,5 +14,4 @@ module.exports = {
     RequiredPropertyError,
     ParameterTypeError,
     ClientSafeError,
-    MappingAlreadyExistsError,
 };

package/handlers/WEBHOOKS.md

@@ -483,35 +483,6 @@ async onWebhook({ data }) {
 }
 ```
 
-`getMapping` followed by `upsertMapping` is not atomic. To claim an event so only one
-concurrent worker proceeds, use the insert-only `createMapping`, which throws
-`MappingAlreadyExistsError` (exported from `@friggframework/core`) when the
-`sourceId` is already taken. `deleteMapping(sourceId)` releases the claim and is a
-no-op when nothing exists.
-
-```javascript
-const { MappingAlreadyExistsError } = require('@friggframework/core');
-
-async onWebhook({ data }) {
-    const claimId = `claim:${data.body.id}`;
-    try {
-        await this.createMapping(claimId, { claimedAt: new Date() });
-    } catch (error) {
-        if (error instanceof MappingAlreadyExistsError) {
-            return { processed: false, duplicate: true };
-        }
-        throw error;
-    }
-
-    try {
-        await this.processEvent(data.body);
-    } catch (error) {
-        await this.deleteMapping(claimId);
-        throw error;
-    }
-}
-```
-
 ### 4. Error Handling
 ```javascript
 async onWebhook({ data }) {

package/index.js

@@ -57,7 +57,6 @@ const {
     HaltError,
     RequiredPropertyError,
     ParameterTypeError,
-    MappingAlreadyExistsError,
 } = require('./errors/index');
 const {
     IntegrationBase,
@@ -145,7 +144,6 @@ module.exports = {
     HaltError,
     RequiredPropertyError,
     ParameterTypeError,
-    MappingAlreadyExistsError,
 
     // integrations
     IntegrationBase,

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/integration-base.js

@@ -457,35 +457,6 @@ class IntegrationBase {
         );
     }
 
-    /**
-     * Insert-only mapping write; usable as an atomic claim/lock row.
-     * @throws {MappingAlreadyExistsError} If a mapping for sourceId exists
-     */
-    async createMapping(sourceId, mapping) {
-        if (!sourceId) {
-            throw new Error(`sourceId must be set`);
-        }
-        return await this.integrationMappingRepository.createMapping(
-            this.id,
-            sourceId,
-            mapping
-        );
-    }
-
-    /**
-     * Deletes the mapping for sourceId. A missing mapping is not an error
-     * (resolves with deletedCount 0).
-     */
-    async deleteMapping(sourceId) {
-        if (!sourceId) {
-            throw new Error(`sourceId must be set`);
-        }
-        return await this.integrationMappingRepository.deleteMapping(
-            this.id,
-            sourceId
-        );
-    }
-
     /**
      * CHILDREN CAN OVERRIDE THESE CONFIGURATION METHODS
      */

package/integrations/integration-router.js

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

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

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

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

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