projen
Version:
CDK for software projects
381 lines • 69.7 kB
JavaScript
"use strict";
var _a;
Object.defineProperty(exports, "__esModule", { value: true });
exports.Release = void 0;
const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
const posixPath = require("node:path/posix");
const publisher_1 = require("./publisher");
const release_trigger_1 = require("./release-trigger");
const consts_1 = require("../build/private/consts");
const component_1 = require("../component");
const github_1 = require("../github");
const constants_1 = require("../github/constants");
const util_1 = require("../github/private/util");
const workflows_model_1 = require("../github/workflows-model");
const runner_options_1 = require("../runner-options");
const name_1 = require("../util/name");
const version_1 = require("../version");
const BUILD_JOBID = "release";
const GIT_REMOTE_STEPID = "git_remote";
const TAG_EXISTS_STEPID = "check_tag_exists";
const LATEST_COMMIT_OUTPUT = "latest_commit";
const TAG_EXISTS_OUTPUT = "tag_exists";
/**
* Conditional (Github Workflow Job `if`) to check if a release job should be run.
*/
const DEPENDENT_JOB_CONDITIONAL = `needs.${BUILD_JOBID}.outputs.${TAG_EXISTS_OUTPUT} != 'true' && needs.${BUILD_JOBID}.outputs.${LATEST_COMMIT_OUTPUT} == github.sha`;
/**
* Manages releases (currently through GitHub workflows).
*
* By default, no branches are released. To add branches, call `addBranch()`.
*/
class Release extends component_1.Component {
/**
* Returns the `Release` component of a project or `undefined` if the project
* does not have a Release component.
*/
static of(project) {
const isRelease = (c) => c instanceof Release;
return project.components.find(isRelease);
}
/**
* @param scope should be part of the project the Release belongs to.
* @param options options to configure the Release Component.
*/
constructor(scope, options) {
super(scope);
this._branches = new Array();
this.jobs = {};
if (Array.isArray(options.releaseBranches)) {
throw new Error('"releaseBranches" is no longer an array. See type annotations');
}
this.github = github_1.GitHub.of(this.project.root);
// Handle both deprecated task and new tasks options
if (options.tasks) {
this.buildTasks = options.tasks;
}
else if (options.task) {
this.buildTasks = [options.task];
}
else {
throw new Error("Either 'tasks' or 'task' must be provided, but not both.");
}
this.preBuildSteps = options.releaseWorkflowSetupSteps ?? [];
this.postBuildSteps = options.postBuildSteps ?? [];
this.artifactsDirectory =
options.artifactsDirectory ?? consts_1.DEFAULT_ARTIFACTS_DIRECTORY;
(0, util_1.ensureNotHiddenPath)(this.artifactsDirectory, "artifactsDirectory");
this.versionFile = options.versionFile;
this.releaseTrigger = options.releaseTrigger ?? release_trigger_1.ReleaseTrigger.continuous();
this.containerImage = options.workflowContainerImage;
this.workflowRunsOn = options.workflowRunsOn;
this.workflowRunsOnGroup = options.workflowRunsOnGroup;
this.workflowPermissions = {
contents: workflows_model_1.JobPermission.WRITE,
...options.workflowPermissions,
};
this.releaseWorkflowEnv = options.releaseWorkflowEnv;
this._branchHooks = [];
/**
* Use manual releases with no changelog if releaseEveryCommit is explicitly
* disabled and no other trigger is set.
*
* TODO: Remove this when releaseEveryCommit and releaseSchedule are removed
*/
if (!((options.releaseEveryCommit ?? true) ||
options.releaseSchedule ||
options.releaseTrigger)) {
this.releaseTrigger = release_trigger_1.ReleaseTrigger.manual({ changelog: false });
}
if (options.releaseSchedule) {
this.releaseTrigger = release_trigger_1.ReleaseTrigger.scheduled({
schedule: options.releaseSchedule,
});
}
this.version = new version_1.Version(this.project, {
versionInputFile: this.versionFile,
artifactsDirectory: this.artifactsDirectory,
versionrcOptions: options.versionrcOptions,
tagPrefix: options.releaseTagPrefix,
releasableCommits: options.releasableCommits,
bumpPackage: options.bumpPackage,
nextVersionCommand: options.nextVersionCommand,
});
this.releaseTagFilePath = posixPath.normalize(posixPath.join(this.artifactsDirectory, this.version.releaseTagFileName));
this.publisher = new publisher_1.Publisher(this.project, {
artifactName: this.artifactsDirectory,
condition: DEPENDENT_JOB_CONDITIONAL,
buildJobId: BUILD_JOBID,
jsiiReleaseVersion: options.jsiiReleaseVersion,
failureIssue: options.releaseFailureIssue,
failureIssueLabel: options.releaseFailureIssueLabel,
...(0, runner_options_1.filteredWorkflowRunsOnOptions)(options.workflowRunsOn, options.workflowRunsOnGroup),
publishTasks: options.publishTasks,
dryRun: options.publishDryRun,
workflowNodeVersion: options.workflowNodeVersion,
workflowContainerImage: options.workflowContainerImage,
});
const githubRelease = options.githubRelease ?? true;
if (githubRelease) {
this.publisher.publishToGitHubReleases({
changelogFile: posixPath.join(this.artifactsDirectory, this.version.changelogFileName),
versionFile: posixPath.join(this.artifactsDirectory, this.version.versionFileName),
releaseTagFile: posixPath.join(this.artifactsDirectory, this.version.releaseTagFileName),
});
}
// add the default branch (we need the internal method which does not require majorVersion)
this.defaultBranch = this._addBranch(options.branch, {
prerelease: options.prerelease,
majorVersion: options.majorVersion,
minMajorVersion: options.minMajorVersion,
workflowName: options.releaseWorkflowName ??
(0, name_1.workflowNameForProject)("release", this.project),
environment: options.releaseEnvironment,
tagPrefix: options.releaseTagPrefix,
npmDistTag: options.npmDistTag,
});
for (const [name, opts] of Object.entries(options.releaseBranches ?? {})) {
this.addBranch(name, {
environment: options.releaseEnvironment,
...opts,
});
}
}
/**
* Add a hook that should be run for every branch (including those that will
* be added by future `addBranch` calls).
* @internal
*/
_forEachBranch(hook) {
for (const branch of this._branches) {
hook(branch.name);
}
this._branchHooks.push(hook);
}
/**
* Adds a release branch.
*
* It is a git branch from which releases are published. If a project has more than one release
* branch, we require that `majorVersion` is also specified for the primary branch in order to
* ensure branches always release the correct version.
*
* @param branch The branch to monitor (e.g. `main`, `v2.x`)
* @param options Branch definition
*/
addBranch(branch, options) {
this._addBranch(branch, options);
// run all branch hooks
for (const hook of this._branchHooks) {
hook(branch);
}
}
/**
* Adds a release branch.
*
* It is a git branch from which releases are published. If a project has more than one release
* branch, we require that `majorVersion` is also specified for the primary branch in order to
* ensure branches always release the correct version.
*
* @param branch The branch to monitor (e.g. `main`, `v2.x`)
* @param options Branch definition
*/
_addBranch(branch, options) {
if (this._branches.find((b) => b.name === branch)) {
throw new Error(`The release branch ${branch} is already defined`);
}
// if we add a branch, we require that the default branch will also define a
// major version.
if (this.defaultBranch &&
options.majorVersion &&
this.defaultBranch.majorVersion === undefined) {
throw new Error('you must specify "majorVersion" for the default branch when adding multiple release branches');
}
const releaseBranch = {
name: branch,
...options,
workflow: this.createWorkflow(branch, options),
};
this._branches.push(releaseBranch);
return releaseBranch;
}
preSynthesize() {
for (const branch of this._branches) {
if (!branch.workflow) {
continue;
}
branch.workflow.addJobs(this.publisher._renderJobsForBranch(branch.name, branch));
branch.workflow.addJobs(this.jobs);
}
}
/**
* Adds jobs to all release workflows.
* @param jobs The jobs to add (name => job)
*/
addJobs(jobs) {
for (const [name, job] of Object.entries(jobs)) {
this.jobs[name] = job;
}
}
/**
* Retrieve all release branch names
*/
get branches() {
return this._branches.map((b) => b.name);
}
/**
* @returns a workflow or `undefined` if github integration is disabled.
*/
createWorkflow(branchName, branch) {
const workflowName = branch.workflowName ??
(0, name_1.workflowNameForProject)(`release-${branchName}`, this.project);
// to avoid race conditions between two commits trying to release the same
// version, we check if the head sha is identical to the remote sha. if
// not, we will skip the release and just finish the build.
const noNewCommits = `\${{ steps.${GIT_REMOTE_STEPID}.outputs.${LATEST_COMMIT_OUTPUT} == github.sha }}`;
// The arrays are being cloned to avoid accumulating values from previous branches
const preBuildSteps = [...this.preBuildSteps];
const env = {
RELEASE: "true",
...this.version.envForBranch({
majorVersion: branch.majorVersion,
minorVersion: branch.minorVersion,
minMajorVersion: branch.minMajorVersion,
prerelease: branch.prerelease,
tagPrefix: branch.tagPrefix,
}),
};
// the "release" task prepares a release but does not publish anything. the
// output of the release task is: `dist`, `.version.txt`, and
// `.changelog.md`. this is what publish tasks expect.
// if this is the release for "main" or "master", just call it "release".
// otherwise, "release:BRANCH"
const releaseTaskName = branchName === "main" || branchName === "master"
? "release"
: `release:${branchName}`;
const releaseTask = this.project.addTask(releaseTaskName, {
description: `Prepare a release from "${branchName}" branch`,
env,
});
releaseTask.exec(`rm -fr ${this.artifactsDirectory}`);
releaseTask.spawn(this.version.bumpTask);
// Spawn all build tasks
for (const buildTask of this.buildTasks) {
releaseTask.spawn(buildTask);
}
releaseTask.spawn(this.version.unbumpTask);
// anti-tamper check (fails if there were changes to committed files)
// this will identify any non-committed files generated during build (e.g. test snapshots)
releaseTask.exec(Release.ANTI_TAMPER_CMD);
if (this.releaseTrigger.isManual) {
const publishTask = this.publisher.publishToGit({
changelogFile: posixPath.join(this.artifactsDirectory, this.version.changelogFileName),
versionFile: posixPath.join(this.artifactsDirectory, this.version.versionFileName),
releaseTagFile: posixPath.join(this.artifactsDirectory, this.version.releaseTagFileName),
projectChangelogFile: this.releaseTrigger.changelogPath,
gitBranch: branchName,
gitPushCommand: this.releaseTrigger.gitPushCommand,
});
releaseTask.spawn(publishTask);
}
const postBuildSteps = [...this.postBuildSteps];
// Read the releasetag, then check if it already exists.
// If it does, we will cancel this release
postBuildSteps.push(github_1.WorkflowSteps.tagExists(`$(cat ${this.releaseTagFilePath})`, {
name: "Check if version has already been tagged",
id: TAG_EXISTS_STEPID,
}));
// check if new commits were pushed to the repo while we were building.
// if new commits have been pushed, we will cancel this release
postBuildSteps.push({
name: "Check for new commits",
id: GIT_REMOTE_STEPID,
shell: "bash",
run: [
`echo "${LATEST_COMMIT_OUTPUT}=$(git ls-remote origin -h \${{ github.ref }} | cut -f1)" >> $GITHUB_OUTPUT`,
"cat $GITHUB_OUTPUT",
].join("\n"),
});
const projectPathRelativeToRoot = (0, util_1.projectPathRelativeToRepoRoot)(this.project);
postBuildSteps.push({
name: "Backup artifact permissions",
if: noNewCommits,
continueOnError: true,
run: `cd ${this.artifactsDirectory} && getfacl -R . > ${constants_1.PERMISSION_BACKUP_FILE}`,
}, github_1.WorkflowSteps.uploadArtifact({
if: noNewCommits,
with: {
name: constants_1.BUILD_ARTIFACT_NAME,
path: this.project.parent // is subproject
? posixPath.join(projectPathRelativeToRoot, this.artifactsDirectory)
: this.artifactsDirectory,
},
}));
if (this.github && !this.releaseTrigger.isManual) {
// Use target (possible parent) GitHub to create the workflow
const workflow = new github_1.GithubWorkflow(this.github, workflowName, {
// see https://github.com/projen/projen/issues/3761
limitConcurrency: true,
});
workflow.on({
schedule: this.releaseTrigger.schedule
? [{ cron: this.releaseTrigger.schedule }]
: undefined,
push: this.releaseTrigger.isContinuous || this.releaseTrigger.tags
? {
branches: [branchName],
tags: this.releaseTrigger.tags,
paths: this.releaseTrigger.paths,
}
: undefined,
workflowDispatch: {}, // allow manual triggering
});
// Create job based on child (only?) project GitHub
const taskjob = new github_1.TaskWorkflowJob(this, releaseTask, {
outputs: {
[LATEST_COMMIT_OUTPUT]: {
stepId: GIT_REMOTE_STEPID,
outputName: LATEST_COMMIT_OUTPUT,
},
[TAG_EXISTS_OUTPUT]: {
stepId: TAG_EXISTS_STEPID,
outputName: "exists",
},
},
container: this.containerImage
? { image: this.containerImage }
: undefined,
env: {
CI: "true",
...this.releaseWorkflowEnv,
},
permissions: this.workflowPermissions,
checkoutWith: {
// fetch-depth= indicates all history for all branches and tags
// we must use this in order to fetch all tags
// and to inspect the history to decide if we should release
fetchDepth: 0,
},
preBuildSteps,
postBuildSteps,
jobDefaults: this.project.parent // is subproject
? {
run: {
workingDirectory: projectPathRelativeToRoot,
},
}
: undefined,
...(0, runner_options_1.filteredRunsOnOptions)(this.workflowRunsOn, this.workflowRunsOnGroup),
});
workflow.addJob(BUILD_JOBID, taskjob);
return workflow;
}
else {
return undefined;
}
}
}
exports.Release = Release;
_a = JSII_RTTI_SYMBOL_1;
Release[_a] = { fqn: "projen.release.Release", version: "0.99.17" };
Release.ANTI_TAMPER_CMD = "git diff --ignore-space-at-eol --exit-code";
//# sourceMappingURL=data:application/json;base64,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