@aifabrix/builder 2.41.0 → 2.42.0

package/lib/commands/repair-datasource.js

@@ -0,0 +1,235 @@
+/**
+ * Datasource repair helpers: align dimensions, metadataSchema, exposed, sync, testPayload
+ * with fieldMappings.attributes as source of truth.
+ *
+ * @fileoverview Repair datasource files for external integration
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const DEFAULT_SYNC = {
+  mode: 'pull',
+  batchSize: 500,
+  maxParallelRequests: 5
+};
+
+const MINIMAL_METADATA_SCHEMA = {
+  type: 'object',
+  additionalProperties: true
+};
+
+/**
+ * Returns the set of attribute keys from fieldMappings.attributes.
+ * @param {Object} parsed - Parsed datasource object
+ * @returns {Set<string>}
+ */
+function getAttributeKeys(parsed) {
+  const attrs = parsed?.fieldMappings?.attributes;
+  if (!attrs || typeof attrs !== 'object') return new Set();
+  return new Set(Object.keys(attrs));
+}
+
+/**
+ * Extracts paths from attribute expressions (e.g. {{ metadata.email }}).
+ * Skips record_ref: expressions.
+ * - topLevelKeys: first segment of each path (e.g. "metadata" from "metadata.id").
+ * - referencedSchemaPropertyNames: for paths like "metadata.xxx" or "metadata.xxx.yyy", the name "xxx"
+ *   (the first property under metadata). Used to prune metadataSchema.properties so we only keep
+ *   properties that are referenced; we do not compare against "metadata" or the schema would be wiped.
+ *
+ * @param {Object} attributes - fieldMappings.attributes object
+ * @returns {{ paths: string[], topLevelKeys: Set<string>, referencedSchemaPropertyNames: Set<string> }}
+ */
+function parsePathsFromExpressions(attributes) {
+  const paths = [];
+  const topLevelKeys = new Set();
+  const referencedSchemaPropertyNames = new Set();
+  if (!attributes || typeof attributes !== 'object') return { paths, topLevelKeys, referencedSchemaPropertyNames };
+  for (const attr of Object.values(attributes)) {
+    const expr = attr?.expression;
+    if (typeof expr !== 'string') continue;
+    if (/^\s*record_ref:/i.test(expr.trim())) continue;
+    const match = expr.match(/\{\{\s*([^}]+)\s*\}\}/);
+    if (!match) continue;
+    const path = match[1].trim().split('|')[0].trim();
+    if (path) {
+      paths.push(path);
+      const segments = path.split('.');
+      const first = segments[0];
+      if (first) topLevelKeys.add(first);
+      if (first === 'metadata' && segments.length >= 2 && segments[1]) {
+        referencedSchemaPropertyNames.add(segments[1]);
+      }
+    }
+  }
+  return { paths, topLevelKeys, referencedSchemaPropertyNames };
+}
+
+/**
+ * Removes dimension entries whose value is metadata.<attr> and attr is not in fieldMappings.attributes.
+ * Mutates parsed.fieldMappings.dimensions.
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if any dimension was removed
+ */
+function repairDimensionsFromAttributes(parsed, changes) {
+  const dims = parsed?.fieldMappings?.dimensions;
+  if (!dims || typeof dims !== 'object') return false;
+  const attributeKeys = getAttributeKeys(parsed);
+  let updated = false;
+  for (const [dimKey, value] of Object.entries(dims)) {
+    if (typeof value !== 'string') continue;
+    if (!value.startsWith('metadata.')) continue;
+    const attr = value.slice('metadata.'.length).trim();
+    if (!attr || attributeKeys.has(attr)) continue;
+    delete dims[dimKey];
+    changes.push(`Removed dimension '${dimKey}': ${value} not in fieldMappings.attributes`);
+    updated = true;
+  }
+  return updated;
+}
+
+/**
+ * Ensures metadataSchema exists (minimal stub if missing). If present, prunes top-level
+ * properties not referenced by any attribute expression. Uses the first property name under
+ * "metadata" in paths (e.g. metadata.id → "id") so we do not remove schema properties that
+ * are referenced. If no metadata.xxx paths exist, we do not prune (keep all properties).
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if schema was added or pruned
+ */
+function repairMetadataSchemaFromAttributes(parsed, changes) {
+  const { referencedSchemaPropertyNames } = parsePathsFromExpressions(parsed?.fieldMappings?.attributes ?? {});
+  if (!parsed.metadataSchema || typeof parsed.metadataSchema !== 'object') {
+    parsed.metadataSchema = { ...MINIMAL_METADATA_SCHEMA };
+    changes.push('Added minimal metadataSchema (was missing)');
+    return true;
+  }
+  const props = parsed.metadataSchema.properties;
+  if (!props || typeof props !== 'object') return false;
+  if (referencedSchemaPropertyNames.size === 0) return false;
+  const toRemove = Object.keys(props).filter(k => !referencedSchemaPropertyNames.has(k));
+  if (toRemove.length === 0) return false;
+  toRemove.forEach(k => delete props[k]);
+  changes.push(`Pruned metadataSchema.properties: removed [${toRemove.join(', ')}] (not referenced by attributes)`);
+  return true;
+}
+
+/**
+ * Sets exposed.attributes to the list of fieldMappings.attributes keys (sorted).
+ * Only when options.expose is true; caller should gate.
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if exposed was updated
+ */
+function repairExposeFromAttributes(parsed, changes) {
+  const keys = Array.from(getAttributeKeys(parsed)).filter(Boolean).sort();
+  if (keys.length === 0) return false;
+  if (!parsed.exposed) parsed.exposed = {};
+  const prev = parsed.exposed.attributes;
+  const same = Array.isArray(prev) && prev.length === keys.length && prev.every((v, i) => v === keys[i]);
+  if (same) return false;
+  parsed.exposed.attributes = keys;
+  changes.push(`Set exposed.attributes to [${keys.join(', ')}]`);
+  return true;
+}
+
+/**
+ * Adds default sync section if missing or empty.
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if sync was added
+ */
+function repairSyncSection(parsed, changes) {
+  const sync = parsed.sync;
+  if (sync && typeof sync === 'object' && Object.keys(sync).length > 0) return false;
+  parsed.sync = { ...DEFAULT_SYNC };
+  changes.push('Added default sync section (mode: pull, batchSize: 500, maxParallelRequests: 5)');
+  return true;
+}
+
+function placeholderForType(type) {
+  if (type === 'number' || type === 'integer') return 0;
+  if (type === 'boolean') return false;
+  if (type === 'array') return [];
+  if (type === 'object') return {};
+  return '';
+}
+
+function setNested(obj, pathParts, value) {
+  let cur = obj;
+  for (let i = 0; i < pathParts.length - 1; i++) {
+    const p = pathParts[i];
+    if (!(p in cur) || typeof cur[p] !== 'object') cur[p] = {};
+    cur = cur[p];
+  }
+  const last = pathParts[pathParts.length - 1];
+  if (last) cur[last] = value;
+}
+
+/**
+ * Builds minimal payloadTemplate and expectedResult from attribute expression paths.
+ *
+ * @param {Object} parsed - Parsed datasource (mutated)
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if testPayload was added or updated
+ */
+function repairTestPayload(parsed, changes) {
+  const attrs = parsed?.fieldMappings?.attributes;
+  if (!attrs || typeof attrs !== 'object') return false;
+  const payloadTemplate = {};
+  const expectedResult = {};
+  for (const [key, config] of Object.entries(attrs)) {
+    const type = config?.type || 'string';
+    const placeholder = placeholderForType(type);
+    expectedResult[key] = placeholder;
+    const match = config?.expression?.match(/\{\{\s*([^}|]+)/);
+    if (match) {
+      const path = match[1].trim();
+      setNested(payloadTemplate, path.split('.'), placeholder);
+    }
+  }
+  if (!parsed.testPayload) parsed.testPayload = {};
+  parsed.testPayload.payloadTemplate = payloadTemplate;
+  parsed.testPayload.expectedResult = expectedResult;
+  changes.push('Generated testPayload.payloadTemplate and testPayload.expectedResult from attributes');
+  return true;
+}
+
+/**
+ * Runs all requested datasource repairs. Core: dimensions + metadataSchema. Optional: expose, sync, testPayload.
+ *
+ * @param {Object} parsed - Parsed datasource object (mutated)
+ * @param {Object} options - { expose?: boolean, sync?: boolean, test?: boolean }
+ * @param {string[]} [changes] - Optional array to append change descriptions to
+ * @returns {{ updated: boolean, changes: string[] }}
+ */
+function repairDatasourceFile(parsed, options = {}, changes = []) {
+  const out = Array.isArray(changes) ? changes : [];
+  let updated = false;
+  updated = repairDimensionsFromAttributes(parsed, out) || updated;
+  updated = repairMetadataSchemaFromAttributes(parsed, out) || updated;
+  if (options.expose) updated = repairExposeFromAttributes(parsed, out) || updated;
+  if (options.sync) updated = repairSyncSection(parsed, out) || updated;
+  if (options.test) updated = repairTestPayload(parsed, out) || updated;
+  return { updated, changes: out };
+}
+
+module.exports = {
+  getAttributeKeys,
+  parsePathsFromExpressions,
+  repairDimensionsFromAttributes,
+  repairMetadataSchemaFromAttributes,
+  repairExposeFromAttributes,
+  repairSyncSection,
+  repairTestPayload,
+  repairDatasourceFile,
+  DEFAULT_SYNC,
+  MINIMAL_METADATA_SCHEMA
+};

package/lib/commands/repair-env-template.js

@@ -0,0 +1,348 @@
+/**
+ * Helpers for repairing env.template from system config (KV_* names, path-style kv://).
+ * @fileoverview Repair env.template to match system file
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const { systemKeyToKvPrefix, kvEnvKeyToPath, securityKeyToVar } = require('../utils/credential-secrets-env');
+const { extractEnvTemplate } = require('../generator/split');
+
+/**
+ * Normalizes a keyvault config entry to canonical KV_* name and path-style value.
+ * Path format: kv://<system-key>/<variable> (e.g. kv://microsoft-teams/clientId).
+ * @param {Object} entry - Config entry with name, value, location
+ * @param {string} prefix - KV prefix (e.g. MICROSOFT_TEAMS)
+ * @param {string} systemKey - System key (e.g. microsoft-teams) for path namespace
+ * @returns {{ name: string, value: string }|null}
+ */
+function normalizeKeyvaultEntry(entry, prefix, systemKey) {
+  const afterPrefix = entry.name.startsWith(`KV_${prefix}_`)
+    ? entry.name.slice(`KV_${prefix}_`.length)
+    : entry.name.replace(/^KV_[A-Z0-9]+_/, '');
+  const normalizedVar = afterPrefix.replace(/_/g, '').toUpperCase();
+  const normalizedName = `KV_${prefix}_${normalizedVar}`;
+  const pathVal = kvEnvKeyToPath(normalizedName, systemKey);
+  if (!pathVal) return null;
+  return {
+    name: normalizedName,
+    value: pathVal.replace(/^kv:\/\//, ''),
+    location: 'keyvault'
+  };
+}
+
+/**
+ * Adds effective config entries from system configuration array.
+ * @param {Array} effective - Mutable result array
+ * @param {Array} config - System configuration array
+ * @param {string} prefix - KV prefix
+ * @param {Set<string>} seenNames - Mutable set of names already added
+ * @param {string} systemKey - System key for path format kv://systemKey/variable
+ */
+function addFromConfiguration(effective, config, prefix, seenNames, systemKey) {
+  for (const entry of config) {
+    if (!entry || !entry.name) continue;
+    if (entry.location === 'keyvault') {
+      const normalized = normalizeKeyvaultEntry(entry, prefix, systemKey);
+      if (normalized && !seenNames.has(normalized.name)) {
+        effective.push(normalized);
+        seenNames.add(normalized.name);
+      }
+    } else if (!seenNames.has(entry.name)) {
+      effective.push({
+        name: entry.name,
+        value: String(entry.value ?? ''),
+        location: entry.location
+      });
+      seenNames.add(entry.name);
+    }
+  }
+}
+
+/**
+ * Adds effective config entries from authentication.security.
+ * Path format: kv://<system-key>/<variable> (e.g. kv://microsoft-teams/clientId).
+ * @param {Array} effective - Mutable result array
+ * @param {Object} systemParsed - Parsed system config
+ * @param {string} prefix - KV prefix
+ * @param {Set<string>} seenNames - Mutable set of names already added
+ * @param {string} systemKey - System key for path namespace
+ */
+function addFromAuthSecurity(effective, systemParsed, prefix, seenNames, systemKey) {
+  const security = systemParsed.authentication?.security;
+  if (!security || typeof security !== 'object') return;
+  for (const key of Object.keys(security)) {
+    const envName = `KV_${prefix}_${securityKeyToVar(key)}`;
+    if (seenNames.has(envName)) continue;
+    const pathVal = kvEnvKeyToPath(envName, systemKey);
+    if (pathVal) {
+      effective.push({
+        name: envName,
+        value: pathVal.replace(/^kv:\/\//, ''),
+        location: 'keyvault'
+      });
+      seenNames.add(envName);
+    }
+  }
+}
+
+/**
+ * Builds effective configuration array from system (KV_* names, path-style kv://).
+ * @param {Object} systemParsed - Parsed system config
+ * @param {string} systemKey - System key (e.g. 'hubspot')
+ * @returns {Array<{ name: string, value: string, location?: string }>}
+ */
+function buildEffectiveConfiguration(systemParsed, systemKey) {
+  const effective = [];
+  const prefix = systemKeyToKvPrefix(systemKey);
+  if (!prefix) return effective;
+  const seenNames = new Set();
+  const config = Array.isArray(systemParsed.configuration) ? systemParsed.configuration : [];
+  addFromConfiguration(effective, config, prefix, seenNames, systemKey);
+  addFromAuthSecurity(effective, systemParsed, prefix, seenNames, systemKey);
+  return effective;
+}
+
+/**
+ * Builds map of env key -> full line (KEY=value) from effective config.
+ * @param {Array} effective - Effective configuration array
+ * @returns {Map<string, string>}
+ */
+function buildExpectedByKey(effective) {
+  const expectedByKey = new Map();
+  const lines = extractEnvTemplate(effective).split('\n').filter(Boolean);
+  for (const line of lines) {
+    const eq = line.indexOf('=');
+    if (eq > 0) {
+      const key = line.substring(0, eq).trim();
+      expectedByKey.set(key, `${key}=${line.substring(eq + 1)}`);
+    }
+  }
+  return expectedByKey;
+}
+
+/**
+ * Creates env.template when missing. Returns true if created (and change pushed).
+ * @param {string} envPath - Path to env.template
+ * @param {Map<string, string>} expectedByKey - Expected key->line map
+ * @param {boolean} dryRun - If true, do not write
+ * @param {string[]} changes - Array to append to
+ * @returns {boolean}
+ */
+function createEnvTemplateIfMissing(envPath, expectedByKey, dryRun, changes) {
+  if (fs.existsSync(envPath)) return false;
+  const lines = Array.from(expectedByKey.values());
+  const content = lines.join('\n');
+  if (!content) return false;
+  if (!dryRun) {
+    fs.writeFileSync(envPath, content + '\n', { mode: 0o644, encoding: 'utf8' });
+  }
+  changes.push('Created env.template from system configuration');
+  return true;
+}
+
+/**
+ * Extracts env key from a commented line (e.g. "# KEY=value" or "#KEY=value"). Returns null if not key=value.
+ * @param {string} trimmed - Trimmed line (starts with #)
+ * @returns {string|null} Key part after # and before =, or null
+ */
+function keyFromCommentedLine(trimmed) {
+  const afterHash = trimmed.slice(1).trim();
+  if (!afterHash.includes('=')) return null;
+  const eq = afterHash.indexOf('=');
+  if (eq <= 0) return null;
+  const key = afterHash.substring(0, eq).trim();
+  return key || null;
+}
+
+/**
+ * Processes one line: keep as-is or replace with expected. Mutates updatedLines, keysWritten, changed.
+ * Preserves existing key=value in env.template: if a key already has a value, that value is never overwritten.
+ * Treats commented key=value (e.g. # KV_X=kv://...) as "already present" so repair does not add it again.
+ * Only missing keys from expectedByKey are added at the end.
+ * @param {string} line - Current line
+ * @param {Map<string, string>} expectedByKey - Expected key->line map
+ * @param {string[]} updatedLines - Mutable output lines
+ * @param {Set<string>} keysWritten - Mutable set of keys written
+ * @param {{ value: boolean }} _changedRef - Mutable changed flag (caller tracks changes)
+ */
+function processLine(line, expectedByKey, updatedLines, keysWritten, _changedRef) {
+  const trimmed = line.trim();
+  if (!trimmed || trimmed.startsWith('#')) {
+    if (trimmed.startsWith('#')) {
+      const commentedKey = keyFromCommentedLine(trimmed);
+      if (commentedKey && expectedByKey.has(commentedKey)) keysWritten.add(commentedKey);
+    }
+    updatedLines.push(line);
+    return;
+  }
+  const eq = line.indexOf('=');
+  if (eq <= 0) {
+    updatedLines.push(line);
+    return;
+  }
+  const key = line.substring(0, eq).trim();
+  if (expectedByKey.has(key)) {
+    // Keep existing value; do not overwrite with expected (user may have set kv:// or custom value)
+    updatedLines.push(line);
+    keysWritten.add(key);
+  } else {
+    updatedLines.push(line);
+  }
+}
+
+/**
+ * Merges existing env.template content with expected key=value lines.
+ * Preserves comments, blank lines, and vars not in expectedByKey.
+ * @param {string} content - Current file content
+ * @param {Map<string, string>} expectedByKey - Expected key->line map
+ * @returns {{ output: string, changed: boolean }}
+ */
+function mergeEnvTemplateContent(content, expectedByKey) {
+  const lines = content.split(/\r?\n/);
+  const updatedLines = [];
+  const keysWritten = new Set();
+  const changedRef = { value: false };
+
+  for (const line of lines) {
+    processLine(line, expectedByKey, updatedLines, keysWritten, changedRef);
+  }
+  for (const key of expectedByKey.keys()) {
+    if (!keysWritten.has(key)) {
+      updatedLines.push(expectedByKey.get(key));
+      changedRef.value = true;
+    }
+  }
+
+  const output = updatedLines.join('\n') + (updatedLines.length > 0 ? '\n' : '');
+  return { output, changed: changedRef.value };
+}
+
+/**
+ * Repairs env.template so KV_ names and path-style kv:// values match the system file.
+ * @param {string} appPath - Application directory path
+ * @param {Object} systemParsed - Parsed system config
+ * @param {string} systemKey - System key
+ * @param {boolean} dryRun - If true, do not write
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if env.template was repaired or created
+ */
+function repairEnvTemplate(appPath, systemParsed, systemKey, dryRun, changes) {
+  const effective = buildEffectiveConfiguration(systemParsed, systemKey);
+  const expectedByKey = buildExpectedByKey(effective);
+  const envPath = path.join(appPath, 'env.template');
+
+  if (createEnvTemplateIfMissing(envPath, expectedByKey, dryRun, changes)) {
+    return true;
+  }
+  if (!fs.existsSync(envPath)) {
+    return false;
+  }
+
+  const content = fs.readFileSync(envPath, 'utf8');
+  const { output, changed } = mergeEnvTemplateContent(content, expectedByKey);
+
+  if (changed && !dryRun) {
+    fs.writeFileSync(envPath, output, { mode: 0o644, encoding: 'utf8' });
+  }
+  if (changed) {
+    changes.push('Repaired env.template (KV_* names and path-style kv:// values)');
+    return true;
+  }
+  return false;
+}
+
+/**
+ * Returns true if a kv value looks like legacy format (KeyVault suffix or no path segments).
+ * @param {string} val - Value from authentication.security or configuration
+ * @returns {boolean}
+ */
+function isLegacyKvValue(val) {
+  if (typeof val !== 'string' || !val.trim().toLowerCase().startsWith('kv://')) return false;
+  const after = val.trim().slice(5); // after 'kv://'
+  return after.includes('KeyVault') || !after.includes('/');
+}
+
+/**
+ * Normalizes authentication.security values to path-style kv:// (kv://systemKey/variable).
+ * @param {Object} security - authentication.security object (mutated)
+ * @param {string} prefix - KV prefix (e.g. 'HUBSPOT')
+ * @param {string} systemKey - System key for path namespace
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if any change was made
+ */
+function normalizeSecuritySection(security, prefix, systemKey, changes) {
+  let updated = false;
+  for (const key of Object.keys(security)) {
+    const val = security[key];
+    if (typeof val !== 'string' || !isLegacyKvValue(val)) continue;
+    const envName = `KV_${prefix}_${securityKeyToVar(key)}`;
+    const pathVal = kvEnvKeyToPath(envName, systemKey);
+    if (pathVal) {
+      security[key] = pathVal;
+      changes.push(`authentication.security.${key}: normalized to path-style ${pathVal}`);
+      updated = true;
+    }
+  }
+  return updated;
+}
+
+/**
+ * Normalizes configuration array keyvault entries to canonical KV_* names and path-style values.
+ * @param {Object[]} config - configuration array (mutated)
+ * @param {string} prefix - KV prefix (e.g. 'HUBSPOT')
+ * @param {string} systemKey - System key for path namespace
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if any change was made
+ */
+function normalizeConfigurationSection(config, prefix, systemKey, changes) {
+  let updated = false;
+  for (let i = 0; i < config.length; i++) {
+    const entry = config[i];
+    if (!entry || !entry.name || (entry.location !== 'keyvault' && !String(entry.name).startsWith('KV_'))) continue;
+    const afterPrefix = entry.name.startsWith(`KV_${prefix}_`)
+      ? entry.name.slice(`KV_${prefix}_`.length)
+      : entry.name.replace(/^KV_[A-Z0-9]+_/, '');
+    const normalizedVar = afterPrefix.replace(/_/g, '').toUpperCase();
+    const canonicalName = `KV_${prefix}_${normalizedVar}`;
+    const pathVal = kvEnvKeyToPath(canonicalName, systemKey);
+    if (!pathVal) continue;
+    const pathValWithoutPrefix = pathVal.replace(/^kv:\/\//, '');
+    const valueLegacy = typeof entry.value === 'string' && (entry.value.includes('KeyVault') || !entry.value.includes('/'));
+    if (entry.name !== canonicalName || (valueLegacy && entry.value !== pathValWithoutPrefix)) {
+      config[i] = { ...entry, name: canonicalName, value: pathValWithoutPrefix, location: 'keyvault' };
+      changes.push(`configuration: normalized ${entry.name} → ${canonicalName}, value → path-style`);
+      updated = true;
+    }
+  }
+  return updated;
+}
+
+/**
+ * Normalizes system file authentication.security and configuration keyvault entries.
+ * @param {Object} systemParsed - Parsed system config (mutated)
+ * @param {string} systemKey - System key (e.g. 'hubspot')
+ * @param {string[]} changes - Array to append change descriptions to
+ * @returns {boolean} True if any change was made
+ */
+function normalizeSystemFileAuthAndConfig(systemParsed, systemKey, changes) {
+  const prefix = systemKeyToKvPrefix(systemKey);
+  if (!prefix) return false;
+  const security = systemParsed.authentication?.security;
+  let updated = (security && typeof security === 'object' && normalizeSecuritySection(security, prefix, systemKey, changes));
+  const config = systemParsed.configuration;
+  if (Array.isArray(config)) {
+    updated = normalizeConfigurationSection(config, prefix, systemKey, changes) || updated;
+  }
+  return updated;
+}
+
+module.exports = {
+  buildEffectiveConfiguration,
+  repairEnvTemplate,
+  normalizeSystemFileAuthAndConfig
+};

package/lib/commands/repair-internal.js

@@ -0,0 +1,85 @@
+/**
+ * Internal helpers for repair command: file discovery and datasource list building.
+ *
+ * @fileoverview Repair discovery and datasource helpers
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+const logger = require('../utils/logger');
+
+/** Matches *-datasource-*.(yaml|yml|json) or datasource-*.(yaml|yml|json) */
+function isDatasourceFileName(name) {
+  if (!/\.(yaml|yml|json)$/i.test(name)) return false;
+  return /-datasource-.+\.(yaml|yml|json)$/i.test(name) || /^datasource-.+\.(yaml|yml|json)$/i.test(name);
+}
+
+/**
+ * Discovers system and datasource files in app directory
+ * @param {string} appPath - Application directory path
+ * @returns {{ systemFiles: string[], datasourceFiles: string[] }}
+ */
+function discoverIntegrationFiles(appPath) {
+  if (!fs.existsSync(appPath)) {
+    return { systemFiles: [], datasourceFiles: [] };
+  }
+  const entries = fs.readdirSync(appPath);
+  const systemFiles = [];
+  const datasourceFiles = [];
+  for (const name of entries) {
+    if (!/^[a-z0-9_.-]+\.(yaml|yml|json)$/i.test(name)) continue;
+    if (/-system\.(yaml|yml|json)$/i.test(name)) {
+      systemFiles.push(name);
+    } else if (isDatasourceFileName(name)) {
+      datasourceFiles.push(name);
+    }
+  }
+  systemFiles.sort();
+  datasourceFiles.sort();
+  return { systemFiles, datasourceFiles };
+}
+
+/**
+ * Builds the effective datasource file list from application.yaml and discovered files.
+ * @param {string} appPath - Application directory path
+ * @param {string[]} discoveredDatasourceFiles - Filenames from discoverIntegrationFiles
+ * @param {string[]} [existingDataSources] - externalIntegration.dataSources from application.yaml
+ * @returns {string[]} Sorted, deduplicated list of datasource filenames
+ */
+function buildEffectiveDatasourceFiles(appPath, discoveredDatasourceFiles, existingDataSources) {
+  const existing = Array.isArray(existingDataSources) ? existingDataSources : [];
+  const seen = new Set();
+  const result = [];
+  for (const name of existing) {
+    if (!name || typeof name !== 'string') continue;
+    const trimmed = name.trim();
+    if (!trimmed || seen.has(trimmed)) continue;
+    const filePath = path.join(appPath, trimmed);
+    if (fs.existsSync(filePath)) {
+      result.push(trimmed);
+      seen.add(trimmed);
+    } else {
+      logger.log(chalk.yellow(`⚠ Datasource file referenced in application.yaml not found: ${trimmed}`));
+    }
+  }
+  for (const name of discoveredDatasourceFiles) {
+    if (seen.has(name)) continue;
+    const filePath = path.join(appPath, name);
+    if (fs.existsSync(filePath)) {
+      result.push(name);
+      seen.add(name);
+    }
+  }
+  result.sort();
+  return result;
+}
+
+module.exports = {
+  discoverIntegrationFiles,
+  buildEffectiveDatasourceFiles
+};