setup_execution_workflow.ts

import { isSafeBranchTree } from '../../../domain/deployment_configuration';
import { PendingPullRequestLinkError, pendingPullRequestParent } from '../../../domain/pull_request_issue_link_state';
import { ApplicationError } from '../../errors/application_error';
import type {
    SetupConfigurationQueryPort,
    SetupIssueQueryPort,
    SetupOrganizationQueryPort,
} from '../../ports/setup_execution_ports';
import { ACTIONS } from '../../../data/model/action_types';
import { restorePreviousBranchState } from '../../../data/model/previous_branch_state_policy';
import { ALL_ISSUE_WORKFLOWS, classifyIssueWorkflow } from '../../../domain/issue_workflow_profile';
import { setGlobalLoggerDebug } from '../../ports/logging_ports';
import type { ExecutionBranchVersionResolution } from './execution_branch_version_resolver';
import { resolveExecutionIssueNumber } from './resolve_execution_issue_number';
import type {
    SetupConfigurationPatch,
    SetupExecutionContext,
    SetupExecutionResult,
    SetupExecutionState,
    SetupHotfixState,
    SetupReleaseState,
} from './setup_execution_contracts';

export interface SetupExecutionDependencies {
    readonly issueSetupPort: SetupIssueQueryPort;
    readonly organizationSetupPort: SetupOrganizationQueryPort;
    readonly configurationPort: SetupConfigurationQueryPort;
    readonly branchVersionResolver: ExecutionBranchVersionResolution;
}

export async function runSetupExecution(
    context: SetupExecutionContext,
    dependencies: SetupExecutionDependencies,
): Promise<SetupExecutionResult> {
    setGlobalLoggerDebug(context.debug, context.local);
    const tokenUser = await loadTokenUser(context, dependencies.organizationSetupPort);
    const issueResolution = await resolveExecutionIssueNumber(context, dependencies.issueSetupPort);
    const isRepositorySetup = context.isSingleAction && context.singleAction.currentAction === ACTIONS.INITIAL_SETUP;
    const canConfigureUnlinkedPullRequest = context.isPullRequest && !isRepositorySetup
        && positiveIssueNumberOrUndefined(context.pullRequest.number) !== undefined;
    if (issueResolution.issueNumber === undefined && !canConfigureUnlinkedPullRequest) {
        return { status: 'issue-unresolved', tokenUser, issueResolution };
    }

    const previousConfiguration = await loadPreviousConfiguration(
        context,
        issueResolution.issueNumber,
        dependencies.configurationPort,
    );
    const currentIssueLabels = issueResolution.issueNumber === undefined
        ? []
        : await dependencies.issueSetupPort.getLabels(issueResolution.issueNumber);
    const liveIssueBody = issueResolution.issueNumber === undefined
        ? undefined
        : await dependencies.issueSetupPort.getDescription(issueResolution.issueNumber);
    const liveIssueTitle = issueResolution.issueNumber === undefined
        ? undefined
        : await dependencies.issueSetupPort.getTitle(issueResolution.issueNumber);
    const issueAdmission = issueResolution.issueNumber !== undefined
        ? classifyIssueWorkflow(currentIssueLabels, context.issueWorkflowProfile ?? ALL_ISSUE_WORKFLOWS, {
            feature: [context.labelNames.feature, context.labelNames.enhancement],
            bugfix: [context.labelNames.bugfix, context.labelNames.bug],
            documentation: [context.labelNames.documentation, context.labelNames.docs],
            chore: [context.labelNames.chore, context.labelNames.maintenance],
            help: [context.labelNames.help ?? 'help', context.labelNames.question ?? 'question'],
            hotfix: [context.labelNames.hotfix],
            release: [context.labelNames.release],
        }, liveIssueBody ?? '')
        : undefined;
    let release: SetupReleaseState = {
        ...context.release,
        active: currentIssueLabels.includes(context.labelNames.release),
    };
    let hotfix: SetupHotfixState = {
        ...context.hotfix,
        active: currentIssueLabels.includes(context.labelNames.hotfix),
    };
    const restored = restorePreviousBranchState(
        previousConfiguration,
        release.active ? 'release' : hotfix.active ? 'hotfix' : 'default',
        context.branches.releaseTree,
        context.branches.hotfixTree,
    );
    release = {
        ...release,
        version: restored.releaseVersion,
        branch: restored.releaseBranch,
    };
    hotfix = {
        ...hotfix,
        baseVersion: restored.hotfixBaseVersion,
        baseBranch: restored.hotfixBaseBranch,
        version: restored.hotfixVersion,
        branch: restored.hotfixBranch,
    };
    let configuration: SetupConfigurationPatch = {
        deploymentOrchestration: previousConfiguration?.deploymentOrchestration,
        releaseOriginBranch: previousConfiguration?.releaseOriginBranch,
        releaseOriginSha: previousConfiguration?.releaseOriginSha,
        hotfixOriginSha: previousConfiguration?.hotfixOriginSha,
        parentBranch: restored.parentBranch,
        workingBranch: restored.workingBranch,
        releaseBranch: restored.releaseBranch,
        hotfixOriginBranch: restored.hotfixBaseBranch,
        hotfixBranch: restored.hotfixBranch,
    };
    let currentPullRequestLabels = [...context.currentPullRequestLabels];
    let pullRequestParentBranch: string | undefined;

    if (context.isIssue && !context.isSingleAction && issueResolution.issueNumber !== undefined && issueAdmission?.status === 'eligible') {
        const resolution = await dependencies.branchVersionResolver.resolve({
            body: liveIssueBody,
            issueWorkflowProfile: context.issueWorkflowProfile,
            issueNumber: issueResolution.issueNumber,
            release,
            hotfix,
            branches: {
                releaseTree: context.branches.releaseTree,
                hotfixTree: context.branches.hotfixTree,
            },
            configuration,
        });
        release = resolution.release;
        hotfix = resolution.hotfix;
        configuration = resolution.configuration;
        if (!resolution.completed) {
            return {
                status: 'version-unresolved',
                tokenUser,
                issueResolution,
                state: setupState(
                    previousConfiguration,
                    currentIssueLabels,
                    currentPullRequestLabels,
                    release,
                    hotfix,
                    configuration,
                    liveIssueBody,
                    issueAdmission,
                    liveIssueTitle,
                ),
            };
        }
    }

    if (context.isPullRequest && !context.isSingleAction) {
        const pullRequestBody = await dependencies.issueSetupPort.getDescription(context.pullRequest.number);
        const pendingParent = pendingPullRequestParent(pullRequestBody ?? '', context.pullRequest.number,
            issueResolution.issueNumber ?? context.pullRequest.number);
        // An admitted issue's exact managed head retains parent authority even
        // if an older runtime already discarded the pending body record.
        const admitted = issueResolution.issueNumber !== undefined && issueAdmission?.status === 'eligible'
            && ['feature', 'bugfix', 'documentation', 'chore'].includes(issueAdmission.kind)
            ? await dependencies.configurationPort.get(issueResolution.issueNumber) : undefined;
        const resolvedHead = issueResolution.pullRequestHeadBranch || context.pullRequest.head;
        const admittedParent = admitted?.workingBranch === resolvedHead ? admitted?.parentBranch : undefined;
        if (admittedParent && !isSafeBranchTree(admittedParent)) {
            throw new ApplicationError('configuration.invalid', 'The admitted managed parent is not a safe branch.');
        }
        if (pendingParent && admittedParent && pendingParent !== admittedParent) {
            throw new PendingPullRequestLinkError('ownership');
        }
        pullRequestParentBranch = admittedParent;
        currentPullRequestLabels = await dependencies.issueSetupPort.getLabels(context.pullRequest.number);
        release = {
            ...release,
            active: context.pullRequest.base.includes(`${context.branches.releaseTree}/`),
        };
        hotfix = {
            ...hotfix,
            active: context.pullRequest.base.includes(`${context.branches.hotfixTree}/`),
        };
        configuration = {
            ...configuration,
            workingBranch: issueResolution.pullRequestHeadBranch || context.pullRequest.head || configuration.workingBranch,
            parentBranch: pendingParent ?? admittedParent ?? (context.pullRequest.base || configuration.parentBranch),
        };
    }

    return {
        status: 'configured',
        tokenUser,
        issueResolution,
        branchType: issueAdmission && issueAdmission.status !== 'eligible'
            ? ''
            : resolveIssueType(context, issueAdmission),
        state: setupState(
            previousConfiguration,
            currentIssueLabels,
            currentPullRequestLabels,
            release,
            hotfix,
            configuration,
            liveIssueBody,
            issueAdmission,
            liveIssueTitle,
            pullRequestParentBranch,
        ),
    };
}

async function loadTokenUser(
    context: SetupExecutionContext,
    organizationSetupPort: SetupOrganizationQueryPort,
): Promise<string> {
    if (context.tokenUser !== undefined) return context.tokenUser;
    const tokenUser = await organizationSetupPort.getTokenUser();
    if (!tokenUser) {
        throw new ApplicationError('authorization.credential-invalid', 'Failed to get user from token.');
    }
    return tokenUser;
}

async function loadPreviousConfiguration(
    context: SetupExecutionContext,
    resolvedIssueNumber: number | undefined,
    configurationPort: SetupConfigurationQueryPort,
) {
    const issueNumber = configurationIssueNumber(context, resolvedIssueNumber);
    return issueNumber === undefined ? undefined : configurationPort.get(issueNumber);
}

function configurationIssueNumber(
    context: SetupExecutionContext,
    resolvedIssueNumber: number | undefined,
): number | undefined {
    if (context.isSingleAction || context.isPush) return positiveIssueNumberOrUndefined(resolvedIssueNumber);
    if (context.isIssue) return positiveIssueNumberOrUndefined(context.issue.number);
    if (context.isPullRequest) return positiveIssueNumberOrUndefined(context.pullRequest.number);
    return undefined;
}

function resolveIssueType(
    context: SetupExecutionContext,
    admission: SetupExecutionState['issueWorkflowAdmission'],
): string {
    if (!admission || admission.status !== 'eligible' || admission.kind === 'help') return '';
    return ({
        feature: context.branches.featureTree,
        bugfix: context.branches.bugfixTree,
        documentation: context.branches.docsTree,
        chore: context.branches.choreTree,
        hotfix: context.branches.hotfixTree,
        release: context.branches.releaseTree,
    })[admission.kind];
}

function setupState(
    previousConfiguration: SetupExecutionState['previousConfiguration'],
    currentIssueLabels: readonly string[],
    currentPullRequestLabels: readonly string[],
    release: SetupReleaseState,
    hotfix: SetupHotfixState,
    configuration: SetupConfigurationPatch,
    liveIssueBody?: string,
    issueWorkflowAdmission?: SetupExecutionState['issueWorkflowAdmission'],
    liveIssueTitle?: string,
    pullRequestParentBranch?: string,
): SetupExecutionState {
    return {
        previousConfiguration,
        currentIssueLabels: [...currentIssueLabels],
        currentPullRequestLabels: [...currentPullRequestLabels],
        release: { ...release },
        hotfix: { ...hotfix },
        configuration: { ...configuration },
        liveIssueBody,
        liveIssueTitle,
        issueWorkflowAdmission,
        pullRequestParentBranch,
    };
}

function positiveIssueNumberOrUndefined(value: unknown): number | undefined {
    return typeof value === 'number' && value > 0 && Number.isSafeInteger(value) ? value : undefined;
}