projen 0.0.0

package/lib/github/stale-util.d.ts

@@ -0,0 +1,8 @@
+import { StaleBehavior } from './stale';
+interface Options {
+    readonly stale: number;
+    readonly close: number;
+    readonly type: string;
+}
+export declare function renderBehavior(behavior: StaleBehavior | undefined, opts: Options): Partial<StaleBehavior>;
+export {};

package/lib/github/stale-util.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderBehavior = void 0;
+function renderBehavior(behavior, opts) {
+    var _a, _b, _c, _d, _e, _f;
+    const enabled = (_a = behavior === null || behavior === void 0 ? void 0 : behavior.enabled) !== null && _a !== void 0 ? _a : true;
+    if (!enabled) {
+        return { daysBeforeStale: -1, daysBeforeClose: -1 };
+    }
+    return {
+        daysBeforeStale: (_b = behavior === null || behavior === void 0 ? void 0 : behavior.daysBeforeStale) !== null && _b !== void 0 ? _b : opts.stale,
+        daysBeforeClose: (_c = behavior === null || behavior === void 0 ? void 0 : behavior.daysBeforeClose) !== null && _c !== void 0 ? _c : opts.close,
+        staleMessage: (_d = behavior === null || behavior === void 0 ? void 0 : behavior.staleMessage) !== null && _d !== void 0 ? _d : `This ${opts.type} is now marked as stale because it hasn\'t seen activity for a while. Add a comment or it will be closed soon.`,
+        closeMessage: (_e = behavior === null || behavior === void 0 ? void 0 : behavior.closeMessage) !== null && _e !== void 0 ? _e : `Closing this ${opts.type} as it hasn\'t seen activity for a while. Please add a comment @mentioning a maintainer to reopen.`,
+        staleLabel: (_f = behavior === null || behavior === void 0 ? void 0 : behavior.staleLabel) !== null && _f !== void 0 ? _f : 'stale',
+    };
+}
+exports.renderBehavior = renderBehavior;
+;
+//# sourceMappingURL=data:application/json;base64,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

package/lib/github/stale.d.ts

@@ -0,0 +1,106 @@
+import { Component } from '../component';
+import { GitHub } from './github';
+/**
+ * (experimental) Options for `Stale`.
+ *
+ * @experimental
+ */
+export interface StaleOptions {
+    /**
+     * (experimental) How to handle stale pull requests.
+     *
+     * @default - By default, pull requests with no activity will be marked as
+     * stale after 14 days and closed within 2 days with relevant comments.
+     * @experimental
+     */
+    readonly pullRequest?: StaleBehavior;
+    /**
+     * (experimental) How to handle stale issues.
+     *
+     * @default - By default, stale issues with no activity will be marked as
+     * stale after 60 days and closed within 7 days.
+     * @experimental
+     */
+    readonly issues?: StaleBehavior;
+    /**
+     * (experimental) Github Runner selection labels.
+     *
+     * @default ["ubuntu-latest"]
+     * @experimental
+     */
+    readonly runsOn?: string[];
+}
+/**
+ * (experimental) Stale behavior.
+ *
+ * @experimental
+ */
+export interface StaleBehavior {
+    /**
+     * (experimental) Determines if this behavior is enabled.
+     *
+     * Same as setting `daysBeforeStale` and `daysBeforeClose` to `-1`.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly enabled?: boolean;
+    /**
+     * (experimental) How many days until the issue or pull request is marked as "Stale".
+     *
+     * Set to -1 to disable.
+     *
+     * @default -
+     * @experimental
+     */
+    readonly daysBeforeStale?: number;
+    /**
+     * (experimental) Days until the issue/PR is closed after it is marked as "Stale".
+     *
+     * Set to -1 to disable.
+     *
+     * @default -
+     * @experimental
+     */
+    readonly daysBeforeClose?: number;
+    /**
+     * (experimental) The comment to add to the issue/PR when it becomes stale.
+     *
+     * @default "This pull request is now marked as stale because hasn\'t seen activity for a while. Add a comment or it will be closed soon."
+     * @experimental
+     */
+    readonly staleMessage?: string;
+    /**
+     * (experimental) The comment to add to the issue/PR when it's closed.
+     *
+     * @default "Closing this pull request as it hasn\'t seen activity for a while. Please add a comment
+     * @experimental
+     * @mentioning a maintainer when you are ready to continue."
+     */
+    readonly closeMessage?: string;
+    /**
+     * (experimental) The label to apply to the issue/PR when it becomes stale.
+     *
+     * @default "Stale"
+     * @experimental
+     */
+    readonly staleLabel?: string;
+}
+/**
+ * (experimental) Warns and then closes issues and PRs that have had no activity for a specified amount of time.
+ *
+ * The default configuration will:
+ *
+ *   * Add a "Stale" label to pull requests after 14 days and closed after 2 days
+ *   * Add a "Stale" label to issues after 60 days and closed after 7 days
+ *   * If a comment is added, the label will be removed and timer is restarted.
+ *
+ * @see https://github.com/actions/stale
+ * @experimental
+ */
+export declare class Stale extends Component {
+    /**
+     * @experimental
+     */
+    constructor(github: GitHub, options?: StaleOptions);
+}

package/lib/github/stale.js

@@ -0,0 +1,71 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stale = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const component_1 = require("../component");
+const stale_util_1 = require("./stale-util");
+const workflows_model_1 = require("./workflows-model");
+/**
+ * (experimental) Warns and then closes issues and PRs that have had no activity for a specified amount of time.
+ *
+ * The default configuration will:
+ *
+ *   * Add a "Stale" label to pull requests after 14 days and closed after 2 days
+ *   * Add a "Stale" label to issues after 60 days and closed after 7 days
+ *   * If a comment is added, the label will be removed and timer is restarted.
+ *
+ * @see https://github.com/actions/stale
+ * @experimental
+ */
+class Stale extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(github, options = {}) {
+        var _b;
+        super(github.project);
+        const stale = github.addWorkflow('stale');
+        stale.on({
+            schedule: [{ cron: '0 1 * * *' }],
+            workflowDispatch: {},
+        });
+        const pullRequests = stale_util_1.renderBehavior(options.pullRequest, { stale: 14, close: 2, type: 'pull request' });
+        const issues = stale_util_1.renderBehavior(options.issues, { stale: 60, close: 7, type: 'issue' });
+        stale.addJobs({
+            stale: {
+                runsOn: (_b = options.runsOn) !== null && _b !== void 0 ? _b : ['ubuntu-latest'],
+                permissions: {
+                    issues: workflows_model_1.JobPermission.WRITE,
+                    pullRequests: workflows_model_1.JobPermission.WRITE,
+                },
+                steps: [
+                    {
+                        uses: 'actions/stale@v4',
+                        with: {
+                            // disable global
+                            'days-before-stale': -1,
+                            'days-before-close': -1,
+                            // pull requests
+                            'days-before-pr-stale': pullRequests.daysBeforeStale,
+                            'days-before-pr-close': pullRequests.daysBeforeClose,
+                            'stale-pr-message': pullRequests.staleMessage,
+                            'close-pr-message': pullRequests.closeMessage,
+                            'stale-pr-label': pullRequests.staleLabel,
+                            // issues
+                            'days-before-issue-stale': issues.daysBeforeStale,
+                            'days-before-issue-close': issues.daysBeforeClose,
+                            'stale-issue-message': issues.staleMessage,
+                            'close-issue-message': issues.closeMessage,
+                            'stale-issue-label': issues.staleLabel,
+                        },
+                    },
+                ],
+            },
+        });
+    }
+}
+exports.Stale = Stale;
+_a = JSII_RTTI_SYMBOL_1;
+Stale[_a] = { fqn: "projen.github.Stale", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/github/task-workflow.d.ts

@@ -0,0 +1,155 @@
+import { Task } from '../task';
+import { GitHub } from './github';
+import { GithubWorkflow } from './workflows';
+import { ContainerOptions, JobPermissions, JobStep, JobStepOutput, Triggers } from './workflows-model';
+/**
+ * @experimental
+ */
+export interface TaskWorkflowOptions {
+    /**
+     * (experimental) The workflow name.
+     *
+     * @experimental
+     */
+    readonly name: string;
+    /**
+     * (experimental) The primary job id.
+     *
+     * @default "build"
+     * @experimental
+     */
+    readonly jobId?: string;
+    /**
+     * @default - default image
+     * @experimental
+     */
+    readonly container?: ContainerOptions;
+    /**
+     * (experimental) Adds an 'if' condition to the workflow.
+     *
+     * @experimental
+     */
+    readonly condition?: string;
+    /**
+     * (experimental) A directory name which contains artifacts to be uploaded (e.g. `dist`). If this is set, the contents of this directory will be uploaded as an artifact at the end of the workflow run, even if other steps fail.
+     *
+     * @default - not set
+     * @experimental
+     */
+    readonly artifactsDirectory?: string;
+    /**
+     * (experimental) The triggers for the workflow.
+     *
+     * @default - by default workflows can only be triggered by manually.
+     * @experimental
+     */
+    readonly triggers?: Triggers;
+    /**
+     * (experimental) Initial steps to run before the source code checkout.
+     *
+     * @default - not set
+     * @experimental
+     */
+    readonly preCheckoutSteps?: JobStep[];
+    /**
+     * (experimental) Override for the `with` property of the source code checkout step.
+     *
+     * @default - not set
+     * @experimental
+     */
+    readonly checkoutWith?: Record<string, any>;
+    /**
+     * (experimental) Steps to run before the main build step.
+     *
+     * @default - not set
+     * @experimental
+     */
+    readonly preBuildSteps?: JobStep[];
+    /**
+     * (experimental) The main task to be executed.
+     *
+     * @experimental
+     */
+    readonly task: Task;
+    /**
+     * (experimental) Actions to run after the main build step.
+     *
+     * @default - not set
+     * @experimental
+     */
+    readonly postBuildSteps?: JobStep[];
+    /**
+     * (experimental) Workflow environment variables.
+     *
+     * @default {}
+     * @experimental
+     */
+    readonly env?: Record<string, string>;
+    /**
+     * (experimental) Permissions for the build job.
+     *
+     * @experimental
+     */
+    readonly permissions: JobPermissions;
+    /**
+     * (experimental) Mapping of job output names to values/expressions.
+     *
+     * @default {}
+     * @experimental
+     */
+    readonly outputs?: {
+        [name: string]: JobStepOutput;
+    };
+    /**
+     * (experimental) The git identity to use in this workflow.
+     *
+     * @experimental
+     */
+    readonly gitIdentity?: GitIdentity;
+    /**
+     * (experimental) Github Runner selection labels.
+     *
+     * @default ["ubuntu-latest"]
+     * @experimental
+     */
+    readonly runsOn?: string[];
+}
+/**
+ * (experimental) A GitHub workflow for common build tasks within a project.
+ *
+ * @experimental
+ */
+export declare class TaskWorkflow extends GithubWorkflow {
+    private readonly github;
+    /**
+     * @experimental
+     */
+    readonly jobId: string;
+    /**
+     * @experimental
+     */
+    readonly artifactsDirectory?: string;
+    /**
+     * @experimental
+     */
+    constructor(github: GitHub, options: TaskWorkflowOptions);
+}
+/**
+ * (experimental) Represents the git identity.
+ *
+ * @experimental
+ */
+export interface GitIdentity {
+    /**
+     * (experimental) The name of the user.
+     *
+     * @experimental
+     */
+    readonly name: string;
+    /**
+     * (experimental) The email address of the git user.
+     *
+     * @experimental
+     */
+    readonly email: string;
+}

package/lib/github/task-workflow.js

@@ -0,0 +1,84 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskWorkflow = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const constants_1 = require("./constants");
+const workflows_1 = require("./workflows");
+const DEFAULT_JOB_ID = 'build';
+/**
+ * (experimental) A GitHub workflow for common build tasks within a project.
+ *
+ * @experimental
+ */
+class TaskWorkflow extends workflows_1.GithubWorkflow {
+    /**
+     * @experimental
+     */
+    constructor(github, options) {
+        var _b, _c, _d, _e, _f, _g;
+        super(github, options.name);
+        this.jobId = (_b = options.jobId) !== null && _b !== void 0 ? _b : DEFAULT_JOB_ID;
+        this.github = github;
+        this.artifactsDirectory = options.artifactsDirectory;
+        if (options.triggers) {
+            if (options.triggers.issueComment) {
+                // https://docs.github.com/en/actions/learn-github-actions/security-hardening-for-github-actions#potential-impact-of-a-compromised-runner
+                throw new Error('Trigger "issueComment" should not be used due to a security concern');
+            }
+            this.on(options.triggers);
+        }
+        this.on({
+            workflowDispatch: {},
+        });
+        const preCheckoutSteps = (_c = options.preCheckoutSteps) !== null && _c !== void 0 ? _c : [];
+        const checkoutWith = options.checkoutWith ? { with: options.checkoutWith } : {};
+        const preBuildSteps = (_d = options.preBuildSteps) !== null && _d !== void 0 ? _d : [];
+        const postBuildSteps = (_e = options.postBuildSteps) !== null && _e !== void 0 ? _e : [];
+        const gitIdentity = (_f = options.gitIdentity) !== null && _f !== void 0 ? _f : constants_1.DEFAULT_GITHUB_ACTIONS_USER;
+        if (this.artifactsDirectory) {
+            postBuildSteps.push({
+                name: 'Upload artifact',
+                uses: 'actions/upload-artifact@v2.1.1',
+                // Setting to always will ensure that this step will run even if
+                // the previous ones have failed (e.g. coverage report, internal logs, etc)
+                if: 'always()',
+                with: {
+                    name: this.artifactsDirectory,
+                    path: this.artifactsDirectory,
+                },
+            });
+        }
+        const job = {
+            runsOn: (_g = options.runsOn) !== null && _g !== void 0 ? _g : ['ubuntu-latest'],
+            container: options.container,
+            env: options.env,
+            permissions: options.permissions,
+            if: options.condition,
+            outputs: options.outputs,
+            steps: [
+                ...preCheckoutSteps,
+                // check out sources.
+                {
+                    name: 'Checkout',
+                    uses: 'actions/checkout@v2',
+                    ...checkoutWith,
+                },
+                // sets git identity so we can push later
+                constants_1.setGitIdentityStep(gitIdentity),
+                ...preBuildSteps,
+                // run the main build task
+                {
+                    name: options.task.name,
+                    run: this.github.project.runTaskCommand(options.task),
+                },
+                ...postBuildSteps,
+            ],
+        };
+        this.addJobs({ [this.jobId]: job });
+    }
+}
+exports.TaskWorkflow = TaskWorkflow;
+_a = JSII_RTTI_SYMBOL_1;
+TaskWorkflow[_a] = { fqn: "projen.github.TaskWorkflow", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-workflow.js","sourceRoot":"","sources":["../../src/github/task-workflow.ts"],"names":[],"mappings":";;;;;AACA,2CAA8E;AAE9E,2CAA6C;AAG7C,MAAM,cAAc,GAAG,OAAO,CAAC;;;;;;AAqD/B,MAAa,YAAa,SAAQ,0BAAc;;;;IAK9C,YAAY,MAAc,EAAE,OAA4B;;QACtD,KAAK,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;QAC5B,IAAI,CAAC,KAAK,SAAG,OAAO,CAAC,KAAK,mCAAI,cAAc,CAAC;QAC7C,IAAI,CAAC,MAAM,GAAG,MAAM,CAAC;QACrB,IAAI,CAAC,kBAAkB,GAAG,OAAO,CAAC,kBAAkB,CAAC;QAErD,IAAI,OAAO,CAAC,QAAQ,EAAE;YACpB,IAAI,OAAO,CAAC,QAAQ,CAAC,YAAY,EAAE;gBACjC,yIAAyI;gBACzI,MAAM,IAAI,KAAK,CAAC,qEAAqE,CAAC,CAAC;aACxF;YAED,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;SAC3B;QAED,IAAI,CAAC,EAAE,CAAC;YACN,gBAAgB,EAAE,EAAE;SACrB,CAAC,CAAC;QAEH,MAAM,gBAAgB,SAAG,OAAO,CAAC,gBAAgB,mCAAI,EAAE,CAAC;QACxD,MAAM,YAAY,GAAG,OAAO,CAAC,YAAY,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,OAAO,CAAC,YAAY,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;QAChF,MAAM,aAAa,SAAG,OAAO,CAAC,aAAa,mCAAI,EAAE,CAAC;QAClD,MAAM,cAAc,SAAG,OAAO,CAAC,cAAc,mCAAI,EAAE,CAAC;QACpD,MAAM,WAAW,SAAG,OAAO,CAAC,WAAW,mCAAI,uCAA2B,CAAC;QAEvE,IAAI,IAAI,CAAC,kBAAkB,EAAE;YAC3B,cAAc,CAAC,IAAI,CAAC;gBAClB,IAAI,EAAE,iBAAiB;gBACvB,IAAI,EAAE,gCAAgC;gBACtC,gEAAgE;gBAChE,2EAA2E;gBAC3E,EAAE,EAAE,UAAU;gBACd,IAAI,EAAE;oBACJ,IAAI,EAAE,IAAI,CAAC,kBAAkB;oBAC7B,IAAI,EAAE,IAAI,CAAC,kBAAkB;iBAC9B;aACF,CAAC,CAAC;SACJ;QAED,MAAM,GAAG,GAAQ;YACf,MAAM,QAAE,OAAO,CAAC,MAAM,mCAAI,CAAC,eAAe,CAAC;YAC3C,SAAS,EAAE,OAAO,CAAC,SAAS;YAC5B,GAAG,EAAE,OAAO,CAAC,GAAG;YAChB,WAAW,EAAE,OAAO,CAAC,WAAW;YAChC,EAAE,EAAE,OAAO,CAAC,SAAS;YACrB,OAAO,EAAE,OAAO,CAAC,OAAO;YACxB,KAAK,EAAE;gBACL,GAAG,gBAAgB;gBAEnB,qBAAqB;gBACrB;oBACE,IAAI,EAAE,UAAU;oBAChB,IAAI,EAAE,qBAAqB;oBAC3B,GAAG,YAAY;iBAChB;gBAED,yCAAyC;gBACzC,8BAAkB,CAAC,WAAW,CAAC;gBAE/B,GAAG,aAAa;gBAEhB,0BAA0B;gBAC1B;oBACE,IAAI,EAAE,OAAO,CAAC,IAAI,CAAC,IAAI;oBACvB,GAAG,EAAE,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC;iBACtD;gBAED,GAAG,cAAc;aAClB;SACF,CAAC;QAEF,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC;IACtC,CAAC;;AA7EH,oCA8EC","sourcesContent":["import { Task } from '../task';\nimport { DEFAULT_GITHUB_ACTIONS_USER, setGitIdentityStep } from './constants';\nimport { GitHub } from './github';\nimport { GithubWorkflow } from './workflows';\nimport { ContainerOptions, Job, JobPermissions, JobStep, JobStepOutput, Triggers } from './workflows-model';\n\nconst DEFAULT_JOB_ID = 'build';\n\nexport interface TaskWorkflowOptions {\n                                   \n  readonly name: string;\n\n                                                          \n  readonly jobId?: string;\n\n                                         \n  readonly container?: ContainerOptions;\n\n                                                        \n  readonly condition?: string;\n\n                                                                                                                                                                                                                                                                        \n  readonly artifactsDirectory?: string;\n\n                                                                                                                            \n  readonly triggers?: Triggers;\n\n                                                                                                   \n  readonly preCheckoutSteps?: JobStep[];\n\n                                                                                                                \n  readonly checkoutWith?: Record<string, any>;\n\n                                                                                      \n  readonly preBuildSteps?: JobStep[];\n\n                                              \n  readonly task: Task;\n\n                                                                                       \n  readonly postBuildSteps?: JobStep[];\n\n                                                                 \n  readonly env?: Record<string, string>;\n\n                                               \n  readonly permissions: JobPermissions;\n\n                                                                                         \n  readonly outputs?: { [name: string]: JobStepOutput };\n\n                                                          \n  readonly gitIdentity?: GitIdentity;\n\n                                                                               \n  readonly runsOn?: string[];\n}\n\n                                                                     \nexport class TaskWorkflow extends GithubWorkflow {\n  private readonly github: GitHub;\n  public readonly jobId: string;\n  public readonly artifactsDirectory?: string;\n\n  constructor(github: GitHub, options: TaskWorkflowOptions) {\n    super(github, options.name);\n    this.jobId = options.jobId ?? DEFAULT_JOB_ID;\n    this.github = github;\n    this.artifactsDirectory = options.artifactsDirectory;\n\n    if (options.triggers) {\n      if (options.triggers.issueComment) {\n        // https://docs.github.com/en/actions/learn-github-actions/security-hardening-for-github-actions#potential-impact-of-a-compromised-runner\n        throw new Error('Trigger \"issueComment\" should not be used due to a security concern');\n      }\n\n      this.on(options.triggers);\n    }\n\n    this.on({\n      workflowDispatch: {}, // allow manual triggering\n    });\n\n    const preCheckoutSteps = options.preCheckoutSteps ?? [];\n    const checkoutWith = options.checkoutWith ? { with: options.checkoutWith } : {};\n    const preBuildSteps = options.preBuildSteps ?? [];\n    const postBuildSteps = options.postBuildSteps ?? [];\n    const gitIdentity = options.gitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n\n    if (this.artifactsDirectory) {\n      postBuildSteps.push({\n        name: 'Upload artifact',\n        uses: 'actions/upload-artifact@v2.1.1',\n        // Setting to always will ensure that this step will run even if\n        // the previous ones have failed (e.g. coverage report, internal logs, etc)\n        if: 'always()',\n        with: {\n          name: this.artifactsDirectory,\n          path: this.artifactsDirectory,\n        },\n      });\n    }\n\n    const job: Job = {\n      runsOn: options.runsOn ?? ['ubuntu-latest'],\n      container: options.container,\n      env: options.env,\n      permissions: options.permissions,\n      if: options.condition,\n      outputs: options.outputs,\n      steps: [\n        ...preCheckoutSteps,\n\n        // check out sources.\n        {\n          name: 'Checkout',\n          uses: 'actions/checkout@v2',\n          ...checkoutWith,\n        },\n\n        // sets git identity so we can push later\n        setGitIdentityStep(gitIdentity),\n\n        ...preBuildSteps,\n\n        // run the main build task\n        {\n          name: options.task.name,\n          run: this.github.project.runTaskCommand(options.task),\n        },\n\n        ...postBuildSteps,\n      ],\n    };\n\n    this.addJobs({ [this.jobId]: job });\n  }\n}\n\n                                       \nexport interface GitIdentity {\n                                      \n  readonly name: string;\n\n                                                   \n  readonly email: string;\n}\n"]}