feat(cli): support generating provider bindings in parallel

CHANGELOG.md

@@ -1,3 +1,9 @@
+## 0.13.0 (unreleased)
+
+**Breaking Changes**
+
+A very minor change in the UX of the `cdktf get` command now generates the provider bindings for all languages other than Typescript in parallel. This speeds up the process in general, but on devices with limited memory it could lead to Out Of Memory errors. If this happens you can limit the parallelism by providing the parallelism flag: `cdktf get --parallelism=1`.
+
 ## 0.12.2
 
 **Breaking Changes**

packages/@cdktf/provider-generator/lib/get/constructs-maker.ts

@@ -52,6 +52,7 @@ export async function generateJsiiLanguage(
 export interface GetOptions {
   readonly targetLanguage: Language;
   readonly codeMakerOutput: string;
+  readonly jsiiParallelism?: number;
   /**
    * Path to copy the output .jsii file.
    * @default - jsii file is not emitted
@@ -365,9 +366,24 @@ a NODE_OPTIONS variable, we won't override it. Hence, the provider generation mi
     }
 
     if (!this.isJavascriptTarget || this.options.outputJsii) {
-      for (const target of this.targets) {
-        await this.generateJsiiLanguage(target);
-      }
+      const numberOfWorkers =
+        this.options.jsiiParallelism === -1
+          ? this.targets.length
+          : this.options.jsiiParallelism;
+
+      const work = [...this.targets];
+      const workers = new Array(numberOfWorkers).fill(async () => {
+        let target: ConstructsMakerTarget | undefined;
+        while ((target = work.pop())) {
+          const endJsiiTarget = logTimespan(
+            `Generating JSII bindings for ${target.name}`
+          );
+          await this.generateJsiiLanguage(target);
+          endJsiiTarget();
+        }
+      });
+
+      await Promise.all(workers.map((fn) => fn()));
     }
 
     for (const target of this.targets) {

packages/cdktf-cli/bin/cmds/get.ts

@@ -28,6 +28,12 @@ class Command extends BaseCommand {
         desc: "Output programming language",
         alias: "l",
         choices: LANGUAGES,
+      })
+      .option("parallelism", {
+        type: "number",
+        required: false,
+        desc: "Number of concurrently generated provider / module bindings. Only applies for languages that are not Typescript (translated by JSII). Defaults to infinity, denoted by -1",
+        default: -1,
       });
 
   public async handleCommand(argv: any) {

packages/cdktf-cli/bin/cmds/handlers.ts

@@ -184,7 +184,11 @@ export async function diff(argv: any) {
   );
 }
 
-export async function get(argv: { output: string; language: Language }) {
+export async function get(argv: {
+  output: string;
+  language: Language;
+  parallelism: number;
+}) {
   throwIfNotProjectDirectory();
   await displayVersionMessage();
   await initializErrorReporting(true);
@@ -193,7 +197,7 @@ export async function get(argv: { output: string; language: Language }) {
   const config = cfg.readConfigSync(); // read config again to be up-to-date (if called via 'add' command)
   const providers = config.terraformProviders ?? [];
   const modules = config.terraformModules ?? [];
-  const { output, language } = argv;
+  const { output, language, parallelism } = argv;
 
   const constraints: cfg.TerraformDependencyConstraint[] = [
     ...providers,
@@ -212,6 +216,7 @@ export async function get(argv: { output: string; language: Language }) {
       codeMakerOutput: output,
       language: language,
       constraints,
+      parallelism,
     })
   );
 }
@@ -418,6 +423,10 @@ export async function providerAdd(argv: any) {
     console.log(
       "Local providers have been updated. Running cdktf get to update..."
     );
-    await get({ language: language, output: config.codeMakerOutput });
+    await get({
+      language: language,
+      output: config.codeMakerOutput,
+      parallelism: -1,
+    });
   }
 }

packages/cdktf-cli/bin/cmds/ui/get.tsx

@@ -10,12 +10,14 @@ interface GetConfig {
   codeMakerOutput: string;
   language: Language;
   constraints: config.TerraformDependencyConstraint[];
+  parallelism: number;
 }
 
 export const Get = ({
   codeMakerOutput,
   language,
   constraints,
+  parallelism,
 }: GetConfig): React.ReactElement => {
   const [currentStatus, setCurrentStatus] = React.useState<Status>(
     Status.STARTING
@@ -25,6 +27,7 @@ export const Get = ({
   const constructsOptions: GetOptions = {
     codeMakerOutput: codeMakerOutput,
     targetLanguage: language,
+    jsiiParallelism: parallelism,
   };
 
   React.useEffect(() => {

website/docs/cdktf/cli-reference/commands.mdx

@@ -301,11 +301,15 @@ cdktf get [OPTIONS]
 Generate CDK Constructs for Terraform providers and modules.
 
 Options:
-  --version          Show version number                                                                                                            [boolean]
-  --log-level        Which log level should be written. Only supported via setting the env CDKTF_LOG_LEVEL                                           [string]
-  --output, -o       Output directory for generated Constructs                                                                     [string] [default: ".gen"]
-  --language, -l     Output programming language                                [string] [required] [choices: "typescript", "python", "java", "csharp", "go"]
-  -h, --help         Show help                                                                                                                      [boolean]
+      --version                   Show version number                                                                                                                                                                [boolean]
+      --disable-plugin-cache-env  Dont set TF_PLUGIN_CACHE_DIR automatically. This is useful when the plugin cache is configured differently. Supported using the env CDKTF_DISABLE_PLUGIN_CACHE_ENV.
+                                                                                                                                                                                                    [boolean] [default: false]
+      --log-level                 Which log level should be written. Only supported via setting the env CDKTF_LOG_LEVEL                                                                                               [string]
+  -o, --output                    Output directory for generated Constructs                                                                                                                      [string] [default: "imports"]
+  -l, --language                  Output programming language                                                                [string] [required] [choices: "typescript", "python", "java", "csharp", "go"] [default: "python"]
+      --parallelism               Number of concurrently generated provider / module bindings. Only applies for languages that are not Typescript (translated by JSII). Defaults to infinity, denoted by -1
+                                                                                                                                                                                                        [number] [default: -1]
+  -h, --help                      Show help                                                                                                                                                                          [boolean]
 ```
 
 **Examples**
@@ -325,6 +329,12 @@ $ cat cdktf.json
 $ cdktf get
 ```
 
+If you run into issues generating a lot of bindings you can use the `--parallelism` option to limit the number of bindings generated in parallel.
+
+```bash
+$ cdktf get --parallelism 1
+```
+
 ## init
 
 This command creates a new CDK for Terraform project using a template.