@friggframework/devtools 2.0.0-next.7 → 2.0.0-next.71

package/infrastructure/routers/integration-defined-routers.js

@@ -1,42 +0,0 @@
-const { createAppHandler } = require('./../app-handler-helpers');
-const {
-    integrationFactory,
-    loadRouterFromObject,
-} = require('./../backend-utils');
-const { Router } = require('express');
-
-const handlers = {};
-for (const IntegrationClass of integrationFactory.integrationClasses) {
-    const router = Router();
-    const basePath = `/api/${IntegrationClass.Definition.name}-integration`;
-    
-    console.log(`\n│ Configuring routes for ${IntegrationClass.Definition.name} Integration:`);
-
-    for (const routeDef of IntegrationClass.Definition.routes) {
-        if (typeof routeDef === 'function') {
-            router.use(basePath, routeDef(IntegrationClass));
-            console.log(`│ ANY ${basePath}/* (function handler)`);
-        } else if (typeof routeDef === 'object') {
-            router.use(
-                basePath,
-                loadRouterFromObject(IntegrationClass, routeDef)
-            );
-            const method = (routeDef.method || 'ANY').toUpperCase();
-            const fullPath = `${basePath}${routeDef.path}`;
-            console.log(`│ ${method} ${fullPath}`);
-        } else if (routeDef instanceof express.Router) {
-            router.use(basePath, routeDef);
-            console.log(`│ ANY ${basePath}/* (express router)`);
-        }
-    }
-    console.log('│');
-
-    handlers[`${IntegrationClass.Definition.name}`] = {
-        handler: createAppHandler(
-            `HTTP Event: ${IntegrationClass.Definition.name}`,
-            router
-        ),
-    };
-}
-
-module.exports = { handlers };

package/infrastructure/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/infrastructure/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/infrastructure/routers/user.js

@@ -1,41 +0,0 @@
-const express = require('express');
-const { createAppHandler } = require('../app-handler-helpers');
-const { checkRequiredParams } = require('@friggframework/core');
-const { User } = require('../backend-utils');
-const catchAsyncError = require('express-async-handler');
-
-const router = express();
-
-// define the login endpoint
-router.route('/user/login').post(
-    catchAsyncError(async (req, res) => {
-        const { username, password } = checkRequiredParams(req.body, [
-            'username',
-            'password',
-        ]);
-        const user = await User.loginUser({ username, password });
-        const token = await user.createUserToken(120);
-        res.status(201);
-        res.json({ token });
-    })
-);
-
-router.route('/user/create').post(
-    catchAsyncError(async (req, res) => {
-        const { username, password } = checkRequiredParams(req.body, [
-            'username',
-            'password',
-        ]);
-        const user = await User.createIndividualUser({
-            username,
-            password,
-        });
-        const token = await user.createUserToken(120);
-        res.status(201);
-        res.json({ token });
-    })
-);
-
-const handler = createAppHandler('HTTP Event: User', router);
-
-module.exports = { handler, router };

package/infrastructure/routers/websocket.js

@@ -1,55 +0,0 @@
-const { createHandler } = require('@friggframework/core');
-const { WebsocketConnection } = require('@friggframework/core');
-
-const handleWebSocketConnection = async (event, context) => {
-    // Handle different WebSocket events
-    switch (event.requestContext.eventType) {
-        case 'CONNECT':
-            // Handle new connection
-            try {
-                const connectionId = event.requestContext.connectionId;
-                await WebsocketConnection.create({ connectionId });
-                console.log(`Stored new connection: ${connectionId}`);
-                return { statusCode: 200, body: 'Connected.' };
-            } catch (error) {
-                console.error('Error storing connection:', error);
-                return { statusCode: 500, body: 'Error connecting.' };
-            }
-
-        case 'DISCONNECT':
-            // Handle disconnection
-            try {
-                const connectionId = event.requestContext.connectionId;
-                await WebsocketConnection.deleteOne({ connectionId });
-                console.log(`Removed connection: ${connectionId}`);
-                return { statusCode: 200, body: 'Disconnected.' };
-            } catch (error) {
-                console.error('Error removing connection:', error);
-                return { statusCode: 500, body: 'Error disconnecting.' };
-            }
-
-        case 'MESSAGE':
-            // Handle incoming message
-            const message = JSON.parse(event.body);
-            console.log('Received message:', message);
-
-            // Process the message and send a response
-            const responseMessage = { message: 'Message received' };
-            return {
-                statusCode: 200,
-                body: JSON.stringify(responseMessage),
-            };
-
-        default:
-            return { statusCode: 400, body: 'Unhandled event type.' };
-    }
-};
-
-const handler = createHandler({
-    eventName: 'WebSocket Event',
-    method: handleWebSocketConnection,
-    shouldUseDatabase: true, // Set to true as we're using the database
-    isUserFacingResponse: true, // This is a server-to-server response
-});
-
-module.exports = { handler };

package/infrastructure/serverless-template.js

@@ -1,291 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-
-const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
-    const definition = {
-        frameworkVersion: '>=3.17.0',
-        service: AppDefinition.name || 'create-frigg-app',
-        package: {
-            individually: true,
-        },
-        useDotenv: true,
-        provider: {
-            name: AppDefinition.provider || 'aws',
-            runtime: 'nodejs20.x',
-            timeout: 30,
-            region: 'us-east-1',
-            stage: '${opt:stage}',
-            environment: {
-                STAGE: '${opt:stage}',
-                AWS_NODEJS_CONNECTION_REUSE_ENABLED: 1,
-            },
-            iamRoleStatements: [
-                {
-                    Effect: 'Allow',
-                    Action: ['sns:Publish'],
-                    Resource: {
-                        Ref: 'InternalErrorBridgeTopic',
-                    },
-                },
-            ],
-        },
-        plugins: [
-            'serverless-dotenv-plugin',
-            'serverless-offline-sqs',
-            'serverless-offline',
-            '@friggframework/serverless-plugin',
-        ],
-        custom: {
-            'serverless-offline': {
-                httpPort: 3001,
-                lambdaPort: 4001,
-                websocketPort: 3002,
-            },
-            'serverless-offline-sqs': {
-                autoCreate: false,
-                apiVersion: '2012-11-05',
-                endpoint: 'http://localhost:4566',
-                region: 'us-east-1',
-                accessKeyId: 'root',
-                secretAccessKey: 'root',
-                skipCacheInvalidation: false,
-            },
-            webpack: {
-                webpackConfig: 'webpack.config.js',
-                includeModules: {
-                    forceExclude: ['aws-sdk'],
-                },
-                packager: 'npm',
-                excludeFiles: ['src/**/*.test.js', 'test/'],
-            },
-        },
-        functions: {
-            defaultWebsocket: {
-                handler:
-                    '/../node_modules/@friggframework/devtools/infrastructure/routers/websocket.handler',
-                events: [
-                    {
-                        websocket: {
-                            route: '$connect',
-                        },
-                    },
-                    {
-                        websocket: {
-                            route: '$default',
-                        },
-                    },
-                    {
-                        websocket: {
-                            route: '$disconnect',
-                        },
-                    },
-                ],
-            },
-            auth: {
-                handler:
-                    '/../node_modules/@friggframework/devtools/infrastructure/routers/auth.handler',
-                events: [
-                    {
-                        http: {
-                            path: '/api/integrations',
-                            method: 'ANY',
-                            cors: true,
-                        },
-                    },
-                    {
-                        http: {
-                            path: '/api/integrations/{proxy+}',
-                            method: 'ANY',
-                            cors: true,
-                        },
-                    },
-                    {
-                        http: {
-                            path: '/api/authorize',
-                            method: 'ANY',
-                            cors: true,
-                        },
-                    },
-                ],
-            },
-            user: {
-                handler:
-                    '/../node_modules/@friggframework/devtools/infrastructure/routers/user.handler',
-                events: [
-                    {
-                        http: {
-                            path: '/user/{proxy+}',
-                            method: 'ANY',
-                            cors: true,
-                        },
-                    },
-                ],
-            },
-        },
-        resources: {
-            Resources: {
-                InternalErrorQueue: {
-                    Type: 'AWS::SQS::Queue',
-                    Properties: {
-                        QueueName:
-                            'internal-error-queue-${self:provider.stage}',
-                        MessageRetentionPeriod: 300,
-                    },
-                },
-                InternalErrorBridgeTopic: {
-                    Type: 'AWS::SNS::Topic',
-                    Properties: {
-                        Subscription: [
-                            {
-                                Protocol: 'sqs',
-                                Endpoint: {
-                                    'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
-                                },
-                            },
-                        ],
-                    },
-                },
-                InternalErrorBridgePolicy: {
-                    Type: 'AWS::SQS::QueuePolicy',
-                    Properties: {
-                        Queues: [{ Ref: 'InternalErrorQueue' }],
-                        PolicyDocument: {
-                            Version: '2012-10-17',
-                            Statement: [
-                                {
-                                    Sid: 'Allow Dead Letter SNS to publish to SQS',
-                                    Effect: 'Allow',
-                                    Principal: {
-                                        Service: 'sns.amazonaws.com',
-                                    },
-                                    Resource: {
-                                        'Fn::GetAtt': [
-                                            'InternalErrorQueue',
-                                            'Arn',
-                                        ],
-                                    },
-                                    Action: [
-                                        'SQS:SendMessage',
-                                        'SQS:SendMessageBatch',
-                                    ],
-                                    Condition: {
-                                        ArnEquals: {
-                                            'aws:SourceArn': {
-                                                Ref: 'InternalErrorBridgeTopic',
-                                            },
-                                        },
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                },
-                ApiGatewayAlarm5xx: {
-                    Type: 'AWS::CloudWatch::Alarm',
-                    Properties: {
-                        AlarmDescription: 'API Gateway 5xx Errors',
-                        Namespace: 'AWS/ApiGateway',
-                        MetricName: '5XXError',
-                        Statistic: 'Sum',
-                        Threshold: 0,
-                        ComparisonOperator: 'GreaterThanThreshold',
-                        EvaluationPeriods: 1,
-                        Period: 60,
-                        AlarmActions: [{ Ref: 'InternalErrorBridgeTopic' }],
-                        Dimensions: [
-                            {
-                                Name: 'ApiName',
-                                Value: {
-                                    'Fn::Join': [
-                                        '-',
-                                        [
-                                            '${self:provider.stage}',
-                                            '${self:service}',
-                                        ],
-                                    ],
-                                },
-                            },
-                        ],
-                    },
-                },
-            },
-        },
-    };
-
-    // Add integration-specific functions and resources
-    AppDefinition.integrations.forEach((integration) => {
-        const integrationName = integration.Definition.name;
-
-        // Add function for the integration
-        definition.functions[integrationName] = {
-            handler: `/../node_modules/@friggframework/devtools/infrastructure/routers/integration-defined-routers.handlers.${integrationName}.handler`,
-            // events: integration.Definition.routes.map((route) => ({
-            //     http: {
-            //         path: `/api/${integrationName}-integration${route.path}`,
-            //         method: route.method || 'ANY',
-            //         cors: true,
-            //     },
-            // })),
-            events: [
-                {
-                    http: {
-                        path: `/api/${integrationName}-integration/{proxy*}`,
-                        method: 'ANY',
-                        cors: true,
-                    },
-                },
-            ],
-        };
-
-        // Add SQS Queue for the integration
-        const queueReference = `${
-            integrationName.charAt(0).toUpperCase() + integrationName.slice(1)
-        }Queue`;
-        const queueName = `\${self:service}--\${self:provider.stage}-${queueReference}`;
-        definition.resources.Resources[queueReference] = {
-            Type: 'AWS::SQS::Queue',
-            Properties: {
-                QueueName: `\${self:custom.${queueReference}}`,
-                MessageRetentionPeriod: 60,
-                RedrivePolicy: {
-                    maxReceiveCount: 1,
-                    deadLetterTargetArn: {
-                        'Fn::GetAtt': ['InternalErrorQueue', 'Arn'],
-                    },
-                },
-            },
-        };
-
-        // Add Queue Worker for the integration
-        const queueWorkerName = `${integrationName}QueueWorker`;
-        definition.functions[queueWorkerName] = {
-            handler: `/../node_modules/@friggframework/devtools/infrastructure/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
-            reservedConcurrency: 5,
-            events: [
-                {
-                    sqs: {
-                        arn: {
-                            'Fn::GetAtt': [queueReference, 'Arn'],
-                        },
-                        batchSize: 1,
-                    },
-                },
-            ],
-            timeout: 600,
-        };
-
-        // Add Queue URL for the integration to the ENVironment variables
-        definition.provider.environment = {
-            ...definition.provider.environment,
-            [integrationName.toUpperCase() + '_QUEUE_URL']: {
-                Ref: queueReference,
-            },
-        };
-
-        definition.custom[queueReference] = queueName;
-    });
-
-    return definition;
-};
-
-module.exports = { composeServerlessDefinition };

package/infrastructure/workers/integration-defined-workers.js

@@ -1,24 +0,0 @@
-const { createHandler } = require('@friggframework/core');
-const { integrationFactory, createQueueWorker } = require('./../backend-utils');
-
-const handlers = {};
-integrationFactory.integrationClasses.forEach((IntegrationClass) => {
-    const defaultQueueWorker = createQueueWorker(IntegrationClass);
-
-    handlers[`${IntegrationClass.Definition.name}`] = {
-        queueWorker: createHandler({
-            eventName: `Queue Worker for ${IntegrationClass.Definition.name}`,
-            isUserFacingResponse: false,
-            method: async (event, context) => {
-                const worker = new defaultQueueWorker();
-                await worker.run(event, context);
-                return {
-                    message: 'Successfully processed the Generic Queue Worker',
-                    input: event,
-                };
-            },
-        }),
-    };
-});
-
-module.exports = { handlers };

package/test/auther-definition-tester.js

@@ -1,125 +0,0 @@
-const {
-    Auther,
-    ModuleConstants,
-    createObjectId,
-    connectToDatabase,
-    disconnectFromDatabase,
-} = require('@friggframework/core');
-const { createMockApiObject } = require("./mock-integration");
-
-
-function testAutherDefinition(definition, mocks) {
-    const getModule = async (params) => {
-        const module = await Auther.getInstance({
-            definition,
-            userId: createObjectId(),
-            ...params,
-        });
-        if (mocks.tokenResponse) {
-            mocks.getTokenFrom = async function(code) {
-                await this.setTokens(mocks.tokenResponse);
-                return mocks.tokenResponse
-            }
-            mocks.getTokenFromCode = mocks.getTokenFromCode || mocks.getTokenFrom
-            mocks.getTokenFromCodeBasicAuthHeader = mocks.getTokenFromCodeBasicAuthHeader || mocks.getTokenFrom
-            mocks.getTokenFromClientCredentials = mocks.getTokenFromClientCredentials || mocks.getTokenFrom
-            mocks.getTokenFromUsernamePassword = mocks.getTokenFromUsernamePassword || mocks.getTokenFrom
-        }
-        if (mocks.refreshResponse) {
-            mocks.refreshAccessToken = async function(code) {
-                await this.setTokens(mocks.refreshResponse);
-                return mocks.refreshResponse
-            }
-        }
-        module.api = createMockApiObject(jest, module.api, mocks);
-        return module
-    }
-
-
-    describe(`${definition.moduleName} Module Tests`, () => {
-        let module, authUrl;
-        beforeAll(async () => {
-            await connectToDatabase();
-            module = await getModule();
-        });
-
-        afterAll(async () => {
-            await disconnectFromDatabase();
-        });
-
-        let requirements, authCallbackParams;
-        if (definition.API.requesterType === ModuleConstants.authType.oauth2) {
-            authCallbackParams = mocks.authorizeResponse || mocks.authorizeParams;
-            describe('getAuthorizationRequirements() test', () => {
-                it('should return auth requirements', async () => {
-                    requirements = await module.getAuthorizationRequirements();
-                    expect(requirements).toBeDefined();
-                    expect(requirements.type).toEqual(ModuleConstants.authType.oauth2);
-                    expect(requirements.url).toBeDefined();
-                    authUrl = requirements.url;
-                });
-            });
-        } else if (definition.API.requesterType === ModuleConstants.authType.basic) {
-            // could also confirm authCallbackParams against the auth requirements
-            authCallbackParams = mocks.authorizeParams
-            describe('getAuthorizationRequirements() test', () => {
-                it('should return auth requirements', async () => {
-                    requirements = module.getAuthorizationRequirements();
-                    expect(requirements).toBeDefined();
-                    expect(requirements.type).toEqual(ModuleConstants.authType.basic);
-                });
-            });
-        } else if (definition.API.requesterType === ModuleConstants.authType.apiKey) {
-            // could also confirm authCallbackParams against the auth requirements
-            authCallbackParams = mocks.authorizeParams
-            describe('getAuthorizationRequirements() test', () => {
-                it('should return auth requirements', async () => {
-                    requirements = module.getAuthorizationRequirements();
-                    expect(requirements).toBeDefined();
-                    expect(requirements.type).toEqual(ModuleConstants.authType.apiKey);
-                });
-            });
-        }
-
-        describe('Authorization requests', () => {
-            let firstRes;
-            it('processAuthorizationCallback()', async () => {
-                firstRes = await module.processAuthorizationCallback(authCallbackParams);
-                expect(firstRes).toBeDefined();
-                expect(firstRes.entity_id).toBeDefined();
-                expect(firstRes.credential_id).toBeDefined();
-            });
-            it('retrieves existing entity on subsequent calls', async () => {
-                const res = await module.processAuthorizationCallback(authCallbackParams);
-                expect(res).toEqual(firstRes);
-            });
-        });
-
-        describe('Test credential retrieval and module instantiation', () => {
-            it('retrieve by entity id', async () => {
-                const newModule = await getModule({
-                    userId: module.userId,
-                    entityId: module.entity.id
-                });
-                expect(newModule).toBeDefined();
-                expect(newModule.entity).toBeDefined();
-                expect(newModule.credential).toBeDefined();
-                expect(await newModule.testAuth()).toBeTruthy();
-
-            });
-
-            it('retrieve by credential id', async () => {
-                const newModule = await getModule({
-                    userId: module.userId,
-                    credentialId: module.credential.id
-                });
-                expect(newModule).toBeDefined();
-                expect(newModule.credential).toBeDefined();
-                expect(await newModule.testAuth()).toBeTruthy();
-            });
-        });
-    });
-}
-
-module.exports = { testAutherDefinition }
-