@friggframework/core 2.0.0--canary.680.daae24e.0 → 2.0.0--canary.686.e94de4d.0

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

@@ -27,13 +27,19 @@ class CreateIntegration {
      * and entity set, instead of creating a duplicate.
      * @async
      * @param {string[]} entities - Array of entity IDs to associate with the integration.
-     * @param {string} userId - ID of the user creating the integration.
+     * @param {string} userId - ID of the OWNER of the integration (ADR-056 §3):
+     *   the person or the organization's user, as ResolveIntegrationOwnership decided.
      * @param {Object} config - Configuration object for the integration.
      * @param {string} config.type - Type of integration to create.
+     * @param {{organizationId?: (string|null), adoptUnscoped?: boolean}} [tenancy]
+     *   the organization it is created in (§3.6). A duplicate is only reused in
+     *   the same organization, so one person's integration in organization A is
+     *   not handed back as the one they asked for in B. `adoptUnscoped` also
+     *   accepts a duplicate written before scoping (no organization).
      * @returns {Promise<Object>} The created or reused integration DTO.
      * @throws {Error} When integration class is not found for the specified type.
      */
-    async execute(entities, userId, config) {
+    async execute(entities, userId, config, tenancy = {}) {
         console.log(
             `[Frigg] Creating ${config?.type} integration for user ${userId} with entities [${entities}]`
         );
@@ -41,7 +47,8 @@ class CreateIntegration {
         const existing = await this._findDuplicate(
             userId,
             config?.type,
-            entities
+            entities,
+            tenancy
         );
         if (existing) {
             console.log(
@@ -50,11 +57,18 @@ class CreateIntegration {
             return this._reuseExisting(existing, config);
         }
 
+        // Everything that can be refused is refused before a row is written: an
+        // unknown type, or an entity the owner cannot load, would otherwise
+        // leave an IN_CREATION integration behind that nothing moves on.
+        const integrationClass = this._requireClass(config?.type);
+        const modules = await this._loadModules(entities, userId);
+
         const integrationRecord =
             await this.integrationRepository.createIntegration(
                 entities,
                 userId,
-                config
+                config,
+                { organizationId: tenancy.organizationId ?? null }
             );
         console.log(
             `[Frigg] Created integration ${integrationRecord.id} for user ${userId}`
@@ -65,7 +79,8 @@ class CreateIntegration {
         const survivor = await this._findDuplicate(
             userId,
             config?.type,
-            entities
+            entities,
+            tenancy
         );
         if (survivor && String(survivor.id) !== String(integrationRecord.id)) {
             console.log(
@@ -78,7 +93,8 @@ class CreateIntegration {
         }
 
         const integrationInstance = await this._buildInstance(
-            integrationRecord
+            integrationRecord,
+            { integrationClass, modules }
         );
         console.log(
             `[Frigg] Sending ON_CREATE for integration ${integrationRecord.id}`
@@ -135,7 +151,7 @@ class CreateIntegration {
         return mapIntegrationClassToIntegrationDTO(integrationInstance);
     }
 
-    async _findDuplicate(userId, type, entityIds) {
+    async _findDuplicate(userId, type, entityIds, tenancy = {}) {
         const candidates =
             await this.integrationRepository.findIntegrationsByUserId(userId);
         const target = [...(entityIds ?? [])].map(String).sort();
@@ -150,6 +166,7 @@ class CreateIntegration {
             // matching how teardown failures are already handled here.
             if (integration.status === 'IN_DELETION') return false;
             if (integration.config?.type !== type) return false;
+            if (!this._sameOrganization(integration, tenancy)) return false;
             const current = [...(integration.entitiesIds ?? [])]
                 .map(String)
                 .sort();
@@ -162,6 +179,15 @@ class CreateIntegration {
         return matches.length ? this._pickOldest(matches) : null;
     }
 
+    /** Same organization, or a row from before scoping that belongs here. */
+    _sameOrganization(integration, tenancy) {
+        const wanted = tenancy.organizationId ?? null;
+        const has = integration.organizationId ?? null;
+        if (wanted === null && has === null) return true;
+        if (wanted !== null && has !== null) return String(wanted) === String(has);
+        return has === null && tenancy.adoptUnscoped === true;
+    }
+
     _pickOldest(records) {
         return [...records].sort((a, b) => {
             const diff =
@@ -173,27 +199,36 @@ class CreateIntegration {
         })[0];
     }
 
-    async _buildInstance(integrationRecord) {
+    _requireClass(type) {
         const integrationClass = this.integrationClasses.find(
-            (integrationClass) =>
-                integrationClass.Definition.name ===
-                integrationRecord.config.type
+            (integrationClass) => integrationClass.Definition.name === type
         );
-
         if (!integrationClass) {
-            throw new Error(
-                `No integration class found for type: ${integrationRecord.config.type}`
-            );
+            throw new Error(`No integration class found for type: ${type}`);
         }
+        return integrationClass;
+    }
 
+    async _loadModules(entityIds, userId) {
         const modules = [];
-        for (const entityId of integrationRecord.entitiesIds) {
-            const moduleInstance = await this.moduleFactory.getModuleInstance(
-                entityId,
-                integrationRecord.userId
+        for (const entityId of entityIds) {
+            modules.push(
+                await this.moduleFactory.getModuleInstance(entityId, userId)
             );
-            modules.push(moduleInstance);
         }
+        return modules;
+    }
+
+    async _buildInstance(integrationRecord, preloaded) {
+        const integrationClass =
+            preloaded?.integrationClass ??
+            this._requireClass(integrationRecord.config.type);
+        const modules =
+            preloaded?.modules ??
+            (await this._loadModules(
+                integrationRecord.entitiesIds,
+                integrationRecord.userId
+            ));
 
         const integrationInstance = new integrationClass({
             id: integrationRecord.id,

package/integrations/use-cases/dispatch-ongoing-syncs.js

@@ -0,0 +1,100 @@
+const {
+    SCHEDULE_SCOPES,
+    resolveScheduleConfig,
+} = require('../schedule-config');
+
+const ONGOING_SYNC_EVENT = 'ONGOING_SYNC';
+const ACTIVE_STATUS = 'ENABLED';
+
+/**
+ * Dispatches one cron tick of ONGOING_SYNC to the queue worker, per each
+ * integration class's `Definition.schedule.scope` (schedule-config.js):
+ *
+ * - 'class' (default): one message per class, `data: {}`.
+ * - 'installation': one message per ENABLED integration record of the class,
+ *   `data: { integrationId }`, so the worker hydrates that installation;
+ *   skipped when the definition's `isDue(integration, { now })` says no.
+ *
+ * Only classes that implement `startOngoingSync` take part. A failure for one
+ * class or installation is counted and logged; the rest still go out.
+ */
+class DispatchOngoingSyncs {
+    /**
+     * @param {Object} params
+     * @param {Object} params.integrationRepository - findIntegrations({ type, status })
+     * @param {Object} params.queueProvider - send(message, queueId)
+     * @param {string} params.queueId - the worker the messages go to
+     * @param {() => Date} [params.now]
+     * @param {Object} [params.logger=console]
+     */
+    constructor({ integrationRepository, queueProvider, queueId, now = () => new Date(), logger = console }) {
+        this.integrationRepository = integrationRepository;
+        this.queueProvider = queueProvider;
+        this.queueId = queueId;
+        this.now = now;
+        this.logger = logger;
+    }
+
+    /**
+     * @param {Array<Function>} integrationClasses
+     * @returns {Promise<{ dispatched: number, notDue: number, errors: number }>}
+     */
+    async execute(integrationClasses = []) {
+        const result = { dispatched: 0, notDue: 0, errors: 0 };
+        const now = this.now();
+
+        for (const IntegrationClass of integrationClasses) {
+            const name = IntegrationClass?.Definition?.name;
+            if (!name) continue;
+            if (typeof IntegrationClass.prototype?.startOngoingSync !== 'function') continue;
+
+            try {
+                const { scope, isDue } = resolveScheduleConfig(IntegrationClass.Definition);
+                if (scope === SCHEDULE_SCOPES.INSTALLATION) {
+                    await this._dispatchPerInstallation(name, isDue, now, result);
+                } else {
+                    await this._send(name, {});
+                    result.dispatched++;
+                }
+            } catch (error) {
+                result.errors++;
+                this.logger.error(`[ScheduledSync] Failed to dispatch sync for ${name}:`, error.message);
+            }
+        }
+
+        return result;
+    }
+
+    async _dispatchPerInstallation(name, isDue, now, result) {
+        const integrations = await this.integrationRepository.findIntegrations({
+            type: name,
+            status: ACTIVE_STATUS,
+        });
+
+        for (const integration of integrations || []) {
+            try {
+                if (isDue && (await isDue(integration, { now })) !== true) {
+                    result.notDue++;
+                    continue;
+                }
+                await this._send(name, { integrationId: integration.id });
+                result.dispatched++;
+            } catch (error) {
+                result.errors++;
+                this.logger.error(
+                    `[ScheduledSync] Failed to dispatch sync for ${name} integration ${integration?.id}:`,
+                    error.message
+                );
+            }
+        }
+    }
+
+    _send(integrationName, data) {
+        return this.queueProvider.send(
+            { integrationName, event: ONGOING_SYNC_EVENT, data },
+            this.queueId
+        );
+    }
+}
+
+module.exports = { DispatchOngoingSyncs, ONGOING_SYNC_EVENT };

package/integrations/use-cases/get-integrations-for-user.js

@@ -2,9 +2,17 @@
 const {
     mapIntegrationClassToIntegrationDTO,
 } = require('../utils/map-integration-dto');
+const {
+    describeRecord,
+    visibilityClauses,
+    matchesListFilters,
+} = require('../../modules/scope-visibility');
+const { DEFAULT_SCOPE_POLICY } = require('../../modules/scope-policy');
 
 /**
- * Use case for retrieving all integrations for a specific user.
+ * Use case for retrieving the integrations a caller may see: the ones they own
+ * or their active organization owns, created in that organization (ADR-056
+ * §3.6), each with `tenancy` ({scope, owner, organizationId, access}).
  * @class GetIntegrationsForUser
  */
 class GetIntegrationsForUser {
@@ -15,13 +23,16 @@ class GetIntegrationsForUser {
      * @param {Array<import('../integration').Integration>} params.integrationClasses - Array of available integration classes.
      * @param {import('../../modules/module-factory').ModuleFactory} params.moduleFactory - Service for module instantiation and management.
      * @param {import('../../modules/repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository - Repository for module and entity data operations.
+     * @param {Object} [params.scopePolicy] - from createScopePolicy
      */
     constructor({
         integrationRepository,
         integrationClasses,
         moduleFactory,
         moduleRepository,
+        scopePolicy,
     }) {
+        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
         /**
          * @type {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface}
          */
@@ -32,57 +43,86 @@ class GetIntegrationsForUser {
     }
 
     /**
-     * Executes the retrieval of all integrations for a user.
      * @async
-     * @param {string} userId - ID of the user whose integrations to retrieve.
-     * @returns {Promise<Object[]>} Array of integration DTOs for the specified user.
+     * @param {Object} user - authenticated User
+     * @param {{scope?: string, owner?: string}} [filters] - `?scope=` and `?owner=`
+     * @returns {Promise<Object[]>} Array of integration DTOs.
      */
-    async execute(userId) {
-        const integrationRecords =
-            await this.integrationRepository.findIntegrationsByUserId(userId);
+    async execute(user, filters = {}) {
+        const ctx = this.scopePolicy.accessContext(user);
+        const records = await this.integrationRepository.findIntegrationsByOwnership(
+            visibilityClauses(ctx, 'integration')
+        );
 
         const integrations = [];
+        for (const record of records) {
+            // The query is the filter; the same rule again means a repository
+            // that returns too much cannot widen the list.
+            const tenancy = describeRecord(record, ctx, 'integration');
+            if (!tenancy || !matchesListFilters(tenancy, filters)) continue;
+            integrations.push({ ...(await this.toDto(record)), tenancy });
+        }
+        return integrations;
+    }
 
-        for (const integrationRecord of integrationRecords) {
-            const entities = await this.moduleRepository.findEntitiesByIds(
-                integrationRecord.entitiesIds
-            );
+    /** Hydrates one stored integration record into its DTO. */
+    async toDto(integrationRecord) {
+        const entities = await this.moduleRepository.findEntitiesByIds(
+            integrationRecord.entitiesIds
+        );
+
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) =>
+                integrationClass.Definition.name ===
+                integrationRecord.config.type
+        );
 
-            const integrationClass = this.integrationClasses.find(
-                (integrationClass) =>
-                    integrationClass.Definition.name ===
-                    integrationRecord.config.type
+        const modules = [];
+        for (const entity of entities) {
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
+                entity.id,
+                integrationRecord.userId
             );
+            modules.push(moduleInstance);
+        }
 
-            const modules = [];
-            for (const entity of entities) {
-                const moduleInstance =
-                    await this.moduleFactory.getModuleInstance(
-                        entity.id,
-                        integrationRecord.userId
-                    );
-                modules.push(moduleInstance);
-            }
+        return mapIntegrationClassToIntegrationDTO({
+            id: integrationRecord.id,
+            userId: integrationRecord.userId,
+            entities: entities,
+            config: integrationRecord.config,
+            status: integrationRecord.status,
+            version: integrationRecord.version,
+            messages: integrationRecord.messages || { errors: [], warnings: [] },
+            modules,
+            options: integrationClass.getOptionDetails(),
+        });
+    }
+}
 
-            const integrationData = {
-                id: integrationRecord.id,
-                userId: integrationRecord.userId,
-                entities: entities,
-                config: integrationRecord.config,
-                status: integrationRecord.status,
-                version: integrationRecord.version,
-                messages: integrationRecord.messages || { errors: [], warnings: [] },
-                modules,
-                options: integrationClass.getOptionDetails(),
-            };
+/**
+ * Every integration one user id owns, with no organization rules: the lookup
+ * behind the app-level `friggCommands.findIntegrationsByUserId`, which has a
+ * user id and no request.
+ */
+class GetIntegrationsByUserId {
+    /** @param {ConstructorParameters<typeof GetIntegrationsForUser>[0]} params */
+    constructor(params) {
+        this.integrationRepository = params.integrationRepository;
+        this.hydrator = new GetIntegrationsForUser(params);
+    }
 
-            integrations.push(
-                mapIntegrationClassToIntegrationDTO(integrationData)
-            );
+    /** @param {string} userId */
+    async execute(userId) {
+        const records = await this.integrationRepository.findIntegrationsByUserId(
+            userId
+        );
+        const integrations = [];
+        for (const record of records) {
+            integrations.push(await this.hydrator.toDto(record));
         }
-
         return integrations;
     }
 }
 
-module.exports = { GetIntegrationsForUser };
+module.exports = { GetIntegrationsForUser, GetIntegrationsByUserId };

package/integrations/use-cases/index.js

@@ -1,4 +1,7 @@
-const { GetIntegrationsForUser } = require('./get-integrations-for-user');
+const {
+    GetIntegrationsForUser,
+    GetIntegrationsByUserId,
+} = require('./get-integrations-for-user');
 const { DeleteIntegrationForUser } = require('./delete-integration-for-user');
 const { CreateIntegration } = require('./create-integration');
 const { GetIntegration } = require('./get-integration');
@@ -6,9 +9,11 @@ const { CreateProcess } = require('./create-process');
 const { UpdateProcessState } = require('./update-process-state');
 const { UpdateProcessMetrics } = require('./update-process-metrics');
 const { GetProcess } = require('./get-process');
+const { DispatchOngoingSyncs } = require('./dispatch-ongoing-syncs');
 
 module.exports = {
     GetIntegrationsForUser,
+    GetIntegrationsByUserId,
     DeleteIntegrationForUser,
     CreateIntegration,
     GetIntegration,
@@ -16,4 +21,5 @@ module.exports = {
     UpdateProcessState,
     UpdateProcessMetrics,
     GetProcess,
+    DispatchOngoingSyncs,
 }; 

package/integrations/use-cases/integration-operations-for-user.js

@@ -1,11 +1,15 @@
 const Boom = require('@hapi/boom');
-const { userOwns } = require('../../modules/use-cases/get-entity-module-for-user');
+const { describeRecord } = require('../../modules/scope-visibility');
+const { DEFAULT_SCOPE_POLICY } = require('../../modules/scope-policy');
+const { assertCanManage } = require('../../modules/use-cases/manage-access');
+const { isIntegrationNotFound } = require('../repositories/integration-not-found');
 
 /**
- * Management API v2 integration operations. They put an ownership check
- * (missing or foreign integration = 404) in front of the existing
- * integration use cases, and pass the record's owner id on, so the
- * organisation user model works the same as for entities.
+ * Management API v2 integration operations. They put an access check
+ * (missing or unavailable integration = 404) in front of the existing
+ * integration use cases, and pass the record's owner id on. Access follows
+ * the owner and the organization the integration was created in (ADR-056
+ * §3.6), not the owner alone.
  */
 
 const notFound = (integrationId) =>
@@ -13,40 +17,61 @@ const notFound = (integrationId) =>
         code: 'INTEGRATION_NOT_FOUND',
     });
 
-/** The integration record, or 404 when it is missing or not the caller's. */
+/**
+ * The integration record, or 404 when it is missing or the caller may not
+ * use it: not theirs or their active organization's, or created in another
+ * organization.
+ */
 class GetOwnedIntegrationRecord {
-    constructor({ integrationRepository }) {
+    constructor({ integrationRepository, scopePolicy }) {
         this.integrationRepository = integrationRepository;
+        this.scopePolicy = scopePolicy || DEFAULT_SCOPE_POLICY;
     }
 
-    async execute(integrationId, user) {
+    /** `{ scope, owner, organizationId, access }` of a record to this caller, or null. */
+    describe(record, user) {
+        return describeRecord(record, this.scopePolicy.accessContext(user), 'integration');
+    }
+
+    /**
+     * @param {string} integrationId
+     * @param {Object} user - authenticated User
+     * @param {{manage?: boolean}} [options] - `manage: true` for changing or
+     *   deleting: a person may use an organization's integration but only an
+     *   admin may change it (403 ORG_ADMIN_REQUIRED)
+     */
+    async execute(integrationId, user, { manage = false } = {}) {
         let record = null;
         try {
             record = await this.integrationRepository.findIntegrationById(
                 integrationId
             );
         } catch (error) {
-            if (/Invalid ID|ObjectId|Malformed/i.test(error?.message || '')) {
+            if (
+                /Invalid ID|ObjectId|Malformed/i.test(error?.message || '') ||
+                isIntegrationNotFound(error)
+            ) {
                 throw notFound(integrationId);
             }
             throw error;
         }
-        if (!record || !userOwns(user, record.userId)) {
-            throw notFound(integrationId);
-        }
+        const tenancy = record && this.describe(record, user);
+        if (!tenancy) throw notFound(integrationId);
+        if (manage) assertCanManage(tenancy.access, `integration ${integrationId}`);
         return record;
     }
 }
 
 /**
- * Creates (or reuses) an integration between entities the caller owns.
- * Unlike v1, the entities' ownership and the integration type are checked
- * before anything is written.
+ * Creates (or reuses) an integration between entities the caller may use.
+ * The entities' access, the binding scopes and the integration type are
+ * checked before anything is written, and the integration is owned and
+ * paired with an organization by `resolveIntegrationOwnership` (§3, §3.6).
  */
 class CreateIntegrationForUser {
-    constructor({ createIntegration, getEntityModuleForUser, integrationClasses }) {
+    constructor({ createIntegration, resolveIntegrationOwnership, integrationClasses }) {
         this.createIntegration = createIntegration;
-        this.getEntityModuleForUser = getEntityModuleForUser;
+        this.resolveIntegrationOwnership = resolveIntegrationOwnership;
         this.integrationClasses = integrationClasses || [];
     }
 
@@ -74,13 +99,17 @@ class CreateIntegrationForUser {
                 details: { field: 'entities' },
             });
         }
-        for (const entityId of entities) {
-            await this.getEntityModuleForUser.loadOwnedEntity(String(entityId), user);
-        }
+        const { ownerId, organizationId, adoptUnscoped } =
+            await this.resolveIntegrationOwnership.execute({
+                entityIds: entities,
+                config,
+                user,
+            });
         return this.createIntegration.execute(
             entities.map(String),
-            user.getId(),
-            config
+            ownerId,
+            config,
+            { organizationId, adoptUnscoped }
         );
     }
 }
@@ -117,7 +146,8 @@ class UpdateIntegrationForUser {
         }
         const record = await this.getOwnedIntegrationRecord.execute(
             integrationId,
-            user
+            user,
+            { manage: true }
         );
         return this.updateIntegration.execute(record.id, record.userId, config);
     }
@@ -133,7 +163,8 @@ class RemoveIntegrationForUser {
     async execute(integrationId, user) {
         const record = await this.getOwnedIntegrationRecord.execute(
             integrationId,
-            user
+            user,
+            { manage: true }
         );
         await this.deleteIntegrationForUser.execute(record.id, record.userId);
     }