@friggframework/core 2.0.0--canary.690.08cd07e.0 → 2.0.0--canary.694.f66a64a.0

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/integrations/tests/doubles/test-integration-repository.js

@@ -1,6 +1,5 @@
 const { v4: uuid } = require('uuid');
 const { validateConfigPatch } = require('../../repositories/config-patch-shared');
-const { matchesAnyClause } = require('../../../modules/tests/doubles/ownership-matching');
 
 class TestIntegrationRepository {
     constructor() {
@@ -8,14 +7,13 @@ class TestIntegrationRepository {
         this.operationHistory = [];
     }
 
-    async createIntegration(entities, userId, config, tenancy = {}) {
+    async createIntegration(entities, userId, config) {
         const id = uuid();
         const record = {
             id,
             _id: id,
             entitiesIds: entities,
             userId: userId,
-            organizationId: tenancy.organizationId ?? null,
             config,
             version: '0.0.0',
             status: 'IN_CREATION',
@@ -40,15 +38,6 @@ class TestIntegrationRepository {
         return results;
     }
 
-    // Answers the way a database does for the clauses a use case hands it.
-    async findIntegrationsByOwnership(clauses) {
-        const results = Array.from(this.store.values()).filter((r) =>
-            matchesAnyClause(r, clauses)
-        );
-        this.operationHistory.push({ operation: 'findByOwnership', clauses, count: results.length });
-        return results;
-    }
-
     async findIntegrations(filter = {}) {
         const { type, status } = filter;
         const results = Array.from(this.store.values()).filter((r) => {

package/integrations/triggers.js

@@ -0,0 +1,244 @@
+/**
+ * Recurring triggers (ADR-055): what an integration declares, how one installation resolves it, and whether it is
+ * due at a tick. Pure; no I/O. The tick itself is `use-cases/run-trigger-tick.js`; the run is
+ * `IntegrationBase.onTriggerRun`.
+ *
+ *   static Definition = {
+ *       name: 'housecallpro',
+ *       triggers: {
+ *           pollErp: { every: '15m', handler: 'pollErp' },                              // every installation
+ *           ongoingSync: { every: '1h', configurable: { min: '15m' }, handler: sync },   // an installation may retime it
+ *           perPlan: { every: (config) => config.pollEvery, when: (config) => config.poll !== false, handler },
+ *           digest: { cron: '0 8 * * 1-5', timezone: 'America/New_York', configurable: true, handler },
+ *           nightly: { at: 'cron(0 3 * * ? *)', timezone: 'Europe/London', handler },   // same time for everyone
+ *       },
+ *   };
+ *
+ * Nothing is created per installation. Devtools provisions one function per integration with one schedule per
+ * distinct tick and one per `at` trigger (`provisioningOf`). At each tick the function pages through the ENABLED
+ * installations and sends `{ event: 'FRIGG_TRIGGER_RUN', data: { integrationId, trigger, scheduledFor } }` for each
+ * one that is due. A disabled or deleted installation is simply not due, and a config change applies at the next tick.
+ *
+ * Two additions to ADR-055 (its "Amendment (ADR-063)"):
+ *   - `configurable: true | { min }` on an `every` or `cron` trigger lets an installation choose its own timing at
+ *     `config.triggers.<name>` (`{ every }`, `{ cron, timezone }` or `{ enabled: false }`), never more often than `min`.
+ *     A choice that breaks the floor, or a trigger that is not configurable, keeps the default (and is reported).
+ *   - `cron` (five fields, with `timezone`) is a calendar trigger that may differ per installation. It runs off the
+ *     shared tick: due when a firing falls in (previous tick, this tick]. `at` stays the ADR-055 calendar trigger,
+ *     the same for every installation, with an exact schedule of its own.
+ */
+const { parseEvery, validateRecurrence, minGapMinutes, lastFiringIn, isTimeZone } = require('../infrastructure/scheduler/recurrence');
+
+const TRIGGER_RUN = 'FRIGG_TRIGGER_RUN';
+/** A tick that ran out of time sends this to the integration's queue to carry on from its page cursor. */
+const TRIGGER_TICK = 'FRIGG_TRIGGER_TICK';
+
+const DEFAULT_TICK_MINUTES = 5;
+const MAX_EVERY_MINUTES = 1440;   // longer cadences use a calendar (`at` / `cron`)
+const AT = /^cron\(\S+ \S+ \S+ \S+ \S+ \S+\)$/;
+const OVERLAP = ['skip', 'allow'];
+
+const configurableOf = (c) => (c ? (c === true ? {} : c) : false);
+const kindOf = (t) => (t.at !== undefined ? 'at' : t.cron !== undefined ? 'cron' : 'every');
+const recurrenceOf = (r) => (r?.every !== undefined ? { every: r.every } : r?.cron !== undefined ? { cron: r.cron, ...(r.timezone ? { timezone: r.timezone } : {}) } : null);
+
+/** A minutes count as the shortest duration string: 90 -> '90m', 60 -> '1h', 1440 -> '1d'. */
+function durationOf(minutes) {
+    if (minutes % 1440 === 0) return `${minutes / 1440}d`;
+    if (minutes % 60 === 0) return `${minutes / 60}h`;
+    return `${minutes}m`;
+}
+
+/**
+ * The tick a trigger runs on, in minutes. `tick` when set. Otherwise: for a constant `every`, that interval; for an
+ * `every` given as a function, 5 minutes; for a `cron`, 5 minutes, or less when the cron itself fires more often.
+ * A configurable trigger never ticks slower than its floor (or 5 minutes, without one), so the fastest choice it
+ * allows can run. `at` triggers have no tick (null): each has its own schedule.
+ */
+function tickMinutesOf(trigger) {
+    if (kindOf(trigger) === 'at') return null;
+    if (trigger.tick !== undefined) return parseEvery(trigger.tick);
+    const configurable = configurableOf(trigger.configurable);
+    const floor = configurable ? (configurable.min !== undefined ? parseEvery(configurable.min) : DEFAULT_TICK_MINUTES) : Infinity;
+    let natural;
+    if (kindOf(trigger) === 'cron') {
+        const gap = minGapMinutes({ cron: trigger.cron });
+        natural = Math.max(1, Math.min(DEFAULT_TICK_MINUTES, gap ?? DEFAULT_TICK_MINUTES));
+    } else {
+        natural = typeof trigger.every === 'function' ? DEFAULT_TICK_MINUTES : parseEvery(trigger.every) ?? DEFAULT_TICK_MINUTES;
+    }
+    return Math.max(1, Math.min(natural, floor ?? DEFAULT_TICK_MINUTES, MAX_EVERY_MINUTES));
+}
+
+/**
+ * Problems with a trigger declaration, found without an installation (definition time and build time).
+ * @returns {string[]}
+ */
+function validateTrigger(name, t) {
+    const at = (m) => `${name}: ${m}`;
+    if (!t || typeof t !== 'object') return [at('A trigger is an object')];
+    const problems = [];
+    const kinds = ['every', 'at', 'cron'].filter((k) => t[k] !== undefined);
+    if (kinds.length !== 1) return [at('Give exactly one of every, at or cron')];
+    if (typeof t.handler !== 'function' && typeof t.handler !== 'string') problems.push(at('handler must be a function or a method name'));
+    if (t.overlap !== undefined && !OVERLAP.includes(t.overlap)) problems.push(at(`overlap must be ${OVERLAP.join(' or ')}`));
+    if (t.when !== undefined && typeof t.when !== 'function') problems.push(at('when must be a function of the installation config'));
+    if (t.tick !== undefined) {
+        const tick = parseEvery(t.tick);
+        if (tick === null || tick > MAX_EVERY_MINUTES) problems.push(at(`tick "${t.tick}" is not a duration between 1m and 1d`));
+    }
+    const kind = kinds[0];
+    if (kind === 'at') {
+        if (typeof t.at !== 'string' || !AT.test(t.at)) problems.push(at(`at "${t.at}" must be an EventBridge cron(...) expression with six fields`));
+        if (t.timezone !== undefined && !isTimeZone(t.timezone)) problems.push(at(`Unknown time zone "${t.timezone}"`));
+        if (t.configurable) problems.push(at('An at trigger runs at one time for every installation; use cron to let installations choose'));
+        if (t.tick !== undefined) problems.push(at('An at trigger has its own schedule; tick does not apply'));
+        return problems;
+    }
+    const configurable = configurableOf(t.configurable);
+    if (configurable && configurable.min !== undefined && parseEvery(configurable.min) === null) problems.push(at(`configurable.min "${configurable.min}" is not a duration (15m, 2h, 1d)`));
+    if (kind === 'every' && typeof t.every === 'function') return problems;
+    const recurrence = recurrenceOf(t);
+    for (const p of validateRecurrence(recurrence)) problems.push(at(p));
+    if (kind === 'every' && parseEvery(t.every) > MAX_EVERY_MINUTES) problems.push(at(`every "${t.every}" is longer than 1d; use at or cron`));
+    if (!problems.length && configurable && configurable.min !== undefined) {
+        for (const p of validateRecurrence(recurrence, { min: configurable.min })) problems.push(at(`The default breaks its own minimum: ${p}`));
+    }
+    return problems;
+}
+
+/** Problems with every trigger a Definition declares. */
+function validateTriggers(triggers = {}) {
+    return Object.entries(triggers || {}).flatMap(([name, t]) => validateTrigger(name, t));
+}
+
+/**
+ * What devtools provisions for an integration class: the distinct ticks (minutes) of its `every`/`cron` triggers,
+ * including the tick of the triggers it resolves per installation (`Definition.instanceTriggers`), and one entry per
+ * `at` trigger. Throws on an invalid declaration, so a bad trigger fails the build rather than the first tick.
+ *
+ * @returns {{ ticks: number[], at: Array<{ name, at, timezone? }> }}
+ */
+function provisioningOf(IntegrationClass) {
+    const Definition = IntegrationClass?.Definition || {};
+    const triggers = Definition.triggers || {};
+    const problems = validateTriggers(triggers);
+    const instance = Definition.instanceTriggers;
+    if (instance && parseEvery(instance.tick) === null) problems.push(`instanceTriggers.tick "${instance.tick}" is not a duration`);
+    if (problems.length) throw new Error(`Integration "${Definition.name}" declares invalid triggers: ${problems.join('; ')}`);
+    const ticks = new Set();
+    const at = [];
+    for (const [name, t] of Object.entries(triggers)) {
+        if (kindOf(t) === 'at') at.push({ name, at: t.at, ...(t.timezone ? { timezone: t.timezone } : {}) });
+        else ticks.add(tickMinutesOf(t));
+    }
+    if (instance) ticks.add(parseEvery(instance.tick));
+    return { ticks: [...ticks].sort((a, b) => a - b), at };
+}
+
+/** Does this class declare any triggers (fixed or per installation)? */
+function hasTriggers(IntegrationClass) {
+    const Definition = IntegrationClass?.Definition || {};
+    return Object.keys(Definition.triggers || {}).length > 0 || Boolean(Definition.instanceTriggers);
+}
+
+/**
+ * One trigger, resolved for one installation.
+ *
+ * @param {string} name
+ * @param {Object} t - the declaration (plus `choice` when the caller found the installation's choice elsewhere)
+ * @param {Object} config - the installation's config
+ * @returns {{ name, kind, recurrence?, at?, tickMinutes, cadence?, overlap, active: boolean, inactive?: string,
+ *             source: 'definition'|'installation', problems: string[] }}
+ *          `active: false` when `when` excludes the installation or it paused a configurable trigger.
+ *          An invalid choice keeps the default and is listed in `problems`, so a bad edit never stops a trigger.
+ */
+function resolveTrigger(name, t, config = {}) {
+    const kind = kindOf(t);
+    const out = { name, kind, tickMinutes: tickMinutesOf(t), overlap: t.overlap || 'skip', active: true, source: 'definition', problems: [] };
+    if (typeof t.when === 'function' && !t.when(config)) return { ...out, active: false, inactive: 'when' };
+    if (kind === 'at') return { ...out, at: t.at, timezone: t.timezone };
+
+    let recurrence = kind === 'every' ? { every: typeof t.every === 'function' ? t.every(config) : t.every } : recurrenceOf(t);
+    const configurable = configurableOf(t.configurable);
+    const choice = t.choice !== undefined ? t.choice : config?.triggers?.[name];
+    if (choice && typeof choice === 'object' && (recurrenceOf(choice) || choice.enabled !== undefined)) {
+        if (!configurable) out.problems.push('This trigger is not configurable');
+        else {
+            const picked = recurrenceOf(choice);
+            const issues = picked ? validateRecurrence(picked, { min: configurable.min }) : [];
+            if (picked?.every !== undefined && !issues.length && parseEvery(picked.every) > MAX_EVERY_MINUTES) issues.push(`every "${picked.every}" is longer than 1d`);
+            if (issues.length) out.problems.push(...issues);
+            else {
+                if (picked) { recurrence = picked; out.source = 'installation'; }
+                if (choice.enabled === false) return { ...out, recurrence, active: false, inactive: 'paused' };
+            }
+        }
+    }
+    const own = validateRecurrence(recurrence);
+    if (recurrence.every !== undefined && !own.length && parseEvery(recurrence.every) > MAX_EVERY_MINUTES) own.push(`every "${recurrence.every}" is longer than 1d`);
+    if (own.length) return { ...out, recurrence, active: false, inactive: 'invalid', problems: [...out.problems, ...own] };
+    out.recurrence = recurrence;
+    // An interval runs every n ticks (rounded up to a whole number of ticks).
+    if (recurrence.every !== undefined) out.cadence = Math.max(1, Math.ceil(parseEvery(recurrence.every) / out.tickMinutes));
+    return out;
+}
+
+/** A stable, evenly spread number for an installation id (FNV-1a, 32 bits). */
+function hashId(value) {
+    let h = 0x811c9dc5;
+    for (const ch of String(value)) {
+        h ^= ch.codePointAt(0);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h;
+}
+
+/** The start of the tick slot an instant falls in: tick runs are keyed by slot, so a late or repeated tick agrees. */
+function slotStart(timeMs, tickMinutes) {
+    const size = tickMinutes * 60000;
+    return Math.floor(timeMs / size) * size;
+}
+
+/**
+ * Is a resolved trigger due for this installation at this tick slot?
+ *
+ * - every: due when `slot mod n == hash(integrationId) mod n` (n = cadence in ticks), so it is stateless and spreads
+ *   installations evenly across the cadence. scheduledFor is the slot start.
+ * - cron:  due when it fired in (slot start - tick, slot start]. scheduledFor is that firing, so two ticks in one slot
+ *   (a redelivery, a retried continuation) name the same run.
+ * - at:    due whenever its own schedule invoked the tick; scheduledFor is that time, to the minute.
+ *
+ * @param {Object} resolved - from resolveTrigger
+ * @param {{ integrationId, slotMs: number, firing?: (recurrence, from, to) => number|null }} at
+ * @returns {{ scheduledFor: string } | null}
+ */
+function dueRun(resolved, { integrationId, slotMs, firing = lastFiringIn }) {
+    if (!resolved?.active) return null;
+    if (resolved.kind === 'at') return { scheduledFor: new Date(Math.floor(slotMs / 60000) * 60000).toISOString() };
+    if (resolved.recurrence.every !== undefined) {
+        const n = resolved.cadence;
+        const slot = Math.floor(slotMs / (resolved.tickMinutes * 60000));
+        return slot % n === hashId(integrationId) % n ? { scheduledFor: new Date(slotMs).toISOString() } : null;
+    }
+    const fired = firing(resolved.recurrence, slotMs - resolved.tickMinutes * 60000, slotMs);
+    return fired === null ? null : { scheduledFor: new Date(fired).toISOString() };
+}
+
+module.exports = {
+    TRIGGER_RUN,
+    TRIGGER_TICK,
+    DEFAULT_TICK_MINUTES,
+    configurableOf,
+    recurrenceOf,
+    durationOf,
+    tickMinutesOf,
+    validateTrigger,
+    validateTriggers,
+    provisioningOf,
+    hasTriggers,
+    resolveTrigger,
+    hashId,
+    slotStart,
+    dueRun,
+};

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

@@ -27,19 +27,13 @@ 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 OWNER of the integration (ADR-056 §3):
-     *   the person or the organization's user, as ResolveIntegrationOwnership decided.
+     * @param {string} userId - ID of the user creating the integration.
      * @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, tenancy = {}) {
+    async execute(entities, userId, config) {
         console.log(
             `[Frigg] Creating ${config?.type} integration for user ${userId} with entities [${entities}]`
         );
@@ -47,8 +41,7 @@ class CreateIntegration {
         const existing = await this._findDuplicate(
             userId,
             config?.type,
-            entities,
-            tenancy
+            entities
         );
         if (existing) {
             console.log(
@@ -57,18 +50,11 @@ 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,
-                { organizationId: tenancy.organizationId ?? null }
+                config
             );
         console.log(
             `[Frigg] Created integration ${integrationRecord.id} for user ${userId}`
@@ -79,8 +65,7 @@ class CreateIntegration {
         const survivor = await this._findDuplicate(
             userId,
             config?.type,
-            entities,
-            tenancy
+            entities
         );
         if (survivor && String(survivor.id) !== String(integrationRecord.id)) {
             console.log(
@@ -93,8 +78,7 @@ class CreateIntegration {
         }
 
         const integrationInstance = await this._buildInstance(
-            integrationRecord,
-            { integrationClass, modules }
+            integrationRecord
         );
         console.log(
             `[Frigg] Sending ON_CREATE for integration ${integrationRecord.id}`
@@ -151,7 +135,7 @@ class CreateIntegration {
         return mapIntegrationClassToIntegrationDTO(integrationInstance);
     }
 
-    async _findDuplicate(userId, type, entityIds, tenancy = {}) {
+    async _findDuplicate(userId, type, entityIds) {
         const candidates =
             await this.integrationRepository.findIntegrationsByUserId(userId);
         const target = [...(entityIds ?? [])].map(String).sort();
@@ -166,7 +150,6 @@ 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();
@@ -179,15 +162,6 @@ 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 =
@@ -199,36 +173,27 @@ class CreateIntegration {
         })[0];
     }
 
-    _requireClass(type) {
+    async _buildInstance(integrationRecord) {
         const integrationClass = this.integrationClasses.find(
-            (integrationClass) => integrationClass.Definition.name === type
+            (integrationClass) =>
+                integrationClass.Definition.name ===
+                integrationRecord.config.type
         );
+
         if (!integrationClass) {
-            throw new Error(`No integration class found for type: ${type}`);
+            throw new Error(
+                `No integration class found for type: ${integrationRecord.config.type}`
+            );
         }
-        return integrationClass;
-    }
 
-    async _loadModules(entityIds, userId) {
         const modules = [];
-        for (const entityId of entityIds) {
-            modules.push(
-                await this.moduleFactory.getModuleInstance(entityId, userId)
+        for (const entityId of integrationRecord.entitiesIds) {
+            const moduleInstance = await this.moduleFactory.getModuleInstance(
+                entityId,
+                integrationRecord.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/get-integrations-for-user.js

@@ -2,17 +2,9 @@
 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 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}).
+ * Use case for retrieving all integrations for a specific user.
  * @class GetIntegrationsForUser
  */
 class GetIntegrationsForUser {
@@ -23,16 +15,13 @@ 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}
          */
@@ -43,86 +32,57 @@ class GetIntegrationsForUser {
     }
 
     /**
+     * Executes the retrieval of all integrations for a user.
      * @async
-     * @param {Object} user - authenticated User
-     * @param {{scope?: string, owner?: string}} [filters] - `?scope=` and `?owner=`
-     * @returns {Promise<Object[]>} Array of integration DTOs.
+     * @param {string} userId - ID of the user whose integrations to retrieve.
+     * @returns {Promise<Object[]>} Array of integration DTOs for the specified user.
      */
-    async execute(user, filters = {}) {
-        const ctx = this.scopePolicy.accessContext(user);
-        const records = await this.integrationRepository.findIntegrationsByOwnership(
-            visibilityClauses(ctx, 'integration')
-        );
+    async execute(userId) {
+        const integrationRecords =
+            await this.integrationRepository.findIntegrationsByUserId(userId);
 
         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;
-    }
 
-    /** 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
-        );
+        for (const integrationRecord of integrationRecords) {
+            const entities = await this.moduleRepository.findEntitiesByIds(
+                integrationRecord.entitiesIds
+            );
 
-        const modules = [];
-        for (const entity of entities) {
-            const moduleInstance = await this.moduleFactory.getModuleInstance(
-                entity.id,
-                integrationRecord.userId
+            const integrationClass = this.integrationClasses.find(
+                (integrationClass) =>
+                    integrationClass.Definition.name ===
+                    integrationRecord.config.type
             );
-            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 modules = [];
+            for (const entity of entities) {
+                const moduleInstance =
+                    await this.moduleFactory.getModuleInstance(
+                        entity.id,
+                        integrationRecord.userId
+                    );
+                modules.push(moduleInstance);
+            }
 
-/**
- * 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);
-    }
+            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(),
+            };
 
-    /** @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));
+            integrations.push(
+                mapIntegrationClassToIntegrationDTO(integrationData)
+            );
         }
+
         return integrations;
     }
 }
 
-module.exports = { GetIntegrationsForUser, GetIntegrationsByUserId };
+module.exports = { GetIntegrationsForUser };

package/integrations/use-cases/index.js

@@ -1,7 +1,4 @@
-const {
-    GetIntegrationsForUser,
-    GetIntegrationsByUserId,
-} = require('./get-integrations-for-user');
+const { GetIntegrationsForUser } = require('./get-integrations-for-user');
 const { DeleteIntegrationForUser } = require('./delete-integration-for-user');
 const { CreateIntegration } = require('./create-integration');
 const { GetIntegration } = require('./get-integration');
@@ -9,11 +6,9 @@ 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,
@@ -21,5 +16,4 @@ module.exports = {
     UpdateProcessState,
     UpdateProcessMetrics,
     GetProcess,
-    DispatchOngoingSyncs,
 };