@friggframework/core 2.0.0--canary.703.12b980b.0 → 2.0.0--canary.707.df80bfd.0

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

@@ -3,6 +3,7 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
+const { integrationNotFoundError } = require('./integration-not-found');
 const { strictIntId } = require('./report-id');
 
 /**
@@ -51,6 +52,7 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
             ...integration,
             id: integration.id?.toString(),
             userId: integration.userId?.toString(),
+            organizationId: integration.organizationId?.toString() ?? null,
             entities: integration.entities?.map(e => ({
                 ...e,
                 id: e.id?.toString(),
@@ -60,6 +62,25 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         };
     }
 
+    /**
+     * The one place a converted integration row becomes the record the
+     * application sees (string ids, ids of its entities, its organization).
+     * @private
+     */
+    _mapIntegration(converted) {
+        return {
+            id: converted.id,
+            entitiesIds: converted.entities.map((e) => e.id),
+            userId: converted.userId,
+            organizationId: converted.organizationId,
+            config: converted.config,
+            version: converted.version,
+            status: converted.status,
+            messages: converted.messages,
+            createdAt: converted.createdAt,
+        };
+    }
+
     /**
      * Find all integrations for a user
      *
@@ -78,16 +99,35 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         // Map to domain objects with string IDs
         return integrations.map((integration) => {
             const converted = this._convertIntegrationIds(integration);
-            return {
-                id: converted.id,
-                entitiesIds: converted.entities.map((e) => e.id),
-                userId: converted.userId,
-                config: converted.config,
-                version: converted.version,
-                status: converted.status,
-                messages: converted.messages,
-                createdAt: converted.createdAt,
-            };
+            return this._mapIntegration(converted);
+        });
+    }
+
+    /**
+     * Find integrations matching any of the owner/organization pairs, in one
+     * query. `organizationId: null` matches rows with no organization. The
+     * caller (a use case) decides which pairs; this only runs them.
+     *
+     * @param {Array<{userId: string, organizationId: (string|null)}>} clauses
+     * @returns {Promise<Array>} Array of integration objects with string IDs
+     */
+    async findIntegrationsByOwnership(clauses) {
+        if (!Array.isArray(clauses) || clauses.length === 0) return [];
+        const integrations = await this.prisma.integration.findMany({
+            where: {
+                OR: clauses.map(({ userId, organizationId }) => ({
+                    userId: this._convertId(userId),
+                    organizationId: this._convertId(organizationId),
+                })),
+            },
+            include: {
+                entities: true,
+            },
+        });
+
+        return integrations.map((integration) => {
+            const converted = this._convertIntegrationIds(integration);
+            return this._mapIntegration(converted);
         });
     }
 
@@ -99,7 +139,7 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
      * @param {string} [filter.status] - Integration status
      * @returns {Promise<Array>} Array of integration objects (possibly empty)
      */
-    async findIntegrations({ type, status, limit, after } = {}) {
+    async findIntegrations({ type, status } = {}) {
         const where = {};
         if (type) {
             where.config = { path: ['type'], equals: type };
@@ -107,30 +147,17 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         if (status) {
             where.status = status;
         }
-        if (limit && after !== undefined && after !== null) {
-            where.id = { gt: this._convertId(after) };
-        }
 
         const integrations = await this.prisma.integration.findMany({
             where,
             include: {
                 entities: true,
             },
-            ...(limit ? { orderBy: { id: 'asc' }, take: limit } : {}),
         });
 
         return integrations.map((integration) => {
             const converted = this._convertIntegrationIds(integration);
-            return {
-                id: converted.id,
-                entitiesIds: converted.entities.map((e) => e.id),
-                userId: converted.userId,
-                config: converted.config,
-                version: converted.version,
-                status: converted.status,
-                messages: converted.messages,
-                createdAt: converted.createdAt,
-            };
+            return this._mapIntegration(converted);
         });
     }
 
@@ -213,15 +240,7 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         }
 
         const converted = this._convertIntegrationIds(integration);
-        return {
-            id: converted.id,
-            entitiesIds: converted.entities.map((e) => e.id),
-            userId: converted.userId,
-            config: converted.config,
-            version: converted.version,
-            status: converted.status,
-            messages: converted.messages,
-        };
+        return this._mapIntegration(converted);
     }
 
     /**
@@ -240,19 +259,11 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         });
 
         if (!integration) {
-            throw new Error(`Integration with id ${id} not found`);
+            throw integrationNotFoundError(id);
         }
 
         const converted = this._convertIntegrationIds(integration);
-        return {
-            id: converted.id,
-            entitiesIds: converted.entities.map((e) => e.id),
-            userId: converted.userId,
-            config: converted.config,
-            version: converted.version,
-            status: converted.status,
-            messages: converted.messages,
-        };
+        return this._mapIntegration(converted);
     }
 
     /**
@@ -332,12 +343,15 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
      * @param {Array<string>} entities - Array of entity IDs (strings from application layer)
      * @param {string} userId - User ID (string from application layer)
      * @param {Object} config - Integration configuration
+     * @param {{organizationId?: (string|null)}} [tenancy] - the organization the
+     *   integration is created in (ADR-056 §3.6)
      * @returns {Promise<Object>} Created integration object with string IDs
      */
-    async createIntegration(entities, userId, config) {
+    async createIntegration(entities, userId, config, tenancy = {}) {
         const data = {
             config,
             version: '0.0.0',
+            organizationId: this._convertId(tenancy.organizationId ?? null),
         };
 
         // PostgreSQL: use nested relations with ID conversion
@@ -358,15 +372,7 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         });
 
         const converted = this._convertIntegrationIds(integration);
-        return {
-            id: converted.id,
-            entitiesIds: converted.entities.map((e) => e.id),
-            userId: converted.userId,
-            config: converted.config,
-            version: converted.version,
-            status: converted.status,
-            messages: converted.messages,
-        };
+        return this._mapIntegration(converted);
     }
 
     /**
@@ -389,15 +395,7 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         }
 
         const converted = this._convertIntegrationIds(integration);
-        return {
-            id: converted.id,
-            entitiesIds: converted.entities.map((e) => e.id),
-            userId: converted.userId,
-            config: converted.config,
-            version: converted.version,
-            status: converted.status,
-            messages: converted.messages,
-        };
+        return this._mapIntegration(converted);
     }
 
     /**
@@ -422,15 +420,7 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         });
 
         const converted = this._convertIntegrationIds(integration);
-        return {
-            id: converted.id,
-            entitiesIds: converted.entities.map((e) => e.id),
-            userId: converted.userId,
-            config: converted.config,
-            version: converted.version,
-            status: converted.status,
-            messages: converted.messages,
-        };
+        return this._mapIntegration(converted);
     }
 
     /**
@@ -480,15 +470,7 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
 
         return integrations.map((integration) => {
             const converted = this._convertIntegrationIds(integration);
-            return {
-                id: converted.id,
-                entitiesIds: converted.entities.map((e) => e.id),
-                userId: converted.userId,
-                config: converted.config,
-                version: converted.version,
-                status: converted.status,
-                messages: converted.messages,
-            };
+            return this._mapIntegration(converted);
         });
     }
 }

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 = { $date: new Date().toISOString() };
+        $set.updatedAt = new Date();
         update.$set = $set;
 
         if (Object.keys(normalized.pushSlice).length > 0) {

package/integrations/schedule-config.js

@@ -0,0 +1,80 @@
+/**
+ * An integration's schedule configuration (`static Definition.schedule`),
+ * read by hosts that tick ONGOING_SYNC from a cron (provider-netlify's
+ * scheduled-sync function).
+ *
+ *   schedule: {
+ *       // 'class' (default): one ONGOING_SYNC per integration class per tick,
+ *       //   with no integration id: the worker runs it on an unhydrated
+ *       //   instance, so the handler finds its own installations.
+ *       // 'installation': one ONGOING_SYNC per ENABLED integration record of
+ *       //   the class, carrying `data.integrationId`, so the worker hydrates
+ *       //   that installation before the handler runs.
+ *       scope: 'installation',
+ *       // Optional, 'installation' only: (integration, { now }) => boolean |
+ *       // Promise<boolean>. Return false to skip that installation this tick.
+ *       // Without it every installation is dispatched on every tick.
+ *       isDue: (integration, { now }) => true,
+ *   }
+ *
+ * Validated at load (loadAppDefinition) so a mistyped scope stops the app
+ * rather than silently falling back to 'class'.
+ */
+
+const SCHEDULE_SCOPES = Object.freeze({
+    CLASS: 'class',
+    INSTALLATION: 'installation',
+});
+
+const DEFAULT_SCHEDULE_SCOPE = SCHEDULE_SCOPES.CLASS;
+
+class ScheduleConfigError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ScheduleConfigError';
+        this.code = 'SCHEDULE_CONFIG_INVALID';
+    }
+}
+
+/**
+ * @param {Object} [definition] - an integration's static Definition
+ * @returns {{ scope: 'class'|'installation', isDue: Function|null }}
+ * @throws {ScheduleConfigError} when `schedule` is malformed
+ */
+function resolveScheduleConfig(definition) {
+    const name = definition?.name || 'integration';
+    const schedule = definition?.schedule;
+    if (schedule === undefined || schedule === null) {
+        return { scope: DEFAULT_SCHEDULE_SCOPE, isDue: null };
+    }
+    if (typeof schedule !== 'object' || Array.isArray(schedule)) {
+        throw new ScheduleConfigError(`${name}: Definition.schedule must be an object`);
+    }
+
+    const scopes = Object.values(SCHEDULE_SCOPES);
+    const scope = schedule.scope === undefined ? DEFAULT_SCHEDULE_SCOPE : schedule.scope;
+    if (!scopes.includes(scope)) {
+        throw new ScheduleConfigError(
+            `${name}: Definition.schedule.scope must be one of ${scopes.map((s) => `'${s}'`).join(', ')} (got ${JSON.stringify(schedule.scope)})`
+        );
+    }
+
+    const isDue = schedule.isDue === undefined ? null : schedule.isDue;
+    if (isDue !== null && typeof isDue !== 'function') {
+        throw new ScheduleConfigError(`${name}: Definition.schedule.isDue must be a function`);
+    }
+    if (isDue && scope !== SCHEDULE_SCOPES.INSTALLATION) {
+        throw new ScheduleConfigError(
+            `${name}: Definition.schedule.isDue applies to scope 'installation' only`
+        );
+    }
+
+    return { scope, isDue };
+}
+
+module.exports = {
+    SCHEDULE_SCOPES,
+    DEFAULT_SCHEDULE_SCOPE,
+    ScheduleConfigError,
+    resolveScheduleConfig,
+};

package/integrations/tests/doubles/test-integration-repository.js

@@ -1,5 +1,6 @@
 const { v4: uuid } = require('uuid');
 const { validateConfigPatch } = require('../../repositories/config-patch-shared');
+const { matchesAnyClause } = require('../../../modules/tests/doubles/ownership-matching');
 
 class TestIntegrationRepository {
     constructor() {
@@ -7,13 +8,14 @@ class TestIntegrationRepository {
         this.operationHistory = [];
     }
 
-    async createIntegration(entities, userId, config) {
+    async createIntegration(entities, userId, config, tenancy = {}) {
         const id = uuid();
         const record = {
             id,
             _id: id,
             entitiesIds: entities,
             userId: userId,
+            organizationId: tenancy.organizationId ?? null,
             config,
             version: '0.0.0',
             status: 'IN_CREATION',
@@ -38,6 +40,15 @@ 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/use-cases/create-integration.js

@@ -1,4 +1,3 @@
-const { resolveIntegrationClass } = require('../integration-types');
 // Removed Integration wrapper - using IntegrationBase directly
 const {
     mapIntegrationClassToIntegrationDTO,
@@ -28,31 +27,28 @@ 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}]`
         );
 
-        // Only a type this user may install: registered code, the app's catalogue, or one their workspace built.
-        const integrationClass = await resolveIntegrationClass(
-            this.integrationClasses,
-            config?.type,
-            { workspaceId: String(userId) }
-        );
-        if (!integrationClass) {
-            throw new Error(`No integration class found for type: ${config?.type}`);
-        }
-
         const existing = await this._findDuplicate(
             userId,
             config?.type,
-            entities
+            entities,
+            tenancy
         );
         if (existing) {
             console.log(
@@ -61,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}`
@@ -76,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(
@@ -89,7 +93,8 @@ class CreateIntegration {
         }
 
         const integrationInstance = await this._buildInstance(
-            integrationRecord
+            integrationRecord,
+            { integrationClass, modules }
         );
         console.log(
             `[Frigg] Sending ON_CREATE for integration ${integrationRecord.id}`
@@ -146,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();
@@ -161,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();
@@ -173,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 =
@@ -184,26 +199,36 @@ class CreateIntegration {
         })[0];
     }
 
-    async _buildInstance(integrationRecord) {
-        const integrationClass = await resolveIntegrationClass(
-            this.integrationClasses,
-            integrationRecord.config.type
+    _requireClass(type) {
+        const integrationClass = this.integrationClasses.find(
+            (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/delete-integration-for-user.js

@@ -1,4 +1,3 @@
-const { resolveIntegrationClass } = require('../integration-types');
 const Boom = require('@hapi/boom');
 const { getLogger } = require('../../logs');
 
@@ -45,9 +44,10 @@ class DeleteIntegrationForUser {
             );
         }
 
-        const integrationClass = await resolveIntegrationClass(
-            this.integrationClasses,
-            integrationRecord.config.type
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) =>
+                integrationClass.Definition.name ===
+                integrationRecord.config.type
         );
 
         if (integrationRecord.userId !== userId) {

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-integration-for-user.js

@@ -1,4 +1,3 @@
-const { resolveIntegrationClass } = require('../integration-types');
 // Removed Integration wrapper - using IntegrationBase directly
 const { mapIntegrationClassToIntegrationDTO } = require('../utils/map-integration-dto');
 const Boom = require('@hapi/boom');
@@ -48,9 +47,8 @@ class GetIntegrationForUser {
             throw Boom.forbidden('User does not have access to this integration');
         }
 
-        const integrationClass = await resolveIntegrationClass(
-            this.integrationClasses,
-            integrationRecord.config.type
+        const integrationClass = this.integrationClasses.find(
+            (integrationClass) => integrationClass.Definition.name === integrationRecord.config.type
         );
 
         const modules = [];