@aifabrix/builder 2.7.0 → 2.9.0

package/lib/generator.js

@@ -12,25 +12,12 @@
 const fs = require('fs');
 const path = require('path');
 const yaml = require('js-yaml');
+const Ajv = require('ajv');
 const _secrets = require('./secrets');
 const _keyGenerator = require('./key-generator');
 const _validator = require('./validator');
-
-/**
- * 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;
-}
+const builders = require('./generator-builders');
+const { detectAppType, getDeployJsonPath } = require('./utils/paths');
 
 /**
  * Loads variables.yaml file
@@ -84,229 +71,61 @@ function loadRbac(rbacPath) {
 }
 
 /**
- * Filters configuration based on registry mode
- * When registryMode is "external", only DOCKER_REGISTRY_SERVER_* variables are allowed
- * @function filterConfigurationByRegistryMode
- * @param {Array} configuration - Environment configuration
- * @param {string} registryMode - Registry mode ('external' or 'internal')
- * @returns {Array} Filtered configuration
- */
-function filterConfigurationByRegistryMode(configuration, registryMode) {
-  if (registryMode !== 'external') {
-    return configuration;
-  }
-
-  const allowedDockerRegistryVars = [
-    'DOCKER_REGISTRY_SERVER_URL',
-    'DOCKER_REGISTRY_SERVER_USERNAME',
-    'DOCKER_REGISTRY_SERVER_PASSWORD'
-  ];
-  return configuration.filter(config => allowedDockerRegistryVars.includes(config.name));
-}
-
-/**
- * Builds base deployment structure
- * @function buildBaseDeployment
- * @param {string} appName - Application name
- * @param {Object} variables - Variables configuration
- * @param {Array} filteredConfiguration - Filtered environment configuration
- * @returns {Object} Base deployment structure
- */
-function buildBaseDeployment(appName, variables, filteredConfiguration) {
-  const requires = variables.requires || {};
-  return {
-    key: variables.app?.key || appName,
-    displayName: variables.app?.displayName || appName,
-    description: variables.app?.description || '',
-    type: variables.app?.type || 'webapp',
-    image: buildImageReference(variables),
-    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 || 'app' }] : []),
-    configuration: filteredConfiguration
-  };
-}
-
-/**
- * Builds authentication configuration from variables or RBAC
- * @function buildAuthenticationConfig
- * @param {Object} variables - Variables configuration
- * @param {Object|null} rbac - RBAC configuration
- * @returns {Object} Authentication configuration
- */
-function buildAuthenticationConfig(variables, rbac) {
-  if (variables.authentication) {
-    const auth = {
-      enableSSO: variables.authentication.enableSSO !== undefined ? variables.authentication.enableSSO : true
-    };
-
-    // When enableSSO is false, default type to 'none' and requiredRoles to []
-    // When enableSSO is true, require type and requiredRoles
-    // Sanitize auth type (e.g., map keycloak to azure)
-    if (auth.enableSSO === false) {
-      auth.type = sanitizeAuthType(variables.authentication.type || 'none');
-      auth.requiredRoles = variables.authentication.requiredRoles || [];
-    } else {
-      auth.type = sanitizeAuthType(variables.authentication.type || 'azure');
-      auth.requiredRoles = variables.authentication.requiredRoles || [];
-    }
-
-    if (variables.authentication.endpoints) {
-      auth.endpoints = variables.authentication.endpoints;
-    }
-    return auth;
-  }
-  return buildAuthentication(rbac);
-}
-
-/**
- * Validates and transforms repository configuration
- * @function validateRepositoryConfig
- * @param {Object} repository - Repository configuration
- * @returns {Object|null} Validated repository config or null
+ * Generates external system <app-name>-deploy.json by loading the system JSON file
+ * For external systems, the system JSON file is already created and we just need to reference it
+ * @async
+ * @function generateExternalSystemDeployJson
+ * @param {string} appName - Name of the application
+ * @param {string} appPath - Path to application directory (integration or builder)
+ * @returns {Promise<string>} Path to generated <app-name>-deploy.json file
+ * @throws {Error} If generation fails
  */
-function validateRepositoryConfig(repository) {
-  if (!repository || (!repository.enabled && !repository.repositoryUrl)) {
-    return null;
+async function generateExternalSystemDeployJson(appName, appPath) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('App name is required and must be a string');
   }
 
-  if (repository.repositoryUrl && repository.repositoryUrl.trim()) {
-    return {
-      enabled: repository.enabled || false,
-      repositoryUrl: repository.repositoryUrl
-    };
-  }
+  const variablesPath = path.join(appPath, 'variables.yaml');
+  const { parsed: variables } = loadVariables(variablesPath);
 
-  if (repository.enabled) {
-    return { enabled: true };
+  if (!variables.externalIntegration) {
+    throw new Error('externalIntegration block not found in variables.yaml');
   }
 
-  return null;
-}
+  // For external systems, the system JSON file should be in the same folder
+  // Check if it already exists (should be <app-name>-deploy.json)
+  const deployJsonPath = getDeployJsonPath(appName, 'external', true);
+  const systemFileName = variables.externalIntegration.systems && variables.externalIntegration.systems.length > 0
+    ? variables.externalIntegration.systems[0]
+    : `${appName}-deploy.json`;
 
-/**
- * Validates and transforms build fields
- * @function validateBuildFields
- * @param {Object} build - Build configuration
- * @returns {Object|null} Validated build config or null
- */
-function validateBuildFields(build) {
-  if (!build) {
-    return null;
-  }
+  // Resolve system file path (schemaBasePath is usually './' for same folder)
+  const schemaBasePath = variables.externalIntegration.schemaBasePath || './';
+  const systemFilePath = path.isAbsolute(schemaBasePath)
+    ? path.join(schemaBasePath, systemFileName)
+    : path.join(appPath, schemaBasePath, systemFileName);
 
-  const buildConfig = {};
-  if (build.envOutputPath) {
-    buildConfig.envOutputPath = build.envOutputPath;
+  // If system file doesn't exist, throw error (it should be created manually or via external-system-generator)
+  if (!fs.existsSync(systemFilePath)) {
+    throw new Error(`External system file not found: ${systemFilePath}. Please create it first.`);
   }
-  if (build.dockerfile && build.dockerfile.trim()) {
-    buildConfig.dockerfile = build.dockerfile;
-  }
-
-  return Object.keys(buildConfig).length > 0 ? buildConfig : null;
-}
 
-/**
- * Validates and transforms deployment fields
- * @function validateDeploymentFields
- * @param {Object} deployment - Deployment configuration
- * @returns {Object|null} Validated deployment config or null
- */
-function validateDeploymentFields(deployment) {
-  if (!deployment) {
-    return null;
-  }
+  // Read the system JSON file
+  const systemContent = await fs.promises.readFile(systemFilePath, 'utf8');
+  const systemJson = JSON.parse(systemContent);
 
-  const deploymentConfig = {};
-  if (deployment.controllerUrl && deployment.controllerUrl.trim() && deployment.controllerUrl.startsWith('https://')) {
-    deploymentConfig.controllerUrl = deployment.controllerUrl;
-  }
+  // Write it as <app-name>-deploy.json (consistent naming)
+  const jsonContent = JSON.stringify(systemJson, null, 2);
+  await fs.promises.writeFile(deployJsonPath, jsonContent, { mode: 0o644, encoding: 'utf8' });
 
-  return Object.keys(deploymentConfig).length > 0 ? deploymentConfig : null;
-}
-
-/**
- * Adds optional fields to deployment manifest
- * @function buildOptionalFields
- * @param {Object} deployment - Deployment manifest
- * @param {Object} variables - Variables configuration
- * @param {Object|null} rbac - RBAC configuration
- * @returns {Object} Deployment manifest with optional fields
- */
-function buildOptionalFields(deployment, variables, rbac) {
-  if (variables.healthCheck) {
-    deployment.healthCheck = buildHealthCheck(variables);
-  }
-
-  deployment.authentication = buildAuthenticationConfig(variables, rbac);
-
-  // Add roles and permissions (from variables.yaml or rbac.yaml)
-  // Priority: variables.yaml > rbac.yaml
-  if (variables.roles) {
-    deployment.roles = variables.roles;
-  } else if (rbac && rbac.roles) {
-    deployment.roles = rbac.roles;
-  }
-
-  if (variables.permissions) {
-    deployment.permissions = variables.permissions;
-  } else if (rbac && rbac.permissions) {
-    deployment.permissions = rbac.permissions;
-  }
-
-  const repository = validateRepositoryConfig(variables.repository);
-  if (repository) {
-    deployment.repository = repository;
-  }
-
-  const build = validateBuildFields(variables.build);
-  if (build) {
-    deployment.build = build;
-  }
-
-  const deploymentConfig = validateDeploymentFields(variables.deployment);
-  if (deploymentConfig) {
-    deployment.deployment = deploymentConfig;
-  }
-
-  if (variables.startupCommand) {
-    deployment.startupCommand = variables.startupCommand;
-  }
-  if (variables.runtimeVersion) {
-    deployment.runtimeVersion = variables.runtimeVersion;
-  }
-  if (variables.scaling) {
-    deployment.scaling = variables.scaling;
-  }
-  if (variables.frontDoorRouting) {
-    deployment.frontDoorRouting = variables.frontDoorRouting;
-  }
-
-  return deployment;
-}
-
-/**
- * Builds deployment manifest structure
- * @param {string} appName - Application name
- * @param {Object} variables - Variables configuration
- * @param {string} deploymentKey - Deployment key
- * @param {Array} configuration - Environment configuration
- * @param {Object|null} rbac - RBAC configuration
- * @returns {Object} Deployment manifest
- */
-function buildManifestStructure(appName, variables, deploymentKey, configuration, rbac) {
-  const registryMode = variables.image?.registryMode || 'external';
-  const filteredConfiguration = filterConfigurationByRegistryMode(configuration, registryMode);
-  const deployment = buildBaseDeployment(appName, variables, filteredConfiguration);
-  return buildOptionalFields(deployment, variables, rbac);
+  return deployJsonPath;
 }
 
 /**
  * Generates deployment JSON from application configuration files
- * Creates aifabrix-deploy.json for Miso Controller deployment
+ * Creates <app-name>-deploy.json for all apps (consistent naming)
+ * For external systems, loads the system JSON file
+ * For regular apps, generates deployment manifest from variables.yaml, env.template, rbac.yaml
  *
  * @async
  * @function generateDeployJson
@@ -316,18 +135,26 @@ function buildManifestStructure(appName, variables, deploymentKey, configuration
  *
  * @example
  * const jsonPath = await generateDeployJson('myapp');
- * // Returns: './builder/myapp/aifabrix-deploy.json'
+ * // Returns: './builder/myapp/myapp-deploy.json' or './integration/hubspot/hubspot-deploy.json'
  */
 async function generateDeployJson(appName) {
   if (!appName || typeof appName !== 'string') {
     throw new Error('App name is required and must be a string');
   }
 
-  const builderPath = path.join(process.cwd(), 'builder', appName);
-  const variablesPath = path.join(builderPath, 'variables.yaml');
-  const templatePath = path.join(builderPath, 'env.template');
-  const rbacPath = path.join(builderPath, 'rbac.yaml');
-  const jsonPath = path.join(builderPath, 'aifabrix-deploy.json');
+  // Detect app type and get correct path (integration or builder)
+  const { isExternal, appPath, appType } = await detectAppType(appName);
+  const variablesPath = path.join(appPath, 'variables.yaml');
+
+  // Check if app type is external
+  if (isExternal) {
+    return await generateExternalSystemDeployJson(appName, appPath);
+  }
+
+  // Regular app: generate deployment manifest
+  const templatePath = path.join(appPath, 'env.template');
+  const rbacPath = path.join(appPath, 'rbac.yaml');
+  const jsonPath = getDeployJsonPath(appName, appType, true); // Use new naming
 
   // Load configuration files
   const { parsed: variables } = loadVariables(variablesPath);
@@ -338,7 +165,7 @@ async function generateDeployJson(appName) {
   const configuration = parseEnvironmentVariables(envTemplate);
 
   // Build deployment manifest WITHOUT deploymentKey initially
-  const deployment = buildManifestStructure(appName, variables, null, configuration, rbac);
+  const deployment = builders.buildManifestStructure(appName, variables, null, configuration, rbac);
 
   // Generate deploymentKey from the manifest object (excluding deploymentKey field)
   const deploymentKey = _keyGenerator.generateDeploymentKeyFromJson(deployment);
@@ -411,89 +238,170 @@ function parseEnvironmentVariables(envTemplate) {
   return configuration;
 }
 
-function buildImageReference(variables) {
-  const imageName = variables.image?.name || variables.app?.key || 'app';
-  const registry = variables.image?.registry;
-  const tag = variables.image?.tag || 'latest';
+async function generateDeployJsonWithValidation(appName) {
+  const jsonPath = await generateDeployJson(appName);
+  const jsonContent = fs.readFileSync(jsonPath, 'utf8');
+  const deployment = JSON.parse(jsonContent);
 
-  if (registry) {
-    return `${registry}/${imageName}:${tag}`;
-  }
+  // Detect if this is an external system
+  const { isExternal } = await detectAppType(appName);
 
-  return `${imageName}:${tag}`;
-}
+  // For external systems, skip deployment JSON validation (they use external system JSON structure)
+  if (isExternal) {
+    return {
+      success: true,
+      path: jsonPath,
+      validation: { valid: true, errors: [], warnings: [] },
+      deployment
+    };
+  }
 
-function buildHealthCheck(variables) {
-  const healthCheck = {
-    path: variables.healthCheck?.path || '/health',
-    interval: variables.healthCheck?.interval || 30
+  const validation = _validator.validateDeploymentJson(deployment);
+  return {
+    success: validation.valid,
+    path: jsonPath,
+    validation,
+    deployment
   };
+}
 
-  // Add optional probe fields if present
-  if (variables.healthCheck?.probePath) {
-    healthCheck.probePath = variables.healthCheck.probePath;
+/**
+ * Generates application-schema.json structure for external systems
+ * Combines system and datasource JSONs into application-level deployment format
+ * @async
+ * @function generateExternalSystemApplicationSchema
+ * @param {string} appName - Application name
+ * @returns {Promise<Object>} Application schema object
+ * @throws {Error} If generation fails
+ */
+async function generateExternalSystemApplicationSchema(appName) {
+  if (!appName || typeof appName !== 'string') {
+    throw new Error('App name is required and must be a string');
   }
-  if (variables.healthCheck?.probeRequestType) {
-    healthCheck.probeRequestType = variables.healthCheck.probeRequestType;
+
+  const { appPath } = await detectAppType(appName);
+  const variablesPath = path.join(appPath, 'variables.yaml');
+
+  // Load variables.yaml
+  const { parsed: variables } = loadVariables(variablesPath);
+
+  if (!variables.externalIntegration) {
+    throw new Error('externalIntegration block not found in variables.yaml');
   }
-  if (variables.healthCheck?.probeProtocol) {
-    healthCheck.probeProtocol = variables.healthCheck.probeProtocol;
+
+  // Load system file
+  const schemaBasePath = variables.externalIntegration.schemaBasePath || './';
+  const systemFiles = variables.externalIntegration.systems || [];
+
+  if (systemFiles.length === 0) {
+    throw new Error('No system files specified in externalIntegration.systems');
   }
-  if (variables.healthCheck?.probeIntervalInSeconds) {
-    healthCheck.probeIntervalInSeconds = variables.healthCheck.probeIntervalInSeconds;
+
+  const systemFileName = systemFiles[0];
+  const systemFilePath = path.isAbsolute(schemaBasePath)
+    ? path.join(schemaBasePath, systemFileName)
+    : path.join(appPath, schemaBasePath, systemFileName);
+
+  if (!fs.existsSync(systemFilePath)) {
+    throw new Error(`System file not found: ${systemFilePath}`);
   }
 
-  return healthCheck;
-}
+  const systemContent = await fs.promises.readFile(systemFilePath, 'utf8');
+  const systemJson = JSON.parse(systemContent);
 
-function buildRequirements(variables) {
-  const requires = variables.requires || {};
+  // Load datasource files
+  const datasourceFiles = variables.externalIntegration.dataSources || [];
+  const datasourceJsons = [];
 
-  return {
-    database: requires.database || false,
-    databases: requires.databases || (requires.database ? [{ name: variables.app?.key || 'app' }] : []),
-    redis: requires.redis || false,
-    storage: requires.storage || false,
-    storageSize: requires.storageSize || '1Gi'
-  };
-}
+  for (const datasourceFile of datasourceFiles) {
+    const datasourcePath = path.isAbsolute(schemaBasePath)
+      ? path.join(schemaBasePath, datasourceFile)
+      : path.join(appPath, schemaBasePath, datasourceFile);
 
-function buildAuthentication(rbac) {
-  if (!rbac) {
-    return {
-      type: 'none',
-      enableSSO: false,
-      requiredRoles: []
-    };
+    if (!fs.existsSync(datasourcePath)) {
+      throw new Error(`Datasource file not found: ${datasourcePath}`);
+    }
+
+    const datasourceContent = await fs.promises.readFile(datasourcePath, 'utf8');
+    const datasourceJson = JSON.parse(datasourceContent);
+    datasourceJsons.push(datasourceJson);
   }
 
-  return {
-    type: 'azure', // Default to azure (enum: azure, local, none)
-    enableSSO: true,
-    requiredRoles: rbac.roles?.map(role => role.value) || []
+  // Build application-schema.json structure
+  const applicationSchema = {
+    version: variables.externalIntegration.version || '1.0.0',
+    application: systemJson,
+    dataSources: datasourceJsons
   };
-}
 
-async function generateDeployJsonWithValidation(appName) {
-  const jsonPath = await generateDeployJson(appName);
-  const jsonContent = fs.readFileSync(jsonPath, 'utf8');
-  const deployment = JSON.parse(jsonContent);
-  const validation = _validator.validateDeploymentJson(deployment);
-  return {
-    success: validation.valid,
-    path: jsonPath,
-    validation,
-    deployment
-  };
+  // Validate individual components against their schemas
+  const externalSystemSchema = require('./schema/external-system.schema.json');
+  const externalDatasourceSchema = require('./schema/external-datasource.schema.json');
+
+  // For draft-2020-12 schemas, remove $schema to avoid AJV issues (similar to schema-loader.js)
+  const datasourceSchemaToAdd = { ...externalDatasourceSchema };
+  if (datasourceSchemaToAdd.$schema && datasourceSchemaToAdd.$schema.includes('2020-12')) {
+    delete datasourceSchemaToAdd.$schema;
+  }
+
+  const ajv = new Ajv({ allErrors: true, strict: false, removeAdditional: false });
+
+  // Validate application (system) against external-system schema
+  const externalSystemSchemaId = externalSystemSchema.$id || 'https://raw.githubusercontent.com/esystemsdev/aifabrix-builder/refs/heads/main/lib/schema/external-system.schema.json';
+  ajv.addSchema(externalSystemSchema, externalSystemSchemaId);
+  const validateSystem = ajv.compile(externalSystemSchema);
+  const systemValid = validateSystem(systemJson);
+
+  if (!systemValid) {
+    // Filter out additionalProperties errors for required properties that aren't defined in schema
+    // This handles schema inconsistencies where authentication is required but not defined in properties
+    const filteredErrors = validateSystem.errors.filter(err => {
+      if (err.keyword === 'additionalProperties' && err.params?.additionalProperty === 'authentication') {
+        // Check if authentication is in required array
+        const required = externalSystemSchema.required || [];
+        if (required.includes('authentication')) {
+          return false; // Ignore this error since authentication is required but not defined
+        }
+      }
+      return true;
+    });
+
+    if (filteredErrors.length > 0) {
+      const errors = filteredErrors.map(err => {
+        const path = err.instancePath || err.schemaPath;
+        return `${path} ${err.message}`;
+      }).join(', ');
+      throw new Error(`System JSON does not match external-system schema: ${errors}`);
+    }
+  }
+
+  // Validate each datasource against external-datasource schema
+  const externalDatasourceSchemaId = datasourceSchemaToAdd.$id || 'https://raw.githubusercontent.com/esystemsdev/aifabrix-builder/refs/heads/main/lib/schema/external-datasource.schema.json';
+  ajv.addSchema(datasourceSchemaToAdd, externalDatasourceSchemaId);
+  const validateDatasource = ajv.compile(datasourceSchemaToAdd);
+
+  for (let i = 0; i < datasourceJsons.length; i++) {
+    const datasourceValid = validateDatasource(datasourceJsons[i]);
+    if (!datasourceValid) {
+      const errors = validateDatasource.errors.map(err => {
+        const path = err.instancePath || err.schemaPath;
+        return `${path} ${err.message}`;
+      }).join(', ');
+      throw new Error(`Datasource ${i + 1} (${datasourceJsons[i].key || 'unknown'}) does not match external-datasource schema: ${errors}`);
+    }
+  }
+
+  return applicationSchema;
 }
 
 module.exports = {
   generateDeployJson,
   generateDeployJsonWithValidation,
+  generateExternalSystemApplicationSchema,
   parseEnvironmentVariables,
-  buildImageReference,
-  buildHealthCheck,
-  buildRequirements,
-  buildAuthentication,
-  buildAuthenticationConfig
+  buildImageReference: builders.buildImageReference,
+  buildHealthCheck: builders.buildHealthCheck,
+  buildRequirements: builders.buildRequirements,
+  buildAuthentication: builders.buildAuthentication,
+  buildAuthenticationConfig: builders.buildAuthenticationConfig
 };