@wolsok/nx-aws-cdk-v2 1.3.0

package/.babelrc

@@ -0,0 +1,10 @@
+{
+  "presets": [
+    [
+      "@nx/js/babel",
+      {
+        "useBuiltIns": "usage"
+      }
+    ]
+  ]
+}

package/README.md

@@ -0,0 +1,96 @@
+[![standard-readme compliant](https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square)](https://github.com/RichardLitt/standard-readme)
+[![@wolsok/nx-aws-cdk-v2](https://img.shields.io/badge/%40adrian--goe-nx--aws--cdk-green)](https://github.com/WolfSoko/nx-aws-cdk-v2/tree/main/packages/aws-cdk-v2)
+[![Typescript](https://badgen.net/badge/icon/typescript?icon=typescript&label)](https://www.typescriptlang.org/)
+[![LICENSE](https://img.shields.io/npm/l/@wolsok/nx-aws-cdk-v2.svg)](https://www.npmjs.com/package/@wolsok/nx-aws-cdk-v2)
+[![npm version](https://img.shields.io/npm/v/@wolsok/nx-aws-cdk-v2.svg)](https://www.npmjs.com/package/@wolsok/nx-aws-cdk-v2)
+[![Downloads](https://img.shields.io/npm/dm/@wolsok/nx-aws-cdk-v2.svg)](https://www.npmjs.com/package/@wolsok/nx-aws-cdk-v2)
+
+<hr>
+
+# @wolsok/nx-aws-cdk-v2
+
+An Nx plugin for developing [aws-cdk](https://docs.aws.amazon.com/cdk/latest/guide/home.html)
+
+## Table of Contents
+
+- [Install](#install)
+- [Usage](#usage)
+  - [Generate Application](#generate-application)
+  - [Targets](#targets)
+- [Maintainers](#maintainers)
+- [Contributing](#contributing)
+- [License](#license)
+
+## Install
+
+```shell
+# npm
+npm install --save-dev @wolsok/nx-aws-cdk-v2
+
+# yarn
+yarn add --dev @wolsok/nx-aws-cdk-v2
+```
+
+## Usage
+
+### Generate Application
+
+Create AWS CDK v2 Application
+
+More details on AWS CDK v2 can be found on https://docs.aws.amazon.com/cdk/v2/guide/home.html
+
+```shell
+nx generate @wolsok/nx-aws-cdk-v2:application myApp
+```
+
+you can customize it further by passing these options:
+
+```
+nx generate @wolsok/nx-aws-cdk-v2:application [name] [options,...]
+
+Options:
+  --name
+  --tags                     Add tags to the project (used for linting)
+  --directory                A directory where the project is placed
+  --skipFormat               Skip formatting files
+  --unitTestRunner           Adds the specified unit test runner (default: jest)
+  --setParserOptionsProject  Whether or not to configure the ESLint "parserOptions.project" option. We do not do this by default for lint performance reasons.
+  --dryRun                   Runs through and reports activity without writing to disk.
+  --skip-nx-cache            Skip the use of Nx cache.
+  --help                     Show available options for project target.
+```
+
+### Targets
+
+Generated applications expose several functions to the CLI that allow users to deploy, destroy and bootstrap.
+
+```shell
+nx deploy myApp
+nx destroy myApp
+nx bootstrap myApp --profile=profile
+#see how to use aws environments https://docs.aws.amazon.com/cdk/v2/guide/bootstrapping.html#bootstrapping-howto-cli
+nx bootstrap myApp aws://123456789012/us-east-1
+```
+
+## Maintainers
+
+[@WolfSoko](https://github.com/WolfSoko)
+
+## Contributing
+
+See [the contributing file](../../CONTRIBUTING.md)!
+
+PRs accepted.
+
+If editing the README, please conform to the [standard-readme](https://github.com/RichardLitt/standard-readme) specification.
+
+## License
+
+This project is MIT licensed 2022 Wolfram Sokollek
+
+## Special thanks
+
+This Project is based on [@tienne](https://github.com/tienne)'s
+[nx-plugins](https://github.com/codebrewlab/nx-plugins).
+
+Also thanks to [@therk](https://github.com/therk) for his work on migrating to cdk v2.

package/eslint.config.js

@@ -0,0 +1,17 @@
+const baseConfig = require('../../eslint.config.js');
+
+module.exports = [
+  ...baseConfig,
+  {
+    files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
+    rules: {},
+  },
+  {
+    files: ['**/*.ts', '**/*.tsx'],
+    rules: {},
+  },
+  {
+    files: ['**/*.js', '**/*.jsx'],
+    rules: {},
+  },
+];

package/executors.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "executors": {
+    "deploy": {
+      "implementation": "./src/executors/deploy/deploy",
+      "schema": "./src/executors/deploy/schema.json",
+      "description": "build executor"
+    },
+    "destroy": {
+      "implementation": "./src/executors/destroy/destroy",
+      "schema": "./src/executors/destroy/schema.json",
+      "description": "destroy executor"
+    },
+    "bootstrap": {
+      "implementation": "./src/executors/bootstrap/bootstrap",
+      "schema": "./src/executors/bootstrap/schema.json",
+      "description": "bootstrap executor"
+    }
+  }
+}

package/generators.json

@@ -0,0 +1,19 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "name": "aws-cdk-v2",
+  "version": "0.0.1",
+  "generators": {
+    "init": {
+      "factory": "./src/generators/init/init",
+      "schema": "./src/generators/init/schema.json",
+      "description": "init generator",
+      "aliases": ["ng-add"],
+      "hidden": true
+    },
+    "application": {
+      "factory": "./src/generators/application/application",
+      "schema": "./src/generators/application/schema.json",
+      "description": "create aws-cdk application"
+    }
+  }
+}

package/jest.config.ts

@@ -0,0 +1,8 @@
+import { JestConfigWithTsJest } from 'ts-jest';
+
+export default {
+  displayName: { name: 'aws-cdk-v2', color: 'blue' },
+  preset: '../../jest.preset.js',
+  testEnvironment: 'node',
+  coverageDirectory: '../../coverage/packages/aws-cdk-v2',
+} as JestConfigWithTsJest;

package/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@wolsok/nx-aws-cdk-v2",
+  "version": "1.3.0",
+  "main": "src/index.js",
+  "generators": "./generators.json",
+  "executors": "./executors.json",
+  "keywords": [
+    "nx",
+    "aws-cdk",
+    "monorepo",
+    "aws cdk",
+    "Node"
+  ],
+  "ng-update": {
+    "requirements": {},
+    "migrations": "./migrations.json"
+  },
+  "author": "Wolfram Sokollek",
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:WolfSoko/nx-aws-cdk-v2"
+  },
+  "license": "MIT"
+}

package/project.json

@@ -0,0 +1,66 @@
+{
+  "name": "aws-cdk-v2",
+  "$schema": "../../node_modules/nx/schemas/project-schema.json",
+  "sourceRoot": "packages/aws-cdk-v2/src",
+  "projectType": "library",
+  "tags": [],
+  "targets": {
+    "build": {
+      "executor": "@nx/js:tsc",
+      "outputs": ["{options.outputPath}"],
+      "options": {
+        "outputPath": "dist/packages/aws-cdk-v2",
+        "main": "packages/aws-cdk-v2/src/index.ts",
+        "tsConfig": "packages/aws-cdk-v2/tsconfig.lib.json",
+        "assets": [
+          "packages/aws-cdk-v2/*.md",
+          {
+            "input": "./packages/aws-cdk-v2/src",
+            "glob": "**/!(*.ts)",
+            "output": "./src"
+          },
+          {
+            "input": "./packages/aws-cdk-v2/src",
+            "glob": "**/*.d.ts",
+            "output": "./src"
+          },
+          {
+            "input": "./packages/aws-cdk-v2",
+            "glob": "generators.json",
+            "output": "."
+          },
+          {
+            "input": "./packages/aws-cdk-v2",
+            "glob": "executors.json",
+            "output": "."
+          }
+        ]
+      }
+    },
+    "lint": {
+      "options": {
+        "args": ["**/*.ts", "generators.json", "executors.json", "package.json"]
+      }
+    },
+    "test": {
+      "inputs": [
+        "default",
+        "^default",
+        "{workspaceRoot}/jest.preset.js",
+        {
+          "externalDependencies": ["jest"]
+        }
+      ],
+      "outputs": ["{workspaceRoot}\\coverage\\packages\\aws-cdk-v2"],
+      "options": {
+        "passWithNoTests": true
+      },
+      "configurations": {
+        "ci": {
+          "ci": true,
+          "coverage": true
+        }
+      }
+    }
+  }
+}

package/src/executors/bootstrap/bootstrap.spec.ts

@@ -0,0 +1,57 @@
+import * as childProcess from 'child_process';
+
+import { logger } from '@nx/devkit';
+
+import { BootstrapExecutorSchema } from './schema';
+import executor from './bootstrap';
+import { generateCommandString, LARGE_BUFFER } from '../../utils/executor.util';
+import { mockExecutorContext } from '../../utils/testing';
+
+const options: BootstrapExecutorSchema = {};
+
+const nodeCommandWithRelativePath = generateCommandString('bootstrap', 'apps/proj');
+
+describe('aws-cdk-v2 Bootstrap Executor', () => {
+  const context = mockExecutorContext('bootstrap');
+
+  beforeEach(async () => {
+    jest.spyOn(logger, 'debug');
+    jest.spyOn(childProcess, 'exec');
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  it('run cdk bootstrap command', async () => {
+    await executor(options, context);
+
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      nodeCommandWithRelativePath,
+      expect.objectContaining({
+        cwd: expect.stringContaining(context.root),
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+
+    expect(logger.debug).toHaveBeenLastCalledWith(`Executing command: ${nodeCommandWithRelativePath}`);
+  });
+
+  it('run cdk bootstrap command profile', async () => {
+    const option: BootstrapExecutorSchema = Object.assign({}, options);
+    const profile = 'prod';
+    option['profile'] = profile;
+    await executor(option, context);
+
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      `${nodeCommandWithRelativePath} --profile ${profile}`,
+      expect.objectContaining({
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+
+    expect(logger.debug).toHaveBeenLastCalledWith(
+      `Executing command: ${nodeCommandWithRelativePath} --profile ${profile}`
+    );
+  });
+});

package/src/executors/bootstrap/bootstrap.ts

@@ -0,0 +1,45 @@
+import { BootstrapExecutorSchema } from './schema';
+import { createCommand, parseArgs, runCommandProcess } from '../../utils/executor.util';
+import { ParsedExecutorInterface } from '../../interfaces/parsed-executor.interface';
+import { ExecutorContext } from '@nx/devkit';
+
+export interface ParsedBootstrapExecutorOption extends ParsedExecutorInterface {
+  profile?: string;
+  app?: string;
+  sourceRoot: string;
+  root: string;
+}
+
+export default async function runExecutor(options: BootstrapExecutorSchema, context: ExecutorContext) {
+  const normalizedOptions = normalizeOptions(options, context);
+  const result = await runBootstrap(normalizedOptions, context);
+
+  return {
+    success: result,
+  };
+}
+
+function runBootstrap(options: ParsedBootstrapExecutorOption, context: ExecutorContext) {
+  const command = createCommand('bootstrap', options);
+  return runCommandProcess(command, context.root);
+}
+
+function normalizeOptions(options: BootstrapExecutorSchema, context: ExecutorContext): ParsedBootstrapExecutorOption {
+  const parsedArgs = parseArgs(options);
+  let profile;
+
+  if (Object.prototype.hasOwnProperty.call(options, 'profile')) {
+    profile = `--profile ${options.profile}`;
+  }
+
+  // eslint-disable-next-line no-unsafe-optional-chaining
+  const { sourceRoot, root } = context?.projectsConfigurations?.projects[context.projectName];
+
+  return {
+    ...options,
+    parseArgs: parsedArgs,
+    profile,
+    sourceRoot,
+    root,
+  };
+}

package/src/executors/bootstrap/schema.d.ts

@@ -0,0 +1,3 @@
+export interface BootstrapExecutorSchema {
+  profile?: string;
+}

package/src/executors/bootstrap/schema.json

@@ -0,0 +1,8 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "title": "Bootstrap executor",
+  "description": "",
+  "type": "object",
+  "properties": {},
+  "required": []
+}

package/src/executors/deploy/deploy.spec.ts

@@ -0,0 +1,106 @@
+import * as childProcess from 'child_process';
+import { logger } from '@nx/devkit';
+
+import executor from './deploy';
+import { DeployExecutorSchema } from './schema';
+import { generateCommandString, LARGE_BUFFER } from '../../utils/executor.util';
+import { mockExecutorContext } from '../../utils/testing';
+
+const options: DeployExecutorSchema = {};
+
+const nodeCommandWithRelativePath = generateCommandString('deploy', 'apps/proj');
+
+describe('aws-cdk-v2 deploy Executor', () => {
+  const context = mockExecutorContext('deploy');
+
+  beforeEach(async () => {
+    jest.spyOn(logger, 'debug');
+    jest.spyOn(childProcess, 'exec');
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  it('run cdk deploy command', async () => {
+    await executor(options, context);
+
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      nodeCommandWithRelativePath,
+      expect.objectContaining({
+        cwd: context.root,
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+    expect(logger.debug).toHaveBeenLastCalledWith(`Executing command: ${nodeCommandWithRelativePath}`);
+  });
+
+  it('run cdk deploy command stack', async () => {
+    const option: DeployExecutorSchema = Object.assign({}, options);
+    const stackName = 'test';
+    option['stacks'] = stackName;
+    await executor(option, context);
+
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      `${nodeCommandWithRelativePath} ${stackName}`,
+      expect.objectContaining({
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+
+    expect(logger.debug).toHaveBeenLastCalledWith(`Executing command: ${nodeCommandWithRelativePath} ${stackName}`);
+  });
+
+  it('run cdk deploy command context options', async () => {
+    const option: DeployExecutorSchema = Object.assign({}, options);
+    const contextOptionString = 'key=value';
+    option['context'] = contextOptionString;
+    await executor(option, context);
+
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      `${nodeCommandWithRelativePath} --context ${contextOptionString}`,
+      expect.objectContaining({
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+
+    expect(logger.debug).toHaveBeenLastCalledWith(
+      `Executing command: ${nodeCommandWithRelativePath} --context ${contextOptionString}`
+    );
+  });
+
+  it('run cdk deploy command with multiple context options', async () => {
+    const option: DeployExecutorSchema = Object.assign({}, options);
+    const contextOptions = ['firstKey=firstValue', 'secondKey=secondValue'];
+    option['context'] = contextOptions;
+    await executor(option, context);
+
+    const contextCmd = contextOptions.map((option) => `--context ${option}`).join(' ');
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      `${nodeCommandWithRelativePath} ${contextCmd}`,
+      expect.objectContaining({
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+
+    expect(logger.debug).toHaveBeenLastCalledWith(`Executing command: ${nodeCommandWithRelativePath} ${contextCmd}`);
+  });
+
+  it('run cdk deploy command with boolean context option', async () => {
+    const option: DeployExecutorSchema = Object.assign({}, options);
+    option['context'] = true;
+    await executor(option, context);
+
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      `${nodeCommandWithRelativePath} --context true`,
+      expect.objectContaining({
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+
+    expect(logger.debug).toHaveBeenLastCalledWith(`Executing command: ${nodeCommandWithRelativePath} --context true`);
+  });
+});

package/src/executors/deploy/deploy.ts

@@ -0,0 +1,43 @@
+import { DeployExecutorSchema } from './schema';
+import { createCommand, runCommandProcess, parseArgs } from '../../utils/executor.util';
+import { ParsedExecutorInterface } from '../../interfaces/parsed-executor.interface';
+import { ExecutorContext } from '@nx/devkit';
+
+export interface ParsedDeployExecutorOption extends ParsedExecutorInterface {
+  stacks?: string[];
+  sourceRoot: string;
+  root: string;
+}
+
+export default async function runExecutor(options: DeployExecutorSchema, context: ExecutorContext) {
+  const normalizedOptions = normalizeOptions(options, context);
+  const result = await runDeploy(normalizedOptions, context);
+
+  return {
+    success: result,
+  };
+}
+
+async function runDeploy(options: ParsedDeployExecutorOption, context: ExecutorContext) {
+  const command = createCommand('deploy', options);
+  return runCommandProcess(command, context.root);
+}
+
+function normalizeOptions(options: DeployExecutorSchema, context: ExecutorContext): ParsedDeployExecutorOption {
+  const parsedArgs = parseArgs(options);
+  let stacks;
+
+  if (Object.prototype.hasOwnProperty.call(options, 'stacks')) {
+    stacks = options.stacks;
+  }
+
+  const { sourceRoot, root } = context?.projectsConfigurations?.projects[context.projectName] ?? {};
+
+  return {
+    ...options,
+    parseArgs: parsedArgs,
+    stacks,
+    sourceRoot,
+    root,
+  };
+}

package/src/executors/deploy/schema.d.ts

@@ -0,0 +1,3 @@
+export interface DeployExecutorSchema {
+  stacks?: string;
+}

package/src/executors/deploy/schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "title": "deploy executor",
+  "description": "",
+  "type": "object",
+  "properties": {
+    "stacks": {
+      "type": "string",
+      "description": "use deploy named STACKS"
+    }
+  },
+  "required": []
+}

package/src/executors/destroy/destroy.spec.ts

@@ -0,0 +1,56 @@
+import * as childProcess from 'child_process';
+
+import { logger } from '@nx/devkit';
+
+import { DestroyExecutorSchema } from './schema';
+import executor from './destroy';
+import { generateCommandString, LARGE_BUFFER } from '../../utils/executor.util';
+import { mockExecutorContext } from '../../utils/testing';
+
+const options: DestroyExecutorSchema = {};
+
+const nodeCommandWithRelativePath = generateCommandString('destroy', 'apps/proj');
+
+describe('aws-cdk-v2 Destroy Executor', () => {
+  const context = mockExecutorContext('destroy');
+
+  beforeEach(async () => {
+    jest.spyOn(logger, 'debug');
+    jest.spyOn(childProcess, 'exec');
+  });
+
+  afterEach(() => jest.clearAllMocks());
+
+  it('run cdk destroy command', async () => {
+    await executor(options, context);
+
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      nodeCommandWithRelativePath,
+      expect.objectContaining({
+        cwd: context.root,
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+
+    expect(logger.debug).toHaveBeenLastCalledWith(`Executing command: ${nodeCommandWithRelativePath}`);
+  });
+
+  it('run cdk destroy command stack', async () => {
+    const option: DestroyExecutorSchema = Object.assign({}, options);
+    const stackName = 'test';
+    option['stacks'] = stackName;
+
+    await executor(option, context);
+
+    expect(childProcess.exec).toHaveBeenCalledWith(
+      `${nodeCommandWithRelativePath} ${stackName}`,
+      expect.objectContaining({
+        env: process.env,
+        maxBuffer: LARGE_BUFFER,
+      })
+    );
+
+    expect(logger.debug).toHaveBeenLastCalledWith(`Executing command: ${nodeCommandWithRelativePath} ${stackName}`);
+  });
+});

package/src/executors/destroy/destroy.ts

@@ -0,0 +1,45 @@
+import { DestroyExecutorSchema } from './schema';
+import { createCommand, parseArgs, runCommandProcess } from '../../utils/executor.util';
+import { ParsedExecutorInterface } from '../../interfaces/parsed-executor.interface';
+import { ExecutorContext } from '@nx/devkit';
+
+export interface ParsedDestroyExecutorOption extends ParsedExecutorInterface {
+  stacks?: string[];
+  app?: string;
+  sourceRoot: string;
+  root: string;
+}
+
+export default async function runExecutor(options: DestroyExecutorSchema, context: ExecutorContext) {
+  const normalizedOptions = normalizeOptions(options, context);
+  const result = await runDestroy(normalizedOptions, context);
+
+  return {
+    success: result,
+  };
+}
+
+function runDestroy(options: ParsedDestroyExecutorOption, context: ExecutorContext) {
+  const command = createCommand('destroy', options);
+  return runCommandProcess(command, context.root);
+}
+
+function normalizeOptions(options: DestroyExecutorSchema, context: ExecutorContext): ParsedDestroyExecutorOption {
+  const parsedArgs = parseArgs(options);
+  let stacks;
+
+  if (Object.prototype.hasOwnProperty.call(options, 'stacks')) {
+    stacks = options.stacks;
+  }
+
+  // eslint-disable-next-line no-unsafe-optional-chaining
+  const { sourceRoot, root } = context?.projectsConfigurations?.projects[context.projectName];
+
+  return {
+    ...options,
+    parseArgs: parsedArgs,
+    stacks,
+    sourceRoot,
+    root,
+  };
+}

package/src/executors/destroy/schema.d.ts

@@ -0,0 +1,3 @@
+export interface DestroyExecutorSchema {
+  stacks?: string;
+}

package/src/executors/destroy/schema.json

@@ -0,0 +1,13 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "title": "Destroy executor",
+  "description": "",
+  "type": "object",
+  "properties": {
+    "stacks": {
+      "type": "string",
+      "description": "use destroy named STACKS"
+    }
+  },
+  "required": []
+}