@copado/agentia-cli 0.122.0-alpha.1 → 1.0.0-beta.0

package/dist/lib/dependency-from-changes.js

@@ -1,121 +1,7 @@
-import { execFile } from 'node:child_process';
-import { promisify } from 'node:util';
-import { resolveSalesforcePath } from './sdr-path-resolver.js';
-const execFileAsync = promisify(execFile);
-let gitCommittedNameStatusFn = defaultGitCommittedNameStatus;
-let gitStagedNameStatusFn = defaultGitStagedNameStatus;
-function parseChangedFilePaths(line) {
-    const trimmed = line.trim();
-    if (!trimmed) {
-        return [];
-    }
-    const statusMatch = trimmed.match(/^[A-Z]\d*(?:\t(.+))?$/);
-    if (!statusMatch) {
-        return [trimmed];
-    }
-    const pathPart = statusMatch[1];
-    if (!pathPart) {
-        return [];
-    }
-    return pathPart
-        .split('\t')
-        .map((entry) => entry.trim())
-        .filter(Boolean);
-}
-async function defaultGitCommittedNameStatus(baseRef) {
-    const { stdout } = await execFileAsync('git', ['diff', '--name-status', `${baseRef}...HEAD`]);
-    return stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-}
-async function defaultGitStagedNameStatus() {
-    const { stdout } = await execFileAsync('git', ['diff', '--cached', '--name-status']);
-    return stdout
-        .split(/\r?\n/)
-        .map((line) => line.trim())
-        .filter(Boolean);
-}
-async function collectChangedFilePaths(baseRef) {
-    const committedLines = await gitCommittedNameStatusFn(baseRef);
-    const stagedLines = await gitStagedNameStatusFn();
-    const paths = new Set();
-    for (const line of [...committedLines, ...stagedLines]) {
-        for (const path of parseChangedFilePaths(line)) {
-            paths.add(path);
-        }
-    }
-    return [...paths];
-}
-function resolveVlocitySelection(path) {
-    const parts = path.split('/').filter(Boolean);
-    const vlocityIndex = parts.findIndex((part) => part.toLowerCase() === 'vlocity');
-    if (vlocityIndex === -1 || parts.length <= vlocityIndex + 2) {
-        return undefined;
-    }
-    return {
-        name: parts[vlocityIndex + 2],
-        type: parts[vlocityIndex + 1],
-    };
-}
-function resolveSalesforceSelection(path) {
-    const resolved = resolveSalesforcePath(path);
-    if (!resolved) {
-        return undefined;
-    }
-    return { name: resolved.name, type: resolved.type };
-}
-export function resolveChangedPath(path, moduleType) {
-    if (moduleType === 'vlocity') {
-        return resolveVlocitySelection(path) ?? resolveSalesforceSelection(path);
-    }
-    return resolveSalesforceSelection(path);
-}
-export async function resolvedSelectionsFromChangedFiles(baseRef, moduleType) {
-    const files = await collectChangedFilePaths(baseRef);
-    if (files.length === 0) {
-        throw new Error(`No changed files were found in committed branch changes against ${baseRef} or in the staged index.`);
-    }
-    const byKey = new Map();
-    for (const file of files) {
-        const selection = resolveChangedPath(file, moduleType);
-        if (selection) {
-            const key = `${selection.type}:${selection.name}`;
-            const existing = byKey.get(key);
-            if (existing) {
-                existing.localPaths.push(file);
-            }
-            else {
-                byKey.set(key, {
-                    localPaths: [file],
-                    selection,
-                });
-            }
-        }
-    }
-    if (byKey.size === 0) {
-        throw new Error('No resolvable metadata selections were found from changed files.');
-    }
-    return [...byKey.values()];
-}
-export async function selectionsFromChangedFiles(baseRef, moduleType) {
-    const resolvedSelections = await resolvedSelectionsFromChangedFiles(baseRef, moduleType);
-    return resolvedSelections.map(({ selection }) => selection);
-}
-// Test-only hook
-export function setGitChangedFilesForTests(committedLines, stagedLines) {
-    gitCommittedNameStatusFn =
-        typeof committedLines === 'function'
-            ? committedLines
-            : async () => committedLines;
-    gitStagedNameStatusFn =
-        typeof stagedLines === 'function'
-            ? stagedLines
-            : async () => stagedLines ?? [];
-}
-// Test-only hook
-export function resetGitChangedFilesForTests() {
-    gitCommittedNameStatusFn = defaultGitCommittedNameStatus;
-    gitStagedNameStatusFn = defaultGitStagedNameStatus;
-}
-//# sourceMappingURL=dependency-from-changes.js.map
+import {modules} from './runtime.js';
+const resetGitChangedFilesForTests = modules["dependency-from-changes.js"]["resetGitChangedFilesForTests"]
+const resolveChangedPath = modules["dependency-from-changes.js"]["resolveChangedPath"]
+const resolvedSelectionsFromChangedFiles = modules["dependency-from-changes.js"]["resolvedSelectionsFromChangedFiles"]
+const selectionsFromChangedFiles = modules["dependency-from-changes.js"]["selectionsFromChangedFiles"]
+const setGitChangedFilesForTests = modules["dependency-from-changes.js"]["setGitChangedFilesForTests"]
+export {resetGitChangedFilesForTests, resolveChangedPath, resolvedSelectionsFromChangedFiles, selectionsFromChangedFiles, setGitChangedFilesForTests};

package/dist/lib/deployment-step-config.js

@@ -1,110 +1,7 @@
-import { readFileSync } from 'node:fs';
-export const DEPLOYMENT_STEP_ENVIRONMENTS = ['source', 'destination', 'both'];
-export const CRT_RUN_ON_VALUES = ['source', 'destination'];
-const FRIENDLY_FLAG_NAMES = [
-    'apex-script',
-    'apex-script-file',
-    'assignee-id',
-    'assignee-name',
-    'crt-run-on',
-    'crt-test-id',
-    'data-set-id',
-    'data-template-id',
-    'environment',
-    'flow-name',
-    'function-name',
-    'instructions',
-    'parameter',
-];
-function required(value, flag) {
-    const trimmed = value?.trim();
-    if (trimmed === undefined || trimmed.length === 0) {
-        throw new Error(`${flag} is required for this deployment step type.`);
-    }
-    return trimmed;
-}
-function selectedFriendlyFlags(flags) {
-    return FRIENDLY_FLAG_NAMES.filter((name) => flags[name] !== undefined).map((name) => `--${name}`);
-}
-function assertOnlyFlags(flags, allowed, type) {
-    const unsupported = FRIENDLY_FLAG_NAMES.filter((name) => flags[name] !== undefined && !allowed.includes(name));
-    if (unsupported.length > 0) {
-        throw new Error(`${unsupported.map((name) => `--${name}`).join(', ')} cannot be used with ${type}.`);
-    }
-}
-export function parseDeploymentStepParameters(values = []) {
-    return values.map((value) => {
-        const separator = value.indexOf('=');
-        if (separator <= 0) {
-            throw new Error(`Invalid --parameter "${value}". Use name=value.`);
-        }
-        const name = value.slice(0, separator).trim();
-        const parameterValue = value.slice(separator + 1);
-        if (name.length === 0) {
-            throw new Error(`Invalid --parameter "${value}". Parameter name cannot be empty.`);
-        }
-        return { name, value: parameterValue };
-    });
-}
-export function hasFriendlyDeploymentStepConfig(flags) {
-    return selectedFriendlyFlags(flags).length > 0;
-}
-export function buildFriendlyDeploymentStepConfig(type, flags) {
-    switch (type) {
-        case 'Apex': {
-            assertOnlyFlags(flags, ['apex-script', 'apex-script-file'], type);
-            if (flags['apex-script'] !== undefined && flags['apex-script-file'] !== undefined) {
-                throw new Error('Use only one of --apex-script or --apex-script-file.');
-            }
-            const script = flags['apex-script-file'] === undefined
-                ? required(flags['apex-script'], '--apex-script or --apex-script-file')
-                : readFileSync(flags['apex-script-file'], 'utf8');
-            if (script.trim().length === 0)
-                throw new Error('Apex script cannot be empty.');
-            return { script };
-        }
-        case 'Data Set - Salesforce': {
-            assertOnlyFlags(flags, ['data-set-id'], type);
-            return { dataSetId: required(flags['data-set-id'], '--data-set-id') };
-        }
-        case 'Data Template - Salesforce': {
-            assertOnlyFlags(flags, ['data-template-id'], type);
-            return { dataTemplateId: required(flags['data-template-id'], '--data-template-id') };
-        }
-        case 'Function': {
-            assertOnlyFlags(flags, ['function-name', 'parameter'], type);
-            return {
-                functionName: required(flags['function-name'], '--function-name'),
-                parameters: parseDeploymentStepParameters(flags.parameter),
-            };
-        }
-        case 'Manual Task': {
-            assertOnlyFlags(flags, ['assignee-id', 'assignee-name', 'environment', 'instructions'], type);
-            const assigneeId = flags['assignee-id']?.trim();
-            const assigneeName = flags['assignee-name']?.trim();
-            if ((assigneeId === undefined) !== (assigneeName === undefined)) {
-                throw new Error('Provide both --assignee-id and --assignee-name, or neither.');
-            }
-            return {
-                ...(assigneeId === undefined ? {} : { assigneeId, assigneeName }),
-                environment: flags.environment ?? 'destination',
-                instructions: required(flags.instructions, '--instructions'),
-            };
-        }
-        case 'Robotic Test': {
-            assertOnlyFlags(flags, ['crt-run-on', 'crt-test-id'], type);
-            return {
-                runOn: flags['crt-run-on'] ?? 'destination',
-                testId: required(flags['crt-test-id'], '--crt-test-id'),
-            };
-        }
-        case 'Salesforce Flow': {
-            assertOnlyFlags(flags, ['flow-name', 'parameter'], type);
-            return {
-                flowName: required(flags['flow-name'], '--flow-name'),
-                parameters: parseDeploymentStepParameters(flags.parameter),
-            };
-        }
-    }
-}
-//# sourceMappingURL=deployment-step-config.js.map
+import {modules} from './runtime.js';
+const CRT_RUN_ON_VALUES = modules["deployment-step-config.js"]["CRT_RUN_ON_VALUES"]
+const DEPLOYMENT_STEP_ENVIRONMENTS = modules["deployment-step-config.js"]["DEPLOYMENT_STEP_ENVIRONMENTS"]
+const buildFriendlyDeploymentStepConfig = modules["deployment-step-config.js"]["buildFriendlyDeploymentStepConfig"]
+const hasFriendlyDeploymentStepConfig = modules["deployment-step-config.js"]["hasFriendlyDeploymentStepConfig"]
+const parseDeploymentStepParameters = modules["deployment-step-config.js"]["parseDeploymentStepParameters"]
+export {CRT_RUN_ON_VALUES, DEPLOYMENT_STEP_ENVIRONMENTS, buildFriendlyDeploymentStepConfig, hasFriendlyDeploymentStepConfig, parseDeploymentStepParameters};

package/dist/lib/deployment-step-types.js

@@ -1,223 +1,26 @@
-import { readFileSync } from 'node:fs';
-import { cellValue, table } from './format.js';
-import { preferSalesforceId } from './salesforce-id.js';
-export const DEPLOYMENT_STEP_TYPES_ENDPOINT = '/plan/deployment-step-types';
-export const DEPLOYMENT_STEP_SALESFORCE_FLOWS_ENDPOINT = '/plan/deployment-step-salesforce-flows';
-export const DEPLOYMENT_STEP_STANDARD_TYPES = [
-    'Manual Task',
-    'Salesforce Flow',
-    'Function',
-    'Apex',
-    'Data Set - Salesforce',
-    'Data Template - Salesforce',
-    'Robotic Test',
-];
-export const SALESFORCE_DATA_DEPLOYMENT_STEP_TYPES = [
-    'Data Set - Salesforce',
-    'Data Template - Salesforce',
-];
-function isObject(value) {
-    return value !== null && typeof value === 'object' && !Array.isArray(value);
-}
-function normalizeArray(response, keys) {
-    if (Array.isArray(response))
-        return response;
-    if (!isObject(response))
-        return [];
-    for (const key of keys) {
-        if (Array.isArray(response[key]))
-            return response[key];
-    }
-    return [];
-}
-function validateOptionalNonEmpty(value, flag) {
-    if (value !== undefined && value.trim().length === 0) {
-        throw new Error(`${flag} cannot be empty.`);
-    }
-}
-export function deploymentStepTypesEndpoint() {
-    return DEPLOYMENT_STEP_TYPES_ENDPOINT;
-}
-export function deploymentStepSalesforceFlowsEndpoint() {
-    return DEPLOYMENT_STEP_SALESFORCE_FLOWS_ENDPOINT;
-}
-export function userStoryDeploymentStepsEndpoint(userStoryId) {
-    return `/plan/user-stories/${encodeURIComponent(preferSalesforceId(userStoryId))}/deployment-steps`;
-}
-export function userStoryDeploymentStepEndpoint(userStoryId, stepId) {
-    return `${userStoryDeploymentStepsEndpoint(userStoryId)}/${encodeURIComponent(stepId)}`;
-}
-export function userStoryDeploymentStepOrderEndpoint(userStoryId) {
-    return `${userStoryDeploymentStepsEndpoint(userStoryId)}/order`;
-}
-export function normalizeDeploymentStepTypes(response) {
-    return normalizeArray(response, ['deploymentStepTypes', 'stepTypes', 'types', 'items', 'records', 'data']);
-}
-export function normalizeSalesforceFlows(response) {
-    return normalizeArray(response, ['salesforceFlows', 'flows', 'items', 'records', 'data']);
-}
-export function isSalesforceDataDeploymentStepType(type) {
-    return SALESFORCE_DATA_DEPLOYMENT_STEP_TYPES.some((allowed) => allowed === type);
-}
-export function hasSalesforceDataDeploymentStep(steps) {
-    return steps.some((step) => isSalesforceDataDeploymentStepType(step.type) || isSalesforceDataDeploymentStepType(step.underlyingType));
-}
-export function normalizeDeploymentSteps(response) {
-    const normalized = normalizeArray(response, ['deploymentSteps', 'steps', 'items', 'records', 'data']);
-    if (normalized.length > 0 || !isObject(response))
-        return normalized;
-    const before = Array.isArray(response.before) ? response.before : [];
-    const after = Array.isArray(response.after) ? response.after : [];
-    return [...before, ...after];
-}
-export function parseConfigJson(options) {
-    const source = options.configFile === undefined ? options.configJson : readFileSync(options.configFile, 'utf8');
-    if (source === undefined) {
-        if (options.required)
-            throw new Error('Provide --config-json or --config-file.');
-        return undefined;
-    }
-    let parsed;
-    try {
-        parsed = JSON.parse(source);
-    }
-    catch {
-        throw new Error('Deployment step config must be valid JSON.');
-    }
-    if (!isObject(parsed))
-        throw new Error('Deployment step config must be a JSON object.');
-    return parsed;
-}
-export function validateDeploymentStepName(name) {
-    if (name === undefined || name.trim().length === 0)
-        throw new Error('--name cannot be empty.');
-    if (name.length > 80)
-        throw new Error('--name cannot exceed 80 characters.');
-}
-export function buildDeploymentStepCreatePayload(flags) {
-    validateDeploymentStepName(flags.name);
-    const selectors = [flags.type, flags['custom-step-api-name']].filter((value) => value !== undefined);
-    if (selectors.length !== 1)
-        throw new Error('Provide exactly one of --type or --custom-step-api-name.');
-    validateOptionalNonEmpty(flags.type, '--type');
-    validateOptionalNonEmpty(flags['custom-step-api-name'], '--custom-step-api-name');
-    validateOptionalNonEmpty(flags['skip-condition'], '--skip-condition');
-    validateOptionalNonEmpty(flags['queue-name'], '--queue-name');
-    if (flags.sequence !== undefined && flags.sequence !== 'before' && flags.sequence !== 'after') {
-        throw new Error('--sequence must be before or after.');
-    }
-    const configJson = parseConfigJson({
-        configFile: flags['config-file'],
-        configJson: flags['config-json'],
-        required: true,
-    });
-    return {
-        configJson,
-        ...(flags['custom-step-api-name'] === undefined ? {} : { customStepApiName: flags['custom-step-api-name'] }),
-        name: flags.name.trim(),
-        ...(flags['queue-name'] === undefined ? {} : { queueName: flags['queue-name'] }),
-        ...(flags['run-on-validation'] === undefined ? {} : { runOnValidation: flags['run-on-validation'] }),
-        ...(flags.sequence === undefined ? {} : { sequence: flags.sequence }),
-        ...(flags['skip-back-promotion'] === undefined ? {} : { skipBackPromotion: flags['skip-back-promotion'] }),
-        ...(flags['skip-condition'] === undefined ? {} : { skipCondition: flags['skip-condition'] }),
-        ...(flags.type === undefined ? {} : { type: flags.type }),
-    };
-}
-export function buildDeploymentStepUpdatePayload(flags) {
-    if (flags.name !== undefined)
-        validateDeploymentStepName(flags.name);
-    if (flags['skip-condition'] !== undefined && flags['clear-skip-condition']) {
-        throw new Error('Use only one of --skip-condition or --clear-skip-condition.');
-    }
-    if (flags['queue-name'] !== undefined && flags['clear-queue-name']) {
-        throw new Error('Use only one of --queue-name or --clear-queue-name.');
-    }
-    validateOptionalNonEmpty(flags['skip-condition'], '--skip-condition');
-    validateOptionalNonEmpty(flags['queue-name'], '--queue-name');
-    const configJson = parseConfigJson({ configFile: flags['config-file'], configJson: flags['config-json'] });
-    const payload = {
-        ...(configJson === undefined ? {} : { configJson }),
-        ...(flags.name === undefined ? {} : { name: flags.name.trim() }),
-        ...(flags['queue-name'] === undefined ? {} : { queueName: flags['queue-name'] }),
-        ...(flags['run-on-validation'] === undefined ? {} : { runOnValidation: flags['run-on-validation'] }),
-        ...(flags['skip-back-promotion'] === undefined ? {} : { skipBackPromotion: flags['skip-back-promotion'] }),
-        ...(flags['skip-condition'] === undefined ? {} : { skipCondition: flags['skip-condition'] }),
-    };
-    if (flags['clear-queue-name'])
-        payload.queueName = null;
-    if (flags['clear-skip-condition'])
-        payload.skipCondition = null;
-    if (Object.keys(payload).length === 0)
-        throw new Error('Provide at least one mutable field to update.');
-    return payload;
-}
-export function parseDeploymentStepOrder(value) {
-    if (!isObject(value) || !Array.isArray(value.before) || !Array.isArray(value.after)) {
-        throw new Error('Reorder input must be an object with before and after arrays.');
-    }
-    if (![...value.before, ...value.after].every((id) => typeof id === 'string' && id.trim().length > 0)) {
-        throw new Error('Reorder before and after values must be nonempty step IDs.');
-    }
-    return { after: value.after, before: value.before };
-}
-export function validateCompleteDeploymentStepOrder(order, current) {
-    const expected = current.map((step) => step.id);
-    const supplied = [...order.before, ...order.after];
-    const duplicates = supplied.filter((id, index) => supplied.indexOf(id) !== index);
-    const missing = expected.filter((id) => !supplied.includes(id));
-    const unknown = supplied.filter((id) => !expected.includes(id));
-    if (duplicates.length > 0 || missing.length > 0 || unknown.length > 0 || supplied.length !== expected.length) {
-        throw new Error(`Reorder input must contain every current deployment step exactly once.${missing.length > 0 ? ` Missing: ${missing.join(', ')}.` : ''}${unknown.length > 0 ? ` Unknown: ${unknown.join(', ')}.` : ''}${duplicates.length > 0 ? ` Duplicates: ${[...new Set(duplicates)].join(', ')}.` : ''}`);
-    }
-}
-export function formatDeploymentStepTypesTable(types) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'LABEL', value: 'label' },
-        { alias: 'SOURCE', value: 'source' },
-        { alias: 'UNDERLYING TYPE', value: 'underlyingType' },
-        { alias: 'SEQUENCE', value: 'defaultSequence' },
-        { alias: 'DEVELOPER NAME', value: 'developerName' },
-    ], types.map((type) => ({
-        defaultSequence: cellValue(type.defaultSequence),
-        developerName: cellValue(type.developerName),
-        id: cellValue(type.id),
-        label: cellValue(type.label),
-        source: cellValue(type.source),
-        underlyingType: cellValue(type.underlyingType),
-    })));
-}
-export function formatSalesforceFlowsTable(flows) {
-    return table([
-        { alias: 'API NAME', value: 'apiName' },
-        { alias: 'LABEL', value: 'label' },
-        { alias: 'NAMESPACE', value: 'namespacePrefix' },
-    ], flows.map((flow) => ({
-        apiName: cellValue(flow.apiName),
-        label: cellValue(flow.label),
-        namespacePrefix: cellValue(flow.namespacePrefix),
-    })));
-}
-export function formatDeploymentStepsTable(steps) {
-    return table([
-        { alias: 'ID', value: 'id' },
-        { alias: 'NAME', value: 'name' },
-        { alias: 'TYPE', value: 'type' },
-        { alias: 'SEQUENCE', value: 'sequence' },
-        { alias: 'ORDER', value: 'order' },
-        { alias: 'VALIDATION', value: 'runOnValidation' },
-        { alias: 'SKIP BACK PROMOTION', value: 'skipBackPromotion' },
-    ], steps.map((step) => ({
-        id: cellValue(step.id),
-        name: cellValue(step.name),
-        order: cellValue(step.order),
-        runOnValidation: cellValue(step.runOnValidation),
-        sequence: cellValue(step.sequence),
-        skipBackPromotion: cellValue(step.skipBackPromotion),
-        type: cellValue(step.type ?? step.customStepApiName),
-    })));
-}
-export function formatDeploymentStepDetail(step) {
-    return formatDeploymentStepsTable([step]);
-}
-//# sourceMappingURL=deployment-step-types.js.map
+import {modules} from './runtime.js';
+const DEPLOYMENT_STEP_SALESFORCE_FLOWS_ENDPOINT = modules["deployment-step-types.js"]["DEPLOYMENT_STEP_SALESFORCE_FLOWS_ENDPOINT"]
+const DEPLOYMENT_STEP_STANDARD_TYPES = modules["deployment-step-types.js"]["DEPLOYMENT_STEP_STANDARD_TYPES"]
+const DEPLOYMENT_STEP_TYPES_ENDPOINT = modules["deployment-step-types.js"]["DEPLOYMENT_STEP_TYPES_ENDPOINT"]
+const SALESFORCE_DATA_DEPLOYMENT_STEP_TYPES = modules["deployment-step-types.js"]["SALESFORCE_DATA_DEPLOYMENT_STEP_TYPES"]
+const buildDeploymentStepCreatePayload = modules["deployment-step-types.js"]["buildDeploymentStepCreatePayload"]
+const buildDeploymentStepUpdatePayload = modules["deployment-step-types.js"]["buildDeploymentStepUpdatePayload"]
+const deploymentStepSalesforceFlowsEndpoint = modules["deployment-step-types.js"]["deploymentStepSalesforceFlowsEndpoint"]
+const deploymentStepTypesEndpoint = modules["deployment-step-types.js"]["deploymentStepTypesEndpoint"]
+const formatDeploymentStepDetail = modules["deployment-step-types.js"]["formatDeploymentStepDetail"]
+const formatDeploymentStepTypesTable = modules["deployment-step-types.js"]["formatDeploymentStepTypesTable"]
+const formatDeploymentStepsTable = modules["deployment-step-types.js"]["formatDeploymentStepsTable"]
+const formatSalesforceFlowsTable = modules["deployment-step-types.js"]["formatSalesforceFlowsTable"]
+const hasSalesforceDataDeploymentStep = modules["deployment-step-types.js"]["hasSalesforceDataDeploymentStep"]
+const isSalesforceDataDeploymentStepType = modules["deployment-step-types.js"]["isSalesforceDataDeploymentStepType"]
+const normalizeDeploymentStepTypes = modules["deployment-step-types.js"]["normalizeDeploymentStepTypes"]
+const normalizeDeploymentSteps = modules["deployment-step-types.js"]["normalizeDeploymentSteps"]
+const normalizeSalesforceFlows = modules["deployment-step-types.js"]["normalizeSalesforceFlows"]
+const parseConfigJson = modules["deployment-step-types.js"]["parseConfigJson"]
+const parseDeploymentStepOrder = modules["deployment-step-types.js"]["parseDeploymentStepOrder"]
+const userStoryDeploymentStepEndpoint = modules["deployment-step-types.js"]["userStoryDeploymentStepEndpoint"]
+const userStoryDeploymentStepOrderEndpoint = modules["deployment-step-types.js"]["userStoryDeploymentStepOrderEndpoint"]
+const userStoryDeploymentStepsEndpoint = modules["deployment-step-types.js"]["userStoryDeploymentStepsEndpoint"]
+const validateCompleteDeploymentStepOrder = modules["deployment-step-types.js"]["validateCompleteDeploymentStepOrder"]
+const validateDeploymentStepName = modules["deployment-step-types.js"]["validateDeploymentStepName"]
+export {DEPLOYMENT_STEP_SALESFORCE_FLOWS_ENDPOINT, DEPLOYMENT_STEP_STANDARD_TYPES, DEPLOYMENT_STEP_TYPES_ENDPOINT, SALESFORCE_DATA_DEPLOYMENT_STEP_TYPES, buildDeploymentStepCreatePayload, buildDeploymentStepUpdatePayload, deploymentStepSalesforceFlowsEndpoint, deploymentStepTypesEndpoint, formatDeploymentStepDetail, formatDeploymentStepTypesTable, formatDeploymentStepsTable, formatSalesforceFlowsTable, hasSalesforceDataDeploymentStep, isSalesforceDataDeploymentStepType, normalizeDeploymentStepTypes, normalizeDeploymentSteps, normalizeSalesforceFlows, parseConfigJson, parseDeploymentStepOrder, userStoryDeploymentStepEndpoint, userStoryDeploymentStepOrderEndpoint, userStoryDeploymentStepsEndpoint, validateCompleteDeploymentStepOrder, validateDeploymentStepName};

package/dist/lib/deployment-step-wizard.js

@@ -1,155 +1,5 @@
-import { confirm, editor, input, select } from '@inquirer/prompts';
-import { buildFriendlyDeploymentStepConfig, } from './deployment-step-config.js';
-import { DEPLOYMENT_STEP_STANDARD_TYPES, validateDeploymentStepName, } from './deployment-step-types.js';
-const defaultPrompts = {
-    confirm: (options) => confirm(options),
-    editor: (options) => editor(options),
-    input: (options) => input(options),
-    select: (options) => select(options),
-};
-let activePrompts = defaultPrompts;
-export function setDeploymentStepPromptsForTests(prompts) {
-    activePrompts = prompts ?? defaultPrompts;
-}
-function requiredInput(message, defaultValue) {
-    return activePrompts.input({
-        ...(defaultValue === undefined ? {} : { default: defaultValue }),
-        message,
-        validate: (value) => value.trim().length > 0 || 'A value is required.',
-    });
-}
-function stepNameInput(defaultValue) {
-    return activePrompts.input({
-        default: defaultValue,
-        message: 'Step name',
-        validate(value) {
-            try {
-                validateDeploymentStepName(value);
-                return true;
-            }
-            catch (error) {
-                return error instanceof Error ? error.message.replace('--name', 'Step name') : String(error);
-            }
-        },
-    });
-}
-async function collectParameters(parameters = []) {
-    const addParameter = await activePrompts.confirm({ default: false, message: 'Add a parameter?' });
-    if (!addParameter)
-        return parameters;
-    const name = await requiredInput('Parameter name');
-    const value = await activePrompts.input({ message: `Value for ${name}` });
-    return collectParameters([...parameters, `${name}=${value}`]);
-}
-async function collectFriendlyFlags(type) {
-    switch (type) {
-        case 'Apex': {
-            return { 'apex-script': await activePrompts.editor({ message: 'Enter the Apex script' }) };
-        }
-        case 'Data Set - Salesforce': {
-            return { 'data-set-id': await requiredInput('Data Set Salesforce ID') };
-        }
-        case 'Data Template - Salesforce': {
-            return { 'data-template-id': await requiredInput('Data Template Salesforce ID') };
-        }
-        case 'Function': {
-            return {
-                'function-name': await requiredInput('Function name'),
-                parameter: await collectParameters(),
-            };
-        }
-        case 'Manual Task': {
-            const instructions = await requiredInput('Task instructions');
-            const environment = await activePrompts.select({
-                choices: [
-                    { name: 'Destination', value: 'destination' },
-                    { name: 'Source', value: 'source' },
-                    { name: 'Both source and destination', value: 'both' },
-                ],
-                default: 'destination',
-                message: 'Where should the task be performed?',
-            });
-            const assign = await activePrompts.confirm({ default: false, message: 'Assign the task to a specific user?' });
-            if (!assign)
-                return { environment, instructions };
-            return {
-                'assignee-id': await requiredInput('Assignee Salesforce user ID'),
-                'assignee-name': await requiredInput('Assignee display name'),
-                environment,
-                instructions,
-            };
-        }
-        case 'Robotic Test': {
-            return {
-                'crt-run-on': await activePrompts.select({
-                    choices: [
-                        { name: 'Destination', value: 'destination' },
-                        { name: 'Source', value: 'source' },
-                    ],
-                    default: 'destination',
-                    message: 'Where should the Robotic Test run?',
-                }),
-                'crt-test-id': await requiredInput('Robotic Test Salesforce ID'),
-            };
-        }
-        case 'Salesforce Flow': {
-            return {
-                'flow-name': await requiredInput('Flow API name'),
-                parameter: await collectParameters(),
-            };
-        }
-    }
-}
-function isStandardType(value) {
-    return DEPLOYMENT_STEP_STANDARD_TYPES.includes(value);
-}
-export async function collectDeploymentStepCreateInput(catalog) {
-    const available = catalog.filter((definition) => definition.source === 'standard' && isStandardType(definition.standardType));
-    if (available.length === 0) {
-        throw new Error('The gateway did not return any supported standard deployment step types.');
-    }
-    const selected = await activePrompts.select({
-        choices: available.map((definition) => ({ name: definition.label, value: definition })),
-        message: 'Deployment step type',
-    });
-    const type = selected.standardType;
-    const name = await stepNameInput(selected.label);
-    const sequence = await activePrompts.select({
-        choices: [
-            { name: 'Before deployment', value: 'before' },
-            { name: 'After deployment', value: 'after' },
-        ],
-        default: selected.defaultSequence,
-        message: 'Execution sequence',
-    });
-    const configJson = buildFriendlyDeploymentStepConfig(type, await collectFriendlyFlags(type));
-    const runOnValidation = type === 'Apex'
-        ? false
-        : await activePrompts.confirm({
-            default: selected.runsOnValidation,
-            message: 'Run during validation deployments?',
-        });
-    const skipBackPromotion = await activePrompts.confirm({
-        default: false,
-        message: 'Skip during back promotion?',
-    });
-    const skipCondition = (await activePrompts.input({ message: 'Skip condition (optional)' })).trim();
-    const queueName = (await activePrompts.input({ message: 'Queue name (optional)' })).trim();
-    return {
-        configJson,
-        name: name.trim(),
-        ...(queueName.length === 0 ? {} : { queueName }),
-        runOnValidation,
-        sequence,
-        skipBackPromotion,
-        ...(skipCondition.length === 0 ? {} : { skipCondition }),
-        type,
-    };
-}
-export function confirmDeploymentStepCreate(body) {
-    return activePrompts.confirm({
-        default: true,
-        message: `Create this deployment step?\n${JSON.stringify(body, null, 2)}`,
-    });
-}
-//# sourceMappingURL=deployment-step-wizard.js.map
+import {modules} from './runtime.js';
+const collectDeploymentStepCreateInput = modules["deployment-step-wizard.js"]["collectDeploymentStepCreateInput"]
+const confirmDeploymentStepCreate = modules["deployment-step-wizard.js"]["confirmDeploymentStepCreate"]
+const setDeploymentStepPromptsForTests = modules["deployment-step-wizard.js"]["setDeploymentStepPromptsForTests"]
+export {collectDeploymentStepCreateInput, confirmDeploymentStepCreate, setDeploymentStepPromptsForTests};