@friggframework/core 2.0.0--canary.393.5a4db58.0 → 2.0.0--canary.395.d07514c.0

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, userConfig });
+
+        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 createdUser = await userRepository.createIndividualUser({
+            id: userId,
+        });
+
+        const user = await getUserFromBearerToken.execute(`Bearer ${token}`);
+
+        expect(user).toBeDefined();
+        expect(user.getId()).toBe(createdUser.getId());
+    });
+
+    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,148 @@
+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';
+            userRepository.findIndividualUserByUsername = jest
+                .fn()
+                .mockRejectedValue(new Error('user not found'));
+
+            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 createdUser = await userRepository.createIndividualUser({
+                appUserId,
+            });
+
+            const result = await loginUser.execute({ appUserId });
+            expect(result.getId()).toBe(createdUser.getId());
+        });
+    });
+
+    describe('With Organization User', () => {
+        beforeEach(() => {
+            userConfig = {
+                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 createdUser = await userRepository.createOrganizationUser({
+                name: 'Test Org',
+                appOrgId,
+            });
+
+            const result = await loginUser.execute({ appOrgId });
+            expect(result.getId()).toBe(createdUser.getId());
+        });
+
+        it('should throw an unauthorized error for a non-existent organization user', async () => {
+            const appOrgId = 'non-existent-org';
+            userRepository.findOrganizationUserByAppOrgId = jest
+                .fn()
+                .mockRejectedValue(new Error('user not found'));
+
+            await expect(loginUser.execute({ appOrgId })).rejects.toThrow(
+                'user 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 });
+            userRepository.findIndividualUserByAppUserId = jest
+                .fn()
+                .mockRejectedValue(new Error('user not found'));
+            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,52 @@
+const { get } = require('../../assertions');
+const Boom = require('@hapi/boom');
+
+/**
+ * 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 individualUser = await this.userRepository.createIndividualUser({
+            email,
+            username,
+            hashword,
+            appUserId,
+            organizationUser: organizationUserId,
+        });
+        return individualUser;
+    }
+}
+
+module.exports = { CreateIndividualUser };

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

@@ -0,0 +1,39 @@
+const { get } = require('../../assertions');
+
+// todo: this is not used anywhere, check if needed
+/**
+ * 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 organizationUser =
+            await this.userRepository.createOrganizationUser({
+                name,
+                appOrgId,
+            });
+        return organizationUser;
+    }
+}
+
+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,50 @@
+const Boom = require('@hapi/boom');
+
+/**
+ * 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') {
+            return this.userRepository.findOrganizationUserById(sessionToken.user);
+        }
+
+        return this.userRepository.findIndividualUserById(sessionToken.user);
+    }
+}
+
+module.exports = { GetUserFromBearerToken }; 

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

@@ -0,0 +1,88 @@
+const bcrypt = require('bcryptjs');
+const Boom = require('@hapi/boom');
+const {
+    RequiredPropertyError,
+} = require('../../errors');
+
+/**
+ * Use case for logging in a user.
+ * @class LoginUser
+ */
+class LoginUser {
+    /**
+     * Creates a new LoginUser 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} userCredentials - The user's credentials for authentication.
+     * @param {string} [userCredentials.username] - The username for authentication.
+     * @param {string} [userCredentials.password] - The password for authentication.
+     * @param {string} [userCredentials.appUserId] - The app user id for authentication if no username and password are provided.
+     * @param {string} [userCredentials.appOrgId] - The app organization id for authentication if no username and password are provided.
+     * @returns {Promise<import('../user').User>} The authenticated user object.
+     */
+    async execute(userCredentials) {
+        const { username, password, appUserId, appOrgId } = userCredentials;
+        if (this.userConfig.individualUserRequired) {
+            if (this.userConfig.usePassword) {
+                if (!username) {
+                    throw new RequiredPropertyError({
+                        parent: this,
+                        key: 'username',
+                    });
+                }
+                if (!password) {
+                    throw new RequiredPropertyError({
+                        parent: this,
+                        key: 'password',
+                    });
+                }
+
+                const individualUser =
+                    await this.userRepository.findIndividualUserByUsername(
+                        username
+                    );
+
+                if (!individualUser.isPasswordValid(password)) {
+                    throw Boom.unauthorized('Incorrect username or password');
+                }
+
+                return individualUser;
+            } else {
+                const individualUser =
+                    await this.userRepository.findIndividualUserByAppUserId(
+                        appUserId
+                    );
+
+                return individualUser;
+            }
+        }
+
+
+        if (this.userConfig.organizationUserRequired) {
+
+            const organizationUser =
+                await this.userRepository.findOrganizationUserByAppOrgId(appOrgId);
+
+            if (!organizationUser) {
+                throw Boom.unauthorized(`org user ${appOrgId} not found`);
+            }
+
+            return organizationUser;
+        }
+
+        // todo: check if organizationUserRequired and individualUserRequired can be used at the same time.
+        return null;
+    }
+}
+
+module.exports = { LoginUser }; 

package/user/user-repository.js

@@ -0,0 +1,97 @@
+const { Token } = require('../database/models/Token');
+const { IndividualUser } = require('../database/models/IndividualUser');
+const { OrganizationUser } = require('../database/models/OrganizationUser');
+const { User } = require('./user');
+
+
+//todo: the user class instantiation needs to happen in each use case and not here.
+class UserRepository {
+    /**
+     * @param {Object} userConfig - The user config in the app definition.
+     */
+    constructor({ userConfig }) {
+        this.IndividualUser = IndividualUser;
+        this.OrganizationUser = OrganizationUser;
+        this.Token = Token;
+        this.userConfig = userConfig;
+    }
+
+    async getSessionToken(token) {
+        const jsonToken =
+            this.Token.getJSONTokenFromBase64BufferToken(token);
+        const sessionToken =
+            await this.Token.validateAndGetTokenFromJSONToken(jsonToken);
+        return sessionToken;
+    }
+
+    async findOrganizationUserById(userId) {
+        const organizationUser = await this.OrganizationUser.findById(userId);
+
+        if (!organizationUser) {
+            throw Boom.unauthorized('Organization User Not Found');
+        }
+
+        return new User(null, organizationUser, this.userConfig.usePassword, this.userConfig.primary, this.userConfig.individualUserRequired, this.userConfig.organizationUserRequired);
+    }
+
+    async findIndividualUserById(userId) {
+        const individualUser = await this.IndividualUser.findById(userId);
+
+        if (!individualUser) {
+            throw Boom.unauthorized('Individual User Not Found');
+        }
+
+        return new User(individualUser, null, this.userConfig.usePassword, this.userConfig.primary, this.userConfig.individualUserRequired, this.userConfig.organizationUserRequired);
+    }
+
+    async createToken(userId, rawToken, minutes = 120) {
+        const createdToken = await this.Token.createTokenWithExpire(
+            userId,
+            rawToken,
+            minutes
+        );
+        return this.Token.createBase64BufferToken(createdToken, rawToken);
+    }
+
+    async createIndividualUser(params) {
+        const individualUser = await this.IndividualUser.create(params);
+        return new User(individualUser, null, this.userConfig.usePassword, this.userConfig.primary, this.userConfig.individualUserRequired, this.userConfig.organizationUserRequired);
+    }
+
+    async createOrganizationUser(params) {
+        const organizationUser = await this.OrganizationUser.create(params);
+        return new User(null, organizationUser, this.userConfig.usePassword, this.userConfig.primary, this.userConfig.individualUserRequired, this.userConfig.organizationUserRequired);
+    }
+
+    async findIndividualUserByUsername(username) {
+        const individualUser = await this.IndividualUser.findOne({ username });
+
+        if (!individualUser) {
+            throw Boom.unauthorized('user not found');
+        }
+
+        return new User(individualUser, null, this.userConfig.usePassword, this.userConfig.primary, this.userConfig.individualUserRequired, this.userConfig.organizationUserRequired);
+    }
+
+    async findIndividualUserByAppUserId(appUserId) {
+        const individualUser = await this.IndividualUser.getUserByAppUserId(appUserId);
+
+        if (!individualUser) {
+            throw Boom.unauthorized('user not found');
+        }
+
+        return new User(individualUser, null, this.userConfig.usePassword, this.userConfig.primary, this.userConfig.individualUserRequired, this.userConfig.organizationUserRequired);
+    }
+
+    async findOrganizationUserByAppOrgId(appOrgId) {
+        const organizationUser = await this.OrganizationUser.getUserByAppOrgId(appOrgId);
+
+        if (!organizationUser) {
+            throw Boom.unauthorized('user not found');
+        }
+
+        return new User(null, organizationUser, this.userConfig.usePassword, this.userConfig.primary, this.userConfig.individualUserRequired, this.userConfig.organizationUserRequired);
+    }
+}
+
+module.exports = { UserRepository };