@friggframework/core 2.0.0--canary.684.0da024b.0 → 2.0.0--canary.679.a2bcc2f.0

package/integrations/integration-router.js

@@ -51,27 +51,22 @@ const {
 const {
     createUserRepository,
 } = require('../user/repositories/user-repository-factory');
+const {
+    GetUserFromBearerToken,
+} = require('../user/use-cases/get-user-from-bearer-token');
+const {
+    GetUserFromXFriggHeaders,
+} = require('../user/use-cases/get-user-from-x-frigg-headers');
+const {
+    GetUserFromAdopterJwt,
+} = require('../user/use-cases/get-user-from-adopter-jwt');
 const {
     AuthenticateWithSharedSecret,
 } = require('../user/use-cases/authenticate-with-shared-secret');
 const { AuthenticateUser } = require('../user/use-cases/authenticate-user');
-const {
-    buildUserAuthentication,
-} = require('../user/create-user-authentication');
 const {
     ProcessAuthorizationCallback,
 } = require('../modules/use-cases/process-authorization-callback');
-const { createScopePolicy } = require('../modules/scope-policy');
-const {
-    AuthorizeEntityForUser,
-} = require('../modules/use-cases/authorize-entity-for-user');
-const {
-    CreateEntityFromCredential,
-} = require('../modules/use-cases/create-entity-from-credential');
-const {
-    ResolveIntegrationOwnership,
-} = require('./use-cases/resolve-integration-ownership');
-const { GetOwnedIntegrationRecord } = require('./use-cases/integration-operations-for-user');
 
 const log = getLogger('frigg.integrations');
 
@@ -82,20 +77,26 @@ function createIntegrationRouter() {
         integrations: integrationClasses,
         userConfig,
         moduleDefinitions,
-        ownership,
-        entityTypeRegistry,
     } = loadAppDefinition();
-    // Ownership by scope (ADR-056 §3): one object every use case asks.
-    const scopePolicy = createScopePolicy({ ownership, entityTypeRegistry });
     const moduleRepository = createModuleRepository();
     const integrationRepository = createIntegrationRepository();
     const credentialRepository = createCredentialRepository();
     const userRepository = createUserRepository();
-    const {
-        getUserFromBearerToken,
-        getUserFromXFriggHeaders,
-        getUserFromAdopterJwt,
-    } = buildUserAuthentication({ userConfig, userRepository });
+
+    const getUserFromBearerToken = new GetUserFromBearerToken({
+        userRepository,
+        userConfig,
+    });
+
+    const getUserFromXFriggHeaders = new GetUserFromXFriggHeaders({
+        userRepository,
+        userConfig,
+    });
+
+    const getUserFromAdopterJwt = new GetUserFromAdopterJwt({
+        userRepository,
+        userConfig,
+    });
 
     const authenticateWithSharedSecret = new AuthenticateWithSharedSecret();
 
@@ -122,19 +123,6 @@ function createIntegrationRouter() {
         integrationClasses,
         moduleFactory,
         moduleRepository,
-        scopePolicy,
-    });
-
-    // Decides who owns a new integration and which entities the caller may bind
-    // (the v1 create used to check neither), and who may reach an existing one.
-    const resolveIntegrationOwnership = new ResolveIntegrationOwnership({
-        moduleRepository,
-        integrationClasses,
-        scopePolicy,
-    });
-    const getOwnedIntegrationRecord = new GetOwnedIntegrationRecord({
-        integrationRepository,
-        scopePolicy,
     });
 
     const getCredentialForUser = new GetCredentialForUser({
@@ -150,7 +138,6 @@ function createIntegrationRouter() {
     const getEntitiesForUser = new GetEntitiesForUser({
         moduleRepository,
         moduleDefinitions,
-        scopePolicy,
     });
 
     const getIntegrationInstance = new GetIntegrationInstance({
@@ -176,55 +163,37 @@ function createIntegrationRouter() {
     const testModuleAuth = new TestModuleAuth({
         moduleRepository,
         moduleDefinitions,
-        scopePolicy,
     });
 
     const getModule = new GetModule({
         moduleRepository,
         moduleDefinitions,
-        scopePolicy,
     });
 
     const getEntityOptionsById = new GetEntityOptionsById({
         moduleRepository,
         moduleDefinitions,
-        scopePolicy,
     });
 
     const refreshEntityOptions = new RefreshEntityOptions({
         moduleRepository,
         moduleDefinitions,
-        scopePolicy,
     });
 
     const getPossibleIntegrations = new GetPossibleIntegrations({
         integrationClasses,
     });
 
-    // The owner of what an authorization creates follows its scope (ADR-056 §3.2).
     const processAuthorizationCallback = new ProcessAuthorizationCallback({
         moduleRepository,
         credentialRepository,
         integrationRepository,
         moduleDefinitions,
     });
-    const authorizeEntityForUser = new AuthorizeEntityForUser({
-        scopePolicy,
-        processAuthorizationCallback,
-    });
-    // v1 POST /api/entity: same owner resolution as /api/authorize.
-    const createEntityFromCredential = new CreateEntityFromCredential({
-        authorizeEntityForUser,
-        processAuthorizationCallback,
-        credentialRepository,
-        moduleDefinitions,
-    });
 
     const router = express();
 
     setIntegrationRoutes(router, authenticateUser, {
-        resolveIntegrationOwnership,
-        getOwnedIntegrationRecord,
         createIntegration,
         deleteIntegrationForUser,
         getIntegrationsForUser,
@@ -241,8 +210,7 @@ function createIntegrationRouter() {
         getModule,
         getEntityOptionsById,
         refreshEntityOptions,
-        authorizeEntityForUser,
-        createEntityFromCredential,
+        processAuthorizationCallback,
     });
     return router;
 }
@@ -279,8 +247,6 @@ function checkRequiredParams(params, requiredKeys) {
  */
 function setIntegrationRoutes(router, authenticateUser, useCases) {
     const {
-        resolveIntegrationOwnership,
-        getOwnedIntegrationRecord,
         createIntegration,
         deleteIntegrationForUser,
         getIntegrationsForUser,
@@ -289,22 +255,15 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
         updateIntegration,
         getPossibleIntegrations,
     } = useCases;
-
-    // The owner of an integration the caller may reach (404 otherwise), which is
-    // what the id-and-owner use cases below expect. `manage: true` is for
-    // changing or deleting: an organization's integration needs an admin (403).
-    const ownerOf = async (integrationId, user, options) =>
-        (await getOwnedIntegrationRecord.execute(integrationId, user, options))
-            .userId;
-
     router.route('/api/integrations').get(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
-            const integrations = await getIntegrationsForUser.execute(user);
+            const userId = user.getId();
+            const integrations = await getIntegrationsForUser.execute(userId);
             const results = {
                 entities: {
                     options: await getPossibleIntegrations.execute(),
-                    authorized: await getEntitiesForUser.execute(user),
+                    authorized: await getEntitiesForUser.execute(userId),
                 },
                 integrations: integrations,
             };
@@ -316,6 +275,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
     router.route('/api/integrations').post(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
+            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entities',
                 'config',
@@ -323,17 +283,10 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
 
             get(params.config, 'type');
 
-            const { ownerId, organizationId, adoptUnscoped } =
-                await resolveIntegrationOwnership.execute({
-                    entityIds: params.entities,
-                    config: params.config,
-                    user,
-                });
             const integration = await createIntegration.execute(
                 params.entities,
-                ownerId,
-                params.config,
-                { organizationId, adoptUnscoped }
+                userId,
+                params.config
             );
 
             res.status(201).json(integration);
@@ -343,11 +296,12 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
     router.route('/api/integrations/:integrationId').patch(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
+            const userId = user.getId();
             const params = checkRequiredParams(req.body, ['config']);
 
             const integration = await updateIntegration.execute(
                 req.params.integrationId,
-                await ownerOf(req.params.integrationId, user, { manage: true }),
+                userId,
                 params.config
             );
             res.json(integration);
@@ -360,7 +314,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             await deleteIntegrationForUser.execute(
                 params.integrationId,
-                await ownerOf(params.integrationId, user, { manage: true })
+                user.getId()
             );
             res.status(204).json({});
         })
@@ -372,7 +326,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             const integration = await getIntegrationInstance.execute(
                 params.integrationId,
-                await ownerOf(params.integrationId, user)
+                user.getId()
             );
             res.json(await integration.send('GET_CONFIG_OPTIONS'));
         })
@@ -388,7 +342,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
                 ]);
                 const integration = await getIntegrationInstance.execute(
                     params.integrationId,
-                    await ownerOf(params.integrationId, user)
+                    user.getId()
                 );
 
                 res.json(
@@ -402,7 +356,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             const integration = await getIntegrationInstance.execute(
                 params.integrationId,
-                await ownerOf(params.integrationId, user)
+                user.getId()
             );
             res.json(await integration.send('GET_USER_ACTIONS', req.body));
         })
@@ -419,7 +373,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
                 ]);
                 const integration = await getIntegrationInstance.execute(
                     params.integrationId,
-                    await ownerOf(params.integrationId, user)
+                    user.getId()
                 );
 
                 res.json(
@@ -444,7 +398,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
                 ]);
                 const integration = await getIntegrationInstance.execute(
                     params.integrationId,
-                    await ownerOf(params.integrationId, user)
+                    user.getId()
                 );
 
                 res.json(
@@ -465,7 +419,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             ]);
             const integration = await getIntegrationInstance.execute(
                 params.integrationId,
-                await ownerOf(params.integrationId, user)
+                user.getId()
             );
             res.json(await integration.send(params.actionId, req.body));
         })
@@ -482,7 +436,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             const integration = await getIntegrationInstance.execute(
                 params.integrationId,
-                await ownerOf(params.integrationId, user)
+                user.getId()
             );
 
             // We could perhaps augment router with dynamic options? Haven't decided yet, but here may be the place
@@ -502,7 +456,7 @@ function setIntegrationRoutes(router, authenticateUser, useCases) {
             const params = checkRequiredParams(req.params, ['integrationId']);
             const instance = await getIntegrationInstance.execute(
                 params.integrationId,
-                await ownerOf(params.integrationId, user)
+                user.getId()
             );
 
             if (!instance) {
@@ -540,21 +494,16 @@ function setEntityRoutes(router, authenticateUser, useCases) {
         getModule,
         getEntityOptionsById,
         refreshEntityOptions,
-        authorizeEntityForUser,
-        createEntityFromCredential,
+        processAuthorizationCallback,
     } = useCases;
 
     router.route('/api/authorize').get(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
+            const userId = user.getId();
             const params = checkRequiredParams(req.query, ['entityType']);
-            // The owner POST stores under, so GET and POST describe one connection.
-            const { ownerId } = authorizeEntityForUser.resolveOwnership({
-                user,
-                entityType: params.entityType,
-            });
             const module = await getModuleInstanceFromType.execute(
-                ownerId,
+                userId,
                 params.entityType,
                 { state: req.query.state }
             );
@@ -573,15 +522,11 @@ function setEntityRoutes(router, authenticateUser, useCases) {
     router.route('/api/authorize').post(
         catchAsyncError(async (req, res) => {
             const user = await authenticateUser.execute(req);
+            const userId = user.getId();
             const params = checkRequiredParams(req.body, [
                 'entityType',
                 'data',
             ]);
-            const ownership = authorizeEntityForUser.resolveOwnership({
-                user,
-                entityType: params.entityType,
-            });
-            const userId = ownership.ownerId;
 
             const dataKeys =
                 params.data && typeof params.data === 'object'
@@ -593,13 +538,11 @@ function setEntityRoutes(router, authenticateUser, useCases) {
                 dataKeys,
             });
 
-            const { result: entityDetails } =
-                await authorizeEntityForUser.execute({
-                    user,
-                    entityType: params.entityType,
-                    data: params.data,
-                    ownership,
-                });
+            const entityDetails = await processAuthorizationCallback.execute(
+                userId,
+                params.entityType,
+                params.data
+            );
 
             log.info('Entity authorized', {
                 eventName: 'frigg.integrations.authorized',
@@ -616,20 +559,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']);
 
-            // The owner follows the entity type's scope, as /api/authorize.
-            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-repository-documentdb.js

@@ -14,7 +14,6 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
-const { integrationNotFoundError } = require('./integration-not-found');
 
 class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     constructor() {
@@ -29,28 +28,6 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         return records.map((doc) => this._mapIntegration(doc));
     }
 
-    /**
-     * Find integrations matching any of the owner/organization pairs, in one
-     * query. `organizationId: null` matches rows with no organization (a raw
-     * MongoDB `null` also matches a missing field). The caller (a use case)
-     * decides which pairs; this only runs them.
-     *
-     * @param {Array<{userId: string, organizationId: (string|null)}>} clauses
-     * @returns {Promise<Array>}
-     */
-    async findIntegrationsByOwnership(clauses) {
-        if (!Array.isArray(clauses) || clauses.length === 0) return [];
-        // Drained: a list can hold more than the first cursor batch (~101).
-        const records = await findManyDrained(this.prisma, 'Integration', {
-            $or: clauses.map(({ userId, organizationId }) => ({
-                userId: toObjectId(userId),
-                organizationId:
-                    organizationId === null ? null : toObjectId(organizationId),
-            })),
-        });
-        return records.map((doc) => this._mapIntegration(doc));
-    }
-
     async findIntegrations({ type, status } = {}) {
         const filter = {};
         if (type) {
@@ -91,11 +68,11 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     async findIntegrationById(id) {
         const objectId = toObjectId(id);
         if (!objectId) {
-            throw integrationNotFoundError(id);
+            throw new Error(`Integration with id ${id} not found`);
         }
         const doc = await findOne(this.prisma, 'Integration', { _id: objectId });
         if (!doc) {
-            throw integrationNotFoundError(id);
+            throw new Error(`Integration with id ${id} not found`);
         }
         return this._mapIntegration(doc);
     }
@@ -155,18 +132,10 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         return true;
     }
 
-    /**
-     * @param {Array<string>} entities - entity ids
-     * @param {string} userId - owner (the person, or the organization's user)
-     * @param {Object} config - Integration configuration
-     * @param {{organizationId?: (string|null)}} [tenancy] - the organization the
-     *   integration is created in (ADR-056 §3.6)
-     */
-    async createIntegration(entities, userId, config, tenancy = {}) {
+    async createIntegration(entities, userId, config) {
         const now = new Date();
         const document = {
             userId: toObjectId(userId) || null,
-            organizationId: toObjectId(tenancy.organizationId) || null,
             config,
             version: '0.0.0',
             status: 'IN_CREATION',
@@ -329,7 +298,6 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
             id: fromObjectId(doc?._id),
             entitiesIds: (doc?.entityIds || []).map((value) => fromObjectId(value)),
             userId: fromObjectId(doc?.userId),
-            organizationId: fromObjectId(doc?.organizationId) ?? null,
             config: doc?.config ?? null,
             version: doc?.version ?? null,
             status: doc?.status ?? null,

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

@@ -10,20 +10,6 @@
  * @abstract
  */
 class IntegrationRepositoryInterface {
-    /**
-     * Find integrations matching any of the owner/organization pairs, in one
-     * query (ADR-056 §3.6). `organizationId: null` matches rows with no
-     * organization. Which pairs is decided by the caller
-     * (modules/entity-scope.js), not here.
-     *
-     * @param {Array<{userId: string|number, organizationId: (string|number|null)}>} clauses
-     * @returns {Promise<Array>} Array of integration objects
-     * @abstract
-     */
-    async findIntegrationsByOwnership(clauses) {
-        throw new Error('Method findIntegrationsByOwnership must be implemented by subclass');
-    }
-
     /**
      * Find all integrations for a user
      *
@@ -137,12 +123,10 @@ class IntegrationRepositoryInterface {
      * @param {Array<string|number>} entities - Array of entity IDs
      * @param {string|number} userId - User ID
      * @param {Object} config - Integration configuration
-     * @param {{organizationId?: (string|number|null)}} [tenancy] - the organization the
-     *   integration is created in (ADR-056 §3.6)
      * @returns {Promise<Object>} Created integration object
      * @abstract
      */
-    async createIntegration(entities, userId, config, tenancy) {
+    async createIntegration(entities, userId, config) {
         throw new Error('Method createIntegration must be implemented by subclass');
     }