@friggframework/core 2.0.0--canary.690.08cd07e.0 → 2.0.0--canary.693.d8859c2.0

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

@@ -1,4 +1,5 @@
 const { prisma } = require('../../database/prisma');
+const { MappingAlreadyExistsError } = require('../../errors');
 const {
     toObjectId,
     fromObjectId,
@@ -180,6 +181,55 @@ class IntegrationMappingRepositoryDocumentDB extends IntegrationMappingRepositor
         return this._mapMapping(decryptedMapping);
     }
 
+    async createMapping(integrationId, sourceId, mapping) {
+        const now = new Date();
+        const encryptedDocument = await this.encryptionService.encryptFields(
+            'IntegrationMapping',
+            {
+                integrationId,
+                sourceId:
+                    sourceId === null || sourceId === undefined
+                        ? null
+                        : String(sourceId),
+                mapping,
+                createdAt: now,
+                updatedAt: now,
+            }
+        );
+
+        let insertedId;
+        try {
+            insertedId = await insertOne(
+                this.prisma,
+                'IntegrationMapping',
+                encryptedDocument
+            );
+        } catch (error) {
+            if (error.code === 11000) {
+                throw new MappingAlreadyExistsError(integrationId, sourceId, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+
+        const created = await findOne(this.prisma, 'IntegrationMapping', {
+            _id: insertedId,
+        });
+        if (!created) {
+            throw new Error(
+                'Failed to create mapping: Document not found after insert. ' +
+                    'This indicates a database consistency issue.'
+            );
+        }
+        return this._mapMapping(
+            await this.encryptionService.decryptFields(
+                'IntegrationMapping',
+                created
+            )
+        );
+    }
+
     async findMappingsByIntegration(integrationId) {
         const filter = {};
         if (integrationId) filter.integrationId = integrationId;

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

@@ -39,6 +39,21 @@ class IntegrationMappingRepositoryInterface {
         throw new Error('Method upsertMapping must be implemented by subclass');
     }
 
+    /**
+     * Insert a mapping, failing if one already exists for the
+     * (integrationId, sourceId) pair. Atomic: usable as a claim/lock row.
+     *
+     * @param {string|number} integrationId - The integration ID
+     * @param {string} sourceId - The source ID for lookup
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created mapping document
+     * @throws {MappingAlreadyExistsError} If the pair already exists
+     * @abstract
+     */
+    async createMapping(integrationId, sourceId, mapping) {
+        throw new Error('createMapping must be implemented by subclass');
+    }
+
     /**
      * Find all mappings for an integration
      *

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

@@ -1,4 +1,5 @@
 const { prisma } = require('../../database/prisma');
+const { MappingAlreadyExistsError } = require('../../errors');
 const {
     assertMappingWrittenUnencrypted,
     decryptQueriedMappings,
@@ -93,6 +94,34 @@ class IntegrationMappingRepositoryMongo extends IntegrationMappingRepositoryInte
         });
     }
 
+    /**
+     * Insert a mapping; fails if (integrationId, sourceId) already exists
+     *
+     * @param {string} integrationId - The integration ID
+     * @param {string} sourceId - The source ID
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created mapping document
+     * @throws {MappingAlreadyExistsError} If the pair already exists
+     */
+    async createMapping(integrationId, sourceId, mapping) {
+        try {
+            return await this.prisma.integrationMapping.create({
+                data: {
+                    integrationId,
+                    sourceId: this._toString(sourceId),
+                    mapping,
+                },
+            });
+        } catch (error) {
+            if (error.code === 'P2002') {
+                throw new MappingAlreadyExistsError(integrationId, sourceId, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+
     /**
      * Find all mappings for an integration
      * Replaces: IntegrationMapping.find({ integration: integrationId })

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

@@ -1,4 +1,5 @@
 const { prisma } = require('../../database/prisma');
+const { MappingAlreadyExistsError } = require('../../errors');
 const {
     assertMappingWrittenUnencrypted,
     decryptQueriedMappings,
@@ -150,6 +151,35 @@ class IntegrationMappingRepositoryPostgres extends IntegrationMappingRepositoryI
         return this._convertMappingIds(result);
     }
 
+    /**
+     * Insert a mapping; fails if (integrationId, sourceId) already exists
+     *
+     * @param {string} integrationId - The integration ID
+     * @param {string} sourceId - The source ID
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created mapping document
+     * @throws {MappingAlreadyExistsError} If the pair already exists
+     */
+    async createMapping(integrationId, sourceId, mapping) {
+        try {
+            const created = await this.prisma.integrationMapping.create({
+                data: {
+                    integrationId: this._stringToInt(integrationId),
+                    sourceId: this._toString(sourceId),
+                    mapping,
+                },
+            });
+            return this._convertMappingIds(created);
+        } catch (error) {
+            if (error.code === 'P2002') {
+                throw new MappingAlreadyExistsError(integrationId, sourceId, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+
     /**
      * Find all mappings for an integration
      * Replaces: IntegrationMapping.find({ integration: integrationId })

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

@@ -1,4 +1,5 @@
 const { prisma } = require('../../database/prisma');
+const { MappingAlreadyExistsError } = require('../../errors');
 const {
     IntegrationMappingRepositoryInterface,
 } = require('./integration-mapping-repository-interface');
@@ -69,6 +70,34 @@ class IntegrationMappingRepository extends IntegrationMappingRepositoryInterface
         });
     }
 
+    /**
+     * Insert a mapping; fails if (integrationId, sourceId) already exists
+     *
+     * @param {string} integrationId - The integration ID
+     * @param {string} sourceId - The source ID
+     * @param {Object} mapping - The mapping data
+     * @returns {Promise<Object>} The created mapping document
+     * @throws {MappingAlreadyExistsError} If the pair already exists
+     */
+    async createMapping(integrationId, sourceId, mapping) {
+        try {
+            return await this.prisma.integrationMapping.create({
+                data: {
+                    integrationId,
+                    sourceId,
+                    mapping,
+                },
+            });
+        } catch (error) {
+            if (error.code === 'P2002') {
+                throw new MappingAlreadyExistsError(integrationId, sourceId, {
+                    cause: error,
+                });
+            }
+            throw error;
+        }
+    }
+
     /**
      * Find all mappings for an integration
      * Replaces: IntegrationMapping.find({ integration: integrationId })

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

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

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

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

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

@@ -1,10 +1,8 @@
 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
@@ -27,25 +25,6 @@ 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')
@@ -62,32 +41,16 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         });
 
         // Map to domain objects (maintains same API)
-        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)));
+        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,
+        }));
     }
 
     /**
@@ -114,7 +77,16 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             },
         });
 
-        return integrations.map((integration) => (this._mapIntegration(integration)));
+        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,
+        }));
     }
 
     /**
@@ -193,7 +165,15 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             throw new Error(`Integration with name ${name} not found`);
         }
 
-        return this._mapIntegration(integration);
+        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,
+        };
     }
 
     /**
@@ -212,10 +192,18 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         });
 
         if (!integration) {
-            throw integrationNotFoundError(id);
+            throw new Error(`Integration with id ${id} not found`);
         }
 
-        return this._mapIntegration(integration);
+        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,
+        };
     }
 
     /**
@@ -302,7 +290,15 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             },
         });
 
-        return integrations.map((integration) => (this._mapIntegration(integration)));
+        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,
+        }));
     }
 
     /**
@@ -314,16 +310,13 @@ 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, tenancy = {}) {
+    async createIntegration(entities, userId, config) {
         const data = {
             config,
             version: '0.0.0',
             userId: userId,
-            organizationId: tenancy.organizationId ?? null,
             entityIds: entities,
         };
 
@@ -334,7 +327,15 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             },
         });
 
-        return this._mapIntegration(integration);
+        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,
+        };
     }
 
     /**
@@ -356,7 +357,15 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             return null;
         }
 
-        return this._mapIntegration(integration);
+        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,
+        };
     }
 
     /**
@@ -380,7 +389,15 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
             },
         });
 
-        return this._mapIntegration(integration);
+        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,
+        };
     }
 
     /**
@@ -402,7 +419,7 @@ class IntegrationRepositoryMongo extends IntegrationRepositoryInterface {
         for (const [key, value] of Object.entries(patch)) {
             $set[`config.${key}`] = value;
         }
-        $set.updatedAt = new Date();
+        $set.updatedAt = { $date: new Date().toISOString() };
 
         const result = await this.prisma.$runCommandRaw({
             findAndModify: 'Integration',