@aifabrix/builder 2.33.0 → 2.33.1

package/integration/hubspot/README.md

@@ -52,15 +52,15 @@ aifabrix validate hubspot
 aifabrix login --controller http://localhost:3100 --method device --environment dev
 
 # Register application
-aifabrix app register hubspot --environment dev
+aifabrix app register hubspot
 
 # Deploy entire system
-aifabrix deploy hubspot --controller http://localhost:3100 --environment dev
+aifabrix deploy hubspot
 
 # Or deploy individual datasources for testing
-aifabrix datasource deploy hubspot-company --environment dev --file integration/hubspot/hubspot-datasource-company.json
-aifabrix datasource deploy hubspot-contact --environment dev --file integration/hubspot/hubspot-datasource-contact.json
-aifabrix datasource deploy hubspot-deal --environment dev --file integration/hubspot/hubspot-datasource-deal.json
+aifabrix datasource deploy hubspot-company --file integration/hubspot/hubspot-datasource-company.json
+aifabrix datasource deploy hubspot-contact --file integration/hubspot/hubspot-datasource-contact.json
+aifabrix datasource deploy hubspot-deal --file integration/hubspot/hubspot-datasource-deal.json
 ```
 
 ## Field Mappings
@@ -122,10 +122,10 @@ RBAC permissions are auto-generated: `hubspot.company.list`, `hubspot.company.ge
 
 ```bash
 # List datasources
-aifabrix datasource list --environment dev
+aifabrix datasource list
 
 # Validate specific datasource
-aifabrix datasource validate hubspot-company --environment dev
+aifabrix datasource validate hubspot-company
 ```
 
 ## Documentation

package/lib/api/index.js

@@ -22,10 +22,14 @@ class ApiClient {
    * @param {string} [authConfig.clientSecret] - Client secret
    */
   constructor(baseUrl, authConfig = {}) {
-    if (!baseUrl || typeof baseUrl !== 'string') {
+    if (baseUrl === null || baseUrl === undefined || typeof baseUrl !== 'string') {
       throw new Error('baseUrl is required and must be a string');
     }
-    this.baseUrl = baseUrl.replace(/\/$/, ''); // Remove trailing slash
+    const trimmedUrl = baseUrl.trim().replace(/\/$/, ''); // Trim and remove trailing slash
+    if (!trimmedUrl) {
+      throw new Error('baseUrl cannot be empty. Please provide a valid URL.');
+    }
+    this.baseUrl = trimmedUrl;
     this.authConfig = authConfig;
   }
 

package/lib/datasource/deploy.js

@@ -118,10 +118,27 @@ async function setupDeploymentAuth(controllerUrl, environment, appKey) {
   logger.log(chalk.green('✓ Authentication successful'));
 
   logger.log(chalk.blue('🌐 Resolving dataplane URL...'));
-  const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
-  logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+  let dataplaneUrl;
+  try {
+    dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+    logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
+  } catch (error) {
+    logger.error(chalk.red('❌ Failed to resolve dataplane URL:'), error.message);
+    logger.error(chalk.gray('\nThe dataplane URL is automatically discovered from the controller.'));
+    logger.error(chalk.gray('If discovery fails, ensure you are logged in and the controller is accessible:'));
+    logger.error(chalk.gray('   aifabrix login'));
+    throw error;
+  }
+
+  // Validate dataplane URL
+  if (!dataplaneUrl || !dataplaneUrl.trim()) {
+    logger.error(chalk.red('❌ Dataplane URL is empty.'));
+    logger.error(chalk.gray('The dataplane URL could not be discovered from the controller.'));
+    logger.error(chalk.gray('Ensure the dataplane service is registered in the controller.'));
+    throw new Error('Dataplane URL is empty');
+  }
 
-  return { authConfig, dataplaneUrl };
+  return { authConfig, dataplaneUrl: dataplaneUrl.trim() };
 }
 
 /**
@@ -143,6 +160,17 @@ async function publishDatasourceToDataplane(dataplaneUrl, systemKey, authConfig,
     const formattedError = publishResponse.formattedError || formatApiError(publishResponse);
     logger.error(chalk.red('❌ Publish failed:'));
     logger.error(formattedError);
+
+    // Show dataplane URL and endpoint information
+    if (publishResponse.errorData && publishResponse.errorData.endpointUrl) {
+      logger.error(chalk.gray(`\nEndpoint URL: ${publishResponse.errorData.endpointUrl}`));
+    } else if (dataplaneUrl) {
+      logger.error(chalk.gray(`\nDataplane URL: ${dataplaneUrl}`));
+      logger.error(chalk.gray(`System Key: ${systemKey}`));
+    }
+
+    logger.error(chalk.gray('\nFull response for debugging:'));
+    logger.error(chalk.gray(JSON.stringify(publishResponse, null, 2)));
     throw new Error(`Dataplane publish failed: ${formattedError}`);
   }
 

package/lib/datasource/list.js

@@ -1,7 +1,8 @@
 /**
  * Datasource List Command
  *
- * Lists datasources from an environment via controller API.
+ * Lists datasources from an environment via dataplane API.
+ * Gets dataplane URL from controller, then lists datasources from dataplane.
  *
  * @fileoverview Datasource listing for AI Fabrix Builder
  * @author AI Fabrix Team
@@ -11,7 +12,8 @@
 const chalk = require('chalk');
 const { getConfig, resolveEnvironment } = require('../core/config');
 const { getOrRefreshDeviceToken } = require('../utils/token-manager');
-const { listEnvironmentDatasources } = require('../api/environments.api');
+const { listDatasources: listDatasourcesFromDataplane } = require('../api/datasources-core.api');
+const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
 const { formatApiError } = require('../utils/api-error-handler');
 const logger = require('../utils/logger');
 
@@ -103,14 +105,19 @@ function extractDatasources(response) {
  * @function displayDatasources
  * @param {Array} datasources - Array of datasource objects
  * @param {string} environment - Environment key
+ * @param {string} dataplaneUrl - Dataplane URL for header display
  */
-function displayDatasources(datasources, environment) {
+function displayDatasources(datasources, environment, dataplaneUrl) {
+  const environmentName = environment || 'dev';
+  const header = `Datasources in ${environmentName} environment${dataplaneUrl ? ` (${dataplaneUrl})` : ''}`;
+
   if (datasources.length === 0) {
-    logger.log(chalk.yellow(`\nNo datasources found in environment: ${environment}`));
+    logger.log(chalk.bold(`\n📋 ${header}:\n`));
+    logger.log(chalk.gray('  No datasources found in this environment.\n'));
     return;
   }
 
-  logger.log(chalk.blue(`\n📋 Datasources in environment: ${environment}\n`));
+  logger.log(chalk.bold(`\n📋 ${header}:\n`));
   logger.log(chalk.gray('Key'.padEnd(30) + 'Display Name'.padEnd(30) + 'System Key'.padEnd(20) + 'Version'.padEnd(15) + 'Status'));
   logger.log(chalk.gray('-'.repeat(120)));
 
@@ -169,7 +176,7 @@ async function getDeviceTokenFromConfig(config) {
  * @param {string|null} controllerUrl - Controller URL
  */
 function validateDatasourceListingAuth(token, controllerUrl) {
-  if (!token || !controllerUrl) {
+  if (!token || !controllerUrl || (typeof controllerUrl === 'string' && !controllerUrl.trim())) {
     logger.error(chalk.red('❌ Not logged in. Run: aifabrix login'));
     logger.error(chalk.gray('   Use device code flow: aifabrix login --method device --controller <url>'));
     process.exit(1);
@@ -181,14 +188,92 @@ function validateDatasourceListingAuth(token, controllerUrl) {
  * @function handleDatasourceApiError
  * @param {Object} response - API response
  */
-function handleDatasourceApiError(response) {
+function handleDatasourceApiError(response, dataplaneUrl = null) {
   const formattedError = response.formattedError || formatApiError(response);
   logger.error(formattedError);
+
+  // Show endpoint URL from error data if available (more specific than dataplane URL)
+  if (response.errorData && response.errorData.endpointUrl) {
+    logger.error(chalk.gray(`\nEndpoint URL: ${response.errorData.endpointUrl}`));
+  } else if (response.errorData && response.errorData.controllerUrl) {
+    logger.error(chalk.gray(`\nDataplane URL: ${response.errorData.controllerUrl}`));
+  } else if (dataplaneUrl) {
+    logger.error(chalk.gray(`\nDataplane URL: ${dataplaneUrl}`));
+  }
+
   logger.error(chalk.gray('\nFull response for debugging:'));
   logger.error(chalk.gray(JSON.stringify(response, null, 2)));
   process.exit(1);
 }
 
+/**
+ * Validates and trims controller URL
+ * @function validateControllerUrl
+ * @param {string} controllerUrl - Controller URL to validate
+ * @returns {string} Trimmed controller URL
+ */
+function validateControllerUrl(controllerUrl) {
+  const trimmed = controllerUrl.trim();
+  if (!trimmed) {
+    logger.error(chalk.red('❌ Controller URL is empty.'));
+    logger.error(chalk.gray(`   Controller URL from config: ${JSON.stringify(controllerUrl)}`));
+    logger.error(chalk.gray('   Run: aifabrix login --method device --controller <url>'));
+    process.exit(1);
+  }
+  return trimmed;
+}
+
+/**
+ * Resolves and validates dataplane URL from controller
+ * @async
+ * @function resolveAndValidateDataplaneUrl
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} environment - Environment key
+ * @param {Object} authConfig - Authentication configuration
+ * @returns {Promise<string>} Validated dataplane URL
+ */
+async function resolveAndValidateDataplaneUrl(controllerUrl, environment, authConfig) {
+  let dataplaneUrl;
+  try {
+    // discoverDataplaneUrl already logs progress and success messages
+    dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
+  } catch (error) {
+    logger.error(chalk.red('❌ Failed to resolve dataplane URL:'), error.message);
+    logger.error(chalk.gray('\nThe dataplane URL is automatically discovered from the controller.'));
+    logger.error(chalk.gray('If discovery fails, ensure you are logged in and the controller is accessible:'));
+    logger.error(chalk.gray('   aifabrix login'));
+    process.exit(1);
+    // eslint-disable-next-line no-unreachable
+    throw error; // Never reached in production, but needed for tests when process.exit is mocked
+  }
+
+  if (!dataplaneUrl || typeof dataplaneUrl !== 'string' || !dataplaneUrl.trim()) {
+    logger.error(chalk.red('❌ Dataplane URL is empty.'));
+    logger.error(chalk.gray('The dataplane URL could not be discovered from the controller.'));
+    logger.error(chalk.gray('Ensure the dataplane service is registered in the controller.'));
+    process.exit(1);
+    // eslint-disable-next-line no-unreachable
+    throw new Error('Dataplane URL is empty'); // Never reached in production, but needed for tests
+  }
+
+  return dataplaneUrl.trim();
+}
+
+/**
+ * Sets up authentication configuration for dataplane API calls
+ * @function setupAuthConfig
+ * @param {string} token - Authentication token
+ * @param {string} controllerUrl - Controller URL
+ * @returns {Object} Authentication configuration
+ */
+function setupAuthConfig(token, controllerUrl) {
+  return {
+    type: 'bearer',
+    token: token,
+    controller: controllerUrl
+  };
+}
+
 async function listDatasources(_options) {
   const config = await getConfig();
 
@@ -199,22 +284,24 @@ async function listDatasources(_options) {
   const authInfo = await getDeviceTokenFromConfig(config);
   validateDatasourceListingAuth(authInfo?.token, authInfo?.controllerUrl);
 
-  // Call controller API using centralized API client
-  // Note: validateDatasourceListingAuth will exit if auth is missing, so this check is defensive
   if (!authInfo || !authInfo.token || !authInfo.controllerUrl) {
-    validateDatasourceListingAuth(null, null); // This will exit
-    return; // Never reached, but satisfies linter
+    validateDatasourceListingAuth(null, null);
+    return;
   }
-  const authConfig = { type: 'bearer', token: authInfo.token };
-  const response = await listEnvironmentDatasources(authInfo.controllerUrl, environment, authConfig);
+
+  const controllerUrl = validateControllerUrl(authInfo.controllerUrl);
+  const authConfig = setupAuthConfig(authInfo.token, controllerUrl);
+  const dataplaneUrl = await resolveAndValidateDataplaneUrl(controllerUrl, environment, authConfig);
+
+  const response = await listDatasourcesFromDataplane(dataplaneUrl, authConfig);
 
   if (!response.success || !response.data) {
-    handleDatasourceApiError(response);
+    handleDatasourceApiError(response, dataplaneUrl);
     return; // Ensure we don't continue after exit
   }
 
   const datasources = extractDatasources(response);
-  displayDatasources(datasources, environment);
+  displayDatasources(datasources, environment, dataplaneUrl);
 }
 
 module.exports = {

package/lib/utils/api.js

@@ -131,6 +131,32 @@ async function handleSuccessResponse(response, url, options, duration) {
   return { success: true, data: text, status: response.status };
 }
 
+/**
+ * Validates that a URL is not empty or missing
+ * @function validateUrl
+ * @param {string} url - URL to validate
+ * @param {string} [urlType='URL'] - Type of URL for error message (e.g., 'Dataplane URL', 'Controller URL')
+ * @returns {void}
+ * @throws {Error} If URL is empty, null, undefined, whitespace-only, or malformed
+ */
+function validateUrl(url, urlType = 'URL') {
+  if (!url || typeof url !== 'string') {
+    throw new Error(`${urlType} is required and must be a string (received: ${JSON.stringify(url)})`);
+  }
+  const trimmedUrl = url.trim();
+  if (!trimmedUrl) {
+    throw new Error(`${urlType} cannot be empty. Please provide a valid URL.`);
+  }
+  // Check for common invalid URL patterns
+  if (trimmedUrl === 'undefined' || trimmedUrl === 'null' || trimmedUrl === 'NaN') {
+    throw new Error(`${urlType} is invalid: "${trimmedUrl}". Please provide a valid URL.`);
+  }
+  // Basic URL format validation - must start with http:// or https://
+  if (!trimmedUrl.match(/^https?:\/\//i)) {
+    throw new Error(`${urlType} must be a valid HTTP/HTTPS URL (received: "${trimmedUrl}")`);
+  }
+}
+
 /**
  * Handles network error from API call
  * @async
@@ -142,7 +168,34 @@ async function handleSuccessResponse(response, url, options, duration) {
  * @returns {Promise<Object>} Error response object
  */
 async function handleNetworkError(error, url, options, duration) {
-  const parsedError = parseErrorResponse(error.message, 0, true);
+  // Enhance error message with URL information if URL is missing or invalid
+  let errorMessage = error.message;
+  if (errorMessage && (errorMessage.includes('cannot be empty') || errorMessage.includes('is required'))) {
+    // Add URL context to validation errors
+    if (!url || !url.trim()) {
+      errorMessage = `${errorMessage} (URL was: ${JSON.stringify(url)})`;
+    } else {
+      errorMessage = `${errorMessage} (URL was: ${url})`;
+    }
+  } else if (!url || !url.trim()) {
+    // If URL is empty but error doesn't mention it, add context
+    errorMessage = `Invalid or missing URL. ${errorMessage} (URL was: ${JSON.stringify(url)})`;
+  }
+
+  const parsedError = parseErrorResponse(errorMessage, 0, true);
+
+  // Extract controller URL from full URL for error data
+  let controllerUrl = null;
+  const endpointUrl = url;
+  if (url && typeof url === 'string' && url.trim()) {
+    try {
+      const urlObj = new URL(url);
+      controllerUrl = `${urlObj.protocol}//${urlObj.host}`;
+    } catch {
+      // If URL parsing fails, use the full URL as endpoint
+      controllerUrl = null;
+    }
+  }
 
   await logApiPerformance({
     url,
@@ -157,10 +210,17 @@ async function handleNetworkError(error, url, options, duration) {
     }
   });
 
+  // Include both controller URL and full endpoint URL in error data
+  const errorData = {
+    ...parsedError.data,
+    controllerUrl: controllerUrl,
+    endpointUrl: endpointUrl
+  };
+
   return {
     success: false,
     error: parsedError.message,
-    errorData: parsedError.data,
+    errorData: errorData,
     errorType: parsedError.type,
     formattedError: parsedError.formatted,
     network: true
@@ -175,6 +235,14 @@ async function handleNetworkError(error, url, options, duration) {
  * @returns {Promise<Object>} Response object with success flag
  */
 async function makeApiCall(url, options = {}) {
+  // Validate URL before attempting request
+  try {
+    validateUrl(url, 'API endpoint URL');
+  } catch (error) {
+    const duration = 0;
+    return await handleNetworkError(error, url || '', options, duration);
+  }
+
   const startTime = Date.now();
   const fetchOptions = { ...options };
   if (!fetchOptions.signal) {

package/lib/utils/error-formatters/network-errors.js

@@ -40,7 +40,10 @@ function addControllerUrlHeader(lines, errorData) {
  * @param {Object} errorData - Error response data
  */
 function addControllerUrlToMessage(lines, errorData) {
-  if (errorData && errorData.controllerUrl) {
+  // Prefer showing full endpoint URL if available
+  if (errorData && errorData.endpointUrl) {
+    lines.push(chalk.gray(`Endpoint URL: ${errorData.endpointUrl}`));
+  } else if (errorData && errorData.controllerUrl) {
     lines.push(chalk.gray(`Controller URL: ${errorData.controllerUrl}`));
   }
 }
@@ -77,8 +80,15 @@ function formatHostnameNotFoundError(lines, errorData) {
  */
 function formatTimeoutError(lines, errorData) {
   lines.push(chalk.yellow('Request timed out.'));
-  addControllerUrlToMessage(lines, errorData);
-  lines.push(chalk.gray('The controller may be overloaded.'));
+
+  // Show full endpoint URL if available, otherwise show controller URL
+  if (errorData && errorData.endpointUrl) {
+    lines.push(chalk.gray(`Endpoint URL: ${errorData.endpointUrl}`));
+  } else if (errorData && errorData.controllerUrl) {
+    lines.push(chalk.gray(`Controller URL: ${errorData.controllerUrl}`));
+  }
+
+  lines.push(chalk.gray('The endpoint may not exist, the controller may be overloaded, or there may be a network issue.'));
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.33.0",
+  "version": "2.33.1",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {

package/templates/github/ci.yaml.hbs

@@ -12,4 +12,47 @@ jobs:
         with:
           node-version: '20'
       - name: Run tests
-        run: npm test
+        run: npm test
+
+  deploy:
+    name: Deploy to AI Fabrix
+    runs-on: ubuntu-latest
+    needs: test
+    # Note: This workflow deploys to ACR (Azure Container Registry) and Azure
+    # For local deployment, use 'aifabrix deploy {{appName}}' directly from your machine
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      
+      - name: Install AI Fabrix Builder
+        run: npm install -g @aifabrix/builder
+      
+      - name: Authenticate with Controller
+        run: |
+          set -e
+          aifabrix login \
+            --method credentials \
+            --app {{appName}} \
+            --client-id ${{ secrets.DEV_MISO_CLIENTID }} \
+            --client-secret ${{ secrets.DEV_MISO_CLIENTSECRET }} \
+            --controller ${{ secrets.MISO_CONTROLLER_URL }} \
+            --environment dev
+      
+      - name: Validate Application Manifest
+        run: |
+          set -e
+          aifabrix validate {{appName}}
+      
+      - name: Build Docker Image
+        run: |
+          set -e
+          aifabrix build {{appName}} --tag ${{ github.sha }}
+      
+      - name: Deploy Application
+        run: |
+          set -e
+          aifabrix deploy {{appName}}

package/templates/github/release.yaml.hbs

@@ -56,3 +56,47 @@ jobs:
           body: Release {{appName}} ${{ github.ref }}
           draft: false
           prerelease: false
+
+  deploy:
+    name: Deploy to AI Fabrix
+    runs-on: ubuntu-latest
+    needs: create-release
+    # Note: This workflow deploys to ACR (Azure Container Registry) and Azure
+    # For local deployment, use 'aifabrix deploy {{appName}}' directly from your machine
+    steps:
+      - uses: actions/checkout@v4
+      
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+      
+      - name: Install AI Fabrix Builder
+        run: npm install -g @aifabrix/builder
+      
+      - name: Authenticate with Controller
+        run: |
+          set -e
+          aifabrix login \
+            --method credentials \
+            --app {{appName}} \
+            --client-id ${{ secrets.PRO_MISO_CLIENTID }} \
+            --client-secret ${{ secrets.PRO_MISO_CLIENTSECRET }} \
+            --controller ${{ secrets.MISO_CONTROLLER_URL }} \
+            --environment pro
+      
+      - name: Validate Application Manifest
+        run: |
+          set -e
+          aifabrix validate {{appName}}
+      
+      - name: Build Docker Image
+        run: |
+          set -e
+          TAG_VERSION=${GITHUB_REF#refs/tags/v}
+          aifabrix build {{appName}} --tag $TAG_VERSION
+      
+      - name: Deploy Application
+        run: |
+          set -e
+          aifabrix deploy {{appName}}