@aifabrix/builder 2.32.2 → 2.33.0

package/lib/utils/api.js

@@ -13,6 +13,9 @@
 const { parseErrorResponse } = require('./api-error-handler');
 const auditLogger = require('../core/audit-logger');
 
+/** Default timeout for HTTP requests (ms). Prevents hanging when the controller is unreachable. */
+const DEFAULT_REQUEST_TIMEOUT_MS = 5000;
+
 /**
  * Logs API request performance metrics and errors to audit log
  * @param {Object} params - Performance logging parameters
@@ -166,15 +169,20 @@ async function handleNetworkError(error, url, options, duration) {
 
 /**
  * Make an API call with proper error handling
+ * Uses a 15s timeout to avoid hanging when the controller is unreachable.
  * @param {string} url - API endpoint URL
- * @param {Object} options - Fetch options
+ * @param {Object} options - Fetch options (signal, method, headers, body, etc.)
  * @returns {Promise<Object>} Response object with success flag
  */
 async function makeApiCall(url, options = {}) {
   const startTime = Date.now();
+  const fetchOptions = { ...options };
+  if (!fetchOptions.signal) {
+    fetchOptions.signal = AbortSignal.timeout(DEFAULT_REQUEST_TIMEOUT_MS);
+  }
 
   try {
-    const response = await fetch(url, options);
+    const response = await fetch(url, fetchOptions);
     const duration = Date.now() - startTime;
 
     if (!response.ok) {
@@ -182,8 +190,13 @@ async function makeApiCall(url, options = {}) {
     }
 
     return await handleSuccessResponse(response, url, options, duration);
-  } catch (error) {
+  } catch (err) {
     const duration = Date.now() - startTime;
+    const error = err?.name === 'AbortError'
+      ? new Error(
+        `Request timed out after ${DEFAULT_REQUEST_TIMEOUT_MS / 1000} seconds. The controller may be unreachable. Check the URL and network.`
+      )
+      : err;
     return await handleNetworkError(error, url, options, duration);
   }
 }
@@ -209,15 +222,21 @@ function extractControllerUrl(url) {
  * Automatically refreshes device token on 401 errors if refresh token is available
  * @param {string} url - API endpoint URL
  * @param {Object} options - Fetch options
- * @param {string} token - Bearer token
+ * @param {string|Object} tokenOrAuthConfig - Bearer token string or authConfig object
+ * @param {string} [tokenOrAuthConfig.token] - Bearer token (if object)
+ * @param {string} [tokenOrAuthConfig.controller] - Controller URL for token refresh (if object)
  * @returns {Promise<Object>} Response object
  */
-async function authenticatedApiCall(url, options = {}, token) {
-  const headers = {
-    'Content-Type': 'application/json',
-    ...options.headers
-  };
-
+// eslint-disable-next-line max-statements
+async function authenticatedApiCall(url, options = {}, tokenOrAuthConfig) {
+  const isStringToken = typeof tokenOrAuthConfig === 'string';
+  const token = isStringToken ? tokenOrAuthConfig : tokenOrAuthConfig?.token;
+  const authControllerUrl = isStringToken ? null : tokenOrAuthConfig?.controller;
+  const isFormData = typeof FormData !== 'undefined' && options.body instanceof FormData;
+  const headers = { ...options.headers };
+  if (!isFormData && !headers['Content-Type']) {
+    headers['Content-Type'] = 'application/json';
+  }
   if (token) {
     headers['Authorization'] = `Bearer ${token}`;
   }
@@ -227,43 +246,19 @@ async function authenticatedApiCall(url, options = {}, token) {
     headers
   });
 
-  // Handle 401 errors with automatic token refresh for device tokens
   if (!response.success && response.status === 401) {
     try {
-      // Extract controller URL from request URL
-      const controllerUrl = extractControllerUrl(url);
-
-      // Try to get and refresh device token
-      const { getOrRefreshDeviceToken } = require('./token-manager');
-      const refreshedToken = await getOrRefreshDeviceToken(controllerUrl);
-
-      if (refreshedToken && refreshedToken.token) {
-        // Retry request with new token
+      const { forceRefreshDeviceToken } = require('./token-manager');
+      const refreshedToken = await forceRefreshDeviceToken(authControllerUrl || extractControllerUrl(url));
+      if (refreshedToken?.token) {
         headers['Authorization'] = `Bearer ${refreshedToken.token}`;
-        const retryResponse = await makeApiCall(url, {
-          ...options,
-          headers
-        });
-        return retryResponse;
-      }
-
-      // Token refresh failed or no refresh token available
-      // Return a more helpful error message
-      if (!refreshedToken) {
-        return {
-          ...response,
-          error: 'Authentication failed: Token expired and refresh failed. Please login again using: aifabrix login',
-          formattedError: 'Authentication failed: Token expired and refresh failed. Please login again using: aifabrix login'
-        };
+        return await makeApiCall(url, { ...options, headers });
       }
+      const authError = 'Authentication failed: Token expired and refresh failed. Please login again using: aifabrix login';
+      return { ...response, error: authError, formattedError: authError };
     } catch (refreshError) {
-      // Refresh failed, return original 401 error with additional context
-      const errorMessage = refreshError.message || String(refreshError);
-      return {
-        ...response,
-        error: `Authentication failed: ${errorMessage}. Please login again using: aifabrix login`,
-        formattedError: `Authentication failed: ${errorMessage}. Please login again using: aifabrix login`
-      };
+      const authError = `Authentication failed: ${refreshError.message || String(refreshError)}. Please login again using: aifabrix login`;
+      return { ...response, error: authError, formattedError: authError };
     }
   }
 

package/lib/utils/app-existence.js

@@ -0,0 +1,42 @@
+/**
+ * Application Existence Check Utility
+ *
+ * Checks if an application exists in an environment before deployment.
+ *
+ * @fileoverview Application existence checking for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { getEnvironmentApplication } = require('../api/environments.api');
+
+/**
+ * Check if application exists in the environment
+ * Uses device token auth to check existence (doesn't require app credentials)
+ * @async
+ * @function checkApplicationExists
+ * @param {string} appKey - Application key
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} envKey - Environment key
+ * @param {Object} authConfig - Authentication configuration (device token)
+ * @returns {Promise<boolean>} True if application exists, false otherwise
+ */
+async function checkApplicationExists(appKey, controllerUrl, envKey, authConfig) {
+  try {
+    // Use device token auth (bearer token) to check if app exists
+    // This doesn't require app credentials, so it works even if credentials are wrong
+    const deviceAuthConfig = { type: 'bearer', token: authConfig.token };
+    const response = await getEnvironmentApplication(controllerUrl, envKey, appKey, deviceAuthConfig);
+    return response.success && response.data !== null && response.data !== undefined;
+  } catch (error) {
+    // If 404, application doesn't exist
+    if (error.status === 404 || (error.response && error.response.status === 404)) {
+      return false;
+    }
+    // For other errors (including 401 if device token is invalid), we can't determine existence
+    // Return false to avoid blocking deployment - the validation step will catch credential issues
+    return false;
+  }
+}
+
+module.exports = { checkApplicationExists };

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

@@ -14,6 +14,7 @@ const chalk = require('chalk');
 const yaml = require('js-yaml');
 const logger = require('./logger');
 const { detectAppType } = require('./paths');
+const { getContainerPort, getLocalPort } = require('./port-resolver');
 
 // createApp is imported dynamically in createMinimalAppIfNeeded to handle test mocking
 
@@ -238,9 +239,11 @@ async function extractExternalAppConfiguration(appKey, variables, appKeyFromFile
 function extractWebappConfiguration(variables, appKeyFromFile, displayName, description, options) {
   const appType = variables.build?.language === 'typescript' ? 'webapp' : 'service';
   const registryMode = variables.image?.registryMode || 'external';
-  const port = variables.build?.port || options.port || 3000;
+  const port = options.port ?? getContainerPort(variables, 3000);
+  const localPort = getLocalPort(variables, port);
   const language = variables.build?.language || 'typescript';
   const image = buildImageReference(variables, appKeyFromFile);
+  const url = variables.app?.url || variables.deployment?.dataplaneUrl || variables.deployment?.appUrl || null;
 
   return {
     appKey: appKeyFromFile,
@@ -249,8 +252,10 @@ function extractWebappConfiguration(variables, appKeyFromFile, displayName, desc
     appType,
     registryMode,
     port,
+    localPort,
     image,
-    language
+    language,
+    url
   };
 }
 

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

@@ -48,7 +48,8 @@ function displayRegistrationResults(data, apiUrl, environment) {
   logger.log(chalk.bold('📋 Application Details:'));
   logger.log(`   ID:           ${data.application.id}`);
   logger.log(`   Key:          ${data.application.key}`);
-  logger.log(`   Display Name: ${data.application.displayName}\n`);
+  logger.log(`   Display Name: ${data.application.displayName}`);
+  logger.log(`   Controller:   ${apiUrl}\n`);
 
   logger.log(chalk.bold.yellow('🔑 CREDENTIALS (save these immediately):'));
   logger.log(chalk.yellow(`   Client ID:     ${data.credentials.clientId}`));

package/lib/utils/auth-config-validator.js

@@ -0,0 +1,92 @@
+/**
+ * Authentication Configuration Validators
+ *
+ * Provides validation functions for authentication configuration commands
+ *
+ * @fileoverview Authentication configuration validators
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { getControllerUrlFromLoggedInUser } = require('./controller-url');
+
+/**
+ * Validate controller URL format
+ * @function validateControllerUrl
+ * @param {string} url - Controller URL to validate
+ * @throws {Error} If URL format is invalid
+ */
+function validateControllerUrl(url) {
+  if (!url || typeof url !== 'string') {
+    throw new Error('Controller URL is required and must be a string');
+  }
+
+  const trimmed = url.trim();
+  if (trimmed.length === 0) {
+    throw new Error('Controller URL cannot be empty');
+  }
+
+  // Basic URL validation - must start with http:// or https://
+  if (!trimmed.match(/^https?:\/\//)) {
+    throw new Error('Controller URL must start with http:// or https://');
+  }
+
+  try {
+    // Use URL constructor for more thorough validation
+    new URL(trimmed);
+  } catch (error) {
+    throw new Error(`Invalid controller URL format: ${error.message}`);
+  }
+}
+
+/**
+ * Validate environment key format
+ * @function validateEnvironment
+ * @param {string} env - Environment key to validate
+ * @throws {Error} If environment format is invalid
+ */
+function validateEnvironment(env) {
+  if (!env || typeof env !== 'string') {
+    throw new Error('Environment is required and must be a string');
+  }
+
+  const trimmed = env.trim();
+  if (trimmed.length === 0) {
+    throw new Error('Environment cannot be empty');
+  }
+
+  // Environment key must contain only letters, numbers, hyphens, and underscores
+  if (!/^[a-z0-9-_]+$/i.test(trimmed)) {
+    throw new Error('Environment must contain only letters, numbers, hyphens, and underscores');
+  }
+}
+
+/**
+ * Check if user is logged in to a controller
+ * @async
+ * @function checkUserLoggedIn
+ * @param {string} controllerUrl - Controller URL to check
+ * @returns {Promise<boolean>} True if user has device token for this controller
+ */
+async function checkUserLoggedIn(controllerUrl) {
+  if (!controllerUrl) {
+    return false;
+  }
+
+  const normalizedUrl = controllerUrl.trim().replace(/\/+$/, '');
+  const loggedInControllerUrl = await getControllerUrlFromLoggedInUser();
+
+  if (!loggedInControllerUrl) {
+    return false;
+  }
+
+  // Normalize both URLs for comparison
+  const normalizedLoggedIn = loggedInControllerUrl.trim().replace(/\/+$/, '');
+  return normalizedLoggedIn === normalizedUrl;
+}
+
+module.exports = {
+  validateControllerUrl,
+  validateEnvironment,
+  checkUserLoggedIn
+};

package/lib/utils/cli-utils.js

@@ -135,7 +135,9 @@ function formatAzureError(errorMsg) {
       '   Use format: *.azurecr.io (e.g., myacr.azurecr.io)'
     ];
   }
-  if (errorMsg.includes('authenticate') || errorMsg.includes('ACR') || errorMsg.includes('Authentication required')) {
+  // Only match ACR-specific authentication errors, not general authentication failures
+  if (errorMsg.includes('ACR') || errorMsg.includes('azurecr.io') ||
+      (errorMsg.includes('authenticate') && (errorMsg.includes('registry') || errorMsg.includes('container')))) {
     return [
       '   Azure Container Registry authentication failed.',
       '   Run: az acr login --name <registry-name>',

package/lib/utils/command-header.js

@@ -0,0 +1,43 @@
+/**
+ * Command Header Display Utility
+ *
+ * Displays active configuration (controller, environment, dataplane) at top of commands
+ *
+ * @fileoverview Command header display utility
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const chalk = require('chalk');
+const logger = require('./logger');
+
+/**
+ * Display command header with active configuration
+ * @function displayCommandHeader
+ * @param {string} controllerUrl - Controller URL
+ * @param {string} environment - Environment key
+ * @param {string} [dataplaneUrl] - Dataplane URL (optional)
+ */
+function displayCommandHeader(controllerUrl, environment, dataplaneUrl) {
+  const parts = [];
+
+  if (controllerUrl) {
+    parts.push(`Controller: ${chalk.cyan(controllerUrl)}`);
+  }
+
+  if (environment) {
+    parts.push(`Environment: ${chalk.cyan(environment)}`);
+  }
+
+  if (dataplaneUrl) {
+    parts.push(`Dataplane: ${chalk.cyan(dataplaneUrl)}`);
+  }
+
+  if (parts.length > 0) {
+    logger.log(chalk.gray(`\n${parts.join(' | ')}\n`));
+  }
+}
+
+module.exports = {
+  displayCommandHeader
+};

package/lib/utils/compose-generator.js

@@ -15,6 +15,8 @@ const path = require('path');
 const handlebars = require('handlebars');
 const config = require('../core/config');
 const buildCopy = require('./build-copy');
+const { formatMissingDbPasswordError } = require('./error-formatter');
+const { getContainerPort } = require('./port-resolver');
 
 // Register commonly used helpers
 handlebars.registerHelper('eq', (a, b) => a === b);
@@ -150,6 +152,71 @@ function buildHealthCheckConfig(config) {
   };
 }
 
+/**
+ * Derives base path from routing pattern by removing trailing wildcards
+ * @param {string} pattern - URL pattern (e.g., '/app/*', '/api/v1/*')
+ * @returns {string} Base path for routing
+ */
+function derivePathFromPattern(pattern) {
+  if (!pattern || typeof pattern !== 'string') {
+    return '/';
+  }
+  const trimmed = pattern.trim();
+  if (trimmed === '/' || trimmed === '') {
+    return '/';
+  }
+  const withoutWildcards = trimmed.replace(/\*+$/g, '');
+  const withoutTrailingSlashes = withoutWildcards.replace(/\/+$/g, '');
+  return withoutTrailingSlashes || '/';
+}
+
+/**
+ * Builds developer username from developer ID
+ * @param {string|number} devId - Developer ID
+ * @returns {string} Developer username (dev, dev01, dev02, ...)
+ */
+function buildDevUsername(devId) {
+  if (devId === undefined || devId === null) {
+    return 'dev';
+  }
+  const devIdString = String(devId);
+  if (devIdString === '0') {
+    return 'dev';
+  }
+  const paddedId = devIdString.length === 1 ? devIdString.padStart(2, '0') : devIdString;
+  return `dev${paddedId}`;
+}
+
+/**
+ * Builds Traefik ingress configuration from frontDoorRouting
+ * Resolves ${DEV_USERNAME} variable interpolation in host field
+ * @param {Object} config - Application configuration
+ * @param {string|number} devId - Developer ID
+ * @returns {Object} Traefik configuration object
+ */
+function buildTraefikConfig(config, devId) {
+  const frontDoor = config.frontDoorRouting;
+  if (!frontDoor || frontDoor.enabled !== true) {
+    return { enabled: false };
+  }
+
+  if (!frontDoor.host || typeof frontDoor.host !== 'string') {
+    throw new Error('frontDoorRouting.host is required when frontDoorRouting.enabled is true');
+  }
+
+  const devUsername = buildDevUsername(devId);
+  const host = frontDoor.host.replace(/\$\{DEV_USERNAME\}/g, devUsername);
+  const path = derivePathFromPattern(frontDoor.pattern);
+
+  return {
+    enabled: true,
+    host,
+    path,
+    tls: frontDoor.tls !== false,
+    certStore: frontDoor.certStore || null
+  };
+}
+
 /**
  * Builds requires configuration section
  * @param {Object} config - Application configuration
@@ -169,17 +236,12 @@ function buildRequiresConfig(config) {
  * @param {string} appName - Application name
  * @param {Object} config - Application configuration
  * @param {number} port - Application port
+ * @param {string|number} devId - Developer ID
  * @returns {Object} Service configuration
  */
-function buildServiceConfig(appName, config, port) {
-  // Container port: build.containerPort > config.port (NEVER use host port parameter)
-  // Container port should remain unchanged regardless of developer ID
-  const containerPortValue = config.build?.containerPort || config.port || 3000;
-
-  // Host port: use port parameter (already calculated from CLI --port or config.port in generateDockerCompose)
-  // Note: build.localPort is ONLY used for .env file PORT variable (for local PC dev), NOT for Docker Compose
+function buildServiceConfig(appName, config, port, devId) {
+  const containerPortValue = getContainerPort(config, 3000);
   const hostPort = port;
-
   return {
     app: buildAppConfig(appName, config),
     image: buildImageConfig(config, appName),
@@ -190,6 +252,7 @@ function buildServiceConfig(appName, config, port) {
       localPort: config.build?.localPort || null // Only used for .env file PORT variable, not for Docker Compose
     },
     healthCheck: buildHealthCheckConfig(config),
+    traefik: buildTraefikConfig(config, devId),
     ...buildRequiresConfig(config)
   };
 }
@@ -200,11 +263,7 @@ function buildServiceConfig(appName, config, port) {
  * @returns {Object} Volumes configuration
  */
 function buildVolumesConfig(appName) {
-  // Use forward slashes for Docker paths (works on both Windows and Unix)
-  const volumePath = path.join(process.cwd(), 'data', appName);
-  return {
-    mountVolume: volumePath.replace(/\\/g, '/')
-  };
+  return { mountVolume: path.join(process.cwd(), 'data', appName).replace(/\\/g, '/') };
 }
 
 /**
@@ -213,23 +272,9 @@ function buildVolumesConfig(appName) {
  * @returns {Object} Networks configuration
  */
 function buildNetworksConfig(config) {
-  // Get databases from requires.databases or top-level databases
-  const databases = config.requires?.databases || config.databases || [];
-  return {
-    databases: databases
-  };
+  return { databases: config.requires?.databases || config.databases || [] };
 }
 
-/**
- * Reads database passwords from .env file
- * Requires DB_0_PASSWORD, DB_1_PASSWORD, etc. to be set in .env file
- * @async
- * @param {string} envPath - Path to .env file
- * @param {Array<Object>} databases - Array of database configurations
- * @param {string} appKey - Application key (fallback for single database)
- * @returns {Promise<Object>} Object with passwords array and lookup map
- * @throws {Error} If required password variables are missing
- */
 /**
  * Reads and parses .env file
  * @async
@@ -276,17 +321,21 @@ async function readEnvFile(envPath) {
  * @function extractPassword
  * @param {Object} envVars - Environment variables
  * @param {string} passwordKey - Password key to look up
+ * @param {Object} [context] - Optional: { appKey, multi } for clearer error messages
  * @returns {string} Password value
  * @throws {Error} If password is missing or empty
  */
-function extractPassword(envVars, passwordKey) {
+function extractPassword(envVars, passwordKey, context = {}) {
+  const { appKey, multi } = context;
+  const appSuffix = appKey ? ` for application '${appKey}'` : '';
+
   if (!(passwordKey in envVars)) {
-    throw new Error(`Missing required password variable ${passwordKey} in .env file`);
+    throw new Error(multi && appKey ? formatMissingDbPasswordError(appKey, { multiDb: true, passwordKey }) : 'Missing required password variable ' + passwordKey + ' in .env file' + appSuffix + '. Add ' + passwordKey + '=your_secret to your .env file.');
   }
 
   const password = envVars[passwordKey].trim();
   if (!password || password.length === 0) {
-    throw new Error(`Password variable ${passwordKey} is empty in .env file`);
+    throw new Error('Password variable ' + passwordKey + ' is empty in .env file' + appSuffix + '. Set a non-empty value.');
   }
 
   return password;
@@ -303,17 +352,14 @@ function extractPassword(envVars, passwordKey) {
 function processMultipleDatabases(databases, envVars, appKey) {
   const passwords = {};
   const passwordsArray = [];
-
   for (let i = 0; i < databases.length; i++) {
     const db = databases[i];
     const dbName = db.name || appKey;
     const passwordKey = `DB_${i}_PASSWORD`;
-    const password = extractPassword(envVars, passwordKey);
-
+    const password = extractPassword(envVars, passwordKey, { appKey, multi: true });
     passwords[dbName] = password;
     passwordsArray.push(password);
   }
-
   return { passwords, passwordsArray };
 }
 
@@ -327,47 +373,36 @@ function processMultipleDatabases(databases, envVars, appKey) {
 function processSingleDatabase(envVars, appKey) {
   const passwords = {};
   const passwordsArray = [];
-
-  // Single database case - use DB_0_PASSWORD or DB_PASSWORD
   const passwordKey = ('DB_0_PASSWORD' in envVars) ? 'DB_0_PASSWORD' : 'DB_PASSWORD';
-
   if (!(passwordKey in envVars)) {
-    throw new Error(`Missing required password variable ${passwordKey} in .env file. Add DB_0_PASSWORD or DB_PASSWORD to your .env file.`);
+    throw new Error(formatMissingDbPasswordError(appKey));
   }
-
-  const password = extractPassword(envVars, passwordKey);
+  const password = extractPassword(envVars, passwordKey, { appKey });
   passwords[appKey] = password;
   passwordsArray.push(password);
-
   return { passwords, passwordsArray };
 }
 
+/**
+ * Reads database passwords from .env file
+ * @async
+ * @function readDatabasePasswords
+ * @param {string} envPath - Path to .env file
+ * @param {Array<Object>} databases - Array of database configurations
+ * @param {string} appKey - Application key (fallback for single database)
+ * @returns {Promise<Object>} Object with passwords map and array
+ * @throws {Error} If required password variables are missing
+ */
 async function readDatabasePasswords(envPath, databases, appKey) {
   const envVars = await readEnvFile(envPath);
-
-  // Process each database
   if (databases && databases.length > 0) {
     const { passwords, passwordsArray } = processMultipleDatabases(databases, envVars, appKey);
-    return {
-      map: passwords,
-      array: passwordsArray
-    };
+    return { map: passwords, array: passwordsArray };
   }
-
   const { passwords, passwordsArray } = processSingleDatabase(envVars, appKey);
-  return {
-    map: passwords,
-    array: passwordsArray
-  };
+  return { map: passwords, array: passwordsArray };
 }
 
-/**
- * Generates Docker Compose configuration from template
- * @param {string} appName - Application name
- * @param {Object} appConfig - Application configuration
- * @param {Object} options - Run options
- * @returns {Promise<string>} Generated compose content
- */
 /**
  * Gets developer ID and calculates numeric ID
  * @async
@@ -376,8 +411,7 @@ async function readDatabasePasswords(envPath, databases, appKey) {
  */
 async function getDeveloperIdAndNumeric() {
   const devId = await config.getDeveloperId();
-  const idNum = typeof devId === 'string' ? parseInt(devId, 10) : devId;
-  return { devId, idNum };
+  return { devId, idNum: typeof devId === 'string' ? parseInt(devId, 10) : devId };
 }
 
 /**
@@ -411,15 +445,22 @@ async function readDatabasePasswordsIfNeeded(requiresDatabase, databases, envFil
   return { map: {}, array: [] };
 }
 
+/**
+ * Generates Docker Compose configuration from template
+ * @async
+ * @function generateDockerCompose
+ * @param {string} appName - Application name
+ * @param {Object} appConfig - Application configuration
+ * @param {Object} options - Run options
+ * @returns {Promise<string>} Generated compose content
+ */
 async function generateDockerCompose(appName, appConfig, options) {
   const language = appConfig.build?.language || appConfig.language || 'typescript';
   const template = loadDockerComposeTemplate(language);
   const port = options.port || appConfig.port || 3000;
-
   const { devId, idNum } = await getDeveloperIdAndNumeric();
   const { networkName, containerName } = buildNetworkAndContainerNames(appName, devId, idNum);
-
-  const serviceConfig = buildServiceConfig(appName, appConfig, port);
+  const serviceConfig = buildServiceConfig(appName, appConfig, port, devId);
   const volumesConfig = buildVolumesConfig(appName);
   const networksConfig = buildNetworksConfig(appConfig);
 
@@ -439,17 +480,19 @@ async function generateDockerCompose(appName, appConfig, options) {
     ...volumesConfig,
     ...networksConfig,
     envFile: envFileAbsolutePath,
-    databasePasswords: databasePasswords,
+    databasePasswords,
     devId: idNum,
-    networkName: networkName,
-    containerName: containerName
+    networkName,
+    containerName
   };
-
   return template(templateData);
 }
 
 module.exports = {
   generateDockerCompose,
-  getImageName
+  getImageName,
+  derivePathFromPattern,
+  buildTraefikConfig,
+  buildDevUsername
 };