@cloudsnorkel/cdk-github-runners 0.0.11 → 0.0.14

package/lib/providers/lambda.js

@@ -13,6 +13,8 @@ const common_1 = require("./common");
  * GitHub Actions runner provider using Lambda to execute the actions.
  *
  * Creates a Docker-based function that gets executed for each job.
+ *
+ * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.
  */
 class LambdaRunner extends constructs_1.Construct {
     constructor(scope, id, props) {
@@ -37,9 +39,19 @@ class LambdaRunner extends constructs_1.Construct {
         });
         this.grantPrincipal = this.function.grantPrincipal;
     }
+    /**
+     * The network connections associated with this resource.
+     */
     get connections() {
         return this.function.connections;
     }
+    /**
+     * Generate step function task(s) to start a new runner.
+     *
+     * Called by GithubRunners and shouldn't be called manually.
+     *
+     * @param parameters workflow job details
+     */
     getStepFunctionTask(parameters) {
         return new aws_cdk_lib_1.aws_stepfunctions_tasks.LambdaInvoke(this, 'Lambda Runner', {
             lambdaFunction: this.function,
@@ -56,5 +68,5 @@ class LambdaRunner extends constructs_1.Construct {
 }
 exports.LambdaRunner = LambdaRunner;
 _a = JSII_RTTI_SYMBOL_1;
-LambdaRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaRunner", version: "0.0.11" };
-//# sourceMappingURL=data:application/json;base64,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
+LambdaRunner[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.LambdaRunner", version: "0.0.14" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"lambda.js","sourceRoot":"","sources":["../../src/providers/lambda.ts"],"names":[],"mappings":";;;;;AAAA,6BAA6B;AAC7B,mCAAmC;AACnC,6CAMqB;AACrB,mDAAqD;AACrD,2CAAuC;AACvC,qCAAwG;AA0DxG;;;;;;GAMG;AACH,MAAa,YAAa,SAAQ,sBAAS;IA0BzC,YAAY,KAAgB,EAAE,EAAU,EAAE,KAAwB;QAChE,KAAK,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;QAEjB,IAAI,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,IAAI,QAAQ,CAAC;QACrC,IAAI,CAAC,GAAG,GAAG,KAAK,CAAC,GAAG,CAAC;QACrB,IAAI,CAAC,aAAa,GAAG,KAAK,CAAC,aAAa,CAAC;QAEzC,IAAI,CAAC,QAAQ,GAAG,IAAI,wBAAM,CAAC,mBAAmB,CAC5C,IAAI,EACJ,UAAU,EACV;YACE,kEAAkE;YAClE,IAAI,EAAE,wBAAM,CAAC,eAAe,CAAC,cAAc,CACzC,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,eAAe,EAAE,QAAQ,CAAC,EAC/C;gBACE,SAAS,EAAE;oBACT,cAAc,EAAE,KAAK,CAAC,aAAa,CAAC,CAAC,CAAC,KAAK,CAAC,aAAa,CAAC,OAAO,CAAC,CAAC,CAAC,sBAAa,CAAC,MAAM,EAAE,CAAC,OAAO;iBACnG;aACF,CACF;YACD,GAAG,EAAE,IAAI,CAAC,GAAG;YACb,cAAc,EAAE,IAAI,CAAC,aAAa,IAAI,CAAC,IAAI,CAAC,aAAa,CAAC;YAC1D,UAAU,EAAE,KAAK,CAAC,eAAe;YACjC,OAAO,EAAE,KAAK,CAAC,OAAO,IAAI,GAAG,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAClD,UAAU,EAAE,KAAK,CAAC,UAAU,IAAI,IAAI;YACpC,oBAAoB,EAAE,KAAK,CAAC,oBAAoB,IAAI,GAAG,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC;YAC1E,YAAY,EAAE,KAAK,CAAC,YAAY,IAAI,wBAAa,CAAC,SAAS;SAC5D,CACF,CAAC;QAEF,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC,QAAQ,CAAC,cAAc,CAAC;IACrD,CAAC;IAED;;OAEG;IACH,IAAW,WAAW;QACpB,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;IACnC,CAAC;IAED;;;;;;OAMG;IACH,mBAAmB,CAAC,UAAmC;QACrD,OAAO,IAAI,qCAAmB,CAAC,YAAY,CACzC,IAAI,EACJ,eAAe,EACf;YACE,cAAc,EAAE,IAAI,CAAC,QAAQ;YAC7B,OAAO,EAAE,+BAAa,CAAC,SAAS,CAAC,UAAU,CAAC;gBAC1C,KAAK,EAAE,UAAU,CAAC,eAAe;gBACjC,UAAU,EAAE,UAAU,CAAC,cAAc;gBACrC,KAAK,EAAE,IAAI,CAAC,KAAK;gBACjB,YAAY,EAAE,UAAU,CAAC,gBAAgB;gBACzC,KAAK,EAAE,UAAU,CAAC,SAAS;gBAC3B,IAAI,EAAE,UAAU,CAAC,QAAQ;aAC1B,CAAC;SACH,CACF,CAAC;IACJ,CAAC;;AAzFH,oCA0FC","sourcesContent":["import * as path from 'path';\nimport * as cdk from 'aws-cdk-lib';\nimport {\n  aws_ec2 as ec2,\n  aws_iam as iam,\n  aws_lambda as lambda,\n  aws_stepfunctions as stepfunctions,\n  aws_stepfunctions_tasks as stepfunctions_tasks,\n} from 'aws-cdk-lib';\nimport { RetentionDays } from 'aws-cdk-lib/aws-logs';\nimport { Construct } from 'constructs';\nimport { IRunnerProvider, RunnerRuntimeParameters, RunnerProviderProps, RunnerVersion } from './common';\n\nexport interface LambdaRunnerProps extends RunnerProviderProps {\n  /**\n   * GitHub Actions label used for this provider.\n   *\n   * @default 'lambda'\n   */\n  readonly label?: string;\n\n  /**\n   * The amount of memory, in MB, that is allocated to your Lambda function.\n   * Lambda uses this value to proportionally allocate the amount of CPU\n   * power. For more information, see Resource Model in the AWS Lambda\n   * Developer Guide.\n   *\n   * @default 2048\n   */\n  readonly memorySize?: number;\n\n  /**\n  * The size of the function’s /tmp directory in MiB.\n  *\n  * @default 10 GiB\n  */\n  readonly ephemeralStorageSize?: cdk.Size;\n\n  /**\n   * The function execution time (in seconds) after which Lambda terminates\n   * the function. Because the execution time affects cost, set this value\n   * based on the function's expected execution time.\n   *\n   * @default Duration.minutes(15)\n   */\n  readonly timeout?: cdk.Duration;\n\n  /**\n  * VPC to launch the runners in.\n  *\n  * @default no VPC\n  */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n  * Security Group to assign to this instance.\n  *\n  * @default public lambda with no security group\n  */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n  * Where to place the network interfaces within the VPC.\n  *\n  * @default no subnet\n  */\n  readonly subnetSelection?: ec2.SubnetSelection;\n}\n\n/**\n * GitHub Actions runner provider using Lambda to execute the actions.\n *\n * Creates a Docker-based function that gets executed for each job.\n *\n * This construct is not meant to be used by itself. It should be passed in the providers property for GitHubRunners.\n */\nexport class LambdaRunner extends Construct implements IRunnerProvider {\n  /**\n   * The function hosting the GitHub runner.\n   */\n  readonly function: lambda.Function;\n\n  /**\n   * Label associated with this provider.\n   */\n  readonly label: string;\n\n  /**\n   * VPC used for hosting the function.\n   */\n  readonly vpc?: ec2.IVpc;\n\n  /**\n   * Security group attached to the function.\n   */\n  readonly securityGroup?: ec2.ISecurityGroup;\n\n  /**\n   * Grant principal used to add permissions to the runner role.\n   */\n  readonly grantPrincipal: iam.IPrincipal;\n\n  constructor(scope: Construct, id: string, props: LambdaRunnerProps) {\n    super(scope, id);\n\n    this.label = props.label || 'lambda';\n    this.vpc = props.vpc;\n    this.securityGroup = props.securityGroup;\n\n    this.function = new lambda.DockerImageFunction(\n      this,\n      'Function',\n      {\n        // https://docs.aws.amazon.com/lambda/latest/dg/images-create.html\n        code: lambda.DockerImageCode.fromImageAsset(\n          path.join(__dirname, 'docker-images', 'lambda'),\n          {\n            buildArgs: {\n              RUNNER_VERSION: props.runnerVersion ? props.runnerVersion.version : RunnerVersion.latest().version,\n            },\n          },\n        ),\n        vpc: this.vpc,\n        securityGroups: this.securityGroup && [this.securityGroup],\n        vpcSubnets: props.subnetSelection,\n        timeout: props.timeout || cdk.Duration.minutes(15),\n        memorySize: props.memorySize || 2048,\n        ephemeralStorageSize: props.ephemeralStorageSize || cdk.Size.gibibytes(10),\n        logRetention: props.logRetention || RetentionDays.ONE_MONTH,\n      },\n    );\n\n    this.grantPrincipal = this.function.grantPrincipal;\n  }\n\n  /**\n   * The network connections associated with this resource.\n   */\n  public get connections(): ec2.Connections {\n    return this.function.connections;\n  }\n\n  /**\n   * Generate step function task(s) to start a new runner.\n   *\n   * Called by GithubRunners and shouldn't be called manually.\n   *\n   * @param parameters workflow job details\n   */\n  getStepFunctionTask(parameters: RunnerRuntimeParameters): stepfunctions.IChainable {\n    return new stepfunctions_tasks.LambdaInvoke(\n      this,\n      'Lambda Runner',\n      {\n        lambdaFunction: this.function,\n        payload: stepfunctions.TaskInput.fromObject({\n          token: parameters.runnerTokenPath,\n          runnerName: parameters.runnerNamePath,\n          label: this.label,\n          githubDomain: parameters.githubDomainPath,\n          owner: parameters.ownerPath,\n          repo: parameters.repoPath,\n        }),\n      },\n    );\n  }\n}"]}

package/lib/runner.d.ts

@@ -2,16 +2,76 @@ import { Construct } from 'constructs';
 import { IRunnerProvider } from './providers/common';
 import { Secrets } from './secrets';
 /**
- * Properties of the GitHubRunners
+ * Properties for GitHubRunners
  */
 export interface GitHubRunnersProps {
+    /**
+     * Label of default provider in case the workflow job doesn't specify any known label. A provider with that label must be configured.
+     *
+     * @default 'codebuild'
+     */
     readonly defaultProviderLabel?: string;
+    /**
+     * List of runner providers to use. At least one provider is required. Provider will be selected when its label matches the labels requested by the workflow job.
+     *
+     * @default CodeBuild, Lambda and Fargate runners with all the defaults (no VPC or default account VPC)
+     */
     readonly providers?: IRunnerProvider[];
 }
+/**
+ * Create all the required infrastructure to provide self-hosted GitHub runners. It creates a webhook, secrets, and a step function to orchestrate all runs. Secrets are not automatically filled. See README.md for instructions on how to setup GitHub integration.
+ *
+ * By default, this will create a runner provider of each available type with the defaults. This is good enough for the initial setup stage when you just want to get GitHub integration working.
+ *
+ * ```typescript
+ * new GitHubRunners(stack, 'runners', {});
+ * ```
+ *
+ * Usually you'd want to configure the runner providers so the runners can run in a certain VPC or have certain permissions.
+ *
+ * ```typescript
+ * const vpc = ec2.Vpc.fromLookup(stack, 'vpc', { vpcId: 'vpc-1234567' });
+ * const runnerSg = new ec2.SecurityGroup(stack, 'runner security group', { vpc: vpc });
+ * const dbSg = ec2.SecurityGroup.fromSecurityGroupId(stack, 'database security group', 'sg-1234567');
+ * const bucket = new s3.Bucket(stack, 'runner bucket');
+ *
+ * // create a custom CodeBuild provider
+ * const myProvider = new CodeBuildRunner(
+ *   stack, 'codebuild runner',
+ *   {
+ *      label: 'my-codebuild',
+ *      vpc: vpc,
+ *      securityGroup: runnerSg,
+ *   },
+ * );
+ * // grant some permissions to the provider
+ * bucket.grantReadWrite(myProvider);
+ * dbSg.connections.allowFrom(runnerSg, ec2.Port.tcp(3306), 'allow runners to connect to MySQL database');
+ *
+ * // create the runner infrastructure
+ * new GitHubRunners(
+ *   stack,
+ *   'runners',
+ *   {
+ *     providers: [myProvider],
+ *     defaultProviderLabel: 'my-codebuild',
+ *   }
+ * );
+ * ```
+ */
 export declare class GitHubRunners extends Construct {
     readonly props: GitHubRunnersProps;
+    /**
+     * Configured runner providers.
+     */
     readonly providers: IRunnerProvider[];
+    /**
+     * Default provider as set by {@link GitHubRunnersProps.defaultProviderLabel}.
+     */
     readonly defaultProvider: IRunnerProvider;
+    /**
+     * Secrets for GitHub communication including webhook secret and runner authentication.
+     */
     readonly secrets: Secrets;
     private readonly webhook;
     private readonly orchestrator;

package/lib/runner.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAEvC,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC;AAED,qBAAa,aAAc,SAAQ,SAAS;IAQA,QAAQ,CAAC,KAAK,EAAE,kBAAkB;IAN5E,QAAQ,CAAC,SAAS,EAAE,eAAe,EAAE,CAAC;IACtC,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;gBAE9C,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAW,KAAK,EAAE,kBAAkB;IA+B5E,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,YAAY;IAwEpB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,eAAe;CAyCxB"}
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC,OAAO,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAGrD,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAIpC;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAEjC;;;;OAIG;IACH,QAAQ,CAAC,oBAAoB,CAAC,EAAE,MAAM,CAAC;IAEvC;;;;OAIG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,eAAe,EAAE,CAAC;CACxC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qBAAa,aAAc,SAAQ,SAAS;IAoBA,QAAQ,CAAC,KAAK,EAAE,kBAAkB;IAlB5E;;OAEG;IACH,QAAQ,CAAC,SAAS,EAAE,eAAe,EAAE,CAAC;IAEtC;;OAEG;IACH,QAAQ,CAAC,eAAe,EAAE,eAAe,CAAC;IAE1C;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAE1B,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAuB;IAC/C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAA6B;gBAE9C,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAW,KAAK,EAAE,kBAAkB;IA+B5E,OAAO,CAAC,kBAAkB;IAU1B,OAAO,CAAC,YAAY;IAwEpB,OAAO,CAAC,cAAc;IAmBtB,OAAO,CAAC,YAAY;IAmBpB,OAAO,CAAC,eAAe;CAyCxB"}

package/lib/runner.js

@@ -12,6 +12,47 @@ const lambda_1 = require("./providers/lambda");
 const secrets_1 = require("./secrets");
 const utils_1 = require("./utils");
 const webhook_1 = require("./webhook");
+/**
+ * Create all the required infrastructure to provide self-hosted GitHub runners. It creates a webhook, secrets, and a step function to orchestrate all runs. Secrets are not automatically filled. See README.md for instructions on how to setup GitHub integration.
+ *
+ * By default, this will create a runner provider of each available type with the defaults. This is good enough for the initial setup stage when you just want to get GitHub integration working.
+ *
+ * ```typescript
+ * new GitHubRunners(stack, 'runners', {});
+ * ```
+ *
+ * Usually you'd want to configure the runner providers so the runners can run in a certain VPC or have certain permissions.
+ *
+ * ```typescript
+ * const vpc = ec2.Vpc.fromLookup(stack, 'vpc', { vpcId: 'vpc-1234567' });
+ * const runnerSg = new ec2.SecurityGroup(stack, 'runner security group', { vpc: vpc });
+ * const dbSg = ec2.SecurityGroup.fromSecurityGroupId(stack, 'database security group', 'sg-1234567');
+ * const bucket = new s3.Bucket(stack, 'runner bucket');
+ *
+ * // create a custom CodeBuild provider
+ * const myProvider = new CodeBuildRunner(
+ *   stack, 'codebuild runner',
+ *   {
+ *      label: 'my-codebuild',
+ *      vpc: vpc,
+ *      securityGroup: runnerSg,
+ *   },
+ * );
+ * // grant some permissions to the provider
+ * bucket.grantReadWrite(myProvider);
+ * dbSg.connections.allowFrom(runnerSg, ec2.Port.tcp(3306), 'allow runners to connect to MySQL database');
+ *
+ * // create the runner infrastructure
+ * new GitHubRunners(
+ *   stack,
+ *   'runners',
+ *   {
+ *     providers: [myProvider],
+ *     defaultProviderLabel: 'my-codebuild',
+ *   }
+ * );
+ * ```
+ */
 class GitHubRunners extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
@@ -150,5 +191,5 @@ class GitHubRunners extends constructs_1.Construct {
 }
 exports.GitHubRunners = GitHubRunners;
 _a = JSII_RTTI_SYMBOL_1;
-GitHubRunners[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.GitHubRunners", version: "0.0.11" };
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { aws_iam as iam, aws_stepfunctions as stepfunctions, aws_stepfunctions_tasks as stepfunctions_tasks } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { CodeBuildRunner } from './providers/codebuild';\nimport { IRunnerProvider } from './providers/common';\nimport { FargateRunner } from './providers/fargate';\nimport { LambdaRunner } from './providers/lambda';\nimport { Secrets } from './secrets';\nimport { BundledNodejsFunction } from './utils';\nimport { GithubWebhookHandler } from './webhook';\n\n/**\n * Properties of the GitHubRunners\n */\nexport interface GitHubRunnersProps {\n  readonly defaultProviderLabel?: string;\n\n  readonly providers?: IRunnerProvider[];\n}\n\nexport class GitHubRunners extends Construct {\n\n  readonly providers: IRunnerProvider[];\n  readonly defaultProvider: IRunnerProvider;\n  readonly secrets: Secrets;\n  private readonly webhook: GithubWebhookHandler;\n  private readonly orchestrator: stepfunctions.StateMachine;\n\n  constructor(scope: Construct, id: string, readonly props: GitHubRunnersProps) {\n    super(scope, id);\n\n    this.secrets = new Secrets(this, 'Secrets');\n\n    if (this.props.providers) {\n      this.providers = this.props.providers;\n    } else {\n      this.providers = [\n        new CodeBuildRunner(this, 'CodeBuild', {}),\n        new LambdaRunner(this, 'Lambda', {}),\n        new FargateRunner(this, 'Fargate', {}),\n      ];\n    }\n\n    const defaultProvider = this.getDefaultProvider();\n    if (!defaultProvider) {\n      throw new Error(`No provider was found for the default label \"${this.props.defaultProviderLabel}\"`);\n    } else {\n      this.defaultProvider = defaultProvider;\n    }\n\n    this.orchestrator = this.stateMachine();\n    this.webhook = new GithubWebhookHandler(this, 'Webhook Handler', {\n      orchestrator: this.orchestrator,\n      secrets: this.secrets,\n    });\n\n    this.statusFunctions();\n  }\n\n  private getDefaultProvider(): IRunnerProvider | null {\n    for (const provider of this.providers) {\n      if ((this.props.defaultProviderLabel || 'codebuild') == provider.label) {\n        return provider;\n      }\n    }\n\n    return null;\n  }\n\n  private stateMachine() {\n    const tokenRetrieverTask = new stepfunctions_tasks.LambdaInvoke(\n      this,\n      'Get Runner Token',\n      {\n        lambdaFunction: this.tokenRetriever(),\n        payloadResponseOnly: true,\n        resultPath: '$.runner',\n      },\n    );\n\n    const deleteRunnerTask = new stepfunctions_tasks.LambdaInvoke(\n      this,\n      'Delete Runner',\n      {\n        lambdaFunction: this.deleteRunner(),\n        payloadResponseOnly: true,\n        resultPath: '$.delete',\n        payload: stepfunctions.TaskInput.fromObject({\n          runnerName: stepfunctions.JsonPath.stringAt('$$.Execution.Name'),\n          owner: stepfunctions.JsonPath.stringAt('$.owner'),\n          repo: stepfunctions.JsonPath.stringAt('$.repo'),\n          runId: stepfunctions.JsonPath.stringAt('$.runId'),\n        }),\n      },\n    );\n\n    const providerChooser = new stepfunctions.Choice(this, 'Choose provider');\n    for (const provider of this.providers) {\n      const providerTask = provider.getStepFunctionTask(\n        {\n          runnerTokenPath: stepfunctions.JsonPath.stringAt('$.runner.token'),\n          runnerNamePath: stepfunctions.JsonPath.stringAt('$$.Execution.Name'),\n          githubDomainPath: stepfunctions.JsonPath.stringAt('$.runner.domain'),\n          ownerPath: stepfunctions.JsonPath.stringAt('$.owner'),\n          repoPath: stepfunctions.JsonPath.stringAt('$.repo'),\n        },\n      );\n      providerChooser.when(\n        stepfunctions.Condition.isPresent(`$.labels.${provider.label}`),\n        providerTask,\n      );\n      if (this.defaultProvider == provider) {\n        providerChooser.otherwise(providerTask);\n      }\n    }\n\n    const work = tokenRetrieverTask.next(\n      new stepfunctions.Parallel(this, 'Error Catcher', { resultPath: '$.result' })\n        .branch(providerChooser)\n        .addCatch(\n          deleteRunnerTask\n            .next(new stepfunctions.Fail(this, 'Runner Failed')),\n          {\n            resultPath: '$.error',\n          },\n        ),\n    );\n\n    const check = new stepfunctions.Choice(this, 'Is self hosted?')\n      .when(stepfunctions.Condition.isNotPresent('$.labels.self-hosted'), new stepfunctions.Succeed(this, 'No'))\n      .otherwise(work);\n\n    return new stepfunctions.StateMachine(\n      this,\n      'Runner Orchestrator',\n      {\n        definition: check,\n      },\n    );\n  }\n\n  private tokenRetriever() {\n    const func = new BundledNodejsFunction(\n      this,\n      'token-retriever',\n      {\n        environment: {\n          GITHUB_SECRET_ARN: this.secrets.github.secretArn,\n          GITHUB_PRIVATE_KEY_SECRET_ARN: this.secrets.githubPrivateKey.secretArn,\n        },\n        timeout: cdk.Duration.seconds(30),\n      },\n    );\n\n    this.secrets.github.grantRead(func);\n    this.secrets.githubPrivateKey.grantRead(func);\n\n    return func;\n  }\n\n  private deleteRunner() {\n    const func = new BundledNodejsFunction(\n      this,\n      'delete-runner',\n      {\n        environment: {\n          GITHUB_SECRET_ARN: this.secrets.github.secretArn,\n          GITHUB_PRIVATE_KEY_SECRET_ARN: this.secrets.githubPrivateKey.secretArn,\n        },\n        timeout: cdk.Duration.seconds(30),\n      },\n    );\n\n    this.secrets.github.grantRead(func);\n    this.secrets.githubPrivateKey.grantRead(func);\n\n    return func;\n  }\n\n  private statusFunctions() {\n    const func = this.providers.map(provider => {\n      return {\n        type: provider.constructor.name,\n        label: provider.label,\n        vpcArn: provider.vpc && provider.vpc.vpcArn,\n        securityGroup: provider.securityGroup && provider.securityGroup.securityGroupId,\n        roleArn: (provider.grantPrincipal.grantPrincipal as iam.Role).roleArn,\n      };\n    });\n\n    const statusFunction = new BundledNodejsFunction(\n      this,\n      'status',\n      {\n        environment: {\n          WEBHOOK_SECRET_ARN: this.secrets.webhook.secretArn,\n          GITHUB_SECRET_ARN: this.secrets.github.secretArn,\n          GITHUB_PRIVATE_KEY_SECRET_ARN: this.secrets.githubPrivateKey.secretArn,\n          WEBHOOK_URL: this.webhook.url,\n          PROVIDERS: JSON.stringify(func),\n          WEBHOOK_HANDLER_ARN: this.webhook.handler.latestVersion.functionArn,\n          STEP_FUNCTION_ARN: this.orchestrator.stateMachineArn,\n        },\n        timeout: cdk.Duration.minutes(3),\n      },\n    );\n\n    this.secrets.webhook.grantRead(statusFunction);\n    this.secrets.github.grantRead(statusFunction);\n    this.secrets.githubPrivateKey.grantRead(statusFunction);\n    this.orchestrator.grantRead(statusFunction);\n\n    new cdk.CfnOutput(\n      this,\n      'status command',\n      {\n        value: `aws --region ${cdk.Stack.of(this).region} lambda invoke --function-name ${statusFunction.functionName} status.json`,\n      },\n    );\n  }\n}\n"]}
+GitHubRunners[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.GitHubRunners", version: "0.0.14" };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"runner.js","sourceRoot":"","sources":["../src/runner.ts"],"names":[],"mappings":"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","sourcesContent":["import * as cdk from 'aws-cdk-lib';\nimport { aws_iam as iam, aws_stepfunctions as stepfunctions, aws_stepfunctions_tasks as stepfunctions_tasks } from 'aws-cdk-lib';\nimport { Construct } from 'constructs';\nimport { CodeBuildRunner } from './providers/codebuild';\nimport { IRunnerProvider } from './providers/common';\nimport { FargateRunner } from './providers/fargate';\nimport { LambdaRunner } from './providers/lambda';\nimport { Secrets } from './secrets';\nimport { BundledNodejsFunction } from './utils';\nimport { GithubWebhookHandler } from './webhook';\n\n/**\n * Properties for GitHubRunners\n */\nexport interface GitHubRunnersProps {\n\n  /**\n   * Label of default provider in case the workflow job doesn't specify any known label. A provider with that label must be configured.\n   *\n   * @default 'codebuild'\n   */\n  readonly defaultProviderLabel?: string;\n\n  /**\n   * List of runner providers to use. At least one provider is required. Provider will be selected when its label matches the labels requested by the workflow job.\n   *\n   * @default CodeBuild, Lambda and Fargate runners with all the defaults (no VPC or default account VPC)\n   */\n  readonly providers?: IRunnerProvider[];\n}\n\n/**\n * Create all the required infrastructure to provide self-hosted GitHub runners. It creates a webhook, secrets, and a step function to orchestrate all runs. Secrets are not automatically filled. See README.md for instructions on how to setup GitHub integration.\n *\n * By default, this will create a runner provider of each available type with the defaults. This is good enough for the initial setup stage when you just want to get GitHub integration working.\n *\n * ```typescript\n * new GitHubRunners(stack, 'runners', {});\n * ```\n *\n * Usually you'd want to configure the runner providers so the runners can run in a certain VPC or have certain permissions.\n *\n * ```typescript\n * const vpc = ec2.Vpc.fromLookup(stack, 'vpc', { vpcId: 'vpc-1234567' });\n * const runnerSg = new ec2.SecurityGroup(stack, 'runner security group', { vpc: vpc });\n * const dbSg = ec2.SecurityGroup.fromSecurityGroupId(stack, 'database security group', 'sg-1234567');\n * const bucket = new s3.Bucket(stack, 'runner bucket');\n *\n * // create a custom CodeBuild provider\n * const myProvider = new CodeBuildRunner(\n *   stack, 'codebuild runner',\n *   {\n *      label: 'my-codebuild',\n *      vpc: vpc,\n *      securityGroup: runnerSg,\n *   },\n * );\n * // grant some permissions to the provider\n * bucket.grantReadWrite(myProvider);\n * dbSg.connections.allowFrom(runnerSg, ec2.Port.tcp(3306), 'allow runners to connect to MySQL database');\n *\n * // create the runner infrastructure\n * new GitHubRunners(\n *   stack,\n *   'runners',\n *   {\n *     providers: [myProvider],\n *     defaultProviderLabel: 'my-codebuild',\n *   }\n * );\n * ```\n */\nexport class GitHubRunners extends Construct {\n\n  /**\n   * Configured runner providers.\n   */\n  readonly providers: IRunnerProvider[];\n\n  /**\n   * Default provider as set by {@link GitHubRunnersProps.defaultProviderLabel}.\n   */\n  readonly defaultProvider: IRunnerProvider;\n\n  /**\n   * Secrets for GitHub communication including webhook secret and runner authentication.\n   */\n  readonly secrets: Secrets;\n\n  private readonly webhook: GithubWebhookHandler;\n  private readonly orchestrator: stepfunctions.StateMachine;\n\n  constructor(scope: Construct, id: string, readonly props: GitHubRunnersProps) {\n    super(scope, id);\n\n    this.secrets = new Secrets(this, 'Secrets');\n\n    if (this.props.providers) {\n      this.providers = this.props.providers;\n    } else {\n      this.providers = [\n        new CodeBuildRunner(this, 'CodeBuild', {}),\n        new LambdaRunner(this, 'Lambda', {}),\n        new FargateRunner(this, 'Fargate', {}),\n      ];\n    }\n\n    const defaultProvider = this.getDefaultProvider();\n    if (!defaultProvider) {\n      throw new Error(`No provider was found for the default label \"${this.props.defaultProviderLabel}\"`);\n    } else {\n      this.defaultProvider = defaultProvider;\n    }\n\n    this.orchestrator = this.stateMachine();\n    this.webhook = new GithubWebhookHandler(this, 'Webhook Handler', {\n      orchestrator: this.orchestrator,\n      secrets: this.secrets,\n    });\n\n    this.statusFunctions();\n  }\n\n  private getDefaultProvider(): IRunnerProvider | null {\n    for (const provider of this.providers) {\n      if ((this.props.defaultProviderLabel || 'codebuild') == provider.label) {\n        return provider;\n      }\n    }\n\n    return null;\n  }\n\n  private stateMachine() {\n    const tokenRetrieverTask = new stepfunctions_tasks.LambdaInvoke(\n      this,\n      'Get Runner Token',\n      {\n        lambdaFunction: this.tokenRetriever(),\n        payloadResponseOnly: true,\n        resultPath: '$.runner',\n      },\n    );\n\n    const deleteRunnerTask = new stepfunctions_tasks.LambdaInvoke(\n      this,\n      'Delete Runner',\n      {\n        lambdaFunction: this.deleteRunner(),\n        payloadResponseOnly: true,\n        resultPath: '$.delete',\n        payload: stepfunctions.TaskInput.fromObject({\n          runnerName: stepfunctions.JsonPath.stringAt('$$.Execution.Name'),\n          owner: stepfunctions.JsonPath.stringAt('$.owner'),\n          repo: stepfunctions.JsonPath.stringAt('$.repo'),\n          runId: stepfunctions.JsonPath.stringAt('$.runId'),\n        }),\n      },\n    );\n\n    const providerChooser = new stepfunctions.Choice(this, 'Choose provider');\n    for (const provider of this.providers) {\n      const providerTask = provider.getStepFunctionTask(\n        {\n          runnerTokenPath: stepfunctions.JsonPath.stringAt('$.runner.token'),\n          runnerNamePath: stepfunctions.JsonPath.stringAt('$$.Execution.Name'),\n          githubDomainPath: stepfunctions.JsonPath.stringAt('$.runner.domain'),\n          ownerPath: stepfunctions.JsonPath.stringAt('$.owner'),\n          repoPath: stepfunctions.JsonPath.stringAt('$.repo'),\n        },\n      );\n      providerChooser.when(\n        stepfunctions.Condition.isPresent(`$.labels.${provider.label}`),\n        providerTask,\n      );\n      if (this.defaultProvider == provider) {\n        providerChooser.otherwise(providerTask);\n      }\n    }\n\n    const work = tokenRetrieverTask.next(\n      new stepfunctions.Parallel(this, 'Error Catcher', { resultPath: '$.result' })\n        .branch(providerChooser)\n        .addCatch(\n          deleteRunnerTask\n            .next(new stepfunctions.Fail(this, 'Runner Failed')),\n          {\n            resultPath: '$.error',\n          },\n        ),\n    );\n\n    const check = new stepfunctions.Choice(this, 'Is self hosted?')\n      .when(stepfunctions.Condition.isNotPresent('$.labels.self-hosted'), new stepfunctions.Succeed(this, 'No'))\n      .otherwise(work);\n\n    return new stepfunctions.StateMachine(\n      this,\n      'Runner Orchestrator',\n      {\n        definition: check,\n      },\n    );\n  }\n\n  private tokenRetriever() {\n    const func = new BundledNodejsFunction(\n      this,\n      'token-retriever',\n      {\n        environment: {\n          GITHUB_SECRET_ARN: this.secrets.github.secretArn,\n          GITHUB_PRIVATE_KEY_SECRET_ARN: this.secrets.githubPrivateKey.secretArn,\n        },\n        timeout: cdk.Duration.seconds(30),\n      },\n    );\n\n    this.secrets.github.grantRead(func);\n    this.secrets.githubPrivateKey.grantRead(func);\n\n    return func;\n  }\n\n  private deleteRunner() {\n    const func = new BundledNodejsFunction(\n      this,\n      'delete-runner',\n      {\n        environment: {\n          GITHUB_SECRET_ARN: this.secrets.github.secretArn,\n          GITHUB_PRIVATE_KEY_SECRET_ARN: this.secrets.githubPrivateKey.secretArn,\n        },\n        timeout: cdk.Duration.seconds(30),\n      },\n    );\n\n    this.secrets.github.grantRead(func);\n    this.secrets.githubPrivateKey.grantRead(func);\n\n    return func;\n  }\n\n  private statusFunctions() {\n    const func = this.providers.map(provider => {\n      return {\n        type: provider.constructor.name,\n        label: provider.label,\n        vpcArn: provider.vpc && provider.vpc.vpcArn,\n        securityGroup: provider.securityGroup && provider.securityGroup.securityGroupId,\n        roleArn: (provider.grantPrincipal.grantPrincipal as iam.Role).roleArn,\n      };\n    });\n\n    const statusFunction = new BundledNodejsFunction(\n      this,\n      'status',\n      {\n        environment: {\n          WEBHOOK_SECRET_ARN: this.secrets.webhook.secretArn,\n          GITHUB_SECRET_ARN: this.secrets.github.secretArn,\n          GITHUB_PRIVATE_KEY_SECRET_ARN: this.secrets.githubPrivateKey.secretArn,\n          WEBHOOK_URL: this.webhook.url,\n          PROVIDERS: JSON.stringify(func),\n          WEBHOOK_HANDLER_ARN: this.webhook.handler.latestVersion.functionArn,\n          STEP_FUNCTION_ARN: this.orchestrator.stateMachineArn,\n        },\n        timeout: cdk.Duration.minutes(3),\n      },\n    );\n\n    this.secrets.webhook.grantRead(statusFunction);\n    this.secrets.github.grantRead(statusFunction);\n    this.secrets.githubPrivateKey.grantRead(statusFunction);\n    this.orchestrator.grantRead(statusFunction);\n\n    new cdk.CfnOutput(\n      this,\n      'status command',\n      {\n        value: `aws --region ${cdk.Stack.of(this).region} lambda invoke --function-name ${statusFunction.functionName} status.json`,\n      },\n    );\n  }\n}\n"]}

package/lib/secrets.d.ts

@@ -4,8 +4,22 @@ import { Construct } from 'constructs';
  * Secrets required for GitHub runners operation.
  */
 export declare class Secrets extends Construct {
+    /**
+     * Webhook secret used to confirm events are coming from GitHub and nowhere else.
+     */
     readonly webhook: secretsmanager.Secret;
+    /**
+     * Authentication secret for GitHub containing either app details or personal authentication token. This secret is used to register runners and
+     * cancel jobs when the runner fails to start.
+     *
+     * This secret is meant to be edited by the user after being created.
+     */
     readonly github: secretsmanager.Secret;
+    /**
+     * GitHub app private key. Not needed when using personal authentication tokens.
+     *
+     * This secret is meant to be edited by the user after being created.
+     */
     readonly githubPrivateKey: secretsmanager.Secret;
     constructor(scope: Construct, id: string);
 }

package/lib/secrets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../src/secrets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,IAAI,cAAc,EAAE,MAAM,aAAa,CAAC;AAEnE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC;;GAEG;AACH,qBAAa,OAAQ,SAAQ,SAAS;IACpC,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,MAAM,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC;IACvC,QAAQ,CAAC,gBAAgB,EAAE,cAAc,CAAC,MAAM,CAAC;gBAErC,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM;CA6CzC"}
+{"version":3,"file":"secrets.d.ts","sourceRoot":"","sources":["../src/secrets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,IAAI,cAAc,EAAE,MAAM,aAAa,CAAC;AAEnE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC;;GAEG;AACH,qBAAa,OAAQ,SAAQ,SAAS;IACpC;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,cAAc,CAAC,MAAM,CAAC;IAExC;;;;;OAKG;IACH,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC,MAAM,CAAC;IAEvC;;;;OAIG;IACH,QAAQ,CAAC,gBAAgB,EAAE,cAAc,CAAC,MAAM,CAAC;gBAErC,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM;CA6CzC"}

package/lib/secrets.js

@@ -43,5 +43,5 @@ class Secrets extends constructs_1.Construct {
 }
 exports.Secrets = Secrets;
 _a = JSII_RTTI_SYMBOL_1;
-Secrets[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.Secrets", version: "0.0.11" };
-//# sourceMappingURL=data:application/json;base64,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
+Secrets[_a] = { fqn: "@cloudsnorkel/cdk-github-runners.Secrets", version: "0.0.14" };
+//# sourceMappingURL=data:application/json;base64,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

package/lib/utils.d.ts

@@ -1,5 +1,8 @@
 import { aws_lambda as lambda } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
+/**
+ * Lambda Function wrapper that uses pre-bundled JavaScript file from the known folder `lib/lambdas` with some reasonable defaults. The bundled files are put there by projen tasks that use esbuild to bundle TypeScript files from `src/lambdas`. This code is found in `.projenrc.js`.
+ */
 export declare class BundledNodejsFunction extends lambda.Function {
     readonly props: lambda.FunctionOptions;
     constructor(scope: Construct, id: string, props: lambda.FunctionOptions);

package/lib/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,IAAI,MAAM,EAAoB,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAGvC,qBAAa,qBAAsB,SAAQ,MAAM,CAAC,QAAQ;IACd,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,eAAe;gBAApE,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAW,KAAK,EAAE,MAAM,CAAC,eAAe;CASjF"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,IAAI,MAAM,EAAoB,MAAM,aAAa,CAAC;AACrE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAEvC;;GAEG;AACH,qBAAa,qBAAsB,SAAQ,MAAM,CAAC,QAAQ;IACd,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC,eAAe;gBAApE,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAW,KAAK,EAAE,MAAM,CAAC,eAAe;CASjF"}

package/lib/utils.js

@@ -3,7 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.BundledNodejsFunction = void 0;
 const path = require("path");
 const aws_cdk_lib_1 = require("aws-cdk-lib");
-// projen defines the bundling as a post compile task. it's defined at the bottom of .projenrc.js.
+/**
+ * Lambda Function wrapper that uses pre-bundled JavaScript file from the known folder `lib/lambdas` with some reasonable defaults. The bundled files are put there by projen tasks that use esbuild to bundle TypeScript files from `src/lambdas`. This code is found in `.projenrc.js`.
+ */
 class BundledNodejsFunction extends aws_cdk_lib_1.aws_lambda.Function {
     constructor(scope, id, props) {
         super(scope, id, {
@@ -17,4 +19,4 @@ class BundledNodejsFunction extends aws_cdk_lib_1.aws_lambda.Function {
     }
 }
 exports.BundledNodejsFunction = BundledNodejsFunction;
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNkJBQTZCO0FBQzdCLDZDQUFxRTtBQUdyRSxrR0FBa0c7QUFDbEcsTUFBYSxxQkFBc0IsU0FBUSx3QkFBTSxDQUFDLFFBQVE7SUFDeEQsWUFBWSxLQUFnQixFQUFFLEVBQVUsRUFBVyxLQUE2QjtRQUM5RSxLQUFLLENBQUMsS0FBSyxFQUFFLEVBQUUsRUFBRTtZQUNmLEdBQUcsS0FBSztZQUNSLElBQUksRUFBRSx3QkFBTSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsSUFBSSxDQUFDLElBQUksQ0FBQyxTQUFTLEVBQUUsU0FBUyxFQUFFLEVBQUUsQ0FBQyxDQUFDO1lBQ2hFLE9BQU8sRUFBRSxlQUFlO1lBQ3hCLE9BQU8sRUFBRSx3QkFBTSxDQUFDLE9BQU8sQ0FBQyxXQUFXO1lBQ25DLFlBQVksRUFBRSxzQkFBSSxDQUFDLGFBQWEsQ0FBQyxTQUFTO1NBQzNDLENBQUMsQ0FBQztRQVA4QyxVQUFLLEdBQUwsS0FBSyxDQUF3QjtJQVFoRixDQUFDO0NBQ0Y7QUFWRCxzREFVQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCAqIGFzIHBhdGggZnJvbSAncGF0aCc7XG5pbXBvcnQgeyBhd3NfbGFtYmRhIGFzIGxhbWJkYSwgYXdzX2xvZ3MgYXMgbG9ncyB9IGZyb20gJ2F3cy1jZGstbGliJztcbmltcG9ydCB7IENvbnN0cnVjdCB9IGZyb20gJ2NvbnN0cnVjdHMnO1xuXG4vLyBwcm9qZW4gZGVmaW5lcyB0aGUgYnVuZGxpbmcgYXMgYSBwb3N0IGNvbXBpbGUgdGFzay4gaXQncyBkZWZpbmVkIGF0IHRoZSBib3R0b20gb2YgLnByb2plbnJjLmpzLlxuZXhwb3J0IGNsYXNzIEJ1bmRsZWROb2RlanNGdW5jdGlvbiBleHRlbmRzIGxhbWJkYS5GdW5jdGlvbiB7XG4gIGNvbnN0cnVjdG9yKHNjb3BlOiBDb25zdHJ1Y3QsIGlkOiBzdHJpbmcsIHJlYWRvbmx5IHByb3BzOiBsYW1iZGEuRnVuY3Rpb25PcHRpb25zKSB7XG4gICAgc3VwZXIoc2NvcGUsIGlkLCB7XG4gICAgICAuLi5wcm9wcyxcbiAgICAgIGNvZGU6IGxhbWJkYS5Db2RlLmZyb21Bc3NldChwYXRoLmpvaW4oX19kaXJuYW1lLCAnbGFtYmRhcycsIGlkKSksXG4gICAgICBoYW5kbGVyOiAnaW5kZXguaGFuZGxlcicsXG4gICAgICBydW50aW1lOiBsYW1iZGEuUnVudGltZS5OT0RFSlNfMTRfWCxcbiAgICAgIGxvZ1JldGVudGlvbjogbG9ncy5SZXRlbnRpb25EYXlzLk9ORV9NT05USCxcbiAgICB9KTtcbiAgfVxufSJdfQ==
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXRpbHMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi9zcmMvdXRpbHMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7O0FBQUEsNkJBQTZCO0FBQzdCLDZDQUFxRTtBQUdyRTs7R0FFRztBQUNILE1BQWEscUJBQXNCLFNBQVEsd0JBQU0sQ0FBQyxRQUFRO0lBQ3hELFlBQVksS0FBZ0IsRUFBRSxFQUFVLEVBQVcsS0FBNkI7UUFDOUUsS0FBSyxDQUFDLEtBQUssRUFBRSxFQUFFLEVBQUU7WUFDZixHQUFHLEtBQUs7WUFDUixJQUFJLEVBQUUsd0JBQU0sQ0FBQyxJQUFJLENBQUMsU0FBUyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsU0FBUyxFQUFFLFNBQVMsRUFBRSxFQUFFLENBQUMsQ0FBQztZQUNoRSxPQUFPLEVBQUUsZUFBZTtZQUN4QixPQUFPLEVBQUUsd0JBQU0sQ0FBQyxPQUFPLENBQUMsV0FBVztZQUNuQyxZQUFZLEVBQUUsc0JBQUksQ0FBQyxhQUFhLENBQUMsU0FBUztTQUMzQyxDQUFDLENBQUM7UUFQOEMsVUFBSyxHQUFMLEtBQUssQ0FBd0I7SUFRaEYsQ0FBQztDQUNGO0FBVkQsc0RBVUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgKiBhcyBwYXRoIGZyb20gJ3BhdGgnO1xuaW1wb3J0IHsgYXdzX2xhbWJkYSBhcyBsYW1iZGEsIGF3c19sb2dzIGFzIGxvZ3MgfSBmcm9tICdhd3MtY2RrLWxpYic7XG5pbXBvcnQgeyBDb25zdHJ1Y3QgfSBmcm9tICdjb25zdHJ1Y3RzJztcblxuLyoqXG4gKiBMYW1iZGEgRnVuY3Rpb24gd3JhcHBlciB0aGF0IHVzZXMgcHJlLWJ1bmRsZWQgSmF2YVNjcmlwdCBmaWxlIGZyb20gdGhlIGtub3duIGZvbGRlciBgbGliL2xhbWJkYXNgIHdpdGggc29tZSByZWFzb25hYmxlIGRlZmF1bHRzLiBUaGUgYnVuZGxlZCBmaWxlcyBhcmUgcHV0IHRoZXJlIGJ5IHByb2plbiB0YXNrcyB0aGF0IHVzZSBlc2J1aWxkIHRvIGJ1bmRsZSBUeXBlU2NyaXB0IGZpbGVzIGZyb20gYHNyYy9sYW1iZGFzYC4gVGhpcyBjb2RlIGlzIGZvdW5kIGluIGAucHJvamVucmMuanNgLlxuICovXG5leHBvcnQgY2xhc3MgQnVuZGxlZE5vZGVqc0Z1bmN0aW9uIGV4dGVuZHMgbGFtYmRhLkZ1bmN0aW9uIHtcbiAgY29uc3RydWN0b3Ioc2NvcGU6IENvbnN0cnVjdCwgaWQ6IHN0cmluZywgcmVhZG9ubHkgcHJvcHM6IGxhbWJkYS5GdW5jdGlvbk9wdGlvbnMpIHtcbiAgICBzdXBlcihzY29wZSwgaWQsIHtcbiAgICAgIC4uLnByb3BzLFxuICAgICAgY29kZTogbGFtYmRhLkNvZGUuZnJvbUFzc2V0KHBhdGguam9pbihfX2Rpcm5hbWUsICdsYW1iZGFzJywgaWQpKSxcbiAgICAgIGhhbmRsZXI6ICdpbmRleC5oYW5kbGVyJyxcbiAgICAgIHJ1bnRpbWU6IGxhbWJkYS5SdW50aW1lLk5PREVKU18xNF9YLFxuICAgICAgbG9nUmV0ZW50aW9uOiBsb2dzLlJldGVudGlvbkRheXMuT05FX01PTlRILFxuICAgIH0pO1xuICB9XG59Il19

package/lib/webhook.d.ts

@@ -2,12 +2,32 @@ import { aws_stepfunctions as stepfunctions } from 'aws-cdk-lib';
 import { Construct } from 'constructs';
 import { Secrets } from './secrets';
 import { BundledNodejsFunction } from './utils';
+/**
+ * Properties for GithubWebhookHandler
+ */
 export interface GithubWebhookHandlerProps {
+    /**
+     * Step function in charge of handling the workflow job events and start the runners.
+     */
     readonly orchestrator: stepfunctions.StateMachine;
+    /**
+     * Secrets used to communicate with GitHub.
+     */
     readonly secrets: Secrets;
 }
+/**
+ * Create a Lambda with a public URL to handle GitHub webhook events. After validating the event with the given secret, the orchestrator step function is called with information about the workflow job.
+ *
+ * This construct is not meant to be used by itself.
+ */
 export declare class GithubWebhookHandler extends Construct {
+    /**
+     * Public URL of webhook to be used with GitHub.
+     */
     readonly url: string;
+    /**
+     * Webhook event handler.
+     */
     readonly handler: BundledNodejsFunction;
     constructor(scope: Construct, id: string, props: GithubWebhookHandlerProps);
 }

package/lib/webhook.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webhook.d.ts","sourceRoot":"","sources":["../src/webhook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEhD,MAAM,WAAW,yBAAyB;IACxC,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,YAAY,CAAC;IAClD,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED,qBAAa,oBAAqB,SAAQ,SAAS;IACjD,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;gBAE5B,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,yBAAyB;CAoB3E"}
+{"version":3,"file":"webhook.d.ts","sourceRoot":"","sources":["../src/webhook.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,IAAI,aAAa,EAAE,MAAM,aAAa,CAAC;AAGjE,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAEhD;;GAEG;AACH,MAAM,WAAW,yBAAyB;IAExC;;OAEG;IACH,QAAQ,CAAC,YAAY,EAAE,aAAa,CAAC,YAAY,CAAC;IAElD;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;CAC3B;AAED;;;;GAIG;AACH,qBAAa,oBAAqB,SAAQ,SAAS;IAEjD;;OAEG;IACH,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,qBAAqB,CAAC;gBAE5B,KAAK,EAAE,SAAS,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,yBAAyB;CAoB3E"}

package/lib/webhook.js

@@ -5,6 +5,11 @@ const cdk = require("aws-cdk-lib");
 const aws_lambda_1 = require("aws-cdk-lib/aws-lambda");
 const constructs_1 = require("constructs");
 const utils_1 = require("./utils");
+/**
+ * Create a Lambda with a public URL to handle GitHub webhook events. After validating the event with the given secret, the orchestrator step function is called with information about the workflow job.
+ *
+ * This construct is not meant to be used by itself.
+ */
 class GithubWebhookHandler extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
@@ -21,4 +26,4 @@ class GithubWebhookHandler extends constructs_1.Construct {
     }
 }
 exports.GithubWebhookHandler = GithubWebhookHandler;
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -48,9 +48,9 @@
     "@typescript-eslint/eslint-plugin": "^5",
     "@typescript-eslint/parser": "^5",
     "aws-cdk-lib": "2.21.1",
-    "aws-sdk": "^2.1140.0",
+    "aws-sdk": "^2.1146.0",
     "constructs": "10.0.5",
-    "esbuild": "^0.14.39",
+    "esbuild": "^0.14.42",
     "eslint": "^8",
     "eslint-import-resolver-node": "^0.3.6",
     "eslint-import-resolver-typescript": "^2.7.1",
@@ -63,10 +63,10 @@
     "jsii-pacmak": "^1.59.0",
     "json-schema": "^0.4.0",
     "npm-check-updates": "^12",
-    "projen": "^0.56.25",
+    "projen": "^0.56.41",
     "standard-version": "^9",
     "ts-jest": "^27",
-    "typescript": "^4.6.4"
+    "typescript": "^4.7.2"
   },
   "peerDependencies": {
     "aws-cdk-lib": "^2.21.1",
@@ -86,7 +86,7 @@
   ],
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "0.0.11",
+  "version": "0.0.14",
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",

package/releasetag.txt

@@ -1 +1 @@
-v0.0.11
+v0.0.14

package/version.txt

@@ -1 +1 @@
-0.0.11
+0.0.14