@aifabrix/builder 2.31.1 → 2.32.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.31.1",
+  "version": "2.32.1",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {
@@ -9,6 +9,7 @@
   "scripts": {
     "test": "node tests/scripts/test-wrapper.js",
     "test:coverage": "jest --config jest.config.coverage.js --coverage --runInBand",
+    "test:coverage:nyc": "nyc --reporter=text --reporter=lcov --reporter=html jest --config jest.config.coverage.js --runInBand",
     "test:watch": "jest --watch",
     "test:integration": "jest --config jest.config.integration.js --runInBand",
     "test:integration:python": "cross-env TEST_LANGUAGE=python jest --config jest.config.integration.js --runInBand",
@@ -38,6 +39,32 @@
   "engines": {
     "node": ">=18.0.0"
   },
+  "nyc": {
+    "all": true,
+    "check-coverage": false,
+    "reporter": [
+      "text",
+      "lcov",
+      "html"
+    ],
+    "include": [
+      "lib/**/*.js",
+      "bin/**/*.js"
+    ],
+    "exclude": [
+      "**/node_modules/**",
+      "**/tests/**",
+      "lib/infra.js",
+      "bin/aifabrix.js"
+    ],
+    "cache": true,
+    "temp-dir": ".nyc_output"
+  },
+  "pnpm": {
+    "overrides": {
+      "@bcoe/v8-coverage": "^1.0.2"
+    }
+  },
   "dependencies": {
     "ajv": "^8.12.0",
     "axios": "^1.6.0",
@@ -49,10 +76,12 @@
     "ora": "^5.4.1"
   },
   "devDependencies": {
+    "@bcoe/v8-coverage": "^1.0.2",
     "@types/node": "^20.10.0",
     "cross-env": "^10.1.0",
     "eslint": "^8.55.0",
-    "jest": "^29.7.0"
+    "jest": "^30.2.0",
+    "nyc": "^17.1.0"
   },
   "repository": {
     "type": "git",

package/templates/external-system/deploy.ps1.hbs

@@ -0,0 +1,34 @@
+# Deploy {{systemKey}} external system and datasources using aifabrix CLI
+
+$ErrorActionPreference = "Stop"
+
+$SCRIPT_DIR = $PSScriptRoot
+$env:ENVIRONMENT = if ($env:ENVIRONMENT) { $env:ENVIRONMENT } else { "dev" }
+$env:CONTROLLER = if ($env:CONTROLLER) { $env:CONTROLLER } else { "http://localhost:3000" }
+
+Write-Host "🔍 Validating {{systemKey}} configuration files..."
+{{#each allJsonFiles}}
+aifabrix validate "${SCRIPT_DIR}\{{this}}"
+if ($LASTEXITCODE -ne 0) { exit 1 }
+{{/each}}
+
+Write-Host "✅ Validation passed"
+
+Write-Host "🚀 Deploying {{systemKey}} external system and datasources..."
+Write-Host "   Environment: $env:ENVIRONMENT"
+Write-Host "   Controller: $env:CONTROLLER"
+
+# Deploy datasources
+{{#each datasourceFileNames}}
+aifabrix datasource deploy {{../systemKey}} "${SCRIPT_DIR}\{{this}}" --environment $env:ENVIRONMENT --controller $env:CONTROLLER
+if ($LASTEXITCODE -ne 0) { exit 1 }
+{{/each}}
+
+Write-Host "✅ Deployment complete"
+
+# Optional: Run tests
+if ($env:RUN_TESTS -eq "true") {
+  Write-Host "🧪 Running integration tests..."
+  aifabrix test-integration {{systemKey}} --environment $env:ENVIRONMENT --controller $env:CONTROLLER
+}
+

package/templates/external-system/deploy.sh.hbs

@@ -0,0 +1,34 @@
+#!/bin/bash
+# Deploy {{systemKey}} external system and datasources using aifabrix CLI
+
+set -e
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+ENVIRONMENT="${ENVIRONMENT:-dev}"
+CONTROLLER="${CONTROLLER:-http://localhost:3000}"
+
+echo "🔍 Validating {{systemKey}} configuration files..."
+{{#each allJsonFiles}}
+aifabrix validate "${SCRIPT_DIR}/{{this}}" || exit 1
+{{/each}}
+
+echo "✅ Validation passed"
+
+echo "🚀 Deploying {{systemKey}} external system and datasources..."
+echo "   Environment: ${ENVIRONMENT}"
+echo "   Controller: ${CONTROLLER}"
+
+# Deploy datasources
+{{#each datasourceFileNames}}
+aifabrix datasource deploy {{../systemKey}} "${SCRIPT_DIR}/{{this}}" \
+  --environment "${ENVIRONMENT}" --controller "${CONTROLLER}" || exit 1
+{{/each}}
+
+echo "✅ Deployment complete"
+
+# Optional: Run tests
+if [ "${RUN_TESTS:-false}" = "true" ]; then
+  echo "🧪 Running integration tests..."
+  aifabrix test-integration {{systemKey}} --environment "${ENVIRONMENT}" --controller "${CONTROLLER}"
+fi
+

package/templates/external-system/external-datasource.json.hbs

@@ -3,7 +3,7 @@
   "displayName": "{{datasourceDisplayName}}",
   "description": "{{datasourceDescription}}",
   "systemKey": "{{systemKey}}",
-  "entityKey": "{{entityKey}}",
+  "entityType": "{{entityType}}",
   "resourceType": "{{resourceType}}",
   "enabled": true,
   "version": "1.0.0",
@@ -12,41 +12,60 @@
     "properties": {}
   },
   "fieldMappings": {
-    "accessFields": ["id", "name"],
-    "fields": {
+    "dimensions": {
+      {{#if dimensions}}
+      {{#each dimensions}}
+      "{{@key}}": "{{this}}"{{#unless @last}},{{/unless}}
+      {{/each}}
+      {{else}}
+      "country": "metadata.country",
+      "department": "metadata.department"
+      {{/if}}
+    },
+    "attributes": {
+      {{#if attributes}}
+      {{#each attributes}}
+      "{{@key}}": {
+        {{#each this}}
+        "{{@key}}": {{#if (eq @key "indexed")}}{{this}}{{else}}"{{this}}"{{/if}}{{#unless @last}},{{/unless}}
+        {{/each}}
+      }{{#unless @last}},{{/unless}}
+      {{/each}}
+      {{else}}
       "id": {
         "expression": "{{raw.id}}",
         "type": "string",
         "description": "Unique identifier",
-        "required": true
+        "indexed": true
       },
       "name": {
         "expression": "{{raw.name}}",
         "type": "string",
         "description": "Display name",
-        "required": true
+        "indexed": false
       }
+      {{/if}}
     }
   },
   "exposed": {
-    "fields": ["id", "name"],
-    "description": "Exposed fields for {{datasourceDisplayName}}"
+    "attributes": ["id", "name"],
+    "description": "Exposed attributes for {{datasourceDisplayName}}"
   }{{#if (eq systemType "openapi")}},
   "openapi": {
     "enabled": true,
     "documentKey": "{{systemKey}}-api",
     "baseUrl": "https://api.example.com",
-    "resourcePath": "/{{entityKey}}",
+    "resourcePath": "/{{entityType}}",
     "operations": {
       "list": {
-        "operationId": "list{{entityKey}}",
+        "operationId": "list{{entityType}}",
         "method": "GET",
-        "path": "/{{entityKey}}"
+        "path": "/{{entityType}}"
       },
       "get": {
-        "operationId": "get{{entityKey}}",
+        "operationId": "get{{entityType}}",
         "method": "GET",
-        "path": "/{{entityKey}}/{id}"
+        "path": "/{{entityType}}/{id}"
       }
     },
     "autoRbac": true

package/lib/app.js

@@ -1,467 +0,0 @@
-/**
- * AI Fabrix Builder Application Management
- *
- * This module handles application building, running, and deployment.
- * Includes runtime detection, Dockerfile generation, and container management.
- *
- * @fileoverview Application build and run management 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 { readExistingEnv } = require('./env-reader');
-const build = require('./build');
-const appRun = require('./app-run');
-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');
-const auditLogger = require('./audit-logger');
-const { downApp } = require('./app-down');
-const { getAppPath } = require('./utils/paths');
-
-/**
- * Displays success message after app creation
- * @param {string} appName - Application name
- * @param {Object} config - Final configuration
- * @param {string} envConversionMessage - Environment conversion message
- */
-function displaySuccessMessage(appName, config, envConversionMessage, hasAppFiles = false, appPath = null) {
-  logger.log(chalk.green('\n✓ Application created successfully!'));
-  logger.log(chalk.blue(`\nApplication: ${appName}`));
-
-  // Determine location based on app type
-  const baseDir = config.type === 'external' ? 'integration' : 'builder';
-  const location = appPath ? path.relative(process.cwd(), appPath) : `${baseDir}/${appName}/`;
-  logger.log(chalk.blue(`Location: ${location}`));
-
-  if (hasAppFiles) {
-    logger.log(chalk.blue(`Application files: apps/${appName}/`));
-  }
-
-  if (config.type === 'external') {
-    logger.log(chalk.blue('Type: External System'));
-    logger.log(chalk.blue(`System Key: ${config.systemKey || appName}`));
-    logger.log(chalk.green('\nNext steps:'));
-    logger.log(chalk.white('1. Edit external system JSON files in ' + location));
-    logger.log(chalk.white('2. Run: aifabrix app register ' + appName + ' --environment dev'));
-    logger.log(chalk.white('3. Run: aifabrix build ' + appName + ' (deploys to dataplane)'));
-    logger.log(chalk.white('4. Run: aifabrix deploy ' + appName + ' (publishes to dataplane)'));
-  } else {
-    logger.log(chalk.blue(`Language: ${config.language}`));
-    logger.log(chalk.blue(`Port: ${config.port}`));
-
-    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'));
-
-    logger.log(chalk.gray(envConversionMessage));
-
-    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));
-  }
-}
-
-/**
- * Validates that app directory doesn't already exist
- * @async
- * @param {string} appPath - Application directory path
- * @param {string} appName - Application name
- * @throws {Error} If directory already exists
- */
-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;
-    }
-  }
-}
-
-/**
- * Gets the base directory path for an app based on its type
- * @param {string} appName - Application name
- * @param {string} appType - Application type ('external' or other)
- * @returns {string} Base directory path ('integration' or 'builder')
- */
-function getBaseDirForAppType(appType) {
-  return appType === 'external' ? 'integration' : 'builder';
-}
-
-/**
- * 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;
-  }
-
-  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, baseDir = 'builder') {
-  validateAppName(appName);
-  await validateAppDirectoryNotExists(appPath, appName, baseDir);
-
-  if (!options.app) {
-    return;
-  }
-
-  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;
-    }
-  }
-}
-
-/**
- * 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;
-  }
-
-  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);
-}
-
-/**
- * Updates variables.yaml for --app flag
- * @async
- * @function updateVariablesForAppFlag
- * @param {string} appPath - Application directory path
- * @param {string} appName - Application name
- * @throws {Error} If update fails
- */
-async function updateVariablesForAppFlag(appPath, appName) {
-  try {
-    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 {
-      variables.build = {
-        context: '../..',
-        envOutputPath: `../../apps/${appName}/.env`
-      };
-    }
-
-    await fs.writeFile(variablesPath, yaml.dump(variables, { indent: 2, lineWidth: 120, noRefs: true }));
-  } catch (error) {
-    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}/`));
-}
-
-/**
- * Creates new application with scaffolded configuration files
- * Prompts for configuration options and generates builder/ folder structure
- *
- * @async
- * @function createApp
- * @param {string} appName - Name of the application to create
- * @param {Object} options - Creation options
- * @param {number} [options.port] - Application port
- * @param {boolean} [options.database] - Requires database
- * @param {boolean} [options.redis] - Requires Redis
- * @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 (e.g., controller, keycloak)
- * @returns {Promise<void>} Resolves when app is created
- * @throws {Error} If creation fails
- *
- * @example
- * await createApp('myapp', { port: 3000, database: true, language: 'typescript' });
- * // Creates builder/ with variables.yaml, env.template, rbac.yaml
- */
-async function createApp(appName, options = {}) {
-  try {
-    // Validate appName early
-    if (!appName || typeof appName !== 'string') {
-      throw new Error('Application name is required');
-    }
-
-    // Determine app type from options (will be confirmed during prompts)
-    // For now, check if type is explicitly set in options
-    const initialType = options.type || 'webapp';
-    const baseDir = getBaseDirForAppType(initialType);
-    const appPath = getAppPath(appName, initialType);
-
-    await validateAppCreation(appName, options, appPath, baseDir);
-
-    if (options.template) {
-      await validateTemplate(options.template);
-    }
-
-    const templateVariables = await loadTemplateVariables(options.template);
-    const mergedOptions = mergeTemplateVariables(options, templateVariables);
-    const config = await promptForOptions(appName, mergedOptions);
-
-    // Update appPath based on final config type (may have changed during prompts)
-    const finalBaseDir = getBaseDirForAppType(config.type);
-    const finalAppPath = getAppPath(appName, config.type);
-
-    // If path changed, validate the new path
-    if (finalAppPath !== appPath) {
-      await validateAppDirectoryNotExists(finalAppPath, appName, finalBaseDir);
-    }
-
-    await fs.mkdir(finalAppPath, { recursive: true });
-    await processTemplateFiles(options.template, finalAppPath, appName, options, config);
-
-    const existingEnv = await readExistingEnv(process.cwd());
-    const envConversionMessage = existingEnv
-      ? '\n✓ Found existing .env file - sensitive values will be converted to kv:// references'
-      : '';
-
-    await generateConfigFiles(finalAppPath, appName, config, existingEnv);
-
-    // Generate external system files if type is external
-    if (config.type === 'external') {
-      const externalGenerator = require('./external-system-generator');
-      await externalGenerator.generateExternalSystemFiles(finalAppPath, appName, config);
-    }
-
-    if (options.app) {
-      await setupAppFiles(appName, finalAppPath, config, options);
-    }
-
-    await handleGitHubWorkflows(options, config);
-    displaySuccessMessage(appName, config, envConversionMessage, options.app, finalAppPath);
-
-    // Log application creation for audit trail
-    await auditLogger.logApplicationCreation(appName, {
-      language: config.language,
-      port: config.port,
-      database: config.database,
-      redis: config.redis,
-      storage: config.storage,
-      authentication: config.authentication,
-      template: options.template,
-      api: null // Local operation, no API involved
-    });
-  } catch (error) {
-    throw new Error(`Failed to create application: ${error.message}`);
-  }
-}
-
-/**
- * Builds a container image for the specified application
- * Auto-detects runtime and generates Dockerfile if needed
- *
- * @async
- * @function buildApp
- * @param {string} appName - Name of the application to build
- * @param {Object} options - Build options
- * @param {string} [options.language] - Override language detection
- * @param {boolean} [options.forceTemplate] - Force rebuild from template
- * @param {string} [options.tag] - Image tag (default: latest)
- * @returns {Promise<string>} Image tag that was built
- * @throws {Error} If build fails or app configuration is invalid
- *
- * @example
- * const imageTag = await buildApp('myapp', { language: 'typescript' });
- * // Returns: 'myapp:latest'
- */
-async function buildApp(appName, options = {}) {
-  return build.buildApp(appName, options);
-}
-
-/**
- * Detects the runtime language of an application
- * Analyzes project files to determine TypeScript, Python, etc.
- *
- * @function detectLanguage
- * @param {string} appPath - Path to application directory
- * @returns {string} Detected language ('typescript', 'python', etc.)
- * @throws {Error} If language cannot be detected
- *
- * @example
- * const language = detectLanguage('./myapp');
- * // Returns: 'typescript'
- */
-function detectLanguage(appPath) {
-  return build.detectLanguage(appPath);
-}
-
-/**
- * Generates a Dockerfile from template based on detected language
- * Uses Handlebars templates to create optimized Dockerfiles
- *
- * @async
- * @function generateDockerfile
- * @param {string} appPath - Path to application directory
- * @param {string} language - Target language ('typescript', 'python')
- * @param {Object} config - Application configuration from variables.yaml
- * @returns {Promise<string>} Path to generated Dockerfile
- * @throws {Error} If template generation fails
- *
- * @example
- * const dockerfilePath = await generateDockerfile('./myapp', 'typescript', config);
- * // Returns: './myapp/.aifabrix/Dockerfile.typescript'
- */
-async function generateDockerfile(appPath, language, config) {
-  return build.generateDockerfile(appPath, language, config);
-}
-
-/**
- * Runs the application locally using Docker
- * Starts container with proper port mapping and environment
- *
- * @async
- * @function runApp
- * @param {string} appName - Name of the application to run
- * @param {Object} options - Run options
- * @param {number} [options.port] - Override local port
- * @param {boolean} [options.debug] - Enable debug output
- * @returns {Promise<void>} Resolves when app is running
- * @throws {Error} If run fails or app is not built
- *
- * @example
- * await runApp('myapp', { port: 3001 });
- * // Application is now running on localhost:3001
- */
-async function runApp(appName, options = {}) {
-  return appRun.runApp(appName, options);
-}
-
-/**
- * Deploys application to controller
- * @async
- * @function deployApp
- * @param {string} appName - Name of the application
- * @param {Object} options - Deployment options
- * @returns {Promise<void>} Resolves when deployment is complete
- */
-async function deployApp(appName, options = {}) {
-  const appDeploy = require('./app-deploy');
-  return appDeploy.deployApp(appName, options);
-}
-
-module.exports = {
-  createApp,
-  buildApp,
-  runApp,
-  downApp,
-  detectLanguage,
-  generateDockerfile,
-  generateDockerfileForApp,
-  pushApp,
-  deployApp,
-  loadTemplateVariables,
-  updateTemplateVariables,
-  mergeTemplateVariables,
-  checkImageExists: appRun.checkImageExists,
-  checkContainerRunning: appRun.checkContainerRunning,
-  stopAndRemoveContainer: appRun.stopAndRemoveContainer,
-  checkPortAvailable: appRun.checkPortAvailable,
-  generateDockerCompose: appRun.generateDockerCompose,
-  waitForHealthCheck: appRun.waitForHealthCheck
-};