@friggframework/core 2.0.0--canary.704.79d9a63.0 → 2.0.0--canary.686.e94de4d.0

package/integrations/repositories/integration-not-found.js

@@ -0,0 +1,14 @@
+/**
+ * The error `findIntegrationById` throws for an id with no row, and the one
+ * predicate that recognises it. The adapters build the error here and the
+ * use cases match it here, so the message is written once and a missing
+ * integration can be told from any other failure without widening a regex.
+ */
+const MESSAGE = /^Integration with id .+ not found$/;
+
+const integrationNotFoundError = (id) =>
+    new Error(`Integration with id ${id} not found`);
+
+const isIntegrationNotFound = (error) => MESSAGE.test(error?.message || '');
+
+module.exports = { integrationNotFoundError, isIntegrationNotFound };

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

@@ -14,6 +14,7 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
+const { integrationNotFoundError } = require('./integration-not-found');
 
 class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     constructor() {
@@ -28,6 +29,28 @@ 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) {
@@ -68,11 +91,11 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
     async findIntegrationById(id) {
         const objectId = toObjectId(id);
         if (!objectId) {
-            throw new Error(`Integration with id ${id} not found`);
+            throw integrationNotFoundError(id);
         }
         const doc = await findOne(this.prisma, 'Integration', { _id: objectId });
         if (!doc) {
-            throw new Error(`Integration with id ${id} not found`);
+            throw integrationNotFoundError(id);
         }
         return this._mapIntegration(doc);
     }
@@ -132,10 +155,18 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         return true;
     }
 
-    async createIntegration(entities, userId, config) {
+    /**
+     * @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 = {}) {
         const now = new Date();
         const document = {
             userId: toObjectId(userId) || null,
+            organizationId: toObjectId(tenancy.organizationId) || null,
             config,
             version: '0.0.0',
             status: 'IN_CREATION',
@@ -164,38 +195,6 @@ class IntegrationRepositoryDocumentDB extends IntegrationRepositoryInterface {
         return this._mapIntegration(created);
     }
 
-    async addEntitiesToIntegration(integrationId, entityIds) {
-        const objectId = toObjectId(integrationId);
-        if (!objectId) return null;
-        const result = await updateOne(
-            this.prisma,
-            'Integration',
-            { _id: objectId },
-            {
-                $addToSet: { entityIds: { $each: toObjectIdArray(entityIds) } },
-                $set: { updatedAt: { $date: new Date().toISOString() } },
-            }
-        );
-        if (!result?.n) return null;
-        return this.findIntegrationById(integrationId);
-    }
-
-    async removeEntitiesFromIntegration(integrationId, entityIds) {
-        const objectId = toObjectId(integrationId);
-        if (!objectId) return null;
-        const result = await updateOne(
-            this.prisma,
-            'Integration',
-            { _id: objectId },
-            {
-                $pullAll: { entityIds: toObjectIdArray(entityIds) },
-                $set: { updatedAt: { $date: new Date().toISOString() } },
-            }
-        );
-        if (!result?.n) return null;
-        return this.findIntegrationById(integrationId);
-    }
-
     async findIntegrationByUserId(userId) {
         const objectId = toObjectId(userId);
         if (!objectId) return null;
@@ -330,6 +329,7 @@ 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,6 +10,20 @@
  * @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
      *
@@ -123,10 +137,12 @@ 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) {
+    async createIntegration(entities, userId, config, tenancy) {
         throw new Error('Method createIntegration must be implemented by subclass');
     }
 
@@ -184,36 +200,6 @@ class IntegrationRepositoryInterface {
             'Method findIntegrationsByEntityId must be implemented by subclass'
         );
     }
-
-    /**
-     * Attach entities to an existing integration. Entities that are already
-     * attached are left as they are.
-     *
-     * @param {string|number} integrationId - Integration ID
-     * @param {Array<string|number>} entityIds - Entity IDs to attach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     * @abstract
-     */
-    async addEntitiesToIntegration(integrationId, entityIds) {
-        throw new Error(
-            'Method addEntitiesToIntegration must be implemented by subclass'
-        );
-    }
-
-    /**
-     * Detach entities from an integration. Entities that are not attached
-     * are ignored; the entities themselves are not deleted.
-     *
-     * @param {string|number} integrationId - Integration ID
-     * @param {Array<string|number>} entityIds - Entity IDs to detach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     * @abstract
-     */
-    async removeEntitiesFromIntegration(integrationId, entityIds) {
-        throw new Error(
-            'Method removeEntitiesFromIntegration must be implemented by subclass'
-        );
-    }
 }
 
 module.exports = { IntegrationRepositoryInterface };

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

@@ -1,8 +1,10 @@
 const { prisma } = require('../../database/prisma');
+const { organizationWhere } = require('../../database/organization-where');
 const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
+const { integrationNotFoundError } = require('./integration-not-found');
 
 /**
  * MongoDB Integration Repository Adapter
@@ -25,6 +27,25 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         this.prisma = prisma;
     }
 
+    /**
+     * The one place a integration integration row becomes the record the
+     * application sees (ids of its entities, its organization).
+     * @private
+     */
+    _mapIntegration(integration) {
+        return {
+            id: integration.id,
+            entitiesIds: integration.entities.map((e) => e.id),
+            userId: integration.userId,
+            organizationId: integration.organizationId ?? null,
+            config: integration.config,
+            version: integration.version,
+            status: integration.status,
+            messages: integration.messages,
+            createdAt: integration.createdAt,
+        };
+    }
+
     /**
      * Find all integrations for a user
      * Replaces: IntegrationModel.find({ user: userId }).populate('entities')
@@ -41,16 +62,32 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         });
 
         // Map to domain objects (maintains same API)
-        return integrations.map((integration) => ({
-            id: integration.id,
-            entitiesIds: integration.entities.map((e) => e.id),
-            userId: integration.userId,
-            config: integration.config,
-            version: integration.version,
-            status: integration.status,
-            messages: integration.messages,
-            createdAt: integration.createdAt,
-        }));
+        return integrations.map((integration) => (this._mapIntegration(integration)));
+    }
+
+    /**
+     * 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
+     */
+    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,
+                    ...organizationWhere(organizationId),
+                })),
+            },
+            include: {
+                entities: true,
+            },
+        });
+
+        return integrations.map((integration) => (this._mapIntegration(integration)));
     }
 
     /**
@@ -77,16 +114,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             },
         });
 
-        return integrations.map((integration) => ({
-            id: integration.id,
-            entitiesIds: integration.entities.map((e) => e.id),
-            userId: integration.userId,
-            config: integration.config,
-            version: integration.version,
-            status: integration.status,
-            messages: integration.messages,
-            createdAt: integration.createdAt,
-        }));
+        return integrations.map((integration) => (this._mapIntegration(integration)));
     }
 
     /**
@@ -165,15 +193,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             throw new Error(`Integration with name ${name} not found`);
         }
 
-        return {
-            id: integration.id,
-            entitiesIds: integration.entities.map((e) => e.id),
-            userId: integration.userId,
-            config: integration.config,
-            version: integration.version,
-            status: integration.status,
-            messages: integration.messages,
-        };
+        return this._mapIntegration(integration);
     }
 
     /**
@@ -192,18 +212,10 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         });
 
         if (!integration) {
-            throw new Error(`Integration with id ${id} not found`);
+            throw integrationNotFoundError(id);
         }
 
-        return {
-            id: integration.id,
-            entitiesIds: integration.entities.map((e) => e.id),
-            userId: integration.userId,
-            config: integration.config,
-            version: integration.version,
-            status: integration.status,
-            messages: integration.messages,
-        };
+        return this._mapIntegration(integration);
     }
 
     /**
@@ -290,15 +302,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             },
         });
 
-        return integrations.map((integration) => ({
-            id: integration.id,
-            entitiesIds: integration.entities.map((e) => e.id),
-            userId: integration.userId,
-            config: integration.config,
-            version: integration.version,
-            status: integration.status,
-            messages: integration.messages,
-        }));
+        return integrations.map((integration) => (this._mapIntegration(integration)));
     }
 
     /**
@@ -310,13 +314,16 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
      * @param {Array<string>} entities - Array of entity IDs (MongoDB ObjectIds)
      * @param {string} userId - User ID (MongoDB ObjectId)
      * @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
      */
-    async createIntegration(entities, userId, config) {
+    async createIntegration(entities, userId, config, tenancy = {}) {
         const data = {
             config,
             version: '0.0.0',
             userId: userId,
+            organizationId: tenancy.organizationId ?? null,
             entityIds: entities,
         };
 
@@ -327,67 +334,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             },
         });
 
-        return {
-            id: integration.id,
-            entitiesIds: integration.entities.map((e) => e.id),
-            userId: integration.userId,
-            config: integration.config,
-            version: integration.version,
-            status: integration.status,
-            messages: integration.messages,
-        };
-    }
-
-    /**
-     * Attach entities to an existing integration. Entities already attached
-     * are left as they are.
-     *
-     * @param {string} integrationId - Integration ID
-     * @param {Array<string>} entityIds - Entity IDs to attach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     */
-    async addEntitiesToIntegration(integrationId, entityIds) {
-
-        try {
-            await this.prisma.integration.update({
-                where: { id: integrationId },
-                data: {
-                    entities: {
-                        connect: entityIds.map((id) => ({ id })),
-                    },
-                },
-            });
-        } catch (error) {
-            if (error.code === 'P2025') return null;
-            throw error;
-        }
-        return this.findIntegrationById(integrationId);
-    }
-
-    /**
-     * Detach entities from an integration. Entities that are not attached
-     * are ignored. The entities themselves are not deleted.
-     *
-     * @param {string} integrationId - Integration ID
-     * @param {Array<string>} entityIds - Entity IDs to detach
-     * @returns {Promise<Object|null>} Updated integration, or null when the integration does not exist
-     */
-    async removeEntitiesFromIntegration(integrationId, entityIds) {
-
-        try {
-            await this.prisma.integration.update({
-                where: { id: integrationId },
-                data: {
-                    entities: {
-                        disconnect: entityIds.map((id) => ({ id })),
-                    },
-                },
-            });
-        } catch (error) {
-            if (error.code === 'P2025') return null;
-            throw error;
-        }
-        return this.findIntegrationById(integrationId);
+        return this._mapIntegration(integration);
     }
 
     /**
@@ -409,15 +356,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             return null;
         }
 
-        return {
-            id: integration.id,
-            entitiesIds: integration.entities.map((e) => e.id),
-            userId: integration.userId,
-            config: integration.config,
-            version: integration.version,
-            status: integration.status,
-            messages: integration.messages,
-        };
+        return this._mapIntegration(integration);
     }
 
     /**
@@ -441,15 +380,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             },
         });
 
-        return {
-            id: integration.id,
-            entitiesIds: integration.entities.map((e) => e.id),
-            userId: integration.userId,
-            config: integration.config,
-            version: integration.version,
-            status: integration.status,
-            messages: integration.messages,
-        };
+        return this._mapIntegration(integration);
     }
 
     /**
@@ -471,7 +402,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         for (const [key, value] of Object.entries(patch)) {
             $set[`config.${key}`] = value;
         }
-        $set.updatedAt = { $date: new Date().toISOString() };
+        $set.updatedAt = new Date();
 
         const result = await this.prisma.$runCommandRaw({
             findAndModify: 'Integration',