@aifabrix/builder 2.11.0 → 2.20.0

package/lib/external-system-test.js

@@ -14,7 +14,7 @@ const fsSync = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const { authenticatedApiCall } = require('./utils/api');
+const { testDatasourceViaPipeline } = require('./api/pipeline.api');
 const { getDeploymentAuth } = require('./utils/token-manager');
 const { getDataplaneUrl } = require('./datasource-deploy');
 const { getConfig } = require('./config');
@@ -270,7 +270,7 @@ async function retryApiCall(fn, maxRetries = 3, backoffMs = 1000) {
 }
 
 /**
- * Calls pipeline test endpoint
+ * Calls pipeline test endpoint using centralized API client
  * @async
  * @param {string} systemKey - System key
  * @param {string} datasourceKey - Datasource key
@@ -281,17 +281,14 @@ async function retryApiCall(fn, maxRetries = 3, backoffMs = 1000) {
  * @returns {Promise<Object>} Test response
  */
 async function callPipelineTestEndpoint(systemKey, datasourceKey, payloadTemplate, dataplaneUrl, authConfig, timeout = 30000) {
-  const endpoint = `${dataplaneUrl}/api/v1/pipeline/${systemKey}/${datasourceKey}/test`;
-
   const response = await retryApiCall(async() => {
-    return await authenticatedApiCall(
-      endpoint,
-      {
-        method: 'POST',
-        body: JSON.stringify({ payloadTemplate }),
-        timeout
-      },
-      authConfig.token
+    return await testDatasourceViaPipeline(
+      dataplaneUrl,
+      systemKey,
+      datasourceKey,
+      authConfig,
+      { payloadTemplate },
+      { timeout }
     );
   });
 

package/lib/utils/app-register-api.js

@@ -10,7 +10,7 @@
 
 const chalk = require('chalk');
 const logger = require('./logger');
-const { authenticatedApiCall } = require('./api');
+const { registerApplication } = require('../api/applications.api');
 const { formatApiError } = require('./api-error-handler');
 
 /**
@@ -23,14 +23,9 @@ const { formatApiError } = require('./api-error-handler');
  * @returns {Promise<Object>} API response
  */
 async function callRegisterApi(apiUrl, token, environment, registrationData) {
-  const response = await authenticatedApiCall(
-    `${apiUrl}/api/v1/environments/${encodeURIComponent(environment)}/applications/register`,
-    {
-      method: 'POST',
-      body: JSON.stringify(registrationData)
-    },
-    token
-  );
+  // Use centralized API client
+  const authConfig = { type: 'bearer', token: token };
+  const response = await registerApplication(apiUrl, environment, authConfig, registrationData);
 
   if (!response.success) {
     const formattedError = response.formattedError || formatApiError(response);
@@ -48,7 +43,7 @@ async function callRegisterApi(apiUrl, token, environment, registrationData) {
   }
 
   // Handle API response structure:
-  // makeApiCall returns: { success: true, data: <API response> }
+  // registerApplication returns: { success: true, data: <API response> }
   // API response can be:
   // 1. Direct format: { application: {...}, credentials: {...} }
   // 2. Wrapped format: { success: true, data: { application: {...}, credentials: {...} } }

package/lib/utils/deployment-errors.js

@@ -18,8 +18,17 @@ const { parseErrorResponse } = require('./api-error-handler');
  * @returns {Object} Structured error information
  */
 function handleDeploymentError(error) {
+  if (!error) {
+    return {
+      message: 'Unknown error',
+      code: 'UNKNOWN',
+      timeout: false,
+      status: undefined,
+      data: undefined
+    };
+  }
   const safeError = {
-    message: error.message,
+    message: error.message || 'Unknown error',
     code: error.code || 'UNKNOWN',
     timeout: error.code === 'ECONNABORTED',
     status: error.status || error.response?.status,
@@ -42,6 +51,38 @@ function handleDeploymentError(error) {
  * @throws {Error} User-friendly error message
  */
 async function handleDeploymentErrors(error, appName, url, alreadyLogged = false) {
+  // For validation errors (like URL validation), just re-throw them directly
+  // They already have user-friendly messages
+  // Handle both Error objects and strings
+  let errorMessage = '';
+  if (error instanceof Error) {
+    errorMessage = error.message || '';
+  } else if (typeof error === 'string') {
+    errorMessage = error;
+  } else if (error && typeof error === 'object' && error.message) {
+    errorMessage = error.message;
+  }
+
+  if (errorMessage && (
+    errorMessage.includes('Controller URL must use HTTPS') ||
+    errorMessage.includes('Invalid environment key') ||
+    errorMessage.includes('Environment key is required') ||
+    errorMessage.includes('Authentication configuration is required') ||
+    errorMessage.includes('Invalid controller URL format') ||
+    errorMessage.includes('Controller URL is required')
+  )) {
+    // If error is a string, convert to Error object
+    if (typeof error === 'string') {
+      throw new Error(error);
+    }
+    // If it's already an Error object, re-throw it directly
+    if (error instanceof Error) {
+      throw error;
+    }
+    // Otherwise, create a new Error with the message
+    throw new Error(errorMessage);
+  }
+
   // Log to audit log if not already logged
   if (!alreadyLogged) {
     try {
@@ -63,7 +104,17 @@ async function handleDeploymentErrors(error, appName, url, alreadyLogged = false
 
   // Ensure errorData is not undefined before parsing
   // If errorData is undefined, use the error message instead
-  const errorResponse = errorData !== undefined ? errorData : safeError.message;
+  let errorResponse = errorData !== undefined ? errorData : safeError.message;
+
+  // Ensure errorResponse is a string or object, not an Error object
+  if (errorResponse instanceof Error) {
+    errorResponse = errorResponse.message || 'Unknown error occurred';
+  }
+
+  // Ensure errorResponse is not null or undefined
+  if (errorResponse === null || errorResponse === undefined) {
+    errorResponse = safeError.message || 'Unknown error occurred';
+  }
 
   // Determine if this is a network error
   const isNetworkError = safeError.code === 'ECONNREFUSED' ||
@@ -72,13 +123,44 @@ async function handleDeploymentErrors(error, appName, url, alreadyLogged = false
     safeError.timeout;
 
   // Parse error using error handler
-  const parsedError = parseErrorResponse(errorResponse, safeError.status || 0, isNetworkError);
+  let parsedError;
+  try {
+    parsedError = parseErrorResponse(errorResponse, safeError.status || 0, isNetworkError);
+    // Ensure parsedError is a valid object
+    if (!parsedError || typeof parsedError !== 'object') {
+      throw new Error('parseErrorResponse returned invalid result');
+    }
+  } catch (parseErr) {
+    // If parsing fails, use the safe error message
+    parsedError = {
+      message: safeError.message || 'Unknown error occurred',
+      formatted: safeError.message || 'Unknown error occurred',
+      data: undefined
+    };
+  }
+
+  // Ensure parsedError is always a valid object with required properties
+  if (!parsedError || typeof parsedError !== 'object') {
+    parsedError = {
+      message: safeError.message || 'Unknown error occurred',
+      formatted: safeError.message || 'Unknown error occurred',
+      data: undefined
+    };
+  }
+
+  // Ensure we have a message - handle case where parsedError.message might be undefined
+  const finalErrorMessage = (parsedError && parsedError.message) ? parsedError.message : (safeError.message || 'Unknown error occurred');
+
+  // Validate finalErrorMessage is a string
+  if (typeof finalErrorMessage !== 'string') {
+    throw new Error(`Invalid error message type: ${typeof finalErrorMessage}. Error: ${JSON.stringify(error)}`);
+  }
 
   // Throw clean error message (without emoji) - CLI will format it
-  const formattedError = new Error(parsedError.message);
-  formattedError.formatted = parsedError.formatted;
+  const formattedError = new Error(finalErrorMessage);
+  formattedError.formatted = parsedError?.formatted || finalErrorMessage;
   formattedError.status = safeError.status;
-  formattedError.data = parsedError.data;
+  formattedError.data = parsedError?.data;
   formattedError._logged = true; // Mark as logged to prevent double-logging
   throw formattedError;
 }

package/package.json

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