@friggframework/core 2.0.0--canary.398.53eac55.0 → 2.0.0--canary.397.878fefa.0

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

@@ -0,0 +1,58 @@
+const { Module } = require('../module');
+
+class RefreshEntityOptions {
+    /**
+     * @param {Object} params
+     * @param {import('../module-repository').ModuleRepository} params.moduleRepository
+     * @param {} params.moduleDefinitions
+     */
+    constructor({ moduleRepository, moduleDefinitions }) {
+        this.moduleRepository = moduleRepository;
+        this.moduleDefinitions = moduleDefinitions;
+    }
+
+    /**
+     * Retrieve a Module instance for a given user and entity/module type.
+     * @param {string} userId
+     * @param {string} entityId
+     */
+    async execute(entityId, userId, options) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.userId !== userId) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.type;
+        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,54 @@
+const { Module } = require('../module');
+
+class TestModuleAuth {
+    /**
+ * @param {Object} params - Configuration parameters.
+ * @param {import('./module-repository').ModuleRepository} 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;
+    }
+
+    async execute(entityId, userId) {
+        const entity = await this.moduleRepository.findEntityById(
+            entityId,
+            userId
+        );
+
+        if (!entity) {
+            throw new Error(`Entity ${entityId} not found`);
+        }
+
+        if (entity.userId !== userId) {
+            throw new Error(
+                `Entity ${entityId} does not belong to user ${userId}`
+            );
+        }
+
+        const entityType = entity.type;
+        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,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.398.53eac55.0",
+  "version": "2.0.0--canary.397.878fefa.0",
   "dependencies": {
     "@hapi/boom": "^10.0.1",
     "aws-sdk": "^2.1200.0",
@@ -22,9 +22,9 @@
     "uuid": "^9.0.1"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0--canary.398.53eac55.0",
-    "@friggframework/prettier-config": "2.0.0--canary.398.53eac55.0",
-    "@friggframework/test": "2.0.0--canary.398.53eac55.0",
+    "@friggframework/eslint-config": "2.0.0--canary.397.878fefa.0",
+    "@friggframework/prettier-config": "2.0.0--canary.397.878fefa.0",
+    "@friggframework/test": "2.0.0--canary.397.878fefa.0",
     "@types/lodash": "4.17.15",
     "@typescript-eslint/eslint-plugin": "^8.0.0",
     "chai": "^4.3.6",
@@ -53,5 +53,5 @@
   },
   "homepage": "https://github.com/friggframework/frigg#readme",
   "description": "",
-  "gitHead": "53eac553535657eaeb3110634f14870418fbbeda"
+  "gitHead": "878fefa87b447613ea7ec353ee5b0f4e06559f57"
 }

package/syncs/sync.js

@@ -1,5 +1,4 @@
 const md5 = require("md5");
-const ModuleManager = require('../module-plugin');
 const { debug } = require("packages/logs");
 const { get } = require("packages/assertions");
 

package/types/integrations/index.d.ts

@@ -1,7 +1,6 @@
 declare module "@friggframework/integrations" {
   import { Delegate, IFriggDelegate } from "@friggframework/core";
   import { Model } from "mongoose";
-  import { EntityManager } from "@friggframework/module-plugin";
 
   export class Integration extends Model {
     entities: any[];
@@ -19,8 +18,7 @@ declare module "@friggframework/integrations" {
 
   export class IntegrationManager
     extends Delegate
-    implements IFriggIntegrationManager
-  {
+    implements IFriggIntegrationManager {
     integration: Integration;
     primaryInstance: any;
     targetInstance: any;
@@ -56,7 +54,6 @@ declare module "@friggframework/integrations" {
       entities: { id: string; user: any },
       userId: string,
       config: any,
-      EntityManager: EntityManager
     ): Promise<any>;
 
     static getFormattedIntegration(
@@ -116,8 +113,7 @@ declare module "@friggframework/integrations" {
   }
 
   export class IntegrationConfigManager
-    implements IFriggIntegrationConfigManager
-  {
+    implements IFriggIntegrationConfigManager {
     options: IntegrationOptions[];
     primary: any;
 

package/types/module-plugin/index.d.ts

@@ -9,21 +9,7 @@ declare module "@friggframework/module-plugin" {
     externalId: string;
   }
 
-  export class EntityManager implements IFriggEntityManager {
-    static primaryEntityClass: any;
-    static entityManagerClasses: any[];
-    static entityTypes: string[];
-    static getEntitiesForUser(userId: string): Promise<any[]>;
-    static checkIsValidType(entityType: string): boolean;
-    static getEntityManagerClass(entityType?: string): any;
-
-    static getEntityManagerInstanceFromEntityId(
-      entityId: string,
-      userId: string
-    ): Promise<any>;
-  }
-
-  interface IFriggEntityManager {}
+  interface IFriggEntityManager { }
 
   export class Entity extends Model {
     credentialId: string;
@@ -34,42 +20,7 @@ declare module "@friggframework/module-plugin" {
   }
 
   export type MappedEntity = Entity & { id: string; type: any };
-  export class ModuleManager extends Delegate implements IFriggModuleManager {
-    static Entity: Entity;
-    static Credential: Credential;
-
-    constructor(params: { userId: string });
 
-    static getName(): any;
-    static getInstance(params: any): Promise<any>;
-    static getEntitiesForUserId(userId: string): Promise<MappedEntity[]>;
-
-    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    findOrCreateEntity(params: any): Promise<any>;
-    getAllSyncObjects(SyncClass: any): Promise<any>;
-    getAuthorizationRequirements(params: any): Promise<any>;
-    getEntityId(): Promise<string>;
-    getEntityOptions(): Promise<any>;
-    markCredentialsInvalid(): Promise<Credential>;
-    processAuthorizationCallback(params: any): Promise<any>;
-    testAuth(params: any): Promise<any>;
-    validateAuthorizationRequirements(): Promise<boolean>;
-  }
-
-  interface IFriggModuleManager extends IFriggDelegate {
-    getEntityId(): Promise<string>;
-    validateAuthorizationRequirements(): Promise<boolean>;
-    getAuthorizationRequirements(params: any): Promise<any>;
-    testAuth(params: any): Promise<any>;
-    processAuthorizationCallback(params: any): Promise<any>;
-    getEntityOptions(): Promise<any>;
-    findOrCreateEntity(params: any): Promise<any>;
-    getAllSyncObjects(SyncClass: any): Promise<any>;
-    batchCreateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    batchUpdateSyncObjects(syncObjects: any, syncManager: any): Promise<any>;
-    markCredentialsInvalid(): Promise<Credential>;
-  }
 
   export class Requester implements IFriggRequester {
     DLGT_INVALID_AUTH: string;
@@ -138,8 +89,7 @@ declare module "@friggframework/module-plugin" {
 
   export class ApiKeyRequester
     extends Requester
-    implements IFriggApiKeyRequester
-  {
+    implements IFriggApiKeyRequester {
     API_KEY_NAME: string;
     API_KEY_VALUE: any;
 
@@ -160,8 +110,7 @@ declare module "@friggframework/module-plugin" {
 
   export class BasicAuthRequester
     extends Requester
-    implements IFriggBasicAuthRequester
-  {
+    implements IFriggBasicAuthRequester {
     password: string;
     username: string;
 
@@ -189,8 +138,7 @@ declare module "@friggframework/module-plugin" {
 
   export class OAuth2Requester
     extends Requester
-    implements IFriggOAuth2Requester
-  {
+    implements IFriggOAuth2Requester {
     DLGT_TOKEN_DEAUTHORIZED: string;
     DLGT_TOKEN_UPDATE: string;
     accessTokenExpire: any;

package/types/syncs/index.d.ts

@@ -28,7 +28,6 @@ declare module "@friggframework/syncs/manager" {
     confirmCreate(
       syncObj: Sync,
       createdId: string,
-      moduleManager: any
     ): Promise<any>;
     confirmUpdate(syncObj: Sync): Promise<any>;
     createSyncDBObject(objArr: any[], entities: any[]): Promise<any>;
@@ -50,7 +49,6 @@ declare module "@friggframework/syncs/manager" {
     confirmCreate(
       syncObj: Sync,
       createdId: string,
-      moduleManager: any
     ): Promise<any>;
     confirmUpdate(syncObj: Sync): Promise<any>;
   }

package/user/tests/doubles/test-user-repository.js

@@ -0,0 +1,72 @@
+const Boom = require('@hapi/boom');
+const { User } = require('../../user');
+
+class TestUserRepository {
+    constructor({ userConfig }) {
+        this.individualUsers = new Map();
+        this.organizationUsers = new Map();
+        this.tokens = new Map();
+        this.userConfig = userConfig;
+    }
+
+    async getSessionToken(token) {
+        return this.tokens.get(token);
+    }
+
+    async findOrganizationUserById(userId) {
+        return this.organizationUsers.get(userId);
+    }
+
+    async findIndividualUserById(userId) {
+        return this.individualUsers.get(userId);
+    }
+
+    async createToken(userId, rawToken, minutes = 120) {
+        const token = `token-for-${userId}-for-${minutes}-mins`;
+        this.tokens.set(token, { user: userId, rawToken });
+        return token;
+    }
+
+    async createIndividualUser(params) {
+        const individualUserData = { id: `individual-${Date.now()}`, ...params };
+        this.individualUsers.set(individualUserData.id, individualUserData);
+        return individualUserData;
+    }
+
+    async createOrganizationUser(params) {
+        const orgUserData = { ...params, id: `org-${Date.now()}` };
+        this.organizationUsers.set(orgUserData.id, orgUserData);
+        return orgUserData;
+    }
+
+    async findIndividualUserByUsername(username) {
+        for (const userDoc of this.individualUsers.values()) {
+            if (userDoc.username === username) {
+                return userDoc;
+            }
+        }
+        return null;
+    }
+
+    async findIndividualUserByAppUserId(appUserId) {
+        if (!appUserId) return null;
+        for (const userDoc of this.individualUsers.values()) {
+            if (userDoc.appUserId === appUserId) {
+                return userDoc;
+            }
+        }
+        return null;
+    }
+
+    async findOrganizationUserByAppOrgId(appOrgId) {
+        if (!appOrgId) return null;
+        for (const userDoc of this.organizationUsers.values()) {
+            if (userDoc.appOrgId === appOrgId) {
+                return userDoc;
+            }
+        }
+        return null;
+    }
+}
+
+module.exports = { TestUserRepository }; 

package/user/tests/use-cases/create-individual-user.test.js

@@ -0,0 +1,24 @@
+const {
+    CreateIndividualUser,
+} = require('../../use-cases/create-individual-user');
+const { TestUserRepository } = require('../doubles/test-user-repository');
+
+describe('CreateIndividualUser Use Case', () => {
+    it('should create and return an individual user via the repository', async () => {
+        const userConfig = { usePassword: true };
+        const userRepository = new TestUserRepository({ userConfig });
+        const createIndividualUser = new CreateIndividualUser({
+            userRepository,
+            userConfig,
+        });
+
+        const params = {
+            username: 'test-user',
+            password: 'password123',
+        };
+        const user = await createIndividualUser.execute(params);
+
+        expect(user).toBeDefined();
+        expect(user.getIndividualUser().username).toBe(params.username);
+    });
+});

package/user/tests/use-cases/create-organization-user.test.js

@@ -0,0 +1,28 @@
+const {
+    CreateOrganizationUser,
+} = require('../../use-cases/create-organization-user');
+const { TestUserRepository } = require('../doubles/test-user-repository');
+
+describe('CreateOrganizationUser Use Case', () => {
+    it('should create and return an organization user via the repository', async () => {
+        const userConfig = {
+            primary: 'organization',
+            organizationUserRequired: true,
+            individualUserRequired: false,
+        };
+        const userRepository = new TestUserRepository({ userConfig });
+        const createOrganizationUser = new CreateOrganizationUser({
+            userRepository,
+            userConfig,
+        });
+
+        const params = {
+            name: 'Test Org',
+            appOrgId: 'org-123',
+        };
+        const user = await createOrganizationUser.execute(params);
+
+        expect(user).toBeDefined();
+        expect(user.getOrganizationUser().name).toBe(params.name);
+    });
+}); 

package/user/tests/use-cases/create-token-for-user-id.test.js

@@ -0,0 +1,19 @@
+const {
+    CreateTokenForUserId,
+} = require('../../use-cases/create-token-for-user-id');
+const { TestUserRepository } = require('../doubles/test-user-repository');
+
+describe('CreateTokenForUserId Use Case', () => {
+    it('should create and return a token via the repository', async () => {
+        const userConfig = {}; // Not used by this use case, but required by the test repo
+        const userRepository = new TestUserRepository({ userConfig });
+        const createTokenForUserId = new CreateTokenForUserId({ userRepository });
+
+        const userId = 'user-123';
+        const token = await createTokenForUserId.execute(userId);
+
+        expect(token).toBeDefined();
+        // The mock token is deterministic, so we can check it
+        expect(token).toContain(`token-for-${userId}`);
+    });
+}); 

package/user/tests/use-cases/get-user-from-bearer-token.test.js

@@ -0,0 +1,64 @@
+const {
+    GetUserFromBearerToken,
+} = require('../../use-cases/get-user-from-bearer-token');
+const { TestUserRepository } = require('../doubles/test-user-repository');
+
+describe('GetUserFromBearerToken Use Case', () => {
+    let userRepository;
+    let getUserFromBearerToken;
+    let userConfig;
+
+    beforeEach(() => {
+        userConfig = {
+            usePassword: true,
+            primary: 'individual',
+            individualUserRequired: true,
+            organizationUserRequired: false,
+        };
+        userRepository = new TestUserRepository({ userConfig });
+        getUserFromBearerToken = new GetUserFromBearerToken({
+            userRepository,
+            userConfig
+        });
+    });
+
+    it('should retrieve a user for a valid bearer token', async () => {
+        const userId = 'user-123';
+        const token = await userRepository.createToken(userId);
+        const createdUserData = await userRepository.createIndividualUser({
+            id: userId,
+        });
+
+        const user = await getUserFromBearerToken.execute(`Bearer ${token}`);
+
+        expect(user).toBeDefined();
+        expect(user.getId()).toBe(createdUserData.id);
+    });
+
+    it('should throw an unauthorized error if the bearer token is missing', async () => {
+        await expect(getUserFromBearerToken.execute(null)).rejects.toThrow(
+            'Missing Authorization Header'
+        );
+    });
+
+    it('should throw an unauthorized error for an invalid token format', async () => {
+        await expect(
+            getUserFromBearerToken.execute('InvalidToken')
+        ).rejects.toThrow('Invalid Token Format');
+    });
+
+    it('should throw an unauthorized error if the Session Token is not found', async () => {
+        userRepository.getSessionToken = jest.fn().mockResolvedValue(null);
+        await expect(
+            getUserFromBearerToken.execute('Bearer invalid-token')
+        ).rejects.toThrow('Session Token Not Found');
+    });
+
+    it('should throw an unauthorized error if the token is valid but finds no user', async () => {
+        userRepository.getSessionToken = jest.fn().mockResolvedValue(null);
+        const token = await userRepository.createToken('user-dne');
+        await expect(
+            getUserFromBearerToken.execute(`Bearer ${token}`)
+        ).rejects.toThrow('Session Token Not Found');
+    });
+}); 

package/user/tests/use-cases/login-user.test.js

@@ -0,0 +1,140 @@
+const bcrypt = require('bcryptjs');
+const { LoginUser } = require('../../use-cases/login-user');
+const { TestUserRepository } = require('../doubles/test-user-repository');
+
+jest.mock('bcryptjs', () => ({
+    compareSync: jest.fn(),
+}));
+
+describe('LoginUser Use Case', () => {
+    let userRepository;
+    let loginUser;
+    let userConfig;
+
+    beforeEach(() => {
+        userConfig = { usePassword: true, individualUserRequired: true, organizationUserRequired: false };
+        userRepository = new TestUserRepository({ userConfig });
+        loginUser = new LoginUser({ userRepository, userConfig });
+
+        bcrypt.compareSync.mockClear();
+    });
+
+    describe('With Password Authentication', () => {
+        it('should successfully log in a user with correct credentials', async () => {
+            const username = 'test-user';
+            const password = 'password123';
+            await userRepository.createIndividualUser({
+                username,
+                hashword: 'hashed-password',
+            });
+
+            bcrypt.compareSync.mockReturnValue(true);
+
+            const user = await loginUser.execute({ username, password });
+
+            expect(bcrypt.compareSync).toHaveBeenCalledWith(
+                password,
+                'hashed-password'
+            );
+            expect(user).toBeDefined();
+            expect(user.getIndividualUser().username).toBe(username);
+        });
+
+        it('should throw an unauthorized error for an incorrect password', async () => {
+            const username = 'test-user';
+            const password = 'wrong-password';
+            await userRepository.createIndividualUser({
+                username,
+                hashword: 'hashed-password',
+            });
+
+            bcrypt.compareSync.mockReturnValue(false);
+
+            await expect(
+                loginUser.execute({ username, password })
+            ).rejects.toThrow('Incorrect username or password');
+        });
+
+        it('should throw an unauthorized error for a non-existent user', async () => {
+            const username = 'non-existent-user';
+            const password = 'password123';
+
+            await expect(
+                loginUser.execute({ username, password })
+            ).rejects.toThrow('user not found');
+        });
+    });
+
+    describe('Without Password (appUserId)', () => {
+        beforeEach(() => {
+            userConfig = { usePassword: false, individualUserRequired: true, organizationUserRequired: false };
+            userRepository = new TestUserRepository({ userConfig });
+            loginUser = new LoginUser({
+                userRepository,
+                userConfig,
+            });
+        });
+
+        it('should successfully retrieve a user by appUserId', async () => {
+            const appUserId = 'app-user-123';
+            const createdUserData = await userRepository.createIndividualUser({
+                appUserId,
+            });
+
+            const result = await loginUser.execute({ appUserId });
+            expect(result.getId()).toBe(createdUserData.id);
+        });
+    });
+
+    describe('With Organization User', () => {
+        beforeEach(() => {
+            userConfig = {
+                primary: 'organization',
+                individualUserRequired: false,
+                organizationUserRequired: true,
+            };
+            userRepository = new TestUserRepository({ userConfig });
+            loginUser = new LoginUser({
+                userRepository,
+                userConfig,
+            });
+        });
+
+        it('should successfully retrieve an organization user by appOrgId', async () => {
+            const appOrgId = 'app-org-123';
+            const createdUserData = await userRepository.createOrganizationUser({
+                name: 'Test Org',
+                appOrgId,
+            });
+
+            const result = await loginUser.execute({ appOrgId });
+            expect(result.getId()).toBe(createdUserData.id);
+        });
+
+        it('should throw an unauthorized error for a non-existent organization user', async () => {
+            const appOrgId = 'non-existent-org';
+
+            await expect(loginUser.execute({ appOrgId })).rejects.toThrow(
+                'org user non-existent-org not found'
+            );
+        });
+    });
+
+    describe('Required User Checks', () => {
+        it('should throw an error if a required individual user is not found', async () => {
+            userConfig = {
+                individualUserRequired: true,
+                usePassword: false,
+            };
+            userRepository = new TestUserRepository({ userConfig });
+            loginUser = new LoginUser({
+                userRepository,
+                userConfig,
+            });
+
+            await expect(
+                loginUser.execute({ appUserId: 'a-non-existent-user-id' })
+            ).rejects.toThrow('user not found');
+        });
+    });
+});