projen 0.78.9 → 0.78.10

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

@@ -0,0 +1,132 @@
+import { IConstruct } from "constructs";
+import { GitIdentity } from "./task-workflow";
+import { CheckoutWith } from "./workflow-steps";
+import { ContainerOptions, Job, JobDefaults, JobPermissions, JobStep, JobStepOutput, JobStrategy, Tools } from "./workflows-model";
+import { Component } from "../component";
+import { GroupRunnerOptions } from "../runner-options";
+import { Task } from "../task";
+/**
+ * Options to create the Job associated with a TaskWorkflow.
+ */
+export interface TaskWorkflowJobOptions {
+    /**
+     * @default - default image
+     */
+    readonly container?: ContainerOptions;
+    /**
+     * Adds an 'if' condition to the workflow.
+     */
+    readonly condition?: string;
+    /**
+     * 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
+     */
+    readonly artifactsDirectory?: string;
+    /**
+     * Initial steps to run before the source code checkout.
+     *
+     * @default - not set
+     */
+    readonly preCheckoutSteps?: JobStep[];
+    /**
+     * Override for the `with` property of the source code checkout step.
+     *
+     * @default - not set
+     */
+    readonly checkoutWith?: CheckoutWith;
+    /**
+     * Steps to run before the main build step.
+     *
+     * @default - not set
+     */
+    readonly preBuildSteps?: JobStep[];
+    /**
+     * Actions to run after the main build step.
+     *
+     * @default - not set
+     */
+    readonly postBuildSteps?: JobStep[];
+    /**
+     * Workflow environment variables.
+     * @default {}
+     */
+    readonly env?: Record<string, string>;
+    /**
+     * Permissions for the build job.
+     */
+    readonly permissions: JobPermissions;
+    /**
+     * Mapping of job output names to values/expressions.
+     *
+     * @default {}
+     */
+    readonly outputs?: {
+        [name: string]: JobStepOutput;
+    };
+    /**
+     * The git identity to use in this workflow.
+     */
+    readonly gitIdentity?: GitIdentity;
+    /**
+     * Github Runner selection labels
+     * @default ["ubuntu-latest"]
+     * @description Defines a target Runner by labels
+     * @throws {Error} if both `runsOn` and `runsOnGroup` are specified
+     */
+    readonly runsOn?: string[];
+    /**
+     * Github Runner Group selection options
+     * @description Defines a target Runner Group by name and/or labels
+     * @throws {Error} if both `runsOn` and `runsOnGroup` are specified
+     */
+    readonly runsOnGroup?: GroupRunnerOptions;
+    /**
+     * Whether to download files from Git LFS for this workflow
+     *
+     * @default - Use the setting on the corresponding GitHub project
+     */
+    readonly downloadLfs?: boolean;
+    /**
+     * Default settings for all steps in the TaskWorkflow Job.
+     */
+    readonly jobDefaults?: JobDefaults;
+}
+/**
+ * The primary or initial job of a TaskWorkflow.
+ *
+ * @implements {Job}
+ */
+export declare class TaskWorkflowJob extends Component {
+    readonly runsOn?: string[] | undefined;
+    readonly runsOnGroup?: GroupRunnerOptions | undefined;
+    readonly steps: JobStep[];
+    readonly environment?: unknown;
+    readonly outputs?: Record<string, JobStepOutput> | undefined;
+    readonly env?: Record<string, string> | undefined;
+    readonly defaults?: JobDefaults | undefined;
+    readonly timeoutMinutes?: number | undefined;
+    readonly continueOnError?: boolean | undefined;
+    readonly container?: ContainerOptions | undefined;
+    readonly services?: Record<string, ContainerOptions> | undefined;
+    readonly tools?: Tools | undefined;
+    readonly name?: string | undefined;
+    readonly needs?: string[] | undefined;
+    readonly permissions: JobPermissions;
+    readonly concurrency?: unknown;
+    readonly if?: string | undefined;
+    readonly strategy?: JobStrategy | undefined;
+    /**
+     * @param scope should be part of the project the Task belongs to.
+     * @param task the main task that is run as part of this job.
+     * @param options options to configure the TaskWorkflowJob.
+     */
+    constructor(scope: IConstruct, task: Task, options: TaskWorkflowJobOptions);
+    /**
+     * @jsii ignore
+     * @internal
+     */
+    toJSON(): Job;
+}

package/lib/github/task-workflow-job.js

@@ -0,0 +1,98 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskWorkflowJob = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const constants_1 = require("./constants");
+const workflow_steps_1 = require("./workflow-steps");
+const component_1 = require("../component");
+const runner_options_1 = require("../runner-options");
+/**
+ * The primary or initial job of a TaskWorkflow.
+ *
+ * @implements {Job}
+ */
+class TaskWorkflowJob extends component_1.Component {
+    /**
+     * @param scope should be part of the project the Task belongs to.
+     * @param task the main task that is run as part of this job.
+     * @param options options to configure the TaskWorkflowJob.
+     */
+    constructor(scope, task, options) {
+        super(scope, `${new.target.name}#${task.name}`);
+        const preCheckoutSteps = options.preCheckoutSteps ?? [];
+        const checkoutWith = {};
+        if (options.downloadLfs) {
+            checkoutWith.lfs = true;
+        }
+        // 'checkoutWith' can override 'lfs'
+        Object.assign(checkoutWith, options.checkoutWith ?? {});
+        const preBuildSteps = options.preBuildSteps ?? [];
+        const postBuildSteps = options.postBuildSteps ?? [];
+        const gitIdentity = options.gitIdentity ?? constants_1.DEFAULT_GITHUB_ACTIONS_USER;
+        if (options.artifactsDirectory) {
+            postBuildSteps.push(workflow_steps_1.WorkflowSteps.uploadArtifact({
+                // 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: options.artifactsDirectory,
+                    path: options.artifactsDirectory,
+                },
+            }));
+        }
+        const runsOnInputs = (0, runner_options_1.filteredRunsOnOptions)(options.runsOn, options.runsOnGroup);
+        this.runsOn = runsOnInputs?.runsOn;
+        this.runsOnGroup = runsOnInputs?.runsOnGroup;
+        this.container = options.container;
+        this.env = options.env;
+        this.permissions = options.permissions;
+        this.defaults = options?.jobDefaults;
+        this.if = options.condition;
+        this.outputs = options.outputs;
+        this.steps = [
+            ...preCheckoutSteps,
+            // check out sources.
+            workflow_steps_1.WorkflowSteps.checkout({ with: checkoutWith }),
+            // sets git identity so we can push later
+            workflow_steps_1.WorkflowSteps.setupGitIdentity({ gitIdentity }),
+            ...preBuildSteps,
+            // run the main build task
+            {
+                name: task.name,
+                run: this.project.runTaskCommand(task),
+            },
+            ...postBuildSteps,
+        ];
+    }
+    /**
+     * @jsii ignore
+     * @internal
+     */
+    toJSON() {
+        return {
+            runsOn: this.runsOn,
+            runsOnGroup: this.runsOnGroup,
+            steps: this.steps,
+            environment: this.environment,
+            outputs: this.outputs,
+            env: this.env,
+            defaults: this.defaults,
+            timeoutMinutes: this.timeoutMinutes,
+            continueOnError: this.continueOnError,
+            container: this.container,
+            services: this.services,
+            tools: this.tools,
+            name: this.name,
+            needs: this.needs,
+            permissions: this.permissions,
+            concurrency: this.concurrency,
+            if: this.if,
+            strategy: this.strategy,
+        };
+    }
+}
+exports.TaskWorkflowJob = TaskWorkflowJob;
+_a = JSII_RTTI_SYMBOL_1;
+TaskWorkflowJob[_a] = { fqn: "projen.github.TaskWorkflowJob", version: "0.78.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-workflow-job.js","sourceRoot":"","sources":["../../src/github/task-workflow-job.ts"],"names":[],"mappings":"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","sourcesContent":["import { IConstruct } from \"constructs\";\nimport { DEFAULT_GITHUB_ACTIONS_USER } from \"./constants\";\nimport { GitIdentity } from \"./task-workflow\";\nimport { CheckoutWith, WorkflowSteps } from \"./workflow-steps\";\nimport {\n  ContainerOptions,\n  Job,\n  JobDefaults,\n  JobPermissions,\n  JobStep,\n  JobStepOutput,\n  JobStrategy,\n  Tools,\n} from \"./workflows-model\";\nimport { Component } from \"../component\";\nimport { GroupRunnerOptions, filteredRunsOnOptions } from \"../runner-options\";\nimport { Task } from \"../task\";\n\n/**\n * Options to create the Job associated with a TaskWorkflow.\n */\nexport interface TaskWorkflowJobOptions {\n  /**\n   * @default - default image\n   */\n  readonly container?: ContainerOptions;\n\n  /**\n   * Adds an 'if' condition to the workflow.\n   */\n  readonly condition?: string;\n\n  /**\n   * A directory name which contains artifacts to be uploaded (e.g. `dist`).\n   * If this is set, the contents of this directory will be uploaded as an\n   * artifact at the end of the workflow run, even if other steps fail.\n   *\n   * @default - not set\n   */\n  readonly artifactsDirectory?: string;\n\n  /**\n   * Initial steps to run before the source code checkout.\n   *\n   * @default - not set\n   */\n  readonly preCheckoutSteps?: JobStep[];\n\n  /**\n   * Override for the `with` property of the source code checkout step.\n   *\n   * @default - not set\n   */\n  readonly checkoutWith?: CheckoutWith;\n\n  /**\n   * Steps to run before the main build step.\n   *\n   * @default - not set\n   */\n  readonly preBuildSteps?: JobStep[];\n\n  /**\n   * Actions to run after the main build step.\n   *\n   * @default - not set\n   */\n  readonly postBuildSteps?: JobStep[];\n\n  /**\n   * Workflow environment variables.\n   * @default {}\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Permissions for the build job.\n   */\n  readonly permissions: JobPermissions;\n\n  /**\n   * Mapping of job output names to values/expressions.\n   *\n   * @default {}\n   */\n  readonly outputs?: { [name: string]: JobStepOutput };\n\n  /**\n   * The git identity to use in this workflow.\n   */\n  readonly gitIdentity?: GitIdentity;\n\n  /**\n   * Github Runner selection labels\n   * @default [\"ubuntu-latest\"]\n   * @description Defines a target Runner by labels\n   * @throws {Error} if both `runsOn` and `runsOnGroup` are specified\n   */\n  readonly runsOn?: string[];\n\n  /**\n   * Github Runner Group selection options\n   * @description Defines a target Runner Group by name and/or labels\n   * @throws {Error} if both `runsOn` and `runsOnGroup` are specified\n   */\n  readonly runsOnGroup?: GroupRunnerOptions;\n\n  /**\n   * Whether to download files from Git LFS for this workflow\n   *\n   * @default - Use the setting on the corresponding GitHub project\n   */\n  readonly downloadLfs?: boolean;\n\n  /**\n   * Default settings for all steps in the TaskWorkflow Job.\n   */\n  readonly jobDefaults?: JobDefaults;\n}\n\n/**\n * The primary or initial job of a TaskWorkflow.\n *\n * @implements {Job}\n */\nexport class TaskWorkflowJob extends Component {\n  public readonly runsOn?: string[] | undefined;\n  public readonly runsOnGroup?: GroupRunnerOptions | undefined;\n  public readonly steps: JobStep[];\n  public readonly environment?: unknown;\n  public readonly outputs?: Record<string, JobStepOutput> | undefined;\n  public readonly env?: Record<string, string> | undefined;\n  public readonly defaults?: JobDefaults | undefined;\n  public readonly timeoutMinutes?: number | undefined;\n  public readonly continueOnError?: boolean | undefined;\n  public readonly container?: ContainerOptions | undefined;\n  public readonly services?: Record<string, ContainerOptions> | undefined;\n  public readonly tools?: Tools | undefined;\n  public readonly name?: string | undefined;\n  public readonly needs?: string[] | undefined;\n  public readonly permissions: JobPermissions;\n  public readonly concurrency?: unknown;\n  public readonly if?: string | undefined;\n  public readonly strategy?: JobStrategy | undefined;\n\n  /**\n   * @param scope should be part of the project the Task belongs to.\n   * @param task the main task that is run as part of this job.\n   * @param options options to configure the TaskWorkflowJob.\n   */\n  constructor(scope: IConstruct, task: Task, options: TaskWorkflowJobOptions) {\n    super(scope, `${new.target.name}#${task.name}`);\n    const preCheckoutSteps = options.preCheckoutSteps ?? [];\n\n    const checkoutWith: { lfs?: boolean } = {};\n    if (options.downloadLfs) {\n      checkoutWith.lfs = true;\n    }\n    // 'checkoutWith' can override 'lfs'\n    Object.assign(checkoutWith, options.checkoutWith ?? {});\n\n    const preBuildSteps = options.preBuildSteps ?? [];\n    const postBuildSteps = options.postBuildSteps ?? [];\n    const gitIdentity = options.gitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n\n    if (options.artifactsDirectory) {\n      postBuildSteps.push(\n        WorkflowSteps.uploadArtifact({\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: options.artifactsDirectory,\n            path: options.artifactsDirectory,\n          },\n        })\n      );\n    }\n\n    const runsOnInputs = filteredRunsOnOptions(\n      options.runsOn,\n      options.runsOnGroup\n    );\n    this.runsOn = (runsOnInputs as { runsOn: string[] })?.runsOn;\n    this.runsOnGroup = (\n      runsOnInputs as { runsOnGroup: GroupRunnerOptions }\n    )?.runsOnGroup;\n    this.container = options.container;\n    this.env = options.env;\n    this.permissions = options.permissions;\n    this.defaults = options?.jobDefaults;\n    this.if = options.condition;\n    this.outputs = options.outputs;\n    this.steps = [\n      ...preCheckoutSteps,\n\n      // check out sources.\n      WorkflowSteps.checkout({ with: checkoutWith }),\n\n      // sets git identity so we can push later\n      WorkflowSteps.setupGitIdentity({ gitIdentity }),\n\n      ...preBuildSteps,\n\n      // run the main build task\n      {\n        name: task.name,\n        run: this.project.runTaskCommand(task),\n      },\n\n      ...postBuildSteps,\n    ];\n  }\n\n  /**\n   * @jsii ignore\n   * @internal\n   */\n  public toJSON(): Job {\n    return {\n      runsOn: this.runsOn,\n      runsOnGroup: this.runsOnGroup,\n      steps: this.steps,\n      environment: this.environment,\n      outputs: this.outputs,\n      env: this.env,\n      defaults: this.defaults,\n      timeoutMinutes: this.timeoutMinutes,\n      continueOnError: this.continueOnError,\n      container: this.container,\n      services: this.services,\n      tools: this.tools,\n      name: this.name,\n      needs: this.needs,\n      permissions: this.permissions,\n      concurrency: this.concurrency,\n      if: this.if,\n      strategy: this.strategy,\n    };\n  }\n}\n"]}

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

@@ -1,10 +1,12 @@
 import { GitHub } from "./github";
-import { CheckoutWith } from "./workflow-steps";
+import { TaskWorkflowJobOptions } from "./task-workflow-job";
 import { GithubWorkflow } from "./workflows";
-import { ContainerOptions, JobPermissions, JobStep, JobStepOutput, Triggers } from "./workflows-model";
-import { GroupRunnerOptions } from "../runner-options";
+import { Triggers } from "./workflows-model";
 import { Task } from "../task";
-export interface TaskWorkflowOptions {
+/**
+ * Options to create a TaskWorkflow.
+ */
+export interface TaskWorkflowOptions extends TaskWorkflowJobOptions {
     /**
      * The workflow name.
      */
@@ -14,102 +16,21 @@ export interface TaskWorkflowOptions {
      * @default "build"
      */
     readonly jobId?: string;
-    /**
-     * @default - default image
-     */
-    readonly container?: ContainerOptions;
-    /**
-     * Adds an 'if' condition to the workflow.
-     */
-    readonly condition?: string;
-    /**
-     * 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
-     */
-    readonly artifactsDirectory?: string;
     /**
      * The triggers for the workflow.
      *
      * @default - by default workflows can only be triggered by manually.
      */
     readonly triggers?: Triggers;
-    /**
-     * Initial steps to run before the source code checkout.
-     *
-     * @default - not set
-     */
-    readonly preCheckoutSteps?: JobStep[];
-    /**
-     * Override for the `with` property of the source code checkout step.
-     *
-     * @default - not set
-     */
-    readonly checkoutWith?: CheckoutWith;
-    /**
-     * Steps to run before the main build step.
-     *
-     * @default - not set
-     */
-    readonly preBuildSteps?: JobStep[];
     /**
      * The main task to be executed.
      */
     readonly task: Task;
-    /**
-     * Actions to run after the main build step.
-     *
-     * @default - not set
-     */
-    readonly postBuildSteps?: JobStep[];
-    /**
-     * Workflow environment variables.
-     * @default {}
-     */
-    readonly env?: Record<string, string>;
-    /**
-     * Permissions for the build job.
-     */
-    readonly permissions: JobPermissions;
-    /**
-     * Mapping of job output names to values/expressions.
-     *
-     * @default {}
-     */
-    readonly outputs?: {
-        [name: string]: JobStepOutput;
-    };
-    /**
-     * The git identity to use in this workflow.
-     */
-    readonly gitIdentity?: GitIdentity;
-    /**
-     * Github Runner selection labels
-     * @default ["ubuntu-latest"]
-     * @description Defines a target Runner by labels
-     * @throws {Error} if both `runsOn` and `runsOnGroup` are specified
-     */
-    readonly runsOn?: string[];
-    /**
-     * Github Runner Group selection options
-     * @description Defines a target Runner Group by name and/or labels
-     * @throws {Error} if both `runsOn` and `runsOnGroup` are specified
-     */
-    readonly runsOnGroup?: GroupRunnerOptions;
-    /**
-     * Whether to download files from Git LFS for this workflow
-     *
-     * @default - Use the setting on the corresponding GitHub project
-     */
-    readonly downloadLfs?: boolean;
 }
 /**
  * A GitHub workflow for common build tasks within a project.
  */
 export declare class TaskWorkflow extends GithubWorkflow {
-    private readonly github;
     readonly jobId: string;
     readonly artifactsDirectory?: string;
     constructor(github: GitHub, options: TaskWorkflowOptions);

package/lib/github/task-workflow.js

@@ -3,10 +3,8 @@ 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 workflow_steps_1 = require("./workflow-steps");
+const task_workflow_job_1 = require("./task-workflow-job");
 const workflows_1 = require("./workflows");
-const runner_options_1 = require("../runner-options");
 const DEFAULT_JOB_ID = "build";
 /**
  * A GitHub workflow for common build tasks within a project.
@@ -15,7 +13,6 @@ class TaskWorkflow extends workflows_1.GithubWorkflow {
     constructor(github, options) {
         super(github, options.name);
         this.jobId = options.jobId ?? DEFAULT_JOB_ID;
-        this.github = github;
         this.artifactsDirectory = options.artifactsDirectory;
         if (options.triggers) {
             if (options.triggers.issueComment) {
@@ -27,55 +24,14 @@ class TaskWorkflow extends workflows_1.GithubWorkflow {
         this.on({
             workflowDispatch: {}, // allow manual triggering
         });
-        const preCheckoutSteps = options.preCheckoutSteps ?? [];
-        const checkoutWith = {};
-        if (options.downloadLfs ?? github.downloadLfs) {
-            checkoutWith.lfs = true;
-        }
-        // 'checkoutWith' can override 'lfs'
-        Object.assign(checkoutWith, options.checkoutWith ?? {});
-        const preBuildSteps = options.preBuildSteps ?? [];
-        const postBuildSteps = options.postBuildSteps ?? [];
-        const gitIdentity = options.gitIdentity ?? constants_1.DEFAULT_GITHUB_ACTIONS_USER;
-        if (this.artifactsDirectory) {
-            postBuildSteps.push({
-                name: "Upload artifact",
-                uses: "actions/upload-artifact@v3",
-                // 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 = {
-            ...(0, runner_options_1.filteredRunsOnOptions)(options.runsOn, options.runsOnGroup),
-            container: options.container,
-            env: options.env,
-            permissions: options.permissions,
-            if: options.condition,
-            outputs: options.outputs,
-            steps: [
-                ...preCheckoutSteps,
-                // check out sources.
-                workflow_steps_1.WorkflowSteps.checkout({ with: checkoutWith }),
-                // sets git identity so we can push later
-                workflow_steps_1.WorkflowSteps.setupGitIdentity({ gitIdentity }),
-                ...preBuildSteps,
-                // run the main build task
-                {
-                    name: options.task.name,
-                    run: this.github.project.runTaskCommand(options.task),
-                },
-                ...postBuildSteps,
-            ],
-        };
+        const job = new task_workflow_job_1.TaskWorkflowJob(this, options.task, {
+            ...options,
+            downloadLfs: options.downloadLfs ?? github.downloadLfs,
+        });
         this.addJobs({ [this.jobId]: job });
     }
 }
 exports.TaskWorkflow = TaskWorkflow;
 _a = JSII_RTTI_SYMBOL_1;
-TaskWorkflow[_a] = { fqn: "projen.github.TaskWorkflow", version: "0.78.9" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"task-workflow.js","sourceRoot":"","sources":["../../src/github/task-workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import { DEFAULT_GITHUB_ACTIONS_USER } from \"./constants\";\nimport { GitHub } from \"./github\";\nimport { CheckoutWith, WorkflowSteps } from \"./workflow-steps\";\nimport { GithubWorkflow } from \"./workflows\";\nimport {\n  ContainerOptions,\n  Job,\n  JobPermissions,\n  JobStep,\n  JobStepOutput,\n  Triggers,\n} from \"./workflows-model\";\nimport { GroupRunnerOptions, filteredRunsOnOptions } from \"../runner-options\";\nimport { Task } from \"../task\";\n\nconst DEFAULT_JOB_ID = \"build\";\n\nexport interface TaskWorkflowOptions {\n  /**\n   * The workflow name.\n   */\n  readonly name: string;\n\n  /**\n   * The primary job id.\n   * @default \"build\"\n   */\n  readonly jobId?: string;\n\n  /**\n   * @default - default image\n   */\n  readonly container?: ContainerOptions;\n\n  /**\n   * Adds an 'if' condition to the workflow.\n   */\n  readonly condition?: string;\n\n  /**\n   * A directory name which contains artifacts to be uploaded (e.g. `dist`).\n   * If this is set, the contents of this directory will be uploaded as an\n   * artifact at the end of the workflow run, even if other steps fail.\n   *\n   * @default - not set\n   */\n  readonly artifactsDirectory?: string;\n\n  /**\n   * The triggers for the workflow.\n   *\n   * @default - by default workflows can only be triggered by manually.\n   */\n  readonly triggers?: Triggers;\n\n  /**\n   * Initial steps to run before the source code checkout.\n   *\n   * @default - not set\n   */\n  readonly preCheckoutSteps?: JobStep[];\n\n  /**\n   * Override for the `with` property of the source code checkout step.\n   *\n   * @default - not set\n   */\n  readonly checkoutWith?: CheckoutWith;\n\n  /**\n   * Steps to run before the main build step.\n   *\n   * @default - not set\n   */\n  readonly preBuildSteps?: JobStep[];\n\n  /**\n   * The main task to be executed.\n   */\n  readonly task: Task;\n\n  /**\n   * Actions to run after the main build step.\n   *\n   * @default - not set\n   */\n  readonly postBuildSteps?: JobStep[];\n\n  /**\n   * Workflow environment variables.\n   * @default {}\n   */\n  readonly env?: Record<string, string>;\n\n  /**\n   * Permissions for the build job.\n   */\n  readonly permissions: JobPermissions;\n\n  /**\n   * Mapping of job output names to values/expressions.\n   *\n   * @default {}\n   */\n  readonly outputs?: { [name: string]: JobStepOutput };\n\n  /**\n   * The git identity to use in this workflow.\n   */\n  readonly gitIdentity?: GitIdentity;\n\n  /**\n   * Github Runner selection labels\n   * @default [\"ubuntu-latest\"]\n   * @description Defines a target Runner by labels\n   * @throws {Error} if both `runsOn` and `runsOnGroup` are specified\n   */\n  readonly runsOn?: string[];\n\n  /**\n   * Github Runner Group selection options\n   * @description Defines a target Runner Group by name and/or labels\n   * @throws {Error} if both `runsOn` and `runsOnGroup` are specified\n   */\n  readonly runsOnGroup?: GroupRunnerOptions;\n\n  /**\n   * Whether to download files from Git LFS for this workflow\n   *\n   * @default - Use the setting on the corresponding GitHub project\n   */\n  readonly downloadLfs?: boolean;\n}\n\n/**\n * A GitHub workflow for common build tasks within a project.\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(\n          'Trigger \"issueComment\" should not be used due to a security concern'\n        );\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\n    const checkoutWith: { lfs?: boolean } = {};\n    if (options.downloadLfs ?? github.downloadLfs) {\n      checkoutWith.lfs = true;\n    }\n    // 'checkoutWith' can override 'lfs'\n    Object.assign(checkoutWith, options.checkoutWith ?? {});\n\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@v3\",\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      ...filteredRunsOnOptions(options.runsOn, options.runsOnGroup),\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        WorkflowSteps.checkout({ with: checkoutWith }),\n\n        // sets git identity so we can push later\n        WorkflowSteps.setupGitIdentity({ 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/**\n * Represents the git identity.\n */\nexport interface GitIdentity {\n  /**\n   * The name of the user.\n   */\n  readonly name: string;\n\n  /**\n   * The email address of the git user.\n   */\n  readonly email: string;\n}\n"]}
+TaskWorkflow[_a] = { fqn: "projen.github.TaskWorkflow", version: "0.78.10" };
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFzay13b3JrZmxvdy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9naXRodWIvdGFzay13b3JrZmxvdy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OztBQUNBLDJEQUE4RTtBQUM5RSwyQ0FBNkM7QUFJN0MsTUFBTSxjQUFjLEdBQUcsT0FBTyxDQUFDO0FBOEIvQjs7R0FFRztBQUNILE1BQWEsWUFBYSxTQUFRLDBCQUFjO0lBSTlDLFlBQVksTUFBYyxFQUFFLE9BQTRCO1FBQ3RELEtBQUssQ0FBQyxNQUFNLEVBQUUsT0FBTyxDQUFDLElBQUksQ0FBQyxDQUFDO1FBQzVCLElBQUksQ0FBQyxLQUFLLEdBQUcsT0FBTyxDQUFDLEtBQUssSUFBSSxjQUFjLENBQUM7UUFDN0MsSUFBSSxDQUFDLGtCQUFrQixHQUFHLE9BQU8sQ0FBQyxrQkFBa0IsQ0FBQztRQUVyRCxJQUFJLE9BQU8sQ0FBQyxRQUFRLEVBQUU7WUFDcEIsSUFBSSxPQUFPLENBQUMsUUFBUSxDQUFDLFlBQVksRUFBRTtnQkFDakMseUlBQXlJO2dCQUN6SSxNQUFNLElBQUksS0FBSyxDQUNiLHFFQUFxRSxDQUN0RSxDQUFDO2FBQ0g7WUFFRCxJQUFJLENBQUMsRUFBRSxDQUFDLE9BQU8sQ0FBQyxRQUFRLENBQUMsQ0FBQztTQUMzQjtRQUVELElBQUksQ0FBQyxFQUFFLENBQUM7WUFDTixnQkFBZ0IsRUFBRSxFQUFFLEVBQUUsMEJBQTBCO1NBQ2pELENBQUMsQ0FBQztRQUVILE1BQU0sR0FBRyxHQUFHLElBQUksbUNBQWUsQ0FBQyxJQUFJLEVBQUUsT0FBTyxDQUFDLElBQUksRUFBRTtZQUNsRCxHQUFHLE9BQU87WUFDVixXQUFXLEVBQUUsT0FBTyxDQUFDLFdBQVcsSUFBSSxNQUFNLENBQUMsV0FBVztTQUN2RCxDQUFDLENBQUM7UUFFSCxJQUFJLENBQUMsT0FBTyxDQUFDLEVBQUUsQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEVBQUUsR0FBRyxFQUFFLENBQUMsQ0FBQztJQUN0QyxDQUFDOztBQTlCSCxvQ0ErQkMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBHaXRIdWIgfSBmcm9tIFwiLi9naXRodWJcIjtcbmltcG9ydCB7IFRhc2tXb3JrZmxvd0pvYiwgVGFza1dvcmtmbG93Sm9iT3B0aW9ucyB9IGZyb20gXCIuL3Rhc2std29ya2Zsb3ctam9iXCI7XG5pbXBvcnQgeyBHaXRodWJXb3JrZmxvdyB9IGZyb20gXCIuL3dvcmtmbG93c1wiO1xuaW1wb3J0IHsgVHJpZ2dlcnMgfSBmcm9tIFwiLi93b3JrZmxvd3MtbW9kZWxcIjtcbmltcG9ydCB7IFRhc2sgfSBmcm9tIFwiLi4vdGFza1wiO1xuXG5jb25zdCBERUZBVUxUX0pPQl9JRCA9IFwiYnVpbGRcIjtcblxuLyoqXG4gKiBPcHRpb25zIHRvIGNyZWF0ZSBhIFRhc2tXb3JrZmxvdy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBUYXNrV29ya2Zsb3dPcHRpb25zIGV4dGVuZHMgVGFza1dvcmtmbG93Sm9iT3B0aW9ucyB7XG4gIC8qKlxuICAgKiBUaGUgd29ya2Zsb3cgbmFtZS5cbiAgICovXG4gIHJlYWRvbmx5IG5hbWU6IHN0cmluZztcblxuICAvKipcbiAgICogVGhlIHByaW1hcnkgam9iIGlkLlxuICAgKiBAZGVmYXVsdCBcImJ1aWxkXCJcbiAgICovXG4gIHJlYWRvbmx5IGpvYklkPzogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgdHJpZ2dlcnMgZm9yIHRoZSB3b3JrZmxvdy5cbiAgICpcbiAgICogQGRlZmF1bHQgLSBieSBkZWZhdWx0IHdvcmtmbG93cyBjYW4gb25seSBiZSB0cmlnZ2VyZWQgYnkgbWFudWFsbHkuXG4gICAqL1xuICByZWFkb25seSB0cmlnZ2Vycz86IFRyaWdnZXJzO1xuXG4gIC8qKlxuICAgKiBUaGUgbWFpbiB0YXNrIHRvIGJlIGV4ZWN1dGVkLlxuICAgKi9cbiAgcmVhZG9ubHkgdGFzazogVGFzaztcbn1cblxuLyoqXG4gKiBBIEdpdEh1YiB3b3JrZmxvdyBmb3IgY29tbW9uIGJ1aWxkIHRhc2tzIHdpdGhpbiBhIHByb2plY3QuXG4gKi9cbmV4cG9ydCBjbGFzcyBUYXNrV29ya2Zsb3cgZXh0ZW5kcyBHaXRodWJXb3JrZmxvdyB7XG4gIHB1YmxpYyByZWFkb25seSBqb2JJZDogc3RyaW5nO1xuICBwdWJsaWMgcmVhZG9ubHkgYXJ0aWZhY3RzRGlyZWN0b3J5Pzogc3RyaW5nO1xuXG4gIGNvbnN0cnVjdG9yKGdpdGh1YjogR2l0SHViLCBvcHRpb25zOiBUYXNrV29ya2Zsb3dPcHRpb25zKSB7XG4gICAgc3VwZXIoZ2l0aHViLCBvcHRpb25zLm5hbWUpO1xuICAgIHRoaXMuam9iSWQgPSBvcHRpb25zLmpvYklkID8/IERFRkFVTFRfSk9CX0lEO1xuICAgIHRoaXMuYXJ0aWZhY3RzRGlyZWN0b3J5ID0gb3B0aW9ucy5hcnRpZmFjdHNEaXJlY3Rvcnk7XG5cbiAgICBpZiAob3B0aW9ucy50cmlnZ2Vycykge1xuICAgICAgaWYgKG9wdGlvbnMudHJpZ2dlcnMuaXNzdWVDb21tZW50KSB7XG4gICAgICAgIC8vIGh0dHBzOi8vZG9jcy5naXRodWIuY29tL2VuL2FjdGlvbnMvbGVhcm4tZ2l0aHViLWFjdGlvbnMvc2VjdXJpdHktaGFyZGVuaW5nLWZvci1naXRodWItYWN0aW9ucyNwb3RlbnRpYWwtaW1wYWN0LW9mLWEtY29tcHJvbWlzZWQtcnVubmVyXG4gICAgICAgIHRocm93IG5ldyBFcnJvcihcbiAgICAgICAgICAnVHJpZ2dlciBcImlzc3VlQ29tbWVudFwiIHNob3VsZCBub3QgYmUgdXNlZCBkdWUgdG8gYSBzZWN1cml0eSBjb25jZXJuJ1xuICAgICAgICApO1xuICAgICAgfVxuXG4gICAgICB0aGlzLm9uKG9wdGlvbnMudHJpZ2dlcnMpO1xuICAgIH1cblxuICAgIHRoaXMub24oe1xuICAgICAgd29ya2Zsb3dEaXNwYXRjaDoge30sIC8vIGFsbG93IG1hbnVhbCB0cmlnZ2VyaW5nXG4gICAgfSk7XG5cbiAgICBjb25zdCBqb2IgPSBuZXcgVGFza1dvcmtmbG93Sm9iKHRoaXMsIG9wdGlvbnMudGFzaywge1xuICAgICAgLi4ub3B0aW9ucyxcbiAgICAgIGRvd25sb2FkTGZzOiBvcHRpb25zLmRvd25sb2FkTGZzID8/IGdpdGh1Yi5kb3dubG9hZExmcyxcbiAgICB9KTtcblxuICAgIHRoaXMuYWRkSm9icyh7IFt0aGlzLmpvYklkXTogam9iIH0pO1xuICB9XG59XG5cbi8qKlxuICogUmVwcmVzZW50cyB0aGUgZ2l0IGlkZW50aXR5LlxuICovXG5leHBvcnQgaW50ZXJmYWNlIEdpdElkZW50aXR5IHtcbiAgLyoqXG4gICAqIFRoZSBuYW1lIG9mIHRoZSB1c2VyLlxuICAgKi9cbiAgcmVhZG9ubHkgbmFtZTogc3RyaW5nO1xuXG4gIC8qKlxuICAgKiBUaGUgZW1haWwgYWRkcmVzcyBvZiB0aGUgZ2l0IHVzZXIuXG4gICAqL1xuICByZWFkb25seSBlbWFpbDogc3RyaW5nO1xufVxuIl19

package/lib/github/workflow-actions.js

@@ -39,12 +39,11 @@ class WorkflowActions {
                     `git diff --staged --patch --exit-code > ${GIT_PATCH_FILE} || echo "${options.outputName}=true" >> $GITHUB_OUTPUT`,
                 ].join("\n"),
             },
-            {
+            workflow_steps_1.WorkflowSteps.uploadArtifact({
                 if: MUTATIONS_FOUND,
                 name: "Upload patch",
-                uses: "actions/upload-artifact@v3",
                 with: { name: GIT_PATCH_FILE, path: GIT_PATCH_FILE },
-            },
+            }),
         ];
         if (options.mutationError) {
             steps.push({
@@ -144,5 +143,5 @@ class WorkflowActions {
 }
 exports.WorkflowActions = WorkflowActions;
 _a = JSII_RTTI_SYMBOL_1;
-WorkflowActions[_a] = { fqn: "projen.github.WorkflowActions", version: "0.78.9" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow-actions.js","sourceRoot":"","sources":["../../src/github/workflow-actions.ts"],"names":[],"mappings":"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","sourcesContent":["import { GitIdentity, GithubCredentials } from \".\";\nimport { DEFAULT_GITHUB_ACTIONS_USER } from \"./constants\";\nimport { CheckoutWith, WorkflowSteps } from \"./workflow-steps\";\nimport { JobStep } from \"./workflows-model\";\n\nfunction context(value: string) {\n  return `\\${{ ${value} }}`;\n}\n\nconst REPO = context(\"github.repository\");\nconst RUN_ID = context(\"github.run_id\");\nconst SERVER_URL = context(\"github.server_url\");\nconst RUN_URL = `${SERVER_URL}/${REPO}/actions/runs/${RUN_ID}`;\nconst GIT_PATCH_FILE_DEFAULT = \".repo.patch\";\nconst RUNNER_TEMP = \"${{ runner.temp }}\";\n\n/**\n * A set of utility functions for creating GitHub actions in workflows.\n */\nexport class WorkflowActions {\n  /**\n   * Creates a .patch file from the current git diff and uploads it as an\n   * artifact. Use `checkoutWithPatch` to download and apply in another job.\n   *\n   * If a patch was uploaded, the action can optionally fail the job.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static uploadGitPatch(options: UploadGitPatchOptions): JobStep[] {\n    const MUTATIONS_FOUND = `steps.${options.stepId}.outputs.${options.outputName}`;\n    const GIT_PATCH_FILE = options.patchFile ?? GIT_PATCH_FILE_DEFAULT;\n\n    const steps: JobStep[] = [\n      {\n        id: options.stepId,\n        name: options.stepName ?? \"Find mutations\",\n        run: [\n          \"git add .\",\n          `git diff --staged --patch --exit-code > ${GIT_PATCH_FILE} || echo \"${options.outputName}=true\" >> $GITHUB_OUTPUT`,\n        ].join(\"\\n\"),\n      },\n      {\n        if: MUTATIONS_FOUND,\n        name: \"Upload patch\",\n        uses: \"actions/upload-artifact@v3\",\n        with: { name: GIT_PATCH_FILE, path: GIT_PATCH_FILE },\n      },\n    ];\n\n    if (options.mutationError) {\n      steps.push({\n        name: \"Fail build on mutation\",\n        if: MUTATIONS_FOUND,\n        run: [\n          `echo \"::error::${options.mutationError}\"`,\n          `cat ${GIT_PATCH_FILE}`,\n          \"exit 1\",\n        ].join(\"\\n\"),\n      });\n    }\n\n    return steps;\n  }\n  /**\n   * Checks out a repository and applies a git patch that was created using\n   * `uploadGitPatch`.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static checkoutWithPatch(\n    options: CheckoutWithPatchOptions = {}\n  ): JobStep[] {\n    const { patchFile, ...restOfOptions } = options;\n    const GIT_PATCH_FILE = options.patchFile ?? GIT_PATCH_FILE_DEFAULT;\n\n    return [\n      WorkflowSteps.checkout({ with: restOfOptions }),\n      {\n        name: \"Download patch\",\n        uses: \"actions/download-artifact@v3\",\n        with: { name: GIT_PATCH_FILE, path: RUNNER_TEMP },\n      },\n      {\n        name: \"Apply patch\",\n        run: `[ -s ${RUNNER_TEMP}/${GIT_PATCH_FILE} ] && git apply ${RUNNER_TEMP}/${GIT_PATCH_FILE} || echo \"Empty patch. Skipping.\"`,\n      },\n    ];\n  }\n\n  /**\n   * A step that creates a pull request based on the current repo state.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static createPullRequest(\n    options: CreatePullRequestOptions\n  ): JobStep[] {\n    const workflowName = options.workflowName;\n    const branchName = options.branchName ?? `github-actions/${workflowName}`;\n    const stepId = options.stepId ?? \"create-pr\";\n    const stepName = options.stepName ?? \"Create Pull Request\";\n    const gitIdentity = options.gitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n    const committer = `${gitIdentity.name} <${gitIdentity.email}>`;\n    const pullRequestDescription = options.pullRequestDescription\n      .trimEnd()\n      .endsWith(\".\")\n      ? options.pullRequestDescription.trimEnd()\n      : `${options.pullRequestDescription.trimEnd()}.`;\n\n    const title = options.pullRequestTitle;\n    const description = [\n      `${pullRequestDescription} See details in [workflow run].`,\n      \"\",\n      `[Workflow Run]: ${RUN_URL}`,\n      \"\",\n      \"------\",\n      \"\",\n      `*Automatically created by projen via the \"${workflowName}\" workflow*`,\n    ].join(\"\\n\");\n\n    return [\n      {\n        name: stepName,\n        id: stepId,\n        uses: \"peter-evans/create-pull-request@v4\",\n        with: {\n          token: options.credentials?.tokenRef,\n          \"commit-message\": `${title}\\n\\n${description}`,\n          branch: branchName,\n          base: options.baseBranch,\n          title: title,\n          labels: options.labels?.join(\",\") || undefined,\n          assignees: options.assignees?.join(\",\") || undefined,\n          body: description,\n          author: committer,\n          committer: committer,\n          signoff: options.signoff ?? true,\n        },\n      },\n    ];\n  }\n\n  /**\n   * Configures the git identity (user name and email).\n   * @param id The identity to use\n   * @returns Job steps\n   *\n   * @deprecated use `WorkflowSteps.setupGitIdentity` instead\n   */\n  public static setupGitIdentity(id: GitIdentity): JobStep[] {\n    return [WorkflowSteps.setupGitIdentity({ gitIdentity: id })];\n  }\n}\n\n/**\n * Options for `checkoutWithPatch`.\n */\nexport interface CheckoutWithPatchOptions extends CheckoutWith {\n  /**\n   * The name of the artifact the patch is stored as.\n   * @default \".repo.patch\"\n   */\n  readonly patchFile?: string;\n}\n\n/**\n * Options for `uploadGitPatch`.\n */\nexport interface UploadGitPatchOptions {\n  /**\n   * The step ID which produces the output which indicates if a patch was created.\n   */\n  readonly stepId: string;\n\n  /**\n   * The name of the step.\n   * @default \"Find mutations\"\n   */\n  readonly stepName?: string;\n\n  /**\n   * The name of the artifact the patch is stored as.\n   * @default \".repo.patch\"\n   */\n  readonly patchFile?: string;\n\n  /**\n   * The name of the output to emit. It will be set to `true` if there was a diff.\n   */\n  readonly outputName: string;\n\n  /**\n   * Fail if a mutation was found and print this error message.\n   * @default - do not fail upon mutation\n   */\n  readonly mutationError?: string;\n}\n\nexport interface CreatePullRequestOptions {\n  /**\n   * The step ID which produces the output which indicates if a patch was created.\n   * @default \"create_pr\"\n   */\n  readonly stepId?: string;\n\n  /**\n   * The name of the step displayed on GitHub.\n   * @default \"Create Pull Request\"\n   */\n  readonly stepName?: string;\n\n  /**\n   * The job credentials used to create the pull request.\n   *\n   * Provided credentials must have permissions to create a pull request on the repository.\n   */\n  readonly credentials?: GithubCredentials;\n\n  /**\n   * The name of the workflow that will create the PR\n   */\n  readonly workflowName: string;\n\n  /**\n   * The full title used to create the pull request.\n   *\n   * If PR titles are validated in this repo, the title should comply with the respective rules.\n   */\n  readonly pullRequestTitle: string;\n\n  /**\n   * Description added to the pull request.\n   *\n   * Providence information are automatically added.\n   */\n  readonly pullRequestDescription: string;\n\n  /**\n   * Sets the pull request base branch.\n   *\n   * @default - The branch checked out in the workflow.\n   */\n  readonly baseBranch?: string;\n\n  /**\n   * The pull request branch name.\n   *\n   * @default `github-actions/${options.workflowName}`\n   */\n  readonly branchName?: string;\n\n  /**\n   * The git identity used to create the commit.\n   * @default - the default github-actions user\n   */\n  readonly gitIdentity?: GitIdentity;\n\n  /**\n   * Add Signed-off-by line by the committer at the end of the commit log message.\n   *\n   * @default true\n   */\n  readonly signoff?: boolean;\n\n  /**\n   * Labels to apply on the PR.\n   *\n   * @default - no labels.\n   */\n  readonly labels?: string[];\n\n  /**\n   * Assignees to add on the PR.\n   *\n   * @default - no assignees\n   */\n  readonly assignees?: string[];\n}\n"]}
+WorkflowActions[_a] = { fqn: "projen.github.WorkflowActions", version: "0.78.10" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"workflow-actions.js","sourceRoot":"","sources":["../../src/github/workflow-actions.ts"],"names":[],"mappings":"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","sourcesContent":["import { GitIdentity, GithubCredentials } from \".\";\nimport { DEFAULT_GITHUB_ACTIONS_USER } from \"./constants\";\nimport { CheckoutWith, WorkflowSteps } from \"./workflow-steps\";\nimport { JobStep } from \"./workflows-model\";\n\nfunction context(value: string) {\n  return `\\${{ ${value} }}`;\n}\n\nconst REPO = context(\"github.repository\");\nconst RUN_ID = context(\"github.run_id\");\nconst SERVER_URL = context(\"github.server_url\");\nconst RUN_URL = `${SERVER_URL}/${REPO}/actions/runs/${RUN_ID}`;\nconst GIT_PATCH_FILE_DEFAULT = \".repo.patch\";\nconst RUNNER_TEMP = \"${{ runner.temp }}\";\n\n/**\n * A set of utility functions for creating GitHub actions in workflows.\n */\nexport class WorkflowActions {\n  /**\n   * Creates a .patch file from the current git diff and uploads it as an\n   * artifact. Use `checkoutWithPatch` to download and apply in another job.\n   *\n   * If a patch was uploaded, the action can optionally fail the job.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static uploadGitPatch(options: UploadGitPatchOptions): JobStep[] {\n    const MUTATIONS_FOUND = `steps.${options.stepId}.outputs.${options.outputName}`;\n    const GIT_PATCH_FILE = options.patchFile ?? GIT_PATCH_FILE_DEFAULT;\n\n    const steps: JobStep[] = [\n      {\n        id: options.stepId,\n        name: options.stepName ?? \"Find mutations\",\n        run: [\n          \"git add .\",\n          `git diff --staged --patch --exit-code > ${GIT_PATCH_FILE} || echo \"${options.outputName}=true\" >> $GITHUB_OUTPUT`,\n        ].join(\"\\n\"),\n      },\n      WorkflowSteps.uploadArtifact({\n        if: MUTATIONS_FOUND,\n        name: \"Upload patch\",\n        with: { name: GIT_PATCH_FILE, path: GIT_PATCH_FILE },\n      }),\n    ];\n\n    if (options.mutationError) {\n      steps.push({\n        name: \"Fail build on mutation\",\n        if: MUTATIONS_FOUND,\n        run: [\n          `echo \"::error::${options.mutationError}\"`,\n          `cat ${GIT_PATCH_FILE}`,\n          \"exit 1\",\n        ].join(\"\\n\"),\n      });\n    }\n\n    return steps;\n  }\n  /**\n   * Checks out a repository and applies a git patch that was created using\n   * `uploadGitPatch`.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static checkoutWithPatch(\n    options: CheckoutWithPatchOptions = {}\n  ): JobStep[] {\n    const { patchFile, ...restOfOptions } = options;\n    const GIT_PATCH_FILE = options.patchFile ?? GIT_PATCH_FILE_DEFAULT;\n\n    return [\n      WorkflowSteps.checkout({ with: restOfOptions }),\n      {\n        name: \"Download patch\",\n        uses: \"actions/download-artifact@v3\",\n        with: { name: GIT_PATCH_FILE, path: RUNNER_TEMP },\n      },\n      {\n        name: \"Apply patch\",\n        run: `[ -s ${RUNNER_TEMP}/${GIT_PATCH_FILE} ] && git apply ${RUNNER_TEMP}/${GIT_PATCH_FILE} || echo \"Empty patch. Skipping.\"`,\n      },\n    ];\n  }\n\n  /**\n   * A step that creates a pull request based on the current repo state.\n   *\n   * @param options Options\n   * @returns Job steps\n   */\n  public static createPullRequest(\n    options: CreatePullRequestOptions\n  ): JobStep[] {\n    const workflowName = options.workflowName;\n    const branchName = options.branchName ?? `github-actions/${workflowName}`;\n    const stepId = options.stepId ?? \"create-pr\";\n    const stepName = options.stepName ?? \"Create Pull Request\";\n    const gitIdentity = options.gitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n    const committer = `${gitIdentity.name} <${gitIdentity.email}>`;\n    const pullRequestDescription = options.pullRequestDescription\n      .trimEnd()\n      .endsWith(\".\")\n      ? options.pullRequestDescription.trimEnd()\n      : `${options.pullRequestDescription.trimEnd()}.`;\n\n    const title = options.pullRequestTitle;\n    const description = [\n      `${pullRequestDescription} See details in [workflow run].`,\n      \"\",\n      `[Workflow Run]: ${RUN_URL}`,\n      \"\",\n      \"------\",\n      \"\",\n      `*Automatically created by projen via the \"${workflowName}\" workflow*`,\n    ].join(\"\\n\");\n\n    return [\n      {\n        name: stepName,\n        id: stepId,\n        uses: \"peter-evans/create-pull-request@v4\",\n        with: {\n          token: options.credentials?.tokenRef,\n          \"commit-message\": `${title}\\n\\n${description}`,\n          branch: branchName,\n          base: options.baseBranch,\n          title: title,\n          labels: options.labels?.join(\",\") || undefined,\n          assignees: options.assignees?.join(\",\") || undefined,\n          body: description,\n          author: committer,\n          committer: committer,\n          signoff: options.signoff ?? true,\n        },\n      },\n    ];\n  }\n\n  /**\n   * Configures the git identity (user name and email).\n   * @param id The identity to use\n   * @returns Job steps\n   *\n   * @deprecated use `WorkflowSteps.setupGitIdentity` instead\n   */\n  public static setupGitIdentity(id: GitIdentity): JobStep[] {\n    return [WorkflowSteps.setupGitIdentity({ gitIdentity: id })];\n  }\n}\n\n/**\n * Options for `checkoutWithPatch`.\n */\nexport interface CheckoutWithPatchOptions extends CheckoutWith {\n  /**\n   * The name of the artifact the patch is stored as.\n   * @default \".repo.patch\"\n   */\n  readonly patchFile?: string;\n}\n\n/**\n * Options for `uploadGitPatch`.\n */\nexport interface UploadGitPatchOptions {\n  /**\n   * The step ID which produces the output which indicates if a patch was created.\n   */\n  readonly stepId: string;\n\n  /**\n   * The name of the step.\n   * @default \"Find mutations\"\n   */\n  readonly stepName?: string;\n\n  /**\n   * The name of the artifact the patch is stored as.\n   * @default \".repo.patch\"\n   */\n  readonly patchFile?: string;\n\n  /**\n   * The name of the output to emit. It will be set to `true` if there was a diff.\n   */\n  readonly outputName: string;\n\n  /**\n   * Fail if a mutation was found and print this error message.\n   * @default - do not fail upon mutation\n   */\n  readonly mutationError?: string;\n}\n\nexport interface CreatePullRequestOptions {\n  /**\n   * The step ID which produces the output which indicates if a patch was created.\n   * @default \"create_pr\"\n   */\n  readonly stepId?: string;\n\n  /**\n   * The name of the step displayed on GitHub.\n   * @default \"Create Pull Request\"\n   */\n  readonly stepName?: string;\n\n  /**\n   * The job credentials used to create the pull request.\n   *\n   * Provided credentials must have permissions to create a pull request on the repository.\n   */\n  readonly credentials?: GithubCredentials;\n\n  /**\n   * The name of the workflow that will create the PR\n   */\n  readonly workflowName: string;\n\n  /**\n   * The full title used to create the pull request.\n   *\n   * If PR titles are validated in this repo, the title should comply with the respective rules.\n   */\n  readonly pullRequestTitle: string;\n\n  /**\n   * Description added to the pull request.\n   *\n   * Providence information are automatically added.\n   */\n  readonly pullRequestDescription: string;\n\n  /**\n   * Sets the pull request base branch.\n   *\n   * @default - The branch checked out in the workflow.\n   */\n  readonly baseBranch?: string;\n\n  /**\n   * The pull request branch name.\n   *\n   * @default `github-actions/${options.workflowName}`\n   */\n  readonly branchName?: string;\n\n  /**\n   * The git identity used to create the commit.\n   * @default - the default github-actions user\n   */\n  readonly gitIdentity?: GitIdentity;\n\n  /**\n   * Add Signed-off-by line by the committer at the end of the commit log message.\n   *\n   * @default true\n   */\n  readonly signoff?: boolean;\n\n  /**\n   * Labels to apply on the PR.\n   *\n   * @default - no labels.\n   */\n  readonly labels?: string[];\n\n  /**\n   * Assignees to add on the PR.\n   *\n   * @default - no assignees\n   */\n  readonly assignees?: string[];\n}\n"]}

package/lib/github/workflow-jobs.js

@@ -41,5 +41,5 @@ class WorkflowJobs {
 }
 exports.WorkflowJobs = WorkflowJobs;
 _a = JSII_RTTI_SYMBOL_1;
-WorkflowJobs[_a] = { fqn: "projen.github.WorkflowJobs", version: "0.78.9" };
+WorkflowJobs[_a] = { fqn: "projen.github.WorkflowJobs", version: "0.78.10" };
 //# sourceMappingURL=data:application/json;base64,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