feat(cli): --project-name init option

packages/aws-cdk/lib/cli.ts

@@ -272,7 +272,8 @@ async function parseCommandLineArguments(args: string[]) {
     .command('init [TEMPLATE]', 'Create a new, empty CDK project from a template.', (yargs: Argv) => yargs
       .option('language', { type: 'string', alias: 'l', desc: 'The language to be used for the new project (default can be configured in ~/.cdk.json)', choices: initTemplateLanguages })
       .option('list', { type: 'boolean', desc: 'List the available templates' })
-      .option('generate-only', { type: 'boolean', default: false, desc: 'If true, only generates project files, without executing additional operations such as setting up a git repo, installing dependencies or compiling the project' }),
+      .option('generate-only', { type: 'boolean', default: false, desc: 'If true, only generates project files, without executing additional operations such as setting up a git repo, installing dependencies or compiling the project' })
+      .option('project-name', { type: 'string', desc: 'Name of the generated project (defaults to current directory name)', requiresArg: true }),
     )
     .command('migrate', false /* hidden from "cdk --help" */, (yargs: Argv) => yargs
       .option('stack-name', { type: 'string', alias: 'n', desc: 'The name assigned to the stack created in the new project. The name of the app will be based off this name as well.', requiresArg: true })

packages/aws-cdk/lib/init.ts

@@ -19,6 +19,7 @@ export interface CliInitOptions {
   readonly language?: string;
   readonly canUseNetwork?: boolean;
   readonly generateOnly?: boolean;
+  readonly projectName?: string;
   readonly workDir?: string;
   readonly stackName?: string;
   readonly migrate?: boolean;
@@ -52,7 +53,16 @@ export async function cliInit(options: CliInitOptions) {
     throw new Error('No language was selected');
   }
 
-  await initializeProject(template, options.language, canUseNetwork, generateOnly, workDir, options.stackName, options.migrate);
+  await initializeProject({
+    template,
+    language: options.language,
+    canUseNetwork,
+    generateOnly,
+    projectName: options.projectName,
+    workDir,
+    stackName: options.stackName,
+    migrate: options.migrate,
+  });
 }
 
 /**
@@ -102,16 +112,18 @@ export class InitTemplate {
    *
    * @param language    the language to instantiate this template with
    * @param targetDirectory the directory where the template is to be instantiated into
+   * @param stackName the output project stack name
+   * @param projectName the output project name
    */
-  public async install(language: string, targetDirectory: string, stackName?: string) {
+  public async install(language: string, targetDirectory: string, stackName?: string, projectName?: string) {
     if (this.languages.indexOf(language) === -1) {
       error(`The ${chalk.blue(language)} language is not supported for ${chalk.green(this.name)} `
           + `(it supports: ${this.languages.map(l => chalk.blue(l)).join(', ')})`);
       throw new Error(`Unsupported language: ${language}`);
     }
 
     const projectInfo: ProjectInfo = {
-      name: decamelize(path.basename(path.resolve(targetDirectory))),
+      name: projectName ?? decamelize(path.basename(path.resolve(targetDirectory))),
       stackName,
     };
 
@@ -280,18 +292,32 @@ export async function printAvailableTemplates(language?: string) {
   }
 }
 
+interface InitializeProjectOptions {
+  template: InitTemplate;
+  language: string;
+  canUseNetwork: boolean;
+  generateOnly: boolean;
+  projectName?: string;
+  workDir: string;
+  stackName?: string;
+  migrate?: boolean;
+}
+
 async function initializeProject(
-  template: InitTemplate,
-  language: string,
-  canUseNetwork: boolean,
-  generateOnly: boolean,
-  workDir: string,
-  stackName?: string,
-  migrate?: boolean,
+  {
+    template,
+    language,
+    canUseNetwork,
+    generateOnly,
+    projectName,
+    workDir,
+    stackName,
+    migrate,
+  }: InitializeProjectOptions,
 ) {
   await assertIsEmptyDirectory(workDir);
   print(`Applying project template ${chalk.green(template.name)} for ${chalk.blue(language)}`);
-  await template.install(language, workDir, stackName);
+  await template.install(language, workDir, stackName, projectName);
   if (migrate) {
     await template.addMigrateContext(workDir);
   }

packages/aws-cdk/test/init.test.ts

@@ -181,6 +181,38 @@ describe('constructs version', () => {
     expect(await fs.pathExists(path.join(workDir, '.git'))).toBeFalsy();
   });
 
+  cliTest('--project-name should change the output directory', async (workDir) => {
+    const projectName = 'custom_project-name';
+    await cliInit({
+      type: 'app',
+      language: 'javascript',
+      canUseNetwork: false,
+      generateOnly: true,
+      workDir,
+      projectName,
+    });
+
+    // Check that lib/, bin/ and test/ files have been set correctly
+    expect(await fs.pathExists(path.join(workDir, 'bin', `${projectName}.js`))).toBeTruthy();
+    expect(await fs.pathExists(path.join(workDir, 'lib', `${projectName}-stack.js`))).toBeTruthy();
+    expect(await fs.pathExists(path.join(workDir, 'test', `${projectName}.test.js`))).toBeTruthy();
+
+    // Check that the package.json "name" and "bin" properties have been set correctly
+    const packageJsonFile = path.join(workDir, 'package.json');
+    expect(await fs.pathExists(packageJsonFile)).toBeTruthy();
+
+    const packageJson = JSON.parse(await fs.readFile(packageJsonFile, 'utf8'));
+    expect(packageJson.name).toEqual(projectName);
+    expect(packageJson.bin).toEqual({ [projectName]: `bin/${projectName}.js` });
+
+    // Check that the cdk.json "app" property has been set correctly
+    const cdkJsonFile = path.join(workDir, 'cdk.json');
+    expect(await fs.pathExists(cdkJsonFile)).toBeTruthy();
+
+    const cdkJson = JSON.parse(await fs.readFile(cdkJsonFile, 'utf8'));
+    expect(cdkJson.app).toEqual(`node bin/${projectName}.js`);
+  });
+
   cliTest('git directory does not throw off the initer!', async (workDir) => {
     fs.mkdirSync(path.join(workDir, '.git'));