projen 0.0.0

package/lib/awscdk/lambda-function.js

@@ -0,0 +1,176 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LambdaRuntime = exports.LambdaFunction = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path_1 = require("path");
+const case_1 = require("case");
+const component_1 = require("../component");
+const file_1 = require("../file");
+const javascript_1 = require("../javascript");
+const source_code_1 = require("../source-code");
+const internal_1 = require("./internal");
+/**
+ * (experimental) Generates a pre-bundled AWS Lambda function construct from handler code.
+ *
+ * To use this, create an AWS Lambda handler file under your source tree with
+ * the `.lambda.ts` extension and add a `LambdaFunction` component to your
+ * typescript project pointing to this entrypoint.
+ *
+ * This will add a task to your "compile" step which will use `esbuild` to
+ * bundle the handler code into the build directory. It will also generate a
+ * file `src/foo-function.ts` with a custom AWS construct called `FooFunction`
+ * which extends `@aws-cdk/aws-lambda.Function` which is bound to the bundled
+ * handle through an asset.
+ *
+ * @experimental
+ * @example
+ *
+ * new LambdaFunction(myProject, {
+ *   srcdir: myProject.srcdir,
+ *   entrypoint: 'src/foo.lambda.ts',
+ * });
+ */
+class LambdaFunction extends component_1.Component {
+    /**
+     * (experimental) Defines a pre-bundled AWS Lambda function construct from handler code.
+     *
+     * @param project The project to use.
+     * @param options Options.
+     * @experimental
+     */
+    constructor(project, options) {
+        var _c, _d, _e;
+        super(project);
+        const cdkDeps = options.cdkDeps;
+        const bundler = javascript_1.Bundler.of(project);
+        if (!bundler) {
+            throw new Error('No bundler found. Please add a Bundler component to your project.');
+        }
+        const runtime = (_c = options.runtime) !== null && _c !== void 0 ? _c : LambdaRuntime.NODEJS_14_X;
+        // allow Lambda handler code to import dev-deps since they are only needed
+        // during bundling
+        const eslint = javascript_1.Eslint.of(project);
+        eslint === null || eslint === void 0 ? void 0 : eslint.allowDevDeps(options.entrypoint);
+        const entrypoint = options.entrypoint;
+        if (!entrypoint.endsWith(internal_1.TYPESCRIPT_LAMBDA_EXT)) {
+            throw new Error(`${entrypoint} must have a ${internal_1.TYPESCRIPT_LAMBDA_EXT} extension`);
+        }
+        const basePath = path_1.join(path_1.dirname(entrypoint), path_1.basename(entrypoint, internal_1.TYPESCRIPT_LAMBDA_EXT));
+        const constructFile = (_d = options.constructFile) !== null && _d !== void 0 ? _d : `${basePath}-function.ts`;
+        if (path_1.extname(constructFile) !== '.ts') {
+            throw new Error(`Construct file name "${constructFile}" must have a .ts extension`);
+        }
+        // type names
+        const constructName = (_e = options.constructName) !== null && _e !== void 0 ? _e : case_1.pascal(path_1.basename(basePath)) + 'Function';
+        const propsType = `${constructName}Props`;
+        const bundle = bundler.addBundle(entrypoint, {
+            target: runtime.esbuildTarget,
+            platform: runtime.esbuildPlatform,
+            externals: ['aws-sdk'],
+            ...options.bundlingOptions,
+        });
+        // calculate the relative path between the directory containing the
+        // generated construct source file to the directory containing the bundle
+        // index.js by resolving them as absolute paths first.
+        // e.g:
+        //  - outfileAbs => `/project-outdir/assets/foo/bar/baz/foo-function/index.js`
+        //  - constructAbs => `/project-outdir/src/foo/bar/baz/foo-function.ts`
+        const outfileAbs = path_1.join(project.outdir, bundle.outfile);
+        const constructAbs = path_1.join(project.outdir, constructFile);
+        const relativeOutfile = path_1.relative(path_1.dirname(constructAbs), path_1.dirname(outfileAbs));
+        const src = new source_code_1.SourceCode(project, constructFile);
+        src.line(`// ${file_1.FileBase.PROJEN_MARKER}`);
+        src.line('import * as path from \'path\';');
+        if (cdkDeps.cdkMajorVersion === 1) {
+            src.line('import * as lambda from \'@aws-cdk/aws-lambda\';');
+            src.line('import { Construct } from \'@aws-cdk/core\';');
+            cdkDeps.addV1Dependencies('@aws-cdk/aws-lambda');
+            cdkDeps.addV1Dependencies('@aws-cdk/core');
+        }
+        else {
+            src.line('import * as lambda from \'aws-cdk-lib/aws-lambda\';');
+            src.line('import { Construct } from \'constructs\';');
+        }
+        src.line();
+        src.line('/**');
+        src.line(` * Props for ${constructName}`);
+        src.line(' */');
+        src.open(`export interface ${propsType} extends lambda.FunctionOptions {`);
+        src.close('}');
+        src.line();
+        src.line('/**');
+        src.line(` * An AWS Lambda function which executes ${convertToPosixPath(basePath)}.`);
+        src.line(' */');
+        src.open(`export class ${constructName} extends lambda.Function {`);
+        src.open(`constructor(scope: Construct, id: string, props?: ${propsType}) {`);
+        src.open('super(scope, id, {');
+        src.line(`description: '${convertToPosixPath(entrypoint)}',`);
+        src.line('...props,');
+        src.line(`runtime: lambda.Runtime.${runtime.functionRuntime},`);
+        src.line('handler: \'index.handler\',');
+        src.line(`code: lambda.Code.fromAsset(path.join(__dirname, '${convertToPosixPath(relativeOutfile)}')),`);
+        src.close('});');
+        src.close('}');
+        src.close('}');
+        this.project.logger.verbose(`${basePath}: construct "${constructName}" generated under "${constructFile}"`);
+        this.project.logger.verbose(`${basePath}: bundle task "${bundle.bundleTask.name}"`);
+        if (bundle.watchTask) {
+            this.project.logger.verbose(`${basePath}: bundle watch task "${bundle.watchTask.name}"`);
+        }
+    }
+}
+exports.LambdaFunction = LambdaFunction;
+_a = JSII_RTTI_SYMBOL_1;
+LambdaFunction[_a] = { fqn: "projen.awscdk.LambdaFunction", version: "0.46.8" };
+/**
+ * (experimental) The runtime for the AWS Lambda function.
+ *
+ * @experimental
+ */
+class LambdaRuntime {
+    constructor(
+    /**
+     * The aws-lambda.Runtime member name to use.
+     */
+    functionRuntime, 
+    /**
+     * The esbuild setting to use.
+     */
+    esbuildTarget) {
+        this.functionRuntime = functionRuntime;
+        this.esbuildTarget = esbuildTarget;
+        /**
+         * @experimental
+         */
+        this.esbuildPlatform = 'node';
+    }
+}
+exports.LambdaRuntime = LambdaRuntime;
+_b = JSII_RTTI_SYMBOL_1;
+LambdaRuntime[_b] = { fqn: "projen.awscdk.LambdaRuntime", version: "0.46.8" };
+/**
+ * (experimental) Node.js 10.x.
+ *
+ * @experimental
+ */
+LambdaRuntime.NODEJS_10_X = new LambdaRuntime('NODEJS_10_X', 'node10');
+/**
+ * (experimental) Node.js 12.x.
+ *
+ * @experimental
+ */
+LambdaRuntime.NODEJS_12_X = new LambdaRuntime('NODEJS_12_X', 'node12');
+/**
+ * (experimental) Node.js 14.x.
+ *
+ * @experimental
+ */
+LambdaRuntime.NODEJS_14_X = new LambdaRuntime('NODEJS_14_X', 'node14');
+/**
+ * Converts the given path string to posix if it wasn't already.
+ */
+function convertToPosixPath(p) {
+    return p.split(path_1.sep).join(path_1.posix.sep);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda-function.js","sourceRoot":"","sources":["../../src/awscdk/lambda-function.ts"],"names":[],"mappings":"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","sourcesContent":["import { basename, dirname, extname, join, relative, sep, posix } from 'path';\nimport { pascal } from 'case';\nimport { Component } from '../component';\nimport { FileBase } from '../file';\nimport { Bundler, BundlingOptions, Eslint } from '../javascript';\nimport { Project } from '../project';\nimport { SourceCode } from '../source-code';\nimport { AwsCdkDeps } from './awscdk-deps';\nimport { TYPESCRIPT_LAMBDA_EXT } from './internal';\n\n                                                                                              \nexport interface LambdaFunctionCommonOptions {\n                                                                                      \n  readonly runtime?: LambdaRuntime;\n\n                                                                                                                                                                                                                     \n  readonly bundlingOptions?: BundlingOptions;\n}\n\n                                  \nexport interface LambdaFunctionOptions extends LambdaFunctionCommonOptions {\n                                                                                                                                                                                                                                                                                 \n  readonly entrypoint: string;\n\n                                                                                                                                                                                                                                          \n  readonly constructFile?: string;\n\n                                                                                                                                                                                                                       \n  readonly constructName?: string;\n\n                                            \n  readonly cdkDeps: AwsCdkDeps;\n}\n\n                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       \nexport class LambdaFunction extends Component {\n                                                                                                                                                               \n  constructor(project: Project, options: LambdaFunctionOptions) {\n    super(project);\n\n    const cdkDeps = options.cdkDeps;\n    const bundler = Bundler.of(project);\n    if (!bundler) {\n      throw new Error('No bundler found. Please add a Bundler component to your project.');\n    }\n\n    const runtime = options.runtime ?? LambdaRuntime.NODEJS_14_X;\n\n    // allow Lambda handler code to import dev-deps since they are only needed\n    // during bundling\n    const eslint = Eslint.of(project);\n    eslint?.allowDevDeps(options.entrypoint);\n\n    const entrypoint = options.entrypoint;\n\n    if (!entrypoint.endsWith(TYPESCRIPT_LAMBDA_EXT)) {\n      throw new Error(`${entrypoint} must have a ${TYPESCRIPT_LAMBDA_EXT} extension`);\n    }\n\n    const basePath = join(dirname(entrypoint), basename(entrypoint, TYPESCRIPT_LAMBDA_EXT));\n    const constructFile = options.constructFile ?? `${basePath}-function.ts`;\n\n    if (extname(constructFile) !== '.ts') {\n      throw new Error(`Construct file name \"${constructFile}\" must have a .ts extension`);\n    }\n\n    // type names\n    const constructName = options.constructName ?? pascal(basename(basePath)) + 'Function';\n    const propsType = `${constructName}Props`;\n\n    const bundle = bundler.addBundle(entrypoint, {\n      target: runtime.esbuildTarget,\n      platform: runtime.esbuildPlatform,\n      externals: ['aws-sdk'],\n      ...options.bundlingOptions,\n    });\n\n    // calculate the relative path between the directory containing the\n    // generated construct source file to the directory containing the bundle\n    // index.js by resolving them as absolute paths first.\n    // e.g:\n    //  - outfileAbs => `/project-outdir/assets/foo/bar/baz/foo-function/index.js`\n    //  - constructAbs => `/project-outdir/src/foo/bar/baz/foo-function.ts`\n    const outfileAbs = join(project.outdir, bundle.outfile);\n    const constructAbs = join(project.outdir, constructFile);\n    const relativeOutfile = relative(dirname(constructAbs), dirname(outfileAbs));\n\n    const src = new SourceCode(project, constructFile);\n    src.line(`// ${FileBase.PROJEN_MARKER}`);\n    src.line('import * as path from \\'path\\';');\n\n    if (cdkDeps.cdkMajorVersion === 1) {\n      src.line('import * as lambda from \\'@aws-cdk/aws-lambda\\';');\n      src.line('import { Construct } from \\'@aws-cdk/core\\';');\n      cdkDeps.addV1Dependencies('@aws-cdk/aws-lambda');\n      cdkDeps.addV1Dependencies('@aws-cdk/core');\n    } else {\n      src.line('import * as lambda from \\'aws-cdk-lib/aws-lambda\\';');\n      src.line('import { Construct } from \\'constructs\\';');\n    }\n\n    src.line();\n    src.line('/**');\n    src.line(` * Props for ${constructName}`);\n    src.line(' */');\n    src.open(`export interface ${propsType} extends lambda.FunctionOptions {`);\n    src.close('}');\n    src.line();\n    src.line('/**');\n    src.line(` * An AWS Lambda function which executes ${convertToPosixPath(basePath)}.`);\n    src.line(' */');\n    src.open(`export class ${constructName} extends lambda.Function {`);\n    src.open(`constructor(scope: Construct, id: string, props?: ${propsType}) {`);\n    src.open('super(scope, id, {');\n    src.line(`description: '${convertToPosixPath(entrypoint)}',`);\n    src.line('...props,');\n    src.line(`runtime: lambda.Runtime.${runtime.functionRuntime},`);\n    src.line('handler: \\'index.handler\\',');\n    src.line(`code: lambda.Code.fromAsset(path.join(__dirname, '${convertToPosixPath(relativeOutfile)}')),`);\n    src.close('});');\n    src.close('}');\n    src.close('}');\n\n    this.project.logger.verbose(`${basePath}: construct \"${constructName}\" generated under \"${constructFile}\"`);\n    this.project.logger.verbose(`${basePath}: bundle task \"${bundle.bundleTask.name}\"`);\n    if (bundle.watchTask) {\n      this.project.logger.verbose(`${basePath}: bundle watch task \"${bundle.watchTask.name}\"`);\n    }\n  }\n}\n\n                                                   \nexport class LambdaRuntime {\n                             \n  public static readonly NODEJS_10_X = new LambdaRuntime('NODEJS_10_X', 'node10');\n\n                             \n  public static readonly NODEJS_12_X = new LambdaRuntime('NODEJS_12_X', 'node12');\n\n                             \n  public static readonly NODEJS_14_X = new LambdaRuntime('NODEJS_14_X', 'node14');\n\n  public readonly esbuildPlatform = 'node';\n\n  private constructor(\n    /**\n     * The aws-lambda.Runtime member name to use.\n     */\n    public readonly functionRuntime: string,\n\n    /**\n     * The esbuild setting to use.\n     */\n    public readonly esbuildTarget: string) {\n  }\n}\n\n/**\n * Converts the given path string to posix if it wasn't already.\n */\nfunction convertToPosixPath(p: string) {\n  return p.split(sep).join(posix.sep);\n}"]}

package/lib/build/build-workflow.d.ts

@@ -0,0 +1,125 @@
+import { Task } from '..';
+import { Component } from '../component';
+import { GitIdentity } from '../github';
+import { Job, JobStep } from '../github/workflows-model';
+import { Project } from '../project';
+/**
+ * @experimental
+ */
+export interface BuildWorkflowOptions {
+    /**
+     * (experimental) The task to execute in order to build the project.
+     *
+     * @experimental
+     */
+    readonly buildTask: Task;
+    /**
+     * (experimental) A name of a directory that includes build artifacts.
+     *
+     * @experimental
+     */
+    readonly artifactsDirectory: string;
+    /**
+     * (experimental) The container image to use for builds.
+     *
+     * @default - the default workflow container
+     * @experimental
+     */
+    readonly containerImage?: string;
+    /**
+     * (experimental) Automatically update files modified during builds to pull-request branches.
+     *
+     * This means
+     * that any files synthesized by projen or e.g. test snapshots will always be up-to-date
+     * before a PR is merged.
+     *
+     * Implies that PR builds do not have anti-tamper checks.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly mutableBuild?: boolean;
+    /**
+     * (experimental) Steps to execute before the build.
+     *
+     * @default []
+     * @experimental
+     */
+    readonly preBuildSteps?: JobStep[];
+    /**
+     * (experimental) Steps to execute after build.
+     *
+     * @default []
+     * @experimental
+     */
+    readonly postBuildSteps?: JobStep[];
+    /**
+     * (experimental) Git identity to use for the workflow.
+     *
+     * @default - default identity
+     * @experimental
+     */
+    readonly gitIdentity?: GitIdentity;
+    /**
+     * (experimental) Build environment variables.
+     *
+     * @default {}
+     * @experimental
+     */
+    readonly env?: {
+        [key: string]: string;
+    };
+    /**
+     * (experimental) Enable anti-tamper check.
+     *
+     * @default true
+     * @experimental
+     */
+    readonly antitamper?: boolean;
+}
+/**
+ * @experimental
+ */
+export declare class BuildWorkflow extends Component {
+    private readonly postBuildSteps;
+    private readonly preBuildSteps;
+    private readonly antitamperSteps;
+    private readonly mutableBuilds;
+    private readonly gitIdentity;
+    private readonly buildTask;
+    private readonly github;
+    private readonly workflow;
+    private readonly primaryJobId;
+    private readonly artifactsDirectory?;
+    private readonly _buildJobIds;
+    private uploadArtitactSteps?;
+    /**
+     * @experimental
+     */
+    constructor(project: Project, options: BuildWorkflowOptions);
+    /**
+     * (experimental) Returns a list of job IDs that are part of the build.
+     *
+     * @experimental
+     */
+    get buildJobIds(): string[];
+    /**
+     * (experimental) Adds steps that are executed after the build.
+     *
+     * @param steps The job steps.
+     * @experimental
+     */
+    addPostBuildSteps(...steps: JobStep[]): void;
+    /**
+     * (experimental) Adds another job to the build workflow which is executed after the build job succeeded.
+     *
+     * @param id The id of the new job.
+     * @param job The job specification.
+     * @experimental
+     */
+    addPostBuildJob(id: string, job: Job): void;
+    /**
+     * Called (lazily) during synth to render the build job steps.
+     */
+    private renderSteps;
+}

package/lib/build/build-workflow.js

@@ -0,0 +1,223 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BuildWorkflow = 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");
+const workflows_model_1 = require("../github/workflows-model");
+const javascript_1 = require("../javascript");
+const BRANCH_REF = '${{ github.event.pull_request.head.ref }}';
+const REPO_REF = '${{ github.event.pull_request.head.repo.full_name }}';
+const PRIMARY_JOB_ID = 'build';
+const SELF_MUTATION_STEP = 'self_mutation';
+const SELF_MUTATION_COMMIT = 'self_mutation_commit';
+/**
+ * @experimental
+ */
+class BuildWorkflow extends component_1.Component {
+    /**
+     * @experimental
+     */
+    constructor(project, options) {
+        var _b, _c, _d, _e, _f, _g;
+        super(project);
+        const github = github_1.GitHub.of(project);
+        if (!github) {
+            throw new Error('BuildWorkflow is currently only supported for GitHub projects');
+        }
+        this.github = github;
+        this.preBuildSteps = (_b = options.preBuildSteps) !== null && _b !== void 0 ? _b : [];
+        this.postBuildSteps = (_c = options.postBuildSteps) !== null && _c !== void 0 ? _c : [];
+        this.mutableBuilds = (_d = options.mutableBuild) !== null && _d !== void 0 ? _d : true;
+        this.gitIdentity = (_e = options.gitIdentity) !== null && _e !== void 0 ? _e : constants_1.DEFAULT_GITHUB_ACTIONS_USER;
+        this.buildTask = options.buildTask;
+        this.artifactsDirectory = options.artifactsDirectory;
+        const antitamper = (_f = options.antitamper) !== null && _f !== void 0 ? _f : true;
+        // disable anti-tamper if build workflow is mutable
+        this.antitamperSteps = ((_g = !this.mutableBuilds) !== null && _g !== void 0 ? _g : antitamper) ? [{
+                // anti-tamper check (fails if there were changes to committed files)
+                // this will identify any non-committed files generated during build (e.g. test snapshots)
+                name: 'Anti-tamper check',
+                run: 'git diff --ignore-space-at-eol --exit-code',
+            }] : [];
+        this.workflow = new github_1.GithubWorkflow(github, 'build');
+        this.workflow.on({
+            pullRequest: {},
+            workflowDispatch: {},
+        });
+        this.workflow.addJob(PRIMARY_JOB_ID, {
+            runsOn: ['ubuntu-latest'],
+            container: options.containerImage ? { image: options.containerImage } : undefined,
+            env: {
+                CI: 'true',
+                ...options.env,
+            },
+            permissions: {
+                contents: workflows_model_1.JobPermission.WRITE,
+            },
+            outputs: {
+                [SELF_MUTATION_COMMIT]: {
+                    stepId: SELF_MUTATION_STEP,
+                    outputName: SELF_MUTATION_COMMIT,
+                },
+            },
+            steps: (() => this.renderSteps()),
+        });
+        this.primaryJobId = PRIMARY_JOB_ID;
+        this._buildJobIds = [PRIMARY_JOB_ID];
+        this.workflow.addJob('update-status', {
+            runsOn: ['ubuntu-latest'],
+            permissions: {
+                checks: workflows_model_1.JobPermission.WRITE,
+                actions: workflows_model_1.JobPermission.WRITE,
+            },
+            needs: (() => this._buildJobIds),
+            if: `\${{ needs.${this.primaryJobId}.outputs.${SELF_MUTATION_COMMIT} }}`,
+            steps: [
+                // if we pushed changes, we need to manually update the status check so
+                // that the PR will be green (we won't get here for forks with updates
+                // because the push would have failed).
+                {
+                    name: 'Update status check (if changed)',
+                    run: [
+                        'gh api',
+                        '-X POST',
+                        `/repos/${REPO_REF}/check-runs`,
+                        `-F name="${PRIMARY_JOB_ID}"`,
+                        `-F head_sha="\${{ needs.${this.primaryJobId}.outputs.${SELF_MUTATION_COMMIT} }}"`,
+                        '-F status="completed"',
+                        '-F conclusion="success"',
+                    ].join(' '),
+                    env: {
+                        GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',
+                    },
+                },
+                // if we pushed changes, we need to mark the current commit as failed, so
+                // that GitHub auto-merge does not risk merging this commit before the
+                // event for the new commit has registered.
+                {
+                    name: 'Cancel workflow (if changed)',
+                    run: [
+                        'gh api',
+                        '-X POST',
+                        `/repos/${REPO_REF}/actions/runs/\${{ github.run_id }}/cancel`,
+                    ].join(' '),
+                    env: {
+                        GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',
+                    },
+                },
+            ],
+        });
+    }
+    /**
+     * (experimental) Returns a list of job IDs that are part of the build.
+     *
+     * @experimental
+     */
+    get buildJobIds() {
+        return [...this._buildJobIds];
+    }
+    /**
+     * (experimental) Adds steps that are executed after the build.
+     *
+     * @param steps The job steps.
+     * @experimental
+     */
+    addPostBuildSteps(...steps) {
+        this.postBuildSteps.push(...steps);
+    }
+    /**
+     * (experimental) Adds another job to the build workflow which is executed after the build job succeeded.
+     *
+     * @param id The id of the new job.
+     * @param job The job specification.
+     * @experimental
+     */
+    addPostBuildJob(id, job) {
+        const steps = [];
+        if (this.artifactsDirectory) {
+            // add a step at the end of the build workflow which will upload the
+            // artifact so we can download it in each post-build job (do it once).
+            if (!this.uploadArtitactSteps) {
+                const paths = ['.', '!.git'];
+                if (this.project instanceof javascript_1.NodeProject) {
+                    paths.push(
+                    // node_modules takes forever to compress.
+                    // instead, we skip it and re-install after downloading.
+                    '!node_modules');
+                }
+                this.uploadArtitactSteps = [{
+                        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: constants_1.BUILD_ARTIFACT_NAME,
+                            path: paths.join('\n'),
+                        },
+                    }];
+            }
+            steps.push({
+                name: 'Download build artifacts',
+                uses: 'actions/download-artifact@v2',
+                with: {
+                    name: constants_1.BUILD_ARTIFACT_NAME,
+                },
+            });
+        }
+        steps.push(...job.steps);
+        this.workflow.addJob(id, {
+            needs: [this.primaryJobId],
+            ...job,
+            steps: steps,
+        });
+        // add to the list of build job IDs
+        this._buildJobIds.push(id);
+    }
+    /**
+     * Called (lazily) during synth to render the build job steps.
+     */
+    renderSteps() {
+        const steps = new Array();
+        steps.push({
+            name: 'Checkout',
+            uses: 'actions/checkout@v2',
+            with: this.mutableBuilds ? {
+                ref: BRANCH_REF,
+                repository: REPO_REF,
+            } : undefined,
+        });
+        steps.push(constants_1.setGitIdentityStep(this.gitIdentity));
+        steps.push(...this.antitamperSteps);
+        steps.push(...this.preBuildSteps);
+        steps.push({
+            name: this.buildTask.name,
+            run: this.github.project.runTaskCommand(this.buildTask),
+        });
+        steps.push(...this.postBuildSteps);
+        steps.push(...this.antitamperSteps);
+        steps.push({
+            name: 'Self mutation',
+            id: SELF_MUTATION_STEP,
+            run: [
+                'if ! git diff --exit-code; then',
+                '  git add .',
+                '  git commit -m "chore: self mutation"',
+                `  git push origin HEAD:${BRANCH_REF}`,
+                `  echo "::set-output name=${SELF_MUTATION_COMMIT}::$(git rev-parse HEAD)"`,
+                'fi',
+            ].join('\n'),
+        });
+        if (this.uploadArtitactSteps) {
+            steps.push(...this.uploadArtitactSteps);
+        }
+        return steps;
+    }
+}
+exports.BuildWorkflow = BuildWorkflow;
+_a = JSII_RTTI_SYMBOL_1;
+BuildWorkflow[_a] = { fqn: "projen.build.BuildWorkflow", version: "0.46.8" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"build-workflow.js","sourceRoot":"","sources":["../../src/build/build-workflow.ts"],"names":[],"mappings":"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","sourcesContent":["import { Task } from '..';\nimport { Component } from '../component';\nimport { GitHub, GithubWorkflow, GitIdentity } from '../github';\nimport { BUILD_ARTIFACT_NAME, DEFAULT_GITHUB_ACTIONS_USER, setGitIdentityStep } from '../github/constants';\nimport { Job, JobPermission, JobStep } from '../github/workflows-model';\nimport { NodeProject } from '../javascript';\nimport { Project } from '../project';\n\nconst BRANCH_REF = '${{ github.event.pull_request.head.ref }}';\nconst REPO_REF = '${{ github.event.pull_request.head.repo.full_name }}';\nconst PRIMARY_JOB_ID = 'build';\nconst SELF_MUTATION_STEP = 'self_mutation';\nconst SELF_MUTATION_COMMIT = 'self_mutation_commit';\n\nexport interface BuildWorkflowOptions {\n                                                                   \n  readonly buildTask: Task;\n\n                                                                     \n  readonly artifactsDirectory: string;\n\n                                                                                                      \n  readonly containerImage?: string;\n\n                                                                                                                                                                                                                                                                                                               \n  readonly mutableBuild?: boolean;\n\n                                                                    \n  readonly preBuildSteps?: JobStep[];\n\n                                                               \n  readonly postBuildSteps?: JobStep[];\n\n                                                                                       \n  readonly gitIdentity?: GitIdentity;\n\n                                                              \n  readonly env?: { [key: string]: string };\n\n                                                                  \n  readonly antitamper?: boolean;\n}\n\nexport class BuildWorkflow extends Component {\n  private readonly postBuildSteps: JobStep[];\n  private readonly preBuildSteps: JobStep[];\n  private readonly antitamperSteps: JobStep[];\n  private readonly mutableBuilds: boolean;\n  private readonly gitIdentity: GitIdentity;\n  private readonly buildTask: Task;\n  private readonly github: GitHub;\n  private readonly workflow: GithubWorkflow;\n  private readonly primaryJobId: string;\n  private readonly artifactsDirectory?: string;\n\n  private readonly _buildJobIds: string[];\n  private uploadArtitactSteps?: JobStep[];\n\n  constructor(project: Project, options: BuildWorkflowOptions) {\n    super(project);\n\n    const github = GitHub.of(project);\n    if (!github) {\n      throw new Error('BuildWorkflow is currently only supported for GitHub projects');\n    }\n\n    this.github = github;\n\n    this.preBuildSteps = options.preBuildSteps ?? [];\n    this.postBuildSteps = options.postBuildSteps ?? [];\n    this.mutableBuilds = options.mutableBuild ?? true;\n    this.gitIdentity = options.gitIdentity ?? DEFAULT_GITHUB_ACTIONS_USER;\n    this.buildTask = options.buildTask;\n    this.artifactsDirectory = options.artifactsDirectory;\n\n    const antitamper = options.antitamper ?? true;\n\n    // disable anti-tamper if build workflow is mutable\n    this.antitamperSteps = (!this.mutableBuilds ?? antitamper) ? [{\n      // anti-tamper check (fails if there were changes to committed files)\n      // this will identify any non-committed files generated during build (e.g. test snapshots)\n      name: 'Anti-tamper check',\n      run: 'git diff --ignore-space-at-eol --exit-code',\n    }] : [];\n\n    this.workflow = new GithubWorkflow(github, 'build');\n\n    this.workflow.on({\n      pullRequest: {},\n      workflowDispatch: {}, // allow manual triggering\n    });\n\n    this.workflow.addJob(PRIMARY_JOB_ID, {\n      runsOn: ['ubuntu-latest'],\n      container: options.containerImage ? { image: options.containerImage } : undefined,\n      env: {\n        CI: 'true',\n        ...options.env,\n      },\n      permissions: {\n        contents: JobPermission.WRITE,\n      },\n      outputs: {\n        [SELF_MUTATION_COMMIT]: {\n          stepId: SELF_MUTATION_STEP,\n          outputName: SELF_MUTATION_COMMIT,\n        },\n      },\n      steps: (() => this.renderSteps()) as any,\n    });\n\n    this.primaryJobId = PRIMARY_JOB_ID;\n\n    this._buildJobIds = [PRIMARY_JOB_ID];\n\n    this.workflow.addJob('update-status', {\n      runsOn: ['ubuntu-latest'],\n      permissions: {\n        checks: JobPermission.WRITE,\n        actions: JobPermission.WRITE,\n      },\n      needs: (() => this._buildJobIds) as any, // wait for all build jobs to finish\n      if: `\\${{ needs.${this.primaryJobId}.outputs.${SELF_MUTATION_COMMIT} }}`,\n      steps: [\n      // if we pushed changes, we need to manually update the status check so\n      // that the PR will be green (we won't get here for forks with updates\n      // because the push would have failed).\n        {\n          name: 'Update status check (if changed)',\n          run: [\n            'gh api',\n            '-X POST',\n            `/repos/${REPO_REF}/check-runs`,\n            `-F name=\"${PRIMARY_JOB_ID}\"`,\n            `-F head_sha=\"\\${{ needs.${this.primaryJobId}.outputs.${SELF_MUTATION_COMMIT} }}\"`,\n            '-F status=\"completed\"',\n            '-F conclusion=\"success\"',\n          ].join(' '),\n          env: {\n            GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n          },\n        },\n\n        // if we pushed changes, we need to mark the current commit as failed, so\n        // that GitHub auto-merge does not risk merging this commit before the\n        // event for the new commit has registered.\n        {\n          name: 'Cancel workflow (if changed)',\n          run: [\n            'gh api',\n            '-X POST',\n            `/repos/${REPO_REF}/actions/runs/\\${{ github.run_id }}/cancel`,\n          ].join(' '),\n          env: {\n            GITHUB_TOKEN: '${{ secrets.GITHUB_TOKEN }}',\n          },\n        },\n      ],\n    });\n  }\n\n                                                                      \n  public get buildJobIds(): string[] {\n    return [...this._buildJobIds];\n  }\n\n                                                                                              \n  public addPostBuildSteps(...steps: JobStep[]): void {\n    this.postBuildSteps.push(...steps);\n  }\n\n                                                                                                                                                                                   \n  public addPostBuildJob(id: string, job: Job) {\n    const steps = [];\n\n    if (this.artifactsDirectory) {\n\n      // add a step at the end of the build workflow which will upload the\n      // artifact so we can download it in each post-build job (do it once).\n      if (!this.uploadArtitactSteps) {\n\n        const paths = ['.', '!.git'];\n\n        if (this.project instanceof NodeProject) {\n          paths.push(\n            // node_modules takes forever to compress.\n            // instead, we skip it and re-install after downloading.\n            '!node_modules',\n          );\n        }\n\n        this.uploadArtitactSteps = [{\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: BUILD_ARTIFACT_NAME,\n            path: paths.join('\\n'),\n          },\n        }];\n      }\n\n      steps.push({\n        name: 'Download build artifacts',\n        uses: 'actions/download-artifact@v2',\n        with: {\n          name: BUILD_ARTIFACT_NAME,\n        },\n      });\n    }\n\n    steps.push(...job.steps);\n\n    this.workflow.addJob(id, {\n      needs: [this.primaryJobId],\n      ...job,\n      steps: steps,\n    });\n\n    // add to the list of build job IDs\n    this._buildJobIds.push(id);\n  }\n\n  /**\n   * Called (lazily) during synth to render the build job steps.\n   */\n  private renderSteps(): JobStep[] {\n    const steps = new Array<JobStep>();\n\n    steps.push({\n      name: 'Checkout',\n      uses: 'actions/checkout@v2',\n      with: this.mutableBuilds ? {\n        ref: BRANCH_REF,\n        repository: REPO_REF,\n      } : undefined,\n    });\n\n    steps.push(setGitIdentityStep(this.gitIdentity));\n\n    steps.push(...this.antitamperSteps);\n    steps.push(...this.preBuildSteps);\n    steps.push({\n      name: this.buildTask.name,\n      run: this.github.project.runTaskCommand(this.buildTask),\n    });\n    steps.push(...this.postBuildSteps);\n    steps.push(...this.antitamperSteps);\n\n    steps.push({\n      name: 'Self mutation',\n      id: SELF_MUTATION_STEP,\n      run: [\n        'if ! git diff --exit-code; then',\n        '  git add .',\n        '  git commit -m \"chore: self mutation\"',\n        `  git push origin HEAD:${BRANCH_REF}`,\n        `  echo \"::set-output name=${SELF_MUTATION_COMMIT}::$(git rev-parse HEAD)\"`,\n        'fi',\n      ].join('\\n'),\n    });\n\n    if (this.uploadArtitactSteps) {\n      steps.push(...this.uploadArtitactSteps);\n    }\n\n    return steps;\n  }\n}"]}

package/lib/build/index.d.ts

@@ -0,0 +1 @@
+export * from './build-workflow';

package/lib/build/index.js

@@ -0,0 +1,14 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./build-workflow"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvYnVpbGQvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7O0FBQUEsbURBQWlDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9idWlsZC13b3JrZmxvdyc7XG4iXX0=

package/lib/builtin-example.task.js

@@ -0,0 +1,4 @@
+"use strict";
+console.log('hello, I am a builtin task');
+console.log('second line');
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYnVpbHRpbi1leGFtcGxlLnRhc2suanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvYnVpbHRpbi1leGFtcGxlLnRhc2sudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IjtBQUFBLE9BQU8sQ0FBQyxHQUFHLENBQUMsNEJBQTRCLENBQUMsQ0FBQztBQUMxQyxPQUFPLENBQUMsR0FBRyxDQUFDLGFBQWEsQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiY29uc29sZS5sb2coJ2hlbGxvLCBJIGFtIGEgYnVpbHRpbiB0YXNrJyk7XG5jb25zb2xlLmxvZygnc2Vjb25kIGxpbmUnKTsiXX0=