@friggframework/core 2.0.0--canary.398.bdb6d27.0 → 2.0.0--canary.397.e634da9.0

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

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

@@ -0,0 +1,122 @@
+const Boom = require('@hapi/boom');
+const {
+    RequiredPropertyError,
+} = require('../../errors');
+const { User } = require('../user');
+
+/**
+ * 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 individualUserData =
+                    await this.userRepository.findIndividualUserByUsername(
+                        username
+                    );
+
+                if (!individualUserData) {
+                    throw Boom.unauthorized('user not found');
+                }
+
+                const individualUser = new User(
+                    individualUserData,
+                    null,
+                    this.userConfig.usePassword,
+                    this.userConfig.primary,
+                    this.userConfig.individualUserRequired,
+                    this.userConfig.organizationUserRequired
+                );
+
+                if (!individualUser.isPasswordValid(password)) {
+                    throw Boom.unauthorized('Incorrect username or password');
+                }
+
+                return individualUser;
+            } else {
+                const individualUserData =
+                    await this.userRepository.findIndividualUserByAppUserId(
+                        appUserId
+                    );
+
+                if (!individualUserData) {
+                    throw Boom.unauthorized('user not found');
+                }
+
+                const individualUser = new User(
+                    individualUserData,
+                    null,
+                    this.userConfig.usePassword,
+                    this.userConfig.primary,
+                    this.userConfig.individualUserRequired,
+                    this.userConfig.organizationUserRequired
+                );
+
+                return individualUser;
+            }
+        }
+
+
+        if (this.userConfig.organizationUserRequired) {
+
+            const organizationUserData =
+                await this.userRepository.findOrganizationUserByAppOrgId(appOrgId);
+
+            if (!organizationUserData) {
+                throw Boom.unauthorized(`org user ${appOrgId} not found`);
+            }
+
+            const organizationUser = new User(
+                null,
+                organizationUserData,
+                this.userConfig.usePassword,
+                this.userConfig.primary,
+                this.userConfig.individualUserRequired,
+                this.userConfig.organizationUserRequired
+            );
+
+            return organizationUser;
+        }
+
+        return null;
+    }
+}
+
+module.exports = { LoginUser }; 

package/user/user-repository.js

@@ -0,0 +1,62 @@
+const { Token } = require('../database/models/Token');
+const { IndividualUser } = require('../database/models/IndividualUser');
+const { OrganizationUser } = require('../database/models/OrganizationUser');
+
+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) {
+        return this.OrganizationUser.findById(userId);
+    }
+
+    async findIndividualUserById(userId) {
+        return this.IndividualUser.findById(userId);
+    }
+
+    async createToken(userId, rawToken, minutes = 120) {
+        const createdToken = await this.Token.createTokenWithExpire(
+            userId,
+            rawToken,
+            minutes
+        );
+        return this.Token.createBase64BufferToken(createdToken, rawToken);
+    }
+
+    async createIndividualUser(params) {
+        return this.IndividualUser.create(params);
+    }
+
+    async createOrganizationUser(params) {
+        return this.OrganizationUser.create(params);
+    }
+
+    async findIndividualUserByUsername(username) {
+        return this.IndividualUser.findOne({ username });
+    }
+
+    async findIndividualUserByAppUserId(appUserId) {
+        return this.IndividualUser.getUserByAppUserId(appUserId);
+    }
+
+    async findOrganizationUserByAppOrgId(appOrgId) {
+        return this.OrganizationUser.getUserByAppOrgId(appOrgId);
+    }
+}
+
+module.exports = { UserRepository }; 

package/user/user.js

@@ -0,0 +1,77 @@
+const bcrypt = require('bcryptjs');
+
+/**
+ * Represents a user in the system. The User class is a domain entity,
+ * @class User
+ */
+class User {
+    /**
+     * Creates a new User instance.
+     * @param {import('../database/models/IndividualUser').IndividualUser} [individualUser=null] - The individual user for the user.
+     * @param {import('../database/models/OrganizationUser').OrganizationUser} [organizationUser=null] - The organization user for the user.
+     * @param {boolean} [usePassword=false] - Whether the user has a password.
+     * @param {string} [primary='individual'] - The primary user type.
+     * @param {boolean} [individualUserRequired=true] - Whether the user is required to have an individual user.
+     * @param {boolean} [organizationUserRequired=false] - Whether the user is required to have an organization user.
+     */
+    constructor(individualUser = null, organizationUser = null, usePassword = false, primary = 'individual', individualUserRequired = true, organizationUserRequired = false) {
+        this.individualUser = individualUser;
+        this.organizationUser = organizationUser;
+        this.usePassword = usePassword;
+
+        this.config = {
+            primary,
+            individualUserRequired,
+            organizationUserRequired,
+        };
+    }
+
+    getPrimaryUser() {
+        if (this.config.primary === 'organization') {
+            return this.organizationUser;
+        }
+        return this.individualUser;
+    }
+
+    getId() {
+        return this.getPrimaryUser()?.id;
+    }
+
+    isPasswordRequired() {
+        return this.usePassword;
+    }
+
+    isPasswordValid(password) {
+        if (!this.isPasswordRequired()) {
+            return true;
+        }
+
+        return bcrypt.compareSync(password, this.getPrimaryUser().hashword);
+    }
+
+    setIndividualUser(individualUser) {
+        this.individualUser = individualUser;
+    }
+
+    setOrganizationUser(organizationUser) {
+        this.organizationUser = organizationUser;
+    }
+
+    isOrganizationUserRequired() {
+        return this.config.organizationUserRequired;
+    }
+
+    isIndividualUserRequired() {
+        return this.config.individualUserRequired;
+    }
+
+    getIndividualUser() {
+        return this.individualUser;
+    }
+
+    getOrganizationUser() {
+        return this.organizationUser;
+    }
+}
+
+module.exports = { User }; 

package/handlers/routers/middleware/loadUser.js

@@ -1,15 +0,0 @@
-const catchAsyncError = require('express-async-handler');
-const { User } = require('../../backend-utils');
-
-module.exports = catchAsyncError(async (req, res, next) => {
-    const authorizationHeader = req.headers.authorization;
-
-    if (authorizationHeader) {
-        // Removes "Bearer " and trims
-        const token = authorizationHeader.split(' ')[1].trim();
-        // Load user for later middleware/routes to use
-        req.user = await User.newUser({ token });
-    }
-
-    return next();
-});

package/handlers/routers/middleware/requireLoggedInUser.js

@@ -1,12 +0,0 @@
-const Boom = require('@hapi/boom');
-
-// CheckLoggedIn Middleware
-const requireLoggedInUser = (req, res, next) => {
-    if (!req.user || !req.user.isLoggedIn()) {
-        throw Boom.unauthorized('Invalid Token');
-    }
-
-    next();
-};
-
-module.exports = { requireLoggedInUser };

package/integrations/create-frigg-backend.js

@@ -1,31 +0,0 @@
-const {IntegrationFactory, IntegrationHelper} = require('./integration-factory');
-const User = require('./integration-user');
-
-function createFriggBackend(appDefinition) {
-    const {integrations = [], user=null} = appDefinition
-    const integrationFactory = new IntegrationFactory(integrations);
-    if (user) {
-        if (user.usePassword) {
-            User.usePassword = true;
-        }
-        if (user.primary === 'organization') {
-            User.primary = User.OrganizationUser
-        }
-        if (user.individualUserRequired !== undefined) {
-            User.individualUserRequired = user.individualUserRequired
-        }
-        if (user.organizationUserRequired !== undefined) {
-            User.organizationUserRequired = user.organizationUserRequired
-        }
-
-    }
-    const backend = {
-        integrationFactory,
-        moduleFactory: integrationFactory.moduleFactory,
-        IntegrationHelper,
-        User: User
-    }
-    return backend
-}
-
-module.exports = { createFriggBackend }