@friggframework/core 2.0.0--canary.667.f74cf3b.0 → 2.0.0--canary.702.ef0dc8c.0

package/database/documentdb-utils.js

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

package/errors/index.js

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

package/errors/mapping-already-exists-error.js

@@ -0,0 +1,14 @@
+const { BaseError } = require('./base-error');
+
+class MappingAlreadyExistsError extends BaseError {
+    constructor(integrationId, sourceId, ...errorOptions) {
+        super(
+            `Mapping already exists for integration ${integrationId} and sourceId ${sourceId}`,
+            ...errorOptions
+        );
+        this.integrationId = integrationId;
+        this.sourceId = sourceId;
+    }
+}
+
+module.exports = { MappingAlreadyExistsError };

package/handlers/WEBHOOKS.md

@@ -483,6 +483,35 @@ 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/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/index.js

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

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

@@ -11,19 +11,65 @@
  * This adapter implements SchedulerServiceInterface for AWS EventBridge Scheduler.
  */
 
-const {
-    SchedulerClient,
-    CreateScheduleCommand,
-    DeleteScheduleCommand,
-    GetScheduleCommand,
-    ResourceNotFoundException,
-} = require('@aws-sdk/client-scheduler');
-
 const { SchedulerServiceInterface } = require('./scheduler-service-interface');
 
+const SCHEDULER_SDK = '@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;
+    }
+}
+
 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',
         });
@@ -42,7 +88,12 @@ 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');
         }
@@ -59,8 +110,11 @@ 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,
@@ -107,6 +161,7 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
             throw new Error('scheduleName is required');
         }
 
+        const { DeleteScheduleCommand, ResourceNotFoundException } = this.sdk;
         const command = new DeleteScheduleCommand({
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
@@ -141,6 +196,7 @@ class EventBridgeSchedulerAdapter extends SchedulerServiceInterface {
             throw new Error('scheduleName is required');
         }
 
+        const { GetScheduleCommand, ResourceNotFoundException } = this.sdk;
         const command = new GetScheduleCommand({
             Name: scheduleName,
             GroupName: this.scheduleGroupName,
@@ -153,9 +209,7 @@ 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,6 +457,35 @@ 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,9 +42,6 @@ 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');
@@ -201,13 +198,6 @@ function createIntegrationRouter() {
             getModulesDefinitionFromIntegrationClasses(integrationClasses),
     });
 
-    const createEntityFromCredential = new CreateEntityFromCredential({
-        processAuthorizationCallback,
-        credentialRepository,
-        moduleDefinitions:
-            getModulesDefinitionFromIntegrationClasses(integrationClasses),
-    });
-
     const router = express();
 
     setIntegrationRoutes(router, authenticateUser, {
@@ -228,7 +218,6 @@ function createIntegrationRouter() {
         getEntityOptionsById,
         refreshEntityOptions,
         processAuthorizationCallback,
-        createEntityFromCredential,
     });
     return router;
 }
@@ -513,7 +502,6 @@ function setEntityRoutes(router, authenticateUser, useCases) {
         getEntityOptionsById,
         refreshEntityOptions,
         processAuthorizationCallback,
-        createEntityFromCredential,
     } = useCases;
 
     router.route('/api/authorize').get(
@@ -578,19 +566,35 @@ 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']);
 
-            res.json(
-                await createEntityFromCredential.execute({
-                    user,
-                    entityType: params.entityType,
-                    credentialId: params.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
             );
+            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,4 +1,5 @@
 const { prisma } = require('../../database/prisma');
+const { MappingAlreadyExistsError } = require('../../errors');
 const {
     toObjectId,
     fromObjectId,
@@ -180,6 +181,55 @@ 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,6 +39,21 @@ class IntegrationMappingRepositoryInterface {
         throw new Error('Method upsertMapping must be implemented by subclass');
     }
 
+    /**
+     * Insert a mapping, failing if one already exists for the
+     * (integrationId, sourceId) pair. Atomic: usable as a claim/lock row.
+     *
+     * @param {string|number} integrationId - The integration ID
+     * @param {string} sourceId - The source ID for lookup
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created mapping document
+     * @throws {MappingAlreadyExistsError} If the pair already exists
+     * @abstract
+     */
+    async createMapping(integrationId, sourceId, mapping) {
+        throw new Error('createMapping must be implemented by subclass');
+    }
+
     /**
      * Find all mappings for an integration
      *

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

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

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

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

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

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

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

@@ -419,7 +419,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         for (const [key, value] of Object.entries(patch)) {
             $set[`config.${key}`] = value;
         }
-        $set.updatedAt = new Date();
+        $set.updatedAt = { $date: new Date().toISOString() };
 
         const result = await this.prisma.$runCommandRaw({
             findAndModify: 'Integration',

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

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

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

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

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

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

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

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

package/modules/use-cases/test-module-auth.js

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

package/package.json

@@ -1,15 +1,18 @@
 {
     "name": "@friggframework/core",
+    "description": "",
     "prettier": "@friggframework/prettier-config",
-    "version": "2.0.0--canary.667.f74cf3b.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.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",
@@ -47,9 +50,9 @@
         }
     },
     "devDependencies": {
-        "@friggframework/eslint-config": "2.0.0--canary.667.f74cf3b.0",
-        "@friggframework/prettier-config": "2.0.0--canary.667.f74cf3b.0",
-        "@friggframework/test": "2.0.0--canary.667.f74cf3b.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",
@@ -85,9 +88,8 @@
         "url": "https://github.com/friggframework/frigg/issues"
     },
     "homepage": "https://github.com/friggframework/frigg#readme",
-    "description": "",
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "f74cf3b1f04195508cb0ee6d4086b1cb2d70d913"
+    "gitHead": "ef0dc8cb6c6f56048a61b6759faad7322046925d"
 }

package/modules/use-cases/create-entity-from-credential.js

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

package/modules/utils/find-module-definition.js

@@ -1,23 +0,0 @@
-/**
- * The API module definition a stored entity belongs to.
- *
- * Entities are persisted with `moduleName` set to the definition's
- * `moduleName` (see ProcessAuthorizationCallback.findOrCreateEntity). A
- * definition's legacy `modelName` is accepted as well, for entities written
- * before the two were the same.
- *
- * @param {Array<Object>} moduleDefinitions
- * @param {Object} entity - entity record with a `moduleName`
- * @returns {Object|undefined}
- */
-function findModuleDefinitionForEntity(moduleDefinitions, entity) {
-    const entityType = entity?.moduleName;
-    if (!entityType) return undefined;
-    return (moduleDefinitions || []).find(
-        (def) =>
-            def &&
-            (def.moduleName === entityType || def.modelName === entityType)
-    );
-}
-
-module.exports = { findModuleDefinitionForEntity };