@friggframework/devtools 2.0.0-next.4 → 2.0.0-next.41

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,14 +1,17 @@
 {
   "name": "@friggframework/devtools",
   "prettier": "@friggframework/prettier-config",
-  "version": "2.0.0-next.4",
+  "version": "2.0.0-next.41",
   "dependencies": {
+    "@aws-sdk/client-ec2": "^3.835.0",
+    "@aws-sdk/client-kms": "^3.835.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.4",
-    "@friggframework/test": "2.0.0-next.4",
-    "@hapi/boom": "^7.4.11",
+    "@friggframework/schemas": "2.0.0-next.41",
+    "@friggframework/test": "2.0.0-next.41",
+    "@hapi/boom": "^10.0.1",
     "@inquirer/prompts": "^5.3.8",
     "axios": "^1.7.2",
     "body-parser": "^1.20.2",
@@ -24,16 +27,24 @@
     "express": "^4.19.2",
     "express-async-handler": "^1.2.0",
     "fs-extra": "^11.2.0",
-    "lodash": "^4.17.21",
+    "js-yaml": "^4.1.0",
+    "lodash": "4.17.21",
     "serverless-http": "^2.7.0"
   },
   "devDependencies": {
-    "@friggframework/eslint-config": "2.0.0-next.4",
-    "@friggframework/prettier-config": "2.0.0-next.4",
+    "@friggframework/eslint-config": "2.0.0-next.41",
+    "@friggframework/prettier-config": "2.0.0-next.41",
+    "aws-sdk-client-mock": "^4.1.0",
+    "aws-sdk-client-mock-jest": "^4.1.0",
+    "jest": "^30.1.3",
+    "prettier": "^2.7.1",
+    "serverless": "3.39.0",
     "serverless-dotenv-plugin": "^6.0.0",
+    "serverless-jetpack": "^0.11.2",
+    "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",
@@ -57,5 +68,5 @@
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "65ef3d8b5710609d4ce6813ae210714050759b53"
+  "gitHead": "a5c413164c1b492a228689851d037706f7f869af"
 }

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