@aifabrix/builder 2.8.0 → 2.9.0

package/integration/hubspot/hubspot-deploy-deal.json

@@ -0,0 +1,248 @@
+{
+  "key": "hubspot-deal",
+  "displayName": "HubSpot Deal",
+  "description": "HubSpot deals datasource with field mappings for CRM deal data",
+  "systemKey": "hubspot",
+  "entityKey": "deal",
+  "resourceType": "deal",
+  "enabled": true,
+  "version": "1.0.0",
+  "metadataSchema": {
+    "type": "object",
+    "properties": {
+      "id": {
+        "type": "string"
+      },
+      "properties": {
+        "type": "object",
+        "properties": {
+          "dealname": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          },
+          "amount": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          },
+          "deal_currency_code": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          },
+          "dealstage": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          },
+          "pipeline": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          },
+          "closedate": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          },
+          "dealtype": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          },
+          "createdate": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          },
+          "hs_lastmodifieddate": {
+            "type": "object",
+            "properties": {
+              "value": {
+                "type": "string"
+              }
+            }
+          }
+        }
+      },
+      "associations": {
+        "type": "object",
+        "properties": {
+          "companies": {
+            "type": "object",
+            "properties": {
+              "results": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "id": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          },
+          "contacts": {
+            "type": "object",
+            "properties": {
+              "results": {
+                "type": "array",
+                "items": {
+                  "type": "object",
+                  "properties": {
+                    "id": {
+                      "type": "string"
+                    }
+                  }
+                }
+              }
+            }
+          }
+        }
+      }
+    },
+    "required": ["id", "properties"]
+  },
+  "fieldMappings": {
+    "accessFields": ["stage", "pipeline"],
+    "fields": {
+      "id": {
+        "expression": "{{id}}",
+        "type": "string",
+        "description": "Unique deal identifier",
+        "required": true
+      },
+      "dealName": {
+        "expression": "{{properties.dealname.value}} | trim",
+        "type": "string",
+        "description": "Deal name",
+        "required": false
+      },
+      "amount": {
+        "expression": "{{properties.amount.value}}",
+        "type": "string",
+        "description": "Deal amount",
+        "required": false
+      },
+      "currency": {
+        "expression": "{{properties.deal_currency_code.value}} | toUpper | trim",
+        "type": "string",
+        "description": "Currency code",
+        "required": false
+      },
+      "stage": {
+        "expression": "{{properties.dealstage.value}} | trim",
+        "type": "string",
+        "description": "Deal stage for ABAC filtering",
+        "required": false
+      },
+      "pipeline": {
+        "expression": "{{properties.pipeline.value}} | trim",
+        "type": "string",
+        "description": "Pipeline name for ABAC filtering",
+        "required": false
+      },
+      "closeDate": {
+        "expression": "{{properties.closedate.value}}",
+        "type": "string",
+        "description": "Expected close date",
+        "required": false
+      },
+      "dealType": {
+        "expression": "{{properties.dealtype.value}} | trim",
+        "type": "string",
+        "description": "Deal type",
+        "required": false
+      },
+      "associatedCompany": {
+        "expression": "{{associations.companies.results[0].id}}",
+        "type": "string",
+        "description": "Associated company ID",
+        "required": false
+      },
+      "associatedContacts": {
+        "expression": "{{associations.contacts.results}}",
+        "type": "array",
+        "description": "Array of associated contact IDs",
+        "required": false
+      },
+      "createdAt": {
+        "expression": "{{properties.createdate.value}}",
+        "type": "string",
+        "description": "Creation timestamp",
+        "required": false
+      },
+      "updatedAt": {
+        "expression": "{{properties.hs_lastmodifieddate.value}}",
+        "type": "string",
+        "description": "Last modification timestamp",
+        "required": false
+      }
+    }
+  },
+  "exposed": {
+    "fields": ["id", "dealName", "amount", "currency", "stage", "pipeline", "closeDate", "dealType", "associatedCompany", "associatedContacts", "createdAt", "updatedAt"],
+    "description": "Exposed fields for HubSpot deals"
+  },
+  "openapi": {
+    "enabled": true,
+    "documentKey": "hubspot-v3",
+    "baseUrl": "https://api.hubapi.com",
+    "operations": {
+      "list": {
+        "operationId": "getDeals",
+        "method": "GET",
+        "path": "/crm/v3/objects/deals"
+      },
+      "get": {
+        "operationId": "getDeal",
+        "method": "GET",
+        "path": "/crm/v3/objects/deals/{dealId}"
+      },
+      "create": {
+        "operationId": "createDeal",
+        "method": "POST",
+        "path": "/crm/v3/objects/deals"
+      },
+      "update": {
+        "operationId": "updateDeal",
+        "method": "PATCH",
+        "path": "/crm/v3/objects/deals/{dealId}"
+      },
+      "delete": {
+        "operationId": "deleteDeal",
+        "method": "DELETE",
+        "path": "/crm/v3/objects/deals/{dealId}"
+      }
+    },
+    "autoRbac": true
+  }
+}
+

package/integration/hubspot/hubspot-deploy.json

@@ -0,0 +1,91 @@
+{
+  "key": "hubspot",
+  "displayName": "HubSpot CRM",
+  "description": "HubSpot CRM integration with OpenAPI support for companies, contacts, and deals",
+  "type": "openapi",
+  "enabled": true,
+  "environment": {
+    "baseUrl": "https://api.hubapi.com"
+  },
+  "authentication": {
+    "type": "oauth2",
+    "mode": "oauth2",
+    "oauth2": {
+      "tokenUrl": "{{TOKENURL}}",
+      "clientId": "{{CLIENTID}}",
+      "clientSecret": "{{CLIENTSECRET}}",
+      "scopes": [
+        "crm.objects.companies.read",
+        "crm.objects.companies.write",
+        "crm.objects.contacts.read",
+        "crm.objects.contacts.write",
+        "crm.objects.deals.read",
+        "crm.objects.deals.write"
+      ]
+    }
+  },
+  "configuration": [
+    {
+      "name": "CLIENTID",
+      "value": "hubspot-clientidKeyVault",
+      "location": "keyvault",
+      "required": true
+    },
+    {
+      "name": "CLIENTSECRET",
+      "value": "hubspot-clientsecretKeyVault",
+      "location": "keyvault",
+      "required": true
+    },
+    {
+      "name": "TOKENURL",
+      "value": "https://api.hubapi.com/oauth/v1/token",
+      "location": "variable",
+      "required": true
+    },
+    {
+      "name": "REDIRECT_URI",
+      "value": "hubspot-redirect-uriKeyVault",
+      "location": "keyvault",
+      "required": false
+    },
+    {
+      "name": "HUBSPOT_API_VERSION",
+      "value": "v3",
+      "location": "variable",
+      "required": false,
+      "portalInput": {
+        "field": "select",
+        "label": "HubSpot API Version",
+        "placeholder": "Select API version",
+        "options": ["v1", "v2", "v3"],
+        "validation": {
+          "required": false
+        }
+      }
+    },
+    {
+      "name": "MAX_PAGE_SIZE",
+      "value": "100",
+      "location": "variable",
+      "required": false,
+      "portalInput": {
+        "field": "text",
+        "label": "Maximum Page Size",
+        "placeholder": "100",
+        "validation": {
+          "required": false,
+          "pattern": "^[0-9]+$",
+          "min": 1,
+          "max": 1000
+        }
+      }
+    }
+  ],
+  "openapi": {
+    "documentKey": "hubspot-v3",
+    "autoDiscoverEntities": false
+  },
+  "tags": ["crm", "sales", "marketing", "hubspot"]
+}
+

package/integration/hubspot/variables.yaml

@@ -0,0 +1,17 @@
+app:
+  key: hubspot
+  displayName: "HubSpot CRM Integration"
+  description: "HubSpot CRM external system integration with companies, contacts, and deals"
+  type: external
+
+externalIntegration:
+  schemaBasePath: ./
+  systems:
+    - hubspot-deploy.json
+  dataSources:
+    - hubspot-deploy-company.json
+    - hubspot-deploy-contact.json
+    - hubspot-deploy-deal.json
+  autopublish: true
+  version: 1.0.0
+

package/lib/app-config.js

@@ -99,14 +99,14 @@ async function generateRbacYamlFile(appPath, appName, config) {
 }
 
 /**
- * Generates aifabrix-deploy.json file
+ * Generates <app-name>-deploy.json file (consistent naming for all apps)
  * @async
  * @param {string} appPath - Path to application directory
  * @param {string} appName - Application name
  * @param {Object} config - Application configuration
  */
 async function generateDeployJsonFile(appPath, appName, config) {
-  // Skip aifabrix-deploy.json for external type (uses pipeline API instead)
+  // Skip for external type (external system JSON is generated separately)
   if (config.type === 'external') {
     return;
   }
@@ -138,8 +138,9 @@ async function generateDeployJsonFile(appPath, appName, config) {
     }
   };
 
+  // Use consistent naming: <app-name>-deploy.json
   await fs.writeFile(
-    path.join(appPath, 'aifabrix-deploy.json'),
+    path.join(appPath, `${appName}-deploy.json`),
     JSON.stringify(deployJson, null, 2)
   );
 }

package/lib/app-deploy.js

@@ -17,6 +17,7 @@ const pushUtils = require('./push');
 const logger = require('./utils/logger');
 const config = require('./config');
 const { getDeploymentAuth } = require('./utils/token-manager');
+const { detectAppType } = require('./utils/paths');
 
 /**
  * Validate application name format
@@ -215,10 +216,11 @@ function validateDeploymentConfig(deploymentConfig) {
  * @throws {Error} If configuration is invalid
  */
 async function loadDeploymentConfig(appName, options) {
-  const builderPath = path.join(process.cwd(), 'builder', appName);
-  await validateAppDirectory(builderPath, appName);
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appName);
+  await validateAppDirectory(appPath, appName);
 
-  const variablesPath = path.join(builderPath, 'variables.yaml');
+  const variablesPath = path.join(appPath, 'variables.yaml');
   const variables = await loadVariablesFile(variablesPath);
 
   const deploymentConfig = extractDeploymentConfig(options, variables);
@@ -366,23 +368,9 @@ async function deployApp(appName, options = {}) {
 
     validateAppName(appName);
 
-    // 2. Check if app type is external - route to external deployment
-    const yaml = require('js-yaml');
-    const fs = require('fs').promises;
-    const path = require('path');
-    const variablesPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
-    try {
-      const variablesContent = await fs.readFile(variablesPath, 'utf8');
-      const variables = yaml.load(variablesContent);
-      if (variables.app && variables.app.type === 'external') {
-        const externalDeploy = require('./external-system-deploy');
-        await externalDeploy.deployExternalSystem(appName, options);
-        return { success: true, type: 'external' };
-      }
-    } catch (error) {
-      // If variables.yaml doesn't exist or can't be read, continue with normal deployment
-      // The error will be properly handled in loadDeploymentConfig
-    }
+    // 2. Check if app type is external - use normal deployment flow with application-schema.json
+    // External systems now deploy via miso controller as normal application (full application file)
+    // The json command generates application-schema.json which is used for deployment
 
     // 2. Load deployment configuration
     config = await loadDeploymentConfig(appName, options);

package/lib/app-dockerfile.js

@@ -85,25 +85,23 @@ async function generateAndCopyDockerfile(appPath, dockerfilePath, config) {
  */
 async function generateDockerfileForApp(appName, options = {}) {
   // Check if app type is external - skip Dockerfile generation
-  const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  const { detectAppType } = require('./utils/paths');
   try {
-    const yamlContent = await fs.readFile(configPath, 'utf8');
-    const variables = yaml.load(yamlContent);
-    if (variables.app && variables.app.type === 'external') {
+    const { isExternal } = await detectAppType(appName);
+    if (isExternal) {
       logger.log(chalk.yellow('⚠️  External systems don\'t require Dockerfiles. Skipping...'));
       return null;
     }
   } catch (error) {
-    // If variables.yaml doesn't exist, continue with normal generation
-    if (error.code !== 'ENOENT') {
-      throw error;
-    }
+    // If detection fails, continue with normal generation
+    // (detectAppType throws if app doesn't exist, which is fine for dockerfile command)
   }
   try {
     // Validate app name
     validateAppName(appName);
 
-    const appPath = path.join(process.cwd(), 'builder', appName);
+    // Detect app type and get correct path (integration or builder)
+    const { appPath } = await detectAppType(appName);
     const dockerfilePath = path.join(appPath, 'Dockerfile');
 
     // Check if Dockerfile already exists

package/lib/app-prompts.js

@@ -364,11 +364,6 @@ function mergePromptAnswers(appName, options, answers) {
  * @returns {Promise<Object>} Complete configuration
  */
 async function promptForOptions(appName, options) {
-  // Default github to false if not provided (make it truly optional)
-  if (!Object.prototype.hasOwnProperty.call(options, 'github')) {
-    options.github = false;
-  }
-
   // Get app type from options (default to webapp)
   const appType = options.type || 'webapp';
 
@@ -398,6 +393,12 @@ async function promptForOptions(appName, options) {
   // Add type to merged config
   merged.type = appType;
 
+  // For external type, remove port and language as they're not applicable
+  if (appType === 'external') {
+    delete merged.port;
+    delete merged.language;
+  }
+
   return merged;
 }
 

package/lib/app-push.js

@@ -69,7 +69,10 @@ function extractImageName(config, appName) {
  * @throws {Error} If configuration cannot be loaded
  */
 async function loadPushConfig(appName, options) {
-  const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { detectAppType } = require('./utils/paths');
+  const { appPath } = await detectAppType(appName);
+  const configPath = path.join(appPath, 'variables.yaml');
   try {
     const config = yaml.load(await fs.readFile(configPath, 'utf8'));
     const registry = options.registry || config.image?.registry;
@@ -180,19 +183,16 @@ function displayPushResults(registry, imageName, tags) {
  */
 async function pushApp(appName, options = {}) {
   // Check if app type is external - skip push
-  const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+  const { detectAppType } = require('./utils/paths');
   try {
-    const yamlContent = await fs.readFile(configPath, 'utf8');
-    const config = yaml.load(yamlContent);
-    if (config.app && config.app.type === 'external') {
+    const { isExternal } = await detectAppType(appName);
+    if (isExternal) {
       logger.log(chalk.yellow('⚠️  External systems don\'t require Docker images. Skipping push...'));
       return;
     }
   } catch (error) {
-    // If variables.yaml doesn't exist, continue with normal push
-    if (error.code !== 'ENOENT') {
-      throw error;
-    }
+    // If detection fails, continue with normal push
+    // (detectAppType throws if app doesn't exist, which is fine for push command)
   }
   try {
     // Validate app name

package/lib/app-register.js

@@ -19,6 +19,8 @@ const logger = require('./utils/logger');
 const { saveLocalSecret, isLocalhost } = require('./utils/local-secrets');
 const { updateEnvTemplate } = require('./utils/env-template');
 const { getOrRefreshDeviceToken } = require('./utils/token-manager');
+const { detectAppType } = require('./utils/paths');
+const { generateEnvFile } = require('./secrets');
 
 // Import createApp to auto-generate config if missing
 let createApp;
@@ -86,7 +88,9 @@ const registerApplicationSchema = {
  * @returns {Promise<{variables: Object, created: boolean}>} Variables and creation flag
  */
 async function loadVariablesYaml(appKey) {
-  const variablesPath = path.join(process.cwd(), 'builder', appKey, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appKey);
+  const variablesPath = path.join(appPath, 'variables.yaml');
 
   try {
     const variablesContent = await fs.readFile(variablesPath, 'utf-8');
@@ -122,7 +126,9 @@ async function createMinimalAppIfNeeded(appKey, options) {
     authentication: false
   });
 
-  const variablesPath = path.join(process.cwd(), 'builder', appKey, 'variables.yaml');
+  // Detect app type and get correct path (integration or builder)
+  const { appPath } = await detectAppType(appKey);
+  const variablesPath = path.join(appPath, 'variables.yaml');
   const variablesContent = await fs.readFile(variablesPath, 'utf-8');
   return yaml.load(variablesContent);
 }
@@ -170,11 +176,12 @@ function extractAppConfiguration(variables, appKey, options) {
 
 /**
  * Validate application registration data
+ * @async
  * @param {Object} config - Application configuration
  * @param {string} originalAppKey - Original app key for error messages
  * @throws {Error} If validation fails
  */
-function validateAppRegistrationData(config, originalAppKey) {
+async function validateAppRegistrationData(config, originalAppKey) {
   const missingFields = [];
   if (!config.appKey) missingFields.push('app.key');
   if (!config.displayName) missingFields.push('app.name');
@@ -182,7 +189,10 @@ function validateAppRegistrationData(config, originalAppKey) {
   if (missingFields.length > 0) {
     logger.error(chalk.red('❌ Missing required fields in variables.yaml:'));
     missingFields.forEach(field => logger.error(chalk.red(`   - ${field}`)));
-    logger.error(chalk.red(`\n   Please update builder/${originalAppKey}/variables.yaml and try again.`));
+    // Detect app type to show correct path
+    const { appPath } = await detectAppType(originalAppKey);
+    const relativePath = path.relative(process.cwd(), appPath);
+    logger.error(chalk.red(`\n   Please update ${relativePath}/variables.yaml and try again.`));
     process.exit(1);
   }
 
@@ -382,7 +392,7 @@ async function registerApplication(appKey, options) {
   const appConfig = extractAppConfiguration(finalVariables, appKey, options);
 
   // Validate configuration (pass original appKey for error messages)
-  validateAppRegistrationData(appConfig, appKey);
+  await validateAppRegistrationData(appConfig, appKey);
 
   // Get controller URL from variables.yaml if available
   const controllerUrl = finalVariables?.deployment?.controllerUrl;
@@ -434,6 +444,14 @@ async function registerApplication(appKey, options) {
       // Update env.template
       await updateEnvTemplate(registeredAppKey, clientIdKey, clientSecretKey, authConfig.apiUrl);
 
+      // Regenerate .env file with updated credentials
+      try {
+        await generateEnvFile(registeredAppKey, null, 'local');
+        logger.log(chalk.green('✓ .env file updated with new credentials'));
+      } catch (error) {
+        logger.warn(chalk.yellow(`⚠️  Could not regenerate .env file: ${error.message}`));
+      }
+
       logger.log(chalk.green('\n✓ Credentials saved to ~/.aifabrix/secrets.local.yaml'));
       logger.log(chalk.green('✓ env.template updated with MISO_CLIENTID, MISO_CLIENTSECRET, and MISO_CONTROLLER_URL\n'));
     } catch (error) {

package/lib/app-rotate-secret.js

@@ -17,6 +17,7 @@ const logger = require('./utils/logger');
 const { saveLocalSecret, isLocalhost } = require('./utils/local-secrets');
 const { updateEnvTemplate } = require('./utils/env-template');
 const { getEnvironmentPrefix } = require('./app-register');
+const { generateEnvFile } = require('./secrets');
 
 /**
  * Validate environment parameter
@@ -147,6 +148,15 @@ async function rotateSecret(appKey, options) {
     // Update env.template if localhost
     if (isLocalhost(controllerUrl)) {
       await updateEnvTemplate(appKey, clientIdKey, clientSecretKey, controllerUrl);
+
+      // Regenerate .env file with updated credentials
+      try {
+        await generateEnvFile(appKey, null, 'local');
+        logger.log(chalk.green('✓ .env file updated with new credentials'));
+      } catch (error) {
+        logger.warn(chalk.yellow(`⚠️  Could not regenerate .env file: ${error.message}`));
+      }
+
       logger.log(chalk.green('\n✓ Credentials saved to ~/.aifabrix/secrets.local.yaml'));
       logger.log(chalk.green('✓ env.template updated with MISO_CLIENTID, MISO_CLIENTSECRET, and MISO_CONTROLLER_URL\n'));
     } else {

package/lib/app-run.js

@@ -49,23 +49,17 @@ async function runApp(appName, options = {}) {
     }
 
     // Check if app type is external - skip Docker run
-    const yaml = require('js-yaml');
-    const fs = require('fs').promises;
-    const path = require('path');
-    const variablesPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
+    const { detectAppType } = require('./utils/paths');
     try {
-      const variablesContent = await fs.readFile(variablesPath, 'utf8');
-      const variables = yaml.load(variablesContent);
-      if (variables.app && variables.app.type === 'external') {
+      const { isExternal } = await detectAppType(appName);
+      if (isExternal) {
         logger.log(chalk.yellow('⚠️  External systems don\'t run as Docker containers.'));
         logger.log(chalk.blue('Use "aifabrix build" to deploy to dataplane, then test via OpenAPI endpoints.'));
         return;
       }
     } catch (error) {
-      // If variables.yaml doesn't exist, continue with normal run
-      if (error.code !== 'ENOENT') {
-        throw error;
-      }
+      // If detection fails, continue with normal run
+      // (detectAppType throws if app doesn't exist, which is fine for run command)
     }
 
     // Validate app name and load configuration