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

package/dist/lib/open-browser.js

@@ -1,52 +1,6 @@
-import { spawn } from 'node:child_process';
-import { platform } from 'node:os';
-export function isHeadlessEnvironment(deps = {}) {
-    const env = deps.env ?? process.env;
-    const currentPlatform = deps.platform ?? platform();
-    if (currentPlatform === 'linux' && !env.DISPLAY?.trim()) {
-        return true;
-    }
-    return false;
-}
-async function defaultOpenUrl(url, deps = {}) {
-    const currentPlatform = deps.platform ?? platform();
-    const spawnFn = deps.spawnImpl ?? spawn;
-    let command;
-    let args;
-    if (currentPlatform === 'darwin') {
-        command = 'open';
-        args = [url];
-    }
-    else if (currentPlatform === 'win32') {
-        command = 'cmd';
-        args = ['/c', 'start', '', url];
-    }
-    else {
-        command = 'xdg-open';
-        args = [url];
-    }
-    await new Promise((resolve, reject) => {
-        const child = spawnFn(command, args, {
-            detached: true,
-            stdio: 'ignore',
-        });
-        child.once('error', reject);
-        child.once('spawn', () => {
-            child.unref();
-            resolve();
-        });
-    });
-}
-let openUrlFn = defaultOpenUrl;
-export async function openUrl(url, deps = {}) {
-    await openUrlFn(url, deps);
-}
-// Test-only hook
-export function setOpenUrlForTests(fn) {
-    openUrlFn = fn;
-}
-// Test-only hook
-export function resetOpenUrlForTests() {
-    openUrlFn = defaultOpenUrl;
-}
-//# sourceMappingURL=open-browser.js.map
+import {modules} from './runtime.js';
+const isHeadlessEnvironment = modules["open-browser.js"]["isHeadlessEnvironment"]
+const openUrl = modules["open-browser.js"]["openUrl"]
+const resetOpenUrlForTests = modules["open-browser.js"]["resetOpenUrlForTests"]
+const setOpenUrlForTests = modules["open-browser.js"]["setOpenUrlForTests"]
+export {isHeadlessEnvironment, openUrl, resetOpenUrlForTests, setOpenUrlForTests};

package/dist/lib/pipeline-connection-flags.js

@@ -1,309 +1,17 @@
-import { Flags } from '@oclif/core';
-import { assertJsonArray, parseJsonValue, readJsonBodyFromFileOrStdin } from './data-flags.js';
-import { PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING, } from './pipeline-types.js';
-export const pipelineConnectionMutationStringFlags = {
-    branch: Flags.string({
-        description: 'Source branch for the connection',
-    }),
-    'connection-id': Flags.string({
-        description: 'Pipeline connection ID (required for single-connection update or delete)',
-    }),
-    'destination-branch': Flags.string({
-        description: 'Destination branch for the connection',
-    }),
-    'destination-environment-id': Flags.string({
-        description: 'Destination environment ID',
-    }),
-    'source-environment-id': Flags.string({
-        description: 'Source environment ID',
-    }),
-    'stage-connection-id': Flags.string({
-        description: 'Stage connection ID',
-    }),
-    'sync-merge-state': Flags.string({
-        description: 'Sync merge state',
-    }),
-    'sync-pull-state': Flags.string({
-        description: 'Sync pull state',
-    }),
-};
-export const pipelineConnectionCreateFlags = {
-    ...pipelineConnectionMutationStringFlags,
-    file: Flags.string({
-        char: 'f',
-        description: 'Path to a JSON array of pipeline connections to create',
-        exclusive: [
-            'branch',
-            'destination-branch',
-            'destination-environment-id',
-            'source-environment-id',
-            'stage-connection-id',
-            'sync-merge-state',
-            'sync-pull-state',
-        ],
-    }),
-    'pipeline-id': Flags.string({
-        description: 'Pipeline ID or name',
-        required: true,
-    }),
-};
-export const pipelineConnectionUpdateFlags = {
-    ...pipelineConnectionMutationStringFlags,
-    file: Flags.string({
-        char: 'f',
-        description: 'Path to a JSON array of pipeline connections to update (each item requires id)',
-        exclusive: [
-            'branch',
-            'connection-id',
-            'destination-branch',
-            'destination-environment-id',
-            'source-environment-id',
-            'stage-connection-id',
-            'sync-merge-state',
-            'sync-pull-state',
-        ],
-    }),
-    'pipeline-id': Flags.string({
-        description: 'Pipeline ID or name',
-        required: true,
-    }),
-};
-export const pipelineConnectionDeleteFlags = {
-    'connection-id': Flags.string({
-        description: 'Pipeline connection ID to delete (repeatable)',
-        multiple: true,
-    }),
-    file: Flags.string({
-        char: 'f',
-        description: 'Path to a JSON array of connection IDs or an object with connectionIds',
-        exclusive: ['connection-id'],
-    }),
-    'pipeline-id': Flags.string({
-        description: 'Pipeline ID or name',
-        required: true,
-    }),
-    yes: Flags.boolean({
-        char: 'y',
-        default: false,
-        description: 'Confirm deletion without prompting',
-    }),
-};
-export function buildPipelineConnectionCreatePayload(flags) {
-    const payload = buildPipelineConnectionCreateMutationPayload(flags);
-    if (payload.syncMergeState === undefined) {
-        payload.syncMergeState = PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING;
-    }
-    if (payload.syncPullState === undefined) {
-        payload.syncPullState = PIPELINE_CONNECTION_SYNC_STATE_NEEDS_RECALCULATING;
-    }
-    return payload;
-}
-export function buildPipelineConnectionUpdatePayload(flags) {
-    const connectionId = flags['connection-id']?.trim();
-    if (connectionId === undefined || connectionId.length === 0) {
-        throw new Error('--connection-id is required when not using --file.');
-    }
-    const payload = { id: connectionId };
-    assignPipelineConnectionUpdateField(payload, 'branch', flags.branch);
-    assignPipelineConnectionUpdateField(payload, 'destinationBranch', flags['destination-branch']);
-    assignPipelineConnectionUpdateField(payload, 'destinationEnvironmentId', flags['destination-environment-id']);
-    assignPipelineConnectionUpdateField(payload, 'sourceEnvironmentId', flags['source-environment-id']);
-    assignPipelineConnectionUpdateField(payload, 'stageConnectionId', flags['stage-connection-id']);
-    assignPipelineConnectionUpdateField(payload, 'syncMergeState', flags['sync-merge-state']);
-    assignPipelineConnectionUpdateField(payload, 'syncPullState', flags['sync-pull-state']);
-    if (countPipelineConnectionUpdateFields(payload) === 0) {
-        throw new Error('Must provide at least one field to update.');
-    }
-    return payload;
-}
-function assignPipelineConnectionUpdateField(payload, key, value) {
-    if (value !== undefined) {
-        Object.assign(payload, { [key]: value });
-    }
-}
-function countPipelineConnectionUpdateFields(payload) {
-    return Object.keys(payload).filter((key) => key !== 'id').length;
-}
-export function buildPipelineConnectionCreateMutationPayload(flags) {
-    const sourceEnvironmentId = flags['source-environment-id'];
-    const destinationEnvironmentId = flags['destination-environment-id'];
-    const { branch } = flags;
-    if (sourceEnvironmentId === undefined ||
-        destinationEnvironmentId === undefined ||
-        branch === undefined) {
-        throw new Error('sourceEnvironmentId, destinationEnvironmentId, and branch are required.');
-    }
-    const payload = {
-        branch,
-        destinationEnvironmentId,
-        sourceEnvironmentId,
-    };
-    if (flags['destination-branch'] !== undefined) {
-        payload.destinationBranch = flags['destination-branch'];
-    }
-    if (flags['stage-connection-id'] !== undefined) {
-        payload.stageConnectionId = flags['stage-connection-id'];
-    }
-    if (flags['sync-merge-state'] !== undefined) {
-        payload.syncMergeState = flags['sync-merge-state'];
-    }
-    if (flags['sync-pull-state'] !== undefined) {
-        payload.syncPullState = flags['sync-pull-state'];
-    }
-    if (flags['connection-id'] !== undefined) {
-        payload.id = flags['connection-id'];
-    }
-    return payload;
-}
-export function validatePipelineConnectionCreatePayload(payload) {
-    for (const key of ['sourceEnvironmentId', 'destinationEnvironmentId', 'branch']) {
-        const value = payload[key];
-        if (typeof value !== 'string' || value.trim().length === 0) {
-            return `${key} is required.`;
-        }
-    }
-    return undefined;
-}
-export function validatePipelineConnectionUpdatePayload(payload) {
-    if (payload.id.trim().length === 0) {
-        return 'id is required for each connection update.';
-    }
-    if (countPipelineConnectionUpdateFields(payload) === 0) {
-        return 'Must provide at least one field to update.';
-    }
-    for (const key of [
-        'branch',
-        'destinationBranch',
-        'destinationEnvironmentId',
-        'sourceEnvironmentId',
-        'stageConnectionId',
-        'syncMergeState',
-        'syncPullState',
-    ]) {
-        const value = payload[key];
-        if (value !== undefined && value.trim().length === 0) {
-            return `${key} value cannot be empty`;
-        }
-    }
-    return undefined;
-}
-export async function readPipelineConnectionArrayFromFile(filePath) {
-    const parsed = await readJsonBodyFromFileOrStdin({
-        file: filePath,
-        label: 'pipeline connections',
-        required: true,
-    });
-    const array = assertJsonArray(parsed, 'pipeline connections');
-    return array.map((item, index) => parsePipelineConnectionMutationObject(item, index));
-}
-export async function readPipelineConnectionUpdateArrayFromFile(filePath) {
-    const parsed = await readJsonBodyFromFileOrStdin({
-        file: filePath,
-        label: 'pipeline connections',
-        required: true,
-    });
-    const array = assertJsonArray(parsed, 'pipeline connections');
-    return array.map((item, index) => parsePipelineConnectionUpdateObject(item, index));
-}
-export function parsePipelineConnectionUpdateObject(value, index = 0) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new TypeError(`pipeline connections[${index}] must be a JSON object.`);
-    }
-    const record = value;
-    const { id } = record;
-    if (id === undefined || id === null || String(id).trim().length === 0) {
-        throw new TypeError(`pipeline connections[${index}].id is required.`);
-    }
-    const payload = { id: String(id) };
-    assignPipelineConnectionUpdateFieldFromRecord(payload, 'branch', record.branch);
-    assignPipelineConnectionUpdateFieldFromRecord(payload, 'destinationBranch', record.destinationBranch);
-    assignPipelineConnectionUpdateFieldFromRecord(payload, 'destinationEnvironmentId', record.destinationEnvironmentId);
-    assignPipelineConnectionUpdateFieldFromRecord(payload, 'sourceEnvironmentId', record.sourceEnvironmentId);
-    assignPipelineConnectionUpdateFieldFromRecord(payload, 'stageConnectionId', record.stageConnectionId);
-    assignPipelineConnectionUpdateFieldFromRecord(payload, 'syncMergeState', record.syncMergeState);
-    assignPipelineConnectionUpdateFieldFromRecord(payload, 'syncPullState', record.syncPullState);
-    if (countPipelineConnectionUpdateFields(payload) === 0) {
-        throw new TypeError(`pipeline connections[${index}] must include at least one field to update.`);
-    }
-    return payload;
-}
-function assignPipelineConnectionUpdateFieldFromRecord(payload, key, value) {
-    if (value !== undefined && value !== null) {
-        Object.assign(payload, { [key]: String(value) });
-    }
-}
-export function parsePipelineConnectionMutationObject(value, index = 0) {
-    if (!value || typeof value !== 'object' || Array.isArray(value)) {
-        throw new TypeError(`pipeline connections[${index}] must be a JSON object.`);
-    }
-    const record = value;
-    const payload = {
-        branch: String(record.branch ?? ''),
-        destinationEnvironmentId: String(record.destinationEnvironmentId ?? ''),
-        sourceEnvironmentId: String(record.sourceEnvironmentId ?? ''),
-    };
-    if (record.destinationBranch !== undefined && record.destinationBranch !== null) {
-        payload.destinationBranch = String(record.destinationBranch);
-    }
-    if (record.stageConnectionId !== undefined && record.stageConnectionId !== null) {
-        payload.stageConnectionId = String(record.stageConnectionId);
-    }
-    if (record.syncMergeState !== undefined && record.syncMergeState !== null) {
-        payload.syncMergeState = String(record.syncMergeState);
-    }
-    if (record.syncPullState !== undefined && record.syncPullState !== null) {
-        payload.syncPullState = String(record.syncPullState);
-    }
-    if (record.id !== undefined && record.id !== null) {
-        payload.id = String(record.id);
-    }
-    return payload;
-}
-export async function readPipelineConnectionIdsFromFile(filePath) {
-    const parsed = await readJsonBodyFromFileOrStdin({
-        file: filePath,
-        label: 'pipeline connection IDs',
-        required: true,
-    });
-    if (Array.isArray(parsed)) {
-        return parsed.map((item, index) => {
-            if (typeof item !== 'string' || item.trim().length === 0) {
-                throw new TypeError(`pipeline connection IDs[${index}] must be a non-empty string.`);
-            }
-            return item;
-        });
-    }
-    if (!parsed || typeof parsed !== 'object') {
-        throw new TypeError('pipeline connection IDs must be a JSON array or an object with connectionIds.');
-    }
-    const { connectionIds } = parsed;
-    if (!Array.isArray(connectionIds)) {
-        throw new TypeError('pipeline connection IDs object must include a connectionIds array.');
-    }
-    return connectionIds.map((item, index) => {
-        if (typeof item !== 'string' || item.trim().length === 0) {
-            throw new TypeError(`connectionIds[${index}] must be a non-empty string.`);
-        }
-        return item;
-    });
-}
-export function parsePipelineConnectionIdsJson(raw) {
-    const parsed = parseJsonValue(raw, 'connection IDs');
-    if (Array.isArray(parsed)) {
-        return parsed.map((item, index) => {
-            if (typeof item !== 'string' || item.trim().length === 0) {
-                throw new TypeError(`connection IDs[${index}] must be a non-empty string.`);
-            }
-            return item;
-        });
-    }
-    if (!parsed || typeof parsed !== 'object') {
-        throw new TypeError('connection IDs must be a JSON array or an object with connectionIds.');
-    }
-    const { connectionIds } = parsed;
-    if (!Array.isArray(connectionIds)) {
-        throw new TypeError('connection IDs object must include a connectionIds array.');
-    }
-    return connectionIds;
-}
-//# sourceMappingURL=pipeline-connection-flags.js.map
+import {modules} from './runtime.js';
+const buildPipelineConnectionCreateMutationPayload = modules["pipeline-connection-flags.js"]["buildPipelineConnectionCreateMutationPayload"]
+const buildPipelineConnectionCreatePayload = modules["pipeline-connection-flags.js"]["buildPipelineConnectionCreatePayload"]
+const buildPipelineConnectionUpdatePayload = modules["pipeline-connection-flags.js"]["buildPipelineConnectionUpdatePayload"]
+const parsePipelineConnectionIdsJson = modules["pipeline-connection-flags.js"]["parsePipelineConnectionIdsJson"]
+const parsePipelineConnectionMutationObject = modules["pipeline-connection-flags.js"]["parsePipelineConnectionMutationObject"]
+const parsePipelineConnectionUpdateObject = modules["pipeline-connection-flags.js"]["parsePipelineConnectionUpdateObject"]
+const pipelineConnectionCreateFlags = modules["pipeline-connection-flags.js"]["pipelineConnectionCreateFlags"]
+const pipelineConnectionDeleteFlags = modules["pipeline-connection-flags.js"]["pipelineConnectionDeleteFlags"]
+const pipelineConnectionMutationStringFlags = modules["pipeline-connection-flags.js"]["pipelineConnectionMutationStringFlags"]
+const pipelineConnectionUpdateFlags = modules["pipeline-connection-flags.js"]["pipelineConnectionUpdateFlags"]
+const readPipelineConnectionArrayFromFile = modules["pipeline-connection-flags.js"]["readPipelineConnectionArrayFromFile"]
+const readPipelineConnectionIdsFromFile = modules["pipeline-connection-flags.js"]["readPipelineConnectionIdsFromFile"]
+const readPipelineConnectionUpdateArrayFromFile = modules["pipeline-connection-flags.js"]["readPipelineConnectionUpdateArrayFromFile"]
+const validatePipelineConnectionCreatePayload = modules["pipeline-connection-flags.js"]["validatePipelineConnectionCreatePayload"]
+const validatePipelineConnectionUpdatePayload = modules["pipeline-connection-flags.js"]["validatePipelineConnectionUpdatePayload"]
+export {buildPipelineConnectionCreateMutationPayload, buildPipelineConnectionCreatePayload, buildPipelineConnectionUpdatePayload, parsePipelineConnectionIdsJson, parsePipelineConnectionMutationObject, parsePipelineConnectionUpdateObject, pipelineConnectionCreateFlags, pipelineConnectionDeleteFlags, pipelineConnectionMutationStringFlags, pipelineConnectionUpdateFlags, readPipelineConnectionArrayFromFile, readPipelineConnectionIdsFromFile, readPipelineConnectionUpdateArrayFromFile, validatePipelineConnectionCreatePayload, validatePipelineConnectionUpdatePayload};

package/dist/lib/pipeline-flags.js

@@ -1,154 +1,16 @@
-import { Flags } from '@oclif/core';
-import { buildListPaginationQuery, listPaginationFlags, } from './list-pagination.js';
-import { PIPELINE_CALCULATE_BASED_ON_VALUES, PIPELINE_PLATFORMS, } from './pipeline-types.js';
-export const pipelineListFlags = {
-    ...listPaginationFlags,
-    active: Flags.boolean({
-        allowNo: true,
-        description: 'Filter by active status',
-    }),
-    name: Flags.string({
-        description: 'Filter by pipeline name',
-    }),
-    platform: Flags.string({
-        description: 'Filter by pipeline platform',
-        options: [...PIPELINE_PLATFORMS],
-    }),
-};
-export function buildPipelineListFilters(flags) {
-    const filters = {};
-    if (typeof flags.name === 'string') {
-        filters.name = flags.name;
-    }
-    if (flags.active !== undefined) {
-        filters.active = flags.active;
-    }
-    if (typeof flags.platform === 'string') {
-        filters.platform = flags.platform;
-    }
-    return { ...filters, ...buildListPaginationQuery(flags) };
-}
-export const pipelineMutationBooleanFlags = {
-    active: Flags.boolean({
-        allowNo: true,
-        description: 'Whether the pipeline is active',
-    }),
-    'block-commits': Flags.boolean({
-        allowNo: true,
-        description: 'Block commits on the pipeline',
-    }),
-    'enable-smart-conflict-resolution': Flags.boolean({
-        allowNo: true,
-        description: 'Enable smart conflict resolution',
-    }),
-};
-export const pipelineMutationStringFlags = {
-    'calculate-based-on': Flags.string({
-        description: 'Promotion calculation basis',
-        options: [...PIPELINE_CALCULATE_BASED_ON_VALUES],
-    }),
-    'git-repository-id': Flags.string({
-        description: 'Git repository ID',
-    }),
-    'main-branch': Flags.string({
-        description: 'Main branch name',
-    }),
-    platform: Flags.string({
-        description: 'Pipeline platform',
-        options: [...PIPELINE_PLATFORMS],
-    }),
-};
-export const pipelineCreateFlags = {
-    ...pipelineMutationBooleanFlags,
-    ...pipelineMutationStringFlags,
-};
-export const pipelineUpdateFlags = {
-    ...pipelineMutationBooleanFlags,
-    ...pipelineMutationStringFlags,
-    name: Flags.string({
-        description: 'Pipeline name',
-    }),
-};
-const PIPELINE_FLAG_TO_PAYLOAD_KEY = {
-    active: 'active',
-    'block-commits': 'blockCommits',
-    'calculate-based-on': 'calculateBasedOn',
-    'enable-smart-conflict-resolution': 'enableSmartConflictResolution',
-    'git-repository-id': 'gitRepositoryId',
-    'main-branch': 'mainBranch',
-    name: 'name',
-    platform: 'platform',
-};
-const mutationFlagKeys = Object.keys(PIPELINE_FLAG_TO_PAYLOAD_KEY);
-export const PIPELINE_STRING_VALIDATION_KEYS = [
-    'calculateBasedOn',
-    'gitRepositoryId',
-    'mainBranch',
-    'name',
-    'platform',
-];
-export function buildPipelineCreatePayload(name, flags) {
-    return {
-        ...buildPipelineMutationPayload(flags),
-        name,
-    };
-}
-export function buildPipelineMutationPayload(flags) {
-    const payload = {};
-    for (const flagKey of mutationFlagKeys) {
-        const value = flags[flagKey];
-        if (value !== undefined) {
-            const payloadKey = PIPELINE_FLAG_TO_PAYLOAD_KEY[flagKey];
-            Object.assign(payload, { [payloadKey]: value });
-        }
-    }
-    return payload;
-}
-export function collectPipelineMutationFlagKeys(flags) {
-    const selected = [];
-    for (const key of mutationFlagKeys) {
-        if (flags[key] !== undefined) {
-            selected.push(key);
-        }
-    }
-    return selected;
-}
-export function validateNonEmptyStringFields(payload, keys) {
-    for (const key of keys) {
-        const value = payload[key];
-        if (typeof value === 'string' && value.trim().length === 0) {
-            return `${key} value cannot be empty`;
-        }
-    }
-    return undefined;
-}
-export function validatePipelinePlatform(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!PIPELINE_PLATFORMS.includes(value)) {
-        return `platform must be one of: ${PIPELINE_PLATFORMS.join(', ')}`;
-    }
-    return undefined;
-}
-export function validatePipelineCalculateBasedOn(value) {
-    if (value === undefined) {
-        return undefined;
-    }
-    if (!PIPELINE_CALCULATE_BASED_ON_VALUES.includes(value)) {
-        return `calculateBasedOn must be one of: ${PIPELINE_CALCULATE_BASED_ON_VALUES.join(', ')}`;
-    }
-    return undefined;
-}
-export function validatePipelineMutationPayload(payload) {
-    const platformError = validatePipelinePlatform(payload.platform);
-    if (platformError !== undefined) {
-        return platformError;
-    }
-    const calculateBasedOnError = validatePipelineCalculateBasedOn(payload.calculateBasedOn);
-    if (calculateBasedOnError !== undefined) {
-        return calculateBasedOnError;
-    }
-    return validateNonEmptyStringFields(payload, PIPELINE_STRING_VALIDATION_KEYS);
-}
-//# sourceMappingURL=pipeline-flags.js.map
+import {modules} from './runtime.js';
+const PIPELINE_STRING_VALIDATION_KEYS = modules["pipeline-flags.js"]["PIPELINE_STRING_VALIDATION_KEYS"]
+const buildPipelineCreatePayload = modules["pipeline-flags.js"]["buildPipelineCreatePayload"]
+const buildPipelineListFilters = modules["pipeline-flags.js"]["buildPipelineListFilters"]
+const buildPipelineMutationPayload = modules["pipeline-flags.js"]["buildPipelineMutationPayload"]
+const collectPipelineMutationFlagKeys = modules["pipeline-flags.js"]["collectPipelineMutationFlagKeys"]
+const pipelineCreateFlags = modules["pipeline-flags.js"]["pipelineCreateFlags"]
+const pipelineListFlags = modules["pipeline-flags.js"]["pipelineListFlags"]
+const pipelineMutationBooleanFlags = modules["pipeline-flags.js"]["pipelineMutationBooleanFlags"]
+const pipelineMutationStringFlags = modules["pipeline-flags.js"]["pipelineMutationStringFlags"]
+const pipelineUpdateFlags = modules["pipeline-flags.js"]["pipelineUpdateFlags"]
+const validateNonEmptyStringFields = modules["pipeline-flags.js"]["validateNonEmptyStringFields"]
+const validatePipelineCalculateBasedOn = modules["pipeline-flags.js"]["validatePipelineCalculateBasedOn"]
+const validatePipelineMutationPayload = modules["pipeline-flags.js"]["validatePipelineMutationPayload"]
+const validatePipelinePlatform = modules["pipeline-flags.js"]["validatePipelinePlatform"]
+export {PIPELINE_STRING_VALIDATION_KEYS, buildPipelineCreatePayload, buildPipelineListFilters, buildPipelineMutationPayload, collectPipelineMutationFlagKeys, pipelineCreateFlags, pipelineListFlags, pipelineMutationBooleanFlags, pipelineMutationStringFlags, pipelineUpdateFlags, validateNonEmptyStringFields, validatePipelineCalculateBasedOn, validatePipelineMutationPayload, validatePipelinePlatform};

package/dist/lib/pipeline-stage-connection-flags.js

@@ -1,46 +1,8 @@
-import { Flags } from '@oclif/core';
-export const pipelineStageConnectionMutationFlags = {
-    'next-pipeline-stage-connection-id': Flags.string({
-        description: 'Next pipeline stage connection ID',
-    }),
-    'stage-id': Flags.string({ description: 'Stage ID' }),
-};
-export const pipelineStageConnectionCreateFlags = {
-    ...pipelineStageConnectionMutationFlags,
-    'pipeline-id': Flags.string({ description: 'Pipeline ID', required: true }),
-};
-export const pipelineStageConnectionUpdateFlags = {
-    ...pipelineStageConnectionMutationFlags,
-    'pipeline-id': Flags.string({ description: 'Pipeline ID', required: true }),
-};
-export const pipelineStageConnectionDeleteFlags = {
-    'pipeline-id': Flags.string({ description: 'Pipeline ID', required: true }),
-    yes: Flags.boolean({
-        char: 'y',
-        default: false,
-        description: 'Confirm deletion without prompting',
-    }),
-};
-export function buildPipelineStageConnectionCreatePayload(flags) {
-    const stageId = flags['stage-id'];
-    if (stageId === undefined || stageId.trim().length === 0) {
-        throw new Error('stageId is required.');
-    }
-    const payload = { stageId };
-    if (flags['next-pipeline-stage-connection-id'] !== undefined) {
-        payload.nextPipelineStageConnectionId = flags['next-pipeline-stage-connection-id'];
-    }
-    return payload;
-}
-export function buildPipelineStageConnectionUpdatePayload(flags, connectionId) {
-    const payload = { id: connectionId };
-    if (flags['stage-id'] !== undefined)
-        payload.stageId = flags['stage-id'];
-    if (flags['next-pipeline-stage-connection-id'] !== undefined) {
-        payload.nextPipelineStageConnectionId = flags['next-pipeline-stage-connection-id'];
-    }
-    if (Object.keys(payload).length === 1)
-        throw new Error('Must provide at least one field to update.');
-    return payload;
-}
-//# sourceMappingURL=pipeline-stage-connection-flags.js.map
+import {modules} from './runtime.js';
+const buildPipelineStageConnectionCreatePayload = modules["pipeline-stage-connection-flags.js"]["buildPipelineStageConnectionCreatePayload"]
+const buildPipelineStageConnectionUpdatePayload = modules["pipeline-stage-connection-flags.js"]["buildPipelineStageConnectionUpdatePayload"]
+const pipelineStageConnectionCreateFlags = modules["pipeline-stage-connection-flags.js"]["pipelineStageConnectionCreateFlags"]
+const pipelineStageConnectionDeleteFlags = modules["pipeline-stage-connection-flags.js"]["pipelineStageConnectionDeleteFlags"]
+const pipelineStageConnectionMutationFlags = modules["pipeline-stage-connection-flags.js"]["pipelineStageConnectionMutationFlags"]
+const pipelineStageConnectionUpdateFlags = modules["pipeline-stage-connection-flags.js"]["pipelineStageConnectionUpdateFlags"]
+export {buildPipelineStageConnectionCreatePayload, buildPipelineStageConnectionUpdatePayload, pipelineStageConnectionCreateFlags, pipelineStageConnectionDeleteFlags, pipelineStageConnectionMutationFlags, pipelineStageConnectionUpdateFlags};