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

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

@@ -3,7 +3,6 @@ const {
     IntegrationRepositoryInterface,
 } = require('./integration-repository-interface');
 const { validateConfigPatch } = require('./config-patch-shared');
-const { integrationNotFoundError } = require('./integration-not-found');
 const { strictIntId } = require('./report-id');
 
 /**
@@ -52,7 +51,6 @@ 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(),
@@ -62,25 +60,6 @@ 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
      *
@@ -99,35 +78,16 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         // Map to domain objects with string IDs
         return integrations.map((integration) => {
             const converted = this._convertIntegrationIds(integration);
-            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);
+            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,
+            };
         });
     }
 
@@ -157,7 +117,16 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
 
         return integrations.map((integration) => {
             const converted = this._convertIntegrationIds(integration);
-            return this._mapIntegration(converted);
+            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,
+            };
         });
     }
 
@@ -240,7 +209,15 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         }
 
         const converted = this._convertIntegrationIds(integration);
-        return this._mapIntegration(converted);
+        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,
+        };
     }
 
     /**
@@ -259,11 +236,19 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         });
 
         if (!integration) {
-            throw integrationNotFoundError(id);
+            throw new Error(`Integration with id ${id} not found`);
         }
 
         const converted = this._convertIntegrationIds(integration);
-        return this._mapIntegration(converted);
+        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,
+        };
     }
 
     /**
@@ -343,15 +328,12 @@ 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, tenancy = {}) {
+    async createIntegration(entities, userId, config) {
         const data = {
             config,
             version: '0.0.0',
-            organizationId: this._convertId(tenancy.organizationId ?? null),
         };
 
         // PostgreSQL: use nested relations with ID conversion
@@ -372,7 +354,15 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         });
 
         const converted = this._convertIntegrationIds(integration);
-        return this._mapIntegration(converted);
+        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,
+        };
     }
 
     /**
@@ -395,7 +385,15 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         }
 
         const converted = this._convertIntegrationIds(integration);
-        return this._mapIntegration(converted);
+        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,
+        };
     }
 
     /**
@@ -420,7 +418,15 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
         });
 
         const converted = this._convertIntegrationIds(integration);
-        return this._mapIntegration(converted);
+        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,
+        };
     }
 
     /**
@@ -470,7 +476,15 @@ class IntegrationRepositoryPostgres extends IntegrationRepositoryInterface {
 
         return integrations.map((integration) => {
             const converted = this._convertIntegrationIds(integration);
-            return this._mapIntegration(converted);
+            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,
+            };
         });
     }
 }

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/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,
 }; 

package/integrations/utils/map-integration-dto.js

@@ -19,48 +19,19 @@ function mapIntegrationClassToIntegrationDTO(integration) {
     };
 }
 
-let deprecationLogged = false;
 
-/**
- * @deprecated Since ADR-059. Read `entityTypeRegistry` / `moduleDefinitions`
- * from `loadAppDefinition()`, or call `getEntityTypeRegistry(appDefinition)`
- * and read each entry's `definition`.
- *
- * Kept as a wrapper over the entity type registry so callers that imported it
- * keep working. It returns the registry's definitions, so it follows the
- * registry's rules: one definition per entity type name (the first wins when
- * two integrations bind different definitions under one name, as
- * ModuleFactory already picked), and, when `entities` is passed, registry-only
- * types are included and conflicts throw `EntityRegistryError`.
- *
- * @param {Array<Function>} integrationClasses - integration classes
- * @param {Object} [entities] - `appDefinition.entities` (ADR-059)
- * @returns {Array<Object>} API module definitions
- */
-function getModulesDefinitionFromIntegrationClasses(
-    integrationClasses,
-    entities
-) {
-    // Required here, not at the top: modules/ must not load at require time
-    // of every integration use case that only wants the DTO mapper.
-    const {
-        getEntityTypeRegistry,
-        getEntityTypeDefinitions,
-    } = require('../../modules/entity-type-registry');
-    if (!deprecationLogged) {
-        deprecationLogged = true;
-        const { getLogger } = require('../../logs');
-        getLogger('frigg.integrations').warn(
-            'getModulesDefinitionFromIntegrationClasses is deprecated; use getEntityTypeRegistry (ADR-059)',
-            { eventName: 'frigg.integrations.deprecated_module_definitions' }
-        );
-    }
-    return getEntityTypeDefinitions(
-        getEntityTypeRegistry({ integrations: integrationClasses, entities })
-    );
-}
-
-module.exports = {
-    mapIntegrationClassToIntegrationDTO,
-    getModulesDefinitionFromIntegrationClasses,
+const getModulesDefinitionFromIntegrationClasses = (integrationClasses) => {
+    return [
+        ...new Set(
+            integrationClasses
+                .map((integration) =>
+                    Object.values(integration.Definition.modules).map(
+                        (module) => module.definition
+                    )
+                )
+                .flat()
+        ),
+    ];
 };
+
+module.exports = { mapIntegrationClassToIntegrationDTO, getModulesDefinitionFromIntegrationClasses };