@aifabrix/builder 2.0.0 → 2.0.3

package/lib/utils/logger.js

@@ -0,0 +1,53 @@
+/**
+ * Logger Utility
+ *
+ * Centralized logging utility that wraps console methods
+ * Allows disabling eslint warnings in one place
+ *
+ * @fileoverview Logger utility for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/* eslint-disable no-console */
+
+/**
+ * Logger utility that wraps console methods
+ * All console statements should use this logger to avoid eslint warnings
+ */
+const logger = {
+  /**
+   * Log informational message
+   * @param {...any} args - Arguments to log
+   */
+  log: (...args) => {
+    console.log(...args);
+  },
+
+  /**
+   * Log error message
+   * @param {...any} args - Arguments to log
+   */
+  error: (...args) => {
+    console.error(...args);
+  },
+
+  /**
+   * Log warning message
+   * @param {...any} args - Arguments to log
+   */
+  warn: (...args) => {
+    console.warn(...args);
+  },
+
+  /**
+   * Log informational message (alias for log)
+   * @param {...any} args - Arguments to log
+   */
+  info: (...args) => {
+    console.log(...args);
+  }
+};
+
+module.exports = logger;
+

package/lib/utils/template-helpers.js

@@ -0,0 +1,223 @@
+/**
+ * Template Helper Utilities
+ *
+ * Handles template variable loading, updating, and merging
+ *
+ * @fileoverview Template helper utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const fs = require('fs').promises;
+const path = require('path');
+const chalk = require('chalk');
+const logger = require('./logger');
+
+/**
+ * Loads template variables from template's variables.yaml file
+ * @async
+ * @function loadTemplateVariables
+ * @param {string} templateName - Template name
+ * @returns {Promise<Object|null>} Template variables or null if not found
+ */
+async function loadTemplateVariables(templateName) {
+  if (!templateName) {
+    return null;
+  }
+
+  const yaml = require('js-yaml');
+  const templatePath = path.join(__dirname, '..', '..', 'templates', 'applications', templateName);
+  const templateVariablesPath = path.join(templatePath, 'variables.yaml');
+
+  try {
+    const templateContent = await fs.readFile(templateVariablesPath, 'utf8');
+    return yaml.load(templateContent);
+  } catch (error) {
+    // Template variables.yaml not found or invalid, continue without it
+    if (error.code !== 'ENOENT') {
+      logger.warn(chalk.yellow(`⚠️  Warning: Could not load template variables.yaml: ${error.message}`));
+    }
+    return null;
+  }
+}
+
+/**
+ * Updates app key and display name in variables
+ * @function updateAppMetadata
+ * @param {Object} variables - Variables object
+ * @param {string} appName - Application name
+ */
+function updateAppMetadata(variables, appName) {
+  if (variables.app) {
+    variables.app.key = appName;
+  }
+
+  if (variables.app?.displayName && variables.app.displayName.toLowerCase().includes('miso')) {
+    variables.app.displayName = appName.replace(/-/g, ' ').replace(/\b\w/g, l => l.toUpperCase());
+  }
+}
+
+/**
+ * Updates port in variables if provided
+ * @function updatePort
+ * @param {Object} variables - Variables object
+ * @param {Object} options - CLI options
+ * @param {Object} config - Final configuration
+ */
+function updatePort(variables, options, config) {
+  if (options.port && config.port && variables.port !== config.port) {
+    variables.port = config.port;
+  }
+}
+
+/**
+ * Updates build configuration
+ * @function updateBuildConfig
+ * @param {Object} variables - Variables object
+ */
+function updateBuildConfig(variables) {
+  if (variables.build && variables.build.envOutputPath) {
+    variables.build.envOutputPath = null;
+  }
+}
+
+/**
+ * Updates database configuration for --app flag
+ * @function updateDatabaseConfig
+ * @param {Object} variables - Variables object
+ * @param {Object} options - CLI options
+ * @param {string} appName - Application name
+ */
+function updateDatabaseConfig(variables, options, appName) {
+  if (!options.app || !variables.requires) {
+    return;
+  }
+
+  if (variables.requires.databases) {
+    variables.requires.databases = [{ name: appName }];
+  } else if (variables.requires.database && !variables.requires.databases) {
+    variables.requires.databases = [{ name: appName }];
+  }
+}
+
+/**
+ * Updates variables.yaml file after copying from template
+ * Updates app.key, displayName, and port with actual values
+ * @async
+ * @function updateTemplateVariables
+ * @param {string} appPath - Application directory path
+ * @param {string} appName - Application name
+ * @param {Object} options - CLI options
+ * @param {Object} config - Final configuration
+ */
+async function updateTemplateVariables(appPath, appName, options, config) {
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  try {
+    const yaml = require('js-yaml');
+    const variablesContent = await fs.readFile(variablesPath, 'utf8');
+    const variables = yaml.load(variablesContent);
+
+    updateAppMetadata(variables, appName);
+    updatePort(variables, options, config);
+    updateBuildConfig(variables);
+    updateDatabaseConfig(variables, options, appName);
+
+    await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }));
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      logger.warn(chalk.yellow(`⚠️  Warning: Could not update variables.yaml: ${error.message}`));
+    }
+  }
+}
+
+/**
+ * Merges port from template variables if not in options
+ * @function mergePort
+ * @param {Object} merged - Merged options object
+ * @param {Object} templateVariables - Template variables
+ */
+function mergePort(merged, templateVariables) {
+  if (!merged.port && templateVariables.port) {
+    merged.port = templateVariables.port;
+  }
+}
+
+/**
+ * Merges language from template variables if not in options
+ * @function mergeLanguage
+ * @param {Object} merged - Merged options object
+ * @param {Object} templateVariables - Template variables
+ */
+function mergeLanguage(merged, templateVariables) {
+  if (!merged.language && templateVariables.build?.language) {
+    merged.language = templateVariables.build.language;
+  }
+}
+
+/**
+ * Merges service requirements from template variables if not in options
+ * @function mergeServices
+ * @param {Object} merged - Merged options object
+ * @param {Object} templateVariables - Template variables
+ */
+function mergeServices(merged, templateVariables) {
+  // Database: use template requires.database if not specified in options
+  if (!Object.prototype.hasOwnProperty.call(merged, 'database') &&
+      templateVariables.requires?.database !== undefined) {
+    merged.database = templateVariables.requires.database;
+  }
+
+  // Redis: use template requires.redis if not specified in options
+  if (!Object.prototype.hasOwnProperty.call(merged, 'redis') &&
+      templateVariables.requires?.redis !== undefined) {
+    merged.redis = templateVariables.requires.redis;
+  }
+
+  // Storage: use template requires.storage if not specified in options
+  if (!Object.prototype.hasOwnProperty.call(merged, 'storage') &&
+      templateVariables.requires?.storage !== undefined) {
+    merged.storage = templateVariables.requires.storage;
+  }
+}
+
+/**
+ * Merges authentication from template variables if not in options
+ * @function mergeAuthentication
+ * @param {Object} merged - Merged options object
+ * @param {Object} templateVariables - Template variables
+ */
+function mergeAuthentication(merged, templateVariables) {
+  if (!Object.prototype.hasOwnProperty.call(merged, 'authentication') &&
+      templateVariables.authentication !== undefined) {
+    merged.authentication = !!templateVariables.authentication;
+  }
+}
+
+/**
+ * Merges template variables into options
+ * @function mergeTemplateVariables
+ * @param {Object} options - User-provided options
+ * @param {Object} templateVariables - Template variables from variables.yaml
+ * @returns {Object} Merged options object
+ */
+function mergeTemplateVariables(options, templateVariables) {
+  if (!templateVariables) {
+    return options;
+  }
+
+  const merged = { ...options };
+
+  mergePort(merged, templateVariables);
+  mergeLanguage(merged, templateVariables);
+  mergeServices(merged, templateVariables);
+  mergeAuthentication(merged, templateVariables);
+
+  return merged;
+}
+
+module.exports = {
+  loadTemplateVariables,
+  updateTemplateVariables,
+  mergeTemplateVariables
+};
+

package/lib/utils/variable-transformer.js

@@ -0,0 +1,271 @@
+/**
+ * Variable Transformation Utilities
+ *
+ * Transforms nested variables.yaml structure to flat schema format
+ * Converts app.*, image.*, requires.* to schema-compatible structure
+ *
+ * @fileoverview Variable transformation utilities for AI Fabrix Builder
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+/**
+ * Sanitizes authentication type - map keycloak to azure (schema allows: azure, local, none)
+ * @function sanitizeAuthType
+ * @param {string} authType - Authentication type
+ * @returns {string} Sanitized authentication type
+ */
+function sanitizeAuthType(authType) {
+  if (authType === 'keycloak') {
+    return 'azure';
+  }
+  if (authType && !['azure', 'local', 'none'].includes(authType)) {
+    return 'azure'; // Default to azure if invalid type
+  }
+  return authType;
+}
+
+/**
+ * Transforms flat structure to schema-compatible format
+ * @function transformFlatStructure
+ * @param {Object} variables - Raw variables from YAML
+ * @param {string} appName - Application name (fallback)
+ * @returns {Object} Transformed variables matching schema
+ */
+function transformFlatStructure(variables, appName) {
+  const result = {
+    key: variables.key || appName,
+    displayName: variables.displayName || appName,
+    description: variables.description || '',
+    type: variables.type || 'webapp',
+    image: variables.image,
+    registryMode: variables.registryMode || 'external',
+    port: variables.port || 3000,
+    requiresDatabase: variables.requiresDatabase || false,
+    requiresRedis: variables.requiresRedis || false,
+    requiresStorage: variables.requiresStorage || false,
+    databases: variables.databases || [],
+    ...variables
+  };
+
+  // Sanitize authentication if present
+  if (result.authentication && result.authentication.type) {
+    result.authentication = {
+      ...result.authentication,
+      type: sanitizeAuthType(result.authentication.type)
+    };
+  }
+
+  return result;
+}
+
+/**
+ * Builds image reference string from variables
+ * @function buildImageReference
+ * @param {Object} variables - Variables configuration
+ * @param {string} appName - Application name (fallback)
+ * @returns {string} Image reference string
+ */
+function buildImageReference(variables, appName) {
+  const imageName = variables.image?.name || variables.app?.key || appName;
+  const registry = variables.image?.registry;
+  const tag = variables.image?.tag || 'latest';
+  return registry ? `${registry}/${imageName}:${tag}` : `${imageName}:${tag}`;
+}
+
+/**
+ * Validates repository URL format
+ * @function validateRepositoryUrl
+ * @param {string} url - Repository URL
+ * @returns {boolean} True if valid
+ */
+function validateRepositoryUrl(url) {
+  if (!url || url.trim() === '') {
+    return false;
+  }
+  const repoPattern = /^(https:\/\/github\.com\/[^/]+\/[^/]+|https:\/\/gitlab\.com\/[^/]+\/[^/]+|https:\/\/dev\.azure\.com\/[^/]+\/[^/]+\/[^/]+)$/;
+  return repoPattern.test(url);
+}
+
+/**
+ * Validates and transforms repository configuration
+ * @function validateRepositoryConfig
+ * @param {Object} repository - Repository configuration
+ * @returns {Object|null} Validated repository config or null
+ */
+function validateRepositoryConfig(repository) {
+  if (!repository) {
+    return null;
+  }
+
+  const repo = { enabled: repository.enabled || false };
+  if (validateRepositoryUrl(repository.repositoryUrl)) {
+    repo.repositoryUrl = repository.repositoryUrl;
+  }
+
+  if (repo.enabled || repo.repositoryUrl) {
+    return repo;
+  }
+
+  return null;
+}
+
+/**
+ * Validates and transforms build configuration
+ * @function validateBuildConfig
+ * @param {Object} build - Build configuration
+ * @returns {Object|null} Validated build config or null
+ */
+function validateBuildConfig(build) {
+  if (!build) {
+    return null;
+  }
+
+  const buildConfig = {};
+  if (build.envOutputPath) {
+    buildConfig.envOutputPath = build.envOutputPath;
+  }
+  if (build.secrets !== null && build.secrets !== undefined && build.secrets !== '') {
+    buildConfig.secrets = build.secrets;
+  }
+  if (build.localPort) {
+    buildConfig.localPort = build.localPort;
+  }
+  if (build.language) {
+    buildConfig.language = build.language;
+  }
+  if (build.context) {
+    buildConfig.context = build.context;
+  }
+  if (build.dockerfile && build.dockerfile.trim() !== '') {
+    buildConfig.dockerfile = build.dockerfile;
+  }
+
+  return Object.keys(buildConfig).length > 0 ? buildConfig : null;
+}
+
+/**
+ * Validates and transforms deployment configuration
+ * @function validateDeploymentConfig
+ * @param {Object} deployment - Deployment configuration
+ * @returns {Object|null} Validated deployment config or null
+ */
+function validateDeploymentConfig(deployment) {
+  if (!deployment) {
+    return null;
+  }
+
+  const deploymentConfig = {};
+  if (deployment.controllerUrl && deployment.controllerUrl.trim() !== '' && /^https:\/\/.*$/.test(deployment.controllerUrl)) {
+    deploymentConfig.controllerUrl = deployment.controllerUrl;
+  }
+  if (deployment.clientId && deployment.clientId.trim() !== '' && /^[a-z0-9-]+$/.test(deployment.clientId)) {
+    deploymentConfig.clientId = deployment.clientId;
+  }
+  if (deployment.clientSecret && deployment.clientSecret.trim() !== '' && /^(kv:\/\/.*|.+)$/.test(deployment.clientSecret)) {
+    deploymentConfig.clientSecret = deployment.clientSecret;
+  }
+
+  return Object.keys(deploymentConfig).length > 0 ? deploymentConfig : null;
+}
+
+/**
+ * Transforms optional fields from variables
+ * @function transformOptionalFields
+ * @param {Object} variables - Raw variables from YAML
+ * @param {Object} transformed - Base transformed object
+ * @returns {Object} Transformed object with optional fields added
+ */
+function transformOptionalFields(variables, transformed) {
+  if (variables.healthCheck) {
+    transformed.healthCheck = variables.healthCheck;
+  }
+
+  if (variables.authentication) {
+    transformed.authentication = {
+      ...variables.authentication,
+      type: sanitizeAuthType(variables.authentication.type)
+    };
+  }
+
+  const repository = validateRepositoryConfig(variables.repository);
+  if (repository) {
+    transformed.repository = repository;
+  }
+
+  const build = validateBuildConfig(variables.build);
+  if (build) {
+    transformed.build = build;
+  }
+
+  const deployment = validateDeploymentConfig(variables.deployment);
+  if (deployment) {
+    transformed.deployment = deployment;
+  }
+
+  if (variables.startupCommand) {
+    transformed.startupCommand = variables.startupCommand;
+  }
+  if (variables.runtimeVersion) {
+    transformed.runtimeVersion = variables.runtimeVersion;
+  }
+  if (variables.scaling) {
+    transformed.scaling = variables.scaling;
+  }
+  if (variables.frontDoorRouting) {
+    transformed.frontDoorRouting = variables.frontDoorRouting;
+  }
+  if (variables.roles) {
+    transformed.roles = variables.roles;
+  }
+  if (variables.permissions) {
+    transformed.permissions = variables.permissions;
+  }
+
+  return transformed;
+}
+
+/**
+ * Transforms nested variables.yaml structure to flat schema format
+ * Converts app.*, image.*, requires.* to schema-compatible structure
+ * Handles both flat and nested structures
+ *
+ * @function transformVariablesForValidation
+ * @param {Object} variables - Raw variables from YAML
+ * @param {string} appName - Application name (fallback)
+ * @returns {Object} Transformed variables matching schema
+ */
+function transformVariablesForValidation(variables, appName) {
+  // Check if structure is already flat (has key, displayName, image as string)
+  const isFlat = variables.key && variables.image && typeof variables.image === 'string';
+
+  if (isFlat) {
+    return transformFlatStructure(variables, appName);
+  }
+
+  // Nested structure - transform it
+  const requires = variables.requires || {};
+  const imageRef = buildImageReference(variables, appName);
+
+  // Transform to flat schema structure
+  const transformed = {
+    key: variables.app?.key || appName,
+    displayName: variables.app?.displayName || appName,
+    description: variables.app?.description || '',
+    type: variables.app?.type || 'webapp',
+    image: imageRef,
+    registryMode: variables.image?.registryMode || 'external',
+    port: variables.port || 3000,
+    requiresDatabase: requires.database || false,
+    requiresRedis: requires.redis || false,
+    requiresStorage: requires.storage || false,
+    databases: requires.databases || (requires.database ? [{ name: variables.app?.key || appName }] : [])
+  };
+
+  return transformOptionalFields(variables, transformed);
+}
+
+module.exports = {
+  transformVariablesForValidation
+};
+