@friggframework/devtools 2.0.0-next.6 → 2.0.0-next.60

package/management-ui/tailwind.config.js

@@ -0,0 +1,63 @@
+/** @type {import('tailwindcss').Config} */
+export default {
+	darkMode: ["class"],
+	content: [
+		"./index.html",
+		"./src/**/*.{js,ts,jsx,tsx}",
+	],
+	theme: {
+		extend: {
+			colors: {
+				'frigg-blue': '#0066CC',
+				'frigg-dark': '#1A1A1A',
+				'frigg-gray': '#F5F5F5',
+				background: 'hsl(var(--background))',
+				foreground: 'hsl(var(--foreground))',
+				card: {
+					DEFAULT: 'hsl(var(--card))',
+					foreground: 'hsl(var(--card-foreground))'
+				},
+				popover: {
+					DEFAULT: 'hsl(var(--popover))',
+					foreground: 'hsl(var(--popover-foreground))'
+				},
+				primary: {
+					DEFAULT: 'hsl(var(--primary))',
+					foreground: 'hsl(var(--primary-foreground))'
+				},
+				secondary: {
+					DEFAULT: 'hsl(var(--secondary))',
+					foreground: 'hsl(var(--secondary-foreground))'
+				},
+				muted: {
+					DEFAULT: 'hsl(var(--muted))',
+					foreground: 'hsl(var(--muted-foreground))'
+				},
+				accent: {
+					DEFAULT: 'hsl(var(--accent))',
+					foreground: 'hsl(var(--accent-foreground))'
+				},
+				destructive: {
+					DEFAULT: 'hsl(var(--destructive))',
+					foreground: 'hsl(var(--destructive-foreground))'
+				},
+				border: 'hsl(var(--border))',
+				input: 'hsl(var(--input))',
+				ring: 'hsl(var(--ring))',
+				chart: {
+					'1': 'hsl(var(--chart-1))',
+					'2': 'hsl(var(--chart-2))',
+					'3': 'hsl(var(--chart-3))',
+					'4': 'hsl(var(--chart-4))',
+					'5': 'hsl(var(--chart-5))'
+				}
+			},
+			borderRadius: {
+				lg: 'var(--radius)',
+				md: 'calc(var(--radius) - 2px)',
+				sm: 'calc(var(--radius) - 4px)'
+			}
+		}
+	},
+	plugins: [require("tailwindcss-animate")],
+}

package/management-ui/tsconfig.json

@@ -0,0 +1,37 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+    "allowJs": true,
+    "checkJs": false,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": false,
+    "noUnusedParameters": false,
+    "noFallthroughCasesInSwitch": true,
+
+    /* Path mapping */
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"],
+      "@/components/*": ["./src/components/*"],
+      "@/hooks/*": ["./src/hooks/*"],
+      "@/utils/*": ["./src/utils/*"],
+      "@/services/*": ["./src/services/*"]
+    }
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

package/management-ui/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.js"]
+}

package/management-ui/vite.config.js

@@ -0,0 +1,26 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'path'
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+  server: {
+    port: 5173,
+    proxy: {
+      '/api': {
+        target: 'http://localhost:3001',
+        changeOrigin: true,
+      },
+      '/socket.io': {
+        target: 'http://localhost:3001',
+        ws: true,
+      }
+    }
+  }
+})

package/management-ui/vitest.config.js

@@ -0,0 +1,38 @@
+import { defineConfig } from 'vitest/config'
+import react from '@vitejs/plugin-react'
+import path from 'path'
+
+export default defineConfig({
+  plugins: [react()],
+  test: {
+    globals: true,
+    environment: 'jsdom',
+    setupFiles: ['./src/test/setup.js'],
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        'server/',
+        '**/*.config.js',
+        '**/*.config.ts',
+        '**/test/**',
+        '**/__tests__/**',
+        '**/*.test.{js,ts,jsx,tsx}',
+        '**/*.spec.{js,ts,jsx,tsx}'
+      ],
+      thresholds: {
+        statements: 70,
+        branches: 70,
+        functions: 70,
+        lines: 70
+      }
+    }
+  },
+  resolve: {
+    alias: {
+      '@': path.resolve(__dirname, './src'),
+    },
+  },
+})

package/package.json

@@ -1,19 +1,32 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.6",
+  "version": "2.0.0-next.60",
+  "bin": {
+    "frigg": "./frigg-cli/index.js"
+  },
   "dependencies": {
+    "@aws-sdk/client-cloudformation": "^3.705.0",
+    "@aws-sdk/client-ec2": "^3.835.0",
+    "@aws-sdk/client-kms": "^3.835.0",
+    "@aws-sdk/client-rds": "^3.906.0",
+    "@aws-sdk/client-s3": "^3.917.0",
+    "@aws-sdk/client-secrets-manager": "^3.906.0",
+    "@aws-sdk/client-sts": "^3.835.0",
     "@babel/eslint-parser": "^7.18.9",
     "@babel/parser": "^7.25.3",
     "@babel/traverse": "^7.25.3",
-    "@friggframework/core": "2.0.0-next.6",
-    "@friggframework/test": "2.0.0-next.6",
-    "@hapi/boom": "^7.4.11",
+    "@friggframework/core": "2.0.0-next.60",
+    "@friggframework/schemas": "2.0.0-next.60",
+    "@friggframework/test": "2.0.0-next.60",
+    "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
     "body-parser": "^1.20.2",
+    "chalk": "^4.1.2",
     "commander": "^12.1.0",
     "cors": "^2.8.5",
+    "cross-spawn": "^7.0.3",
     "dotenv": "^16.4.5",
     "eslint": "^8.22.0",
     "eslint-config-prettier": "^8.5.0",
@@ -24,25 +37,33 @@
     "express": "^4.19.2",
     "express-async-handler": "^1.2.0",
     "fs-extra": "^11.2.0",
-    "lodash": "^4.17.21",
-    "serverless-http": "^2.7.0"
+    "js-yaml": "^4.1.0",
+    "lodash": "4.17.21",
+    "node-cache": "^5.1.2",
+    "open": "^8.4.2",
+    "semver": "^7.6.0",
+    "serverless-http": "^2.7.0",
+    "validate-npm-package-name": "^5.0.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0-next.6",
-    "@friggframework/prettier-config": "2.0.0-next.6",
-    "serverless": "3.39.0",
+    "@friggframework/eslint-config": "2.0.0-next.60",
+    "@friggframework/prettier-config": "2.0.0-next.60",
+    "aws-sdk-client-mock": "^4.1.0",
+    "aws-sdk-client-mock-jest": "^4.1.0",
+    "jest": "^30.1.3",
+    "osls": "^3.40.1",
+    "prettier": "^2.7.1",
     "serverless-dotenv-plugin": "^6.0.0",
+    "serverless-esbuild": "^1.54.3",
+    "serverless-kms-grants": "^1.0.0",
     "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",
     "test": "jest --passWithNoTests # TODO"
   },
-  "bin": {
-    "frigg": "./frigg-cli/index.js"
-  },
   "author": "",
   "license": "MIT",
   "main": "index.js",
@@ -58,5 +79,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "14d7f856430f95bc0367246089713540e1c23a86"
+  "gitHead": "8fc85a629bedc7b17a9415ef8952dddb1daee1b5"
 }

package/test/index.js

@@ -1,11 +1,9 @@
-const {testDefinitionRequiredAuthMethods} = require('./auther-definition-method-tester');
-const {createMockIntegration, createMockApiObject} = require('./mock-integration');
-const { testAutherDefinition } = require('./auther-definition-tester');
+const { testDefinitionRequiredAuthMethods } = require('./auther-definition-method-tester');
+const { createMockIntegration, createMockApiObject } = require('./mock-integration');
 
 
 module.exports = {
     createMockIntegration,
     createMockApiObject,
     testDefinitionRequiredAuthMethods,
-    testAutherDefinition,
 };

package/test/mock-integration.js

@@ -1,8 +1,4 @@
 const {
-    Auther,
-    Credential,
-    Entity,
-    IntegrationFactory,
     createObjectId,
 } = require('@friggframework/core');
 
@@ -11,7 +7,6 @@ async function createMockIntegration(
     userId = null,
     config = { type: IntegrationClass.Definition.name }
 ) {
-    const integrationFactory = new IntegrationFactory([IntegrationClass]);
     userId = userId || createObjectId();
 
     const insertOptions = {
@@ -24,10 +19,8 @@ async function createMockIntegration(
     const entities = [];
     for (const moduleName in IntegrationClass.modules) {
         const ModuleDef = IntegrationClass.Definition.modules[moduleName];
-        const module = await Auther.getInstance({
-            definition: ModuleDef,
-            userId: userId,
-        });
+        // todo: create module using the new architecture
+        const module = {}
         const credential = await module.CredentialModel.findOneAndUpdate(
             user,
             { $set: user },
@@ -51,11 +44,8 @@ async function createMockIntegration(
         );
     }
 
-    const integration = await integrationFactory.createIntegration(
-        entities,
-        userId,
-        config
-    );
+    // todo: create integration using the new architecture
+    const integration = {}
 
     integration.id = integration.record._id;
 

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,87 +0,0 @@
-const { createFriggBackend, Worker } = require('@friggframework/core');
-const {
-    findNearestBackendPackageJson,
-} = require('../frigg-cli/utils/backend-path');
-const path = require('node: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, res, next});
-            res.json(result);
-        } catch (error) {
-            next(error);
-        }
-    });
-
-    return router;
-};
-const createQueueWorker = (integrationClass) => {
-    class QueueWorker extends Worker {
-        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,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 };