@aifabrix/builder 2.22.1 → 2.31.0

package/lib/generator-external.js

@@ -81,38 +81,15 @@ async function generateExternalSystemDeployJson(appName, appPath) {
 }
 
 /**
- * Generates application-schema.json structure for external systems
- * Combines system and datasource JSONs into application-level deployment format
+ * Load system file and merge RBAC
  * @async
- * @function generateExternalSystemApplicationSchema
- * @param {string} appName - Application name
- * @returns {Promise<Object>} Application schema object
- * @throws {Error} If generation fails
+ * @param {string} appPath - Application path
+ * @param {string} schemaBasePath - Schema base path
+ * @param {string} systemFileName - System file name
+ * @returns {Promise<Object>} System JSON object
+ * @throws {Error} If file cannot be loaded
  */
-async function generateExternalSystemApplicationSchema(appName) {
-  if (!appName || typeof appName !== 'string') {
-    throw new Error('App name is required and must be a string');
-  }
-
-  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');
-  }
-
-  // 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');
-  }
-
-  const systemFileName = systemFiles[0];
+async function loadSystemFile(appPath, schemaBasePath, systemFileName) {
   const systemFilePath = path.isAbsolute(schemaBasePath)
     ? path.join(schemaBasePath, systemFileName)
     : path.join(appPath, schemaBasePath, systemFileName);
@@ -125,7 +102,6 @@ async function generateExternalSystemApplicationSchema(appName) {
   const systemJson = JSON.parse(systemContent);
 
   // Load rbac.yaml from app directory and merge if present
-  // Priority: roles/permissions in system JSON > rbac.yaml (if both exist, prefer JSON)
   const rbacPath = path.join(appPath, 'rbac.yaml');
   const rbac = loadRbac(rbacPath);
   if (rbac) {
@@ -137,8 +113,19 @@ async function generateExternalSystemApplicationSchema(appName) {
     }
   }
 
-  // Load datasource files
-  const datasourceFiles = variables.externalIntegration.dataSources || [];
+  return systemJson;
+}
+
+/**
+ * Load datasource files
+ * @async
+ * @param {string} appPath - Application path
+ * @param {string} schemaBasePath - Schema base path
+ * @param {Array<string>} datasourceFiles - Array of datasource file names
+ * @returns {Promise<Array<Object>>} Array of datasource JSON objects
+ * @throws {Error} If files cannot be loaded
+ */
+async function loadDatasourceFiles(appPath, schemaBasePath, datasourceFiles) {
   const datasourceJsons = [];
 
   for (const datasourceFile of datasourceFiles) {
@@ -155,69 +142,155 @@ async function generateExternalSystemApplicationSchema(appName) {
     datasourceJsons.push(datasourceJson);
   }
 
-  // Build application-schema.json structure
-  const applicationSchema = {
-    version: variables.externalIntegration.version || '1.0.0',
+  return datasourceJsons;
+}
+
+/**
+ * Build base application schema structure
+ * @param {Object} systemJson - System JSON object
+ * @param {Array<Object>} datasourceJsons - Array of datasource JSON objects
+ * @param {string} version - Schema version
+ * @returns {Object} Application schema object
+ */
+function buildBaseSchema(systemJson, datasourceJsons, version) {
+  return {
+    version: version || '1.0.0',
     application: systemJson,
     dataSources: datasourceJsons
   };
+}
 
-  // 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;
-  }
+/**
+ * Filter validation errors to handle schema inconsistencies
+ * @param {Array} errors - Validation errors
+ * @param {Object} schema - Schema object
+ * @returns {Array} Filtered errors
+ */
+function filterValidationErrors(errors, schema) {
+  return errors.filter(err => {
+    if (err.keyword === 'additionalProperties' && err.params?.additionalProperty === 'authentication') {
+      const required = schema.required || [];
+      if (required.includes('authentication')) {
+        return false; // Ignore this error since authentication is required but not defined
+      }
+    }
+    return true;
+  });
+}
 
-  const ajv = new Ajv({ allErrors: true, strict: false, removeAdditional: false });
+/**
+ * Format validation errors for display
+ * @param {Array} errors - Validation errors
+ * @returns {string} Formatted error message
+ */
+function formatValidationErrors(errors) {
+  return errors.map(err => {
+    const path = err.instancePath || err.schemaPath;
+    return `${path} ${err.message}`;
+  }).join(', ');
+}
 
-  // Validate application (system) against external-system schema
+/**
+ * Validate system against external-system schema
+ * @param {Object} systemJson - System JSON object
+ * @param {Object} externalSystemSchema - External system schema
+ * @param {Object} ajv - AJV instance
+ * @throws {Error} If validation fails
+ */
+function validateSystemSchema(systemJson, externalSystemSchema, ajv) {
   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;
-    });
-
+    const filteredErrors = filterValidationErrors(validateSystem.errors, externalSystemSchema);
     if (filteredErrors.length > 0) {
-      const errors = filteredErrors.map(err => {
-        const path = err.instancePath || err.schemaPath;
-        return `${path} ${err.message}`;
-      }).join(', ');
+      const errors = formatValidationErrors(filteredErrors);
       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);
+/**
+ * Validate datasources against external-datasource schema
+ * @param {Array<Object>} datasourceJsons - Array of datasource JSON objects
+ * @param {Object} externalDatasourceSchema - External datasource schema
+ * @param {Object} ajv - AJV instance
+ * @throws {Error} If validation fails
+ */
+function validateDatasourceSchemas(datasourceJsons, externalDatasourceSchema, ajv) {
+  const externalDatasourceSchemaId = externalDatasourceSchema.$id || 'https://raw.githubusercontent.com/esystemsdev/aifabrix-builder/refs/heads/main/lib/schema/external-datasource.schema.json';
+  ajv.addSchema(externalDatasourceSchema, externalDatasourceSchemaId);
+  const validateDatasource = ajv.compile(externalDatasourceSchema);
 
   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(', ');
+      const errors = formatValidationErrors(validateDatasource.errors);
       throw new Error(`Datasource ${i + 1} (${datasourceJsons[i].key || 'unknown'}) does not match external-datasource schema: ${errors}`);
     }
   }
+}
+
+/**
+ * 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');
+  }
+
+  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');
+  }
+
+  // Load system file and merge RBAC
+  const schemaBasePath = variables.externalIntegration.schemaBasePath || './';
+  const systemFiles = variables.externalIntegration.systems || [];
+
+  if (systemFiles.length === 0) {
+    throw new Error('No system files specified in externalIntegration.systems');
+  }
+
+  const systemJson = await loadSystemFile(appPath, schemaBasePath, systemFiles[0]);
+
+  // Load datasource files
+  const datasourceFiles = variables.externalIntegration.dataSources || [];
+  const datasourceJsons = await loadDatasourceFiles(appPath, schemaBasePath, datasourceFiles);
+
+  // Build application-schema.json structure
+  const applicationSchema = buildBaseSchema(systemJson, datasourceJsons, variables.externalIntegration.version);
+
+  // 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
+  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 system against external-system schema
+  validateSystemSchema(systemJson, externalSystemSchema, ajv);
+
+  // Validate datasources against external-datasource schema
+  validateDatasourceSchemas(datasourceJsons, datasourceSchemaToAdd, ajv);
 
   return applicationSchema;
 }

package/lib/generator-helpers.js

@@ -63,17 +63,12 @@ function loadRbac(rbacPath) {
 }
 
 /**
- * Validates portalInput structure against schema requirements
- * @param {Object} portalInput - Portal input configuration to validate
+ * Validate required fields in portalInput
+ * @param {Object} portalInput - Portal input configuration
  * @param {string} variableName - Variable name for error messages
- * @throws {Error} If portalInput structure is invalid
+ * @throws {Error} If required fields are missing
  */
-function validatePortalInput(portalInput, variableName) {
-  if (!portalInput || typeof portalInput !== 'object') {
-    throw new Error(`Invalid portalInput for variable '${variableName}': must be an object`);
-  }
-
-  // Check required fields
+function validateRequiredFields(portalInput, variableName) {
   if (!portalInput.field || typeof portalInput.field !== 'string') {
     throw new Error(`Invalid portalInput for variable '${variableName}': field is required and must be a string`);
   }
@@ -81,21 +76,48 @@ function validatePortalInput(portalInput, variableName) {
   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
+/**
+ * Validate field type in portalInput
+ * @param {Object} portalInput - Portal input configuration
+ * @param {string} variableName - Variable name for error messages
+ * @throws {Error} If field type is invalid
+ */
+function validateFieldType(portalInput, variableName) {
   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
+/**
+ * Validate select field options
+ * @param {Object} portalInput - Portal input configuration
+ * @param {string} variableName - Variable name for error messages
+ * @throws {Error} If select field options are invalid
+ */
+function validateSelectFieldOptions(portalInput, variableName) {
   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.options !== undefined && portalInput.field !== 'select') {
+    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`);
+    }
+  }
+}
+
+/**
+ * Validate optional fields in portalInput
+ * @param {Object} portalInput - Portal input configuration
+ * @param {string} variableName - Variable name for error messages
+ * @throws {Error} If optional fields are invalid
+ */
+function validateOptionalFields(portalInput, variableName) {
   if (portalInput.placeholder !== undefined && typeof portalInput.placeholder !== 'string') {
     throw new Error(`Invalid portalInput for variable '${variableName}': placeholder must be a string`);
   }
@@ -109,13 +131,23 @@ function validatePortalInput(portalInput, variableName) {
       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`);
-    }
+/**
+ * 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`);
   }
+
+  validateRequiredFields(portalInput, variableName);
+  validateFieldType(portalInput, variableName);
+  validateSelectFieldOptions(portalInput, variableName);
+  validateOptionalFields(portalInput, variableName);
 }
 
 /**

package/lib/generator-split.js

@@ -84,98 +84,145 @@ function parseImageReference(imageString) {
 }
 
 /**
- * Extracts deployment JSON into variables.yaml structure
- * @function extractVariablesYaml
+ * Extract app section from deployment
  * @param {Object} deployment - Deployment JSON object
- * @returns {Object} Variables YAML structure
+ * @returns {Object|undefined} App section or undefined
  */
-function extractVariablesYaml(deployment) {
-  if (!deployment || typeof deployment !== 'object') {
-    throw new Error('Deployment object is required');
+function extractAppSection(deployment) {
+  if (!deployment.key && !deployment.displayName && !deployment.description && !deployment.type) {
+    return undefined;
   }
 
-  const variables = {};
+  const app = {};
+  if (deployment.key) app.key = deployment.key;
+  if (deployment.displayName) app.displayName = deployment.displayName;
+  if (deployment.description) app.description = deployment.description;
+  if (deployment.type) app.type = deployment.type;
+  return app;
+}
 
-  // 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 section from deployment
+ * @param {Object} deployment - Deployment JSON object
+ * @returns {Object|undefined} Image section or undefined
+ */
+function extractImageSection(deployment) {
+  if (!deployment.image) {
+    return undefined;
   }
 
-  // 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;
-  }
+  const imageParts = parseImageReference(deployment.image);
+  const image = {};
+  if (imageParts.name) image.name = imageParts.name;
+  if (imageParts.registry) image.registry = imageParts.registry;
+  if (imageParts.tag) image.tag = imageParts.tag;
+  if (deployment.registryMode) image.registryMode = deployment.registryMode;
+  return image;
+}
 
-  // Extract port
-  if (deployment.port !== undefined) {
-    variables.port = deployment.port;
+/**
+ * Extract requirements section from deployment
+ * @param {Object} deployment - Deployment JSON object
+ * @returns {Object|undefined} Requirements section or undefined
+ */
+function extractRequirementsSection(deployment) {
+  if (!deployment.requiresDatabase && !deployment.requiresRedis && !deployment.requiresStorage && !deployment.databases) {
+    return undefined;
   }
 
-  // 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;
-  }
+  const requires = {};
+  if (deployment.requiresDatabase !== undefined) requires.database = deployment.requiresDatabase;
+  if (deployment.requiresRedis !== undefined) requires.redis = deployment.requiresRedis;
+  if (deployment.requiresStorage !== undefined) requires.storage = deployment.requiresStorage;
+  if (deployment.databases) requires.databases = deployment.databases;
+  return requires;
+}
+
+/**
+ * Extract optional sections from deployment
+ * @param {Object} deployment - Deployment JSON object
+ * @returns {Object} Object with optional sections
+ */
+function extractOptionalSections(deployment) {
+  const optional = {};
 
-  // Extract healthCheck
   if (deployment.healthCheck) {
-    variables.healthCheck = deployment.healthCheck;
+    optional.healthCheck = deployment.healthCheck;
   }
-
-  // Extract authentication
   if (deployment.authentication) {
-    variables.authentication = { ...deployment.authentication };
+    optional.authentication = { ...deployment.authentication };
   }
-
-  // Extract build
   if (deployment.build) {
-    variables.build = deployment.build;
+    optional.build = deployment.build;
   }
-
-  // Extract repository
   if (deployment.repository) {
-    variables.repository = deployment.repository;
+    optional.repository = deployment.repository;
   }
-
-  // Extract deployment config
   if (deployment.deployment) {
-    variables.deployment = deployment.deployment;
+    optional.deployment = deployment.deployment;
   }
-
-  // Extract other optional fields
   if (deployment.startupCommand) {
-    variables.startupCommand = deployment.startupCommand;
+    optional.startupCommand = deployment.startupCommand;
   }
   if (deployment.runtimeVersion) {
-    variables.runtimeVersion = deployment.runtimeVersion;
+    optional.runtimeVersion = deployment.runtimeVersion;
   }
   if (deployment.scaling) {
-    variables.scaling = deployment.scaling;
+    optional.scaling = deployment.scaling;
   }
   if (deployment.frontDoorRouting) {
-    variables.frontDoorRouting = deployment.frontDoorRouting;
+    optional.frontDoorRouting = deployment.frontDoorRouting;
   }
-
-  // Extract roles and permissions (if present)
   if (deployment.roles) {
-    variables.roles = deployment.roles;
+    optional.roles = deployment.roles;
   }
   if (deployment.permissions) {
-    variables.permissions = deployment.permissions;
+    optional.permissions = deployment.permissions;
+  }
+
+  return optional;
+}
+
+/**
+ * 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 section
+  const appSection = extractAppSection(deployment);
+  if (appSection) {
+    variables.app = appSection;
+  }
+
+  // Extract image section
+  const imageSection = extractImageSection(deployment);
+  if (imageSection) {
+    variables.image = imageSection;
+  }
+
+  // Extract port
+  if (deployment.port !== undefined) {
+    variables.port = deployment.port;
+  }
+
+  // Extract requirements section
+  const requirementsSection = extractRequirementsSection(deployment);
+  if (requirementsSection) {
+    variables.requires = requirementsSection;
+  }
+
+  // Extract optional sections
+  const optionalSections = extractOptionalSections(deployment);
+  Object.assign(variables, optionalSections);
+
   return variables;
 }