@aifabrix/builder 2.0.0 → 2.0.2

package/lib/app.js

@@ -11,206 +11,223 @@
 
 const fs = require('fs').promises;
 const path = require('path');
-const inquirer = require('inquirer');
 const chalk = require('chalk');
-const yaml = require('js-yaml');
-const { generateVariablesYaml, generateEnvTemplate, generateRbacYaml } = require('./templates');
-const { readExistingEnv, generateEnvTemplate: generateEnvTemplateFromReader } = require('./env-reader');
+const { readExistingEnv } = require('./env-reader');
 const build = require('./build');
 const appRun = require('./app-run');
-const pushUtils = require('./push');
+const { validateTemplate, copyTemplateFiles, copyAppFiles } = require('./template-validator');
+const { promptForOptions } = require('./app-prompts');
+const { generateConfigFiles } = require('./app-config');
+const { validateAppName, pushApp } = require('./app-push');
+const { generateDockerfileForApp } = require('./app-dockerfile');
+const { loadTemplateVariables, updateTemplateVariables, mergeTemplateVariables } = require('./utils/template-helpers');
+const logger = require('./utils/logger');
 
 /**
- * Validate application name format
- * @param {string} appName - Application name to validate
- * @throws {Error} If app name is invalid
+ * Displays success message after app creation
+ * @param {string} appName - Application name
+ * @param {Object} config - Final configuration
+ * @param {string} envConversionMessage - Environment conversion message
  */
-function validateAppName(appName) {
-  if (!appName || typeof appName !== 'string') {
-    throw new Error('Application name is required');
+function displaySuccessMessage(appName, config, envConversionMessage, hasAppFiles = false) {
+  logger.log(chalk.green('\n✓ Application created successfully!'));
+  logger.log(chalk.blue(`\nApplication: ${appName}`));
+  logger.log(chalk.blue(`Location: builder/${appName}/`));
+  if (hasAppFiles) {
+    logger.log(chalk.blue(`Application files: apps/${appName}/`));
   }
+  logger.log(chalk.blue(`Language: ${config.language}`));
+  logger.log(chalk.blue(`Port: ${config.port}`));
 
-  // App name should be lowercase, alphanumeric with dashes, 3-40 characters
-  const nameRegex = /^[a-z0-9-]{3,40}$/;
-  if (!nameRegex.test(appName)) {
-    throw new Error('Application name must be 3-40 characters, lowercase letters, numbers, and dashes only');
-  }
+  if (config.database) logger.log(chalk.yellow('  - Database enabled'));
+  if (config.redis) logger.log(chalk.yellow('  - Redis enabled'));
+  if (config.storage) logger.log(chalk.yellow('  - Storage enabled'));
+  if (config.authentication) logger.log(chalk.yellow('  - Authentication enabled'));
 
-  // Cannot start or end with dash
-  if (appName.startsWith('-') || appName.endsWith('-')) {
-    throw new Error('Application name cannot start or end with a dash');
-  }
+  logger.log(chalk.gray(envConversionMessage));
 
-  // Cannot have consecutive dashes
-  if (appName.includes('--')) {
-    throw new Error('Application name cannot have consecutive dashes');
-  }
+  logger.log(chalk.green('\nNext steps:'));
+  logger.log(chalk.white('1. Copy env.template to .env and fill in your values'));
+  logger.log(chalk.white('2. Run: aifabrix build ' + appName));
+  logger.log(chalk.white('3. Run: aifabrix run ' + appName));
 }
 
 /**
- * Prompt for missing configuration options
+ * Validates that app directory doesn't already exist
+ * @async
+ * @param {string} appPath - Application directory path
  * @param {string} appName - Application name
- * @param {Object} options - Provided options
- * @returns {Promise<Object>} Complete configuration
+ * @throws {Error} If directory already exists
  */
-async function promptForOptions(appName, options) {
-  const questions = [];
-
-  // Port validation
-  if (!options.port) {
-    questions.push({
-      type: 'input',
-      name: 'port',
-      message: 'What port should the application run on?',
-      default: '3000',
-      validate: (input) => {
-        const port = parseInt(input, 10);
-        if (isNaN(port) || port < 1 || port > 65535) {
-          return 'Port must be a number between 1 and 65535';
-        }
-        return true;
-      }
-    });
+async function validateAppDirectoryNotExists(appPath, appName, baseDir = 'builder') {
+  try {
+    await fs.access(appPath);
+    throw new Error(`Application '${appName}' already exists in ${baseDir}/${appName}/`);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
   }
+}
 
-  // Language selection
-  if (!options.language) {
-    questions.push({
-      type: 'list',
-      name: 'language',
-      message: 'What language is your application written in?',
-      choices: [
-        { name: 'TypeScript/Node.js', value: 'typescript' },
-        { name: 'Python', value: 'python' }
-      ],
-      default: 'typescript'
-    });
+/**
+ * Handles GitHub workflow generation if requested
+ * @async
+ * @param {Object} options - Creation options
+ * @param {Object} config - Final configuration
+ */
+async function handleGitHubWorkflows(options, config) {
+  if (!options.github) {
+    return;
   }
 
-  // Service options
-  if (!Object.prototype.hasOwnProperty.call(options, 'database')) {
-    questions.push({
-      type: 'confirm',
-      name: 'database',
-      message: 'Does your application need a database?',
-      default: false
-    });
-  }
+  const githubGen = require('./github-generator');
+
+  // Parse github-steps if provided
+  const githubSteps = options.githubSteps
+    ? options.githubSteps.split(',').map(s => s.trim()).filter(s => s.length > 0)
+    : [];
+
+  const workflowFiles = await githubGen.generateGithubWorkflows(
+    process.cwd(),
+    config,
+    {
+      mainBranch: options.mainBranch || 'main',
+      uploadCoverage: true,
+      githubSteps: githubSteps
+    }
+  );
+
+  logger.log(chalk.green('✓ Generated GitHub Actions workflows:'));
+  workflowFiles.forEach(file => logger.log(chalk.gray(`  - ${file}`)));
+}
+
+/**
+ * Validates app creation prerequisites
+ * @async
+ * @function validateAppCreation
+ * @param {string} appName - Application name
+ * @param {Object} options - Creation options
+ * @param {string} appPath - Application directory path
+ * @throws {Error} If validation fails
+ */
+async function validateAppCreation(appName, options, appPath) {
+  validateAppName(appName);
+  await validateAppDirectoryNotExists(appPath, appName, 'builder');
 
-  if (!Object.prototype.hasOwnProperty.call(options, 'redis')) {
-    questions.push({
-      type: 'confirm',
-      name: 'redis',
-      message: 'Does your application need Redis?',
-      default: false
-    });
+  if (!options.app) {
+    return;
   }
 
-  if (!Object.prototype.hasOwnProperty.call(options, 'storage')) {
-    questions.push({
-      type: 'confirm',
-      name: 'storage',
-      message: 'Does your application need file storage?',
-      default: false
-    });
+  const appsPath = path.join(process.cwd(), 'apps', appName);
+  try {
+    await fs.access(appsPath);
+    throw new Error(`Application '${appName}' already exists in apps/${appName}/`);
+  } catch (error) {
+    if (error.code !== 'ENOENT') {
+      throw error;
+    }
   }
+}
 
-  if (!Object.prototype.hasOwnProperty.call(options, 'authentication')) {
-    questions.push({
-      type: 'confirm',
-      name: 'authentication',
-      message: 'Does your application need authentication/RBAC?',
-      default: false
-    });
+/**
+ * Processes template files if template is specified
+ * @async
+ * @function processTemplateFiles
+ * @param {string} template - Template name
+ * @param {string} appPath - Application directory path
+ * @param {string} appName - Application name
+ * @param {Object} options - Creation options
+ * @param {Object} config - Final configuration
+ * @throws {Error} If template processing fails
+ */
+async function processTemplateFiles(template, appPath, appName, options, config) {
+  if (!template) {
+    return;
   }
 
-  // Prompt for missing options
-  const answers = questions.length > 0 ? await inquirer.prompt(questions) : {};
-
-  // Merge provided options with answers
-  return {
-    appName,
-    port: parseInt(options.port || answers.port || 3000, 10),
-    language: options.language || answers.language || 'typescript',
-    database: options.database || answers.database || false,
-    redis: options.redis || answers.redis || false,
-    storage: options.storage || answers.storage || false,
-    authentication: options.authentication || answers.authentication || false
-  };
+  await validateTemplate(template);
+  const copiedFiles = await copyTemplateFiles(template, appPath);
+  logger.log(chalk.green(`✓ Copied ${copiedFiles.length} file(s) from template '${template}'`));
+  await updateTemplateVariables(appPath, appName, options, config);
 }
 
 /**
- * Generate all configuration files for the application
- * @param {string} appPath - Path to application directory
+ * Updates variables.yaml for --app flag
+ * @async
+ * @function updateVariablesForAppFlag
+ * @param {string} appPath - Application directory path
  * @param {string} appName - Application name
- * @param {Object} config - Application configuration
- * @param {Object} existingEnv - Existing environment variables
+ * @throws {Error} If update fails
  */
-async function generateConfigFiles(appPath, appName, config, existingEnv) {
+async function updateVariablesForAppFlag(appPath, appName) {
   try {
-    // Generate variables.yaml
-    const variablesYaml = generateVariablesYaml(appName, config);
-    await fs.writeFile(path.join(appPath, 'variables.yaml'), variablesYaml);
-
-    // Generate env.template
-    let envTemplate;
-    if (existingEnv) {
-      const envResult = await generateEnvTemplateFromReader(config, existingEnv);
-      envTemplate = envResult.template;
-
-      if (envResult.warnings.length > 0) {
-        console.log(chalk.yellow('\n⚠️  Environment conversion warnings:'));
-        envResult.warnings.forEach(warning => console.log(chalk.yellow(`  - ${warning}`)));
-      }
+    const yaml = require('js-yaml');
+    const variablesPath = path.join(appPath, 'variables.yaml');
+    const variablesContent = await fs.readFile(variablesPath, 'utf8');
+    const variables = yaml.load(variablesContent);
+
+    if (variables.build) {
+      variables.build.context = '../..';
+      variables.build.envOutputPath = `apps/${appName}/.env`;
     } else {
-      envTemplate = generateEnvTemplate(config);
-    }
-    await fs.writeFile(path.join(appPath, 'env.template'), envTemplate);
-
-    // Generate rbac.yaml if authentication is enabled
-    if (config.authentication) {
-      const rbacYaml = generateRbacYaml(appName, config);
-      if (rbacYaml) {
-        await fs.writeFile(path.join(appPath, 'rbac.yaml'), rbacYaml);
-      }
+      variables.build = {
+        context: '../..',
+        envOutputPath: `apps/${appName}/.env`
+      };
     }
 
-    // Generate aifabrix-deploy.json template
-    const deployJson = {
-      apiVersion: 'v1',
-      kind: 'ApplicationDeployment',
-      metadata: {
-        name: appName,
-        namespace: 'default'
-      },
-      spec: {
-        application: {
-          name: appName,
-          version: '1.0.0',
-          language: config.language,
-          port: config.port
-        },
-        services: {
-          database: config.database,
-          redis: config.redis,
-          storage: config.storage,
-          authentication: config.authentication
-        },
-        deployment: {
-          replicas: 1,
-          strategy: 'RollingUpdate'
-        }
-      }
-    };
-
-    await fs.writeFile(
-      path.join(appPath, 'aifabrix-deploy.json'),
-      JSON.stringify(deployJson, null, 2)
-    );
-
+    await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }));
   } catch (error) {
-    throw new Error(`Failed to generate configuration files: ${error.message}`);
+    logger.warn(chalk.yellow(`⚠️  Warning: Could not update variables.yaml: ${error.message}`));
+  }
+}
+
+/**
+ * Gets language from config or variables.yaml
+ * @async
+ * @function getLanguageForAppFiles
+ * @param {string} language - Language from config
+ * @param {string} appPath - Application directory path
+ * @returns {Promise<string>} Language to use
+ * @throws {Error} If language cannot be determined
+ */
+async function getLanguageForAppFiles(language, appPath) {
+  if (language) {
+    return language;
+  }
+
+  const yaml = require('js-yaml');
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  const variablesContent = await fs.readFile(variablesPath, 'utf8');
+  const variables = yaml.load(variablesContent);
+  const languageFromYaml = variables?.build?.language;
+
+  if (!languageFromYaml) {
+    throw new Error('Language not specified and could not be determined from variables.yaml. Use --language flag or ensure variables.yaml contains build.language');
   }
+
+  return languageFromYaml;
+}
+
+/**
+ * Sets up apps directory and copies application files
+ * @async
+ * @function setupAppFiles
+ * @param {string} appName - Application name
+ * @param {string} appPath - Application directory path
+ * @param {Object} config - Final configuration
+ * @param {Object} options - Creation options
+ * @throws {Error} If setup fails
+ */
+async function setupAppFiles(appName, appPath, config, options) {
+  const appsPath = path.join(process.cwd(), 'apps', appName);
+  await fs.mkdir(appsPath, { recursive: true });
+  await updateVariablesForAppFlag(appPath, appName);
+
+  const language = await getLanguageForAppFiles(config.language || options.language, appPath);
+  const copiedFiles = await copyAppFiles(language, appsPath);
+  logger.log(chalk.green(`✓ Copied ${copiedFiles.length} application file(s) to apps/${appName}/`));
 }
 
 /**
@@ -227,7 +244,7 @@ async function generateConfigFiles(appPath, appName, config, existingEnv) {
  * @param {boolean} [options.storage] - Requires file storage
  * @param {boolean} [options.authentication] - Requires authentication/RBAC
  * @param {string} [options.language] - Runtime language (typescript/python)
- * @param {string} [options.template] - Template to use (platform for Keycloak/Miso)
+ * @param {string} [options.template] - Template to use (e.g., controller, keycloak)
  * @returns {Promise<void>} Resolves when app is created
  * @throws {Error} If creation fails
  *
@@ -237,75 +254,40 @@ async function generateConfigFiles(appPath, appName, config, existingEnv) {
  */
 async function createApp(appName, options = {}) {
   try {
-    // Validate app name format
-    validateAppName(appName);
+    // Validate appName early
+    if (!appName || typeof appName !== 'string') {
+      throw new Error('Application name is required');
+    }
 
-    // Check if directory already exists
     const builderPath = path.join(process.cwd(), 'builder');
     const appPath = path.join(builderPath, appName);
 
-    try {
-      await fs.access(appPath);
-      throw new Error(`Application '${appName}' already exists in builder/${appName}/`);
-    } catch (error) {
-      if (error.code !== 'ENOENT') {
-        throw error;
-      }
+    await validateAppCreation(appName, options, appPath);
+
+    if (options.template) {
+      await validateTemplate(options.template);
     }
 
-    // Prompt for missing options
-    const config = await promptForOptions(appName, options);
+    const templateVariables = await loadTemplateVariables(options.template);
+    const mergedOptions = mergeTemplateVariables(options, templateVariables);
+    const config = await promptForOptions(appName, mergedOptions);
 
-    // Create directory structure
     await fs.mkdir(appPath, { recursive: true });
+    await processTemplateFiles(options.template, appPath, appName, options, config);
 
-    // Check for existing .env file
     const existingEnv = await readExistingEnv(process.cwd());
-    let envConversionMessage = '';
-
-    if (existingEnv) {
-      envConversionMessage = '\n✓ Found existing .env file - sensitive values will be converted to kv:// references';
-    }
+    const envConversionMessage = existingEnv
+      ? '\n✓ Found existing .env file - sensitive values will be converted to kv:// references'
+      : '';
 
-    // Generate configuration files
     await generateConfigFiles(appPath, appName, config, existingEnv);
 
-    // Generate GitHub workflows if requested
-    if (options.github) {
-      const githubGen = require('./github-generator');
-      const workflowFiles = await githubGen.generateGithubWorkflows(
-        process.cwd(),
-        config,
-        {
-          mainBranch: options.mainBranch || 'main',
-          uploadCoverage: true,
-          publishToNpm: options.template === 'platform'
-        }
-      );
-
-      console.log(chalk.green('✓ Generated GitHub Actions workflows:'));
-      workflowFiles.forEach(file => console.log(chalk.gray(`  - ${file}`)));
+    if (options.app) {
+      await setupAppFiles(appName, appPath, config, options);
     }
 
-    // Display success message
-    console.log(chalk.green('\n✓ Application created successfully!'));
-    console.log(chalk.blue(`\nApplication: ${appName}`));
-    console.log(chalk.blue(`Location: builder/${appName}/`));
-    console.log(chalk.blue(`Language: ${config.language}`));
-    console.log(chalk.blue(`Port: ${config.port}`));
-
-    if (config.database) console.log(chalk.yellow('  - Database enabled'));
-    if (config.redis) console.log(chalk.yellow('  - Redis enabled'));
-    if (config.storage) console.log(chalk.yellow('  - Storage enabled'));
-    if (config.authentication) console.log(chalk.yellow('  - Authentication enabled'));
-
-    console.log(chalk.gray(envConversionMessage));
-
-    console.log(chalk.green('\nNext steps:'));
-    console.log(chalk.white('1. Copy env.template to .env and fill in your values'));
-    console.log(chalk.white('2. Run: aifabrix build ' + appName));
-    console.log(chalk.white('3. Run: aifabrix run ' + appName));
-
+    await handleGitHubWorkflows(options, config);
+    displaySuccessMessage(appName, config, envConversionMessage, options.app);
   } catch (error) {
     throw new Error(`Failed to create application: ${error.message}`);
   }
@@ -391,65 +373,13 @@ async function runApp(appName, options = {}) {
 }
 
 /**
- * Pushes application image to Azure Container Registry
+ * Deploys application to controller
  * @async
- * @function pushApp
+ * @function deployApp
  * @param {string} appName - Name of the application
- * @param {Object} options - Push options (registry, tag)
- * @returns {Promise<void>} Resolves when push is complete
+ * @param {Object} options - Deployment options
+ * @returns {Promise<void>} Resolves when deployment is complete
  */
-async function pushApp(appName, options = {}) {
-  try {
-    // Validate app name
-    validateAppName(appName);
-
-    const configPath = path.join(process.cwd(), 'builder', appName, 'variables.yaml');
-    let config;
-    try {
-      config = yaml.load(await fs.readFile(configPath, 'utf8'));
-    } catch (error) {
-      throw new Error(`Failed to load configuration: ${configPath}\nRun 'aifabrix create ${appName}' first`);
-    }
-
-    const registry = options.registry || config.image?.registry;
-    if (!registry) {
-      throw new Error('Registry URL is required. Provide via --registry flag or configure in variables.yaml under image.registry');
-    }
-
-    if (!pushUtils.validateRegistryURL(registry)) {
-      throw new Error(`Invalid registry URL format: ${registry}. Expected format: *.azurecr.io`);
-    }
-
-    const tags = options.tag ? options.tag.split(',').map(t => t.trim()) : ['latest'];
-
-    if (!await pushUtils.checkLocalImageExists(appName, 'latest')) {
-      throw new Error(`Docker image ${appName}:latest not found locally.\nRun 'aifabrix build ${appName}' first`);
-    }
-
-    if (!await pushUtils.checkAzureCLIInstalled()) {
-      throw new Error('Azure CLI is not installed. Install from: https://docs.microsoft.com/cli/azure/install-azure-cli');
-    }
-
-    if (await pushUtils.checkACRAuthentication(registry)) {
-      console.log(chalk.green(`✓ Already authenticated with ${registry}`));
-    } else {
-      await pushUtils.authenticateACR(registry);
-    }
-
-    await Promise.all(tags.map(async(tag) => {
-      await pushUtils.tagImage(`${appName}:latest`, `${registry}/${appName}:${tag}`);
-      await pushUtils.pushImage(`${registry}/${appName}:${tag}`);
-    }));
-
-    console.log(chalk.green(`\n✓ Successfully pushed ${tags.length} tag(s) to ${registry}`));
-    console.log(chalk.gray(`Image: ${registry}/${appName}:*`));
-    console.log(chalk.gray(`Tags: ${tags.join(', ')}`));
-
-  } catch (error) {
-    throw new Error(`Failed to push application: ${error.message}`);
-  }
-}
-
 async function deployApp(appName, options = {}) {
   const appDeploy = require('./app-deploy');
   return appDeploy.deployApp(appName, options);
@@ -461,8 +391,12 @@ module.exports = {
   runApp,
   detectLanguage,
   generateDockerfile,
+  generateDockerfileForApp,
   pushApp,
   deployApp,
+  loadTemplateVariables,
+  updateTemplateVariables,
+  mergeTemplateVariables,
   checkImageExists: appRun.checkImageExists,
   checkContainerRunning: appRun.checkContainerRunning,
   stopAndRemoveContainer: appRun.stopAndRemoveContainer,

package/lib/audit-logger.js

@@ -9,6 +9,8 @@
  * @version 2.0.0
  */
 
+/* eslint-disable no-console */
+
 /**
  * Masks sensitive data in strings
  * Prevents secrets, keys, and passwords from appearing in logs