@friggframework/devtools 2.0.0--canary.546.74db90f.0 → 2.0.0--canary.545.e7becd9.0

package/frigg-cli/templates/backend/.prettierrc

@@ -0,0 +1,6 @@
+{
+    "singleQuote": true,
+    "tabWidth": 4,
+    "printWidth": 100,
+    "trailingComma": "es5"
+}

package/frigg-cli/templates/backend/docker-compose.yml

@@ -0,0 +1,22 @@
+version: '3.8'
+
+services:
+  postgres:
+    image: postgres:15-alpine
+    container_name: frigg-postgres
+    environment:
+      POSTGRES_USER: frigg
+      POSTGRES_PASSWORD: frigg
+      POSTGRES_DB: frigg
+    ports:
+      - "5432:5432"
+    volumes:
+      - postgres_data:/var/lib/postgresql/data
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U frigg"]
+      interval: 5s
+      timeout: 5s
+      retries: 5
+
+volumes:
+  postgres_data:

package/frigg-cli/templates/backend/index.js

@@ -0,0 +1,96 @@
+/**
+ * Frigg Application Definition
+ *
+ * This file defines your Frigg integration application.
+ * Configure integrations, authentication, and infrastructure settings here.
+ */
+
+// Import your integrations here
+// const ExampleIntegration = require('./src/integrations/ExampleIntegration');
+
+const appDefinition = {
+    // Application metadata
+    label: 'My Frigg Application',
+    name: 'my-frigg-app',
+
+    // Deployment mode: 'managed' (recommended) or 'custom'
+    managementMode: 'managed',
+
+    // VPC isolation strategy: 'isolated' (each stage separate) or 'shared'
+    vpcIsolation: 'isolated',
+
+    // Your integrations - add Integration classes here
+    integrations: [
+        // Add your integrations here as you install them
+        // Example:
+        // ExampleIntegration,
+    ],
+
+    // User authentication configuration
+    user: {
+        usePassword: true,
+        primary: 'organization',
+        individualUserRequired: true,
+        organizationUserRequired: true,
+        authModes: {
+            friggToken: true, // Support web UI login
+            sharedSecret: true, // Enable backend-to-backend API communication
+            adopterJwt: false, // Set true to use your own JWT tokens
+        },
+    },
+
+    // Encryption settings
+    encryption: {
+        fieldLevelEncryptionMethod: 'kms', // KMS encryption for production
+    },
+
+    // VPC configuration
+    vpc: {
+        enable: true,
+        enableVPCEndpoints: true,
+        selfHeal: true,
+    },
+
+    // Database configuration (PostgreSQL via Aurora Serverless)
+    database: {
+        postgres: {
+            enable: true,
+            publiclyAccessible: false,
+            database: 'postgres',
+            minCapacity: 0.5,
+            maxCapacity: 1,
+        },
+    },
+
+    // SSM Parameter Store (optional)
+    ssm: {
+        enable: false,
+    },
+
+    // Environment variables required by your application
+    // Set these in your .env file or deployment environment
+    environment: {
+        // Core Configuration
+        BASE_URL: true,
+        DATABASE_URL: true,
+        DATABASE_USER: true,
+        DATABASE_PASSWORD: true,
+        REDIRECT_URI: true,
+        HEALTH_API_KEY: true,
+        ADMIN_API_KEY: true,
+        FRIGG_API_KEY: true,
+        FRIGG_APP_USER_ID: true,
+
+        // AWS Configuration
+        AWS_REGION: true,
+        S3_BUCKET_NAME: true,
+
+        // Add your integration-specific environment variables here
+        // EXAMPLE_CLIENT_ID: true,
+        // EXAMPLE_CLIENT_SECRET: true,
+    },
+};
+
+module.exports = {
+    Definition: appDefinition,
+};

package/frigg-cli/templates/backend/infrastructure.js

@@ -0,0 +1,12 @@
+/**
+ * Frigg Infrastructure Configuration
+ *
+ * This file exports the serverless configuration for your Frigg application.
+ * The createFriggInfrastructure function reads your app definition and
+ * generates the appropriate serverless.yml configuration.
+ */
+
+const { createFriggInfrastructure } = require('@friggframework/devtools');
+
+// Serverless supports async configuration by exporting a promise
+module.exports = createFriggInfrastructure();

package/frigg-cli/templates/backend/jest.config.js

@@ -0,0 +1,17 @@
+module.exports = {
+    testEnvironment: 'node',
+    testMatch: ['**/test/**/*.test.js', '**/test/**/*.spec.js'],
+    testPathIgnorePatterns: ['/node_modules/'],
+    collectCoverageFrom: [
+        'src/**/*.js',
+        '!src/**/*.test.js',
+        '!src/**/*.spec.js',
+    ],
+    coverageDirectory: 'coverage',
+    coverageReporters: ['text', 'lcov', 'html'],
+    verbose: true,
+    testTimeout: 30000,
+    setupFilesAfterEnv: ['./test/setup.js'],
+    // Jest groups for selective testing
+    runner: 'groups',
+};

package/frigg-cli/templates/backend/package.json

@@ -0,0 +1,50 @@
+{
+    "name": "frigg-backend",
+    "version": "0.1.0",
+    "private": true,
+    "prettier": "@friggframework/prettier-config",
+    "scripts": {
+        "test": "jest --group=-interactive --group=-live-api",
+        "test:full": "jest",
+        "test:unit": "jest --config jest.unit.config.js",
+        "test:watch": "jest --watch",
+        "test:coverage": "jest --coverage",
+        "lint": "eslint .",
+        "lint:fix": "prettier --write --loglevel error . && eslint . --fix",
+        "format": "prettier --write --loglevel error .",
+        "backend-start": "sls offline --stage dev --config serverless.js",
+        "docker:start": "docker compose up -d",
+        "docker:stop": "docker compose down",
+        "frigg:start": "frigg start",
+        "frigg:deploy": "frigg deploy",
+        "frigg:db:setup": "frigg db:setup"
+    },
+    "dependencies": {
+        "@friggframework/core": "2.0.0-next.58",
+        "axios": "^1.6.0",
+        "body-parser": "^1.20.3",
+        "cors": "^2.8.5",
+        "express": "^4.21.2",
+        "express-async-handler": "^1.2.0",
+        "node-cache": "^5.1.2",
+        "serverless-http": "^2.7.0"
+    },
+    "devDependencies": {
+        "@friggframework/devtools": "2.0.0-next.58",
+        "@friggframework/eslint-config": "2.0.0-next.58",
+        "@friggframework/prettier-config": "2.0.0-next.58",
+        "@friggframework/serverless-plugin": "2.0.0-next.58",
+        "@friggframework/test": "2.0.0-next.58",
+        "@prisma/client": "^6.0.0",
+        "dotenv": "^16.4.5",
+        "esbuild": "^0.25.0",
+        "jest": "^29.7.0",
+        "nock": "^13.5.4",
+        "osls": "^3.40.1",
+        "prettier": "3.5.3",
+        "prisma": "^6.0.0",
+        "serverless-dotenv-plugin": "^6.0.0",
+        "serverless-esbuild": "^1.55.1",
+        "serverless-offline": "^13.8.0"
+    }
+}

package/frigg-cli/templates/backend/src/api-modules/.gitkeep

@@ -0,0 +1,10 @@
+# This directory is for custom API modules
+#
+# API modules define how to connect with external APIs.
+# Most integrations use published @friggframework/api-module-* packages.
+#
+# Only create custom API modules here if:
+# - You're integrating with a proprietary API
+# - No published module exists for your service
+#
+# Use 'frigg generate:api-module' to create new API modules

package/frigg-cli/templates/backend/src/base/.gitkeep

@@ -0,0 +1,7 @@
+# This directory contains base classes and shared infrastructure
+#
+# Common patterns:
+# - Custom entity extensions
+# - Shared middleware
+# - Base integration classes
+# - Custom authentication handlers

package/frigg-cli/templates/backend/src/integrations/.gitkeep

@@ -0,0 +1,10 @@
+# This directory contains your Integration classes
+# Each integration connects your application with a third-party API module
+#
+# Example structure:
+# src/integrations/
+#   SalesforceIntegration.js
+#   HubSpotIntegration.js
+#   SlackIntegration.js
+#
+# Use 'frigg generate:integration' to create new integrations

package/frigg-cli/templates/backend/src/integrations/ExampleIntegration.js

@@ -0,0 +1,65 @@
+/**
+ * Example Integration
+ *
+ * This is a template showing how to create an Integration class.
+ * An Integration connects your application with a third-party API module.
+ *
+ * To create your own integration:
+ * 1. Install the API module: npm install @friggframework/api-module-<name>
+ * 2. Copy this file and rename it (e.g., SalesforceIntegration.js)
+ * 3. Update the imports and class to use your API module
+ * 4. Register it in index.js
+ */
+
+const { Integration } = require('@friggframework/core');
+// const { Api, Entity } = require('@friggframework/api-module-example');
+
+class ExampleIntegration extends Integration {
+    static Definition = {
+        name: 'example',
+        version: '1.0.0',
+        supportedVersions: ['1.0.0'],
+
+        // Events this integration can emit
+        events: ['SYNC_COMPLETED', 'DATA_UPDATED', 'ERROR_OCCURRED'],
+    };
+
+    /**
+     * Create API instance for this integration
+     * @param {Object} params - Parameters from the credential
+     */
+    static async getInstance(params) {
+        // Return your API module instance
+        // return new Api(params);
+        throw new Error('ExampleIntegration.getInstance() not implemented');
+    }
+
+    /**
+     * Process incoming webhook events
+     * @param {Object} event - The webhook event data
+     */
+    async processWebhook(event) {
+        // Handle webhook events from the third-party service
+        console.log('Processing webhook:', event);
+    }
+
+    /**
+     * Perform initial sync after user connects
+     * @param {Object} options - Sync options
+     */
+    async initialSync(options = {}) {
+        // Sync initial data from the third-party service
+        console.log('Performing initial sync');
+    }
+
+    /**
+     * Handle OAuth callback
+     * @param {Object} callbackParams - OAuth callback parameters
+     */
+    async handleCallback(callbackParams) {
+        // Process OAuth callback and store credentials
+        console.log('Handling OAuth callback');
+    }
+}
+
+module.exports = ExampleIntegration;

package/frigg-cli/templates/backend/src/utils/.gitkeep

@@ -0,0 +1,7 @@
+# This directory contains utility functions and helpers
+#
+# Common utilities:
+# - Data transformation helpers
+# - Validation utilities
+# - Custom error classes
+# - Logging helpers

package/frigg-cli/templates/backend/test/setup.js

@@ -0,0 +1,30 @@
+/**
+ * Jest Test Setup
+ *
+ * This file runs before each test file and sets up the testing environment.
+ */
+
+const dotenv = require('dotenv');
+const path = require('path');
+
+// Load test environment variables
+dotenv.config({ path: path.join(__dirname, '..', '.env.test') });
+
+// Set test environment
+process.env.NODE_ENV = 'test';
+
+// Global test timeout
+jest.setTimeout(30000);
+
+// Silence console logs during tests (optional - comment out for debugging)
+// global.console = {
+//     ...console,
+//     log: jest.fn(),
+//     info: jest.fn(),
+//     warn: jest.fn(),
+// };
+
+// Clean up after all tests
+afterAll(async () => {
+    // Add any global cleanup here
+});

package/frigg-cli/templates/backend/ui-extensions/README.md

@@ -0,0 +1,77 @@
+# UI Extensions
+
+This directory contains custom UI extensions for external platform integrations. Each subdirectory represents a separate integration-specific package.
+
+## Purpose
+
+When integrating with platforms that provide their own UI extension frameworks (like Attio, HubSpot, Salesforce, etc.), you can build and manage those extension packages here.
+
+## Directory Structure
+
+```
+ui-extensions/
+├── README.md               # This file
+├── attio/                  # Attio UI extension (if using Attio)
+├── hubspot/                # HubSpot UI extension (if using HubSpot)
+├── salesforce/             # Salesforce Lightning component (if using Salesforce)
+└── <platform>/             # Other platform-specific extensions
+```
+
+## Getting Started
+
+Each platform extension is a separate npm package. To create one:
+
+1. **Create the extension directory:**
+   ```bash
+   mkdir ui-extensions/<platform-name>
+   cd ui-extensions/<platform-name>
+   ```
+
+2. **Initialize the package:**
+   Follow the platform's SDK documentation to set up the extension package.
+
+3. **Develop and test:**
+   Each extension has its own build and development scripts.
+
+## Example: Attio Extension
+
+```bash
+cd ui-extensions/attio
+npm install
+npm run dev    # Start development server
+npm run build  # Build for production
+```
+
+## Example: HubSpot Extension
+
+```bash
+cd ui-extensions/hubspot
+npm install
+npx hs project create --template=react-app
+npm run dev
+```
+
+## Workspace Integration
+
+Add extensions as workspaces in the root `package.json`:
+
+```json
+{
+    "workspaces": [
+        "ui-extensions/*"
+    ]
+}
+```
+
+## Platform Documentation
+
+- [Attio Apps](https://developers.attio.com)
+- [HubSpot UI Extensions](https://developers.hubspot.com/docs/platform/ui-extensions-overview)
+- [Salesforce Lightning Components](https://developer.salesforce.com/docs/atlas.en-us.lightning.meta)
+- [Monday.com Apps](https://developer.monday.com/apps)
+
+## Notes
+
+- Each extension is independent and can be deployed separately
+- Extensions typically have their own build tools and test suites
+- Keep platform-specific code isolated to its respective directory

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

@@ -2,16 +2,19 @@ const open = require('open');
 const chalk = require('chalk');
 const path = require('path');
 const ProcessManager = require('../utils/process-manager');
-const { 
-    getCurrentRepositoryInfo, 
-    discoverFriggRepositories, 
+const {
+    getCurrentRepositoryInfo,
+    discoverFriggRepositories,
     promptRepositorySelection,
-    formatRepositoryInfo 
+    formatRepositoryInfo
 } = require('../utils/repo-detection');
 
 async function uiCommand(options) {
-    const { port = 3001, open: shouldOpen = true, repo: specifiedRepo, dev = false } = options;
-    
+    const { port = 3210, open: shouldOpen = true, repo: specifiedRepo, dev = false } = options;
+
+    // Fix: --no-open should set open to false, not use the default true
+    const shouldOpenBrowser = options.open !== false;
+
     let targetRepo = null;
     let workingDirectory = process.cwd();
 
@@ -25,7 +28,7 @@ async function uiCommand(options) {
         // Check if we're already in a Frigg repository
         console.log(chalk.blue('Detecting Frigg repository...'));
         const currentRepo = await getCurrentRepositoryInfo();
-        
+
         if (currentRepo) {
             console.log(chalk.green(`✓ Found Frigg repository: ${formatRepositoryInfo(currentRepo)}`));
             if (currentRepo.currentSubPath) {
@@ -37,40 +40,40 @@ async function uiCommand(options) {
             // Discover Frigg repositories
             console.log(chalk.yellow('Current directory is not a Frigg repository.'));
             console.log(chalk.blue('Searching for Frigg repositories...'));
-            
+
             const discoveredRepos = await discoverFriggRepositories();
-            
+
             if (discoveredRepos.length === 0) {
                 console.log(chalk.red('No Frigg repositories found. Please create one first.'));
                 process.exit(1);
             }
-            
+
             // For UI command, we'll let the UI handle repository selection
             // Set a placeholder and pass the discovered repos via environment
-            targetRepo = { 
-                name: 'Multiple Repositories Available', 
+            targetRepo = {
+                name: 'Multiple Repositories Available',
                 path: process.cwd(),
                 isMultiRepo: true,
                 availableRepos: discoveredRepos
             };
             workingDirectory = process.cwd();
-            
+
             console.log(chalk.blue(`Found ${discoveredRepos.length} Frigg repositories. You'll be able to select one in the UI.`));
         }
     }
 
     console.log(chalk.blue('🚀 Starting Frigg Management UI...'));
-    
+
     const processManager = new ProcessManager();
-    
+
     try {
         const managementUiPath = path.join(__dirname, '../../management-ui');
-        
+
         // Check if we're in development mode
         // For CLI usage, we prefer development mode unless explicitly set to production
         const fs = require('fs');
         const isDevelopment = dev || process.env.NODE_ENV !== 'production';
-        
+
         if (isDevelopment) {
             const env = {
                 ...process.env,
@@ -80,15 +83,15 @@ async function uiCommand(options) {
                 REPOSITORY_INFO: JSON.stringify(targetRepo),
                 AVAILABLE_REPOSITORIES: targetRepo.isMultiRepo ? JSON.stringify(targetRepo.availableRepos) : null
             };
-            
-            // Start backend server
+
+            // Start backend server with nodemon for auto-restart
             processManager.spawnProcess(
                 'backend',
                 'npm',
-                ['run', 'server'],
+                ['run', 'server:dev'],
                 { cwd: managementUiPath, env }
             );
-            
+
             // Start frontend dev server
             processManager.spawnProcess(
                 'frontend',
@@ -96,52 +99,71 @@ async function uiCommand(options) {
                 ['run', 'dev'],
                 { cwd: managementUiPath, env }
             );
-            
-            // Wait for servers to start
-            await new Promise(resolve => setTimeout(resolve, 2000));
-            
+
+            // Wait for backend to be ready by polling health endpoint
+            const maxAttempts = 20;
+            const delayMs = 250;
+            let backendReady = false;
+
+            for (let attempt = 0; attempt < maxAttempts; attempt++) {
+                try {
+                    const response = await fetch(`http://localhost:${port}/api/health`);
+                    if (response.ok) {
+                        backendReady = true;
+                        break;
+                    }
+                } catch (err) {
+                    // Backend not ready yet, wait and retry
+                }
+                await new Promise(resolve => setTimeout(resolve, delayMs));
+            }
+
+            if (!backendReady) {
+                console.warn('⚠️  Backend health check timed out, but continuing anyway...');
+            }
+
             // Display clean status
             processManager.printStatus(
                 'http://localhost:5173',
                 `http://localhost:${port}`,
                 targetRepo.name
             );
-            
+
             // Open browser if requested
-            if (shouldOpen) {
+            if (shouldOpenBrowser) {
                 setTimeout(() => {
                     open('http://localhost:5173');
                 }, 1000);
             }
-            
+
         } else {
             // Production mode - just start the backend server
             const { FriggManagementServer } = await import('../../management-ui/server/index.js');
-            
-            const server = new FriggManagementServer({ 
-                port, 
+
+            const server = new FriggManagementServer({
+                port,
                 projectRoot: workingDirectory,
                 repositoryInfo: targetRepo,
                 availableRepositories: targetRepo.isMultiRepo ? targetRepo.availableRepos : null
             });
             await server.start();
-            
+
             processManager.printStatus(
                 `http://localhost:${port}`,
                 `http://localhost:${port}/api`,
                 targetRepo.name
             );
-            
-            if (shouldOpen) {
+
+            if (shouldOpenBrowser) {
                 setTimeout(() => {
                     open(`http://localhost:${port}`);
                 }, 1000);
             }
         }
-        
+
         // Keep the process running
         process.stdin.resume();
-        
+
     } catch (error) {
         console.error(chalk.red('Failed to start Management UI:'), error.message);
         if (error.code === 'EADDRINUSE') {

package/frigg-cli/utils/__tests__/provider-helper.test.js

@@ -0,0 +1,55 @@
+const path = require('path');
+const { loadProviderForCli, loadCliAppDefinition } = require('../provider-helper');
+
+describe('provider-helper', () => {
+    describe('loadCliAppDefinition', () => {
+        it('returns null when no index.js exists', () => {
+            const result = loadCliAppDefinition('/nonexistent/path');
+            expect(result).toBeNull();
+        });
+
+        it('returns null when index.js has no Definition export', () => {
+            // Use a directory that has an index.js but no Definition
+            const result = loadCliAppDefinition(
+                path.join(__dirname, '..', '..')
+            );
+            // frigg-cli/index.js doesn't export Definition
+            expect(result).toBeNull();
+        });
+    });
+
+    describe('loadProviderForCli', () => {
+        it('returns null when no appDefinition found', () => {
+            // Run from a directory with no Frigg app
+            const originalCwd = process.cwd();
+            try {
+                process.chdir('/tmp');
+                const result = loadProviderForCli();
+                expect(result).toBeNull();
+            } finally {
+                process.chdir(originalCwd);
+            }
+        });
+
+        it('returns null provider for aws (default)', () => {
+            // Mock: loadCliAppDefinition returns an appDef with provider: 'aws'
+            jest.mock('../provider-helper', () => {
+                const original = jest.requireActual('../provider-helper');
+                return {
+                    ...original,
+                    loadProviderForCli: (options) => {
+                        // Simulate AWS provider (no provider field defaults to aws)
+                        return { appDefinition: { provider: 'aws' }, provider: null, providerName: 'aws' };
+                    },
+                };
+            });
+
+            const { loadProviderForCli: mocked } = require('../provider-helper');
+            const result = mocked();
+            expect(result.providerName).toBe('aws');
+            expect(result.provider).toBeNull();
+
+            jest.restoreAllMocks();
+        });
+    });
+});