@friggframework/core 2.0.0--canary.686.df38e8e.0 → 2.0.0--canary.710.9045bbc.0

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/use-cases/remove-entities-from-integration.js

@@ -0,0 +1,70 @@
+const {
+    assertEntityIdsInput,
+    integrationNotFound,
+    loadIntegration,
+} = require('../utils/assert-entity-ids-input');
+
+/**
+ * Detaches entities from an integration. Entities that are not attached are
+ * ignored, and detached entities are not deleted. Every module the
+ * integration holds must keep at least one entity, so the integration can
+ * still hydrate each of its modules.
+ * @class RemoveEntitiesFromIntegration
+ */
+class RemoveEntitiesFromIntegration {
+    /**
+     * @param {Object} params
+     * @param {import('../repositories/integration-repository-interface').IntegrationRepositoryInterface} params.integrationRepository
+     * @param {import('../../modules/repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository
+     */
+    constructor({ integrationRepository, moduleRepository }) {
+        this.integrationRepository = integrationRepository;
+        this.moduleRepository = moduleRepository;
+    }
+
+    /**
+     * @param {string} integrationId
+     * @param {string[]} entityIds
+     * @returns {Promise<Object>} The updated integration record.
+     */
+    async execute(integrationId, entityIds) {
+        assertEntityIdsInput(integrationId, entityIds);
+
+        const integration = await loadIntegration(
+            this.integrationRepository,
+            integrationId
+        );
+
+        const removing = new Set(entityIds.map(String));
+        const attached = await this.moduleRepository.findEntitiesByIds(
+            integration.entitiesIds ?? []
+        );
+        const emptied = [...new Set(attached.map((e) => e.moduleName))].filter(
+            (moduleName) =>
+                !attached.some(
+                    (e) =>
+                        e.moduleName === moduleName &&
+                        !removing.has(String(e.id))
+                )
+        );
+        if (emptied.length > 0) {
+            const error = new Error(
+                `Removing these entities would leave no entity for module(s): ${emptied.join(
+                    ', '
+                )}`
+            );
+            error.code = 'LAST_ENTITY_OF_MODULE';
+            throw error;
+        }
+
+        const updated =
+            await this.integrationRepository.removeEntitiesFromIntegration(
+                integrationId,
+                entityIds
+            );
+        if (!updated) throw integrationNotFound(integrationId);
+        return updated;
+    }
+}
+
+module.exports = { RemoveEntitiesFromIntegration };

package/integrations/utils/assert-entity-ids-input.js

@@ -0,0 +1,42 @@
+/**
+ * Throws INVALID_INTEGRATION_DATA unless an integration id and a non-empty
+ * list of entity ids are given.
+ * @param {string} integrationId
+ * @param {string[]} entityIds
+ */
+function assertEntityIdsInput(integrationId, entityIds) {
+    if (!integrationId || !Array.isArray(entityIds) || entityIds.length === 0) {
+        const error = new Error(
+            'integrationId and a non-empty entityIds array are required'
+        );
+        error.code = 'INVALID_INTEGRATION_DATA';
+        throw error;
+    }
+}
+
+function integrationNotFound(integrationId) {
+    const error = new Error(`Integration ${integrationId} not found`);
+    error.code = 'INTEGRATION_NOT_FOUND';
+    return error;
+}
+
+/**
+ * Loads an integration, mapping the repositories' "not found" error to
+ * INTEGRATION_NOT_FOUND. Any other failure (connection, invalid id) is
+ * rethrown unchanged.
+ * @param {Object} integrationRepository
+ * @param {string} integrationId
+ * @returns {Promise<Object>} The integration record.
+ */
+async function loadIntegration(integrationRepository, integrationId) {
+    try {
+        return await integrationRepository.findIntegrationById(integrationId);
+    } catch (error) {
+        if (/^Integration with id .* not found$/.test(error?.message)) {
+            throw integrationNotFound(integrationId);
+        }
+        throw error;
+    }
+}
+
+module.exports = { assertEntityIdsInput, integrationNotFound, loadIntegration };

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

package/jest-setup.js

@@ -1,2 +1,13 @@
-const {globalSetup} = require('@friggframework/test');
-module.exports = globalSetup;
+// Core's unit suites must not need a database, so this global setup only
+// sets the test environment. It deliberately does not start an in-memory
+// MongoDB (as @friggframework/test's globalSetup does): nothing in the default
+// suite talks to a live server, and a binary that failed to start used to stop
+// every core suite from running. Suites that need a real database are
+// `*.db.test.js` files, run by `npm run test:db` (see jest.db.config.js).
+const { overrideEnvironment } = require('@friggframework/test');
+
+module.exports = async function () {
+    if (!process.env.STAGE) {
+        overrideEnvironment({ STAGE: 'dev' });
+    }
+};

package/jest-teardown.js

@@ -1,2 +1,5 @@
-const {globalTeardown} = require('@friggframework/test');
-module.exports = globalTeardown;
+const { restoreEnvironment } = require('@friggframework/test');
+
+module.exports = async function () {
+    restoreEnvironment();
+};

package/jest.config.js

@@ -20,4 +20,8 @@ module.exports = {
     globalTeardown: './jest-teardown.js',
 
     setupFilesAfterEnv: ['./logs/jest-logger-setup.js'],
+
+    // `*.db.test.js` suites talk to a real MongoDB replica set / PostgreSQL
+    // and run separately via `npm run test:db` (jest.db.config.js).
+    testPathIgnorePatterns: ['/node_modules/', '\\.db\\.test\\.js$'],
 };

package/jest.db.config.js

@@ -0,0 +1,23 @@
+/*
+ * Database integration suites (`*.db.test.js`).
+ *
+ * These talk to real databases instead of mocking Prisma, so they are kept
+ * out of the default `npm test` run and executed with `npm run test:db`.
+ * They need generated Prisma clients (`npm run prisma:generate`) and:
+ *   - a MongoDB replica set (Prisma requires one for MongoDB writes):
+ *     FRIGG_TEST_MONGODB_URL, default
+ *     mongodb://localhost:27017/frigg?replicaSet=rs0
+ *   - PostgreSQL with the prisma-postgresql migrations applied:
+ *     FRIGG_TEST_POSTGRES_URL, default
+ *     postgresql://postgres:postgres@localhost:5432/frigg?schema=public
+ * The repository parity suites skip themselves unless their own URLs are
+ * set (INTEGRATION_ENTITIES_PARITY_* / QUERY_MAPPINGS_PARITY_*).
+ */
+const base = require('./jest.config');
+
+module.exports = {
+    ...base,
+    coverageThreshold: undefined,
+    testMatch: ['**/*.db.test.js'],
+    testPathIgnorePatterns: ['/node_modules/'],
+};

package/modules/index.js

@@ -4,15 +4,6 @@ const { OAuth2Requester } = require('./requester/oauth-2');
 const { Requester } = require('./requester/requester');
 const { ModuleConstants } = require('./ModuleConstants');
 const { ModuleFactory } = require('./module-factory');
-const {
-    getEntityTypeRegistry,
-    EntityRegistryError,
-} = require('./entity-type-registry');
-const {
-    resolveScope,
-    listBindingScopes,
-    OwnershipConfigError,
-} = require('./entity-scope');
 
 module.exports = {
     ApiKeyRequester,
@@ -21,9 +12,4 @@ module.exports = {
     Requester,
     ModuleConstants,
     ModuleFactory,
-    getEntityTypeRegistry,
-    EntityRegistryError,
-    resolveScope,
-    listBindingScopes,
-    OwnershipConfigError,
 };

package/modules/module-factory.js

@@ -45,18 +45,6 @@ class ModuleFactory {
             );
         }
 
-        // definition.env may be an async function (e.g. the db-credentials
-        // extension's bootstrap loads OAuth app credentials from the
-        // database); resolve it first. A static env keeps the plain
-        // constructor, exactly as before.
-        if (typeof moduleDefinition.env === 'function') {
-            return await Module.create({
-                userId,
-                entity,
-                definition: moduleDefinition,
-            });
-        }
-
         return new Module({
             userId,
             entity,

package/modules/module.js

@@ -21,17 +21,8 @@ class Module extends Delegate {
      * @param {string} params.userId The user id
      * @param {Object} params.entity The entity record from the database
      * @param {string} [params.state] Optional OAuth state value forwarded to the API client (round-trips through the OAuth provider).
-     * @param {Object} [params.resolvedEnv] definition.env as Module.create() resolved it (may be undefined).
-     * @param {boolean} [params.envResolved=false] true when resolvedEnv carries the resolved env, even an undefined one; otherwise the static definition.env is used.
      */
-    constructor({
-        definition,
-        userId = null,
-        entity: entityObj = null,
-        state = null,
-        resolvedEnv,
-        envResolved = false,
-    }) {
+    constructor({ definition, userId = null, entity: entityObj = null, state = null }) {
         super({ definition, userId, entity: entityObj });
 
         this.validateDefinition(definition);
@@ -63,23 +54,8 @@ class Module extends Delegate {
 
         Object.assign(this, this.definition.requiredAuthMethods);
 
-        // A pre-resolved env (Module.create()) supports definition.env as an
-        // async function, e.g. OAuth app credentials loaded from the database
-        // by the db-credentials extension; otherwise the static object.
-        // "Resolved" is an explicit flag, not a non-null value: a function env
-        // may legitimately resolve to undefined (no static env, no DB row),
-        // and falling back to definition.env would then read the function.
-        const envValues = envResolved ? resolvedEnv : this.definition.env;
-        if (typeof envValues === 'function') {
-            // Spreading a function yields no keys, so the API client would
-            // silently get no client_id / client_secret.
-            throw new TypeError(
-                `Module ${this.name}: definition.env is a function; build the module with await Module.create(...)`
-            );
-        }
-
         const apiParams = {
-            ...envValues,
+            ...this.definition.env,
             delegate: this,
             logger: this.logger,
             ...(state ? { state } : {}),
@@ -91,33 +67,6 @@ class Module extends Delegate {
         this.api = new this.apiClass(apiParams);
     }
 
-    /**
-     * Resolves definition.env, supporting both a static object and a
-     * (possibly async) function.
-     *
-     * @param {Object} definition - Module definition
-     * @returns {Promise<Object|undefined>} Resolved env values
-     */
-    static async resolveEnv(definition) {
-        if (typeof definition.env === 'function') {
-            return await definition.env();
-        }
-        return definition.env;
-    }
-
-    /**
-     * Async factory that resolves definition.env first, so a module whose
-     * env is a function gets its values. Prefer it over `new Module(...)`
-     * wherever the call site can await.
-     *
-     * @param {Object} params - same as the constructor, minus resolvedEnv
-     * @returns {Promise<Module>}
-     */
-    static async create({ definition, userId = null, entity = null, state = null }) {
-        const resolvedEnv = await Module.resolveEnv(definition);
-        return new Module({ definition, userId, entity, state, resolvedEnv, envResolved: true });
-    }
-
     getName() {
         return this.name;
     }