@friggframework/core 2.0.0--canary.405.b81908d.0 → 2.0.0--canary.397.c07f148.0

package/handlers/routers/health.test.js

@@ -1,203 +0,0 @@
-process.env.HEALTH_API_KEY = 'test-api-key';
-
-jest.mock('mongoose', () => ({
-    set: jest.fn(),
-    connection: {
-        readyState: 1,
-        db: {
-            admin: () => ({
-                ping: jest.fn().mockResolvedValue(true)
-            })
-        }
-    }
-}));
-
-jest.mock('./../backend-utils', () => ({
-    moduleFactory: {
-        moduleTypes: ['test-module', 'another-module']
-    },
-    integrationFactory: {
-        integrationTypes: ['test-integration', 'another-integration']
-    }
-}));
-
-jest.mock('./../app-handler-helpers', () => ({
-    createAppHandler: jest.fn((name, router) => ({ name, router }))
-}));
-
-const { router } = require('./health');
-const mongoose = require('mongoose');
-
-const mockRequest = (path, headers = {}) => ({
-    path,
-    headers
-});
-
-const mockResponse = () => {
-    const res = {};
-    res.status = jest.fn().mockReturnValue(res);
-    res.json = jest.fn().mockReturnValue(res);
-    return res;
-};
-
-describe('Health Check Endpoints', () => {
-    beforeEach(() => {
-        mongoose.connection.readyState = 1;
-    });
-
-    describe('Middleware - validateApiKey', () => {
-        it('should allow access to /health without authentication', async () => {
-            expect(true).toBe(true);
-        });
-    });
-
-    describe('GET /health', () => {
-        it('should return basic health status', async () => {
-            const req = mockRequest('/health');
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                status: 'ok',
-                timestamp: expect.any(String),
-                service: 'frigg-core-api'
-            });
-        });
-    });
-
-    describe('GET /health/detailed', () => {
-        it('should return detailed health status when healthy', async () => {
-            const req = mockRequest('/health/detailed', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const originalPromiseAll = Promise.all;
-            Promise.all = jest.fn().mockResolvedValue([
-                { name: 'github', status: 'healthy', reachable: true, statusCode: 200, responseTime: 100 },
-                { name: 'npm', status: 'healthy', reachable: true, statusCode: 200, responseTime: 150 }
-            ]);
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/detailed'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-            
-            Promise.all = originalPromiseAll;
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                status: 'healthy',
-                service: 'frigg-core-api',
-                timestamp: expect.any(String),
-                checks: expect.objectContaining({
-                    database: expect.objectContaining({
-                        status: 'healthy',
-                        state: 'connected'
-                    }),
-                    integrations: expect.objectContaining({
-                        status: 'healthy'
-                    })
-                }),
-                responseTime: expect.any(Number)
-            }));
-
-            const response = res.json.mock.calls[0][0];
-            expect(response).not.toHaveProperty('version');
-            expect(response).not.toHaveProperty('uptime');
-            expect(response.checks).not.toHaveProperty('memory');
-            expect(response.checks.database).not.toHaveProperty('type');
-        });
-
-        it('should return 503 when database is disconnected', async () => {
-            mongoose.connection.readyState = 0;
-
-            const req = mockRequest('/health/detailed', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const originalPromiseAll = Promise.all;
-            Promise.all = jest.fn().mockResolvedValue([
-                { name: 'github', status: 'healthy', reachable: true, statusCode: 200, responseTime: 100 },
-                { name: 'npm', status: 'healthy', reachable: true, statusCode: 200, responseTime: 150 }
-            ]);
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/detailed'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-            
-            Promise.all = originalPromiseAll;
-
-            expect(res.status).toHaveBeenCalledWith(503);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                status: 'unhealthy'
-            }));
-        });
-    });
-
-    describe('GET /health/live', () => {
-        it('should return alive status', async () => {
-            const req = mockRequest('/health/live', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/live'
-            ).route.stack[0].handle;
-
-            routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                status: 'alive',
-                timestamp: expect.any(String)
-            });
-        });
-    });
-
-    describe('GET /health/ready', () => {
-        it('should return ready when all checks pass', async () => {
-            const req = mockRequest('/health/ready', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/ready'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(200);
-            expect(res.json).toHaveBeenCalledWith({
-                ready: true,
-                timestamp: expect.any(String),
-                checks: {
-                    database: true,
-                    modules: true
-                }
-            });
-        });
-
-        it('should return 503 when database is not connected', async () => {
-            mongoose.connection.readyState = 0;
-
-            const req = mockRequest('/health/ready', { 'x-api-key': 'test-api-key' });
-            const res = mockResponse();
-
-            const routeHandler = router.stack.find(layer => 
-                layer.route && layer.route.path === '/health/ready'
-            ).route.stack[0].handle;
-
-            await routeHandler(req, res);
-
-            expect(res.status).toHaveBeenCalledWith(503);
-            expect(res.json).toHaveBeenCalledWith(expect.objectContaining({
-                ready: false
-            }));
-        });
-    });
-});

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 }

package/integrations/integration-factory.js

@@ -1,251 +0,0 @@
-const { ModuleFactory, Credential, Entity } = require('../module-plugin');
-const { IntegrationModel } = require('./integration-model');
-const _ = require('lodash');
-
-class IntegrationFactory {
-    constructor(integrationClasses = []) {
-        this.integrationClasses = integrationClasses;
-        this.moduleFactory = new ModuleFactory(...this.getModules());
-        this.integrationTypes = this.integrationClasses.map(
-            (IntegrationClass) => IntegrationClass.getName()
-        );
-        this.getIntegrationDefinitions = this.integrationClasses.map(
-            (IntegrationClass) => IntegrationClass.Definition
-        );
-    }
-
-    async getIntegrationOptions() {
-        const options = this.integrationClasses.map(
-            (IntegrationClass) => IntegrationClass
-        );
-        return {
-            entities: {
-                options: options.map((IntegrationClass) =>
-                    IntegrationClass.getOptionDetails()
-                ),
-                authorized: [],
-            },
-            integrations: [],
-        };
-    }
-
-    getModules() {
-        return [
-            ...new Set(
-                this.integrationClasses
-                    .map((integration) =>
-                        Object.values(integration.Definition.modules).map(
-                            (module) => module.definition
-                        )
-                    )
-                    .flat()
-            ),
-        ];
-    }
-
-    getIntegrationClassByType(type) {
-        const integrationClassIndex = this.integrationTypes.indexOf(type);
-        return this.integrationClasses[integrationClassIndex];
-    }
-    getModuleTypesAndKeys(integrationClass) {
-        const moduleTypesAndKeys = {};
-        const moduleTypeCount = {};
-
-        if (integrationClass && integrationClass.Definition.modules) {
-            for (const [key, moduleClass] of Object.entries(
-                integrationClass.Definition.modules
-            )) {
-                if (
-                    moduleClass &&
-                    typeof moduleClass.definition.getName === 'function'
-                ) {
-                    const moduleType = moduleClass.definition.getName();
-
-                    // Check if this module type has already been seen
-                    if (moduleType in moduleTypesAndKeys) {
-                        throw new Error(
-                            `Duplicate module type "${moduleType}" found in integration class definition.`
-                        );
-                    }
-
-                    // Well how baout now
-
-                    moduleTypesAndKeys[moduleType] = key;
-                    moduleTypeCount[moduleType] =
-                        (moduleTypeCount[moduleType] || 0) + 1;
-                }
-            }
-        }
-
-        // Check for any module types with count > 1
-        for (const [moduleType, count] of Object.entries(moduleTypeCount)) {
-            if (count > 1) {
-                throw new Error(
-                    `Multiple instances of module type "${moduleType}" found in integration class definition.`
-                );
-            }
-        }
-
-        return moduleTypesAndKeys;
-    }
-
-    async getInstanceFromIntegrationId(params) {
-        const integrationRecord = await IntegrationHelper.getIntegrationById(
-            params.integrationId
-        );
-        let { userId } = params;
-        if (!integrationRecord) {
-            throw new Error(
-                `No integration found by the ID of ${params.integrationId}`
-            );
-        }
-
-        if (!userId) {
-            userId = integrationRecord.user._id.toString();
-        } else if (userId.toString() !== integrationRecord.user.toString()) {
-            throw new Error(
-                `Integration ${
-                    params.integrationId
-                } does not belong to User ${userId}, ${integrationRecord.user.toString()}`
-            );
-        }
-
-        const integrationClass = this.getIntegrationClassByType(
-            integrationRecord.config.type
-        );
-
-        const instance = new integrationClass({
-            userId,
-            integrationId: params.integrationId,
-        });
-
-        if (
-            integrationRecord.entityReference &&
-            Object.keys(integrationRecord.entityReference) > 0
-        ) {
-            // Use the specified entityReference to find the modules and load them according to their key
-            // entityReference will be a map of entityIds with their corresponding desired key
-            for (const [entityId, key] of Object.entries(
-                integrationRecord.entityReference
-            )) {
-                const moduleInstance =
-                    await this.moduleFactory.getModuleInstanceFromEntityId(
-                        entityId,
-                        integrationRecord.user
-                    );
-                instance[key] = moduleInstance;
-            }
-        } else {
-            // for each entity, get the moduleinstance and load them according to their keys
-            // If it's the first entity, load the moduleinstance into primary as well
-            // If it's the second entity, load the moduleinstance into target as well
-            const moduleTypesAndKeys =
-                this.getModuleTypesAndKeys(integrationClass);
-            for (let i = 0; i < integrationRecord.entities.length; i++) {
-                const entityId = integrationRecord.entities[i];
-                const moduleInstance =
-                    await this.moduleFactory.getModuleInstanceFromEntityId(
-                        entityId,
-                        integrationRecord.user
-                    );
-                const moduleType = moduleInstance.getName();
-                const key = moduleTypesAndKeys[moduleType];
-                instance[key] = moduleInstance;
-                if (i === 0) {
-                    instance.primary = moduleInstance;
-                } else if (i === 1) {
-                    instance.target = moduleInstance;
-                }
-            }
-        }
-        instance.record = integrationRecord;
-
-        try {
-            const additionalUserActions =
-                await instance.loadDynamicUserActions();
-            instance.events = { ...instance.events, ...additionalUserActions };
-        } catch (e) {
-            instance.record.status = 'ERROR';
-            instance.record.messages.errors.push(e);
-            await instance.record.save();
-        }
-        // Register all of the event handlers
-
-        await instance.registerEventHandlers();
-        return instance;
-    }
-
-    async createIntegration(entities, userId, config) {
-        const integrationRecord = await IntegrationModel.create({
-            entities: entities,
-            user: userId,
-            config,
-            version: '0.0.0',
-        });
-        return await this.getInstanceFromIntegrationId({
-            integrationId: integrationRecord.id,
-            userId,
-        });
-    }
-}
-
-const IntegrationHelper = {
-    getFormattedIntegration: async function (integrationRecord) {
-        const integrationObj = {
-            id: integrationRecord.id,
-            status: integrationRecord.status,
-            config: integrationRecord.config,
-            entities: [],
-            version: integrationRecord.version,
-            messages: integrationRecord.messages,
-        };
-        for (const entityId of integrationRecord.entities) {
-            // Only return non-internal fields. Leverages "select" and "options" to non-excepted fields and a pure object.
-            const entity = await Entity.findById(
-                entityId,
-                '-createdAt -updatedAt -user -credentials -credential -_id -__t -__v',
-                { lean: true }
-            );
-            integrationObj.entities.push({
-                id: entityId,
-                ...entity,
-            });
-        }
-        return integrationObj;
-    },
-
-    getIntegrationsForUserId: async function (userId) {
-        const integrationList = await IntegrationModel.find({ user: userId });
-        return await Promise.all(
-            integrationList.map(
-                async (integrationRecord) =>
-                    await IntegrationHelper.getFormattedIntegration(
-                        integrationRecord
-                    )
-            )
-        );
-    },
-
-    deleteIntegrationForUserById: async function (userId, integrationId) {
-        const integrationList = await IntegrationModel.find({
-            user: userId,
-            _id: integrationId,
-        });
-        if (integrationList.length !== 1) {
-            throw new Error(
-                `Integration with id of ${integrationId} does not exist for this user`
-            );
-        }
-        await IntegrationModel.deleteOne({ _id: integrationId });
-    },
-
-    getIntegrationById: async function (id) {
-        return IntegrationModel.findById(id).populate('entities');
-    },
-
-    listCredentials: async function (options) {
-        return Credential.find(options);
-    },
-};
-
-module.exports = { IntegrationFactory, IntegrationHelper };

package/integrations/integration-user.js

@@ -1,144 +0,0 @@
-const bcrypt = require('bcryptjs');
-const crypto = require('crypto');
-const { get } = require('../assertions');
-const { Token } = require('../database/models/Token');
-const { IndividualUser } = require('../database/models/IndividualUser');
-const { OrganizationUser } = require('../database/models/OrganizationUser');
-const Boom = require('@hapi/boom');
-
-class User {
-    static IndividualUser = IndividualUser;
-    static OrganizationUser = OrganizationUser;
-    static Token = Token;
-    static usePassword = false
-    static primary = User.IndividualUser;
-    static individualUserRequired = true;
-    static organizationUserRequired = false;
-
-    constructor() {
-        this.user = null;
-        this.individualUser = null;
-        this.organizationUser = null;
-    }
-
-    getPrimaryUser() {
-        if (User.primary === User.OrganizationUser) {
-            return this.organizationUser;
-        }
-        return this.individualUser;
-    }
-
-    getUserId() {
-        return this.getPrimaryUser()?.id;
-    }
-
-    isLoggedIn() {
-        return Boolean(this.getUserId());
-    }
-
-    async createUserToken(minutes) {
-        const rawToken = crypto.randomBytes(20).toString('hex');
-        const createdToken = await User.Token.createTokenWithExpire(this.getUserId(), rawToken, 120);
-        const tokenBuf = User.Token.createBase64BufferToken(createdToken, rawToken);
-        return tokenBuf;
-    }
-
-    static async newUser(params={}) {
-        const user = new User();
-        const token = get(params, 'token', null);
-        if (token) {
-            const jsonToken = this.Token.getJSONTokenFromBase64BufferToken(token);
-            const sessionToken = await this.Token.validateAndGetTokenFromJSONToken(jsonToken);
-            if (this.primary === User.OrganizationUser) {
-                user.organizationUser = await this.OrganizationUser.findById(sessionToken.user);
-            } else {
-                user.individualUser = await this.IndividualUser.findById(sessionToken.user);
-            }
-        }
-        return user;
-    }
-
-    static async createIndividualUser(params) {
-        const user = await this.newUser(params);
-        let hashword;
-        if (this.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);
-
-        user.individualUser = await this.IndividualUser.create({
-            email,
-            username,
-            hashword,
-            appUserId,
-            organizationUser: organizationUserId,
-        });
-        return user;
-    }
-
-    static async createOrganizationUser(params) {
-        const user = await this.newUser(params);
-        const name = get(params, 'name');
-        const appOrgId = get(params, 'appOrgId');
-        user.organizationUser = await this.OrganizationUser.create({
-            name,
-            appOrgId,
-        });
-        return user;
-    }
-
-    static async loginUser(params) {
-        const user = await this.newUser(params);
-
-        if (this.usePassword){
-            const username = get(params, 'username');
-            const password = get(params, 'password');
-
-            const individualUser = await this.IndividualUser.findOne({username});
-
-            if (!individualUser) {
-                throw Boom.unauthorized('incorrect username or password');
-            }
-
-            const isValid = await bcrypt.compareSync(password, individualUser.hashword);
-            if (!isValid) {
-                throw Boom.unauthorized('incorrect username or password');
-            }
-            user.individualUser = individualUser;
-        }
-        else {
-            const appUserId = get(params, 'appUserId', null);
-            user.individualUser = await this.IndividualUser.getUserByAppUserId(
-                appUserId
-            );
-        }
-
-        const appOrgId = get(params, 'appOrgId', null);
-        user.organizationUser = await this.OrganizationUser.getUserByAppOrgId(
-            appOrgId
-        );
-
-        if (this.individualUserRequired) {
-            if (!user.individualUser) {
-                throw Boom.unauthorized('user not found');
-            }
-        }
-
-        if (this.organizationUserRequired) {
-            if (!user.organizationUser) {
-                throw Boom.unauthorized(`org user ${appOrgId} not found`);
-            }
-        }
-        return user;
-    }
-}
-
-module.exports = User;