@aifabrix/builder 2.54.1 → 2.55.2

package/lib/deployment/deployer-poll-run.js

@@ -18,52 +18,133 @@ const {
 const { resolvePollIntervalFromController } = require('./poll-interval');
 const { createDeployPollHandlers } = require('./deploy-poll-ui');
 
+/** Same progress for this many polls + dataplane published → treat deploy as complete. */
+const STUCK_PROGRESS_POLLS = 10;
+
+function recordStuckProgress(state, snapshot) {
+  const progress = Number(snapshot && snapshot.progress);
+  const value = Number.isFinite(progress) ? progress : null;
+  if (value === state.lastProgress) {
+    state.stuckCount += 1;
+  } else {
+    state.lastProgress = value;
+    state.stuckCount = 1;
+  }
+  return state;
+}
+
+async function completeIfDataplanePublished(lastSeen, options) {
+  if (!lastSeen || typeof options.isDataplanePublished !== 'function') {
+    return null;
+  }
+  try {
+    if (await options.isDataplanePublished()) {
+      return {
+        ...lastSeen,
+        status: 'completed',
+        progress: 100,
+        completedViaDataplane: true
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
 /**
- * Polls deployment status from controller.
- *
- * @async
- * @param {string} deploymentId
- * @param {string} controllerUrl
- * @param {string} envKey
- * @param {Object} authConfig
- * @param {Object} [options]
- * @returns {Promise<Object>}
+ * Poll until the controller job is terminal, or dataplane is already published.
+ * @param {Object} ctx
+ * @returns {Promise<Object|null>}
  */
+async function pollUntilTerminal(ctx) {
+  const {
+    controllerUrl,
+    validatedEnvKey,
+    deploymentId,
+    pipelineAuthConfig,
+    interval,
+    maxAttempts,
+    onPollWait,
+    wrappedProgress,
+    stuckState,
+    options,
+    getLastSeen
+  } = ctx;
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    if (onPollWait) {
+      onPollWait(attempt, maxAttempts);
+    }
+    const response = await getPipelineDeployment(
+      controllerUrl,
+      validatedEnvKey,
+      deploymentId,
+      pipelineAuthConfig
+    );
+    const deploymentData = await processDeploymentStatusResponse(
+      response,
+      attempt,
+      maxAttempts,
+      interval,
+      deploymentId,
+      wrappedProgress
+    );
+    if (deploymentData) {
+      return deploymentData;
+    }
+    if (stuckState.stuckCount >= STUCK_PROGRESS_POLLS) {
+      const viaDataplane = await completeIfDataplanePublished(getLastSeen(), options);
+      if (viaDataplane) {
+        return viaDataplane;
+      }
+    }
+  }
+  return null;
+}
+
 async function pollDeploymentStatus(deploymentId, controllerUrl, envKey, authConfig, options = {}) {
   const interval = options.interval || 5000;
   const maxAttempts = options.maxAttempts || 300;
-
   const validatedEnvKey = validateEnvironmentKey(envKey);
   const pipelineAuthConfig = convertToPipelineAuthConfig(authConfig);
-
   const onPollProgress = typeof options.onPollProgress === 'function' ? options.onPollProgress : null;
   const onPollWait = typeof options.onPollWait === 'function' ? options.onPollWait : null;
-
-  for (let attempt = 0; attempt < maxAttempts; attempt++) {
-    try {
-      if (onPollWait) {
-        onPollWait(attempt, maxAttempts);
-      }
-      const response = await getPipelineDeployment(controllerUrl, validatedEnvKey, deploymentId, pipelineAuthConfig);
-      const deploymentData = await processDeploymentStatusResponse(
-        response,
-        attempt,
-        maxAttempts,
-        interval,
-        deploymentId,
-        onPollProgress
-      );
-      if (deploymentData) {
-        return deploymentData;
-      }
-    } catch (error) {
-      if (error.message && error.message.includes('not found')) {
-        throw error;
-      }
+  const stuckState = { lastProgress: undefined, stuckCount: 0 };
+  let lastSeen = null;
+  const wrappedProgress = (data, attempt, max) => {
+    lastSeen = data;
+    recordStuckProgress(stuckState, data);
+    if (onPollProgress) {
+      onPollProgress(data, attempt, max);
+    }
+  };
+  try {
+    const terminal = await pollUntilTerminal({
+      controllerUrl,
+      validatedEnvKey,
+      deploymentId,
+      pipelineAuthConfig,
+      interval,
+      maxAttempts,
+      onPollWait,
+      wrappedProgress,
+      stuckState,
+      options,
+      getLastSeen: () => lastSeen
+    });
+    if (terminal) {
+      return terminal;
+    }
+  } catch (error) {
+    if (error.message && error.message.includes('not found')) {
       throw error;
     }
+    throw error;
+  }
+  const timedOutComplete = await completeIfDataplanePublished(lastSeen, options);
+  if (timedOutComplete) {
+    return timedOutComplete;
   }
-
   throw new Error('Deployment timeout: Maximum polling attempts reached');
 }
 
@@ -94,7 +175,8 @@ async function pollDeployment(result, url, validatedEnvKey, authConfig, options)
         interval: resolvedInterval,
         maxAttempts,
         onPollProgress: pollUi.onPollProgress,
-        onPollWait: pollUi.onPollWait
+        onPollWait: pollUi.onPollWait,
+        isDataplanePublished: options.isDataplanePublished
       }
     );
 

package/lib/external-system/deploy-dataplane-published.js

@@ -0,0 +1,70 @@
+/**
+ * Treat a stuck controller deploy poll as complete when dataplane is already published.
+ *
+ * @fileoverview Dataplane published check for external deploy poll
+ */
+
+'use strict';
+
+const { getExternalSystem } = require('../api/external-systems.api');
+const { unwrapApiData } = require('../utils/external-system-readiness-core');
+const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
+
+/**
+ * @param {Object|null|undefined} system
+ * @returns {boolean}
+ */
+function isDataplaneSystemPublished(system) {
+  const status = String((system && system.status) || '').toLowerCase();
+  return status === 'published' || status === 'deployed';
+}
+
+/**
+ * @param {string} controllerUrl
+ * @param {string} environment
+ * @param {Object} authConfig
+ * @param {string} systemKey
+ * @param {string} [dataplaneUrl]
+ * @returns {Promise<boolean>}
+ */
+async function checkDataplaneSystemPublished(
+  controllerUrl,
+  environment,
+  authConfig,
+  systemKey,
+  dataplaneUrl
+) {
+  let url = dataplaneUrl;
+  if (!url) {
+    url = await resolveDataplaneUrl(controllerUrl, environment, authConfig, { silent: true });
+  }
+  const getRes = await getExternalSystem(url, systemKey, authConfig);
+  return isDataplaneSystemPublished(unwrapApiData(getRes));
+}
+
+/**
+ * @param {Object} params
+ * @returns {() => Promise<boolean>}
+ */
+function createDataplanePublishedCheck(params) {
+  const { controllerUrl, environment, authConfig, systemKey, dataplaneUrl } = params;
+  return async function isDataplanePublished() {
+    try {
+      return await checkDataplaneSystemPublished(
+        controllerUrl,
+        environment,
+        authConfig,
+        systemKey,
+        dataplaneUrl
+      );
+    } catch {
+      return false;
+    }
+  };
+}
+
+module.exports = {
+  isDataplaneSystemPublished,
+  checkDataplaneSystemPublished,
+  createDataplanePublishedCheck
+};

package/lib/external-system/deploy.js

@@ -31,6 +31,7 @@ const { syncDeployJsonFromSources } = require('./sync-deploy-manifest');
 const { runDeployGateOrchestrator } = require('../commands/deploy-gate-orchestrator');
 const { runPostPublishDataSync } = require('../commands/run-post-publish-data-sync');
 const { uploadDigitalWorkerIfNeeded, deployRoleAssistantShellIfNeeded } = require('./deploy-helpers');
+const { createDataplanePublishedCheck } = require('./deploy-dataplane-published');
 
 /**
  * Validates manifest on dataplane (dry-run) before controller deploy.
@@ -194,9 +195,10 @@ const EXTERNAL_DEPLOY_POLL_INTERVAL_MS = 2000;
 /** 300 × 2s ≈ 10 minutes — must cover controller publish-job max wait with gates. */
 const EXTERNAL_DEPLOY_POLL_MAX_ATTEMPTS = 300;
 
-function buildExternalDeployPollOpts(options) {
+function buildExternalDeployPollOpts(options, extra = {}) {
   return {
     ...options,
+    ...extra,
     poll: true,
     pollInterval:
       options.pollInterval !== undefined ? options.pollInterval : EXTERNAL_DEPLOY_POLL_INTERVAL_MS,
@@ -300,7 +302,15 @@ async function executeDeployAndDisplay(manifest, controllerUrl, environment, aut
     controllerUrl,
     environment,
     authConfig,
-    buildExternalDeployPollOpts(options)
+    buildExternalDeployPollOpts(options, {
+      isDataplanePublished: createDataplanePublishedCheck({
+        controllerUrl,
+        environment,
+        authConfig,
+        systemKey: manifest.key,
+        dataplaneUrl: options.knownDataplaneUrl
+      })
+    })
   );
 
   const deploymentOutcome = parseControllerDeploymentOutcome(result);

package/lib/external-system/download-role-assistant.js

@@ -24,13 +24,23 @@ const {
   isPlatformShellKind
 } = require('../utils/platform-shell-package');
 
-const CONNECTED_SYSTEM_DRY_RUN_FILES = [
-  'deploy.json',
-  'application.yaml',
-  'system.yaml',
-  'env.template',
-  'README.md'
-];
+function connectedSystemDryRunFileNames(systemKey, dataSources, format) {
+  const { getExternalDatasourceFileName } = require('../generator/split-variables');
+  const ext = format === 'json' ? 'json' : 'yaml';
+  const names = [
+    `${systemKey}-deploy.json`,
+    `application.${ext}`,
+    `${systemKey}-system.${ext}`,
+    'env.template',
+    'README.md'
+  ];
+  const list = Array.isArray(dataSources) ? dataSources : [];
+  for (let i = 0; i < list.length; i += 1) {
+    const yamlName = getExternalDatasourceFileName(systemKey, list[i], i);
+    names.push(ext === 'json' ? yamlName.replace(/\.yaml$/i, '.json') : yamlName);
+  }
+  return names;
+}
 
 async function maybeExportRoleAssistantEvidenceArtifacts(systemKey, manifest, dataplaneUrl, authConfig, options) {
   try {
@@ -47,6 +57,23 @@ async function maybeExportRoleAssistantEvidenceArtifacts(systemKey, manifest, da
   }
 }
 
+async function maybeExportRoleAssistantTestsArtifacts(systemKey, dataplaneUrl, authConfig, options) {
+  try {
+    const { exportRoleAssistantTests } = require('../role-assistant/test-pack-sync');
+    const testsResult = await exportRoleAssistantTests({
+      systemKey,
+      dataplaneUrl,
+      authConfig,
+      options
+    });
+    if (testsResult && testsResult.skipped) {
+      logger.log(formatWarningLine(`Role assistant tests export skipped: ${testsResult.reason}`));
+    }
+  } catch (testsErr) {
+    logger.log(formatWarningLine(`Role assistant tests export skipped: ${testsErr.message}`));
+  }
+}
+
 async function maybeExportRoleAssistantKnowledgeArtifacts(systemKey, manifest, dataplaneUrl, authConfig, options) {
   try {
     const knowledgeResult = await exportRoleAssistantKnowledge({
@@ -67,19 +94,17 @@ async function runRoleAssistantDownloadSidecars(params) {
   const { systemKey, manifest, dataplaneUrl, authConfig, options = {} } = params;
   await maybeExportRoleAssistantEvidenceArtifacts(systemKey, manifest, dataplaneUrl, authConfig, options);
   await maybeExportRoleAssistantKnowledgeArtifacts(systemKey, manifest, dataplaneUrl, authConfig, options);
+  await maybeExportRoleAssistantTestsArtifacts(systemKey, dataplaneUrl, authConfig, options);
 }
 
-function logConnectedSystemDryRunFiles(systemKey) {
+function logConnectedSystemDryRunFiles(systemKey, dataSources, format) {
   logger.log(metadata('Would create:'));
-  CONNECTED_SYSTEM_DRY_RUN_FILES.forEach((name) => {
-    const fileName = name === 'deploy.json' || name === 'system.yaml'
-      ? `${systemKey}-${name}`
-      : name;
+  connectedSystemDryRunFileNames(systemKey, dataSources, format).forEach((fileName) => {
     logger.log(metadata(`  - integration/${systemKey}/${fileName}`));
   });
 }
 
-function handleDownloadDryRun(systemKey, dataplaneUrl, application) {
+function handleDownloadDryRun(systemKey, dataplaneUrl, application, dataSources, format) {
   logger.log(formatWarningLine('Dry run mode: no files written.'));
   logger.log(metadata(`Would fetch: ${dataplaneUrl}/api/v1/external/systems/${systemKey}/config`));
   if (isEnterpriseKnowledgeKind(application)) {
@@ -91,7 +116,7 @@ function handleDownloadDryRun(systemKey, dataplaneUrl, application) {
     logger.log(metadata(`  - role-assistant/${systemKey}/role-assistant.yaml`));
     return;
   }
-  logConnectedSystemDryRunFiles(systemKey);
+  logConnectedSystemDryRunFiles(systemKey, dataSources, format);
 }
 
 async function downloadDigitalWorkerPackage(params) {
@@ -130,5 +155,6 @@ async function downloadPlatformShellIfNeeded(params) {
 module.exports = {
   runRoleAssistantDownloadSidecars,
   downloadPlatformShellIfNeeded,
-  handleDownloadDryRun
+  handleDownloadDryRun,
+  connectedSystemDryRunFileNames
 };

package/lib/external-system/download.js

@@ -74,9 +74,8 @@ async function setupAuthenticationAndDataplane(systemKey, _options, _config) {
   }
 
   const { resolveDataplaneUrl } = require('../utils/dataplane-resolver');
-  logger.log(formatProgress('Resolving dataplane URL…'));
+  // discoverDataplaneUrl already logs progress and success
   const dataplaneUrl = await resolveDataplaneUrl(controllerUrl, environment, authConfig);
-  logger.log(formatSuccessLine(`Dataplane URL: ${dataplaneUrl}`));
 
   return { authConfig, dataplaneUrl };
 }
@@ -421,7 +420,13 @@ async function downloadExternalSystem(systemKey, options = {}) {
     );
     const manifest = await downloadFullManifest(dataplaneUrl, systemKey, authConfig, options);
     if (options.dryRun) {
-      handleDownloadDryRun(systemKey, dataplaneUrl, manifest.application);
+      handleDownloadDryRun(
+        systemKey,
+        dataplaneUrl,
+        manifest.application,
+        manifest.dataSources,
+        format
+      );
       return;
     }
     const platformHandled = await downloadPlatformShellIfNeeded({

package/lib/generator/helpers.js

@@ -234,6 +234,18 @@ function determineVariableLocation(value, key) {
     required = true;
   }
 
+  if (location === 'keyvault' && value.startsWith('kv://')) {
+    try {
+      const { getInfraParameterCatalog } = require('../parameters/infra-parameter-catalog');
+      const entry = getInfraParameterCatalog().findEntryForKey(value.slice('kv://'.length));
+      if (entry?.scope === 'infra' && entry.generator?.type === 'emptyAllowed') {
+        required = false;
+      }
+    } catch {
+      // Keep the conservative required=true default when the catalog is unavailable.
+    }
+  }
+
   return { location, required };
 }
 
@@ -344,4 +356,3 @@ module.exports = {
   validatePortalInput,
   parseEnvironmentVariables
 };
-

package/lib/generator/wizard-datasource-key.js

@@ -0,0 +1,54 @@
+/**
+ * Canonical kebab datasource keys for wizard generate-config.
+ *
+ * @fileoverview Wizard datasource key segments
+ */
+
+'use strict';
+
+/**
+ * @param {string} str
+ * @returns {string}
+ */
+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';
+}
+
+/**
+ * @param {string} finalSystemKey
+ * @param {{ key?: string, entityName?: string, entityType?: string, entityKey?: string }} ds
+ * @param {string} originalPrefix
+ * @param {Set<string>} [usedKeys]
+ * @returns {string}
+ */
+function wizardCanonicalDatasourceKey(finalSystemKey, ds, originalPrefix, usedKeys) {
+  const dsKey = String(ds.key || '').trim();
+  let segment;
+  if (dsKey && originalPrefix && dsKey.startsWith(originalPrefix)) {
+    segment = toKeySegment(dsKey.substring(originalPrefix.length));
+  } else {
+    const raw = ds.entityName || dsKey || ds.entityType || ds.entityKey || 'default';
+    segment = toKeySegment(raw);
+  }
+  let candidate = segment.includes('-') && !segment.startsWith(`${finalSystemKey}-`)
+    ? segment
+    : `${finalSystemKey}-${segment}`;
+  if (usedKeys && usedKeys.has(candidate)) {
+    let suffix = 2;
+    while (usedKeys.has(`${candidate}-${suffix}`)) {
+      suffix += 1;
+    }
+    candidate = `${candidate}-${suffix}`;
+  }
+  return candidate;
+}
+
+module.exports = {
+  toKeySegment,
+  wizardCanonicalDatasourceKey
+};

package/lib/generator/wizard.js

@@ -17,19 +17,7 @@ const { loadConfigFile, writeConfigFile } = require('../utils/config-format');
 const { systemKeyToKvPrefix, securityKeyToVar, isValidKvPath } = require('../utils/credential-secrets-env');
 const { generateExternalEnvTemplateContent } = require('../utils/external-env-template');
 const { generateReadme } = require('./wizard-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';
-}
+const { toKeySegment, wizardCanonicalDatasourceKey } = require('./wizard-datasource-key');
 
 const { normalizeAuthenticationToSystemKey } = require('../utils/authentication-shape');
 
@@ -118,10 +106,46 @@ async function writeDatasourceYamlFiles(appPath, finalSystemKey, datasourceConfi
  * @param {string} [params.aiGeneratedReadme] - Optional AI-generated README content
  * @returns {Promise<Object>} Object with file paths
  */
-async function generateConfigFilesForWizard(params) {
-  const { appPath, appName, finalSystemKey, systemFileName, datasourceFileNames, systemConfig, datasourceConfigs, aiGeneratedReadme, format } = params;
+async function writeWizardEnvTemplate(appPath, systemConfig) {
+  const envTemplatePath = path.join(appPath, 'env.template');
+  const envTemplateContent = generateExternalEnvTemplateContent(systemConfig);
+  await fs.writeFile(envTemplatePath, envTemplateContent, 'utf8');
+  logger.log(formatSuccessLine('Generated env.template'));
+  try {
+    const secretsEnsure = require('../core/secrets-ensure');
+    await secretsEnsure.ensureSecretsFromEnvTemplate(envTemplatePath, {
+      emptyValuesForCredentials: true
+    });
+  } catch (err) {
+    if (err.code !== 'ENOENT') {
+      logger.warn(`Could not ensure integration placeholder secrets: ${err.message}`);
+    }
+  }
+  return envTemplatePath;
+}
 
-  // Generate or update application config with externalIntegration block
+async function writeWizardDeployManifest(appPath, appName, finalSystemKey) {
+  const { generateControllerManifest, toDeployJsonShape } = require('./external-controller-manifest');
+  const manifest = await generateControllerManifest(appName, { appPath });
+  const deployJson = toDeployJsonShape(manifest);
+  const deployManifestPath = path.join(appPath, `${finalSystemKey}-deploy.json`);
+  await fs.writeFile(deployManifestPath, JSON.stringify(deployJson, null, 2), 'utf8');
+  logger.log(formatSuccessLine(`Generated deployment manifest: ${finalSystemKey}-deploy.json`));
+  return deployManifestPath;
+}
+
+async function generateConfigFilesForWizard(params) {
+  const {
+    appPath,
+    appName,
+    finalSystemKey,
+    systemFileName,
+    datasourceFileNames,
+    systemConfig,
+    datasourceConfigs,
+    aiGeneratedReadme,
+    format
+  } = params;
   const configPath = await generateOrUpdateVariablesYaml({
     appPath,
     appName,
@@ -131,21 +155,7 @@ async function generateConfigFilesForWizard(params) {
     systemConfig,
     format: format || 'yaml'
   });
-
-  // Generate env.template with Authentication and Configuration sections (Handlebars)
-  const envTemplatePath = path.join(appPath, 'env.template');
-  const envTemplateContent = generateExternalEnvTemplateContent(systemConfig);
-  await fs.writeFile(envTemplatePath, envTemplateContent, 'utf8');
-  logger.log(formatSuccessLine('Generated env.template'));
-
-  try {
-    const secretsEnsure = require('../core/secrets-ensure');
-    await secretsEnsure.ensureSecretsFromEnvTemplate(envTemplatePath, { emptyValuesForCredentials: true });
-  } catch (err) {
-    if (err.code !== 'ENOENT') logger.warn(`Could not ensure integration placeholder secrets: ${err.message}`);
-  }
-
-  // Generate README.md (use AI-generated content if available)
+  const envTemplatePath = await writeWizardEnvTemplate(appPath, systemConfig);
   await generateReadme({
     appPath,
     appName,
@@ -155,21 +165,16 @@ async function generateConfigFilesForWizard(params) {
     aiGeneratedContent: aiGeneratedReadme,
     format
   });
-
-  // Generate deployment scripts
-  const deployScripts = await generateDeployScripts(appPath, finalSystemKey, systemFileName, datasourceFileNames);
-
-  // Generate deployment manifest (<systemKey>-deploy.json) using controller format
-  const { generateControllerManifest, toDeployJsonShape } = require('./external-controller-manifest');
-  const manifest = await generateControllerManifest(appName, { appPath });
-  const deployJson = toDeployJsonShape(manifest);
-  const deployManifestPath = path.join(appPath, `${finalSystemKey}-deploy.json`);
-  await fs.writeFile(deployManifestPath, JSON.stringify(deployJson, null, 2), 'utf8');
-  logger.log(formatSuccessLine(`Generated deployment manifest: ${finalSystemKey}-deploy.json`));
-
+  const deployScripts = await generateDeployScripts(
+    appPath,
+    finalSystemKey,
+    systemFileName,
+    datasourceFileNames
+  );
+  const deployManifestPath = await writeWizardDeployManifest(appPath, appName, finalSystemKey);
   return {
     variablesPath: configPath,
-    envTemplatePath: path.join(appPath, 'env.template'),
+    envTemplatePath,
     readmePath: path.join(appPath, 'README.md'),
     applicationSchemaPath: deployManifestPath,
     ...deployScripts
@@ -190,16 +195,10 @@ async function prepareWizardContext(appName, systemConfig, datasourceConfigs) {
     appDisplayName
   );
   const originalPrefix = `${originalSystemKey}-`;
+  const usedKeys = new Set();
   const updatedDatasourceConfigs = datasourceConfigs.map(ds => {
-    let newKey;
-    const dsKey = ds.key || '';
-    if (dsKey && dsKey.startsWith(originalPrefix)) {
-      newKey = `${finalSystemKey}-${dsKey.substring(originalPrefix.length)}`;
-    } else {
-      const entityType = ds.entityType || ds.entityKey || dsKey.split('-').pop() || 'default';
-      const keySegment = toKeySegment(entityType);
-      newKey = `${finalSystemKey}-${keySegment}`;
-    }
+    const newKey = wizardCanonicalDatasourceKey(finalSystemKey, ds, originalPrefix, usedKeys);
+    usedKeys.add(newKey);
     const entityType = ds.entityType || ds.entityKey || newKey.split('-').pop() || 'default';
     const entityDisplayName = String(entityType).charAt(0).toUpperCase() + String(entityType).slice(1).replace(/-/g, ' ');
     return { ...ds, key: newKey, systemKey: finalSystemKey, displayName: ds.displayName || `${appDisplayName} ${entityDisplayName}` };
@@ -481,6 +480,8 @@ const { generateDeployScripts } = require('./deploy-script');
 
 module.exports = {
   generateWizardFiles,
-  generateDeployScripts
+  generateDeployScripts,
+  wizardCanonicalDatasourceKey,
+  toKeySegment
 };