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

package/dist/lib/nested-metadata-changes.js

@@ -1,260 +1,9 @@
-import { DOMParser, XMLSerializer } from '@xmldom/xmldom';
-import { isPermissionNestedParentType, NESTED_METADATA_REGISTRY, nestedRulesForType, } from './nested-metadata-registry.js';
-import { resolveSalesforcePath } from './sdr-path-resolver.js';
-const ELEMENT_NODE = 1;
-function selectionKey(selection) {
-    return `${selection.type}:${selection.name}`;
-}
-function compareSelections(left, right) {
-    return left.type.localeCompare(right.type) || left.name.localeCompare(right.name);
-}
-export function formatNestedMetadataSelection(selection) {
-    return selectionKey(selection);
-}
-/**
- * Deleted nested children that may be registered as deletions. Profile and PermissionSet children
- * are excluded: their blocks grant permissions, so removing one revokes access rather than deleting
- * the component it points at.
- */
-export function listDeletableNestedChildren(changes) {
-    const permissionChildren = new Set(changes.permissionNestedChildren.map((child) => selectionKey(child)));
-    return changes.deletedNestedChildren.filter((child) => !permissionChildren.has(selectionKey(child)));
-}
-/**
- * Changed files whose metadata type aggregates nested children, paired with the rules that describe
- * the nested XML blocks to diff. Paths that do not resolve to Salesforce metadata are dropped.
- */
-export function listNestedParentCandidates(filePaths, registry = NESTED_METADATA_REGISTRY) {
-    const candidates = new Map();
-    for (const filePath of filePaths) {
-        const resolved = resolveSalesforcePath(filePath);
-        if (!resolved) {
-            continue;
-        }
-        const rules = nestedRulesForType(resolved.type, registry);
-        if (!rules) {
-            continue;
-        }
-        candidates.set(filePath, { ...resolved, filePath, rules });
-    }
-    return [...candidates.values()];
-}
-function localName(node) {
-    return (node.localName ?? node.nodeName ?? '').replace(/^.*:/, '');
-}
-function childElements(parent) {
-    const elements = [];
-    for (let index = 0; index < parent.childNodes.length; index++) {
-        const child = parent.childNodes.item(index);
-        if (child?.nodeType === ELEMENT_NODE) {
-            elements.push(child);
-        }
-    }
-    return elements;
-}
-function textOfField(element, field) {
-    for (const child of childElements(element)) {
-        if (localName(child) === field) {
-            return child.textContent?.trim() ?? '';
-        }
-    }
-    return '';
-}
-/** Composite key Copado uses for layout assignments: `<layout base>--<recordType>`. */
-export function layoutRecordTypeKey(layout, recordType) {
-    const base = layout.includes('-') ? layout.split('-')[0] : layout;
-    return recordType ? `${base}--${recordType}` : base;
-}
-/**
- * The object a parent component belongs to. Object-scoped parents carry it as the first segment of
- * their own name, before the record type (`Account.Business`) or the language (`Account-en_US`).
- */
-function objectOfParentName(parentName) {
-    return parentName.split(/[.-]/)[0] ?? '';
-}
-/**
- * Prefix the nested block does not carry itself. Nested names Copado tracks per object stay
- * ambiguous without it: a `Notify_Owner` workflow rule exists on any number of objects.
- */
-function nameScopePrefix(rule, parentName) {
-    switch (rule.nameScope) {
-        case 'object': {
-            return objectOfParentName(parentName);
-        }
-        case 'parent': {
-            return parentName;
-        }
-        default: {
-            return '';
-        }
-    }
-}
-export function nestedChildName(element, rule, parentName = '') {
-    const name = unscopedNestedChildName(element, rule);
-    if (name === undefined) {
-        return undefined;
-    }
-    const prefix = nameScopePrefix(rule, parentName);
-    if (prefix.length === 0 || name.startsWith(`${prefix}.`)) {
-        return name;
-    }
-    return `${prefix}.${name}`;
-}
-function unscopedNestedChildName(element, rule) {
-    if (rule.keyStyle === 'layoutRecordType') {
-        const layout = textOfField(element, rule.nameFields[0] ?? 'layout');
-        if (!layout) {
-            return undefined;
-        }
-        return layoutRecordTypeKey(layout, textOfField(element, rule.nameFields[1] ?? 'recordType'));
-    }
-    const parts = rule.nameFields.map((field) => textOfField(element, field)).filter(Boolean);
-    return parts.length === 0 ? undefined : parts.join('.');
-}
-function parseXml(xml) {
-    if (xml.trim().length === 0) {
-        return undefined;
-    }
-    try {
-        // Malformed or unexpected input must never reach stdout; `--json` output would be corrupted.
-        const document = new DOMParser({
-            onError() { },
-        }).parseFromString(xml, 'text/xml');
-        return document.documentElement ?? undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
-/** Whitespace-insensitive snapshot of a nested block, so reformatting alone is not a change. */
-function normalizeBlock(serialized) {
-    return serialized.replaceAll(/>\s+</g, '><').replaceAll(/\s+/g, ' ').trim();
-}
-function collectNestedBlocks(root, rule, parentName) {
-    const blocks = new Map();
-    if (!root) {
-        return blocks;
-    }
-    const serializer = new XMLSerializer();
-    for (const element of childElements(root)) {
-        if (localName(element) !== rule.xmlElement) {
-            continue;
-        }
-        const name = nestedChildName(element, rule, parentName);
-        if (name === undefined) {
-            continue;
-        }
-        blocks.set(name, normalizeBlock(serializer.serializeToString(element)));
-    }
-    return blocks;
-}
-/**
- * A child that is present under one rule or parent and gone under another still exists on the
- * branch, so anything but a removal wins: only children removed everywhere can be deleted.
- */
-function mergeChangeKind(current, next) {
-    return current === 'removed' ? next : current;
-}
-function recordChange(changes, change) {
-    const key = selectionKey(change);
-    const current = changes.get(key);
-    changes.set(key, current === undefined
-        ? change
-        : { ...current, changeKind: mergeChangeKind(current.changeKind, change.changeKind) });
-}
-/**
- * Nested children whose XML block was added, removed, or edited between the two parent revisions.
- * `parentName` scopes the child names Copado tracks per object, such as a workflow rule.
- */
-export function diffNestedChildren(baseXml, headXml, rules, parentName = '') {
-    const baseRoot = parseXml(baseXml);
-    const headRoot = parseXml(headXml);
-    const changes = new Map();
-    for (const rule of rules) {
-        const baseBlocks = collectNestedBlocks(baseRoot, rule, parentName);
-        const headBlocks = collectNestedBlocks(headRoot, rule, parentName);
-        for (const name of new Set([...baseBlocks.keys(), ...headBlocks.keys()])) {
-            const before = baseBlocks.get(name);
-            const after = headBlocks.get(name);
-            if (before === after) {
-                continue;
-            }
-            let changeKind = 'modified';
-            if (after === undefined) {
-                changeKind = 'removed';
-            }
-            else if (before === undefined) {
-                changeKind = 'added';
-            }
-            recordChange(changes, { changeKind, name, type: rule.childType });
-        }
-    }
-    return [...changes.values()];
-}
-/**
- * Translates changed nested-parent files into the parents to ignore and the nested children that
- * represent the actual change. A parent is only ignored when at least one of its nested blocks
- * changed; parents whose top-level fields alone changed still need to be deployed as a whole.
- *
- * A parent file that is absent at the base revision and present at `HEAD` is brand new: it is
- * reported as `fullMetadataParents` and is not decomposed, so the complete file travels.
- *
- * Profile and PermissionSet parents are reported separately and are never ignored: dropping them
- * would leave nothing to deploy the permissions their changed blocks describe.
- */
-export async function detectNestedMetadataChanges(options) {
-    const { filePaths, readBase, readHead } = options;
-    const candidates = listNestedParentCandidates(filePaths, options.registry);
-    const fullMetadataParents = new Map();
-    const ignoredParents = new Map();
-    const nestedChildren = new Map();
-    const permissionNestedChildren = new Map();
-    const permissionParents = new Map();
-    for (const candidate of candidates) {
-        // eslint-disable-next-line no-await-in-loop -- git reads are cheap and kept sequential on purpose
-        const [baseXml, headXml] = await Promise.all([
-            readBase(candidate.filePath),
-            readHead(candidate.filePath),
-        ]);
-        if (baseXml.length === 0 && headXml.length === 0) {
-            continue;
-        }
-        const parent = { name: candidate.name, type: candidate.type };
-        // Brand-new nested parent file: keep the whole component rather than listing every nested block.
-        if (baseXml.length === 0 && headXml.length > 0) {
-            fullMetadataParents.set(selectionKey(parent), parent);
-            continue;
-        }
-        const children = diffNestedChildren(baseXml, headXml, candidate.rules, candidate.name);
-        if (children.length === 0) {
-            continue;
-        }
-        const isPermissionParent = isPermissionNestedParentType(candidate.type);
-        if (isPermissionParent) {
-            permissionParents.set(selectionKey(parent), parent);
-        }
-        else {
-            ignoredParents.set(selectionKey(parent), parent);
-        }
-        for (const child of children) {
-            recordChange(nestedChildren, child);
-            if (isPermissionParent) {
-                const { name, type } = child;
-                permissionNestedChildren.set(selectionKey(child), { name, type });
-            }
-        }
-    }
-    const changed = [...nestedChildren.values()];
-    return {
-        deletedNestedChildren: changed
-            .filter((child) => child.changeKind === 'removed')
-            .map(({ name, type }) => ({ name, type }))
-            .sort(compareSelections),
-        fullMetadataParents: [...fullMetadataParents.values()].sort(compareSelections),
-        ignoredParents: [...ignoredParents.values()].sort(compareSelections),
-        nestedChildren: changed.map(({ name, type }) => ({ name, type })).sort(compareSelections),
-        permissionNestedChildren: [...permissionNestedChildren.values()].sort(compareSelections),
-        permissionParents: [...permissionParents.values()].sort(compareSelections),
-    };
-}
-//# sourceMappingURL=nested-metadata-changes.js.map
+import {modules} from './runtime.js';
+const detectNestedMetadataChanges = modules["nested-metadata-changes.js"]["detectNestedMetadataChanges"]
+const diffNestedChildren = modules["nested-metadata-changes.js"]["diffNestedChildren"]
+const formatNestedMetadataSelection = modules["nested-metadata-changes.js"]["formatNestedMetadataSelection"]
+const layoutRecordTypeKey = modules["nested-metadata-changes.js"]["layoutRecordTypeKey"]
+const listDeletableNestedChildren = modules["nested-metadata-changes.js"]["listDeletableNestedChildren"]
+const listNestedParentCandidates = modules["nested-metadata-changes.js"]["listNestedParentCandidates"]
+const nestedChildName = modules["nested-metadata-changes.js"]["nestedChildName"]
+export {detectNestedMetadataChanges, diffNestedChildren, formatNestedMetadataSelection, layoutRecordTypeKey, listDeletableNestedChildren, listNestedParentCandidates, nestedChildName};

package/dist/lib/nested-metadata-registry.js

@@ -1,257 +1,12 @@
-/**
- * Parents whose nested children are permissions rather than deployable components on their own.
- * Their changed children are pushed as `RetrieveOnly`, the same way `lastPermissionSelected` is.
- */
-export const PERMISSION_NESTED_PARENT_TYPES = new Set(['PermissionSet', 'Profile']);
-export function isPermissionNestedParentType(type) {
-    return PERMISSION_NESTED_PARENT_TYPES.has(type);
-}
-export const NESTED_METADATA_REGISTRY = {
-    AssignmentRules: [
-        { childType: 'AssignmentRule', nameFields: ['fullName'], nameScope: 'parent', xmlElement: 'assignmentRule' },
-    ],
-    AutoResponseRules: [
-        {
-            childType: 'AutoResponseRule',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'autoResponseRule',
-        },
-    ],
-    CustomLabels: [{ childType: 'CustomLabel', nameFields: ['fullName'], xmlElement: 'labels' }],
-    CustomObject: [
-        { childType: 'SharingRecalculation', nameFields: ['className'], xmlElement: 'sharingRecalculations' },
-    ],
-    CustomObjectTranslation: [
-        { childType: 'FieldSet', nameFields: ['name'], nameScope: 'object', xmlElement: 'fieldSets' },
-        { childType: 'CustomField', nameFields: ['name'], nameScope: 'object', xmlElement: 'fields' },
-        {
-            // The translated layout name already carries its object, so it needs no parent scope.
-            childType: 'Layout',
-            keyStyle: 'layoutRecordType',
-            nameFields: ['layout', 'layoutType'],
-            xmlElement: 'layouts',
-        },
-        { childType: 'QuickAction', nameFields: ['name'], nameScope: 'object', xmlElement: 'quickActions' },
-        { childType: 'RecordType', nameFields: ['name'], nameScope: 'object', xmlElement: 'recordTypes' },
-        { childType: 'SharingReason', nameFields: ['name'], nameScope: 'object', xmlElement: 'sharingReasons' },
-        {
-            childType: 'StandardFieldTranslation',
-            nameFields: ['name'],
-            nameScope: 'object',
-            xmlElement: 'standardFields',
-        },
-        { childType: 'ValidationRule', nameFields: ['name'], nameScope: 'object', xmlElement: 'validationRules' },
-        { childType: 'WebLink', nameFields: ['name'], nameScope: 'object', xmlElement: 'webLinks' },
-        { childType: 'WorkflowTask', nameFields: ['name'], nameScope: 'object', xmlElement: 'workflowTasks' },
-    ],
-    EscalationRules: [
-        { childType: 'EscalationRule', nameFields: ['fullName'], nameScope: 'parent', xmlElement: 'escalationRule' },
-    ],
-    MatchingRules: [
-        { childType: 'MatchingRule', nameFields: ['fullName'], nameScope: 'parent', xmlElement: 'matchingRules' },
-    ],
-    MutingPermissionSet: [
-        { childType: 'CustomApplication', nameFields: ['application'], xmlElement: 'applicationVisibilities' },
-        { childType: 'CustomField', nameFields: ['field'], xmlElement: 'fieldPermissions' },
-        { childType: 'CustomObject', nameFields: ['object'], xmlElement: 'objectPermissions' },
-        { childType: 'CustomTab', nameFields: ['tab'], xmlElement: 'tabSettings' },
-        { childType: 'ApexClass', nameFields: ['apexClass'], xmlElement: 'classAccesses' },
-        { childType: 'ApexPage', nameFields: ['apexPage'], xmlElement: 'pageAccesses' },
-        { childType: 'RecordType', nameFields: ['recordType'], xmlElement: 'recordTypeVisibilities' },
-        { childType: 'CustomPermission', nameFields: ['name'], xmlElement: 'customPermissions' },
-        { childType: 'CustomObject', nameFields: ['name'], xmlElement: 'customMetadataTypeAccesses' },
-        { childType: 'CustomObject', nameFields: ['name'], xmlElement: 'customSettingAccesses' },
-        { childType: 'Flow', nameFields: ['flow'], xmlElement: 'flowAccesses' },
-        { childType: 'EmailRoutingAddress', nameFields: ['name'], xmlElement: 'emailRoutingAddressAccesses' },
-        {
-            childType: 'ServicePresenceStatus',
-            nameFields: ['servicePresenceStatus'],
-            xmlElement: 'servicePresenceStatusAccesses',
-        },
-        {
-            childType: 'ExternalCredential',
-            nameFields: ['externalCredentialPrincipal'],
-            xmlElement: 'externalCredentialPrincipalAccesses',
-        },
-    ],
-    PermissionSet: [
-        { childType: 'CustomApplication', nameFields: ['application'], xmlElement: 'applicationVisibilities' },
-        { childType: 'CustomField', nameFields: ['field'], xmlElement: 'fieldPermissions' },
-        { childType: 'CustomObject', nameFields: ['object'], xmlElement: 'objectPermissions' },
-        { childType: 'CustomTab', nameFields: ['tab'], xmlElement: 'tabSettings' },
-        { childType: 'ApexClass', nameFields: ['apexClass'], xmlElement: 'classAccesses' },
-        { childType: 'ApexPage', nameFields: ['apexPage'], xmlElement: 'pageAccesses' },
-        { childType: 'RecordType', nameFields: ['recordType'], xmlElement: 'recordTypeVisibilities' },
-        { childType: 'CustomPermission', nameFields: ['name'], xmlElement: 'customPermissions' },
-        { childType: 'CustomObject', nameFields: ['name'], xmlElement: 'customMetadataTypeAccesses' },
-        { childType: 'CustomObject', nameFields: ['name'], xmlElement: 'customSettingAccesses' },
-        { childType: 'Flow', nameFields: ['flow'], xmlElement: 'flowAccesses' },
-        {
-            childType: 'ExternalDataSource',
-            nameFields: ['externalDataSource'],
-            xmlElement: 'externalDataSourceAccesses',
-        },
-        { childType: 'EmailRoutingAddress', nameFields: ['name'], xmlElement: 'emailRoutingAddressAccesses' },
-        {
-            childType: 'ServicePresenceStatus',
-            nameFields: ['servicePresenceStatus'],
-            xmlElement: 'servicePresenceStatusAccesses',
-        },
-        {
-            childType: 'GenComputingSummaryDefAccess',
-            nameFields: ['configName'],
-            xmlElement: 'genComputingSummaryDefAccesses',
-        },
-        {
-            childType: 'ExternalCredential',
-            nameFields: ['externalCredentialPrincipal'],
-            xmlElement: 'externalCredentialPrincipalAccesses',
-        },
-    ],
-    Profile: [
-        { childType: 'CustomApplication', nameFields: ['application'], xmlElement: 'applicationVisibilities' },
-        { childType: 'CustomField', nameFields: ['field'], xmlElement: 'fieldPermissions' },
-        { childType: 'CustomObject', nameFields: ['object'], xmlElement: 'objectPermissions' },
-        { childType: 'CustomTab', nameFields: ['tab'], xmlElement: 'tabVisibilities' },
-        { childType: 'ApexClass', nameFields: ['apexClass'], xmlElement: 'classAccesses' },
-        { childType: 'ApexPage', nameFields: ['apexPage'], xmlElement: 'pageAccesses' },
-        { childType: 'RecordType', nameFields: ['recordType'], xmlElement: 'recordTypeVisibilities' },
-        { childType: 'CustomPermission', nameFields: ['name'], xmlElement: 'customPermissions' },
-        {
-            childType: 'Layout',
-            keyStyle: 'layoutRecordType',
-            nameFields: ['layout', 'recordType'],
-            xmlElement: 'layoutAssignments',
-        },
-        { childType: 'CustomObject', nameFields: ['name'], xmlElement: 'customMetadataTypeAccesses' },
-        { childType: 'CustomObject', nameFields: ['name'], xmlElement: 'customSettingAccesses' },
-        { childType: 'AgentAccess', nameFields: ['agentName'], xmlElement: 'agentAccesses' },
-        {
-            childType: 'ServicePresenceStatus',
-            nameFields: ['servicePresenceStatus'],
-            xmlElement: 'servicePresenceStatusAccesses',
-        },
-        {
-            childType: 'GenComputingSummaryDefAccess',
-            nameFields: ['configName'],
-            xmlElement: 'genComputingSummaryDefAccesses',
-        },
-        { childType: 'Flow', nameFields: ['flow'], xmlElement: 'flowAccesses' },
-    ],
-    SharingRules: [
-        {
-            childType: 'SharingCriteriaRule',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'sharingCriteriaRules',
-        },
-        {
-            childType: 'SharingOwnerRule',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'sharingOwnerRules',
-        },
-        {
-            childType: 'SharingTerritoryRule',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'sharingTerritoryRules',
-        },
-        {
-            childType: 'SharingGuestRule',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'sharingGuestRules',
-        },
-    ],
-    Translations: [
-        { childType: 'CustomApplication', nameFields: ['name'], xmlElement: 'customApplications' },
-        { childType: 'CustomLabel', nameFields: ['name'], xmlElement: 'customLabels' },
-        { childType: 'CustomPageWebLinkTranslation', nameFields: ['name'], xmlElement: 'customPageWebLinks' },
-        { childType: 'CustomTab', nameFields: ['name'], xmlElement: 'customTabs' },
-        { childType: 'FlowDefinition', nameFields: ['fullName'], xmlElement: 'flowDefinitions' },
-        { childType: 'QuickAction', nameFields: ['name'], xmlElement: 'quickActions' },
-        { childType: 'ReportType', nameFields: ['name'], xmlElement: 'reportTypes' },
-        { childType: 'CustomObject', nameFields: ['name'], xmlElement: 'scontrols' },
-        {
-            childType: 'CustomDataTypeTranslation',
-            nameFields: ['customDataTypeName'],
-            xmlElement: 'customDataTypes',
-        },
-        { childType: 'PipelineInspMetricConfig', nameFields: ['name'], xmlElement: 'pipelineInspMetricConfigs' },
-        { childType: 'DataConnector', nameFields: ['name'], xmlElement: 'dataConnectors' },
-        {
-            childType: 'ConversationMessageDefinition',
-            nameFields: ['name'],
-            xmlElement: 'conversationMessageDefinitions',
-        },
-        { childType: 'BotTemplate', nameFields: ['fullName'], xmlElement: 'botTemplates' },
-        { childType: 'BotBlock', nameFields: ['fullName'], xmlElement: 'botBlocks' },
-        { childType: 'Bot', nameFields: ['fullName'], xmlElement: 'bots' },
-        {
-            childType: 'ConversationMessageDefinitionTranslation',
-            nameFields: ['name'],
-            xmlElement: 'aiCoachAgentScnrDefs',
-        },
-        {
-            childType: 'IdentityVerificationCustomFieldLabel',
-            nameFields: ['name'],
-            xmlElement: 'identityVerificationFields',
-        },
-        {
-            childType: 'ServiceProcessAttributeTranslation',
-            nameFields: ['name'],
-            xmlElement: 'serviceProcessAttributes',
-        },
-        {
-            childType: 'ServiceProcessItemGroupTranslation',
-            nameFields: ['name'],
-            xmlElement: 'serviceProcessItemGroups',
-        },
-        { childType: 'ProductSpecificationType', nameFields: ['name'], xmlElement: 'productSpecificationTypes' },
-        { childType: 'RecordAlertCategory', nameFields: ['name'], xmlElement: 'recordAlertCategories' },
-        { childType: 'RecordAlertTemplate', nameFields: ['name'], xmlElement: 'recordAlertTemplates' },
-        { childType: 'TimelineObjectDefinition', nameFields: ['name'], xmlElement: 'timelineObjectDefinitions' },
-        { childType: 'ContextDefinition', nameFields: ['name'], xmlElement: 'contextDefinitions' },
-        { childType: 'DashboardComponent', nameFields: ['name'], xmlElement: 'dashboardComponents' },
-        { childType: 'Dashboard', nameFields: ['name'], xmlElement: 'dashboards' },
-        { childType: 'Report', nameFields: ['name'], xmlElement: 'reports' },
-    ],
-    Workflow: [
-        { childType: 'WorkflowRule', nameFields: ['fullName'], nameScope: 'parent', xmlElement: 'rules' },
-        { childType: 'WorkflowFlowAction', nameFields: ['fullName'], nameScope: 'parent', xmlElement: 'flowActions' },
-        {
-            childType: 'WorkflowFieldUpdate',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'fieldUpdates',
-        },
-        { childType: 'WorkflowTask', nameFields: ['fullName'], nameScope: 'parent', xmlElement: 'tasks' },
-        { childType: 'WorkflowAlert', nameFields: ['fullName'], nameScope: 'parent', xmlElement: 'alerts' },
-        {
-            childType: 'WorkflowOutboundMessage',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'outboundMessages',
-        },
-        {
-            childType: 'WorkflowKnowledgePublish',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'knowledgePublishes',
-        },
-        { childType: 'WorkflowSend', nameFields: ['fullName'], nameScope: 'parent', xmlElement: 'send' },
-        {
-            childType: 'WorkflowFlowAutomation',
-            nameFields: ['fullName'],
-            nameScope: 'parent',
-            xmlElement: 'flowAutomations',
-        },
-    ],
-};
-export function nestedRulesForType(type, registry = NESTED_METADATA_REGISTRY) {
-    const rules = registry[type];
-    return rules === undefined || rules.length === 0 ? undefined : rules;
-}
-//# sourceMappingURL=nested-metadata-registry.js.map
+import {modules} from './runtime.js';
+const FULL_METADATA_SELECTION_TYPES = modules["nested-metadata-registry.js"]["FULL_METADATA_SELECTION_TYPES"]
+const FULL_METADATA_SELECTION_TYPES_HELP = modules["nested-metadata-registry.js"]["FULL_METADATA_SELECTION_TYPES_HELP"]
+const NESTED_METADATA_REGISTRY = modules["nested-metadata-registry.js"]["NESTED_METADATA_REGISTRY"]
+const PERMISSION_NESTED_PARENT_TYPES = modules["nested-metadata-registry.js"]["PERMISSION_NESTED_PARENT_TYPES"]
+const PERMISSION_SELECTION_TYPES = modules["nested-metadata-registry.js"]["PERMISSION_SELECTION_TYPES"]
+const PERMISSION_SELECTION_TYPES_HELP = modules["nested-metadata-registry.js"]["PERMISSION_SELECTION_TYPES_HELP"]
+const isFullMetadataSelectionType = modules["nested-metadata-registry.js"]["isFullMetadataSelectionType"]
+const isPermissionNestedParentType = modules["nested-metadata-registry.js"]["isPermissionNestedParentType"]
+const isPermissionSelectionType = modules["nested-metadata-registry.js"]["isPermissionSelectionType"]
+const nestedRulesForType = modules["nested-metadata-registry.js"]["nestedRulesForType"]
+export {FULL_METADATA_SELECTION_TYPES, FULL_METADATA_SELECTION_TYPES_HELP, NESTED_METADATA_REGISTRY, PERMISSION_NESTED_PARENT_TYPES, PERMISSION_SELECTION_TYPES, PERMISSION_SELECTION_TYPES_HELP, isFullMetadataSelectionType, isPermissionNestedParentType, isPermissionSelectionType, nestedRulesForType};

package/dist/lib/notifications-configure.js

@@ -1,101 +1,13 @@
-import { CicdGateway, CicdGatewayError } from './cicd-gateway.js';
-export const NOTIFICATIONS_CONFIGURE_ENDPOINT = '/notifications/configure';
-export const NOTIFICATION_EVENTS = [
-    'Promotion_Success',
-    'Promotion_Failed',
-    'Promotion_Conflict',
-    'Failed_Promotion_Creation',
-    'Deploy_Success',
-    'Deploy_Failed',
-    'Commit_Failed',
-    'Successful_Snapshot',
-    'Failed_Snapshot',
-    'ManualTask_Assigned',
-    'Test_Success',
-    'Test_Failed',
-    'Test_Cancelled',
-    'Test_Not Started',
-    'Quality_Gate_Success',
-    'Quality_Gate_Failed',
-    'Quality_Gate_Cancelled',
-    'Quality_Gate_Not Started',
-    'Create_Package_Success',
-    'Create_Package_Failure',
-    'Generate_Package_Version_Success',
-    'Generate_Package_Version_Failure',
-    'Import_Package_Success',
-    'Import_Package_Failure',
-    'Publish_Package_Success',
-    'Publish_Package_Failure',
-];
-export const NOTIFICATION_DESTINATION_TYPES = ['user', 'channel'];
-export const NOTIFICATION_SUBSCRIPTIONS = ['user', 'all'];
-const PIPELINE_ID_PATTERN = /^[A-Za-z0-9_]+$/;
-const NOTIFICATION_CONFIGURE_ERROR_MESSAGES = {
-    'NTF-003': 'Slack destination is invalid for the selected destination type. Check destinationId and destinationType.',
-    'NTF-004': 'Pipeline id is missing or invalid. Use a 15- or 18-character Copado pipeline Salesforce id.',
-};
-export class NotificationConfigureInputError extends Error {
-    exitCode = 2;
-    constructor(message) {
-        super(message);
-        this.name = 'NotificationConfigureInputError';
-    }
-}
-export function validatePipelineId(value) {
-    const trimmed = value.trim();
-    if (trimmed.length === 0) {
-        throw new NotificationConfigureInputError('--pipeline-id cannot be empty.');
-    }
-    if (trimmed.length !== 15 && trimmed.length !== 18) {
-        throw new NotificationConfigureInputError('--pipeline-id must be 15 or 18 characters. Use a valid Copado pipeline Salesforce id.');
-    }
-    if (!PIPELINE_ID_PATTERN.test(trimmed)) {
-        throw new NotificationConfigureInputError('--pipeline-id contains invalid characters. Only letters, digits, and underscores are allowed.');
-    }
-    return trimmed;
-}
-export function buildConfigureNotificationPayload(input) {
-    return {
-        destinationId: input.destinationId.trim(),
-        destinationType: input.destinationType,
-        event: input.event,
-        pipelineId: validatePipelineId(input.pipelineId),
-        providers: ['slack'],
-        subscription: input.subscription,
-    };
-}
-export function formatConfigureNotificationSummary(result) {
-    return `Configured ${result.event} notification for pipeline ${result.pipelineId} (destination: ${result.destinationId}, type: ${result.destinationType}, subscription: ${result.subscription}).`;
-}
-export function translateNotificationConfigureError(error) {
-    if (error instanceof CicdGatewayError) {
-        const identifiers = [...error.categories, error.code];
-        const identifier = identifiers.find((value) => value !== undefined && value in NOTIFICATION_CONFIGURE_ERROR_MESSAGES);
-        if (identifier !== undefined) {
-            return new Error(NOTIFICATION_CONFIGURE_ERROR_MESSAGES[identifier]);
-        }
-    }
-    return error instanceof Error ? error : new Error(String(error));
-}
-export async function withNotificationConfigureErrorTranslation(action) {
-    try {
-        return await action();
-    }
-    catch (error) {
-        throw translateNotificationConfigureError(error);
-    }
-}
-export async function configureNotification(input, gatewayCall = CicdGateway.call) {
-    const body = buildConfigureNotificationPayload(input);
-    if (body.destinationId.length === 0) {
-        throw new NotificationConfigureInputError('--destination-id cannot be empty.');
-    }
-    return gatewayCall({
-        body,
-        endpoint: NOTIFICATIONS_CONFIGURE_ENDPOINT,
-        headers: { 'Content-Type': 'application/json' },
-        method: 'POST',
-    });
-}
-//# sourceMappingURL=notifications-configure.js.map
+import {modules} from './runtime.js';
+const NOTIFICATIONS_CONFIGURE_ENDPOINT = modules["notifications-configure.js"]["NOTIFICATIONS_CONFIGURE_ENDPOINT"]
+const NOTIFICATION_DESTINATION_TYPES = modules["notifications-configure.js"]["NOTIFICATION_DESTINATION_TYPES"]
+const NOTIFICATION_EVENTS = modules["notifications-configure.js"]["NOTIFICATION_EVENTS"]
+const NOTIFICATION_SUBSCRIPTIONS = modules["notifications-configure.js"]["NOTIFICATION_SUBSCRIPTIONS"]
+const NotificationConfigureInputError = modules["notifications-configure.js"]["NotificationConfigureInputError"]
+const buildConfigureNotificationPayload = modules["notifications-configure.js"]["buildConfigureNotificationPayload"]
+const configureNotification = modules["notifications-configure.js"]["configureNotification"]
+const formatConfigureNotificationSummary = modules["notifications-configure.js"]["formatConfigureNotificationSummary"]
+const translateNotificationConfigureError = modules["notifications-configure.js"]["translateNotificationConfigureError"]
+const validatePipelineId = modules["notifications-configure.js"]["validatePipelineId"]
+const withNotificationConfigureErrorTranslation = modules["notifications-configure.js"]["withNotificationConfigureErrorTranslation"]
+export {NOTIFICATIONS_CONFIGURE_ENDPOINT, NOTIFICATION_DESTINATION_TYPES, NOTIFICATION_EVENTS, NOTIFICATION_SUBSCRIPTIONS, NotificationConfigureInputError, buildConfigureNotificationPayload, configureNotification, formatConfigureNotificationSummary, translateNotificationConfigureError, validatePipelineId, withNotificationConfigureErrorTranslation};