@friggframework/devtools 2.0.0-next.2 → 2.0.0-next.21

package/frigg-cli/build-command/index.js

@@ -0,0 +1,52 @@
+const { spawnSync } = require('child_process');
+const path = require('path');
+
+function buildCommand(options) {
+    console.log('Building the serverless application...');
+    console.log('Hello from npm link world')
+    const backendPath = path.resolve(process.cwd());
+    const infrastructurePath = 'infrastructure.js';
+    const command = 'serverless';
+    const serverlessArgs = [
+        'package',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    // Add support for --verbose option
+    if (options.verbose) {
+        serverlessArgs.push('--verbose');
+    }
+
+    console.log('Running command from ', backendPath);
+    console.log('Serverless Command:', command, serverlessArgs.join(' '));
+
+    const result = spawnSync(command, serverlessArgs, {
+        cwd: backendPath,
+        stdio: 'inherit',
+        shell: true,
+        env: {
+            ...process.env,
+            NODE_PATH: path.resolve(backendPath, 'node_modules'),
+        }
+    });
+
+    if (result.status !== 0) {
+        console.error(`Serverless build failed with code ${result.status}`);
+        process.exit(1);
+    }
+
+    // childProcess.on('error', (error) => {
+    //     console.error(`Error executing command: ${error.message}`);
+    // });
+
+    // childProcess.on('close', (code) => {
+    //     if (code !== 0) {
+    //         console.log(`Child process exited with code ${code}`);
+    //     }
+    // });
+}
+
+module.exports = { buildCommand };

package/frigg-cli/deploy-command/index.js

@@ -0,0 +1,33 @@
+const { spawn } = require('child_process');
+const path = require('path');
+
+function deployCommand(options) {
+    console.log('Deploying the serverless application...');
+    const backendPath = path.resolve(process.cwd());
+    const infrastructurePath = 'infrastructure.js';
+    const command = 'serverless';
+    const serverlessArgs = [
+        'deploy',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    const childProcess = spawn(command, serverlessArgs, {
+        cwd: backendPath,
+        stdio: 'inherit',
+    });
+
+    childProcess.on('error', (error) => {
+        console.error(`Error executing command: ${error.message}`);
+    });
+
+    childProcess.on('close', (code) => {
+        if (code !== 0) {
+            console.log(`Child process exited with code ${code}`);
+        }
+    });
+}
+
+module.exports = { deployCommand };

package/frigg-cli/index.js

@@ -3,6 +3,8 @@
 const { Command } = require('commander');
 const { installCommand } = require('./install-command');
 const { startCommand } = require('./start-command'); // Assuming you have a startCommand module
+const { buildCommand } = require('./build-command');
+const { deployCommand } = require('./deploy-command');
 
 const program = new Command();
 program
@@ -13,8 +15,24 @@ program
 program
     .command('start')
     .description('Run the backend and optional frontend')
+    .option('-s, --stage <stage>', 'deployment stage', 'dev')
+    .option('-v, --verbose', 'enable verbose output')
     .action(startCommand);
 
+program
+    .command('build')
+    .description('Build the serverless application')
+    .option('-s, --stage <stage>', 'deployment stage', 'dev')
+    .option('-v, --verbose', 'enable verbose output')
+    .action(buildCommand);
+
+program
+    .command('deploy')
+    .description('Deploy the serverless application')
+    .option('-s, --stage <stage>', 'deployment stage', 'dev')
+    .option('-v, --verbose', 'enable verbose output')
+    .action(deployCommand);
+
 program.parse(process.argv);
 
-module.exports = { installCommand, startCommand };
+module.exports = { installCommand, startCommand, buildCommand, deployCommand };

package/frigg-cli/index.test.js

@@ -1,10 +1,7 @@
 const { Command } = require('commander');
 const { installCommand } = require('./index');
 const { validatePackageExists } = require('./install-command/validate-package');
-const {
-    findNearestBackendPackageJson,
-    validateBackendPath,
-} = require('./utils/backend-path');
+const { findNearestBackendPackageJson, validateBackendPath } = require('@friggframework/core');
 const { installPackage } = require('./install-command/install-package');
 const { createIntegrationFile } = require('./install-command/integration-file');
 const { updateBackendJsFile } = require('./install-command/backend-js');

package/frigg-cli/install-command/index.js

@@ -4,15 +4,12 @@ const { resolve } = require('node:path');
 const { updateBackendJsFile } = require('./backend-js');
 const { logInfo, logError } = require('./logger');
 const { commitChanges } = require('./commit-changes');
-const {
-    findNearestBackendPackageJson,
-    validateBackendPath,
-} = require('../utils/backend-path');
 const { handleEnvVariables } = require('./environment-variables');
 const {
     validatePackageExists,
     searchAndSelectPackage,
 } = require('./validate-package');
+const { findNearestBackendPackageJson, validateBackendPath } = require('@friggframework/core');
 
 const installCommand = async (apiModuleName) => {
     try {

package/frigg-cli/start-command/index.js

@@ -1,7 +1,11 @@
-const { spawn } = require('child_process');
-const path = require('path');
+const { spawn } = require('node:child_process');
+const path = require('node:path');
 
-function startCommand() {
+function startCommand(options) {
+    if (options.verbose) {
+        console.log('Verbose mode enabled');
+        console.log('Options:', options);
+    }
     console.log('Starting backend and optional frontend...');
     // Suppress AWS SDK warning message about maintenance mode
     process.env.AWS_SDK_JS_SUPPRESS_MAINTENANCE_MODE_MESSAGE = 1;
@@ -9,7 +13,23 @@ function startCommand() {
     console.log(`Starting backend in ${backendPath}...`);
     const infrastructurePath = 'infrastructure.js';
     const command = 'serverless';
-    const args = ['offline', '--config', infrastructurePath, '--stage=dev'];
+    const args = [
+        'offline',
+        '--config',
+        infrastructurePath,
+        '--stage',
+        options.stage
+    ];
+
+    // Add verbose flag to serverless if verbose option is enabled
+    if (options.verbose) {
+        args.push('--verbose');
+    }
+
+    if (options.verbose) {
+        console.log(`Executing command: ${command} ${args.join(' ')}`);
+        console.log(`Working directory: ${backendPath}`);
+    }
 
     const childProcess = spawn(command, args, {
         cwd: backendPath,

package/infrastructure/create-frigg-infrastructure.js

@@ -2,9 +2,7 @@ const path = require('path');
 const fs = require('fs-extra');
 const { composeServerlessDefinition } = require('./serverless-template');
 
-const {
-    findNearestBackendPackageJson,
-} = require('../frigg-cli/utils/backend-path');
+const { findNearestBackendPackageJson } = require('@friggframework/core');
 
 function createFriggInfrastructure() {
     const backendPath = findNearestBackendPackageJson();

package/infrastructure/serverless-template.js

@@ -1,12 +1,114 @@
 const path = require('path');
 const fs = require('fs');
 
-const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
+// Function to find the actual path to node_modules
+const findNodeModulesPath = () => {
+    try {
+        // Method 1: Try to find node_modules by traversing up from current directory
+        let currentDir = process.cwd();
+        let nodeModulesPath = null;
+        
+        // Traverse up to 5 levels to find node_modules
+        for (let i = 0; i < 5; i++) {
+            const potentialPath = path.join(currentDir, 'node_modules');
+            if (fs.existsSync(potentialPath)) {
+                nodeModulesPath = potentialPath;
+                console.log(`Found node_modules at: ${nodeModulesPath} (method 1)`);
+                break;
+            }
+            // Move up one directory
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                // We've reached the root
+                break;
+            }
+            currentDir = parentDir;
+        }
+        
+        // Method 2: If method 1 fails, try using npm root command
+        if (!nodeModulesPath) {
+            try {
+                // This requires child_process, so let's require it here
+                const { execSync } = require('node:child_process');
+                const npmRoot = execSync('npm root', { encoding: 'utf8' }).trim();
+                if (fs.existsSync(npmRoot)) {
+                    nodeModulesPath = npmRoot;
+                    console.log(`Found node_modules at: ${nodeModulesPath} (method 2)`);
+                }
+            } catch (npmError) {
+                console.error('Error executing npm root:', npmError);
+            }
+        }
+        
+        // Method 3: If all else fails, check for a package.json and assume node_modules is adjacent
+        if (!nodeModulesPath) {
+            currentDir = process.cwd();
+            for (let i = 0; i < 5; i++) {
+                const packageJsonPath = path.join(currentDir, 'package.json');
+                if (fs.existsSync(packageJsonPath)) {
+                    const potentialNodeModules = path.join(currentDir, 'node_modules');
+                    if (fs.existsSync(potentialNodeModules)) {
+                        nodeModulesPath = potentialNodeModules;
+                        console.log(`Found node_modules at: ${nodeModulesPath} (method 3)`);
+                        break;
+                    }
+                }
+                // Move up one directory
+                const parentDir = path.dirname(currentDir);
+                if (parentDir === currentDir) {
+                    // We've reached the root
+                    break;
+                }
+                currentDir = parentDir;
+            }
+        }
+        
+        if (nodeModulesPath) {
+            return nodeModulesPath;
+        }
+        
+        console.warn('Could not find node_modules path, falling back to default');
+        return path.resolve(process.cwd(), '../node_modules');
+    } catch (error) {
+        console.error('Error finding node_modules path:', error);
+        return path.resolve(process.cwd(), '../node_modules');
+    }
+};
+
+// Function to modify handler paths to point to the correct node_modules
+const modifyHandlerPaths = (functions) => {
+    // Check if we're running in offline mode
+    const isOffline = process.argv.includes('offline');
+    console.log('isOffline', isOffline);
+    
+    if (!isOffline) {
+        console.log('Not in offline mode, skipping handler path modification');
+        return functions;
+    }
+
+    const nodeModulesPath = findNodeModulesPath();
+    const modifiedFunctions = { ...functions };
+    
+    for (const functionName of Object.keys(modifiedFunctions)) {
+        console.log('functionName', functionName);
+        const functionDef = modifiedFunctions[functionName];
+        if (functionDef?.handler?.includes('node_modules/')) {
+            // Replace node_modules/ with the actual path to node_modules/
+            functionDef.handler = functionDef.handler.replace('node_modules/', '../node_modules/');
+            console.log(`Updated handler for ${functionName}: ${functionDef.handler}`);
+        }
+    }
+    
+    return modifiedFunctions;
+};
+
+const composeServerlessDefinition = (AppDefinition) => {
     const definition = {
         frameworkVersion: '>=3.17.0',
         service: AppDefinition.name || 'create-frigg-app',
         package: {
             individually: true,
+            exclude: ["!**/node_modules/aws-sdk/**", "!**/node_modules/@aws-sdk/**", "!package.json"],
         },
         useDotenv: true,
         provider: {
@@ -30,6 +132,7 @@ const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
             ],
         },
         plugins: [
+            'serverless-jetpack',
             'serverless-dotenv-plugin',
             'serverless-offline-sqs',
             'serverless-offline',
@@ -50,19 +153,13 @@ const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
                 secretAccessKey: 'root',
                 skipCacheInvalidation: false,
             },
-            webpack: {
-                webpackConfig: 'webpack.config.js',
-                includeModules: {
-                    forceExclude: ['aws-sdk'],
-                },
-                packager: 'npm',
-                excludeFiles: ['src/**/*.test.js', 'test/'],
+            jetpack: {
+                base: '..',
             },
         },
         functions: {
             defaultWebsocket: {
-                handler:
-                    '/../node_modules/@friggframework/devtools/infrastructure/routers/websocket.handler',
+                handler: 'node_modules/@friggframework/core/handlers/routers/websocket.handler',
                 events: [
                     {
                         websocket: {
@@ -82,8 +179,7 @@ const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
                 ],
             },
             auth: {
-                handler:
-                    '/../node_modules/@friggframework/devtools/infrastructure/routers/auth.handler',
+                handler: 'node_modules/@friggframework/core/handlers/routers/auth.handler',
                 events: [
                     {
                         http: {
@@ -109,8 +205,7 @@ const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
                 ],
             },
             user: {
-                handler:
-                    '/../node_modules/@friggframework/devtools/infrastructure/routers/user.handler',
+                handler: 'node_modules/@friggframework/core/handlers/routers/user.handler',
                 events: [
                     {
                         http: {
@@ -213,23 +308,16 @@ const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
     };
 
     // Add integration-specific functions and resources
-    AppDefinition.integrations.forEach((integration) => {
+    for (const integration of AppDefinition.integrations) {
         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,
-            //     },
-            // })),
+            handler: `node_modules/@friggframework/core/handlers/routers/integration-defined-routers.handlers.${integrationName}.handler`,
             events: [
                 {
                     http: {
-                        path: `/api/${integrationName}-integration/{proxy*}`,
+                        path: `/api/${integrationName}-integration/{proxy+}`,
                         method: 'ANY',
                         cors: true,
                     },
@@ -247,6 +335,7 @@ const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
             Properties: {
                 QueueName: `\${self:custom.${queueReference}}`,
                 MessageRetentionPeriod: 60,
+                VisibilityTimeout: 1800,  // 30 minutes
                 RedrivePolicy: {
                     maxReceiveCount: 1,
                     deadLetterTargetArn: {
@@ -259,7 +348,7 @@ const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
         // 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`,
+            handler: `node_modules/@friggframework/core/handlers/workers/integration-defined-workers.handlers.${integrationName}.queueWorker`,
             reservedConcurrency: 5,
             events: [
                 {
@@ -277,14 +366,17 @@ const composeServerlessDefinition = (AppDefinition, IntegrationFactory) => {
         // Add Queue URL for the integration to the ENVironment variables
         definition.provider.environment = {
             ...definition.provider.environment,
-            [integrationName.toUpperCase() + '_QUEUE_URL']: {
+            [`${integrationName.toUpperCase()}_QUEUE_URL`]: {
                 Ref: queueReference,
             },
         };
 
         definition.custom[queueReference] = queueName;
-    });
+    }
 
+    // Modify handler paths to point to the correct node_modules location
+    definition.functions = modifyHandlerPaths(definition.functions);
+    
     return definition;
 };
 

package/package.json

@@ -1,14 +1,13 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.2",
+  "version": "2.0.0-next.21",
   "dependencies": {
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0-next.2",
-    "@friggframework/test": "2.0.0-next.2",
-    "@hapi/boom": "^7.4.11",
+    "@friggframework/test": "2.0.0-next.21",
+    "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
     "body-parser": "^1.20.2",
@@ -24,16 +23,19 @@
     "express": "^4.19.2",
     "express-async-handler": "^1.2.0",
     "fs-extra": "^11.2.0",
-    "lodash": "^4.17.21",
+    "lodash": "4.17.21",
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0-next.2",
-    "@friggframework/prettier-config": "2.0.0-next.2",
+    "@friggframework/eslint-config": "2.0.0-next.21",
+    "@friggframework/prettier-config": "2.0.0-next.21",
+    "prettier": "^2.7.1",
+    "serverless": "3.39.0",
     "serverless-dotenv-plugin": "^6.0.0",
+    "serverless-jetpack": "^0.11.2",
     "serverless-offline": "^13.8.0",
     "serverless-offline-sqs": "^8.0.0",
-    "serverless-webpack": "^5.14.1"
+    "serverless-plugin-monorepo": "^0.11.0"
   },
   "scripts": {
     "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
@@ -57,5 +59,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "d2468c93806cf76851ead37495c10a4532d61489"
+  "gitHead": "ad1d397f60175576cb2d939ae6c75533ee5a4c2a"
 }

package/frigg-cli/utils/backend-path.js

@@ -1,26 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const PACKAGE_JSON = 'package.json';
-
-function findNearestBackendPackageJson() {
-    let currentDir = process.cwd();
-    while (currentDir !== path.parse(currentDir).root) {
-        const packageJsonPath = path.join(currentDir, 'backend', PACKAGE_JSON);
-        if (fs.existsSync(packageJsonPath)) {
-            return packageJsonPath;
-        }
-        currentDir = path.dirname(currentDir);
-    }
-    return null;
-}
-
-function validateBackendPath(backendPath) {
-    if (!backendPath) {
-        throw new Error('Could not find a backend package.json file.');
-    }
-}
-
-module.exports = {
-    findNearestBackendPackageJson,
-    validateBackendPath,
-};

package/infrastructure/app-handler-helpers.js

@@ -1,57 +0,0 @@
-const { createHandler, flushDebugLog } = require('@friggframework/core');
-const express = require('express');
-const bodyParser = require('body-parser');
-const cors = require('cors');
-const Boom = require('@hapi/boom');
-const loadUserManager = require('./routers/middleware/loadUser');
-const serverlessHttp = require('serverless-http');
-
-const createApp = (applyMiddleware) => {
-    const app = express();
-
-    app.use(bodyParser.json({ limit: '10mb' }));
-    app.use(bodyParser.urlencoded({ extended: true }));
-    app.use(
-        cors({
-            origin: '*',
-            credentials: true,
-        })
-    );
-
-    app.use(loadUserManager);
-
-    if (applyMiddleware) applyMiddleware(app);
-
-    // Handle sending error response and logging server errors to console
-    app.use((err, req, res, next) => {
-        const boomError = err.isBoom ? err : Boom.boomify(err);
-        const {
-            output: { statusCode = 500 },
-        } = boomError;
-
-        if (statusCode >= 500) {
-            flushDebugLog(boomError);
-            res.status(statusCode).json({ error: 'Internal Server Error' });
-        } else {
-            res.status(statusCode).json({ error: err.message });
-        }
-    });
-
-    return app;
-};
-
-function createAppHandler(eventName, router, shouldUseDatabase = true) {
-    const app = createApp((app) => {
-        app.use(router);
-    });
-    return createHandler({
-        eventName,
-        method: serverlessHttp(app),
-        shouldUseDatabase,
-    });
-}
-
-module.exports = {
-    createApp,
-    createAppHandler,
-};

package/infrastructure/backend-utils.js

@@ -1,90 +0,0 @@
-const { createFriggBackend, Worker } = require('@friggframework/core');
-const {
-    findNearestBackendPackageJson,
-} = require('../frigg-cli/utils/backend-path');
-const path = require('path');
-const fs = require('fs-extra');
-
-const backendPath = findNearestBackendPackageJson();
-if (!backendPath) {
-    throw new Error('Could not find backend package.json');
-}
-
-const backendDir = path.dirname(backendPath);
-const backendFilePath = path.join(backendDir, 'index.js');
-if (!fs.existsSync(backendFilePath)) {
-    throw new Error('Could not find index.js');
-}
-
-const backendJsFile = require(backendFilePath);
-const { Router } = require('express');
-const appDefinition = backendJsFile.Definition;
-
-const backend = createFriggBackend(appDefinition);
-const loadRouterFromObject = (IntegrationClass, routerObject) => {
-    const router = Router();
-    const { path, method, event } = routerObject;
-    console.log(
-        `Registering ${method} ${path} for ${IntegrationClass.Definition.name}`
-    );
-    router[method.toLowerCase()](path, async (req, res, next) => {
-        try {
-            const integration = new IntegrationClass({});
-            await integration.loadModules();
-            await integration.registerEventHandlers();
-            const result = await integration.send(event, req.body);
-            res.json(result);
-        } catch (error) {
-            next(error);
-        }
-    });
-
-    return router;
-};
-const createQueueWorker = (integrationClass) => {
-    class QueueWorker extends Worker {
-        constructor(params) {
-            super(params);
-        }
-        async _run(params, context) {
-            try {
-                let instance;
-                if (!params.integrationId) {
-                    instance = new integrationClass({});
-                    await instance.loadModules();
-                    // await instance.loadUserActions();
-                    await instance.registerEventHandlers();
-                    console.log(
-                        `${params.event} for ${integrationClass.Definition.name} integration with no integrationId`
-                    );
-                } else {
-                    instance =
-                        await integrationClass.getInstanceFromIntegrationId({
-                            integrationId: params.integrationId,
-                        });
-                    console.log(
-                        `${params.event} for ${instance.integration.config.type} of integrationId: ${params.integrationId}`
-                    );
-                }
-                const res = await instance.send(params.event, {
-                    data: params.data,
-                    context,
-                });
-                return res;
-            } catch (error) {
-                console.error(
-                    `Error in ${params.event} for ${integrationClass.Definition.name}:`,
-                    error
-                );
-                throw error;
-            }
-        }
-    }
-    return QueueWorker;
-};
-
-module.exports = {
-    ...backend,
-    loadRouterFromObject,
-    createQueueWorker,
-};

package/infrastructure/routers/auth.js

@@ -1,26 +0,0 @@
-const { createIntegrationRouter } = require('@friggframework/core');
-const { createAppHandler } = require('./../app-handler-helpers');
-const { requireLoggedInUser } = require('./middleware/requireLoggedInUser');
-const {
-    moduleFactory,
-    integrationFactory,
-    IntegrationHelper,
-} = require('./../backend-utils');
-
-const router = createIntegrationRouter({
-    factory: { moduleFactory, integrationFactory, IntegrationHelper },
-    requireLoggedInUser,
-    getUserId: (req) => req.user.getUserId(),
-});
-
-router.route('/redirect/:appId').get((req, res) => {
-    res.redirect(
-        `${process.env.FRONTEND_URI}/redirect/${
-            req.params.appId
-        }?${new URLSearchParams(req.query)}`
-    );
-});
-
-const handler = createAppHandler('HTTP Event: Auth', router);
-
-module.exports = { handler, router };

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

@@ -1,37 +0,0 @@
-const { createIntegrationRouter } = require('@friggframework/core');
-const { createAppHandler } = require('./../app-handler-helpers');
-const { requireLoggedInUser } = require('./middleware/requireLoggedInUser');
-const {
-    moduleFactory,
-    integrationFactory,
-    IntegrationHelper,
-    loadRouterFromObject,
-} = require('./../backend-utils');
-const { Router } = require('express');
-
-const handlers = {};
-integrationFactory.integrationClasses.forEach((IntegrationClass) => {
-    const router = Router();
-    const basePath = `/api/${IntegrationClass.Definition.name}-integration`;
-    IntegrationClass.Definition.routes.forEach((routeDef) => {
-        if (typeof routeDef === 'function') {
-            router.use(basePath, routeDef(IntegrationClass));
-        } else if (typeof routeDef === 'object') {
-            router.use(
-                basePath,
-                loadRouterFromObject(IntegrationClass, routeDef)
-            );
-        } else if (routeDef instanceof express.Router) {
-            router.use(basePath, routeDef);
-        }
-    });
-
-    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/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 };