@aifabrix/builder 2.11.0 → 2.21.0

package/lib/external-system-deploy.js

@@ -14,7 +14,13 @@ const fsSync = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const { authenticatedApiCall } = require('./utils/api');
+const {
+  deployExternalSystemViaPipeline,
+  deployDatasourceViaPipeline,
+  uploadApplicationViaPipeline,
+  validateUploadViaPipeline,
+  publishUploadViaPipeline
+} = require('./api/pipeline.api');
 const { getDeploymentAuth } = require('./utils/token-manager');
 const { getConfig } = require('./config');
 const logger = require('./utils/logger');
@@ -155,14 +161,7 @@ async function buildExternalSystem(appName, options = {}) {
     const systemContent = await fs.readFile(systemFiles[0], 'utf8');
     const systemJson = JSON.parse(systemContent);
 
-    const systemResponse = await authenticatedApiCall(
-      `${dataplaneUrl}/api/v1/pipeline/deploy`,
-      {
-        method: 'POST',
-        body: JSON.stringify(systemJson)
-      },
-      authConfig.token
-    );
+    const systemResponse = await deployExternalSystemViaPipeline(dataplaneUrl, authConfig, systemJson);
 
     if (!systemResponse.success) {
       throw new Error(`Failed to deploy external system: ${systemResponse.error || systemResponse.formattedError}`);
@@ -178,14 +177,7 @@ async function buildExternalSystem(appName, options = {}) {
       const datasourceContent = await fs.readFile(datasourceFile, 'utf8');
       const datasourceJson = JSON.parse(datasourceContent);
 
-      const datasourceResponse = await authenticatedApiCall(
-        `${dataplaneUrl}/api/v1/pipeline/${systemKey}/deploy`,
-        {
-          method: 'POST',
-          body: JSON.stringify(datasourceJson)
-        },
-        authConfig.token
-      );
+      const datasourceResponse = await deployDatasourceViaPipeline(dataplaneUrl, systemKey, authConfig, datasourceJson);
 
       if (!datasourceResponse.success) {
         throw new Error(`Failed to deploy datasource ${datasourceName}: ${datasourceResponse.error || datasourceResponse.formattedError}`);
@@ -245,14 +237,7 @@ async function deployExternalSystem(appName, options = {}) {
 
     // Step 1: Upload application
     logger.log(chalk.blue('📤 Uploading application configuration...'));
-    const uploadResponse = await authenticatedApiCall(
-      `${dataplaneUrl}/api/v1/pipeline/upload`,
-      {
-        method: 'POST',
-        body: JSON.stringify(applicationSchema)
-      },
-      authConfig.token
-    );
+    const uploadResponse = await uploadApplicationViaPipeline(dataplaneUrl, authConfig, applicationSchema);
 
     if (!uploadResponse.success || !uploadResponse.data) {
       throw new Error(`Failed to upload application: ${uploadResponse.error || uploadResponse.formattedError || 'Unknown error'}`);
@@ -270,13 +255,7 @@ async function deployExternalSystem(appName, options = {}) {
     // Step 2: Validate upload (optional, can be skipped)
     if (!options.skipValidation) {
       logger.log(chalk.blue('🔍 Validating upload...'));
-      const validateResponse = await authenticatedApiCall(
-        `${dataplaneUrl}/api/v1/pipeline/upload/${uploadId}/validate`,
-        {
-          method: 'POST'
-        },
-        authConfig.token
-      );
+      const validateResponse = await validateUploadViaPipeline(dataplaneUrl, uploadId, authConfig);
 
       if (!validateResponse.success || !validateResponse.data) {
         throw new Error(`Validation failed: ${validateResponse.error || validateResponse.formattedError || 'Unknown error'}`);
@@ -308,13 +287,7 @@ async function deployExternalSystem(appName, options = {}) {
     const generateMcpContract = options.generateMcpContract !== false; // Default to true
     logger.log(chalk.blue(`📢 Publishing application (MCP contract: ${generateMcpContract ? 'enabled' : 'disabled'})...`));
 
-    const publishResponse = await authenticatedApiCall(
-      `${dataplaneUrl}/api/v1/pipeline/upload/${uploadId}/publish?generateMcpContract=${generateMcpContract}`,
-      {
-        method: 'POST'
-      },
-      authConfig.token
-    );
+    const publishResponse = await publishUploadViaPipeline(dataplaneUrl, uploadId, authConfig, { generateMcpContract });
 
     if (!publishResponse.success || !publishResponse.data) {
       throw new Error(`Failed to publish application: ${publishResponse.error || publishResponse.formattedError || 'Unknown error'}`);

package/lib/external-system-download.js

@@ -14,7 +14,7 @@ const path = require('path');
 const os = require('os');
 const yaml = require('js-yaml');
 const chalk = require('chalk');
-const { authenticatedApiCall } = require('./utils/api');
+const { getExternalSystemConfig } = require('./api/external-systems.api');
 const { getDeploymentAuth } = require('./utils/token-manager');
 const { getDataplaneUrl } = require('./datasource-deploy');
 const { getConfig } = require('./config');
@@ -284,14 +284,12 @@ async function downloadExternalSystem(systemKey, options = {}) {
     const dataplaneUrl = await getDataplaneUrl(controllerUrl, systemKey, environment, authConfig);
     logger.log(chalk.green(`✓ Dataplane URL: ${dataplaneUrl}`));
 
-    // Download system configuration
-    // Note: Verify this endpoint exists. Alternative: GET /api/v1/pipeline/{systemIdOrKey}
-    const downloadEndpoint = `${dataplaneUrl}/api/v1/external/systems/${systemKey}/config`;
-    logger.log(chalk.blue(`📡 Downloading from: ${downloadEndpoint}`));
+    // Download system configuration using centralized API client
+    logger.log(chalk.blue(`📡 Downloading system configuration: ${systemKey}`));
 
     if (options.dryRun) {
       logger.log(chalk.yellow('🔍 Dry run mode - would download from:'));
-      logger.log(chalk.gray(`  ${downloadEndpoint}`));
+      logger.log(chalk.gray(`  ${dataplaneUrl}/api/v1/external/systems/${systemKey}/config`));
       logger.log(chalk.yellow('\nWould create:'));
       logger.log(chalk.gray(`  integration/${systemKey}/`));
       logger.log(chalk.gray(`  integration/${systemKey}/variables.yaml`));
@@ -301,13 +299,7 @@ async function downloadExternalSystem(systemKey, options = {}) {
       return;
     }
 
-    const response = await authenticatedApiCall(
-      downloadEndpoint,
-      {
-        method: 'GET'
-      },
-      authConfig.token
-    );
+    const response = await getExternalSystemConfig(dataplaneUrl, systemKey, authConfig);
 
     if (!response.success || !response.data) {
       throw new Error(`Failed to download system configuration: ${response.error || response.formattedError || 'Unknown error'}`);

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/generator-split.js

@@ -0,0 +1,342 @@
+/**
+ * AI Fabrix Builder Deployment JSON Split Functions
+ *
+ * Helper functions for splitting deployment JSON files into component files
+ *
+ * @fileoverview Split functions for deployment JSON reverse conversion
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const yaml = require('js-yaml');
+
+/**
+ * Converts configuration array back to env.template format
+ * @function extractEnvTemplate
+ * @param {Array} configuration - Configuration array from deployment JSON
+ * @returns {string} env.template content
+ */
+function extractEnvTemplate(configuration) {
+  if (!Array.isArray(configuration) || configuration.length === 0) {
+    return '';
+  }
+
+  const lines = [];
+
+  // Generate env.template lines
+  for (const config of configuration) {
+    if (!config.name || !config.value) {
+      continue;
+    }
+
+    let value = config.value;
+    // Add kv:// prefix if location is keyvault
+    if (config.location === 'keyvault') {
+      value = `kv://${value}`;
+    }
+
+    lines.push(`${config.name}=${value}`);
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Parses image reference string into components
+ * @function parseImageReference
+ * @param {string} imageString - Full image string (e.g., "registry/name:tag")
+ * @returns {Object} Object with registry, name, and tag
+ */
+function parseImageReference(imageString) {
+  if (!imageString || typeof imageString !== 'string') {
+    return { registry: null, name: null, tag: 'latest' };
+  }
+
+  // Handle format: registry/name:tag or name:tag or registry/name
+  const parts = imageString.split('/');
+  let registry = null;
+  let nameAndTag = imageString;
+
+  if (parts.length > 1) {
+    // Check if first part looks like a registry (contains .)
+    if (parts[0].includes('.')) {
+      registry = parts[0];
+      nameAndTag = parts.slice(1).join('/');
+    } else {
+      // No registry, just name:tag
+      nameAndTag = imageString;
+    }
+  }
+
+  // Split name and tag
+  const tagIndex = nameAndTag.lastIndexOf(':');
+  let name = nameAndTag;
+  let tag = 'latest';
+
+  if (tagIndex !== -1) {
+    name = nameAndTag.substring(0, tagIndex);
+    tag = nameAndTag.substring(tagIndex + 1);
+  }
+
+  return { registry, name, tag };
+}
+
+/**
+ * Extracts deployment JSON into variables.yaml structure
+ * @function extractVariablesYaml
+ * @param {Object} deployment - Deployment JSON object
+ * @returns {Object} Variables YAML structure
+ */
+function extractVariablesYaml(deployment) {
+  if (!deployment || typeof deployment !== 'object') {
+    throw new Error('Deployment object is required');
+  }
+
+  const variables = {};
+
+  // Extract app information
+  if (deployment.key || deployment.displayName || deployment.description || deployment.type) {
+    variables.app = {};
+    if (deployment.key) variables.app.key = deployment.key;
+    if (deployment.displayName) variables.app.displayName = deployment.displayName;
+    if (deployment.description) variables.app.description = deployment.description;
+    if (deployment.type) variables.app.type = deployment.type;
+  }
+
+  // Extract image information
+  if (deployment.image) {
+    const imageParts = parseImageReference(deployment.image);
+    variables.image = {};
+    if (imageParts.name) variables.image.name = imageParts.name;
+    if (imageParts.registry) variables.image.registry = imageParts.registry;
+    if (imageParts.tag) variables.image.tag = imageParts.tag;
+    if (deployment.registryMode) variables.image.registryMode = deployment.registryMode;
+  }
+
+  // Extract port
+  if (deployment.port !== undefined) {
+    variables.port = deployment.port;
+  }
+
+  // Extract requirements
+  if (deployment.requiresDatabase || deployment.requiresRedis || deployment.requiresStorage || deployment.databases) {
+    variables.requires = {};
+    if (deployment.requiresDatabase !== undefined) variables.requires.database = deployment.requiresDatabase;
+    if (deployment.requiresRedis !== undefined) variables.requires.redis = deployment.requiresRedis;
+    if (deployment.requiresStorage !== undefined) variables.requires.storage = deployment.requiresStorage;
+    if (deployment.databases) variables.requires.databases = deployment.databases;
+  }
+
+  // Extract healthCheck
+  if (deployment.healthCheck) {
+    variables.healthCheck = deployment.healthCheck;
+  }
+
+  // Extract authentication
+  if (deployment.authentication) {
+    variables.authentication = { ...deployment.authentication };
+  }
+
+  // Extract build
+  if (deployment.build) {
+    variables.build = deployment.build;
+  }
+
+  // Extract repository
+  if (deployment.repository) {
+    variables.repository = deployment.repository;
+  }
+
+  // Extract deployment config
+  if (deployment.deployment) {
+    variables.deployment = deployment.deployment;
+  }
+
+  // Extract other optional fields
+  if (deployment.startupCommand) {
+    variables.startupCommand = deployment.startupCommand;
+  }
+  if (deployment.runtimeVersion) {
+    variables.runtimeVersion = deployment.runtimeVersion;
+  }
+  if (deployment.scaling) {
+    variables.scaling = deployment.scaling;
+  }
+  if (deployment.frontDoorRouting) {
+    variables.frontDoorRouting = deployment.frontDoorRouting;
+  }
+
+  // Extract roles and permissions (if present)
+  if (deployment.roles) {
+    variables.roles = deployment.roles;
+  }
+  if (deployment.permissions) {
+    variables.permissions = deployment.permissions;
+  }
+
+  return variables;
+}
+
+/**
+ * Extracts roles and permissions from deployment JSON
+ * @function extractRbacYaml
+ * @param {Object} deployment - Deployment JSON object
+ * @returns {Object|null} RBAC YAML structure or null if no roles/permissions
+ */
+function extractRbacYaml(deployment) {
+  if (!deployment || typeof deployment !== 'object') {
+    return null;
+  }
+
+  const hasRoles = deployment.roles && Array.isArray(deployment.roles) && deployment.roles.length > 0;
+  const hasPermissions = deployment.permissions && Array.isArray(deployment.permissions) && deployment.permissions.length > 0;
+
+  if (!hasRoles && !hasPermissions) {
+    return null;
+  }
+
+  const rbac = {};
+  if (hasRoles) {
+    rbac.roles = deployment.roles;
+  }
+  if (hasPermissions) {
+    rbac.permissions = deployment.permissions;
+  }
+
+  return rbac;
+}
+
+/**
+ * Generates README.md content from deployment JSON
+ * @function generateReadmeFromDeployJson
+ * @param {Object} deployment - Deployment JSON object
+ * @returns {string} README.md content
+ */
+function generateReadmeFromDeployJson(deployment) {
+  if (!deployment || typeof deployment !== 'object') {
+    throw new Error('Deployment object is required');
+  }
+
+  const appName = deployment.key || 'application';
+  const displayName = deployment.displayName || appName;
+  const description = deployment.description || 'Application deployment configuration';
+  const port = deployment.port || 3000;
+  const image = deployment.image || 'unknown';
+
+  const lines = [
+    `# ${displayName}`,
+    '',
+    description,
+    '',
+    '## Quick Start',
+    '',
+    'This application is configured via deployment JSON and component files.',
+    '',
+    '## Configuration',
+    '',
+    `- **Application Key**: \`${appName}\``,
+    `- **Port**: \`${port}\``,
+    `- **Image**: \`${image}\``,
+    '',
+    '## Files',
+    '',
+    '- `variables.yaml` - Application configuration',
+    '- `env.template` - Environment variables template',
+    '- `rbac.yml` - Roles and permissions (if applicable)',
+    '- `README.md` - This file',
+    '',
+    '## Documentation',
+    '',
+    'For more information, see the [AI Fabrix Builder documentation](../../docs/README.md).'
+  ];
+
+  return lines.join('\n');
+}
+
+/**
+ * Splits a deployment JSON file into component files
+ * @async
+ * @function splitDeployJson
+ * @param {string} deployJsonPath - Path to deployment JSON file
+ * @param {string} [outputDir] - Directory to write component files (defaults to same directory as JSON)
+ * @returns {Promise<Object>} Object with paths to generated files
+ * @throws {Error} If JSON file not found or invalid
+ */
+async function splitDeployJson(deployJsonPath, outputDir = null) {
+  if (!deployJsonPath || typeof deployJsonPath !== 'string') {
+    throw new Error('Deployment JSON path is required and must be a string');
+  }
+
+  // Validate file exists
+  const fsSync = require('fs');
+  if (!fsSync.existsSync(deployJsonPath)) {
+    throw new Error(`Deployment JSON file not found: ${deployJsonPath}`);
+  }
+
+  // Determine output directory
+  const finalOutputDir = outputDir || path.dirname(deployJsonPath);
+
+  // Ensure output directory exists
+  if (!fsSync.existsSync(finalOutputDir)) {
+    await fs.mkdir(finalOutputDir, { recursive: true });
+  }
+
+  // Load and parse deployment JSON
+  let deployment;
+  try {
+    const jsonContent = await fs.readFile(deployJsonPath, 'utf8');
+    deployment = JSON.parse(jsonContent);
+  } catch (error) {
+    if (error.code === 'ENOENT') {
+      throw new Error(`Deployment JSON file not found: ${deployJsonPath}`);
+    }
+    throw new Error(`Invalid JSON syntax in deployment file: ${error.message}`);
+  }
+
+  // Extract components
+  const envTemplate = extractEnvTemplate(deployment.configuration || []);
+  const variables = extractVariablesYaml(deployment);
+  const rbac = extractRbacYaml(deployment);
+  const readme = generateReadmeFromDeployJson(deployment);
+
+  // Write component files
+  const results = {};
+
+  // Write env.template
+  const envTemplatePath = path.join(finalOutputDir, 'env.template');
+  await fs.writeFile(envTemplatePath, envTemplate, { mode: 0o644, encoding: 'utf8' });
+  results.envTemplate = envTemplatePath;
+
+  // Write variables.yaml
+  const variablesPath = path.join(finalOutputDir, 'variables.yaml');
+  const variablesYaml = yaml.dump(variables, { indent: 2, lineWidth: -1 });
+  await fs.writeFile(variablesPath, variablesYaml, { mode: 0o644, encoding: 'utf8' });
+  results.variables = variablesPath;
+
+  // Write rbac.yml (only if roles/permissions exist)
+  if (rbac) {
+    const rbacPath = path.join(finalOutputDir, 'rbac.yml');
+    const rbacYaml = yaml.dump(rbac, { indent: 2, lineWidth: -1 });
+    await fs.writeFile(rbacPath, rbacYaml, { mode: 0o644, encoding: 'utf8' });
+    results.rbac = rbacPath;
+  }
+
+  // Write README.md
+  const readmePath = path.join(finalOutputDir, 'README.md');
+  await fs.writeFile(readmePath, readme, { mode: 0o644, encoding: 'utf8' });
+  results.readme = readmePath;
+
+  return results;
+}
+
+module.exports = {
+  splitDeployJson,
+  extractEnvTemplate,
+  extractVariablesYaml,
+  extractRbacYaml,
+  parseImageReference,
+  generateReadmeFromDeployJson
+};
+

package/lib/generator.js

@@ -18,6 +18,7 @@ const _keyGenerator = require('./key-generator');
 const _validator = require('./validator');
 const builders = require('./generator-builders');
 const { detectAppType, getDeployJsonPath } = require('./utils/paths');
+const splitFunctions = require('./generator-split');
 
 /**
  * Loads variables.yaml file
@@ -161,8 +162,8 @@ async function generateDeployJson(appName) {
   const envTemplate = loadEnvTemplate(templatePath);
   const rbac = loadRbac(rbacPath);
 
-  // Parse environment variables from template
-  const configuration = parseEnvironmentVariables(envTemplate);
+  // Parse environment variables from template and merge portalInput from variables.yaml
+  const configuration = parseEnvironmentVariables(envTemplate, variables);
 
   // Build deployment manifest WITHOUT deploymentKey initially
   const deployment = builders.buildManifestStructure(appName, variables, null, configuration, rbac);
@@ -187,10 +188,85 @@ async function generateDeployJson(appName) {
   return jsonPath;
 }
 
-function parseEnvironmentVariables(envTemplate) {
+/**
+ * Validates portalInput structure against schema requirements
+ * @param {Object} portalInput - Portal input configuration to validate
+ * @param {string} variableName - Variable name for error messages
+ * @throws {Error} If portalInput structure is invalid
+ */
+function validatePortalInput(portalInput, variableName) {
+  if (!portalInput || typeof portalInput !== 'object') {
+    throw new Error(`Invalid portalInput for variable '${variableName}': must be an object`);
+  }
+
+  // Check required fields
+  if (!portalInput.field || typeof portalInput.field !== 'string') {
+    throw new Error(`Invalid portalInput for variable '${variableName}': field is required and must be a string`);
+  }
+
+  if (!portalInput.label || typeof portalInput.label !== 'string') {
+    throw new Error(`Invalid portalInput for variable '${variableName}': label is required and must be a string`);
+  }
+
+  // Validate field type
+  const validFieldTypes = ['password', 'text', 'textarea', 'select'];
+  if (!validFieldTypes.includes(portalInput.field)) {
+    throw new Error(`Invalid portalInput for variable '${variableName}': field must be one of: ${validFieldTypes.join(', ')}`);
+  }
+
+  // Validate select field requires options
+  if (portalInput.field === 'select') {
+    if (!portalInput.options || !Array.isArray(portalInput.options) || portalInput.options.length === 0) {
+      throw new Error(`Invalid portalInput for variable '${variableName}': select field requires a non-empty options array`);
+    }
+  }
+
+  // Validate optional fields
+  if (portalInput.placeholder !== undefined && typeof portalInput.placeholder !== 'string') {
+    throw new Error(`Invalid portalInput for variable '${variableName}': placeholder must be a string`);
+  }
+
+  if (portalInput.masked !== undefined && typeof portalInput.masked !== 'boolean') {
+    throw new Error(`Invalid portalInput for variable '${variableName}': masked must be a boolean`);
+  }
+
+  if (portalInput.validation !== undefined) {
+    if (typeof portalInput.validation !== 'object' || Array.isArray(portalInput.validation)) {
+      throw new Error(`Invalid portalInput for variable '${variableName}': validation must be an object`);
+    }
+  }
+
+  if (portalInput.options !== undefined && portalInput.field !== 'select') {
+    // Options should only be present for select fields
+    if (Array.isArray(portalInput.options) && portalInput.options.length > 0) {
+      throw new Error(`Invalid portalInput for variable '${variableName}': options can only be used with select field type`);
+    }
+  }
+}
+
+/**
+ * Parses environment variables from env.template and merges portalInput from variables.yaml
+ * @param {string} envTemplate - Content of env.template file
+ * @param {Object|null} [variablesConfig=null] - Optional configuration from variables.yaml
+ * @returns {Array<Object>} Configuration array with merged portalInput
+ * @throws {Error} If portalInput structure is invalid
+ */
+function parseEnvironmentVariables(envTemplate, variablesConfig = null) {
   const configuration = [];
   const lines = envTemplate.split('\n');
 
+  // Create a map of portalInput configurations by variable name
+  const portalInputMap = new Map();
+  if (variablesConfig && variablesConfig.configuration && Array.isArray(variablesConfig.configuration)) {
+    for (const configItem of variablesConfig.configuration) {
+      if (configItem.name && configItem.portalInput) {
+        // Validate portalInput before adding to map
+        validatePortalInput(configItem.portalInput, configItem.name);
+        portalInputMap.set(configItem.name, configItem.portalInput);
+      }
+    }
+  }
+
   for (const line of lines) {
     const trimmed = line.trim();
 
@@ -227,12 +303,19 @@ function parseEnvironmentVariables(envTemplate) {
       required = true;
     }
 
-    configuration.push({
+    const configItem = {
       name: key,
       value: value.replace('kv://', ''), // Remove kv:// prefix for KeyVault
       location,
       required
-    });
+    };
+
+    // Merge portalInput if it exists in variables.yaml
+    if (portalInputMap.has(key)) {
+      configItem.portalInput = portalInputMap.get(key);
+    }
+
+    configuration.push(configItem);
   }
 
   return configuration;
@@ -399,6 +482,12 @@ module.exports = {
   generateDeployJsonWithValidation,
   generateExternalSystemApplicationSchema,
   parseEnvironmentVariables,
+  splitDeployJson: splitFunctions.splitDeployJson,
+  extractEnvTemplate: splitFunctions.extractEnvTemplate,
+  extractVariablesYaml: splitFunctions.extractVariablesYaml,
+  extractRbacYaml: splitFunctions.extractRbacYaml,
+  parseImageReference: splitFunctions.parseImageReference,
+  generateReadmeFromDeployJson: splitFunctions.generateReadmeFromDeployJson,
   buildImageReference: builders.buildImageReference,
   buildHealthCheck: builders.buildHealthCheck,
   buildRequirements: builders.buildRequirements,