@aifabrix/builder 2.32.3 → 2.33.0

package/lib/generator/index.js

@@ -17,23 +17,26 @@ const builders = require('./builders');
 const { detectAppType, getDeployJsonPath } = require('../utils/paths');
 const splitFunctions = require('./split');
 const { loadVariables, loadEnvTemplate, loadRbac, parseEnvironmentVariables } = require('./helpers');
-const { generateExternalSystemDeployJson, generateExternalSystemApplicationSchema } = require('./external');
+const { generateExternalSystemApplicationSchema, splitExternalApplicationSchema } = require('./external');
+const { generateControllerManifest } = require('./external-controller-manifest');
 
 /**
  * Generates deployment JSON from application configuration files
- * Creates <app-name>-deploy.json for all apps (consistent naming)
- * For external systems, loads the system JSON file
+ * Creates <app-name>-deploy.json for regular apps (consistent naming)
+ * For external systems, generates application-schema.json
  * For regular apps, generates deployment manifest from variables.yaml, env.template, rbac.yaml
  *
  * @async
  * @function generateDeployJson
  * @param {string} appName - Name of the application
+ * @param {Object} [options] - Generation options
+ * @param {string} [options.type] - Forced application type (external)
  * @returns {Promise<string>} Path to generated deployment JSON file
  * @throws {Error} If generation fails or configuration is invalid
  *
  * @example
  * const jsonPath = await generateDeployJson('myapp');
- * // Returns: './builder/myapp/myapp-deploy.json' or './integration/hubspot/hubspot-deploy.json'
+ * // Returns: './builder/myapp/myapp-deploy.json' or './integration/hubspot/application-schema.json'
  */
 /**
  * Loads configuration files for deployment generation
@@ -88,17 +91,25 @@ function buildAndValidateDeployment(appName, variables, envTemplate, rbac) {
   return deployment;
 }
 
-async function generateDeployJson(appName) {
+async function generateDeployJson(appName, options = {}) {
   if (!appName || typeof appName !== 'string') {
     throw new Error('App name is required and must be a string');
   }
 
   // Detect app type and get correct path (integration or builder)
-  const { isExternal, appPath, appType } = await detectAppType(appName);
+  const { isExternal, appPath, appType } = await detectAppType(appName, options);
 
   // Check if app type is external
   if (isExternal) {
-    return await generateExternalSystemDeployJson(appName, appPath);
+    // Generate controller-compatible manifest format
+    const manifest = await generateControllerManifest(appName);
+
+    // Determine system key for file naming
+    const systemKey = manifest.key || appName;
+    const deployJsonPath = path.join(appPath, `${systemKey}-deploy.json`);
+
+    await fs.promises.writeFile(deployJsonPath, JSON.stringify(manifest, null, 2), { mode: 0o644, encoding: 'utf8' });
+    return deployJsonPath;
   }
 
   // Regular app: generate deployment manifest
@@ -112,13 +123,13 @@ async function generateDeployJson(appName) {
   return jsonPath;
 }
 
-async function generateDeployJsonWithValidation(appName) {
-  const jsonPath = await generateDeployJson(appName);
+async function generateDeployJsonWithValidation(appName, options = {}) {
+  const jsonPath = await generateDeployJson(appName, options);
   const jsonContent = fs.readFileSync(jsonPath, 'utf8');
   const deployment = JSON.parse(jsonContent);
 
   // Detect if this is an external system
-  const { isExternal } = await detectAppType(appName);
+  const { isExternal } = await detectAppType(appName, options);
 
   // For external systems, skip deployment JSON validation (they use external system JSON structure)
   if (isExternal) {
@@ -143,6 +154,7 @@ module.exports = {
   generateDeployJson,
   generateDeployJsonWithValidation,
   generateExternalSystemApplicationSchema,
+  splitExternalApplicationSchema,
   parseEnvironmentVariables,
   splitDeployJson: splitFunctions.splitDeployJson,
   extractEnvTemplate: splitFunctions.extractEnvTemplate,

package/lib/generator/wizard-prompts.js

@@ -29,6 +29,28 @@ async function promptForMode() {
   return mode;
 }
 
+/**
+ * Prompt for existing system ID or key (for add-datasource mode)
+ * @async
+ * @function promptForSystemIdOrKey
+ * @returns {Promise<string>} System ID or key
+ */
+async function promptForSystemIdOrKey() {
+  const { systemIdOrKey } = await inquirer.prompt([
+    {
+      type: 'input',
+      name: 'systemIdOrKey',
+      message: 'Enter the existing system ID or key:',
+      validate: (input) => {
+        if (!input || typeof input !== 'string' || input.trim().length === 0) {
+          return 'System ID or key is required';
+        }
+        return true;
+      }
+    }
+  ]);
+  return systemIdOrKey.trim();
+}
 /**
  * Prompt for source type selection
  * @async
@@ -195,19 +217,19 @@ async function promptForKnownPlatform(platforms = []) {
 async function promptForUserIntent() {
   const { intent } = await inquirer.prompt([
     {
-      type: 'list',
+      type: 'input',
       name: 'intent',
-      message: 'What is your primary use case?',
-      choices: [
-        { name: 'Sales-focused (CRM, leads, deals)', value: 'sales-focused' },
-        { name: 'Support-focused (tickets, customers)', value: 'support-focused' },
-        { name: 'Marketing-focused (campaigns, contacts)', value: 'marketing-focused' },
-        { name: 'General integration', value: 'general' }
-      ],
-      default: 'general'
+      message: 'Describe your primary use case (any text):',
+      default: 'general integration',
+      validate: (input) => {
+        if (!input || typeof input !== 'string' || input.trim().length === 0) {
+          return 'Intent is required';
+        }
+        return true;
+      }
     }
   ]);
-  return intent;
+  return intent.trim();
 }
 
 /**
@@ -344,6 +366,7 @@ async function promptForAppName(defaultName) {
 
 module.exports = {
   promptForMode,
+  promptForSystemIdOrKey,
   promptForSourceType,
   promptForOpenApiFile,
   promptForOpenApiUrl,

package/lib/generator/wizard.js

@@ -10,7 +10,7 @@ const yaml = require('js-yaml');
 const Handlebars = require('handlebars');
 const chalk = require('chalk');
 const logger = require('../utils/logger');
-const { generateExternalSystemApplicationSchema } = require('./external');
+const { generateExternalReadmeContent } = require('../utils/external-readme');
 
 /**
  * Generate files from dataplane-generated wizard configurations
@@ -33,7 +33,7 @@ const { generateExternalSystemApplicationSchema } = require('./external');
  * @returns {Promise<string>} System file path
  */
 async function writeSystemJsonFile(appPath, finalSystemKey, systemConfig) {
-  const systemFileName = `${finalSystemKey}-deploy.json`;
+  const systemFileName = `${finalSystemKey}-system.json`;
   const systemFilePath = path.join(appPath, systemFileName);
   await fs.writeFile(systemFilePath, JSON.stringify(systemConfig, null, 2), 'utf8');
   logger.log(chalk.green(`✓ Generated system file: ${systemFileName}`));
@@ -53,7 +53,12 @@ async function writeDatasourceJsonFiles(appPath, finalSystemKey, datasourceConfi
   const datasourceFileNames = [];
   for (const datasourceConfig of datasourceConfigs) {
     const entityType = datasourceConfig.entityType || datasourceConfig.entityKey || datasourceConfig.key?.split('-').pop() || 'default';
-    const datasourceFileName = `${finalSystemKey}-deploy-${entityType}.json`;
+    const datasourceKey = datasourceConfig.key || `${finalSystemKey}-${entityType}`;
+    // Extract datasource key (remove system key prefix if present)
+    const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${finalSystemKey}-`)
+      ? datasourceKey.substring(finalSystemKey.length + 1)
+      : entityType;
+    const datasourceFileName = `${finalSystemKey}-datasource-${datasourceKeyOnly}.json`;
     const datasourceFilePath = path.join(appPath, datasourceFileName);
     await fs.writeFile(datasourceFilePath, JSON.stringify(datasourceConfig, null, 2), 'utf8');
     datasourceFileNames.push(datasourceFileName);
@@ -99,17 +104,18 @@ async function generateConfigFilesForWizard(params) {
   // Generate deployment scripts
   const deployScripts = await generateDeployScripts(appPath, finalSystemKey, systemFileName, datasourceFileNames);
 
-  // Generate application-schema.json
-  const applicationSchema = await generateExternalSystemApplicationSchema(appName);
-  const applicationSchemaPath = path.join(appPath, 'application-schema.json');
-  await fs.writeFile(applicationSchemaPath, JSON.stringify(applicationSchema, null, 2), 'utf8');
-  logger.log(chalk.green('✓ Generated application-schema.json'));
+  // Generate deployment manifest (<systemKey>-deploy.json) using controller format
+  const { generateControllerManifest } = require('./external-controller-manifest');
+  const manifest = await generateControllerManifest(appName, { appPath });
+  const deployManifestPath = path.join(appPath, `${finalSystemKey}-deploy.json`);
+  await fs.writeFile(deployManifestPath, JSON.stringify(manifest, null, 2), 'utf8');
+  logger.log(chalk.green(`✓ Generated deployment manifest: ${finalSystemKey}-deploy.json`));
 
   return {
     variablesPath: path.join(appPath, 'variables.yaml'),
     envTemplatePath: path.join(appPath, 'env.template'),
     readmePath: path.join(appPath, 'README.md'),
-    applicationSchemaPath,
+    applicationSchemaPath: deployManifestPath,
     ...deployScripts
   };
 }
@@ -123,23 +129,46 @@ async function generateWizardFiles(appName, systemConfig, datasourceConfigs, sys
     // Create directory if it doesn't exist
     await fs.mkdir(appPath, { recursive: true });
 
-    // Extract system key from config if not provided
-    const finalSystemKey = systemKey || systemConfig.key || appName;
+    // Use appName as the system key to ensure consistent naming
+    // Priority: appName > systemKey parameter > systemConfig.key
+    const finalSystemKey = appName;
+
+    // Generate displayName from appName (e.g., "my-hubspot" -> "My Hubspot")
+    const appDisplayName = appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+
+    // Update system config to use the appName as key and displayName
+    const updatedSystemConfig = {
+      ...systemConfig,
+      key: finalSystemKey,
+      displayName: appDisplayName
+    };
+
+    // Update datasource configs to use appName-based keys and systemKey
+    const updatedDatasourceConfigs = datasourceConfigs.map(ds => {
+      const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || 'default';
+      const entityDisplayName = entityType.charAt(0).toUpperCase() + entityType.slice(1).replace(/-/g, ' ');
+      return {
+        ...ds,
+        key: `${finalSystemKey}-${entityType}`,
+        systemKey: finalSystemKey,
+        displayName: `${appDisplayName} ${entityDisplayName}`
+      };
+    });
 
     // Write system and datasource JSON files
-    const systemFilePath = await writeSystemJsonFile(appPath, finalSystemKey, systemConfig);
-    const datasourceFileNames = await writeDatasourceJsonFiles(appPath, finalSystemKey, datasourceConfigs);
+    const systemFilePath = await writeSystemJsonFile(appPath, finalSystemKey, updatedSystemConfig);
+    const datasourceFileNames = await writeDatasourceJsonFiles(appPath, finalSystemKey, updatedDatasourceConfigs);
 
     // Generate configuration files
-    const systemFileName = `${finalSystemKey}-deploy.json`;
+    const systemFileName = `${finalSystemKey}-system.json`;
     const configFiles = await generateConfigFilesForWizard({
       appPath,
       appName,
       finalSystemKey,
       systemFileName,
       datasourceFileNames,
-      systemConfig,
-      datasourceConfigs,
+      systemConfig: updatedSystemConfig,
+      datasourceConfigs: updatedDatasourceConfigs,
       aiGeneratedReadme
     });
 
@@ -408,76 +437,30 @@ async function generateReadme(appPath, appName, systemKey, systemConfig, datasou
       return;
     }
 
-    const displayName = systemConfig.displayName || appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
-    const description = systemConfig.description || `External system integration for ${appName}`;
-
-    const lines = [
-      `# ${displayName}`,
-      '',
-      description,
-      '',
-      '## Overview',
-      '',
-      'This integration was created using the AI Fabrix wizard.',
-      '',
-      '## Files',
-      '',
-      `- \`${systemKey}-deploy.json\` - External system configuration`,
-      ...datasourceConfigs.map((ds, index) => {
-        const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || `datasource${index + 1}`;
-        return `- \`${systemKey}-deploy-${entityType}.json\` - Datasource configuration`;
-      }),
-      '- `variables.yaml` - Application variables and external integration configuration',
-      '- `env.template` - Environment variable template',
-      '- `application-schema.json` - Single deployment file',
-      '- `deploy.sh` - Bash deployment script',
-      '- `deploy.ps1` - PowerShell deployment script',
-      '',
-      '## Deployment',
-      '',
-      '### Using Deployment Scripts',
-      '',
-      'You can deploy using the provided scripts:',
-      '',
-      '**Bash (Linux/macOS):**',
-      '```bash',
-      './deploy.sh',
-      '```',
-      '',
-      '**PowerShell (Windows):**',
-      '```powershell',
-      '.\\deploy.ps1',
-      '```',
-      '',
-      'The scripts support environment variables:',
-      '- `ENVIRONMENT` - Environment key (default: dev)',
-      '- `CONTROLLER` - Controller URL (default: http://localhost:3000)',
-      '- `RUN_TESTS` - Set to "true" to run integration tests after deployment',
-      '',
-      '**Example:**',
-      '```bash',
-      'ENVIRONMENT=prod CONTROLLER=https://controller.example.com ./deploy.sh',
-      '```',
-      '',
-      '### Using CLI Directly',
-      '',
-      'To deploy this external system:',
-      '',
-      '```bash',
-      `aifabrix deploy ${appName}`,
-      '```',
-      '',
-      '## Configuration',
-      '',
-      'Update the environment variables in `env.template` and set the values in your secrets store.',
-      '',
-      '## Documentation',
-      '',
-      'For more information, see the [External Systems Documentation](../../docs/external-systems.md).'
-    ];
-
-    await fs.writeFile(readmePath, lines.join('\n'), 'utf8');
-    logger.log(chalk.green('✓ Generated README.md'));
+    const datasources = (Array.isArray(datasourceConfigs) ? datasourceConfigs : []).map((ds, index) => {
+      const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || `datasource${index + 1}`;
+      const datasourceKey = ds.key || `${systemKey}-${entityType}`;
+      const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${systemKey}-`)
+        ? datasourceKey.substring(systemKey.length + 1)
+        : entityType;
+      return {
+        entityType,
+        displayName: ds.displayName || ds.name || ds.key || `Datasource ${index + 1}`,
+        fileName: `${systemKey}-datasource-${datasourceKeyOnly}.json`
+      };
+    });
+
+    const readmeContent = generateExternalReadmeContent({
+      appName,
+      systemKey,
+      systemType: systemConfig.type || systemConfig.systemType,
+      displayName: systemConfig.displayName,
+      description: systemConfig.description,
+      datasources
+    });
+
+    await fs.writeFile(readmePath, readmeContent, 'utf8');
+    logger.log(chalk.green('✓ Generated README.md (template)'));
   } catch (error) {
     throw new Error(`Failed to generate README.md: ${error.message}`);
   }

package/lib/infrastructure/compose.js

@@ -0,0 +1,100 @@
+/**
+ * AI Fabrix Builder Infrastructure Compose File Generation
+ *
+ * Handles Docker Compose file generation from templates and Traefik configuration.
+ *
+ * @fileoverview Compose file generation for infrastructure
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs');
+const handlebars = require('handlebars');
+const path = require('path');
+
+/**
+ * Builds Traefik configuration from environment variables
+ * @param {boolean} enabled - Whether Traefik should be included
+ * @returns {Object} Traefik configuration
+ */
+function buildTraefikConfig(enabled) {
+  return {
+    enabled: !!enabled,
+    certStore: process.env.TRAEFIK_CERT_STORE || null,
+    certFile: process.env.TRAEFIK_CERT_FILE || null,
+    keyFile: process.env.TRAEFIK_KEY_FILE || null
+  };
+}
+
+/**
+ * Validates Traefik configuration when enabled
+ * @param {Object} traefikConfig - Traefik configuration
+ * @returns {{valid: boolean, errors: string[]}} Validation result
+ */
+function validateTraefikConfig(traefikConfig) {
+  if (!traefikConfig || !traefikConfig.enabled) {
+    return { valid: true, errors: [] };
+  }
+
+  const errors = [];
+
+  if (traefikConfig.certStore) {
+    if (!traefikConfig.certFile || !traefikConfig.keyFile) {
+      errors.push('TRAEFIK_CERT_FILE and TRAEFIK_KEY_FILE are required when TRAEFIK_CERT_STORE is set');
+    } else {
+      if (!fs.existsSync(traefikConfig.certFile)) {
+        errors.push(`Certificate file not found: ${traefikConfig.certFile}`);
+      }
+      if (!fs.existsSync(traefikConfig.keyFile)) {
+        errors.push(`Private key file not found: ${traefikConfig.keyFile}`);
+      }
+    }
+  }
+
+  return { valid: errors.length === 0, errors };
+}
+
+/**
+ * Generate docker-compose file from template
+ * @param {string} templatePath - Path to compose template
+ * @param {string} devId - Developer ID
+ * @param {number} idNum - Developer ID number
+ * @param {Object} ports - Port configuration
+ * @param {string} infraDir - Infrastructure directory
+ * @param {Object} [options] - Additional options
+ * @param {Object|boolean} [options.traefik] - Traefik configuration
+ * @returns {string} Path to generated compose file
+ */
+function generateComposeFile(templatePath, devId, idNum, ports, infraDir, options = {}) {
+  const templateContent = fs.readFileSync(templatePath, 'utf8');
+  const template = handlebars.compile(templateContent);
+  const networkName = idNum === 0 ? 'infra-aifabrix-network' : `infra-dev${devId}-aifabrix-network`;
+  const serversJsonPath = path.join(infraDir, 'servers.json');
+  const pgpassPath = path.join(infraDir, 'pgpass');
+  const traefikConfig = typeof options.traefik === 'object'
+    ? options.traefik
+    : buildTraefikConfig(!!options.traefik);
+  const composeContent = template({
+    devId: devId,
+    postgresPort: ports.postgres,
+    redisPort: ports.redis,
+    pgadminPort: ports.pgadmin,
+    redisCommanderPort: ports.redisCommander,
+    traefikHttpPort: ports.traefikHttp,
+    traefikHttpsPort: ports.traefikHttps,
+    networkName: networkName,
+    serversJsonPath: serversJsonPath,
+    pgpassPath: pgpassPath,
+    infraDir: infraDir,
+    traefik: traefikConfig
+  });
+  const composePath = path.join(infraDir, 'compose.yaml');
+  fs.writeFileSync(composePath, composeContent);
+  return composePath;
+}
+
+module.exports = {
+  buildTraefikConfig,
+  validateTraefikConfig,
+  generateComposeFile
+};

package/lib/infrastructure/helpers.js

@@ -0,0 +1,139 @@
+/**
+ * AI Fabrix Builder Infrastructure Helpers
+ *
+ * Helper functions for infrastructure management including directory names,
+ * Docker availability checks, and pgAdmin configuration.
+ *
+ * @fileoverview Helper functions for infrastructure management
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const path = require('path');
+const fs = require('fs');
+const handlebars = require('handlebars');
+const secrets = require('../core/secrets');
+const logger = require('../utils/logger');
+const dockerUtils = require('../utils/docker');
+const paths = require('../utils/paths');
+
+/**
+ * Gets infrastructure directory name based on developer ID
+ * Dev 0: infra (no dev-0 suffix), Dev > 0: infra-dev{id}
+ * @param {number|string} devId - Developer ID
+ * @returns {string} Infrastructure directory name
+ */
+function getInfraDirName(devId) {
+  const idNum = typeof devId === 'string' ? parseInt(devId, 10) : devId;
+  return idNum === 0 ? 'infra' : `infra-dev${devId}`;
+}
+
+/**
+ * Gets Docker Compose project name based on developer ID
+ * Dev 0: infra (no dev-0 suffix), Dev > 0: infra-dev{id}
+ * @param {number|string} devId - Developer ID
+ * @returns {string} Docker Compose project name
+ */
+function getInfraProjectName(devId) {
+  const idNum = typeof devId === 'string' ? parseInt(devId, 10) : devId;
+  return idNum === 0 ? 'infra' : `infra-dev${devId}`;
+}
+
+/**
+ * Check Docker availability
+ * @async
+ * @returns {Promise<void>}
+ * @throws {Error} If Docker is not available
+ */
+async function checkDockerAvailability() {
+  try {
+    await dockerUtils.ensureDockerAndCompose();
+  } catch (error) {
+    throw new Error('Docker or Docker Compose is not available. Please install and start Docker.');
+  }
+}
+
+/**
+ * Ensure admin secrets file exists
+ * @async
+ * @returns {Promise<string>} Path to admin secrets file
+ */
+async function ensureAdminSecrets() {
+  const adminSecretsPath = path.join(paths.getAifabrixHome(), 'admin-secrets.env');
+  if (!fs.existsSync(adminSecretsPath)) {
+    logger.log('Generating admin-secrets.env...');
+    await secrets.generateAdminSecretsEnv();
+  }
+  return adminSecretsPath;
+}
+
+/**
+ * Generates pgAdmin4 configuration files (servers.json and pgpass)
+ * @param {string} infraDir - Infrastructure directory path
+ * @param {string} postgresPassword - PostgreSQL password
+ */
+function generatePgAdminConfig(infraDir, postgresPassword) {
+  const serversJsonTemplatePath = path.join(__dirname, '..', 'templates', 'infra', 'servers.json.hbs');
+  if (!fs.existsSync(serversJsonTemplatePath)) {
+    return;
+  }
+
+  const serversJsonTemplateContent = fs.readFileSync(serversJsonTemplatePath, 'utf8');
+  const serversJsonTemplate = handlebars.compile(serversJsonTemplateContent);
+  const serversJsonContent = serversJsonTemplate({ postgresPassword });
+  const serversJsonPath = path.join(infraDir, 'servers.json');
+  fs.writeFileSync(serversJsonPath, serversJsonContent, { mode: 0o644 });
+
+  const pgpassContent = `postgres:5432:postgres:pgadmin:${postgresPassword}\n`;
+  const pgpassPath = path.join(infraDir, 'pgpass');
+  fs.writeFileSync(pgpassPath, pgpassContent, { mode: 0o600 });
+}
+
+/**
+ * Prepare infrastructure directory and extract postgres password
+ * @param {string} devId - Developer ID
+ * @param {string} adminSecretsPath - Path to admin secrets file
+ * @returns {Object} Object with infraDir and postgresPassword
+ */
+function prepareInfraDirectory(devId, adminSecretsPath) {
+  const aifabrixDir = paths.getAifabrixHome();
+  const infraDirName = getInfraDirName(devId);
+  const infraDir = path.join(aifabrixDir, infraDirName);
+  if (!fs.existsSync(infraDir)) {
+    fs.mkdirSync(infraDir, { recursive: true });
+  }
+
+  const adminSecretsContent = fs.readFileSync(adminSecretsPath, 'utf8');
+  const postgresPasswordMatch = adminSecretsContent.match(/^POSTGRES_PASSWORD=(.+)$/m);
+  const postgresPassword = postgresPasswordMatch ? postgresPasswordMatch[1] : '';
+  generatePgAdminConfig(infraDir, postgresPassword);
+
+  return { infraDir, postgresPassword };
+}
+
+/**
+ * Register Handlebars helper for equality comparison
+ */
+function registerHandlebarsHelper() {
+  handlebars.registerHelper('eq', (a, b) => {
+    // Handle null/undefined - treat as "0" for default infrastructure
+    if (a === null || a === undefined) a = '0';
+    if (b === null || b === undefined) b = '0';
+    const aNum = typeof a === 'string' && /^\d+$/.test(a) ? parseInt(a, 10) : a;
+    const bNum = typeof b === 'string' && /^\d+$/.test(b) ? parseInt(b, 10) : b;
+    if (typeof aNum === 'number' && typeof bNum === 'number') {
+      return aNum === bNum;
+    }
+    return a === b;
+  });
+}
+
+module.exports = {
+  getInfraDirName,
+  getInfraProjectName,
+  checkDockerAvailability,
+  ensureAdminSecrets,
+  generatePgAdminConfig,
+  prepareInfraDirectory,
+  registerHandlebarsHelper
+};