@friggframework/core 2.0.0-next.8 → 2.0.0-next.80

package/modules/use-cases/get-module-instance-from-type.js

@@ -0,0 +1,31 @@
+const { Module } = require('../module');
+
+class GetModuleInstanceFromType {
+    /**
+     * @param {Object} params
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleDefinitions }) {
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Retrieve a Module instance for a given user and entity/module type.
+     * @param {string} userId
+     * @param {string} type – human-readable module/entity type (e.g. "Hubspot")
+     */
+    async execute(userId, type) {
+        const moduleDefinition = this.moduleDefinitions.find(
+            (def) => def.getName() === type
+        );
+        if (!moduleDefinition) {
+            throw new Error(`Module definition not found for type: ${type}`);
+        }
+        return new Module({
+            userId,
+            definition: moduleDefinition,
+        });
+    }
+}
+
+module.exports = { GetModuleInstanceFromType };

package/modules/use-cases/get-module.js

@@ -0,0 +1,74 @@
+const { Module } = require('../module');
+
+class GetModule {
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Get module instance for an entity
+     *
+     * @param {string|number} entityId - Entity ID to retrieve
+     * @param {string|number|import('../../user/user').User} userIdOrUser - User ID or User object for validation
+     * @returns {Promise<Object>} Module details
+     */
+    async execute(entityId, userIdOrUser) {
+        // Support both userId (backward compatible) and User object (new pattern)
+        const userId = typeof userIdOrUser === 'object' && userIdOrUser?.getId
+            ? userIdOrUser.getId()
+            : userIdOrUser;
+
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        // Validate entity ownership
+        // If User object provided, use ownsUserId to check linked users
+        // Otherwise fall back to simple equality check
+        const isOwned = typeof userIdOrUser === 'object' && userIdOrUser?.ownsUserId
+            ? userIdOrUser.ownsUserId(entity.userId)
+            : entity.userId?.toString() === userId?.toString();
+
+        if (!isOwned) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.moduleName;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName = Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        // todo: this properties should be methods in the Module class
+        return {
+            id: module.entity.id,
+            name: module.entity.name,
+            moduleName: module.entity.moduleName,
+            credential: module.credential,
+            externalId: module.entity.externalId,
+            userId: module.entity.user.toString(),
+        }
+    }
+}
+
+module.exports = { GetModule };

package/modules/use-cases/process-authorization-callback.js

@@ -0,0 +1,177 @@
+const { Module } = require('../module');
+const { ModuleConstants } = require('../ModuleConstants');
+
+// Statuses considered "broken" for an integration whose credentials have just
+// been successfully re-authorized. Both ERROR (system-driven auth failure) and
+// DISABLED (user paused the integration) are flipped back to ENABLED when the
+// user completes a new authorization flow.
+const STATUSES_RESET_ON_REAUTH = ['ERROR', 'DISABLED'];
+
+class ProcessAuthorizationCallback {
+    /**
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/module-repository-factory').ModuleRepositoryInterface} params.moduleRepository - Repository for module data operations.
+     * @param {import('../../credential/repositories/credential-repository-factory').CredentialRepositoryInterface} params.credentialRepository - Repository for credential data operations.
+     * @param {Array<Object>} params.moduleDefinitions - Array of module definitions.
+     * @param {import('../../integrations/repositories/integration-repository-interface').IntegrationRepositoryInterface} [params.integrationRepository] - Repository for integration data operations. When provided, integrations in a broken state linked to the re-authorized entity are restored to ENABLED.
+     */
+    constructor({
+        moduleRepository,
+        credentialRepository,
+        moduleDefinitions,
+        integrationRepository,
+    }) {
+        this.moduleRepository = moduleRepository;
+        this.credentialRepository = credentialRepository;
+        this.moduleDefinitions = moduleDefinitions;
+        this.integrationRepository = integrationRepository;
+    }
+
+    async execute(userId, entityType, params) {
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            return entityType === def.moduleName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        // todo: check if we need to pass entity to Module, right now it's null
+        let entity = null;
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        let tokenResponse;
+        if (module.apiClass.requesterType === ModuleConstants.authType.oauth2) {
+            tokenResponse = await moduleDefinition.requiredAuthMethods.getToken(
+                module.api,
+                params
+            );
+        } else {
+            tokenResponse =
+                await moduleDefinition.requiredAuthMethods.setAuthParams(
+                    module.api,
+                    params
+                );
+            await this.onTokenUpdate(module, moduleDefinition, userId);
+        }
+
+        const authRes = await module.testAuth();
+        if (!authRes) {
+            throw new Error('Authorization failed');
+        }
+
+        const entityDetails =
+            await moduleDefinition.requiredAuthMethods.getEntityDetails(
+                module.api,
+                params,
+                tokenResponse,
+                userId
+            );
+
+        Object.assign(
+            entityDetails.details,
+            module.apiParamsFromEntity(module.api)
+        );
+
+        const persistedEntity = await this.findOrCreateEntity(
+            entityDetails,
+            entityType,
+            module.credential.id
+        );
+
+        // Best-effort: a hiccup here must not fail a successful re-auth whose
+        // credential + entity are already persisted. Operators can recover
+        // stuck integrations manually.
+        try {
+            await this.restoreIntegrationsForEntity(persistedEntity.id);
+        } catch (err) {
+            console.error(
+                `[Frigg] Failed to restore integrations for entity ${persistedEntity.id} after successful re-auth — manual intervention may be needed`,
+                err
+            );
+        }
+
+        return {
+            credential_id: module.credential.id,
+            entity_id: persistedEntity.id,
+            type: module.getName(),
+        };
+    }
+
+    async restoreIntegrationsForEntity(entityId) {
+        if (!this.integrationRepository) return;
+        const integrations =
+            await this.integrationRepository.findIntegrationsByEntityId(
+                entityId
+            );
+        for (const integration of integrations) {
+            if (STATUSES_RESET_ON_REAUTH.includes(integration.status)) {
+                console.log(
+                    `[Frigg] Restoring integration ${integration.id} from ${integration.status} to ENABLED after successful re-auth (entityId=${entityId})`
+                );
+                await this.integrationRepository.updateIntegrationStatus(
+                    integration.id,
+                    'ENABLED'
+                );
+            }
+        }
+    }
+
+    async onTokenUpdate(module, moduleDefinition, userId) {
+        const credentialDetails =
+            await moduleDefinition.requiredAuthMethods.getCredentialDetails(
+                module.api,
+                userId
+            );
+
+        Object.assign(
+            credentialDetails.details,
+            module.apiParamsFromCredential(module.api)
+        );
+        credentialDetails.details.authIsValid = true;
+
+        const persisted = await this.credentialRepository.upsertCredential(credentialDetails);
+        module.credential = persisted;
+    }
+
+    async findOrCreateEntity(entityDetails, moduleName, credentialId) {
+        const { identifiers, details } = entityDetails;
+
+        // Support both 'user' and 'userId' field names from module definitions
+        // Some modules use 'user' (legacy), others use 'userId' (newer pattern)
+        const userId = identifiers.user || identifiers.userId;
+
+        if (!userId) {
+            throw new Error(
+                `Module definition for ${moduleName} must return 'user' or 'userId' in identifiers from getEntityDetails(). ` +
+                    `Without userId, entity lookup would match across all users (security issue).`
+            );
+        }
+
+        const existingEntity = await this.moduleRepository.findEntity({
+            externalId: identifiers.externalId,
+            user: userId,
+            moduleName: moduleName,
+        });
+
+        if (existingEntity) {
+            return existingEntity;
+        }
+
+        return await this.moduleRepository.createEntity({
+            ...identifiers,
+            ...details,
+            moduleName: moduleName,
+            credential: credentialId,
+        });
+    }
+}
+
+module.exports = { ProcessAuthorizationCallback };

package/modules/use-cases/refresh-entity-options.js

@@ -0,0 +1,72 @@
+const { Module } = require('../module');
+
+class RefreshEntityOptions {
+    /**
+     * @param {Object} params
+     * @param {import('../repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Refresh entity options for a given entity
+     *
+     * @param {string|number} entityId - Entity ID to refresh
+     * @param {string|number|import('../../user/user').User} userIdOrUser - User ID or User object for validation
+     * @param {Object} options - Refresh options
+     * @returns {Promise<Object>} Updated entity options
+     */
+    async execute(entityId, userIdOrUser, options) {
+        // Support both userId (backward compatible) and User object (new pattern)
+        const userId = typeof userIdOrUser === 'object' && userIdOrUser?.getId
+            ? userIdOrUser.getId()
+            : userIdOrUser;
+
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        // Validate entity ownership
+        const isOwned = typeof userIdOrUser === 'object' && userIdOrUser?.ownsUserId
+            ? userIdOrUser.ownsUserId(entity.userId)
+            : entity.userId?.toString() === userId?.toString();
+
+        if (!isOwned) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.moduleName;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName =
+                Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        await module.refreshEntityOptions(options);
+        return module.getEntityOptions();
+    }
+}
+
+module.exports = { RefreshEntityOptions };

package/modules/use-cases/test-module-auth.js

@@ -0,0 +1,72 @@
+const { Module } = require('../module');
+
+class TestModuleAuth {
+    /**
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../repositories/module-repository-interface').ModuleRepositoryInterface} params.moduleRepository - Repository for module data operations.
+     * @param {Array<Object>} params.moduleDefinitions - Array of module definitions.
+     */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Test authentication for a module entity
+     *
+     * @param {string|number} entityId - Entity ID to test
+     * @param {string|number|import('../../user/user').User} userIdOrUser - User ID or User object for validation
+     * @returns {Promise<boolean>} Authentication test result
+     */
+    async execute(entityId, userIdOrUser) {
+        // Support both userId (backward compatible) and User object (new pattern)
+        const userId = typeof userIdOrUser === 'object' && userIdOrUser?.getId
+            ? userIdOrUser.getId()
+            : userIdOrUser;
+
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        // Validate entity ownership
+        const isOwned = typeof userIdOrUser === 'object' && userIdOrUser?.ownsUserId
+            ? userIdOrUser.ownsUserId(entity.userId)
+            : entity.userId?.toString() === userId?.toString();
+
+        if (!isOwned) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.moduleName;
+        const moduleDefinition = this.moduleDefinitions.find((def) => {
+            const modelName =
+                Module.getEntityModelFromDefinition(def).modelName;
+            return entityType === modelName;
+        });
+
+        if (!moduleDefinition) {
+            throw new Error(
+                `Module definition not found for entity type: ${entityType}`
+            );
+        }
+
+        const module = new Module({
+            userId,
+            entity,
+            definition: moduleDefinition,
+        });
+
+        const testAuthResponse = await module.testAuth();
+
+        return testAuthResponse;
+    }
+}
+
+module.exports = { TestModuleAuth };

package/modules/utils/map-module-dto.js

@@ -0,0 +1,18 @@
+/**
+ * @param {import('../module').Module} moduleInstance
+ * Convert a Module domain instance to a plain DTO suitable for JSON responses.
+ */
+function mapModuleClassToModuleDTO(moduleInstance) {
+    if (!moduleInstance) return null;
+
+    return {
+        id: moduleInstance.entity.id,
+        name: moduleInstance.name,
+        userId: moduleInstance.userId,
+        entity: moduleInstance.entity,
+        credentialId: moduleInstance.credential?._id?.toString(),
+        type: moduleInstance.getName()
+    };
+}
+
+module.exports = { mapModuleClassToModuleDTO }; 

package/package.json

@@ -1,52 +1,84 @@
 {
-  "name": "@friggframework/core",
-  "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.8",
-  "dependencies": {
-    "@hapi/boom": "^10.0.1",
-    "aws-sdk": "^2.1200.0",
-    "bcryptjs": "^2.4.3",
-    "common-tags": "^1.8.2",
-    "express": "^4.18.2",
-    "express-async-handler": "^1.2.0",
-    "lodash": "^4.17.21",
-    "lodash.get": "^4.4.2",
-    "mongoose": "6.11.6",
-    "node-fetch": "^2.6.7"
-  },
-  "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0-next.8",
-    "@friggframework/prettier-config": "2.0.0-next.8",
-    "@friggframework/test": "2.0.0-next.8",
-    "@types/lodash": "^4.14.191",
-    "@typescript-eslint/eslint-plugin": "^8.0.0",
-    "chai": "^4.3.6",
-    "eslint": "^8.22.0",
-    "eslint-plugin-import": "^2.29.1",
-    "eslint-plugin-n": "^17.10.2",
-    "eslint-plugin-promise": "^7.0.0",
-    "jest": "^29.7.0",
-    "jest-runner-groups": "^2.2.0",
-    "mongodb-memory-server": "^8.9.0",
-    "prettier": "^2.8.5",
-    "sinon": "^16.1.1",
-    "typescript": "^5.0.2"
-  },
-  "scripts": {
-    "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
-    "test": "jest --passWithNoTests # TODO"
-  },
-  "author": "",
-  "license": "MIT",
-  "main": "index.js",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/friggframework/frigg.git"
-  },
-  "bugs": {
-    "url": "https://github.com/friggframework/frigg/issues"
-  },
-  "homepage": "https://github.com/friggframework/frigg#readme",
-  "description": "",
-  "gitHead": "60b7a6f92954ad165186861a35fba66e40f60a42"
+    "name": "@friggframework/core",
+    "prettier": "@friggframework/prettier-config",
+    "version": "2.0.0-next.80",
+    "dependencies": {
+        "@aws-sdk/client-apigatewaymanagementapi": "^3.588.0",
+        "@aws-sdk/client-kms": "^3.588.0",
+        "@aws-sdk/client-lambda": "^3.714.0",
+        "@aws-sdk/client-sqs": "^3.588.0",
+        "@hapi/boom": "^10.0.1",
+        "bcryptjs": "^2.4.3",
+        "body-parser": "^1.20.2",
+        "bson": "^4.7.2",
+        "chalk": "^4.1.2",
+        "common-tags": "^1.8.2",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.7",
+        "express": "^4.19.2",
+        "express-async-handler": "^1.2.0",
+        "form-data": "^4.0.0",
+        "fs-extra": "^11.2.0",
+        "lodash": "4.17.21",
+        "lodash.get": "^4.4.2",
+        "node-fetch": "^2.6.7",
+        "serverless-http": "^2.7.0",
+        "uuid": "^9.0.1"
+    },
+    "peerDependencies": {
+        "@prisma/client": "^6.16.3",
+        "prisma": "^6.16.3"
+    },
+    "peerDependenciesMeta": {
+        "@prisma/client": {
+            "optional": true
+        },
+        "prisma": {
+            "optional": true
+        }
+    },
+    "devDependencies": {
+        "@friggframework/eslint-config": "2.0.0-next.80",
+        "@friggframework/prettier-config": "2.0.0-next.80",
+        "@friggframework/test": "2.0.0-next.80",
+        "@prisma/client": "^6.17.0",
+        "@types/lodash": "4.17.15",
+        "@typescript-eslint/eslint-plugin": "^8.0.0",
+        "chai": "^4.3.6",
+        "eslint": "^8.22.0",
+        "eslint-plugin-import": "^2.29.1",
+        "eslint-plugin-n": "^17.10.2",
+        "eslint-plugin-promise": "^7.0.0",
+        "jest": "^29.7.0",
+        "prettier": "^2.7.1",
+        "prisma": "^6.17.0",
+        "sinon": "^16.1.1",
+        "typescript": "^5.0.2"
+    },
+    "scripts": {
+        "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
+        "test": "jest --passWithNoTests # TODO",
+        "prisma:generate:mongo": "npx prisma generate --schema ./prisma-mongodb/schema.prisma",
+        "prisma:generate:postgres": "npx prisma generate --schema ./prisma-postgresql/schema.prisma",
+        "prisma:generate": "npm run prisma:generate:mongo && npm run prisma:generate:postgres",
+        "prisma:push:mongo": "npx prisma db push --schema ./prisma-mongodb/schema.prisma",
+        "prisma:migrate:postgres": "npx prisma migrate dev --schema ./prisma-postgresql/schema.prisma",
+        "prepublishOnly": "npm run prisma:generate"
+    },
+    "author": "",
+    "license": "MIT",
+    "main": "index.js",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/friggframework/frigg.git"
+    },
+    "bugs": {
+        "url": "https://github.com/friggframework/frigg/issues"
+    },
+    "homepage": "https://github.com/friggframework/frigg#readme",
+    "description": "",
+    "publishConfig": {
+        "access": "public"
+    },
+    "gitHead": "7a66dfcb02143941411ff26aaee866afc1473df8"
 }