projen 0.0.0

package/lib/release/release.js

@@ -0,0 +1,287 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Release = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const component_1 = require("../component");
+const github_1 = require("../github");
+const constants_1 = require("../github/constants");
+const workflows_model_1 = require("../github/workflows-model");
+const javascript_1 = require("../javascript");
+const version_1 = require("../version");
+const publisher_1 = require("./publisher");
+const release_trigger_1 = require("./release-trigger");
+const BUILD_JOBID = 'release';
+const GIT_REMOTE_STEPID = 'git_remote';
+const LATEST_COMMIT_OUTPUT = 'latest_commit';
+/**
+ * (experimental) Manages releases (currently through GitHub workflows).
+ *
+ * By default, no branches are released. To add branches, call `addBranch()`.
+ *
+ * @experimental
+ */
+class Release extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k;
+        super(project);
+        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 = project.github;
+        this.buildTask = options.task;
+        this.preBuildSteps = (_b = options.releaseWorkflowSetupSteps) !== null && _b !== void 0 ? _b : [];
+        this.postBuildSteps = (_c = options.postBuildSteps) !== null && _c !== void 0 ? _c : [];
+        this.antitamper = (_d = options.antitamper) !== null && _d !== void 0 ? _d : true;
+        this.artifactsDirectory = (_e = options.artifactsDirectory) !== null && _e !== void 0 ? _e : 'dist';
+        this.versionFile = options.versionFile;
+        this.releaseTrigger = (_f = options.releaseTrigger) !== null && _f !== void 0 ? _f : release_trigger_1.ReleaseTrigger.continuous();
+        this.containerImage = options.workflowContainerImage;
+        this.workflowRunsOn = options.workflowRunsOn;
+        /**
+         * 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 (!(((_g = options.releaseEveryCommit) !== null && _g !== void 0 ? _g : 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(project, {
+            versionInputFile: this.versionFile,
+            artifactsDirectory: this.artifactsDirectory,
+            versionrcOptions: options.versionrcOptions,
+        });
+        this.publisher = new publisher_1.Publisher(project, {
+            artifactName: this.artifactsDirectory,
+            condition: `needs.${BUILD_JOBID}.outputs.${LATEST_COMMIT_OUTPUT} == github.sha`,
+            buildJobId: BUILD_JOBID,
+            jsiiReleaseVersion: options.jsiiReleaseVersion,
+            failureIssue: options.releaseFailureIssue,
+            failureIssueLabel: options.releaseFailureIssueLabel,
+            workflowRunsOn: options.workflowRunsOn,
+            publishTasks: options.publishTasks,
+            dryRun: options.publishDryRun,
+        });
+        const githubRelease = (_h = options.githubRelease) !== null && _h !== void 0 ? _h : true;
+        if (githubRelease) {
+            this.publisher.publishToGitHubReleases({
+                changelogFile: path.posix.join(this.artifactsDirectory, this.version.changelogFileName),
+                versionFile: path.posix.join(this.artifactsDirectory, this.version.versionFileName),
+                releaseTagFile: path.posix.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,
+            workflowName: (_j = options.releaseWorkflowName) !== null && _j !== void 0 ? _j : 'release',
+            tagPrefix: options.releaseTagPrefix,
+            npmDistTag: options.npmDistTag,
+        });
+        for (const [name, opts] of Object.entries((_k = options.releaseBranches) !== null && _k !== void 0 ? _k : {})) {
+            this.addBranch(name, opts);
+        }
+    }
+    /**
+     * (experimental) 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.
+     * @experimental
+     */
+    addBranch(branch, options) {
+        this._addBranch(branch, options);
+    }
+    /**
+     * 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;
+    }
+    /**
+     * (experimental) Called before synthesis.
+     *
+     * @experimental
+     */
+    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);
+        }
+    }
+    /**
+     * (experimental) Adds jobs to all release workflows.
+     *
+     * @param jobs The jobs to add (name => job).
+     * @experimental
+     */
+    addJobs(jobs) {
+        for (const [name, job] of Object.entries(jobs)) {
+            this.jobs[name] = job;
+        }
+    }
+    /**
+     * (experimental) Retrieve all release branch names.
+     *
+     * @experimental
+     */
+    get branches() {
+        return this._branches.map(b => b.name);
+    }
+    /**
+     * @returns a workflow or `undefined` if github integration is disabled.
+     */
+    createWorkflow(branchName, branch) {
+        var _b;
+        const workflowName = (_b = branch.workflowName) !== null && _b !== void 0 ? _b : `release-${branchName}`;
+        // 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',
+        };
+        if (branch.majorVersion !== undefined) {
+            env.MAJOR = branch.majorVersion.toString();
+        }
+        if (branch.prerelease) {
+            env.PRERELEASE = branch.prerelease;
+        }
+        if (branch.tagPrefix) {
+            env.RELEASE_TAG_PREFIX = 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);
+        releaseTask.spawn(this.buildTask);
+        releaseTask.spawn(this.version.unbumpTask);
+        if (this.releaseTrigger.isManual) {
+            const publishTask = this.publisher.publishToGit({
+                changelogFile: path.posix.join(this.artifactsDirectory, this.version.changelogFileName),
+                versionFile: path.posix.join(this.artifactsDirectory, this.version.versionFileName),
+                releaseTagFile: path.posix.join(this.artifactsDirectory, this.version.releaseTagFileName),
+                projectChangelogFile: this.releaseTrigger.changelogPath,
+                gitBranch: branchName,
+                gitPushCommand: this.releaseTrigger.gitPushCommand,
+            });
+            releaseTask.spawn(publishTask);
+        }
+        // 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)
+        if (this.antitamper) {
+            releaseTask.exec('git diff --ignore-space-at-eol --exit-code');
+        }
+        const postBuildSteps = [...this.postBuildSteps];
+        // 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,
+            run: `echo ::set-output name=${LATEST_COMMIT_OUTPUT}::"$(git ls-remote origin -h \${{ github.ref }} | cut -f1)"`,
+        });
+        const paths = ['.', '!.git'];
+        if (this.project instanceof javascript_1.NodeProject) {
+            paths.push(
+            // node_modules takes forever to compress.
+            // instead, we skip it and re-install after downloading.
+            '!node_modules');
+        }
+        postBuildSteps.push({
+            name: 'Upload artifact',
+            if: noNewCommits,
+            uses: 'actions/upload-artifact@v2.1.1',
+            with: {
+                name: constants_1.BUILD_ARTIFACT_NAME,
+                path: paths.join('\n'),
+            },
+        });
+        if (this.github && !this.releaseTrigger.isManual) {
+            return new github_1.TaskWorkflow(this.github, {
+                name: workflowName,
+                jobId: BUILD_JOBID,
+                outputs: {
+                    latest_commit: {
+                        stepId: GIT_REMOTE_STEPID,
+                        outputName: LATEST_COMMIT_OUTPUT,
+                    },
+                },
+                triggers: {
+                    schedule: this.releaseTrigger.schedule ? [{ cron: this.releaseTrigger.schedule }] : undefined,
+                    push: this.releaseTrigger.isContinuous ? { branches: [branchName] } : undefined,
+                },
+                container: this.containerImage ? { image: this.containerImage } : undefined,
+                env: {
+                    CI: 'true',
+                },
+                permissions: {
+                    contents: workflows_model_1.JobPermission.WRITE,
+                },
+                checkoutWith: {
+                    // we must use 'fetch-depth=0' in order to fetch all tags
+                    // otherwise tags are not checked out
+                    'fetch-depth': 0,
+                },
+                preBuildSteps,
+                task: releaseTask,
+                postBuildSteps,
+                runsOn: this.workflowRunsOn,
+            });
+        }
+        else {
+            return undefined;
+        }
+    }
+}
+exports.Release = Release;
+_a = JSII_RTTI_SYMBOL_1;
+Release[_a] = { fqn: "projen.release.Release", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"release.js","sourceRoot":"","sources":["../../src/release/release.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { Component } from '../component';\nimport { GitHub, GitHubProject, GithubWorkflow, TaskWorkflow } from '../github';\nimport { BUILD_ARTIFACT_NAME } from '../github/constants';\nimport { Job, JobPermission, JobStep } from '../github/workflows-model';\nimport { NodeProject } from '../javascript';\nimport { Task } from '../task';\nimport { Version } from '../version';\nimport { Publisher } from './publisher';\nimport { ReleaseTrigger } from './release-trigger';\n\nconst BUILD_JOBID = 'release';\nconst GIT_REMOTE_STEPID = 'git_remote';\nconst LATEST_COMMIT_OUTPUT = 'latest_commit';\n\n                                       \nexport interface ReleaseProjectOptions {\n                                                                                                                                                                                                                 \n  readonly releaseEveryCommit?: boolean;\n\n                                                                                                                                                                                 \n  readonly releaseSchedule?: string;\n\n                                                                                                                     \n  readonly releaseTrigger?: ReleaseTrigger;\n\n                                                                                                  \n  readonly releaseWorkflowSetupSteps?: JobStep[];\n\n                                                                                                \n  readonly workflowContainerImage?: string;\n\n                                                                                                                      \n  readonly jsiiReleaseVersion?: string;\n\n                                                                                               \n  readonly postBuildSteps?: JobStep[];\n\n                                                                                               \n  readonly antitamper?: boolean;\n\n                                                                                                                                                                                                                                                                       \n  readonly majorVersion?: number;\n\n                                                                                                                                                        \n  readonly prerelease?: string;\n\n                                                                                                                                                                                                                       \n  readonly npmDistTag?: string;\n\n                                                                                       \n  readonly releaseWorkflowName?: string;\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            \n  readonly releaseBranches?: { [name: string]: BranchOptions };\n\n                                                                                                \n  readonly releaseFailureIssue?: boolean;\n\n                                                                                                                                                                  \n  readonly releaseFailureIssueLabel?: string;\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                \n  readonly releaseTagPrefix?: string;\n\n                                                                                                                                                                                                                                                                    \n  readonly versionrcOptions?: Record<string, any>;\n\n                                                                               \n  readonly workflowRunsOn?: string[];\n\n                                                                                                                                                                                                                                                                                 \n  readonly publishTasks?: boolean;\n\n                                                                                                                                \n  readonly publishDryRun?: boolean;\n}\n\n                                 \nexport interface ReleaseOptions extends ReleaseProjectOptions {\n                                                                                                                                                                                                  \n  readonly task: Task;\n\n                                                                                                                     \n  readonly versionFile: string;\n\n                                                                                                                                                                                                                                          \n  readonly branch: string;\n\n                                                                                  \n  readonly githubRelease?: boolean;\n\n\n                                                                                          \n  readonly artifactsDirectory: string;\n\n}\n\n                                                                                                                                                  \nexport class Release extends Component {\n                                   \n  public readonly publisher: Publisher;\n\n  private readonly buildTask: Task;\n  private readonly version: Version;\n  private readonly postBuildSteps: JobStep[];\n  private readonly antitamper: boolean;\n  private readonly versionFile: string;\n  private readonly releaseTrigger: ReleaseTrigger;\n  private readonly preBuildSteps: JobStep[];\n  private readonly containerImage?: string;\n  private readonly _branches = new Array<ReleaseBranch>();\n  private readonly jobs: Record<string, Job> = {};\n  private readonly defaultBranch: ReleaseBranch;\n  private readonly github?: GitHub;\n  private readonly workflowRunsOn?: string[];\n\n                                             \n  public readonly artifactsDirectory: string;\n\n  constructor(project: GitHubProject, options: ReleaseOptions) {\n    super(project);\n\n    if (Array.isArray(options.releaseBranches)) {\n      throw new Error('\"releaseBranches\" is no longer an array. See type annotations');\n    }\n\n    this.github = project.github;\n    this.buildTask = options.task;\n    this.preBuildSteps = options.releaseWorkflowSetupSteps ?? [];\n    this.postBuildSteps = options.postBuildSteps ?? [];\n    this.antitamper = options.antitamper ?? true;\n    this.artifactsDirectory = options.artifactsDirectory ?? 'dist';\n    this.versionFile = options.versionFile;\n    this.releaseTrigger = options.releaseTrigger ?? ReleaseTrigger.continuous();\n    this.containerImage = options.workflowContainerImage;\n    this.workflowRunsOn = options.workflowRunsOn;\n\n    /**\n     * Use manual releases with no changelog if releaseEveryCommit is explicitly\n     * disabled and no other trigger is set.\n     *\n     * TODO: Remove this when releaseEveryCommit and releaseSchedule are removed\n     */\n    if (!((options.releaseEveryCommit ?? true) || options.releaseSchedule || options.releaseTrigger)) {\n      this.releaseTrigger = ReleaseTrigger.manual({ changelog: false });\n    }\n\n    if (options.releaseSchedule) {\n      this.releaseTrigger = ReleaseTrigger.scheduled({ schedule: options.releaseSchedule });\n    }\n\n    this.version = new Version(project, {\n      versionInputFile: this.versionFile,\n      artifactsDirectory: this.artifactsDirectory,\n      versionrcOptions: options.versionrcOptions,\n    });\n\n    this.publisher = new Publisher(project, {\n      artifactName: this.artifactsDirectory,\n      condition: `needs.${BUILD_JOBID}.outputs.${LATEST_COMMIT_OUTPUT} == github.sha`,\n      buildJobId: BUILD_JOBID,\n      jsiiReleaseVersion: options.jsiiReleaseVersion,\n      failureIssue: options.releaseFailureIssue,\n      failureIssueLabel: options.releaseFailureIssueLabel,\n      workflowRunsOn: options.workflowRunsOn,\n      publishTasks: options.publishTasks,\n      dryRun: options.publishDryRun,\n    });\n\n    const githubRelease = options.githubRelease ?? true;\n    if (githubRelease) {\n      this.publisher.publishToGitHubReleases({\n        changelogFile: path.posix.join(this.artifactsDirectory, this.version.changelogFileName),\n        versionFile: path.posix.join(this.artifactsDirectory, this.version.versionFileName),\n        releaseTagFile: path.posix.join(this.artifactsDirectory, this.version.releaseTagFileName),\n      });\n    }\n\n    // add the default branch (we need the internal method which does not require majorVersion)\n    this.defaultBranch = this._addBranch(options.branch, {\n      prerelease: options.prerelease,\n      majorVersion: options.majorVersion,\n      workflowName: options.releaseWorkflowName ?? 'release',\n      tagPrefix: options.releaseTagPrefix,\n      npmDistTag: options.npmDistTag,\n    });\n\n    for (const [name, opts] of Object.entries(options.releaseBranches ?? {})) {\n      this.addBranch(name, opts);\n    }\n  }\n\n                                                                                                                                                                                                                                                                                                                                                                                                                  \n  public addBranch(branch: string, options: BranchOptions) {\n    this._addBranch(branch, options);\n  }\n\n  /**\n   * Adds a release branch.\n   *\n   * It is a git branch from which releases are published. If a project has more than one release\n   * branch, we require that `majorVersion` is also specified for the primary branch in order to\n   * ensure branches always release the correct version.\n   *\n   * @param branch The branch to monitor (e.g. `main`, `v2.x`)\n   * @param options Branch definition\n   */\n  private _addBranch(branch: string, options: Partial<BranchOptions>): ReleaseBranch {\n    if (this._branches.find(b => b.name === branch)) {\n      throw new Error(`The release branch ${branch} is already defined`);\n    }\n\n    // if we add a branch, we require that the default branch will also define a\n    // major version.\n    if (this.defaultBranch && options.majorVersion && this.defaultBranch.majorVersion === undefined) {\n      throw new Error('you must specify \"majorVersion\" for the default branch when adding multiple release branches');\n    }\n\n    const releaseBranch: ReleaseBranch = {\n      name: branch,\n      ...options,\n      workflow: this.createWorkflow(branch, options),\n    };\n\n    this._branches.push(releaseBranch);\n\n    return releaseBranch;\n  }\n\n  public preSynthesize() {\n    for (const branch of this._branches) {\n      if (!branch.workflow) {\n        continue;\n      }\n\n      branch.workflow.addJobs(this.publisher._renderJobsForBranch(branch.name, branch));\n      branch.workflow.addJobs(this.jobs);\n    }\n  }\n\n                                                                                                   \n  public addJobs(jobs: Record<string, Job>) {\n    for (const [name, job] of Object.entries(jobs)) {\n      this.jobs[name] = job;\n    }\n  }\n\n                                                  \n  public get branches(): string[] {\n    return this._branches.map(b => b.name);\n  }\n\n  /**\n   * @returns a workflow or `undefined` if github integration is disabled.\n   */\n  private createWorkflow(branchName: string, branch: Partial<BranchOptions>): TaskWorkflow | undefined {\n    const workflowName = branch.workflowName ?? `release-${branchName}`;\n\n    // to avoid race conditions between two commits trying to release the same\n    // version, we check if the head sha is identical to the remote sha. if\n    // not, we will skip the release and just finish the build.\n    const noNewCommits = `\\${{ steps.${GIT_REMOTE_STEPID}.outputs.${LATEST_COMMIT_OUTPUT} == github.sha }}`;\n\n    // The arrays are being cloned to avoid accumulating values from previous branches\n    const preBuildSteps = [...this.preBuildSteps];\n\n    const env: Record<string, string> = {\n      RELEASE: 'true',\n    };\n\n    if (branch.majorVersion !== undefined) {\n      env.MAJOR = branch.majorVersion.toString();\n    }\n\n    if (branch.prerelease) {\n      env.PRERELEASE = branch.prerelease;\n    }\n\n    if (branch.tagPrefix) {\n      env.RELEASE_TAG_PREFIX = branch.tagPrefix;\n    }\n\n    // the \"release\" task prepares a release but does not publish anything. the\n    // output of the release task is: `dist`, `.version.txt`, and\n    // `.changelog.md`. this is what publish tasks expect.\n\n    // if this is the release for \"main\" or \"master\", just call it \"release\".\n    // otherwise, \"release:BRANCH\"\n    const releaseTaskName = (branchName === 'main' || branchName === 'master') ? 'release' : `release:${branchName}`;\n    const releaseTask = this.project.addTask(releaseTaskName, {\n      description: `Prepare a release from \"${branchName}\" branch`,\n      env,\n    });\n\n    releaseTask.exec(`rm -fr ${this.artifactsDirectory}`);\n    releaseTask.spawn(this.version.bumpTask);\n    releaseTask.spawn(this.buildTask);\n    releaseTask.spawn(this.version.unbumpTask);\n\n    if (this.releaseTrigger.isManual) {\n      const publishTask = this.publisher.publishToGit({\n        changelogFile: path.posix.join(this.artifactsDirectory, this.version.changelogFileName),\n        versionFile: path.posix.join(this.artifactsDirectory, this.version.versionFileName),\n        releaseTagFile: path.posix.join(this.artifactsDirectory, this.version.releaseTagFileName),\n        projectChangelogFile: this.releaseTrigger.changelogPath,\n        gitBranch: branchName,\n        gitPushCommand: this.releaseTrigger.gitPushCommand,\n      });\n\n      releaseTask.spawn(publishTask);\n    }\n\n    // anti-tamper check (fails if there were changes to committed files)\n    // this will identify any non-committed files generated during build (e.g. test snapshots)\n    if (this.antitamper) {\n      releaseTask.exec('git diff --ignore-space-at-eol --exit-code');\n    }\n\n    const postBuildSteps = [...this.postBuildSteps];\n\n    // check if new commits were pushed to the repo while we were building.\n    // if new commits have been pushed, we will cancel this release\n    postBuildSteps.push({\n      name: 'Check for new commits',\n      id: GIT_REMOTE_STEPID,\n      run: `echo ::set-output name=${LATEST_COMMIT_OUTPUT}::\"$(git ls-remote origin -h \\${{ github.ref }} | cut -f1)\"`,\n    });\n\n    const paths = ['.', '!.git'];\n\n    if (this.project instanceof NodeProject) {\n      paths.push(\n        // node_modules takes forever to compress.\n        // instead, we skip it and re-install after downloading.\n        '!node_modules',\n      );\n    }\n\n    postBuildSteps.push({\n      name: 'Upload artifact',\n      if: noNewCommits,\n      uses: 'actions/upload-artifact@v2.1.1',\n      with: {\n        name: BUILD_ARTIFACT_NAME,\n        path: paths.join('\\n'),\n      },\n    });\n\n    if (this.github && !this.releaseTrigger.isManual) {\n      return new TaskWorkflow(this.github, {\n        name: workflowName,\n        jobId: BUILD_JOBID,\n        outputs: {\n          latest_commit: {\n            stepId: GIT_REMOTE_STEPID,\n            outputName: LATEST_COMMIT_OUTPUT,\n          },\n        },\n        triggers: {\n          schedule: this.releaseTrigger.schedule ? [{ cron: this.releaseTrigger.schedule }] : undefined,\n          push: this.releaseTrigger.isContinuous ? { branches: [branchName] } : undefined,\n        },\n        container: this.containerImage ? { image: this.containerImage } : undefined,\n        env: {\n          CI: 'true',\n        },\n        permissions: {\n          contents: JobPermission.WRITE,\n        },\n        checkoutWith: {\n          // we must use 'fetch-depth=0' in order to fetch all tags\n          // otherwise tags are not checked out\n          'fetch-depth': 0,\n        },\n        preBuildSteps,\n        task: releaseTask,\n        postBuildSteps,\n        runsOn: this.workflowRunsOn,\n      });\n    } else {\n      return undefined;\n    }\n  }\n}\n\n                                        \nexport interface BranchOptions {\n                                                                                 \n  readonly workflowName?: string;\n\n                                                              \n  readonly majorVersion: number;\n\n                                                                                            \n  readonly prerelease?: string;\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                \n  readonly tagPrefix?: string;\n\n                                                                                             \n  readonly npmDistTag?: string;\n}\n\ninterface ReleaseBranch extends Partial<BranchOptions> {\n  readonly workflow?: GithubWorkflow;\n  readonly name: string;\n}\n"]}

package/lib/release/reset-version.task.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/release/reset-version.task.js

@@ -0,0 +1,17 @@
+"use strict";
+// a builtin task that sets the "version" field of the file
+// specified in OUTFILE to "0.0.0"
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = require("fs");
+const fs_extra_1 = require("fs-extra");
+const outfile = process.env.OUTFILE;
+if (!outfile) {
+    throw new Error('OUTFILE is required');
+}
+if (!fs_extra_1.pathExistsSync(outfile)) {
+    process.exit(0); // nothing to do
+}
+const content = JSON.parse(fs_1.readFileSync(outfile, 'utf8'));
+content.version = '0.0.0';
+fs_1.writeFileSync(outfile, JSON.stringify(content, undefined, 2));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmVzZXQtdmVyc2lvbi50YXNrLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vc3JjL3JlbGVhc2UvcmVzZXQtdmVyc2lvbi50YXNrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7QUFBQSwyREFBMkQ7QUFDM0Qsa0NBQWtDOztBQUVsQywyQkFBaUQ7QUFDakQsdUNBQTBDO0FBRTFDLE1BQU0sT0FBTyxHQUFHLE9BQU8sQ0FBQyxHQUFHLENBQUMsT0FBTyxDQUFDO0FBQ3BDLElBQUksQ0FBQyxPQUFPLEVBQUU7SUFDWixNQUFNLElBQUksS0FBSyxDQUFDLHFCQUFxQixDQUFDLENBQUM7Q0FDeEM7QUFFRCxJQUFJLENBQUMseUJBQWMsQ0FBQyxPQUFPLENBQUMsRUFBRTtJQUM1QixPQUFPLENBQUMsSUFBSSxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsZ0JBQWdCO0NBQ2xDO0FBRUQsTUFBTSxPQUFPLEdBQUcsSUFBSSxDQUFDLEtBQUssQ0FBQyxpQkFBWSxDQUFDLE9BQU8sRUFBRSxNQUFNLENBQUMsQ0FBQyxDQUFDO0FBQzFELE9BQU8sQ0FBQyxPQUFPLEdBQUcsT0FBTyxDQUFDO0FBQzFCLGtCQUFhLENBQUMsT0FBTyxFQUFFLElBQUksQ0FBQyxTQUFTLENBQUMsT0FBTyxFQUFFLFNBQVMsRUFBRSxDQUFDLENBQUMsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiLy8gYSBidWlsdGluIHRhc2sgdGhhdCBzZXRzIHRoZSBcInZlcnNpb25cIiBmaWVsZCBvZiB0aGUgZmlsZVxuLy8gc3BlY2lmaWVkIGluIE9VVEZJTEUgdG8gXCIwLjAuMFwiXG5cbmltcG9ydCB7IHJlYWRGaWxlU3luYywgd3JpdGVGaWxlU3luYyB9IGZyb20gJ2ZzJztcbmltcG9ydCB7IHBhdGhFeGlzdHNTeW5jIH0gZnJvbSAnZnMtZXh0cmEnO1xuXG5jb25zdCBvdXRmaWxlID0gcHJvY2Vzcy5lbnYuT1VURklMRTtcbmlmICghb3V0ZmlsZSkge1xuICB0aHJvdyBuZXcgRXJyb3IoJ09VVEZJTEUgaXMgcmVxdWlyZWQnKTtcbn1cblxuaWYgKCFwYXRoRXhpc3RzU3luYyhvdXRmaWxlKSkge1xuICBwcm9jZXNzLmV4aXQoMCk7IC8vIG5vdGhpbmcgdG8gZG9cbn1cblxuY29uc3QgY29udGVudCA9IEpTT04ucGFyc2UocmVhZEZpbGVTeW5jKG91dGZpbGUsICd1dGY4JykpO1xuY29udGVudC52ZXJzaW9uID0gJzAuMC4wJztcbndyaXRlRmlsZVN5bmMob3V0ZmlsZSwgSlNPTi5zdHJpbmdpZnkoY29udGVudCwgdW5kZWZpbmVkLCAyKSk7XG4iXX0=

package/lib/release/tag-version.d.ts

@@ -0,0 +1,31 @@
+export interface TagOptions {
+    /**
+     * Path to release tag file housing the release version.
+     *
+     * Relative to cwd.
+     *
+     * @example `dist/releaseTag.txt`
+     */
+    readonly releaseTagFile: string;
+    /**
+     * Path to release-specific changelog file.
+     *
+     * Relative to cwd.
+     *
+     * @example `dist/changelog.md`
+     */
+    readonly changelog: string;
+}
+/**
+ * Generate an annotated release tag using version and changelog files.
+ *
+ * The tag will be normalized to the format "v<version>" where version comes
+ * from the provided version file.
+ *
+ * The tag annotation message will be set to the content of the provided release
+ * changelog file.
+ *
+ * @param cwd working directory (git repository)
+ * @param options options
+ */
+export declare function tag(cwd: string, options: TagOptions): Promise<void>;

package/lib/release/tag-version.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tag = void 0;
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const utils = require("../util");
+/**
+ * Generate an annotated release tag using version and changelog files.
+ *
+ * The tag will be normalized to the format "v<version>" where version comes
+ * from the provided version file.
+ *
+ * The tag annotation message will be set to the content of the provided release
+ * changelog file.
+ *
+ * @param cwd working directory (git repository)
+ * @param options options
+ */
+async function tag(cwd, options) {
+    const git = (cmd) => utils.exec(`git ${cmd}`, { cwd: cwd });
+    const releaseTagFilePath = path_1.join(cwd, options.releaseTagFile);
+    const changelogFilePath = path_1.join(cwd, options.changelog);
+    if (!fs_extra_1.pathExists(releaseTagFilePath)) {
+        throw new Error(`No release tag file present at ${releaseTagFilePath}`);
+    }
+    if (!fs_extra_1.pathExists(changelogFilePath)) {
+        throw new Error(`No changelog file present at ${changelogFilePath}`);
+    }
+    let releaseTag = (await utils.tryReadFile(releaseTagFilePath)).trim();
+    if (!releaseTag) {
+        throw new Error(`No version present in file at ${releaseTagFilePath}`);
+    }
+    git(`tag ${releaseTag} -a -F ${changelogFilePath}`);
+}
+exports.tag = tag;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/release/tag-version.task.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/release/tag-version.task.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Generate an annotated release tag using version and changelog files.
+ *
+ * The tag from the release tag from the release tag file will be used as is.
+ *
+ * The tag annotation message will be set to the content of the provided changelog
+ * file.
+ *
+ * Environment variables:
+ *
+ * - RELEASE_TAG_FILE: Release Tag file containing the bumped release tag
+ * - CHANGELOG_FILE: Changelog to be used for tag annotation
+ *
+ */
+const tag_version_1 = require("./tag-version");
+const changelog = process.env.CHANGELOG;
+const releaseTagFile = process.env.RELEASE_TAG_FILE;
+if (!releaseTagFile) {
+    throw new Error('RELEASE_TAG_FILE is required');
+}
+if (!changelog) {
+    throw new Error('CHANGELOG is required');
+}
+const opts = {
+    changelog,
+    releaseTagFile: releaseTagFile,
+};
+tag_version_1.tag(process.cwd(), opts).catch((e) => {
+    console.log(e.stack);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/release/update-changelog.d.ts

@@ -0,0 +1,36 @@
+export interface UpdateChangelogOptions {
+    /**
+     * Path to input changelog entry file.
+     *
+     * Relative to cwd.
+     *
+     * @example dist/changelog.md
+     */
+    inputChangelog: string;
+    /**
+     * Path to project-level changelog.
+     *
+     * The contents of inputChangelog will be prepended onto
+     * this changelog.
+     *
+     * Relative to cwd
+     *
+     * @example changelog.md
+     */
+    outputChangelog: string;
+    /**
+     * Release version.
+     */
+    versionFile: string;
+}
+/**
+ * Prepends input changelog entry onto project-level changelog.
+ *
+ * Currently assumes a headerless changelog formatted according to
+ * [conventional-changelog](https://github.com/conventional-changelog/conventional-changelog)
+ * rules.
+ *
+ * @param cwd working directory (git repository)
+ * @param options options
+ */
+export declare function updateChangelog(cwd: string, options: UpdateChangelogOptions): Promise<void>;

package/lib/release/update-changelog.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateChangelog = void 0;
+const path_1 = require("path");
+const fs_extra_1 = require("fs-extra");
+const logging = require("../logging");
+const utils = require("../util");
+/**
+ * Prepends input changelog entry onto project-level changelog.
+ *
+ * Currently assumes a headerless changelog formatted according to
+ * [conventional-changelog](https://github.com/conventional-changelog/conventional-changelog)
+ * rules.
+ *
+ * @param cwd working directory (git repository)
+ * @param options options
+ */
+async function updateChangelog(cwd, options) {
+    const inputChangelog = path_1.join(cwd, options.inputChangelog);
+    const outputChangelog = path_1.join(cwd, options.outputChangelog);
+    const versionFile = path_1.join(cwd, options.versionFile);
+    let version = (await utils.tryReadFile(versionFile)).trim();
+    if (!version) {
+        throw new Error(`Unable to determine version from ${versionFile}. Cannot proceed with changelog update. Did you run 'bump'?`);
+    }
+    const inputChangelogContent = await fs_extra_1.readFile(inputChangelog, 'utf-8');
+    const changelogVersionSearchPattern = `[${version}]`;
+    if (!inputChangelogContent.includes(changelogVersionSearchPattern)) {
+        throw new Error(`Supplied version ${version} was not found in input changelog. You may want to check it's content.`);
+    }
+    const outputChangelogContent = await fs_extra_1.readFile(outputChangelog, 'utf-8');
+    if (outputChangelogContent.indexOf(changelogVersionSearchPattern) > -1) {
+        logging.info(`Changelog already contains an entry for ${version}. Skipping changelog update.`);
+        return;
+    }
+    const newChangelog = inputChangelogContent.trimEnd() + '\n\n' + outputChangelogContent.trimStart();
+    await fs_extra_1.writeFile(outputChangelog, newChangelog);
+    utils.exec(`git add ${outputChangelog} && git commit -m "chore(release): ${version}"`, { cwd });
+}
+exports.updateChangelog = updateChangelog;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/release/update-changelog.task.d.ts

@@ -0,0 +1 @@
+export {};

package/lib/release/update-changelog.task.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+/**
+ * Prepends the release changelog entry onto the provided project-level changelog
+ *
+ * Currently assumes a headerless changelog formatted according to
+ * [conventional-changelog](https://github.com/conventional-changelog/conventional-changelog)
+ * rules.
+ *
+ * Environment variables:
+ *
+ * - VERSION_FILE: Current semantic version file
+ * - CHANGELOG_FILE: Release changelog
+ * - PROJECT_CHANGELOG_FILE: Project-level changelog
+ *
+ */
+const update_changelog_1 = require("./update-changelog");
+const inputChangelog = process.env.CHANGELOG;
+const outputChangelog = process.env.PROJECT_CHANGELOG_FILE;
+const versionFile = process.env.VERSION_FILE;
+if (!versionFile) {
+    throw new Error('VERSION_FILE is required');
+}
+if (!inputChangelog) {
+    throw new Error('CHANGELOG is required');
+}
+if (!outputChangelog) {
+    throw new Error('PROJECT_CHANGELOG_FILE is required');
+}
+const opts = {
+    inputChangelog,
+    outputChangelog,
+    versionFile: versionFile,
+};
+update_changelog_1.updateChangelog(process.cwd(), opts).catch((e) => {
+    console.log(e.stack);
+    process.exit(1);
+});
+//# sourceMappingURL=data:application/json;base64,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

package/lib/run-projenrc-json.task.d.ts

@@ -0,0 +1 @@
+export {};