@cdktn/provider-generator 0.24.0-pre.87 → 0.24.0-pre.89

package/src/get/__tests__/generator/provider-functions.test.ts

@@ -0,0 +1,262 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import {
+  assertNoFunctionsGetterCollision,
+  buildProviderFunctionsModel,
+} from "../../generator/models/provider-function-model";
+import { CodeMaker } from "codemaker";
+import { FunctionSignature } from "@cdktn/commons";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate provider functions for the time provider (real terraform 1.15.6 schema fragment)", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("provider-functions.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "provider-functions.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const providerFunctionsOutput = fs.readFileSync(
+    path.join(workdir, "providers/time/provider-functions/index.ts"),
+    "utf-8",
+  );
+  expect(providerFunctionsOutput).toMatchSnapshot("time-provider-functions");
+
+  const providerOutput = fs.readFileSync(
+    path.join(workdir, "providers/time/provider/index.ts"),
+    "utf-8",
+  );
+  expect(providerOutput).toMatchSnapshot("time-provider");
+
+  const providerIndex = fs.readFileSync(
+    path.join(workdir, "providers/time/index.ts"),
+    "utf-8",
+  );
+  expect(providerIndex).toMatchSnapshot("provider-index");
+
+  const providerLazyIndex = fs.readFileSync(
+    path.join(workdir, "providers/time/lazy-index.ts"),
+    "utf-8",
+  );
+  expect(providerLazyIndex).toMatchSnapshot("provider-lazy-index");
+});
+
+describe("generate provider functions covering variadic parameters, primitive/list returns, and a 'default' parameter name", () => {
+  let providerFunctionsOutput: string;
+  let providerIndex: string;
+  let providerLazyIndex: string;
+
+  beforeAll(async () => {
+    const code = new CodeMaker();
+    const workdir = tmp("provider-functions-synthetic.test");
+    const spec = JSON.parse(
+      fs.readFileSync(
+        path.join(
+          __dirname,
+          "fixtures",
+          "provider-functions-synthetic.test.fixture.json",
+        ),
+        "utf-8",
+      ),
+    );
+    new TerraformProviderGenerator(code, spec).generateAll();
+    await code.save(workdir);
+
+    providerFunctionsOutput = fs.readFileSync(
+      path.join(workdir, "providers/example/provider-functions/index.ts"),
+      "utf-8",
+    );
+    providerIndex = fs.readFileSync(
+      path.join(workdir, "providers/example/index.ts"),
+      "utf-8",
+    );
+    providerLazyIndex = fs.readFileSync(
+      path.join(workdir, "providers/example/lazy-index.ts"),
+      "utf-8",
+    );
+  });
+
+  test("matches the snapshot", () => {
+    expect(providerFunctionsOutput).toMatchSnapshot(
+      "example-provider-functions",
+    );
+    expect(providerIndex).toMatchSnapshot("provider-index");
+    expect(providerLazyIndex).toMatchSnapshot("provider-lazy-index");
+  });
+
+  test("nested collection docstrings use the compact recursive Array/Set notation", () => {
+    // list(set(string)): notation carries the structure; a plain Terraform
+    // list needs no prose note.
+    expect(providerFunctionsOutput).toContain(
+      "@param {Array<Set<string>>} nameGroups",
+    );
+    expect(providerFunctionsOutput).toContain("@returns {Array<Set<string>>}");
+    // set(list(string)): Set<...> notation plus the set-semantics prose note
+    // (the jsii type is still an array - the note keeps a reader from
+    // literally passing a JS Set).
+    expect(providerFunctionsOutput).toContain(
+      "@param {Set<Array<string>>} nameLists - Terraform set; ordering is not guaranteed and duplicate values are removed.",
+    );
+    expect(providerFunctionsOutput).toContain(
+      "@returns {Set<Array<string>>} Terraform set; ordering is not guaranteed and duplicate values are removed.",
+    );
+  });
+
+  // This package has no TypeScript-compiling harness
+  // for generated output (no fixture/test anywhere generates a snippet and
+  // feeds it through `tsc`/`ts.transpileModule`, and `cdktn` itself isn't a
+  // dependency of this package to typecheck against), so these are
+  // structural assertions on the emitted declaration text rather than an
+  // actual compile - see also the runtime-level proof in
+  // packages/cdktn/test/provider-functions.test.ts, which exercises the
+  // same union/token mechanics these signatures rely on.
+  describe("composition: a function's return type is directly assignable to another function's parameter of the 'same' Terraform type", () => {
+    test("flagsForSeed()'s set(bool) return type (cdktn.IResolvable) is one of the exact union members flagSet()'s set(bool) parameter declares", () => {
+      expect(providerFunctionsOutput).toContain(
+        "public flagsForSeed(seed: string): cdktn.IResolvable {",
+      );
+      expect(providerFunctionsOutput).toContain(
+        "public flagSet(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {",
+      );
+    });
+
+    test("defaultTags()'s map(string) return type is textually identical to tagMap()'s map(string) parameter type", () => {
+      expect(providerFunctionsOutput).toContain(
+        "public defaultTags(prefix: string): { [key: string]: string } {",
+      );
+      expect(providerFunctionsOutput).toContain(
+        "public tagMap(tags: { [key: string]: string }): string {",
+      );
+    });
+  });
+
+  test("a list(bool) parameter (not just set(bool)) also accepts a whole-collection token", () => {
+    expect(providerFunctionsOutput).toContain(
+      "public flagsOrdered(flags: Array<boolean | cdktn.IResolvable> | cdktn.IResolvable): cdktn.IResolvable {",
+    );
+  });
+
+  test("a list(object) parameter widens to any[] | cdktn.IResolvable (whole-collection token accepted)", () => {
+    expect(providerFunctionsOutput).toContain(
+      "public describeConfigs(configs: any[] | cdktn.IResolvable): string {",
+    );
+  });
+});
+
+test("buildProviderFunctionsModel throws when two function names collapse to the same generated method name", () => {
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      foo_bar: { return_type: "string", parameters: [] },
+      foo__bar: { return_type: "string", parameters: [] },
+    }),
+  ).toThrow(/foo_bar/);
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      foo_bar: { return_type: "string", parameters: [] },
+      foo__bar: { return_type: "string", parameters: [] },
+    }),
+  ).toThrow(/foo__bar/);
+});
+
+test("buildProviderFunctionsModel throws when two parameter names collapse within one function", () => {
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      my_function: {
+        return_type: "string",
+        parameters: [
+          { name: "some_value", type: "string" },
+          { name: "some__value", type: "string" },
+        ],
+      },
+    }),
+  ).toThrow(/some_value/);
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      my_function: {
+        return_type: "string",
+        parameters: [
+          { name: "some_value", type: "string" },
+          { name: "some__value", type: "string" },
+        ],
+      },
+    }),
+  ).toThrow(/some__value/);
+});
+
+// Both of these assert the model-level throw happens before any file is
+// generated: buildProviderFunctionsModel is called directly, with no
+// CodeMaker/generator involved, so there is no emission step to reach.
+test("buildProviderFunctionsModel throws when a function name sanitizes to 'constructor'", () => {
+  // The nested signature literal is cast to `FunctionSignature` (rather than
+  // relying on contextual typing from the surrounding index signature)
+  // because TypeScript special-cases a property literally named
+  // "constructor" - contextually typing it against `Function` (from
+  // `Object.prototype`) instead of the index signature's `FunctionSignature`,
+  // and spuriously flagging `return_type: "string"` as an error. See
+  // https://github.com/microsoft/TypeScript/issues/40776.
+  const signature: FunctionSignature = {
+    return_type: "string",
+    parameters: [],
+  };
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      constructor: signature,
+    }),
+  ).toThrow(/constructor/);
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      constructor: signature,
+    }),
+  ).toThrow(/example/);
+});
+
+test("buildProviderFunctionsModel throws when a function name sanitizes to 'providerLocalName'", () => {
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      provider_local_name: { return_type: "string", parameters: [] },
+    }),
+  ).toThrow(/provider_local_name/);
+  expect(() =>
+    buildProviderFunctionsModel("example", {
+      provider_local_name: { return_type: "string", parameters: [] },
+    }),
+  ).toThrow(/providerLocalName/);
+});
+
+test("assertNoFunctionsGetterCollision throws when the provider's own config schema would generate a 'functions' property", () => {
+  expect(() =>
+    assertNoFunctionsGetterCollision("example", ["alias", "functions"]),
+  ).toThrow(/"functions"/);
+});
+
+test("assertNoFunctionsGetterCollision does not throw when there is no colliding attribute", () => {
+  expect(() =>
+    assertNoFunctionsGetterCollision("example", ["alias"]),
+  ).not.toThrow();
+});
+
+test("generation throws when a provider's config attribute collides with the generated 'functions' getter", async () => {
+  const code = new CodeMaker();
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(
+        __dirname,
+        "fixtures",
+        "provider-functions-collision.test.fixture.json",
+      ),
+      "utf-8",
+    ),
+  );
+  expect(() =>
+    new TerraformProviderGenerator(code, spec).generateAll(),
+  ).toThrow(/"functions"/);
+});

package/src/get/__tests__/generator/provider.test.ts

@@ -25,6 +25,10 @@ test("generate provider", async () => {
     "utf-8",
   );
   expect(output).toMatchSnapshot();
+  // aws has no provider-defined functions in this fixture - no getter, no
+  // cross-directory import should be emitted.
+  expect(output).not.toContain("public get functions()");
+  expect(output).not.toContain("provider-functions");
 });
 
 test("generate provider with only block_types", async () => {
@@ -48,4 +52,8 @@ test("generate provider with only block_types", async () => {
     "utf-8",
   );
   expect(output).toMatchSnapshot();
+  // elasticstack has no provider-defined functions in this fixture - no
+  // getter, no cross-directory import should be emitted.
+  expect(output).not.toContain("public get functions()");
+  expect(output).not.toContain("provider-functions");
 });

package/src/get/__tests__/generator/write-only.test.ts

@@ -0,0 +1,71 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs";
+import * as path from "path";
+import { TerraformProviderGenerator } from "../../generator/provider-generator";
+import { CodeMaker } from "codemaker";
+import { createTmpHelper } from "../util";
+
+const tmp = createTmpHelper();
+
+test("generate a vault_alicloud_secret_backend resource with a write-only attribute", async () => {
+  const code = new CodeMaker();
+  const workdir = tmp("write-only.test");
+  const spec = JSON.parse(
+    fs.readFileSync(
+      path.join(__dirname, "fixtures", "write-only.test.fixture.json"),
+      "utf-8",
+    ),
+  );
+  new TerraformProviderGenerator(code, spec).generateAll();
+  await code.save(workdir);
+
+  const output = fs.readFileSync(
+    path.join(workdir, "providers/vault/alicloud-secret-backend/index.ts"),
+    "utf-8",
+  );
+  expect(output).toMatchSnapshot();
+
+  // The write-only attribute's getter is deprecated ...
+  expect(output).toMatch(
+    /@deprecated Write-only: the provider never returns this value[\s\S]*?public get secretKeyWo\(\)/,
+  );
+  // ... its setter is a plain assignment ...
+  expect(output).toMatch(
+    /public set secretKeyWo\(value: string\) \{\n\s*this\._secretKeyWo = value;\n\s*\}/,
+  );
+  // ... and usage registration happens at resolve time, from inside
+  // synthesizeAttributes()/synthesizeHclAttributes(), by wrapping the
+  // mapped value in markWriteOnlyAttribute() ...
+  expect(output).toMatch(
+    /secret_key_wo: this\.markWriteOnlyAttribute\(cdktn\.stringToTerraform\(this\._secretKeyWo\)\),/,
+  );
+  expect(output).toMatch(
+    /value: this\.markWriteOnlyAttribute\(cdktn\.stringToHclTerraform\(this\._secretKeyWo\)\),/,
+  );
+
+  // The required write-only attribute gets no reset method (required
+  // attributes never do) ...
+  expect(output).not.toMatch(/resetSecretKeyWo\b/);
+  // ... but the OPTIONAL write-only sibling does, exercising the reset ->
+  // clear -> synth-passes path end to end at the generator level.
+  expect(output).toMatch(
+    /public resetSecondarySecretKeyWo\(\) \{\n\s*this\._secondarySecretKeyWo = undefined;\n\s*\}/,
+  );
+  expect(output).toMatch(
+    /secondary_secret_key_wo: this\.markWriteOnlyAttribute\(cdktn\.stringToTerraform\(this\._secondarySecretKeyWo\)\),/,
+  );
+
+  // The non-write-only sibling attribute is untouched: its getter is
+  // emitted directly (no @deprecated JSDoc immediately above), its setter
+  // has no registration call, and its synthesis isn't wrapped.
+  expect(output).toMatch(
+    /private _secretKeyWoVersion\?: number; \n\s*public get secretKeyWoVersion\(\)/,
+  );
+  expect(output).toMatch(
+    /public set secretKeyWoVersion\(value: number\) \{\n\s*this\._secretKeyWoVersion = value;\n\s*\}/,
+  );
+  expect(output).toMatch(
+    /secret_key_wo_version: cdktn\.numberToTerraform\(this\._secretKeyWoVersion\),/,
+  );
+});

package/src/get/__tests__/target-versions.test.ts

@@ -0,0 +1,206 @@
+// Copyright (c) HashiCorp, Inc
+// SPDX-License-Identifier: MPL-2.0
+import * as fs from "fs-extra";
+import * as path from "path";
+import {
+  Language,
+  TerraformDependencyConstraint,
+  TerraformTargetVersions,
+} from "@cdktn/commons";
+import { createTmpHelper } from "./util";
+
+const mockReadSchema = jest.fn();
+jest.mock("@cdktn/provider-schema", () => ({
+  readSchema: (...args: unknown[]) => mockReadSchema(...args),
+}));
+
+// Imported after the mock so ConstructsMaker picks up the mocked readSchema.
+import { ConstructsMaker, GetOptions } from "../constructs-maker";
+
+const tmp = createTmpHelper();
+
+const constraint: TerraformDependencyConstraint = {
+  fqn: "hashicorp/random",
+  name: "random",
+  source: "hashicorp/random",
+  version: "3.1.3",
+};
+
+// Minimal schema - no resources/data sources - so generation stays within
+// pure TypeScript emission (no jsii-pacmak invocation), mirroring the
+// "empty-provider-resources" fixture used elsewhere in this package.
+const fakeSchema = {
+  providerSchema: {
+    format_version: "0.2" as const,
+    provider_schemas: {
+      "registry.terraform.io/hashicorp/random": {
+        resource_schemas: null,
+        data_source_schemas: null,
+      },
+    },
+    provider_versions: {
+      "registry.terraform.io/hashicorp/random": "3.1.3",
+    },
+    cli_name: "terraform",
+    cli_version: "1.7.5",
+  },
+};
+
+describe("targetVersions threading through 'cdktn get'", () => {
+  beforeEach(() => {
+    mockReadSchema.mockReset();
+    mockReadSchema.mockResolvedValue(fakeSchema);
+  });
+
+  it("passes GetOptions.targetVersions through to readSchema", async () => {
+    const workdir = tmp("target-versions-thread.test");
+    const targetVersions: TerraformTargetVersions = { terraform: ">=1.5.7" };
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    };
+
+    const maker = new ConstructsMaker(options, "/some/cache/path");
+    await maker.generate([constraint]);
+
+    expect(mockReadSchema).toHaveBeenCalledWith(
+      [constraint],
+      "/some/cache/path",
+      targetVersions,
+    );
+  });
+
+  it("omits targetVersions from the readSchema call when not configured", async () => {
+    const workdir = tmp("target-versions-absent.test");
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    expect(mockReadSchema).toHaveBeenCalledWith(
+      [constraint],
+      undefined,
+      undefined,
+    );
+  });
+
+  it("stamps constraints.json with targetVersions + cli identity, and older constraints.json files without those fields are still treated as fresh (no forced regeneration)", async () => {
+    const workdir = tmp("target-versions-stamp.test");
+    const targetVersions: TerraformTargetVersions = { terraform: ">=1.5.7" };
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    const constraintsFile = JSON.parse(
+      await fs.readFile(path.join(workdir, "constraints.json"), "utf8"),
+    );
+    expect(constraintsFile.targetVersions).toEqual(targetVersions);
+    expect(constraintsFile.cli).toEqual({
+      name: "terraform",
+      version: "1.7.5",
+    });
+
+    // Rewrite constraints.json as it would have looked before this feature
+    // landed (no targetVersions/cli fields), keeping the rest identical -
+    // this simulates re-running `cdktn get` against an output directory
+    // generated by an older cdktn version.
+    const {
+      targetVersions: _tv,
+      cli: _cli,
+      ...legacyConstraints
+    } = constraintsFile;
+    await fs.writeFile(
+      path.join(workdir, "constraints.json"),
+      JSON.stringify(legacyConstraints, null, 2),
+    );
+
+    const maker2 = new ConstructsMaker(options);
+    const toGenerate = await maker2.filterAlreadyGenerated([constraint]);
+    expect(toGenerate).toEqual([]);
+  });
+
+  it("threads a partial targetVersions (single product) through unchanged and stamps it verbatim", async () => {
+    const workdir = tmp("target-versions-partial.test");
+    const targetVersions: TerraformTargetVersions = { opentofu: ">=1.11.0" };
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    expect(mockReadSchema).toHaveBeenCalledWith(
+      [constraint],
+      undefined,
+      targetVersions,
+    );
+
+    // The stamp records exactly what the project declared - no terraform
+    // default is injected at get-time (defaulting for the undeclared
+    // product happens only at synth-time, in resolveTargetVersions).
+    const constraintsFile = JSON.parse(
+      await fs.readFile(path.join(workdir, "constraints.json"), "utf8"),
+    );
+    expect(constraintsFile.targetVersions).toEqual({ opentofu: ">=1.11.0" });
+  });
+
+  it("omits the cli stamp when the fetched schema carries no CLI version metadata", async () => {
+    const workdir = tmp("target-versions-no-cli.test");
+    const {
+      cli_name: _cliName,
+      cli_version: _cliVersion,
+      ...schemaWithoutCli
+    } = fakeSchema.providerSchema;
+    mockReadSchema.mockResolvedValue({ providerSchema: schemaWithoutCli });
+
+    const targetVersions: TerraformTargetVersions = { terraform: ">=1.5.7" };
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions,
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    const constraintsFile = JSON.parse(
+      await fs.readFile(path.join(workdir, "constraints.json"), "utf8"),
+    );
+    expect(constraintsFile.cli).toBeUndefined();
+    expect(constraintsFile.targetVersions).toEqual(targetVersions);
+  });
+
+  it("does not force regeneration when targetVersions change between runs", async () => {
+    // The stamp is diagnostic-only: per the GetOptions.targetVersions doc,
+    // targetVersions never filters codegen (the full schema surface is
+    // always generated), so freshness only compares the providers map and
+    // the cdktf version.
+    const workdir = tmp("target-versions-change.test");
+    const options: GetOptions = {
+      codeMakerOutput: workdir,
+      targetLanguage: Language.TYPESCRIPT,
+      targetVersions: { terraform: ">=1.5.7" },
+    };
+
+    const maker = new ConstructsMaker(options);
+    await maker.generate([constraint]);
+
+    const maker2 = new ConstructsMaker({
+      ...options,
+      targetVersions: { terraform: ">=1.11.0" },
+    });
+    const toGenerate = await maker2.filterAlreadyGenerated([constraint]);
+    expect(toGenerate).toEqual([]);
+  });
+});

package/src/get/constructs-maker.ts

@@ -15,6 +15,7 @@ import {
   ModuleSchema,
   Errors,
   type LanguageOptions,
+  type TerraformTargetVersions,
 } from "@cdktn/commons";
 import { DISPLAY_VERSION, Language } from "@cdktn/commons";
 import { TerraformProviderGenerator } from "./generator/provider-generator";
@@ -265,7 +266,23 @@ export async function generateJsiiLanguage(
   });
 }
 
-type ConstraintFile = { providers: Record<string, string>; cdktf: string };
+type ConstraintFile = {
+  providers: Record<string, string>;
+  cdktf: string;
+  /**
+   * The project's declared targetVersions (cdktf.json), stamped for
+   * diagnostics/cache debugging. Purely informational - never read back to
+   * decide whether cached output is stale, since it doesn't affect the
+   * generated surface (the full surface is always generated; narrowing
+   * happens at synth).
+   */
+  targetVersions?: TerraformTargetVersions;
+  /**
+   * Identity of the CLI (terraform/opentofu) that fetched the schemas used
+   * for this generation, stamped for diagnostics/cache debugging.
+   */
+  cli?: { name?: string; version?: string };
+};
 
 export interface GetOptions {
   readonly targetLanguage: Language;
@@ -280,6 +297,13 @@ export interface GetOptions {
    * Language-specific code generation options.
    */
   readonly languageOptions?: LanguageOptions;
+  /**
+   * The project's declared targetVersions (cdktf.json). Used to drive the
+   * fetch-time emission-gap warning in @cdktn/provider-schema and to stamp
+   * the generated constraints.json for diagnostics. Does NOT filter codegen:
+   * the full surface is always generated, narrowing happens at synth.
+   */
+  readonly targetVersions?: TerraformTargetVersions;
 }
 
 export class ConstructsMaker {
@@ -570,6 +594,7 @@ export class ConstructsMaker {
   // this is used for caching purposes
   private emitConstraintsFile(
     allowedConstraints: TerraformDependencyConstraint[],
+    providerSchema?: ProviderSchema,
   ) {
     const filePath = "constraints.json";
 
@@ -586,6 +611,17 @@ export class ConstructsMaker {
         ),
     };
 
+    if (this.options.targetVersions) {
+      content.targetVersions = this.options.targetVersions;
+    }
+
+    if (providerSchema?.cli_name || providerSchema?.cli_version) {
+      content.cli = {
+        name: providerSchema.cli_name,
+        version: providerSchema.cli_version,
+      };
+    }
+
     this.code.openFile(filePath);
     this.code.line(JSON.stringify(content, null, 2));
     this.code.closeFile(filePath);
@@ -686,7 +722,11 @@ a NODE_OPTIONS variable, we won't override it. Hence, the provider generation mi
   }
 
   public async getSchemas(targets: TerraformDependencyConstraint[]) {
-    return await readSchema(targets, this.schemaCachePath);
+    return await readSchema(
+      targets,
+      this.schemaCachePath,
+      this.options.targetVersions,
+    );
   }
 
   public async generate(
@@ -708,7 +748,7 @@ a NODE_OPTIONS variable, we won't override it. Hence, the provider generation mi
     endGenerateTimer();
 
     this.updateVersionsFile(allConstraints);
-    this.emitConstraintsFile(allConstraints);
+    this.emitConstraintsFile(allConstraints, schemas.providerSchema);
 
     if (this.isJavascriptTarget) {
       await this.save();