@aifabrix/builder 2.37.0 → 2.37.9

package/lib/generator/wizard.js

@@ -12,6 +12,19 @@ const chalk = require('chalk');
 const logger = require('../utils/logger');
 const { generateExternalReadmeContent } = require('../utils/external-readme');
 
+/**
+ * Converts a string to a schema-valid key segment (lowercase letters, numbers, hyphens only).
+ * e.g. "recordStorage" -> "record-storage", "documentStorage" -> "document-storage"
+ * @param {string} str - Raw entity type or key segment (may be camelCase)
+ * @returns {string} Segment matching ^[a-z0-9-]+$
+ */
+function toKeySegment(str) {
+  if (!str || typeof str !== 'string') return 'default';
+  const withHyphens = str.replace(/([A-Z])/g, '-$1').toLowerCase();
+  const sanitized = withHyphens.replace(/[^a-z0-9]+/g, '-').replace(/^-|-$/g, '');
+  return sanitized || 'default';
+}
+
 /**
  * Generate files from dataplane-generated wizard configurations
  * @async
@@ -53,11 +66,12 @@ async function writeDatasourceJsonFiles(appPath, finalSystemKey, datasourceConfi
   const datasourceFileNames = [];
   for (const datasourceConfig of datasourceConfigs) {
     const entityType = datasourceConfig.entityType || datasourceConfig.entityKey || datasourceConfig.key?.split('-').pop() || 'default';
-    const datasourceKey = datasourceConfig.key || `${finalSystemKey}-${entityType}`;
-    // Extract datasource key (remove system key prefix if present)
+    const keySegment = toKeySegment(entityType);
+    const datasourceKey = datasourceConfig.key || `${finalSystemKey}-${keySegment}`;
+    // Extract datasource key (remove system key prefix if present); use normalized segment for filename
     const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${finalSystemKey}-`)
       ? datasourceKey.substring(finalSystemKey.length + 1)
-      : entityType;
+      : keySegment;
     const datasourceFileName = `${finalSystemKey}-datasource-${datasourceKeyOnly}.json`;
     const datasourceFilePath = path.join(appPath, datasourceFileName);
     await fs.writeFile(datasourceFilePath, JSON.stringify(datasourceConfig, null, 2), 'utf8');
@@ -143,13 +157,14 @@ async function generateWizardFiles(appName, systemConfig, datasourceConfigs, sys
       displayName: appDisplayName
     };
 
-    // Update datasource configs to use appName-based keys and systemKey
+    // Update datasource configs to use appName-based keys and systemKey (key must match ^[a-z0-9-]+$)
     const updatedDatasourceConfigs = datasourceConfigs.map(ds => {
       const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || 'default';
+      const keySegment = toKeySegment(entityType);
       const entityDisplayName = entityType.charAt(0).toUpperCase() + entityType.slice(1).replace(/-/g, ' ');
       return {
         ...ds,
-        key: `${finalSystemKey}-${entityType}`,
+        key: `${finalSystemKey}-${keySegment}`,
         systemKey: finalSystemKey,
         displayName: `${appDisplayName} ${entityDisplayName}`
       };
@@ -360,23 +375,22 @@ async function generateEnvTemplate(appPath, systemConfig) {
 }
 
 /**
- * Generate deployment scripts (deploy.sh, deploy.ps1, deploy.js) from templates
+ * Generate deployment script (deploy.js) from template
  * @async
  * @function generateDeployScripts
  * @param {string} appPath - Application directory path
  * @param {string} systemKey - System key
  * @param {string} systemFileName - System file name
  * @param {string[]} datasourceFileNames - Array of datasource file names
- * @returns {Promise<Object>} Object with deployShPath, deployPs1Path, deployJsPath
+ * @returns {Promise<Object>} Object with deployJsPath
  * @throws {Error} If generation fails
  */
 const templatesExternalDir = path.join(__dirname, '..', '..', 'templates', 'external-system');
 
-async function writeDeployScriptFromTemplate(templateName, outputPath, context, executable) {
+async function writeDeployScriptFromTemplate(templateName, outputPath, context) {
   const templatePath = path.join(templatesExternalDir, templateName);
   const content = Handlebars.compile(await fs.readFile(templatePath, 'utf8'))(context);
   await fs.writeFile(outputPath, content, 'utf8');
-  if (executable) await fs.chmod(outputPath, 0o755);
   logger.log(chalk.green(`✓ Generated ${path.basename(outputPath)}`));
 }
 
@@ -385,13 +399,9 @@ async function generateDeployScripts(appPath, systemKey, systemFileName, datasou
     const allJsonFiles = [systemFileName, ...datasourceFileNames];
     const context = { systemKey, allJsonFiles, datasourceFileNames };
 
-    await writeDeployScriptFromTemplate('deploy.sh.hbs', path.join(appPath, 'deploy.sh'), context, true);
-    await writeDeployScriptFromTemplate('deploy.ps1.hbs', path.join(appPath, 'deploy.ps1'), context, false);
-    await writeDeployScriptFromTemplate('deploy.js.hbs', path.join(appPath, 'deploy.js'), context, false);
+    await writeDeployScriptFromTemplate('deploy.js.hbs', path.join(appPath, 'deploy.js'), context);
 
     return {
-      deployShPath: path.join(appPath, 'deploy.sh'),
-      deployPs1Path: path.join(appPath, 'deploy.ps1'),
       deployJsPath: path.join(appPath, 'deploy.js')
     };
   } catch (error) {
@@ -424,10 +434,11 @@ async function generateReadme(appPath, appName, systemKey, systemConfig, datasou
 
     const datasources = (Array.isArray(datasourceConfigs) ? datasourceConfigs : []).map((ds, index) => {
       const entityType = ds.entityType || ds.entityKey || ds.key?.split('-').pop() || `datasource${index + 1}`;
-      const datasourceKey = ds.key || `${systemKey}-${entityType}`;
+      const keySegment = toKeySegment(entityType);
+      const datasourceKey = ds.key || `${systemKey}-${keySegment}`;
       const datasourceKeyOnly = datasourceKey.includes('-') && datasourceKey.startsWith(`${systemKey}-`)
         ? datasourceKey.substring(systemKey.length + 1)
-        : entityType;
+        : keySegment;
       return {
         entityType,
         displayName: ds.displayName || ds.name || ds.key || `Datasource ${index + 1}`,

package/lib/schema/environment-deploy-request.schema.json

@@ -0,0 +1,64 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://raw.githubusercontent.com/esystemsdev/aifabrix-builder/refs/heads/main/lib/schema/environment-deploy-request.schema.json",
+  "title": "Environment Deploy Request",
+  "description": "Request body for POST /api/v1/environments/{envKey}/deploy",
+  "type": "object",
+  "required": ["environmentConfig"],
+  "properties": {
+    "environmentConfig": {
+      "type": "object",
+      "description": "Environment infrastructure configuration",
+      "required": ["key", "environment", "preset", "serviceName", "location"],
+      "properties": {
+        "key": {
+          "type": "string",
+          "description": "Environment key",
+          "pattern": "^[a-z0-9-]+$",
+          "minLength": 2,
+          "maxLength": 40
+        },
+        "environment": {
+          "type": "string",
+          "description": "Environment type",
+          "enum": ["miso", "dev", "tst", "pro"]
+        },
+        "preset": {
+          "type": "string",
+          "description": "Deployment preset size",
+          "enum": ["evaluation", "eval", "s", "m", "l", "xl"]
+        },
+        "serviceName": {
+          "type": "string",
+          "description": "Service name for resource naming",
+          "pattern": "^[a-z0-9-]{2,40}$"
+        },
+        "location": {
+          "type": "string",
+          "description": "Azure region (e.g. swedencentral)"
+        },
+        "resourceGroupName": { "type": "string" },
+        "subscriptionId": { "type": "string" },
+        "tenantId": { "type": "string" },
+        "customDomain": { "type": "object" },
+        "frontDoor": { "type": "object" },
+        "networking": { "type": "object" },
+        "allowedIPs": {
+          "type": "array",
+          "items": { "type": "string" }
+        },
+        "infrastructureAccess": {
+          "type": "array",
+          "items": { "type": "object" }
+        }
+      },
+      "additionalProperties": true
+    },
+    "dryRun": {
+      "type": "boolean",
+      "description": "If true, validate only without deploying",
+      "default": false
+    }
+  },
+  "additionalProperties": false
+}

package/lib/utils/paths.js

@@ -31,11 +31,15 @@ function safeHomedir() {
 }
 
 /**
- * Returns the path to the config file (AIFABRIX_HOME env or ~/.aifabrix).
- * Used so getAifabrixHome can read from the same location as config.js.
+ * Returns the path to the config directory (same precedence as config.js so both read the same config).
+ * Priority: AIFABRIX_CONFIG (dirname) → AIFABRIX_HOME → ~/.aifabrix.
  * @returns {string} Absolute path to config directory
  */
 function getConfigDirForPaths() {
+  const configFile = process.env.AIFABRIX_CONFIG && typeof process.env.AIFABRIX_CONFIG === 'string';
+  if (configFile) {
+    return path.dirname(path.resolve(process.env.AIFABRIX_CONFIG.trim()));
+  }
   if (process.env.AIFABRIX_HOME && typeof process.env.AIFABRIX_HOME === 'string') {
     return path.resolve(process.env.AIFABRIX_HOME.trim());
   }
@@ -281,7 +285,23 @@ function getAppPath(appName, appType) {
 }
 
 /**
- * Gets the integration folder path for external systems
+ * Base directory for integration/builder: project root when cwd is inside project, else cwd.
+ * So deploy works when run from integration/<app> (e.g. node deploy.js), and tests using temp dirs still work.
+ * @returns {string} Directory to resolve integration/ and builder/ from
+ */
+function getIntegrationBuilderBaseDir() {
+  const root = getProjectRoot();
+  const cwd = path.resolve(process.cwd());
+  const rootNorm = path.resolve(root);
+  if (cwd === rootNorm || cwd.startsWith(rootNorm + path.sep)) {
+    return rootNorm;
+  }
+  return cwd;
+}
+
+/**
+ * Gets the integration folder path for external systems.
+ * Uses project root when cwd is inside project so deploy works when run from integration/<app> (e.g. node deploy.js).
  * @param {string} appName - Application name
  * @returns {string} Absolute path to integration directory
  */
@@ -289,13 +309,14 @@ function getIntegrationPath(appName) {
   if (!appName || typeof appName !== 'string') {
     throw new Error('App name is required and must be a string');
   }
-  return path.join(process.cwd(), 'integration', appName);
+  const base = getIntegrationBuilderBaseDir();
+  return path.join(base, 'integration', appName);
 }
 
 /**
  * Gets the builder folder path for regular applications.
  * When AIFABRIX_BUILDER_DIR is set (e.g. by up-miso/up-dataplane from config aifabrix-env-config),
- * uses that as builder root instead of cwd/builder.
+ * uses that as builder root; otherwise uses project root so deploy works when run from integration/<app>.
  * @param {string} appName - Application name
  * @returns {string} Absolute path to builder directory
  */
@@ -309,7 +330,8 @@ function getBuilderPath(appName) {
   if (builderRoot) {
     return path.join(builderRoot, appName);
   }
-  return path.join(process.cwd(), 'builder', appName);
+  const base = getIntegrationBuilderBaseDir();
+  return path.join(base, 'builder', appName);
 }
 
 /**
@@ -462,7 +484,6 @@ async function detectAppType(appName, options = {}) {
   // Check builder folder (backward compatibility)
   return checkBuilderFolder(appName);
 }
-
 module.exports = {
   getAifabrixHome,
   getConfigDirForPaths,

package/lib/utils/secrets-generator.js

@@ -18,7 +18,17 @@ const logger = require('./logger');
 const pathsUtil = require('./paths');
 
 /**
- * Finds missing secret keys from template
+ * Skips commented or empty lines when scanning env.template
+ * @param {string} line - Single line
+ * @returns {boolean}
+ */
+function isCommentOrEmptyLine(line) {
+  const t = line.trim();
+  return t === '' || t.startsWith('#');
+}
+
+/**
+ * Finds missing secret keys from template (skips commented and empty lines)
  * @function findMissingSecretKeys
  * @param {string} envTemplate - Environment template content
  * @param {Object} existingSecrets - Existing secrets object
@@ -28,13 +38,18 @@ function findMissingSecretKeys(envTemplate, existingSecrets) {
   const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
   const missingKeys = [];
   const seenKeys = new Set();
-
-  let match;
-  while ((match = kvPattern.exec(envTemplate)) !== null) {
-    const secretKey = match[1];
-    if (!seenKeys.has(secretKey) && !(secretKey in existingSecrets)) {
-      missingKeys.push(secretKey);
-      seenKeys.add(secretKey);
+  const lines = envTemplate.split('\n');
+
+  for (const line of lines) {
+    if (isCommentOrEmptyLine(line)) continue;
+    let match;
+    kvPattern.lastIndex = 0;
+    while ((match = kvPattern.exec(line)) !== null) {
+      const secretKey = match[1];
+      if (!seenKeys.has(secretKey) && !(secretKey in existingSecrets)) {
+        missingKeys.push(secretKey);
+        seenKeys.add(secretKey);
+      }
     }
   }
 

package/lib/utils/secrets-helpers.js

@@ -33,7 +33,17 @@ function interpolateEnvVars(content, envVars) {
 }
 
 /**
- * Collect missing kv:// secrets referenced in content
+ * Returns true if the line is a comment or empty (should be skipped for kv:// resolution)
+ * @param {string} line - Single line
+ * @returns {boolean}
+ */
+function isCommentOrEmptyLine(line) {
+  const t = line.trim();
+  return t === '' || t.startsWith('#');
+}
+
+/**
+ * Collect missing kv:// secrets referenced in content (skips commented and empty lines)
  * @function collectMissingSecrets
  * @param {string} content - Text content
  * @param {Object} secrets - Available secrets
@@ -42,11 +52,16 @@ function interpolateEnvVars(content, envVars) {
 function collectMissingSecrets(content, secrets) {
   const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
   const missing = [];
-  let match;
-  while ((match = kvPattern.exec(content)) !== null) {
-    const secretKey = match[1];
-    if (!(secretKey in secrets)) {
-      missing.push(`kv://${secretKey}`);
+  const lines = content.split('\n');
+  for (const line of lines) {
+    if (isCommentOrEmptyLine(line)) continue;
+    let match;
+    kvPattern.lastIndex = 0;
+    while ((match = kvPattern.exec(line)) !== null) {
+      const secretKey = match[1];
+      if (!(secretKey in secrets)) {
+        missing.push(`kv://${secretKey}`);
+      }
     }
   }
   return missing;
@@ -76,7 +91,7 @@ function formatMissingSecretsFileInfo(secretsFilePaths) {
 }
 
 /**
- * Replace kv:// references with actual values, after also interpolating any ${VAR} within secret values
+ * Replace kv:// references with actual values (skips commented and empty lines)
  * @function replaceKvInContent
  * @param {string} content - Text content containing kv:// references
  * @param {Object} secrets - Secrets map
@@ -85,15 +100,20 @@ function formatMissingSecretsFileInfo(secretsFilePaths) {
  */
 function replaceKvInContent(content, secrets, envVars) {
   const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
-  return content.replace(kvPattern, (match, secretKey) => {
-    let value = secrets[secretKey];
-    if (typeof value === 'string') {
-      value = value.replace(/\$\{([A-Z_]+)\}/g, (m, envVar) => {
-        return envVars[envVar] || m;
-      });
-    }
-    return value;
+  const lines = content.split('\n');
+  const result = lines.map(line => {
+    if (isCommentOrEmptyLine(line)) return line;
+    return line.replace(kvPattern, (match, secretKey) => {
+      let value = secrets[secretKey];
+      if (typeof value === 'string') {
+        value = value.replace(/\$\{([A-Z_]+)\}/g, (m, envVar) => {
+          return envVars[envVar] || m;
+        });
+      }
+      return value;
+    });
   });
+  return result.join('\n');
 }
 
 /**
@@ -420,7 +440,7 @@ function ensureNonEmptySecrets(secrets) {
 }
 
 /**
- * Validate secrets against the env template, returning missing refs
+ * Validate secrets against the env template (skips commented and empty lines)
  * @function validateSecrets
  * @param {string} envTemplate - Environment template content
  * @param {Object} secrets - Available secrets
@@ -429,11 +449,16 @@ function ensureNonEmptySecrets(secrets) {
 function validateSecrets(envTemplate, secrets) {
   const kvPattern = /kv:\/\/([a-zA-Z0-9-_]+)/g;
   const missing = [];
-  let match;
-  while ((match = kvPattern.exec(envTemplate)) !== null) {
-    const secretKey = match[1];
-    if (!(secretKey in secrets)) {
-      missing.push(`kv://${secretKey}`);
+  const lines = envTemplate.split('\n');
+  for (const line of lines) {
+    if (isCommentOrEmptyLine(line)) continue;
+    let match;
+    kvPattern.lastIndex = 0;
+    while ((match = kvPattern.exec(line)) !== null) {
+      const secretKey = match[1];
+      if (!(secretKey in secrets)) {
+        missing.push(`kv://${secretKey}`);
+      }
     }
   }
   return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aifabrix/builder",
-  "version": "2.37.0",
+  "version": "2.37.9",
   "description": "AI Fabrix Local Fabric & Deployment SDK",
   "main": "lib/index.js",
   "bin": {

package/scripts/install-local.js

@@ -114,10 +114,19 @@ function installLocal() {
   console.log('Linking @aifabrix/builder globally...\n');
 
   try {
+    const projectRoot = path.join(__dirname, '..');
     if (pm === 'pnpm') {
-      execSync('pnpm link --global', { stdio: 'inherit' });
+      // Update pnpm global.
+      execSync('pnpm link --global', { stdio: 'inherit', cwd: projectRoot });
+      // Also run npm link so npm's global bin points here; often PATH has
+      // npm's global bin before pnpm's, so "aifabrix" would otherwise stay old.
+      try {
+        execSync('npm link', { stdio: 'inherit', cwd: projectRoot });
+      } catch {
+        // npm may not be available or may fail; pnpm link already ran
+      }
     } else {
-      execSync('npm link', { stdio: 'inherit' });
+      execSync('npm link', { stdio: 'inherit', cwd: projectRoot });
     }
 
     // Get new version after linking

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

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+/* eslint-disable no-console */
 /**
  * Deploy {{systemKey}} external system and datasources using aifabrix CLI.
  * Run: node deploy.js
@@ -13,6 +14,12 @@ const appKey = '{{systemKey}}';
 const env = process.env.ENVIRONMENT || 'dev';
 // Controller URL: from config (aifabrix auth config) or set CONTROLLER env before running
 
+/**
+ * Run a shell command with optional options.
+ * @param {string} cmd - Command to run
+ * @param {Object} [options={}] - Options (cwd, stdio, ignoreExit)
+ * @returns {boolean} True if command succeeded
+ */
 function run(cmd, options = {}) {
   const opts = { cwd: scriptDir, stdio: 'inherit', ...options };
   try {
@@ -24,6 +31,10 @@ function run(cmd, options = {}) {
   }
 }
 
+/**
+ * Check if aifabrix auth is logged in.
+ * @returns {boolean} True if logged in
+ */
 function isLoggedIn() {
   try {
     execSync('aifabrix auth status', { cwd: scriptDir, stdio: 'pipe' });

package/templates/infra/environment-dev.json

@@ -0,0 +1,10 @@
+{
+    "environmentConfig": {
+      "key": "dev",
+      "environment": "dev",
+      "preset": "s",
+      "serviceName": "aifabrix",
+      "location": "swedencentral"
+    },
+    "dryRun": false
+  }