projen 0.0.0

package/lib/javascript/upgrade-dependencies.d.ts

@@ -0,0 +1,252 @@
+import { Component } from '../component';
+import { GithubWorkflow, GitIdentity, workflows } from '../github';
+import { ContainerOptions, JobStep } from '../github/workflows-model';
+import { NodeProject } from '../javascript';
+/**
+ * (experimental) Options for `UpgradeDependencies`.
+ *
+ * @experimental
+ */
+export interface UpgradeDependenciesOptions {
+    /**
+     * (experimental) List of package names to exclude during the upgrade.
+     *
+     * @default - Nothing is excluded.
+     * @experimental
+     */
+    readonly exclude?: string[];
+    /**
+     * (experimental) List of package names to include during the upgrade.
+     *
+     * @default - Everything is included.
+     * @experimental
+     */
+    readonly include?: string[];
+    /**
+     * (experimental) Include a github workflow for creating PR's that upgrades the required dependencies, either by manual dispatch, or by a schedule.
+     *
+     * If this is `false`, only a local projen task is created, which can be executed manually to
+     * upgrade the dependencies.
+     *
+     * @default - true for root projects, false for sub-projects.
+     * @experimental
+     */
+    readonly workflow?: boolean;
+    /**
+     * (experimental) Options for the github workflow.
+     *
+     * Only applies if `workflow` is true.
+     *
+     * @default - default options.
+     * @experimental
+     */
+    readonly workflowOptions?: UpgradeDependenciesWorkflowOptions;
+    /**
+     * (experimental) The name of the task that will be created.
+     *
+     * This will also be the workflow name.
+     *
+     * @default "upgrade".
+     * @experimental
+     */
+    readonly taskName?: string;
+    /**
+     * (experimental) Title of the pull request to use (should be all lower-case).
+     *
+     * @default "upgrade dependencies"
+     * @experimental
+     */
+    readonly pullRequestTitle?: string;
+    /**
+     * (experimental) Whether or not to ignore projen upgrades.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly ignoreProjen?: boolean;
+    /**
+     * (experimental) Add Signed-off-by line by the committer at the end of the commit log message.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly signoff?: boolean;
+}
+/**
+ * (experimental) Upgrade node project dependencies.
+ *
+ * @experimental
+ */
+export declare class UpgradeDependencies extends Component {
+    /**
+     * (experimental) The workflows that execute the upgrades.
+     *
+     * One workflow per branch.
+     *
+     * @experimental
+     */
+    readonly workflows: GithubWorkflow[];
+    private readonly options;
+    private readonly _project;
+    private readonly pullRequestTitle;
+    /**
+     * (experimental) Whether or not projen is also upgraded in this workflow,.
+     *
+     * @experimental
+     */
+    readonly ignoresProjen: boolean;
+    /**
+     * (experimental) Container definitions for the upgrade workflow.
+     *
+     * @experimental
+     */
+    containerOptions?: ContainerOptions;
+    private readonly gitIdentity;
+    private readonly postBuildSteps;
+    /**
+     * @experimental
+     */
+    constructor(project: NodeProject, options?: UpgradeDependenciesOptions);
+    /**
+     * (experimental) Add steps to execute a successful build.
+     *
+     * @param steps worklfow steps.
+     * @experimental
+     */
+    addPostBuildSteps(...steps: JobStep[]): void;
+    /**
+     * (experimental) Called before synthesis.
+     *
+     * @experimental
+     */
+    preSynthesize(): void;
+    private createTask;
+    private createWorkflow;
+    private createUpgrade;
+    private createPr;
+}
+/**
+ * (experimental) Options for `UpgradeDependencies.workflowOptions`.
+ *
+ * @experimental
+ */
+export interface UpgradeDependenciesWorkflowOptions {
+    /**
+     * (experimental) Schedule to run on.
+     *
+     * @default UpgradeDependenciesSchedule.DAILY
+     * @experimental
+     */
+    readonly schedule?: UpgradeDependenciesSchedule;
+    /**
+     * (experimental) Which secret to use when creating the PR.
+     *
+     * When using the default github token, PR's created by this workflow
+     * will not trigger any subsequent workflows (i.e the build workflow).
+     * This is why this workflow also runs 'build' by default, and manually updates
+     * the status check of the PR.
+     *
+     * If you pass a token that has the `workflow` permissions, you can skip running
+     * build in this workflow by specifying `rebuild: false`.
+     *
+     * @default - default github token.
+     * @see https://github.com/peter-evans/create-pull-request/issues/48
+     * @experimental
+     */
+    readonly secret?: string;
+    /**
+     * (experimental) Labels to apply on the PR.
+     *
+     * @default - no labels.
+     * @experimental
+     */
+    readonly labels?: string[];
+    /**
+     * (experimental) Execute 'build' after the upgrade.
+     *
+     * When true, the workflow will run the project build task after the dependency upgrade.
+     * This means that the PR created will include any changes caused by the `build` command,
+     * (e.g project synth changes, test snapshots)
+     *
+     * This is necessary when using the default github token.
+     *
+     * @default true
+     * @see `secret` for more details.
+     * @experimental
+     */
+    readonly rebuild?: boolean;
+    /**
+     * (experimental) Job container options.
+     *
+     * @default - defaults
+     * @experimental
+     */
+    readonly container?: workflows.ContainerOptions;
+    /**
+     * (experimental) List of branches to create PR's for.
+     *
+     * @default - All release branches configured for the project.
+     * @experimental
+     */
+    readonly branches?: string[];
+    /**
+     * (experimental) The git identity to use for commits.
+     *
+     * @default "github-actions
+     * @experimental
+     * @github .com"
+     */
+    readonly gitIdentity?: GitIdentity;
+    /**
+     * (experimental) Github Runner selection labels.
+     *
+     * @default ["ubuntu-latest"]
+     * @experimental
+     */
+    readonly runsOn?: string[];
+}
+/**
+ * (experimental) How often to check for new versions and raise pull requests for version upgrades.
+ *
+ * @experimental
+ */
+export declare class UpgradeDependenciesSchedule {
+    readonly cron: string[];
+    /**
+     * (experimental) Disables automatic upgrades.
+     *
+     * @experimental
+     */
+    static readonly NEVER: UpgradeDependenciesSchedule;
+    /**
+     * (experimental) At 00:00.
+     *
+     * @experimental
+     */
+    static readonly DAILY: UpgradeDependenciesSchedule;
+    /**
+     * (experimental) At 00:00 on every day-of-week from Monday through Friday.
+     *
+     * @experimental
+     */
+    static readonly WEEKDAY: UpgradeDependenciesSchedule;
+    /**
+     * (experimental) At 00:00 on Monday.
+     *
+     * @experimental
+     */
+    static readonly WEEKLY: UpgradeDependenciesSchedule;
+    /**
+     * (experimental) At 00:00 on day-of-month 1.
+     *
+     * @experimental
+     */
+    static readonly MONTHLY: UpgradeDependenciesSchedule;
+    /**
+     * (experimental) Create a schedule from a raw cron expression.
+     *
+     * @experimental
+     */
+    static expressions(cron: string[]): UpgradeDependenciesSchedule;
+    private constructor();
+}

package/lib/javascript/upgrade-dependencies.js

@@ -0,0 +1,341 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UpgradeDependenciesSchedule = exports.UpgradeDependencies = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("../component");
+const github_1 = require("../github");
+const constants_1 = require("../github/constants");
+function context(value) {
+    return `\${{ ${value} }}`;
+}
+function setOutput(name, value) {
+    return `echo "::set-output name=${name}::${value}"`;
+}
+const RUNNER_TEMP = context('runner.temp');
+const DEFAULT_TOKEN = context('secrets.GITHUB_TOKEN');
+const REPO = context('github.repository');
+const RUN_ID = context('github.run_id');
+const RUN_URL = `https://github.com/${REPO}/actions/runs/${RUN_ID}`;
+/**
+ * (experimental) Upgrade node project dependencies.
+ *
+ * @experimental
+ */
+class UpgradeDependencies extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options = {}) {
+        var _c, _d, _e, _f, _g;
+        super(project);
+        /**
+         * (experimental) The workflows that execute the upgrades.
+         *
+         * One workflow per branch.
+         *
+         * @experimental
+         */
+        this.workflows = [];
+        this._project = project;
+        this.options = options;
+        this.pullRequestTitle = (_c = options.pullRequestTitle) !== null && _c !== void 0 ? _c : 'upgrade dependencies';
+        this.ignoresProjen = (_d = this.options.ignoreProjen) !== null && _d !== void 0 ? _d : true;
+        this.gitIdentity = (_f = (_e = options.workflowOptions) === null || _e === void 0 ? void 0 : _e.gitIdentity) !== null && _f !== void 0 ? _f : constants_1.DEFAULT_GITHUB_ACTIONS_USER;
+        this.postBuildSteps = [];
+        this.containerOptions = (_g = options.workflowOptions) === null || _g === void 0 ? void 0 : _g.container;
+        project.addDevDeps('npm-check-updates@^12');
+    }
+    /**
+     * (experimental) Add steps to execute a successful build.
+     *
+     * @param steps worklfow steps.
+     * @experimental
+     */
+    addPostBuildSteps(...steps) {
+        this.postBuildSteps.push(...steps);
+    }
+    // create the upgrade task and a corresponding github workflow
+    // for each requested branch.
+    /**
+     * (experimental) Called before synthesis.
+     *
+     * @experimental
+     */
+    preSynthesize() {
+        var _c, _d, _e, _f, _g;
+        const task = this.createTask();
+        if (this._project.github && ((_c = this.options.workflow) !== null && _c !== void 0 ? _c : true)) {
+            // represents the default repository branch.
+            // just like not specifying anything.
+            const defaultBranch = undefined;
+            const branches = (_e = (_d = this.options.workflowOptions) === null || _d === void 0 ? void 0 : _d.branches) !== null && _e !== void 0 ? _e : ((_g = (_f = this._project.release) === null || _f === void 0 ? void 0 : _f.branches) !== null && _g !== void 0 ? _g : [defaultBranch]);
+            for (const branch of branches) {
+                this.workflows.push(this.createWorkflow(task, this._project.github, branch));
+            }
+        }
+    }
+    createTask() {
+        var _c, _d;
+        const taskName = (_c = this.options.taskName) !== null && _c !== void 0 ? _c : 'upgrade';
+        const task = this._project.addTask(taskName, {
+            // this task should not run in CI mode because its designed to
+            // update package.json and lock files.
+            env: { CI: '0' },
+            description: this.pullRequestTitle,
+        });
+        const exclude = (_d = this.options.exclude) !== null && _d !== void 0 ? _d : [];
+        if (this.ignoresProjen) {
+            exclude.push('projen');
+        }
+        for (const dep of ['dev', 'optional', 'peer', 'prod', 'bundle']) {
+            const ncuCommand = ['npm-check-updates', '--dep', dep, '--upgrade', '--target=minor'];
+            if (exclude.length > 0) {
+                ncuCommand.push(`--reject='${exclude.join(',')}'`);
+            }
+            if (this.options.include) {
+                ncuCommand.push(`--filter='${this.options.include.join(',')}'`);
+            }
+            task.exec(ncuCommand.join(' '));
+        }
+        // run "yarn/npm install" to update the lockfile and install any deps (such as projen)
+        task.exec(this._project.package.installAndUpdateLockfileCommand);
+        // run upgrade command to upgrade transitive deps as well
+        task.exec(this._project.package.renderUpgradePackagesCommand(exclude, this.options.include));
+        // run "projen" to give projen a chance to update dependencies (it will also run "yarn install")
+        task.exec(this._project.projenCommand);
+        return task;
+    }
+    createWorkflow(task, github, branch) {
+        var _c, _d;
+        const schedule = (_d = (_c = this.options.workflowOptions) === null || _c === void 0 ? void 0 : _c.schedule) !== null && _d !== void 0 ? _d : UpgradeDependenciesSchedule.DAILY;
+        const workflowName = `${task.name}${branch ? `-${branch.replace(/\//g, '-')}` : ''}`;
+        const workflow = github.addWorkflow(workflowName);
+        const triggers = {
+            workflowDispatch: {},
+            schedule: schedule.cron ? schedule.cron.map(e => ({ cron: e })) : undefined,
+        };
+        workflow.on(triggers);
+        const upgrade = this.createUpgrade(task, branch);
+        const pr = this.createPr(workflow, upgrade);
+        const jobs = {};
+        jobs[upgrade.jobId] = upgrade.job;
+        jobs[pr.jobId] = pr.job;
+        workflow.addJobs(jobs);
+        return workflow;
+    }
+    createUpgrade(task, branch) {
+        var _c, _d, _e, _f;
+        const build = (_d = (_c = this.options.workflowOptions) === null || _c === void 0 ? void 0 : _c.rebuild) !== null && _d !== void 0 ? _d : true;
+        const runsOn = (_f = (_e = this.options.workflowOptions) === null || _e === void 0 ? void 0 : _e.runsOn) !== null && _f !== void 0 ? _f : ['ubuntu-latest'];
+        const patchFile = '.upgrade.tmp.patch';
+        const buildStepId = 'build';
+        const conclusion = 'conclusion';
+        // thats all we should need at this stage since all we do is clone.
+        // note that this also prevents new code that is introduced in the upgrade
+        // to have write access to anything, in case its somehow executed. (for example during build)
+        const permissions = {
+            contents: github_1.workflows.JobPermission.READ,
+        };
+        const outputs = {};
+        const steps = [
+            {
+                name: 'Checkout',
+                uses: 'actions/checkout@v2',
+                with: branch ? { ref: branch } : undefined,
+            },
+            constants_1.setGitIdentityStep(this.gitIdentity),
+            ...this._project.installWorkflowSteps,
+            {
+                name: 'Upgrade dependencies',
+                run: this._project.runTaskCommand(task),
+            },
+        ];
+        if (build) {
+            steps.push({
+                name: 'Build',
+                id: buildStepId,
+                run: `${this._project.runTaskCommand(this._project.buildTask)} && ${setOutput(conclusion, 'success')} || ${setOutput(conclusion, 'failure')}`,
+            });
+            outputs[conclusion] = {
+                stepId: buildStepId,
+                outputName: conclusion,
+            };
+        }
+        steps.push(...this.postBuildSteps);
+        steps.push({
+            name: 'Create Patch',
+            run: [
+                'git add .',
+                `git diff --patch --staged > ${patchFile}`,
+            ].join('\n'),
+        }, {
+            name: 'Upload patch',
+            uses: 'actions/upload-artifact@v2',
+            with: { name: patchFile, path: patchFile },
+        });
+        return {
+            job: {
+                name: 'Upgrade',
+                container: this.containerOptions,
+                permissions: permissions,
+                runsOn: runsOn !== null && runsOn !== void 0 ? runsOn : ['ubuntu-latest'],
+                outputs: outputs,
+                steps: steps,
+            },
+            jobId: 'upgrade',
+            patchFile: patchFile,
+            build: build,
+            buildConclusionOutput: conclusion,
+            ref: branch,
+        };
+    }
+    createPr(workflow, upgrade) {
+        var _c, _d, _e, _f, _g, _h;
+        const customToken = ((_c = this.options.workflowOptions) === null || _c === void 0 ? void 0 : _c.secret) ? context(`secrets.${this.options.workflowOptions.secret}`) : undefined;
+        const runsOn = (_e = (_d = this.options.workflowOptions) === null || _d === void 0 ? void 0 : _d.runsOn) !== null && _e !== void 0 ? _e : ['ubuntu-latest'];
+        const workflowName = workflow.name;
+        const branchName = `github-actions/${workflowName}`;
+        const prStepId = 'create-pr';
+        const title = `chore(deps): ${this.pullRequestTitle}`;
+        const description = [
+            'Upgrades project dependencies. See details in [workflow run].',
+            '',
+            `[Workflow Run]: ${RUN_URL}`,
+            '',
+            '------',
+            '',
+            `*Automatically created by projen via the "${workflow.name}" workflow*`,
+        ].join('\n');
+        const comitter = `${this.gitIdentity.name} <${this.gitIdentity.email}>`;
+        const steps = [
+            {
+                name: 'Checkout',
+                uses: 'actions/checkout@v2',
+                with: upgrade.ref ? { ref: upgrade.ref } : undefined,
+            },
+            constants_1.setGitIdentityStep(this.gitIdentity),
+            {
+                name: 'Download patch',
+                uses: 'actions/download-artifact@v2',
+                with: { name: upgrade.patchFile, path: RUNNER_TEMP },
+            },
+            {
+                name: 'Apply patch',
+                run: `[ -s ${RUNNER_TEMP}/${upgrade.patchFile} ] && git apply ${RUNNER_TEMP}/${upgrade.patchFile} || echo "Empty patch. Skipping."`,
+            },
+            {
+                name: 'Create Pull Request',
+                id: prStepId,
+                uses: 'peter-evans/create-pull-request@v3',
+                with: {
+                    // the pr can modify workflow files, so we need to use the custom
+                    // secret if one is configured.
+                    'token': customToken !== null && customToken !== void 0 ? customToken : DEFAULT_TOKEN,
+                    'commit-message': `${title}\n\n${description}`,
+                    'branch': branchName,
+                    'title': title,
+                    'labels': ((_g = (_f = this.options.workflowOptions) === null || _f === void 0 ? void 0 : _f.labels) === null || _g === void 0 ? void 0 : _g.join(',')) || undefined,
+                    'body': description,
+                    'author': comitter,
+                    'committer': comitter,
+                    'signoff': (_h = this.options.signoff) !== null && _h !== void 0 ? _h : true,
+                },
+            },
+        ];
+        let writeChecksPermission = false;
+        if (this._project.buildWorkflowJobId && upgrade.build) {
+            const body = {
+                name: this._project.buildWorkflowJobId,
+                head_sha: branchName,
+                status: 'completed',
+                conclusion: context(`needs.${upgrade.jobId}.outputs.${upgrade.buildConclusionOutput}`),
+                output: {
+                    title: `Created via the ${workflowName} workflow.`,
+                    summary: `Action run URL: ${RUN_URL}`,
+                },
+            };
+            steps.push({
+                name: 'Update status check',
+                if: `steps.${prStepId}.outputs.pull-request-url != \'\'`,
+                run: 'curl -i --fail '
+                    + '-X POST '
+                    + '-H "Accept: application/vnd.github.v3+json" '
+                    + `-H "Authorization: token \${GITHUB_TOKEN}" https://api.github.com/repos/${REPO}/check-runs `
+                    + `-d '${JSON.stringify(body)}'`,
+                env: { GITHUB_TOKEN: DEFAULT_TOKEN },
+            });
+            // necessary to update status checks
+            writeChecksPermission = true;
+        }
+        return {
+            job: {
+                name: 'Create Pull Request',
+                needs: [upgrade.jobId],
+                permissions: {
+                    contents: github_1.workflows.JobPermission.WRITE,
+                    pullRequests: github_1.workflows.JobPermission.WRITE,
+                    checks: writeChecksPermission ? github_1.workflows.JobPermission.WRITE : undefined,
+                },
+                runsOn: runsOn !== null && runsOn !== void 0 ? runsOn : ['ubuntu-latest'],
+                steps: steps,
+            },
+            jobId: 'pr',
+        };
+    }
+}
+exports.UpgradeDependencies = UpgradeDependencies;
+_a = JSII_RTTI_SYMBOL_1;
+UpgradeDependencies[_a] = { fqn: "projen.javascript.UpgradeDependencies", version: "0.46.8" };
+/**
+ * (experimental) How often to check for new versions and raise pull requests for version upgrades.
+ *
+ * @experimental
+ */
+class UpgradeDependenciesSchedule {
+    constructor(cron) {
+        this.cron = cron;
+    }
+    /**
+     * (experimental) Create a schedule from a raw cron expression.
+     *
+     * @experimental
+     */
+    static expressions(cron) {
+        return new UpgradeDependenciesSchedule(cron);
+    }
+}
+exports.UpgradeDependenciesSchedule = UpgradeDependenciesSchedule;
+_b = JSII_RTTI_SYMBOL_1;
+UpgradeDependenciesSchedule[_b] = { fqn: "projen.javascript.UpgradeDependenciesSchedule", version: "0.46.8" };
+/**
+ * (experimental) Disables automatic upgrades.
+ *
+ * @experimental
+ */
+UpgradeDependenciesSchedule.NEVER = new UpgradeDependenciesSchedule([]);
+/**
+ * (experimental) At 00:00.
+ *
+ * @experimental
+ */
+UpgradeDependenciesSchedule.DAILY = new UpgradeDependenciesSchedule(['0 0 * * *']);
+/**
+ * (experimental) At 00:00 on every day-of-week from Monday through Friday.
+ *
+ * @experimental
+ */
+UpgradeDependenciesSchedule.WEEKDAY = new UpgradeDependenciesSchedule(['0 0 * * 1-5']);
+/**
+ * (experimental) At 00:00 on Monday.
+ *
+ * @experimental
+ */
+UpgradeDependenciesSchedule.WEEKLY = new UpgradeDependenciesSchedule(['0 0 * * 1']);
+/**
+ * (experimental) At 00:00 on day-of-month 1.
+ *
+ * @experimental
+ */
+UpgradeDependenciesSchedule.MONTHLY = new UpgradeDependenciesSchedule(['0 0 1 * *']);
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"upgrade-dependencies.js","sourceRoot":"","sources":["../../src/javascript/upgrade-dependencies.ts"],"names":[],"mappings":"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","sourcesContent":["import { Component } from '../component';\nimport { GitHub, GithubWorkflow, GitIdentity, workflows } from '../github';\nimport { DEFAULT_GITHUB_ACTIONS_USER, setGitIdentityStep } from '../github/constants';\nimport { ContainerOptions, JobStep } from '../github/workflows-model';\nimport { NodeProject } from '../javascript';\nimport { Task } from '../task';\n\nfunction context(value: string) {\n  return `\\${{ ${value} }}`;\n}\n\nfunction setOutput(name: string, value: string) {\n  return `echo \"::set-output name=${name}::${value}\"`;\n}\n\nconst RUNNER_TEMP = context('runner.temp');\nconst DEFAULT_TOKEN = context('secrets.GITHUB_TOKEN');\nconst REPO = context('github.repository');\nconst RUN_ID = context('github.run_id');\nconst RUN_URL = `https://github.com/${REPO}/actions/runs/${RUN_ID}`;\n\n                                             \nexport interface UpgradeDependenciesOptions {\n\n                                                                                                               \n  readonly exclude?: string[];\n\n                                                                                                                  \n  readonly include?: string[];\n\n                                                                                                                                                                                                                                                                                                                                                                \n  readonly workflow?: boolean;\n\n                                                                                                                           \n  readonly workflowOptions?: UpgradeDependenciesWorkflowOptions;\n\n                                                                                                                                   \n  readonly taskName?: string;\n\n                                                                                                                       \n  readonly pullRequestTitle?: string;\n\n                                                                                  \n  readonly ignoreProjen?: boolean;\n\n                                                                                                                      \n  readonly signoff?: boolean;\n}\n\n                                             \nexport class UpgradeDependencies extends Component {\n\n                                                                                  \n  public readonly workflows: GithubWorkflow[] = [];\n\n  private readonly options: UpgradeDependenciesOptions;\n  private readonly _project: NodeProject;\n  private readonly pullRequestTitle: string;\n\n                                                                         \n  public readonly ignoresProjen: boolean;\n\n                                                                \n  public containerOptions?: ContainerOptions;\n\n  private readonly gitIdentity: GitIdentity;\n  private readonly postBuildSteps: JobStep[];\n\n  constructor(project: NodeProject, options: UpgradeDependenciesOptions = {}) {\n    super(project);\n\n    this._project = project;\n    this.options = options;\n    this.pullRequestTitle = options.pullRequestTitle ?? 'upgrade dependencies';\n    this.ignoresProjen = this.options.ignoreProjen ?? true;\n    this.gitIdentity = options.workflowOptions?.gitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n    this.postBuildSteps = [];\n    this.containerOptions = options.workflowOptions?.container;\n\n    project.addDevDeps('npm-check-updates@^12');\n  }\n\n                                                                                          \n  public addPostBuildSteps(...steps: JobStep[]) {\n    this.postBuildSteps.push(...steps);\n  }\n\n  // create the upgrade task and a corresponding github workflow\n  // for each requested branch.\n  public preSynthesize() {\n    const task = this.createTask();\n    if (this._project.github && (this.options.workflow ?? true)) {\n      // represents the default repository branch.\n      // just like not specifying anything.\n      const defaultBranch = undefined;\n\n      const branches = this.options.workflowOptions?.branches ?? (this._project.release?.branches ?? [defaultBranch]);\n      for (const branch of branches) {\n        this.workflows.push(this.createWorkflow(task, this._project.github, branch));\n      }\n    }\n  }\n\n  private createTask(): Task {\n    const taskName = this.options.taskName ?? 'upgrade';\n    const task = this._project.addTask(taskName, {\n      // this task should not run in CI mode because its designed to\n      // update package.json and lock files.\n      env: { CI: '0' },\n      description: this.pullRequestTitle,\n    });\n\n    const exclude = this.options.exclude ?? [];\n    if (this.ignoresProjen) {\n      exclude.push('projen');\n    }\n\n    for (const dep of ['dev', 'optional', 'peer', 'prod', 'bundle']) {\n\n      const ncuCommand = ['npm-check-updates', '--dep', dep, '--upgrade', '--target=minor'];\n      if (exclude.length > 0) {\n        ncuCommand.push(`--reject='${exclude.join(',')}'`);\n      }\n      if (this.options.include) {\n        ncuCommand.push(`--filter='${this.options.include.join(',')}'`);\n      }\n\n      task.exec(ncuCommand.join(' '));\n\n    }\n\n    // run \"yarn/npm install\" to update the lockfile and install any deps (such as projen)\n    task.exec(this._project.package.installAndUpdateLockfileCommand);\n\n    // run upgrade command to upgrade transitive deps as well\n    task.exec(this._project.package.renderUpgradePackagesCommand(exclude, this.options.include));\n\n    // run \"projen\" to give projen a chance to update dependencies (it will also run \"yarn install\")\n    task.exec(this._project.projenCommand);\n\n    return task;\n  }\n\n  private createWorkflow(task: Task, github: GitHub, branch?: string): GithubWorkflow {\n    const schedule = this.options.workflowOptions?.schedule ?? UpgradeDependenciesSchedule.DAILY;\n\n    const workflowName = `${task.name}${branch ? `-${branch.replace(/\\//g, '-')}` : ''}`;\n    const workflow = github.addWorkflow(workflowName);\n    const triggers: workflows.Triggers = {\n      workflowDispatch: {},\n      schedule: schedule.cron ? schedule.cron.map(e => ({ cron: e })) : undefined,\n    };\n    workflow.on(triggers);\n\n    const upgrade = this.createUpgrade(task, branch);\n    const pr = this.createPr(workflow, upgrade);\n\n    const jobs: Record<string, workflows.Job> = {};\n    jobs[upgrade.jobId] = upgrade.job;\n    jobs[pr.jobId] = pr.job;\n\n    workflow.addJobs(jobs);\n    return workflow;\n  }\n\n  private createUpgrade(task: Task, branch?: string): Upgrade {\n    const build = this.options.workflowOptions?.rebuild ?? true;\n    const runsOn = this.options.workflowOptions?.runsOn ?? ['ubuntu-latest'];\n    const patchFile = '.upgrade.tmp.patch';\n    const buildStepId = 'build';\n    const conclusion = 'conclusion';\n\n    // thats all we should need at this stage since all we do is clone.\n    // note that this also prevents new code that is introduced in the upgrade\n    // to have write access to anything, in case its somehow executed. (for example during build)\n    const permissions: workflows.JobPermissions = {\n      contents: workflows.JobPermission.READ,\n    };\n\n    const outputs: Record<string, workflows.JobStepOutput> = {};\n    const steps: workflows.JobStep[] = [\n      {\n        name: 'Checkout',\n        uses: 'actions/checkout@v2',\n        with: branch ? { ref: branch } : undefined,\n      },\n      setGitIdentityStep(this.gitIdentity),\n      ...this._project.installWorkflowSteps,\n      {\n        name: 'Upgrade dependencies',\n        run: this._project.runTaskCommand(task),\n      },\n    ];\n\n    if (build) {\n      steps.push({\n        name: 'Build',\n        id: buildStepId,\n        run: `${this._project.runTaskCommand(this._project.buildTask)} && ${setOutput(conclusion, 'success')} || ${setOutput(conclusion, 'failure')}`,\n      });\n\n      outputs[conclusion] = {\n        stepId: buildStepId,\n        outputName: conclusion,\n      };\n    }\n\n    steps.push(...this.postBuildSteps);\n\n    steps.push(\n      {\n        name: 'Create Patch',\n        run: [\n          'git add .',\n          `git diff --patch --staged > ${patchFile}`,\n        ].join('\\n'),\n      },\n      {\n        name: 'Upload patch',\n        uses: 'actions/upload-artifact@v2',\n        with: { name: patchFile, path: patchFile },\n      },\n    );\n\n    return {\n      job: {\n        name: 'Upgrade',\n        container: this.containerOptions,\n        permissions: permissions,\n        runsOn: runsOn ?? ['ubuntu-latest'],\n        outputs: outputs,\n        steps: steps,\n      },\n      jobId: 'upgrade',\n      patchFile: patchFile,\n      build: build,\n      buildConclusionOutput: conclusion,\n      ref: branch,\n    };\n  }\n\n  private createPr(workflow: GithubWorkflow, upgrade: Upgrade): PR {\n\n    const customToken = this.options.workflowOptions?.secret ? context(`secrets.${this.options.workflowOptions.secret}`) : undefined;\n    const runsOn = this.options.workflowOptions?.runsOn ?? ['ubuntu-latest'];\n    const workflowName = workflow.name;\n    const branchName = `github-actions/${workflowName}`;\n    const prStepId = 'create-pr';\n\n    const title = `chore(deps): ${this.pullRequestTitle}`;\n    const description = [\n      'Upgrades project dependencies. See details in [workflow run].',\n      '',\n      `[Workflow Run]: ${RUN_URL}`,\n      '',\n      '------',\n      '',\n      `*Automatically created by projen via the \"${workflow.name}\" workflow*`,\n    ].join('\\n');\n\n    const comitter = `${this.gitIdentity.name} <${this.gitIdentity.email}>`;\n\n    const steps: workflows.JobStep[] = [\n      {\n        name: 'Checkout',\n        uses: 'actions/checkout@v2',\n        with: upgrade.ref ? { ref: upgrade.ref } : undefined,\n      },\n      setGitIdentityStep(this.gitIdentity),\n      {\n        name: 'Download patch',\n        uses: 'actions/download-artifact@v2',\n        with: { name: upgrade.patchFile, path: RUNNER_TEMP },\n      },\n      {\n        name: 'Apply patch',\n        run: `[ -s ${RUNNER_TEMP}/${upgrade.patchFile} ] && git apply ${RUNNER_TEMP}/${upgrade.patchFile} || echo \"Empty patch. Skipping.\"`,\n      },\n      {\n        name: 'Create Pull Request',\n        id: prStepId,\n        uses: 'peter-evans/create-pull-request@v3',\n        with: {\n          // the pr can modify workflow files, so we need to use the custom\n          // secret if one is configured.\n          'token': customToken ?? DEFAULT_TOKEN,\n          'commit-message': `${title}\\n\\n${description}`,\n          'branch': branchName,\n          'title': title,\n          'labels': this.options.workflowOptions?.labels?.join(',') || undefined,\n          'body': description,\n          'author': comitter,\n          'committer': comitter,\n          'signoff': this.options.signoff ?? true,\n        },\n      },\n    ];\n\n    let writeChecksPermission = false;\n    if (this._project.buildWorkflowJobId && upgrade.build) {\n      const body = {\n        name: this._project.buildWorkflowJobId,\n        head_sha: branchName,\n        status: 'completed',\n        conclusion: context(`needs.${upgrade.jobId}.outputs.${upgrade.buildConclusionOutput}`),\n        output: {\n          title: `Created via the ${workflowName} workflow.`,\n          summary: `Action run URL: ${RUN_URL}`,\n        },\n      };\n      steps.push({\n        name: 'Update status check',\n        if: `steps.${prStepId}.outputs.pull-request-url != \\'\\'`,\n        run: 'curl -i --fail '\n                + '-X POST '\n                + '-H \"Accept: application/vnd.github.v3+json\" '\n                + `-H \"Authorization: token \\${GITHUB_TOKEN}\" https://api.github.com/repos/${REPO}/check-runs `\n                + `-d '${JSON.stringify(body)}'`,\n        env: { GITHUB_TOKEN: DEFAULT_TOKEN },\n      });\n\n      // necessary to update status checks\n      writeChecksPermission = true;\n    }\n\n    return {\n      job: {\n        name: 'Create Pull Request',\n        needs: [upgrade.jobId],\n        permissions: {\n          contents: workflows.JobPermission.WRITE,\n          pullRequests: workflows.JobPermission.WRITE,\n          checks: writeChecksPermission ? workflows.JobPermission.WRITE : undefined,\n        },\n        runsOn: runsOn ?? ['ubuntu-latest'],\n        steps: steps,\n      },\n      jobId: 'pr',\n    };\n  }\n}\n\ninterface Upgrade {\n  readonly ref?: string;\n  readonly job: workflows.Job;\n  readonly jobId: string;\n  readonly patchFile: string;\n  readonly build: boolean;\n  readonly buildConclusionOutput: string;\n}\n\ninterface PR {\n  readonly job: workflows.Job;\n  readonly jobId: string;\n}\n\n                                                             \nexport interface UpgradeDependenciesWorkflowOptions {\n\n                                                                                         \n  readonly schedule?: UpgradeDependenciesSchedule;\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         \n  readonly secret?: string;\n\n                                                                           \n  readonly labels?: string[];\n\n                                                                                                                                                                                                                                                                                                                                                                                                                              \n  readonly rebuild?: boolean;\n\n                                                                     \n  readonly container?: workflows.ContainerOptions;\n\n                                                                                                                           \n  readonly branches?: string[];\n\n                                                                                               \n  readonly gitIdentity?: GitIdentity;\n\n                                                                               \n  readonly runsOn?: string[];\n}\n\n                                                                                            \nexport class UpgradeDependenciesSchedule {\n\n                                             \n  public static readonly NEVER = new UpgradeDependenciesSchedule([]);\n\n                          \n  public static readonly DAILY = new UpgradeDependenciesSchedule(['0 0 * * *']);\n\n                                                                          \n  public static readonly WEEKDAY = new UpgradeDependenciesSchedule(['0 0 * * 1-5']);\n\n                                    \n  public static readonly WEEKLY = new UpgradeDependenciesSchedule(['0 0 * * 1']);\n\n                                            \n  public static readonly MONTHLY = new UpgradeDependenciesSchedule(['0 0 1 * *']);\n\n                                                              \n  public static expressions(cron: string[]) {\n    return new UpgradeDependenciesSchedule(cron);\n  }\n\n  private constructor(public readonly cron: string[]) {}\n}\n"]}

package/lib/javascript/util.d.ts

@@ -0,0 +1 @@
+export declare function renderBundleName(entrypoint: string): string;