@friggframework/core 2.0.0--canary.405.1f6792c.0 → 2.0.0--canary.396.6862738.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@friggframework/core",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0--canary.405.1f6792c.0",
+  "version": "2.0.0--canary.396.6862738.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.405.1f6792c.0",
-    "@friggframework/prettier-config": "2.0.0--canary.405.1f6792c.0",
-    "@friggframework/test": "2.0.0--canary.405.1f6792c.0",
+    "@friggframework/eslint-config": "2.0.0--canary.396.6862738.0",
+    "@friggframework/prettier-config": "2.0.0--canary.396.6862738.0",
+    "@friggframework/test": "2.0.0--canary.396.6862738.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": "1f6792ccfcbd08502e14072f07ccbebdf99394cb"
+  "gitHead": "6862738f1b370d1bb37353809b30586267e7deb0"
 }

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;
@@ -138,8 +124,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 +145,7 @@ declare module "@friggframework/module-plugin" {
 
   export class BasicAuthRequester
     extends Requester
-    implements IFriggBasicAuthRequester
-  {
+    implements IFriggBasicAuthRequester {
     password: string;
     username: string;
 
@@ -189,8 +173,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/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');
+        });
+    });
+}); 

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

@@ -0,0 +1,61 @@
+const { get } = require('../../assertions');
+const Boom = require('@hapi/boom');
+const { User } = require('../user');
+
+/**
+ * Use case for creating an individual user.
+ * @class CreateIndividualUser
+ */
+class CreateIndividualUser {
+    /**
+     * Creates a new CreateIndividualUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../user-repository').UserRepository} params.userRepository - Repository for user data operations.
+     * @param {Object} params.userConfig - The user properties inside of the app definition.
+     */
+    constructor({ userRepository, userConfig }) {
+        this.userRepository = userRepository;
+        this.userConfig = userConfig;
+    }
+
+    /**
+     * Executes the use case.
+     * @async
+     * @param {Object} params - The parameters for creating the user.
+     * @returns {Promise<import('../user').User>} The newly created user object.
+     */
+    async execute(params) {
+        let hashword;
+        if (this.userConfig.usePassword) {
+            hashword = get(params, 'password');
+        }
+
+        const email = get(params, 'email', null);
+        const username = get(params, 'username', null);
+        if (!email && !username) {
+            throw Boom.badRequest('email or username is required');
+        }
+
+        const appUserId = get(params, 'appUserId', null);
+        const organizationUserId = get(params, 'organizationUserId', null);
+
+        const individualUserData = await this.userRepository.createIndividualUser({
+            email,
+            username,
+            hashword,
+            appUserId,
+            organizationUser: organizationUserId,
+        });
+
+        return new User(
+            individualUserData,
+            null,
+            this.userConfig.usePassword,
+            this.userConfig.primary,
+            this.userConfig.individualUserRequired,
+            this.userConfig.organizationUserRequired
+        );
+    }
+}
+
+module.exports = { CreateIndividualUser };

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

@@ -0,0 +1,47 @@
+const { get } = require('../../assertions');
+const { User } = require('../user');
+
+/**
+ * Use case for creating an organization user.
+ * @class CreateOrganizationUser
+ */
+class CreateOrganizationUser {
+    /**
+     * Creates a new CreateOrganizationUser instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../user-repository').UserRepository} params.userRepository - Repository for user data operations.
+     * @param {Object} params.userConfig - The user properties inside of the app definition.
+     */
+    constructor({ userRepository, userConfig }) {
+        this.userRepository = userRepository;
+        this.userConfig = userConfig;
+    }
+
+    /**
+     * Executes the use case.
+     * @async
+     * @param {Object} params - The parameters for creating the user.
+     * @returns {Promise<import('../user').User>} The newly created user object.
+     */
+    async execute(params) {
+        const name = get(params, 'name');
+        const appOrgId = get(params, 'appOrgId');
+
+        const organizationUserData =
+            await this.userRepository.createOrganizationUser({
+                name,
+                appOrgId,
+            });
+
+        return new User(
+            null,
+            organizationUserData,
+            this.userConfig.usePassword,
+            this.userConfig.primary,
+            this.userConfig.individualUserRequired,
+            this.userConfig.organizationUserRequired
+        );
+    }
+}
+
+module.exports = { CreateOrganizationUser }; 

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

@@ -0,0 +1,30 @@
+const crypto = require('crypto');
+
+/**
+ * Use case for creating a token for a user ID.
+ * @class CreateTokenForUserId
+ */
+class CreateTokenForUserId {
+    /**
+     * Creates a new CreateTokenForUserId instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../user-repository').UserRepository} params.userRepository - Repository for user data operations.
+     */
+    constructor({ userRepository }) {
+        this.userRepository = userRepository;
+    }
+
+    /**
+     * Executes the use case.
+     * @async
+     * @param {string} userId - The ID of the user to create a token for.
+     * @param {number} minutes - The number of minutes until the token expires.
+     * @returns {Promise<string>} The user token.
+     */
+    async execute(userId, minutes) {
+        const rawToken = crypto.randomBytes(20).toString('hex');
+        return this.userRepository.createToken(userId, rawToken, minutes);
+    }
+}
+
+module.exports = { CreateTokenForUserId }; 

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

@@ -0,0 +1,77 @@
+const Boom = require('@hapi/boom');
+const { User } = require('../user');
+
+/**
+ * Use case for retrieving a user from a bearer token.
+ * @class GetUserFromBearerToken
+ */
+class GetUserFromBearerToken {
+    /**
+     * Creates a new GetUserFromBearerToken instance.
+     * @param {Object} params - Configuration parameters.
+     * @param {import('../user-repository').UserRepository} params.userRepository - Repository for user data operations.
+     * @param {Object} params.userConfig - The user config in the app definition.
+     */
+    constructor({ userRepository, userConfig }) {
+        this.userRepository = userRepository;
+        this.userConfig = userConfig;
+    }
+
+    /**
+     * Executes the use case.
+     * @async
+     * @param {string} bearerToken - The bearer token from the authorization header.
+     * @returns {Promise<import('../user').User>} The authenticated user object.
+     * @throws {Boom} 401 Unauthorized if the token is missing, malformed, or invalid.
+     */
+    async execute(bearerToken) {
+        if (!bearerToken) {
+            throw Boom.unauthorized('Missing Authorization Header');
+        }
+
+        const token = bearerToken.split(' ')[1]?.trim();
+        if (!token) {
+            throw Boom.unauthorized('Invalid Token Format');
+        }
+
+        const sessionToken = await this.userRepository.getSessionToken(token);
+
+        if (!sessionToken) {
+            throw Boom.unauthorized('Session Token Not Found');
+        }
+
+        if (this.userConfig.primary === 'organization') {
+            const organizationUserData = await this.userRepository.findOrganizationUserById(sessionToken.user);
+
+            if (!organizationUserData) {
+                throw Boom.unauthorized('Organization User Not Found');
+            }
+
+            return new User(
+                null,
+                organizationUserData,
+                this.userConfig.usePassword,
+                this.userConfig.primary,
+                this.userConfig.individualUserRequired,
+                this.userConfig.organizationUserRequired
+            );
+        }
+
+        const individualUserData = await this.userRepository.findIndividualUserById(sessionToken.user);
+
+        if (!individualUserData) {
+            throw Boom.unauthorized('Individual User Not Found');
+        }
+
+        return new User(
+            individualUserData,
+            null,
+            this.userConfig.usePassword,
+            this.userConfig.primary,
+            this.userConfig.individualUserRequired,
+            this.userConfig.organizationUserRequired
+        );
+    }
+}
+
+module.exports = { GetUserFromBearerToken };