@wolsok/nx-aws-cdk-v2 1.3.0

package/src/generators/application/application.spec.ts

@@ -0,0 +1,30 @@
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
+import { Tree, readProjectConfiguration } from '@nx/devkit';
+
+import generator from './application';
+import { ApplicationSchema } from './schema';
+
+describe('aws-cdk generator', () => {
+  let appTree: Tree;
+  const options: ApplicationSchema = { name: 'test' };
+
+  beforeEach(() => {
+    appTree = createTreeWithEmptyWorkspace();
+  });
+
+  it('should run successfully', async () => {
+    await generator(appTree, options);
+    const config = readProjectConfiguration(appTree, 'test');
+    expect(config).toBeDefined();
+  });
+
+  it('directory option', async () => {
+    const directory = 'sub';
+    const directoryOptions = Object.assign({}, options);
+    directoryOptions.directory = directory;
+
+    await generator(appTree, directoryOptions);
+    const config = readProjectConfiguration(appTree, 'sub-test');
+    expect(config).toBeDefined();
+  });
+});

package/src/generators/application/application.ts

@@ -0,0 +1,125 @@
+import * as path from 'path';
+import {
+  addProjectConfiguration,
+  convertNxGenerator,
+  formatFiles,
+  generateFiles,
+  GeneratorCallback,
+  getWorkspaceLayout,
+  names,
+  offsetFromRoot,
+  ProjectConfiguration,
+  readProjectConfiguration,
+  runTasksInSerial,
+  Tree,
+  updateProjectConfiguration,
+} from '@nx/devkit';
+import { configurationGenerator } from '@nx/jest';
+
+import { ApplicationSchema } from './schema';
+import { initGenerator } from '../init/init';
+
+interface NormalizedSchema extends ApplicationSchema {
+  projectName: string;
+  projectRoot: string;
+  projectDirectory: string;
+  parsedTags: string[];
+}
+
+function normalizeOptions(host: Tree, options: ApplicationSchema): NormalizedSchema {
+  const name = names(options.name).fileName;
+  const projectDirectory = options.directory ? `${names(options.directory).fileName}/${name}` : name;
+  const projectName = projectDirectory.replace(new RegExp('/', 'g'), '-');
+  const projectRoot = `${getWorkspaceLayout(host).appsDir}/${projectDirectory}`;
+  const parsedTags = options.tags ? options.tags.split(',').map((s) => s.trim()) : [];
+
+  return {
+    ...options,
+    projectName,
+    projectRoot,
+    projectDirectory,
+    parsedTags,
+    unitTestRunner: options.unitTestRunner ?? 'jest',
+  };
+}
+
+function addFiles(host: Tree, options: NormalizedSchema) {
+  const templateOptions = {
+    ...options,
+    ...names(options.projectName),
+    offsetFromRoot: offsetFromRoot(options.projectRoot),
+    template: '',
+  };
+
+  generateFiles(host, path.join(__dirname, 'files'), options.projectRoot, templateOptions);
+}
+
+function addJestFiles(host: Tree, options: NormalizedSchema) {
+  const templateOptions = {
+    ...options,
+    ...names(options.projectName),
+    offsetFromRoot: offsetFromRoot(options.projectRoot),
+    template: '',
+  };
+  generateFiles(host, path.join(__dirname, 'jest-files'), options.projectRoot, templateOptions);
+}
+
+export async function applicationGenerator(host: Tree, options: ApplicationSchema) {
+  const tasks: GeneratorCallback[] = [];
+  const normalizedOptions = normalizeOptions(host, options);
+  const initTask = await initGenerator(host, {
+    ...options,
+    skipFormat: true,
+  });
+
+  tasks.push(initTask);
+
+  const project: ProjectConfiguration = {
+    root: normalizedOptions.projectRoot,
+    projectType: 'application',
+    sourceRoot: `${normalizedOptions.projectRoot}/src`,
+    targets: {
+      deploy: {
+        executor: '@ago-dev/nx-aws-cdk-v2:deploy',
+        options: {},
+      },
+      destroy: {
+        executor: '@ago-dev/nx-aws-cdk-v2:destroy',
+        options: {},
+      },
+      bootstrap: {
+        executor: '@ago-dev/nx-aws-cdk-v2:bootstrap',
+        options: {},
+      },
+    },
+    tags: normalizedOptions.parsedTags,
+  };
+  addProjectConfiguration(host, normalizedOptions.projectName, project);
+  const workspace = readProjectConfiguration(host, normalizedOptions.projectName);
+
+  updateProjectConfiguration(host, normalizedOptions.projectName, workspace);
+  addFiles(host, normalizedOptions);
+
+  if (normalizedOptions.unitTestRunner === 'jest') {
+    const jestTask = await configurationGenerator(host, {
+      project: normalizedOptions.projectName,
+      setupFile: 'none',
+      skipSerializers: true,
+      supportTsx: false,
+      babelJest: false,
+      testEnvironment: 'node',
+      skipFormat: true,
+    });
+    tasks.push(jestTask);
+    addJestFiles(host, normalizedOptions);
+  }
+
+  if (!options.skipFormat) {
+    await formatFiles(host);
+  }
+
+  return runTasksInSerial(...tasks);
+}
+
+export default applicationGenerator;
+export const applicationSchematic = convertNxGenerator(applicationGenerator);

package/src/generators/application/files/cdk.json__template__

@@ -0,0 +1,36 @@
+{
+  "app": "npx ts-node src/main.ts",
+  "output": "<%= offsetFromRoot %>dist/apps/<%= projectName %>",
+  "requireApproval": "never",
+  "watch": {
+    "include": [
+      "**"
+    ],
+    "exclude": [
+      "README.md",
+      "cdk*.json",
+      "**/*.d.ts",
+      "**/*.js",
+      "tsconfig.json",
+      "package*.json",
+      "yarn.lock",
+      "node_modules",
+      "test"
+    ]
+  },
+  "context": {
+    "@aws-cdk/aws-apigateway:usagePlanKeyOrderInsensitiveId": true,
+    "@aws-cdk/core:stackRelativeExports": true,
+    "@aws-cdk/aws-rds:lowercaseDbIdentifier": true,
+    "@aws-cdk/aws-lambda:recognizeVersionProps": true,
+    "@aws-cdk/aws-cloudfront:defaultSecurityPolicyTLSv1.2_2021": true,
+    "@aws-cdk-containers/ecs-service-extensions:enableDefaultLogDriver": true,
+    "@aws-cdk/aws-ec2:uniqueImdsv2TemplateName": true,
+    "@aws-cdk/core:checkSecretUsage": true,
+    "@aws-cdk/aws-iam:minimizePolicies": true,
+    "@aws-cdk/core:target-partitions": [
+      "aws",
+      "aws-cn"
+    ]
+  }
+}

package/src/generators/application/files/src/main.ts__template__

@@ -0,0 +1,5 @@
+import { App } from 'aws-cdk-lib';
+import { AppStack } from './stacks/app-stack';
+
+const app = new App();
+new AppStack(app, '<%= projectName %>');

package/src/generators/application/files/src/stacks/app-stack.ts__template__

@@ -0,0 +1,9 @@
+import { Stack, App, StackProps } from 'aws-cdk-lib';
+
+export class AppStack extends Stack {
+  constructor(scope: App, id: string, props?: StackProps) {
+    super(scope, id, props);
+
+        // defines your stack here
+    }
+}

package/src/generators/application/files/tsconfig.app.json__template__

@@ -0,0 +1,9 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "<%= offsetFromRoot %>dist/out-tsc",
+    "types": ["node"]
+  },
+  "exclude": ["**/*.spec.ts", "**/*.test.ts"],
+  "include": ["**/*.ts"]
+}

package/src/generators/application/files/tsconfig.json__template__

@@ -0,0 +1,15 @@
+{
+  "extends": "<%= offsetFromRoot %>tsconfig.base.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "<%= offsetFromRoot %>dist/out-tsc",
+    "types": ["node", "jest"]
+  },
+  "include": [],
+  "files": [],
+  "references": [
+    {
+      "path": "./tsconfig.app.json"
+    }
+  ]
+}

package/src/generators/application/jest-files/src/main.test.ts__template__

@@ -0,0 +1,13 @@
+import { Stack, App } from 'aws-cdk-lib';
+import { Template } from 'aws-cdk-lib/assertions';
+import { AppStack } from './stacks/app-stack';
+
+test('Empty Stack', () => {
+    const app = new App();
+    // WHEN
+    const stack = new AppStack(app, '<%= projectName %>TestStack');
+    // THEN
+    Template.fromStack(stack as Stack).templateMatches({
+        Resources: {}
+    });
+});

package/src/generators/application/schema.d.ts

@@ -0,0 +1,8 @@
+export interface ApplicationSchema {
+  name: string;
+  tags?: string;
+  directory?: string;
+  skipFormat?: boolean;
+  unitTestRunner?: 'jest' | 'none';
+  setParserOptionsProject?: boolean;
+}

package/src/generators/application/schema.json

@@ -0,0 +1,44 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "id": "AwsCdk",
+  "title": "",
+  "type": "object",
+  "properties": {
+    "name": {
+      "type": "string",
+      "description": "",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "What name would you like to use?"
+    },
+    "tags": {
+      "type": "string",
+      "description": "Add tags to the project (used for linting)",
+      "alias": "t"
+    },
+    "directory": {
+      "type": "string",
+      "description": "A directory where the project is placed",
+      "alias": "d"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files",
+      "type": "boolean",
+      "default": false
+    },
+    "unitTestRunner": {
+      "description": "Adds the specified unit test runner",
+      "type": "string",
+      "enum": ["jest", "none"],
+      "default": "jest"
+    },
+    "setParserOptionsProject": {
+      "type": "boolean",
+      "description": "Whether or not to configure the ESLint \"parserOptions.project\" option. We do not do this by default for lint performance reasons.",
+      "default": false
+    }
+  },
+  "required": ["name"]
+}

package/src/generators/init/init.spec.ts

@@ -0,0 +1,22 @@
+import { readJson, Tree } from '@nx/devkit';
+import { createTreeWithEmptyWorkspace } from '@nx/devkit/testing';
+
+import { initGenerator } from './init';
+import { InitGeneratorSchema } from './schema';
+
+describe('init', () => {
+  let tree: Tree;
+  const options: InitGeneratorSchema = {};
+
+  beforeEach(() => {
+    tree = createTreeWithEmptyWorkspace();
+  });
+
+  it('should add aws-cdk dependency', async () => {
+    await initGenerator(tree, options);
+    const packageJson = readJson(tree, 'package.json');
+
+    expect(packageJson.dependencies['aws-cdk-lib']).toBeDefined();
+    expect(packageJson.dependencies['aws-cdk']).toBeDefined();
+  });
+});

package/src/generators/init/init.ts

@@ -0,0 +1,45 @@
+import { addDependenciesToPackageJson, convertNxGenerator, formatFiles, GeneratorCallback, Tree } from '@nx/devkit';
+import { jestInitGenerator } from '@nx/jest';
+
+import { InitGeneratorSchema } from './schema';
+import { CDK_CONSTRUCTS_VERSION, CDK_VERSION } from '../../utils/cdk-shared';
+
+function normalizeOptions(schema: InitGeneratorSchema) {
+  return {
+    ...schema,
+    unitTestRunner: schema.unitTestRunner ?? 'jest',
+  };
+}
+
+export async function initGenerator(host: Tree, options: InitGeneratorSchema) {
+  let jestInstall: GeneratorCallback;
+  const schema = normalizeOptions(options);
+
+  if (schema.unitTestRunner === 'jest') {
+    jestInstall = await jestInitGenerator(host, {});
+  }
+
+  const installTask = addDependenciesToPackageJson(
+    host,
+    {
+      'aws-cdk': CDK_VERSION,
+      'aws-cdk-lib': CDK_VERSION,
+      constructs: CDK_CONSTRUCTS_VERSION,
+    },
+    {}
+  );
+
+  if (!schema.skipFormat) {
+    await formatFiles(host);
+  }
+
+  return async () => {
+    if (jestInstall) {
+      await jestInstall();
+    }
+    await installTask();
+  };
+}
+
+export default initGenerator;
+export const initSchematic = convertNxGenerator(initGenerator);

package/src/generators/init/schema.d.ts

@@ -0,0 +1,4 @@
+export interface InitGeneratorSchema {
+  unitTestRunner?: 'jest' | 'none';
+  skipFormat?: boolean;
+}

package/src/generators/init/schema.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "id": "AwsCdkInit",
+  "title": "Add AWS CDK Schematics",
+  "type": "object",
+  "properties": {
+    "unitTestRunner": {
+      "description": "Adds the specified unit test runner",
+      "type": "string",
+      "enum": ["jest", "none"],
+      "default": "jest"
+    },
+    "skipFormat": {
+      "description": "Skip formatting files",
+      "type": "boolean",
+      "default": false
+    }
+  },
+  "required": []
+}

package/src/interfaces/parsed-executor.interface.ts

@@ -0,0 +1,7 @@
+export interface ParsedExecutorInterface {
+  parseArgs?: Record<string, string | string[]>;
+  stacks?: string[];
+  sourceRoot: string;
+  root: string;
+  env?: Record<string, string>;
+}

package/src/utils/cdk-shared.ts

@@ -0,0 +1,2 @@
+export const CDK_VERSION = '^2.77.0';
+export const CDK_CONSTRUCTS_VERSION = '^10.2.10';

package/src/utils/executor.util.ts

@@ -0,0 +1,120 @@
+import { exec } from 'child_process';
+
+import { DeployExecutorSchema } from '../executors/deploy/schema';
+import { ParsedExecutorInterface } from '../interfaces/parsed-executor.interface';
+import { logger, detectPackageManager } from '@nx/devkit';
+import { BootstrapExecutorSchema } from '../executors/bootstrap/schema';
+import { getPackageJson } from '@nx/eslint-plugin/src/utils/package-json-utils';
+import * as path from 'node:path';
+
+export const executorPropKeys = ['stacks'];
+export const LARGE_BUFFER = 1024 * 1000000;
+
+const NX_WORKSPACE_ROOT = process.env.NX_WORKSPACE_ROOT ?? '';
+if (!NX_WORKSPACE_ROOT) {
+  throw new Error('CDK not Found');
+}
+
+export function generateCommandString(command: string, appPath: string) {
+  const packageManager = detectPackageManager();
+  const packageManagerExecutor = packageManager === 'npm' ? 'npx' : packageManager;
+
+  const projectPath = path.join(NX_WORKSPACE_ROOT, appPath);
+  const moduleType = getModuleType(projectPath);
+  const tsNodePart = moduleType === 'module' ? '--loader ts-node/esm' : 'ts-node';
+
+  const generatePath = `"${packageManagerExecutor} ${tsNodePart} --require tsconfig-paths/register --project ${path.join(projectPath, 'tsconfig.app.json')} ${path.join(projectPath, '/src/main.ts')}"`;
+  return `node --require ts-node/register ${path.join(NX_WORKSPACE_ROOT, 'node_modules/aws-cdk/bin/cdk')} -a ${generatePath} ${command}`;
+}
+
+export function parseArgs(options: DeployExecutorSchema | BootstrapExecutorSchema): Record<string, string | string[]> {
+  const keys = Object.keys(options);
+  return keys
+    .filter((prop) => executorPropKeys.indexOf(prop) < 0)
+    .reduce((acc, key) => {
+      acc[key] = options[key];
+      return acc;
+    }, {});
+}
+
+export function createCommand(command: string, options: ParsedExecutorInterface): string {
+  console.log('OptionsParsedExecutorInterface', JSON.stringify(options));
+
+  const nodeCommandWithRelativePath = generateCommandString(command, options.root);
+  console.log('nodeCommandWithRelativePath', nodeCommandWithRelativePath);
+  const commands = [nodeCommandWithRelativePath];
+
+  if (typeof options.stacks === 'string') {
+    commands.push(options.stacks);
+  }
+
+  for (const arg in options.parseArgs) {
+    const parsedArg = options.parseArgs[arg];
+    if (Array.isArray(parsedArg)) {
+      parsedArg.forEach((value) => {
+        commands.push(`--${arg} ${value}`);
+      });
+    } else {
+      commands.push(`--${arg} ${parsedArg}`);
+    }
+  }
+
+  return commands.join(' ');
+}
+
+export function runCommandProcess(command: string, cwd: string): Promise<boolean> {
+  return new Promise((resolve) => {
+    logger.debug(`Executing command: ${command}`);
+
+    const childProcess = exec(command, {
+      maxBuffer: LARGE_BUFFER,
+      env: process.env,
+      cwd: cwd,
+    });
+
+    // Ensure the child process is killed when the parent exits
+    const processExitListener = () => childProcess.kill();
+    process.on('exit', processExitListener);
+    process.on('SIGTERM', processExitListener);
+
+    process.stdin.on('data', (data) => {
+      childProcess.stdin.write(data);
+      childProcess.stdin.end();
+    });
+
+    childProcess.stdout.on('data', (data) => {
+      process.stdout.write(data);
+    });
+
+    childProcess.stderr.on('data', (err) => {
+      process.stderr.write(err);
+    });
+
+    childProcess.on('close', (code) => {
+      if (code === 0) {
+        resolve(true);
+      } else {
+        resolve(false);
+      }
+
+      process.removeListener('exit', processExitListener);
+
+      if (process.stdin.isTTY) {
+        process.stdin.end();
+      }
+      process.stdin.removeListener('data', processExitListener);
+    });
+  });
+}
+
+function getModuleType(projectPath: string) {
+  const packageJsonPath = path.join(NX_WORKSPACE_ROOT, projectPath, 'package.json');
+  const appPackageJson = getPackageJson(packageJsonPath);
+  if (appPackageJson?.type) {
+    console.log('App Package Json', appPackageJson.type);
+    return appPackageJson.type;
+  }
+  const globalPackageJson = getPackageJson(path.join(NX_WORKSPACE_ROOT, 'package.json'));
+  console.log('Global Package Json', globalPackageJson.type);
+  return globalPackageJson.type;
+}

package/src/utils/testing.ts

@@ -0,0 +1,28 @@
+import { ExecutorContext } from '@nx/devkit';
+
+export function mockExecutorContext(executorName: string, workspaceVersion = 2): ExecutorContext {
+  return {
+    projectName: 'proj',
+    root: '/root',
+    cwd: '/root',
+    nxJsonConfiguration: {},
+    projectsConfigurations: {
+      version: workspaceVersion,
+      projects: {
+        proj: {
+          root: 'apps/proj',
+          targets: {
+            test: {
+              executor: `@wolsok/nx-aws-cdk-v2:${executorName}`,
+            },
+          },
+        },
+      },
+    },
+    projectGraph: { nodes: {}, dependencies: {} },
+    target: {
+      executor: `@wolsok/nx-aws-cdk-v2:${executorName}`,
+    },
+    isVerbose: true,
+  };
+}

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "files": [],
+  "include": [],
+  "references": [
+    {
+      "path": "./tsconfig.lib.json"
+    },
+    {
+      "path": "./tsconfig.spec.json"
+    }
+  ]
+}

package/tsconfig.lib.json

@@ -0,0 +1,11 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "module": "commonjs",
+    "outDir": "../../dist/out-tsc",
+    "declaration": true,
+    "types": ["node"]
+  },
+  "exclude": ["**/*.spec.ts", "**/*.test.ts", "jest.config.ts"],
+  "include": ["**/*.ts"]
+}

package/tsconfig.spec.json

@@ -0,0 +1,20 @@
+{
+  "extends": "./tsconfig.json",
+  "compilerOptions": {
+    "outDir": "../../dist/out-tsc",
+    "module": "commonjs",
+    "types": ["jest", "node"]
+  },
+  "include": [
+    "**/*.spec.ts",
+    "**/*.test.ts",
+    "**/*.spec.tsx",
+    "**/*.test.tsx",
+    "**/*.spec.js",
+    "**/*.test.js",
+    "**/*.spec.jsx",
+    "**/*.test.jsx",
+    "**/*.d.ts",
+    "jest.config.ts"
+  ]
+}