@aifabrix/builder 2.32.3 → 2.33.0

package/lib/infrastructure/index.js

@@ -9,234 +9,32 @@
  * @version 2.0.0
  */
 
-const { exec } = require('child_process');
-const { promisify } = require('util');
 const path = require('path');
 const fs = require('fs');
-const handlebars = require('handlebars');
-const secrets = require('../core/secrets');
 const config = require('../core/config');
 const devConfig = require('../utils/dev-config');
 const logger = require('../utils/logger');
-const containerUtils = require('../utils/infra-containers');
 const dockerUtils = require('../utils/docker');
 const paths = require('../utils/paths');
 const statusHelpers = require('../utils/infra-status');
-
-// Register Handlebars helper for equality check
-// Handles both strict equality and numeric string comparisons
-// Treats null/undefined as equivalent to "0" (default infrastructure)
-handlebars.registerHelper('eq', (a, b) => {
-  // Handle null/undefined - treat as "0" for default infrastructure
-  if (a === null || a === undefined) a = '0';
-  if (b === null || b === undefined) b = '0';
-
-  // If both are numeric strings or one is number and other is numeric string, compare as numbers
-  const aNum = typeof a === 'string' && /^\d+$/.test(a) ? parseInt(a, 10) : a;
-  const bNum = typeof b === 'string' && /^\d+$/.test(b) ? parseInt(b, 10) : b;
-  // Use numeric comparison if both are numbers, otherwise strict equality
-  if (typeof aNum === 'number' && typeof bNum === 'number') {
-    return aNum === bNum;
-  }
-  return a === b;
-});
-const execAsync = promisify(exec);
-
-/**
- * Gets infrastructure directory name based on developer ID
- * Dev 0: infra (no dev-0 suffix), Dev > 0: infra-dev{id}
- * @param {number|string} devId - Developer ID
- * @returns {string} Infrastructure directory name
- */
-function getInfraDirName(devId) {
-  const idNum = typeof devId === 'string' ? parseInt(devId, 10) : devId;
-  return idNum === 0 ? 'infra' : `infra-dev${devId}`;
-}
-
-/**
- * Gets Docker Compose project name based on developer ID
- * Dev 0: infra (no dev-0 suffix), Dev > 0: infra-dev{id}
- * @param {number|string} devId - Developer ID
- * @returns {string} Docker Compose project name
- */
-function getInfraProjectName(devId) {
-  const idNum = typeof devId === 'string' ? parseInt(devId, 10) : devId;
-  return idNum === 0 ? 'infra' : `infra-dev${devId}`;
-}
-
-// Wrapper to support cwd option
-function execAsyncWithCwd(command, options = {}) {
-  return new Promise((resolve, reject) => {
-    const { cwd, ...execOptions } = options;
-    exec(command, { ...execOptions, cwd }, (error, stdout, stderr) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve({ stdout, stderr });
-      }
-    });
-  });
-}
-
-/**
- * Starts local infrastructure services
- * Launches Postgres, Redis, Keycloak, and Controller in Docker containers
- *
- * @async
- * @function startInfra
- * @returns {Promise<void>} Resolves when infrastructure is started
- * @throws {Error} If Docker is not running or compose fails
- *
- * @example
- * await startInfra();
- * // Infrastructure services are now running
- */
-async function checkDockerAvailability() {
-  try {
-    await dockerUtils.ensureDockerAndCompose();
-  } catch (error) {
-    throw new Error('Docker or Docker Compose is not available. Please install and start Docker.');
-  }
-}
-
-async function ensureAdminSecrets() {
-  const adminSecretsPath = path.join(paths.getAifabrixHome(), 'admin-secrets.env');
-  if (!fs.existsSync(adminSecretsPath)) {
-    logger.log('Generating admin-secrets.env...');
-    await secrets.generateAdminSecretsEnv();
-  }
-  return adminSecretsPath;
-}
-
-/**
- * Generates pgAdmin4 configuration files (servers.json and pgpass)
- * @param {string} infraDir - Infrastructure directory path
- * @param {string} postgresPassword - PostgreSQL password
- */
-function generatePgAdminConfig(infraDir, postgresPassword) {
-  const serversJsonTemplatePath = path.join(__dirname, '..', 'templates', 'infra', 'servers.json.hbs');
-  if (!fs.existsSync(serversJsonTemplatePath)) {
-    return;
-  }
-
-  const serversJsonTemplateContent = fs.readFileSync(serversJsonTemplatePath, 'utf8');
-  const serversJsonTemplate = handlebars.compile(serversJsonTemplateContent);
-  const serversJsonContent = serversJsonTemplate({ postgresPassword });
-  const serversJsonPath = path.join(infraDir, 'servers.json');
-  fs.writeFileSync(serversJsonPath, serversJsonContent, { mode: 0o644 });
-
-  const pgpassContent = `postgres:5432:postgres:pgadmin:${postgresPassword}\n`;
-  const pgpassPath = path.join(infraDir, 'pgpass');
-  fs.writeFileSync(pgpassPath, pgpassContent, { mode: 0o600 });
-}
-
-/**
- * Prepare infrastructure directory and extract postgres password
- * @param {string} devId - Developer ID
- * @param {string} adminSecretsPath - Path to admin secrets file
- * @returns {Object} Object with infraDir and postgresPassword
- */
-function prepareInfraDirectory(devId, adminSecretsPath) {
-  const aifabrixDir = paths.getAifabrixHome();
-  const infraDirName = getInfraDirName(devId);
-  const infraDir = path.join(aifabrixDir, infraDirName);
-  if (!fs.existsSync(infraDir)) {
-    fs.mkdirSync(infraDir, { recursive: true });
-  }
-
-  const adminSecretsContent = fs.readFileSync(adminSecretsPath, 'utf8');
-  const postgresPasswordMatch = adminSecretsContent.match(/^POSTGRES_PASSWORD=(.+)$/m);
-  const postgresPassword = postgresPasswordMatch ? postgresPasswordMatch[1] : '';
-  generatePgAdminConfig(infraDir, postgresPassword);
-
-  return { infraDir, postgresPassword };
-}
-
-/**
- * Register Handlebars helper for equality comparison
- */
-function registerHandlebarsHelper() {
-  handlebars.registerHelper('eq', (a, b) => {
-    if (a === null || a === undefined) a = '0';
-    if (b === null || b === undefined) b = '0';
-    const aNum = typeof a === 'string' && /^\d+$/.test(a) ? parseInt(a, 10) : a;
-    const bNum = typeof b === 'string' && /^\d+$/.test(b) ? parseInt(b, 10) : b;
-    if (typeof aNum === 'number' && typeof bNum === 'number') {
-      return aNum === bNum;
-    }
-    return a === b;
-  });
-}
-
-/**
- * Generate docker-compose file from template
- * @param {string} templatePath - Path to compose template
- * @param {string} devId - Developer ID
- * @param {number} idNum - Developer ID number
- * @param {Object} ports - Port configuration
- * @param {string} infraDir - Infrastructure directory
- * @returns {string} Path to generated compose file
- */
-function generateComposeFile(templatePath, devId, idNum, ports, infraDir) {
-  const templateContent = fs.readFileSync(templatePath, 'utf8');
-  const template = handlebars.compile(templateContent);
-  const networkName = idNum === 0 ? 'infra-aifabrix-network' : `infra-dev${devId}-aifabrix-network`;
-  const serversJsonPath = path.join(infraDir, 'servers.json');
-  const pgpassPath = path.join(infraDir, 'pgpass');
-  const composeContent = template({
-    devId: devId,
-    postgresPort: ports.postgres,
-    redisPort: ports.redis,
-    pgadminPort: ports.pgadmin,
-    redisCommanderPort: ports.redisCommander,
-    networkName: networkName,
-    serversJsonPath: serversJsonPath,
-    pgpassPath: pgpassPath,
-    infraDir: infraDir
-  });
-  const composePath = path.join(infraDir, 'compose.yaml');
-  fs.writeFileSync(composePath, composeContent);
-  return composePath;
-}
-
-/**
- * Start Docker services using docker-compose
- * @async
- * @param {string} composePath - Path to compose file
- * @param {string} projectName - Docker project name
- * @param {string} adminSecretsPath - Path to admin secrets file
- * @param {string} infraDir - Infrastructure directory
- */
-async function startDockerServices(composePath, projectName, adminSecretsPath, infraDir) {
-  logger.log(`Using compose file: ${composePath}`);
-  logger.log('Starting infrastructure services...');
-  const composeCmd = await dockerUtils.getComposeCommand();
-  await execAsyncWithCwd(`${composeCmd} -f "${composePath}" -p ${projectName} --env-file "${adminSecretsPath}" up -d`, { cwd: infraDir });
-  logger.log('Infrastructure services started successfully');
-}
-
-/**
- * Copy pgAdmin4 configuration files into container
- * @async
- * @param {string} pgadminContainerName - pgAdmin container name
- * @param {string} serversJsonPath - Path to servers.json file
- * @param {string} pgpassPath - Path to pgpass file
- */
-async function copyPgAdminConfig(pgadminContainerName, serversJsonPath, pgpassPath) {
-  try {
-    await new Promise(resolve => setTimeout(resolve, 2000)); // Wait for container to be ready
-    if (fs.existsSync(serversJsonPath)) {
-      await execAsync(`docker cp "${serversJsonPath}" ${pgadminContainerName}:/pgadmin4/servers.json`);
-    }
-    if (fs.existsSync(pgpassPath)) {
-      await execAsync(`docker cp "${pgpassPath}" ${pgadminContainerName}:/pgpass`);
-      await execAsync(`docker exec ${pgadminContainerName} chmod 600 /pgpass`);
-    }
-  } catch (error) {
-    // Ignore copy errors - files might already be there or container not ready
-    logger.log('Note: Could not copy pgAdmin4 config files (this is OK if container was just restarted)');
-  }
-}
+const {
+  getInfraDirName,
+  getInfraProjectName,
+  checkDockerAvailability,
+  ensureAdminSecrets,
+  prepareInfraDirectory,
+  registerHandlebarsHelper
+} = require('./helpers');
+const {
+  buildTraefikConfig,
+  validateTraefikConfig,
+  generateComposeFile
+} = require('./compose');
+const {
+  execAsyncWithCwd,
+  startDockerServicesAndConfigure,
+  checkInfraHealth
+} = require('./services');
 
 /**
  * Prepares infrastructure environment
@@ -254,7 +52,7 @@ async function prepareInfrastructureEnvironment(developerId) {
   const ports = devConfig.getDevPorts(devIdNum);
   const idNum = devIdNum;
 
-  const templatePath = path.join(__dirname, '..', 'templates', 'infra', 'compose.yaml.hbs');
+  const templatePath = path.join(__dirname, '..', '..', 'templates', 'infra', 'compose.yaml.hbs');
   if (!fs.existsSync(templatePath)) {
     throw new Error(`Compose template not found: ${templatePath}`);
   }
@@ -266,39 +64,35 @@ async function prepareInfrastructureEnvironment(developerId) {
 }
 
 /**
- * Starts Docker services and configures pgAdmin
+ * Starts local infrastructure services
+ * Launches Postgres, Redis, pgAdmin, and Redis Commander in Docker containers
+ *
  * @async
- * @function startDockerServicesAndConfigure
- * @param {string} composePath - Compose file path
- * @param {string} devId - Developer ID
- * @param {number} idNum - Developer ID number
- * @param {string} adminSecretsPath - Admin secrets path
- * @param {string} infraDir - Infrastructure directory
+ * @function startInfra
+ * @param {number|string|null} developerId - Developer ID (null = use current)
+ * @param {Object} [options] - Infrastructure options
+ * @param {boolean} [options.traefik=false] - Include Traefik service
+ * @returns {Promise<void>} Resolves when infrastructure is started
+ * @throws {Error} If Docker is not running or compose fails
+ *
+ * @example
+ * await startInfra(null, { traefik: true });
+ * // Infrastructure services are now running
  */
-async function startDockerServicesAndConfigure(composePath, devId, idNum, adminSecretsPath, infraDir) {
-  // Start Docker services
-  const projectName = getInfraProjectName(devId);
-  await startDockerServices(composePath, projectName, adminSecretsPath, infraDir);
-
-  // Copy pgAdmin4 config files
-  const pgadminContainerName = idNum === 0 ? 'aifabrix-pgadmin' : `aifabrix-dev${devId}-pgadmin`;
-  const serversJsonPath = path.join(infraDir, 'servers.json');
-  const pgpassPath = path.join(infraDir, 'pgpass');
-  await copyPgAdminConfig(pgadminContainerName, serversJsonPath, pgpassPath);
-
-  // Wait for services to be healthy
-  await waitForServices(devId);
-  logger.log('All services are healthy and ready');
-}
-
-async function startInfra(developerId = null) {
+async function startInfra(developerId = null, options = {}) {
   const { devId, idNum, ports, templatePath, infraDir, adminSecretsPath } = await prepareInfrastructureEnvironment(developerId);
+  const { traefik = false } = options;
+  const traefikConfig = buildTraefikConfig(traefik);
+  const validation = validateTraefikConfig(traefikConfig);
+  if (!validation.valid) {
+    throw new Error(validation.errors.join('\n'));
+  }
 
   // Register Handlebars helper
   registerHandlebarsHelper();
 
   // Generate compose file
-  const composePath = generateComposeFile(templatePath, devId, idNum, ports, infraDir);
+  const composePath = generateComposeFile(templatePath, devId, idNum, ports, infraDir, { traefik: traefikConfig });
 
   try {
     await startDockerServicesAndConfigure(composePath, devId, idNum, adminSecretsPath, infraDir);
@@ -381,42 +175,6 @@ async function stopInfraWithVolumes() {
   }
 }
 
-/**
- * Checks if infrastructure services are running
- * Validates that all required services are healthy and accessible
- *
- * @async
- * @function checkInfraHealth
- * @returns {Promise<Object>} Health status of each service
- * @throws {Error} If health check fails
- *
- * @example
- * const health = await checkInfraHealth();
- * // Returns: { postgres: 'healthy', redis: 'healthy', keycloak: 'healthy', controller: 'healthy' }
- */
-async function checkInfraHealth(devId = null) {
-  const developerId = devId || await config.getDeveloperId();
-  const servicesWithHealthCheck = ['postgres', 'redis'];
-  const servicesWithoutHealthCheck = ['pgadmin', 'redis-commander'];
-  const health = {};
-
-  // Check health status for services with health checks
-  for (const service of servicesWithHealthCheck) {
-    health[service] = await containerUtils.checkServiceWithHealthCheck(service, developerId);
-  }
-
-  // Check if services without health checks are running
-  for (const service of servicesWithoutHealthCheck) {
-    health[service] = await containerUtils.checkServiceWithoutHealthCheck(service, developerId);
-  }
-
-  return health;
-}
-
-// Re-export status helper functions
-const getInfraStatus = statusHelpers.getInfraStatus;
-const getAppStatus = statusHelpers.getAppStatus;
-
 /**
  * Restarts a specific infrastructure service
  * Useful for applying configuration changes
@@ -436,7 +194,7 @@ async function restartService(serviceName) {
     throw new Error('Service name is required and must be a string');
   }
 
-  const validServices = ['postgres', 'redis', 'pgadmin', 'redis-commander'];
+  const validServices = ['postgres', 'redis', 'pgadmin', 'redis-commander', 'traefik'];
   if (!validServices.includes(serviceName)) {
     throw new Error(`Invalid service name. Must be one of: ${validServices.join(', ')}`);
   }
@@ -463,34 +221,17 @@ async function restartService(serviceName) {
   }
 }
 
-/**
- * Waits for services to be healthy
- * @private
- * @param {number} [devId] - Developer ID (optional, will be loaded from config if not provided)
- */
-async function waitForServices(devId = null) {
-  const maxAttempts = 30;
-  const delay = 2000; // 2 seconds
-
-  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-    const health = await checkInfraHealth(devId);
-    const allHealthy = Object.values(health).every(status => status === 'healthy');
-
-    if (allHealthy) {
-      return;
-    }
-
-    // Debug logging
-
-    if (attempt < maxAttempts) {
-      logger.log(`Waiting for services to be healthy... (${attempt}/${maxAttempts})`);
-      await new Promise(resolve => setTimeout(resolve, delay));
-    }
-  }
+// Re-export status helper functions
+const getInfraStatus = statusHelpers.getInfraStatus;
+const getAppStatus = statusHelpers.getAppStatus;
 
-  throw new Error('Services failed to become healthy within timeout period');
-}
 module.exports = {
-  startInfra, stopInfra, stopInfraWithVolumes, checkInfraHealth,
-  getInfraStatus, getAppStatus, restartService, ensureAdminSecrets
+  startInfra,
+  stopInfra,
+  stopInfraWithVolumes,
+  checkInfraHealth,
+  getInfraStatus,
+  getAppStatus,
+  restartService,
+  ensureAdminSecrets
 };

package/lib/infrastructure/services.js

@@ -0,0 +1,168 @@
+/**
+ * AI Fabrix Builder Infrastructure Docker Services
+ *
+ * Handles Docker service operations including starting, stopping, and configuring services.
+ *
+ * @fileoverview Docker service management for infrastructure
+ * @author AI Fabrix Team
+ * @version 2.0.0
+ */
+
+const { exec } = require('child_process');
+const { promisify } = require('util');
+const path = require('path');
+const fs = require('fs');
+const logger = require('../utils/logger');
+const containerUtils = require('../utils/infra-containers');
+const dockerUtils = require('../utils/docker');
+const config = require('../core/config');
+const { getInfraProjectName } = require('./helpers');
+
+const execAsync = promisify(exec);
+
+// Wrapper to support cwd option
+function execAsyncWithCwd(command, options = {}) {
+  return new Promise((resolve, reject) => {
+    const { cwd, ...execOptions } = options;
+    exec(command, { ...execOptions, cwd }, (error, stdout, stderr) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve({ stdout, stderr });
+      }
+    });
+  });
+}
+
+/**
+ * Start Docker services using docker-compose
+ * @async
+ * @param {string} composePath - Path to compose file
+ * @param {string} projectName - Docker project name
+ * @param {string} adminSecretsPath - Path to admin secrets file
+ * @param {string} infraDir - Infrastructure directory
+ */
+async function startDockerServices(composePath, projectName, adminSecretsPath, infraDir) {
+  logger.log(`Using compose file: ${composePath}`);
+  logger.log('Starting infrastructure services...');
+  const composeCmd = await dockerUtils.getComposeCommand();
+  await execAsyncWithCwd(`${composeCmd} -f "${composePath}" -p ${projectName} --env-file "${adminSecretsPath}" up -d`, { cwd: infraDir });
+  logger.log('Infrastructure services started successfully');
+}
+
+/**
+ * Copy pgAdmin4 configuration files into container
+ * @async
+ * @param {string} pgadminContainerName - pgAdmin container name
+ * @param {string} serversJsonPath - Path to servers.json file
+ * @param {string} pgpassPath - Path to pgpass file
+ */
+async function copyPgAdminConfig(pgadminContainerName, serversJsonPath, pgpassPath) {
+  try {
+    await new Promise(resolve => setTimeout(resolve, 2000)); // Wait for container to be ready
+    if (fs.existsSync(serversJsonPath)) {
+      await execAsync(`docker cp "${serversJsonPath}" ${pgadminContainerName}:/pgadmin4/servers.json`);
+    }
+    if (fs.existsSync(pgpassPath)) {
+      await execAsync(`docker cp "${pgpassPath}" ${pgadminContainerName}:/pgpass`);
+      await execAsync(`docker exec ${pgadminContainerName} chmod 600 /pgpass`);
+    }
+  } catch (error) {
+    // Ignore copy errors - files might already be there or container not ready
+    logger.log('Note: Could not copy pgAdmin4 config files (this is OK if container was just restarted)');
+  }
+}
+
+/**
+ * Starts Docker services and configures pgAdmin
+ * @async
+ * @function startDockerServicesAndConfigure
+ * @param {string} composePath - Compose file path
+ * @param {string} devId - Developer ID
+ * @param {number} idNum - Developer ID number
+ * @param {string} adminSecretsPath - Admin secrets path
+ * @param {string} infraDir - Infrastructure directory
+ */
+async function startDockerServicesAndConfigure(composePath, devId, idNum, adminSecretsPath, infraDir) {
+  // Start Docker services
+  const projectName = getInfraProjectName(devId);
+  await startDockerServices(composePath, projectName, adminSecretsPath, infraDir);
+
+  // Copy pgAdmin4 config files
+  const pgadminContainerName = idNum === 0 ? 'aifabrix-pgadmin' : `aifabrix-dev${devId}-pgadmin`;
+  const serversJsonPath = path.join(infraDir, 'servers.json');
+  const pgpassPath = path.join(infraDir, 'pgpass');
+  await copyPgAdminConfig(pgadminContainerName, serversJsonPath, pgpassPath);
+
+  // Wait for services to be healthy
+  await waitForServices(devId);
+  logger.log('All services are healthy and ready');
+}
+
+/**
+ * Waits for services to be healthy
+ * @private
+ * @param {number} [devId] - Developer ID (optional, will be loaded from config if not provided)
+ */
+async function waitForServices(devId = null) {
+  const maxAttempts = 30;
+  const delay = 2000; // 2 seconds
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    const health = await checkInfraHealth(devId);
+    const allHealthy = Object.values(health).every(status => status === 'healthy');
+
+    if (allHealthy) {
+      return;
+    }
+
+    if (attempt < maxAttempts) {
+      logger.log(`Waiting for services to be healthy... (${attempt}/${maxAttempts})`);
+      await new Promise(resolve => setTimeout(resolve, delay));
+    }
+  }
+
+  throw new Error('Services failed to become healthy within timeout period');
+}
+
+/**
+ * Checks if infrastructure services are running
+ * Validates that all required services are healthy and accessible
+ *
+ * @async
+ * @function checkInfraHealth
+ * @param {number|string|null} [devId] - Developer ID (null = use current)
+ * @returns {Promise<Object>} Health status of each service
+ * @throws {Error} If health check fails
+ *
+ * @example
+ * const health = await checkInfraHealth();
+ * // Returns: { postgres: 'healthy', redis: 'healthy', pgadmin: 'healthy', redis-commander: 'healthy' }
+ */
+async function checkInfraHealth(devId = null) {
+  const developerId = devId || await config.getDeveloperId();
+  const servicesWithHealthCheck = ['postgres', 'redis'];
+  const servicesWithoutHealthCheck = ['pgadmin', 'redis-commander'];
+  const health = {};
+
+  // Check health status for services with health checks
+  for (const service of servicesWithHealthCheck) {
+    health[service] = await containerUtils.checkServiceWithHealthCheck(service, developerId);
+  }
+
+  // Check if services without health checks are running
+  for (const service of servicesWithoutHealthCheck) {
+    health[service] = await containerUtils.checkServiceWithoutHealthCheck(service, developerId);
+  }
+
+  return health;
+}
+
+module.exports = {
+  execAsyncWithCwd,
+  startDockerServices,
+  copyPgAdminConfig,
+  startDockerServicesAndConfigure,
+  waitForServices,
+  checkInfraHealth
+};

package/lib/schema/application-schema.json

@@ -457,20 +457,20 @@
     },
     "frontDoorRouting": {
       "type": "object",
-      "description": "Front Door routing configuration",
+      "description": "Front Door routing configuration for Azure deployments and Traefik ingress for local development",
       "properties": {
         "pattern": {
           "type": "string",
-          "description": "URL pattern for routing (e.g., '/app/*')",
+          "description": "URL pattern for routing (e.g., '/app/*', '/api/v1/*'). Used for both Front Door and Traefik path routing",
           "pattern": "^/.+"
         },
         "requiresRuleSet": {
           "type": "boolean",
-          "description": "Whether URL rewriting rule set is required"
+          "description": "Whether URL rewriting rule set is required (Azure Front Door only)"
         },
         "ruleSetConditions": {
           "type": "array",
-          "description": "Rule set conditions for URL rewriting",
+          "description": "Rule set conditions for URL rewriting (Azure Front Door only)",
           "items": {
             "type": "object",
             "properties": {
@@ -490,6 +490,25 @@
               }
             }
           }
+        },
+        "enabled": {
+          "type": "boolean",
+          "description": "Enable Traefik ingress labels for local development (docker-compose)"
+        },
+        "host": {
+          "type": "string",
+          "description": "Hostname for Traefik routing. Supports ${DEV_USERNAME} variable interpolation (e.g., '${DEV_USERNAME}.aifabrix.dev'). Required if enabled is true.",
+          "pattern": "^[a-z0-9.$\\{\\}-]+$"
+        },
+        "tls": {
+          "type": "boolean",
+          "description": "Enable TLS/HTTPS for Traefik (local development)",
+          "default": true
+        },
+        "certStore": {
+          "type": "string",
+          "description": "Certificate store name for wildcard certificates. Optional - only needed when using a pre-configured certificate store in Traefik.",
+          "pattern": "^[a-z0-9-]+$"
         }
       },
       "additionalProperties": false

package/lib/schema/external-datasource.schema.json

@@ -176,8 +176,8 @@
                   "properties":{
                      "expression":{
                         "type":"string",
-                        "description":"Pipe-based DSL expression: '{{raw.path}} | toLower | trim'.",
-                        "pattern":"^\\s*\\{\\{[^}]+\\}\\}(\\s*\\|\\s*[a-zA-Z0-9_]+(\\([^)]*\\))?)*\\s*$"
+                        "description":"Pipe-based DSL expression: '{{raw.path}} | toLower | trim' or record reference: 'record_ref:customer'.",
+                        "pattern":"^\\s*((\\{\\{[^}]+\\}\\}(\\s*\\|\\s*[a-zA-Z0-9_]+(\\([^)]*\\))?)*)|(record_ref:[a-z0-9-]+))\\s*$"
                      },
                      "type":{
                         "type":"string",