token-injectable-docker-builder 0.1.4 → 0.1.6

package/LICENSE.md

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2024] [Alex Stepansky]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,6 +1,6 @@
 # TokenInjectableDockerBuilder
 
-The `TokenInjectableDockerBuilder` is a flexible AWS CDK construct that enabled the usage of AWS CDK tokens in the building, pushing, and deployment of Docker images to Amazon Elastic Container Registry (ECR). It leverages AWS CodeBuild and Lambda custom resources. 
+The `TokenInjectableDockerBuilder` is a flexible AWS CDK construct that enables the usage of AWS CDK tokens in the building, pushing, and deployment of Docker images to Amazon Elastic Container Registry (ECR). It leverages AWS CodeBuild and Lambda custom resources. 
 
 ## Why?
 
@@ -162,3 +162,5 @@ Ensure you have the following:
 ## Support
 
 Open an issue on [GitHub](https://github.com/AlexTech314/TokenInjectableDockerBuilder) :)
+
+

package/lib/index.d.ts

@@ -1,16 +1,62 @@
 import { DockerImageCode } from 'aws-cdk-lib/aws-lambda';
 import { Construct } from 'constructs';
 import { ContainerImage } from 'aws-cdk-lib/aws-ecs';
+/**
+ * Properties for the `TokenInjectableDockerBuilder` construct.
+ */
 export interface TokenInjectableDockerBuilderProps {
+    /**
+     * The path to the directory containing the Dockerfile or source code.
+     */
     path: string;
+    /**
+     * Build arguments to pass to the Docker build process.
+     * These are transformed into `--build-arg` flags.
+     * @example
+     * {
+     *   TOKEN: 'my-secret-token',
+     *   ENV: 'production'
+     * }
+     */
     buildArgs?: {
         [key: string]: string;
     };
 }
+/**
+ * A CDK construct to build and push Docker images to an ECR repository using CodeBuild and Lambda custom resources.
+ *
+ * @example
+ * const dockerBuilder = new TokenInjectableDockerBuilder(this, 'DockerBuilder', {
+ *   path: './docker',
+ *   buildArgs: {
+ *     TOKEN: 'my-secret-token',
+ *     ENV: 'production'
+ *   },
+ * });
+ *
+ * const containerImage = dockerBuilder.getContainerImage();
+ */
 export declare class TokenInjectableDockerBuilder extends Construct {
     private readonly ecrRepository;
     private readonly buildTriggerResource;
+    /**
+     * Creates a new `TokenInjectableDockerBuilder` instance.
+     *
+     * @param scope The parent construct/stack.
+     * @param id The unique ID of the construct.
+     * @param props Configuration properties for the construct.
+     */
     constructor(scope: Construct, id: string, props: TokenInjectableDockerBuilderProps);
+    /**
+     * Retrieves the container image from the ECR repository.
+     *
+     * @returns A `ContainerImage` object representing the built image.
+     */
     getContainerImage(): ContainerImage;
+    /**
+     * Retrieves the Docker image code for use in AWS Lambda.
+     *
+     * @returns A `DockerImageCode` object for the Docker image.
+     */
     getDockerImageCode(): DockerImageCode;
 }

package/lib/index.js

@@ -13,7 +13,28 @@ const constructs_1 = require("constructs");
 const aws_ecs_1 = require("aws-cdk-lib/aws-ecs");
 const crypto = require("crypto");
 const aws_lambda_2 = require("aws-cdk-lib/aws-lambda");
+/**
+ * A CDK construct to build and push Docker images to an ECR repository using CodeBuild and Lambda custom resources.
+ *
+ * @example
+ * const dockerBuilder = new TokenInjectableDockerBuilder(this, 'DockerBuilder', {
+ *   path: './docker',
+ *   buildArgs: {
+ *     TOKEN: 'my-secret-token',
+ *     ENV: 'production'
+ *   },
+ * });
+ *
+ * const containerImage = dockerBuilder.getContainerImage();
+ */
 class TokenInjectableDockerBuilder extends constructs_1.Construct {
+    /**
+     * Creates a new `TokenInjectableDockerBuilder` instance.
+     *
+     * @param scope The parent construct/stack.
+     * @param id The unique ID of the construct.
+     * @param props Configuration properties for the construct.
+     */
     constructor(scope, id, props) {
         super(scope, id);
         const { path: sourcePath, buildArgs } = props; // Default to linux/amd64
@@ -87,7 +108,7 @@ class TokenInjectableDockerBuilder extends constructs_1.Construct {
         }));
         // Create Node.js Lambda function for onEvent
         const onEventHandlerFunction = new aws_lambda_2.Function(this, 'OnEventHandlerFunction', {
-            runtime: aws_lambda_1.Runtime.NODEJS_18_X, // Use Node.js runtime
+            runtime: aws_lambda_1.Runtime.NODEJS_LATEST, // Use Node.js runtime
             code: aws_lambda_1.Code.fromAsset(onEventHandlerPath), // Path to handler code
             handler: 'index.handler', // Entry point (adjust as needed)
             timeout: aws_cdk_lib_1.Duration.minutes(15),
@@ -98,7 +119,7 @@ class TokenInjectableDockerBuilder extends constructs_1.Construct {
         }));
         // Create Node.js Lambda function for isComplete
         const isCompleteHandlerFunction = new aws_lambda_2.Function(this, 'IsCompleteHandlerFunction', {
-            runtime: aws_lambda_1.Runtime.NODEJS_18_X,
+            runtime: aws_lambda_1.Runtime.NODEJS_LATEST,
             code: aws_lambda_1.Code.fromAsset(isCompleteHandlerPath),
             handler: 'index.handler',
             timeout: aws_cdk_lib_1.Duration.minutes(15),
@@ -129,12 +150,22 @@ class TokenInjectableDockerBuilder extends constructs_1.Construct {
         });
         this.buildTriggerResource.node.addDependency(codeBuildProject);
     }
+    /**
+     * Retrieves the container image from the ECR repository.
+     *
+     * @returns A `ContainerImage` object representing the built image.
+     */
     getContainerImage() {
         return aws_ecs_1.ContainerImage.fromEcrRepository(this.ecrRepository, 'latest');
     }
+    /**
+     * Retrieves the Docker image code for use in AWS Lambda.
+     *
+     * @returns A `DockerImageCode` object for the Docker image.
+     */
     getDockerImageCode() {
         return aws_lambda_1.DockerImageCode.fromEcr(this.ecrRepository);
     }
 }
 exports.TokenInjectableDockerBuilder = TokenInjectableDockerBuilder;
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { Duration, CustomResource, Stack } from 'aws-cdk-lib';\nimport { Project, Source, LinuxBuildImage, BuildSpec } from 'aws-cdk-lib/aws-codebuild';\nimport { Repository } from 'aws-cdk-lib/aws-ecr';\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Code, DockerImageCode, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport { Asset } from 'aws-cdk-lib/aws-s3-assets';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport { Construct } from 'constructs';\nimport { ContainerImage } from 'aws-cdk-lib/aws-ecs';\nimport * as crypto from 'crypto';\nimport { Function } from 'aws-cdk-lib/aws-lambda';\n\nexport interface TokenInjectableDockerBuilderProps {\n  path: string;\n  buildArgs?: { [key: string]: string };\n}\n\nexport class TokenInjectableDockerBuilder extends Construct {\n  private readonly ecrRepository: Repository;\n  private readonly buildTriggerResource: CustomResource;\n\n  constructor(scope: Construct, id: string, props: TokenInjectableDockerBuilderProps) {\n    super(scope, id);\n\n    const { path: sourcePath, buildArgs } = props; // Default to linux/amd64\n\n    // Define absolute paths for Lambda handlers\n    const onEventHandlerPath = path.resolve(__dirname, '../src/onEventHandler');\n    const isCompleteHandlerPath = path.resolve(__dirname, '../src/isCompleteHandler');\n\n    // Create an ECR repository\n    this.ecrRepository = new Repository(this, 'ECRRepository');\n\n    // Package the source code as an asset\n    const sourceAsset = new Asset(this, 'SourceAsset', {\n      path: sourcePath, // Path to the Dockerfile or source code\n    });\n\n    // Transform buildArgs into a string of --build-arg KEY=VALUE\n    const buildArgsString = buildArgs\n      ? Object.entries(buildArgs)\n          .map(([key, value]) => `--build-arg ${key}=${value}`)\n          .join(' ')\n      : '';\n\n    // Pass the buildArgsString and platform as environment variables\n    const environmentVariables: { [name: string]: { value: string } } = {\n      ECR_REPO_URI: { value: this.ecrRepository.repositoryUri },\n      BUILD_ARGS: { value: buildArgsString },\n    };\n\n    // Create a CodeBuild project\n    const codeBuildProject = new Project(this, 'UICodeBuildProject', {\n      source: Source.s3({\n        bucket: sourceAsset.bucket,\n        path: sourceAsset.s3ObjectKey,\n      }),\n      environment: {\n        buildImage: LinuxBuildImage.STANDARD_7_0,\n        privileged: true, // Required for Docker builds\n      },\n      environmentVariables: environmentVariables,\n      buildSpec: BuildSpec.fromObject({\n        version: '0.2',\n        phases: {\n          pre_build: {\n            commands: [\n              'echo \"Retrieving AWS Account ID...\"',\n              'export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)',\n              'echo \"Logging in to Amazon ECR...\"',\n              'aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com',\n            ],\n          },\n          build: {\n            commands: [\n              'echo Build phase: Building the Docker image...',\n              'docker build $BUILD_ARGS -t $ECR_REPO_URI:latest $CODEBUILD_SRC_DIR',\n            ],\n          },\n          post_build: {\n            commands: [\n              'echo Post-build phase: Pushing the Docker image...',\n              'docker push $ECR_REPO_URI:latest',\n            ],\n          },\n        },\n      }),\n    });\n\n    // Grant permissions to interact with ECR\n    this.ecrRepository.grantPullPush(codeBuildProject);\n\n    codeBuildProject.role!.addToPrincipalPolicy(\n      new PolicyStatement({\n        actions: ['ecr:GetAuthorizationToken'],\n        resources: ['*'],\n      })\n    );\n\n    // Grant permissions to CodeBuild for CloudWatch Logs\n    codeBuildProject.role!.addToPrincipalPolicy(\n      new PolicyStatement({\n        actions: ['logs:PutLogEvents', 'logs:CreateLogGroup', 'logs:CreateLogStream'],\n        resources: [`arn:aws:logs:${Stack.of(this).region}:${Stack.of(this).account}:*`],\n      })\n    );\n\n    // Create Node.js Lambda function for onEvent\n    const onEventHandlerFunction = new Function(this, 'OnEventHandlerFunction', {\n      runtime: Runtime.NODEJS_18_X, // Use Node.js runtime\n      code: Code.fromAsset(onEventHandlerPath), // Path to handler code\n      handler: 'index.handler', // Entry point (adjust as needed)\n      timeout: Duration.minutes(15),\n    });\n\n    onEventHandlerFunction.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['codebuild:StartBuild'],\n        resources: [codeBuildProject.projectArn], // Restrict to specific project\n      })\n    );\n\n    // Create Node.js Lambda function for isComplete\n    const isCompleteHandlerFunction = new Function(this, 'IsCompleteHandlerFunction', {\n      runtime: Runtime.NODEJS_18_X,\n      code: Code.fromAsset(isCompleteHandlerPath),\n      handler: 'index.handler',\n      timeout: Duration.minutes(15),\n    });\n\n    isCompleteHandlerFunction.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'codebuild:BatchGetBuilds',\n          'codebuild:ListBuildsForProject',\n          'logs:GetLogEvents',\n          'logs:DescribeLogStreams',\n          'logs:DescribeLogGroups'\n        ],\n        resources: ['*'],\n      })\n    );\n\n    // Create a custom resource provider\n    const provider = new Provider(this, 'CustomResourceProvider', {\n      onEventHandler: onEventHandlerFunction,\n      isCompleteHandler: isCompleteHandlerFunction,\n      queryInterval: Duration.minutes(1),\n    });\n\n    // Define the custom resource\n    this.buildTriggerResource = new CustomResource(this, 'BuildTriggerResource', {\n      serviceToken: provider.serviceToken,\n      properties: {\n        ProjectName: codeBuildProject.projectName,\n        Trigger: crypto.randomUUID(),\n      },\n    });\n\n    this.buildTriggerResource.node.addDependency(codeBuildProject);\n  }\n\n  public getContainerImage(): ContainerImage {\n    return ContainerImage.fromEcrRepository(this.ecrRepository, 'latest');\n  }\n\n  public getDockerImageCode(): DockerImageCode {\n    return DockerImageCode.fromEcr(this.ecrRepository);\n  }\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport { Duration, CustomResource, Stack } from 'aws-cdk-lib';\nimport { Project, Source, LinuxBuildImage, BuildSpec } from 'aws-cdk-lib/aws-codebuild';\nimport { Repository } from 'aws-cdk-lib/aws-ecr';\nimport { PolicyStatement } from 'aws-cdk-lib/aws-iam';\nimport { Code, DockerImageCode, Runtime } from 'aws-cdk-lib/aws-lambda';\nimport { Asset } from 'aws-cdk-lib/aws-s3-assets';\nimport { Provider } from 'aws-cdk-lib/custom-resources';\nimport { Construct } from 'constructs';\nimport { ContainerImage } from 'aws-cdk-lib/aws-ecs';\nimport * as crypto from 'crypto';\nimport { Function } from 'aws-cdk-lib/aws-lambda';\n\n\n/**\n * Properties for the `TokenInjectableDockerBuilder` construct.\n */\nexport interface TokenInjectableDockerBuilderProps {\n  /**\n   * The path to the directory containing the Dockerfile or source code.\n   */\n  path: string;\n\n  /**\n   * Build arguments to pass to the Docker build process.\n   * These are transformed into `--build-arg` flags.\n   * @example\n   * {\n   *   TOKEN: 'my-secret-token',\n   *   ENV: 'production'\n   * }\n   */\n  buildArgs?: { [key: string]: string };\n}\n\n\n/**\n * A CDK construct to build and push Docker images to an ECR repository using CodeBuild and Lambda custom resources.\n *\n * @example\n * const dockerBuilder = new TokenInjectableDockerBuilder(this, 'DockerBuilder', {\n *   path: './docker',\n *   buildArgs: {\n *     TOKEN: 'my-secret-token',\n *     ENV: 'production'\n *   },\n * });\n *\n * const containerImage = dockerBuilder.getContainerImage();\n */\nexport class TokenInjectableDockerBuilder extends Construct {\n  private readonly ecrRepository: Repository;\n  private readonly buildTriggerResource: CustomResource;\n\n  /**\n   * Creates a new `TokenInjectableDockerBuilder` instance.\n   *\n   * @param scope The parent construct/stack.\n   * @param id The unique ID of the construct.\n   * @param props Configuration properties for the construct.\n   */\n  constructor(scope: Construct, id: string, props: TokenInjectableDockerBuilderProps) {\n    super(scope, id);\n\n    const { path: sourcePath, buildArgs } = props; // Default to linux/amd64\n\n    // Define absolute paths for Lambda handlers\n    const onEventHandlerPath = path.resolve(__dirname, '../src/onEventHandler');\n    const isCompleteHandlerPath = path.resolve(__dirname, '../src/isCompleteHandler');\n\n    // Create an ECR repository\n    this.ecrRepository = new Repository(this, 'ECRRepository');\n\n    // Package the source code as an asset\n    const sourceAsset = new Asset(this, 'SourceAsset', {\n      path: sourcePath, // Path to the Dockerfile or source code\n    });\n\n    // Transform buildArgs into a string of --build-arg KEY=VALUE\n    const buildArgsString = buildArgs\n      ? Object.entries(buildArgs)\n        .map(([key, value]) => `--build-arg ${key}=${value}`)\n        .join(' ')\n      : '';\n\n    // Pass the buildArgsString and platform as environment variables\n    const environmentVariables: { [name: string]: { value: string } } = {\n      ECR_REPO_URI: { value: this.ecrRepository.repositoryUri },\n      BUILD_ARGS: { value: buildArgsString },\n    };\n\n    // Create a CodeBuild project\n    const codeBuildProject = new Project(this, 'UICodeBuildProject', {\n      source: Source.s3({\n        bucket: sourceAsset.bucket,\n        path: sourceAsset.s3ObjectKey,\n      }),\n      environment: {\n        buildImage: LinuxBuildImage.STANDARD_7_0,\n        privileged: true, // Required for Docker builds\n      },\n      environmentVariables: environmentVariables,\n      buildSpec: BuildSpec.fromObject({\n        version: '0.2',\n        phases: {\n          pre_build: {\n            commands: [\n              'echo \"Retrieving AWS Account ID...\"',\n              'export ACCOUNT_ID=$(aws sts get-caller-identity --query Account --output text)',\n              'echo \"Logging in to Amazon ECR...\"',\n              'aws ecr get-login-password --region $AWS_DEFAULT_REGION | docker login --username AWS --password-stdin $ACCOUNT_ID.dkr.ecr.$AWS_DEFAULT_REGION.amazonaws.com',\n            ],\n          },\n          build: {\n            commands: [\n              'echo Build phase: Building the Docker image...',\n              'docker build $BUILD_ARGS -t $ECR_REPO_URI:latest $CODEBUILD_SRC_DIR',\n            ],\n          },\n          post_build: {\n            commands: [\n              'echo Post-build phase: Pushing the Docker image...',\n              'docker push $ECR_REPO_URI:latest',\n            ],\n          },\n        },\n      }),\n    });\n\n    // Grant permissions to interact with ECR\n    this.ecrRepository.grantPullPush(codeBuildProject);\n\n    codeBuildProject.role!.addToPrincipalPolicy(\n      new PolicyStatement({\n        actions: ['ecr:GetAuthorizationToken'],\n        resources: ['*'],\n      })\n    );\n\n    // Grant permissions to CodeBuild for CloudWatch Logs\n    codeBuildProject.role!.addToPrincipalPolicy(\n      new PolicyStatement({\n        actions: ['logs:PutLogEvents', 'logs:CreateLogGroup', 'logs:CreateLogStream'],\n        resources: [`arn:aws:logs:${Stack.of(this).region}:${Stack.of(this).account}:*`],\n      })\n    );\n\n    // Create Node.js Lambda function for onEvent\n    const onEventHandlerFunction = new Function(this, 'OnEventHandlerFunction', {\n      runtime: Runtime.NODEJS_LATEST, // Use Node.js runtime\n      code: Code.fromAsset(onEventHandlerPath), // Path to handler code\n      handler: 'index.handler', // Entry point (adjust as needed)\n      timeout: Duration.minutes(15),\n    });\n\n    onEventHandlerFunction.addToRolePolicy(\n      new PolicyStatement({\n        actions: ['codebuild:StartBuild'],\n        resources: [codeBuildProject.projectArn], // Restrict to specific project\n      })\n    );\n\n    // Create Node.js Lambda function for isComplete\n    const isCompleteHandlerFunction = new Function(this, 'IsCompleteHandlerFunction', {\n      runtime: Runtime.NODEJS_LATEST,\n      code: Code.fromAsset(isCompleteHandlerPath),\n      handler: 'index.handler',\n      timeout: Duration.minutes(15),\n    });\n\n    isCompleteHandlerFunction.addToRolePolicy(\n      new PolicyStatement({\n        actions: [\n          'codebuild:BatchGetBuilds',\n          'codebuild:ListBuildsForProject',\n          'logs:GetLogEvents',\n          'logs:DescribeLogStreams',\n          'logs:DescribeLogGroups'\n        ],\n        resources: ['*'],\n      })\n    );\n\n    // Create a custom resource provider\n    const provider = new Provider(this, 'CustomResourceProvider', {\n      onEventHandler: onEventHandlerFunction,\n      isCompleteHandler: isCompleteHandlerFunction,\n      queryInterval: Duration.minutes(1),\n    });\n\n    // Define the custom resource\n    this.buildTriggerResource = new CustomResource(this, 'BuildTriggerResource', {\n      serviceToken: provider.serviceToken,\n      properties: {\n        ProjectName: codeBuildProject.projectName,\n        Trigger: crypto.randomUUID(),\n      },\n    });\n\n    this.buildTriggerResource.node.addDependency(codeBuildProject);\n  }\n\n  /**\n   * Retrieves the container image from the ECR repository.\n   *\n   * @returns A `ContainerImage` object representing the built image.\n   */\n  public getContainerImage(): ContainerImage {\n    return ContainerImage.fromEcrRepository(this.ecrRepository, 'latest');\n  }\n\n  /**\n   * Retrieves the Docker image code for use in AWS Lambda.\n   *\n   * @returns A `DockerImageCode` object for the Docker image.\n   */\n  public getDockerImageCode(): DockerImageCode {\n    return DockerImageCode.fromEcr(this.ecrRepository);\n  }\n}\n"]}

package/lib/index.ts

@@ -11,15 +11,54 @@ import { ContainerImage } from 'aws-cdk-lib/aws-ecs';
 import * as crypto from 'crypto';
 import { Function } from 'aws-cdk-lib/aws-lambda';
 
+
+/**
+ * Properties for the `TokenInjectableDockerBuilder` construct.
+ */
 export interface TokenInjectableDockerBuilderProps {
+  /**
+   * The path to the directory containing the Dockerfile or source code.
+   */
   path: string;
+
+  /**
+   * Build arguments to pass to the Docker build process.
+   * These are transformed into `--build-arg` flags.
+   * @example
+   * {
+   *   TOKEN: 'my-secret-token',
+   *   ENV: 'production'
+   * }
+   */
   buildArgs?: { [key: string]: string };
 }
 
+
+/**
+ * A CDK construct to build and push Docker images to an ECR repository using CodeBuild and Lambda custom resources.
+ *
+ * @example
+ * const dockerBuilder = new TokenInjectableDockerBuilder(this, 'DockerBuilder', {
+ *   path: './docker',
+ *   buildArgs: {
+ *     TOKEN: 'my-secret-token',
+ *     ENV: 'production'
+ *   },
+ * });
+ *
+ * const containerImage = dockerBuilder.getContainerImage();
+ */
 export class TokenInjectableDockerBuilder extends Construct {
   private readonly ecrRepository: Repository;
   private readonly buildTriggerResource: CustomResource;
 
+  /**
+   * Creates a new `TokenInjectableDockerBuilder` instance.
+   *
+   * @param scope The parent construct/stack.
+   * @param id The unique ID of the construct.
+   * @param props Configuration properties for the construct.
+   */
   constructor(scope: Construct, id: string, props: TokenInjectableDockerBuilderProps) {
     super(scope, id);
 
@@ -40,8 +79,8 @@ export class TokenInjectableDockerBuilder extends Construct {
     // Transform buildArgs into a string of --build-arg KEY=VALUE
     const buildArgsString = buildArgs
       ? Object.entries(buildArgs)
-          .map(([key, value]) => `--build-arg ${key}=${value}`)
-          .join(' ')
+        .map(([key, value]) => `--build-arg ${key}=${value}`)
+        .join(' ')
       : '';
 
     // Pass the buildArgsString and platform as environment variables
@@ -108,7 +147,7 @@ export class TokenInjectableDockerBuilder extends Construct {
 
     // Create Node.js Lambda function for onEvent
     const onEventHandlerFunction = new Function(this, 'OnEventHandlerFunction', {
-      runtime: Runtime.NODEJS_18_X, // Use Node.js runtime
+      runtime: Runtime.NODEJS_LATEST, // Use Node.js runtime
       code: Code.fromAsset(onEventHandlerPath), // Path to handler code
       handler: 'index.handler', // Entry point (adjust as needed)
       timeout: Duration.minutes(15),
@@ -123,7 +162,7 @@ export class TokenInjectableDockerBuilder extends Construct {
 
     // Create Node.js Lambda function for isComplete
     const isCompleteHandlerFunction = new Function(this, 'IsCompleteHandlerFunction', {
-      runtime: Runtime.NODEJS_18_X,
+      runtime: Runtime.NODEJS_LATEST,
       code: Code.fromAsset(isCompleteHandlerPath),
       handler: 'index.handler',
       timeout: Duration.minutes(15),
@@ -161,10 +200,20 @@ export class TokenInjectableDockerBuilder extends Construct {
     this.buildTriggerResource.node.addDependency(codeBuildProject);
   }
 
+  /**
+   * Retrieves the container image from the ECR repository.
+   *
+   * @returns A `ContainerImage` object representing the built image.
+   */
   public getContainerImage(): ContainerImage {
     return ContainerImage.fromEcrRepository(this.ecrRepository, 'latest');
   }
 
+  /**
+   * Retrieves the Docker image code for use in AWS Lambda.
+   *
+   * @returns A `DockerImageCode` object for the Docker image.
+   */
   public getDockerImageCode(): DockerImageCode {
     return DockerImageCode.fromEcr(this.ecrRepository);
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "token-injectable-docker-builder",
-  "version": "0.1.4",
+  "version": "0.1.6",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
   "scripts": {