projen 0.99.66 → 0.99.68

package/lib/cdk/integration-test-base.js

@@ -45,5 +45,5 @@ class IntegrationTestBase extends component_1.Component {
 }
 exports.IntegrationTestBase = IntegrationTestBase;
 _a = JSII_RTTI_SYMBOL_1;
-IntegrationTestBase[_a] = { fqn: "projen.cdk.IntegrationTestBase", version: "0.99.66" };
+IntegrationTestBase[_a] = { fqn: "projen.cdk.IntegrationTestBase", version: "0.99.68" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/cdk/jsii-build.d.ts

@@ -0,0 +1,165 @@
+import type { IConstruct, IMixin } from "constructs";
+import type { JsiiDotNetTarget, JsiiGoTarget, JsiiJavaTarget, JsiiPythonTarget } from "./jsii-project";
+import type { Step } from "../github/workflows-model";
+import type { NpmPublishOptions } from "../release";
+import { TypeScriptProject } from "../typescript";
+/**
+ * Options for `JsiiBuild`.
+ */
+export interface JsiiBuildOptions {
+    /**
+     * Publish to maven
+     * @default - no publishing
+     */
+    readonly publishToMaven?: JsiiJavaTarget;
+    /**
+     * Publish to pypi
+     * @default - no publishing
+     */
+    readonly publishToPypi?: JsiiPythonTarget;
+    /**
+     * Publish Go bindings to a git repository.
+     * @default - no publishing
+     */
+    readonly publishToGo?: JsiiGoTarget;
+    /**
+     * Publish to NuGet
+     * @default - no publishing
+     */
+    readonly publishToNuget?: JsiiDotNetTarget;
+    /**
+     * Automatically run API compatibility test against the latest version published to npm after compilation.
+     *
+     * - You can manually run compatibility tests using `yarn compat` if this feature is disabled.
+     * - You can ignore compatibility failures by adding lines to a ".compatignore" file.
+     *
+     * @default false
+     */
+    readonly compat?: boolean;
+    /**
+     * Name of the ignore file for API compatibility tests.
+     *
+     * @default ".compatignore"
+     */
+    readonly compatIgnore?: string;
+    /**
+     * Accepts a list of glob patterns. Files matching any of those patterns will be excluded from the TypeScript compiler input.
+     *
+     * By default, jsii will include all *.ts files (except .d.ts files) in the TypeScript compiler input.
+     * This can be problematic for example when the package's build or test procedure generates .ts files
+     * that cannot be compiled with jsii's compiler settings.
+     */
+    readonly excludeTypescript?: string[];
+    /**
+     * File path for generated docs.
+     * @default "API.md"
+     */
+    readonly docgenFilePath?: string;
+    /**
+     * Emit a compressed version of the assembly
+     * @default false
+     */
+    readonly compressAssembly?: boolean;
+    /**
+     * Version of the jsii compiler to use.
+     *
+     * Set to "*" if you want to manually manage the version of jsii in your
+     * project by managing updates to `package.json` on your own.
+     *
+     * NOTE: The jsii compiler releases since 5.0.0 are not semantically versioned
+     * and should remain on the same minor, so we recommend using a `~` dependency
+     * (e.g. `~5.0.0`).
+     *
+     * @default "~5.9.0"
+     * @pjnew "~5.9.0"
+     */
+    readonly jsiiVersion?: string;
+    /**
+     * The stability of the package.
+     *
+     * @default "stable"
+     */
+    readonly stability?: string;
+    /**
+     * Generate a MarkDown file describing the jsii API.
+     *
+     * @default true
+     */
+    readonly docgen?: boolean;
+    /**
+     * Whether to publish to npm.
+     *
+     * @default true
+     */
+    readonly releaseToNpm?: boolean;
+    /**
+     * Whether to use trusted publishing for npm.
+     *
+     * @default false
+     */
+    readonly npmTrustedPublishing?: boolean;
+    /**
+     * Options for publishing npm package to AWS CodeArtifact.
+     *
+     * @default - undefined
+     */
+    readonly codeArtifactOptions?: NpmPublishOptions["codeArtifactOptions"];
+    /**
+     * Relative path of the package within the repository.
+     *
+     * This is used in monorepo setups where the package is not at the root.
+     * Packaging steps will extract build artifacts into this subdirectory.
+     *
+     * @default "." - root of the repository
+     */
+    readonly workspaceDirectory?: string;
+    /**
+     * The node version to use in packaging workflows.
+     *
+     * @default "lts/*"
+     */
+    readonly workflowNodeVersion?: string;
+    /**
+     * Additional steps to run before packaging in workflows.
+     *
+     * @default []
+     */
+    readonly workflowBootstrapSteps?: Array<Step>;
+}
+/**
+ * A mixin that adds jsii compilation, multi-language packaging, and publishing
+ * capabilities to any TypeScript project.
+ *
+ * This implements the constructs `IMixin` interface and is applied using the
+ * `.with()` method on any construct.
+ *
+ * @example
+ * const project = new TypeScriptProject({ disableTsconfig: true, ... });
+ * project.with(new JsiiBuild({
+ *   jsiiVersion: '~5.9.0',
+ *   publishToMaven: { ... },
+ * }));
+ */
+export declare class JsiiBuild implements IMixin {
+    private readonly options;
+    private readonly extraJobOptions;
+    constructor(options?: JsiiBuildOptions, extraJobOptions?: Record<string, unknown>);
+    /**
+     * Returns true if the construct is a TypeScriptProject.
+     */
+    supports(construct: IConstruct): construct is TypeScriptProject;
+    /**
+     * Applies jsii configuration to the target TypeScriptProject.
+     */
+    applyTo(project: IConstruct): void;
+    /**
+     * Adds a target language to the release workflow.
+     */
+    private addTargetToRelease;
+    /**
+     * Adds a target language to the build workflow.
+     */
+    private addTargetToBuild;
+    private addPackagingTask;
+    private pacmakForLanguage;
+}

package/lib/cdk/jsii-build.js

@@ -0,0 +1,319 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsiiBuild = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const consts_1 = require("./consts");
+const jsii_docgen_1 = require("./jsii-docgen");
+const consts_2 = require("../build/private/consts");
+const workflow_steps_1 = require("../github/workflow-steps");
+const workflows_model_1 = require("../github/workflows-model");
+const javascript_1 = require("../javascript");
+const util_1 = require("../javascript/util");
+const runner_options_1 = require("../runner-options");
+const typescript_1 = require("../typescript");
+const REPO_TEMP_DIRECTORY = ".repo";
+const BUILD_ARTIFACT_OLD_DIR = "dist.old";
+/**
+ * A mixin that adds jsii compilation, multi-language packaging, and publishing
+ * capabilities to any TypeScript project.
+ *
+ * This implements the constructs `IMixin` interface and is applied using the
+ * `.with()` method on any construct.
+ *
+ * @example
+ * const project = new TypeScriptProject({ disableTsconfig: true, ... });
+ * project.with(new JsiiBuild({
+ *   jsiiVersion: '~5.9.0',
+ *   publishToMaven: { ... },
+ * }));
+ */
+class JsiiBuild {
+    constructor(options = {}, extraJobOptions) {
+        this.options = options;
+        this.extraJobOptions = (extraJobOptions ?? {});
+    }
+    /**
+     * Returns true if the construct is a TypeScriptProject.
+     */
+    supports(construct) {
+        return construct instanceof typescript_1.TypeScriptProject;
+    }
+    /**
+     * Applies jsii configuration to the target TypeScriptProject.
+     */
+    applyTo(project) {
+        if (!this.supports(project)) {
+            return;
+        }
+        const options = { ...this.options };
+        const srcdir = project.srcdir;
+        const libdir = project.libdir;
+        project.addFields({ types: `${libdir}/index.d.ts` });
+        const compressAssembly = options.compressAssembly ?? false;
+        // this is an unhelpful warning
+        const jsiiFlags = ["--silence-warnings=reserved-word"];
+        if (compressAssembly) {
+            jsiiFlags.push("--compress-assembly");
+        }
+        const compatIgnore = options.compatIgnore ?? ".compatignore";
+        project.addFields({ stability: options.stability ?? "stable" });
+        if (options.stability === "deprecated") {
+            project.addFields({ deprecated: true });
+        }
+        project.compileTask.reset(["jsii", ...jsiiFlags].join(" "));
+        project.watchTask.reset(["jsii", "-w", ...jsiiFlags].join(" "));
+        const compatTask = project.addTask("compat", {
+            description: "Perform API compatibility check against latest version",
+            exec: `jsii-diff npm:$(node -p "require(\'./package.json\').name") -k --ignore-file ${compatIgnore} || (echo "\nUNEXPECTED BREAKING CHANGES: add keys such as \'removed:constructs.Node.of\' to ${compatIgnore} to skip.\n" && exit 1)`,
+        });
+        if (options.compat ?? false) {
+            project.compileTask.spawn(compatTask);
+        }
+        // Create a new package:all task, it will be filled with language targets later
+        const packageAllTask = project.addTask("package-all", {
+            description: "Packages artifacts for all target languages",
+        });
+        // in jsii we consider the entire repo (post build) as the build artifact
+        // which is then used to create the language bindings in separate jobs.
+        const packageJsTask = this.addPackagingTask(project, packageAllTask, "js");
+        // When running inside CI we initially only package js. Other targets are packaged in separate jobs.
+        // Outside of CI (i.e locally) we simply package all targets.
+        project.packageTask.reset();
+        project.packageTask.spawn(packageJsTask, {
+            // Only run in CI
+            condition: `node -e "if (!process.env.CI) process.exit(1)"`,
+        });
+        project.packageTask.spawn(packageAllTask, {
+            // Don't run in CI
+            condition: `node -e "if (process.env.CI) process.exit(1)"`,
+        });
+        const targets = {};
+        const jsii = {
+            outdir: project.artifactsDirectory,
+            targets,
+            tsc: {
+                outDir: libdir,
+                rootDir: srcdir,
+            },
+        };
+        if (options.excludeTypescript) {
+            jsii.excludeTypescript = options.excludeTypescript;
+        }
+        project.addFields({ jsii });
+        const extraJobOptions = this.extraJobOptions;
+        if (options.releaseToNpm !== false) {
+            const npmjs = {
+                registry: project.package.npmRegistry,
+                npmTokenSecret: project.package.npmTokenSecret,
+                npmProvenance: project.package.npmProvenance,
+                codeArtifactOptions: options.codeArtifactOptions,
+                trustedPublishing: options.npmTrustedPublishing ?? false,
+            };
+            this.addTargetToBuild(project, packageJsTask, "js", extraJobOptions);
+            this.addTargetToRelease(project, packageJsTask, "js", npmjs);
+        }
+        const maven = options.publishToMaven;
+        if (maven) {
+            targets.java = {
+                package: maven.javaPackage,
+                maven: {
+                    groupId: maven.mavenGroupId,
+                    artifactId: maven.mavenArtifactId,
+                },
+            };
+            const task = this.addPackagingTask(project, packageAllTask, "java");
+            this.addTargetToBuild(project, task, "java", extraJobOptions);
+            this.addTargetToRelease(project, task, "java", maven);
+        }
+        const pypi = options.publishToPypi;
+        if (pypi) {
+            targets.python = {
+                distName: pypi.distName,
+                module: pypi.module,
+            };
+            const task = this.addPackagingTask(project, packageAllTask, "python");
+            this.addTargetToBuild(project, task, "python", extraJobOptions);
+            this.addTargetToRelease(project, task, "python", pypi);
+        }
+        const nuget = options.publishToNuget;
+        if (nuget) {
+            targets.dotnet = {
+                namespace: nuget.dotNetNamespace,
+                packageId: nuget.packageId,
+                iconUrl: nuget.iconUrl,
+            };
+            const task = this.addPackagingTask(project, packageAllTask, "dotnet");
+            this.addTargetToBuild(project, task, "dotnet", extraJobOptions);
+            this.addTargetToRelease(project, task, "dotnet", nuget);
+        }
+        const golang = options.publishToGo;
+        if (golang) {
+            targets.go = {
+                moduleName: golang.moduleName,
+                packageName: golang.packageName,
+                versionSuffix: golang.versionSuffix,
+            };
+            const task = this.addPackagingTask(project, packageAllTask, "go");
+            this.addTargetToBuild(project, task, "go", extraJobOptions);
+            this.addTargetToRelease(project, task, "go", golang);
+        }
+        // If jsiiVersion is "*", don't specify anything so the user can manage.
+        // Otherwise, use `jsiiVersion`
+        const jsiiVersion = options.jsiiVersion ?? "~5.9.0";
+        const jsiiSuffix = jsiiVersion === "*" ? "" : `@${jsiiVersion}`;
+        project.addDevDeps(`jsii${jsiiSuffix}`, `jsii-rosetta${jsiiSuffix}`, "jsii-diff", "jsii-pacmak");
+        project.gitignore.exclude(".jsii", "tsconfig.json");
+        project.npmignore?.include(".jsii");
+        if (options.docgen ?? true) {
+            // If jsiiVersion is "*", don't specify anything so the user can manage.
+            // Otherwise use a version that is compatible with all supported jsii releases.
+            const docgenVersion = options.jsiiVersion === "*" ? "*" : "^10.5.0";
+            new jsii_docgen_1.JsiiDocgen(project, {
+                version: docgenVersion,
+                filePath: options.docgenFilePath,
+            });
+        }
+        // jsii updates .npmignore, so we make it writable
+        if (project.npmignore) {
+            project.npmignore.readonly = false;
+        }
+    }
+    /**
+     * Adds a target language to the release workflow.
+     */
+    addTargetToRelease(project, packTask, language, target) {
+        if (!project.release) {
+            return;
+        }
+        const pacmak = this.pacmakForLanguage(project, language, packTask);
+        const prePublishSteps = [
+            ...pacmak.bootstrapSteps,
+            workflow_steps_1.WorkflowSteps.checkout({
+                with: {
+                    path: REPO_TEMP_DIRECTORY,
+                    ...(project.github?.downloadLfs ? { lfs: true } : {}),
+                },
+            }),
+            ...pacmak.packagingSteps,
+        ];
+        const commonPublishOptions = {
+            publishTools: pacmak.publishTools,
+            prePublishSteps,
+        };
+        const handler = publishTo[language];
+        project.release?.publisher[handler]({
+            ...commonPublishOptions,
+            ...target,
+        });
+    }
+    /**
+     * Adds a target language to the build workflow.
+     */
+    addTargetToBuild(project, packTask, language, extraJobOptions) {
+        if (!project.buildWorkflow) {
+            return;
+        }
+        const pacmak = this.pacmakForLanguage(project, language, packTask);
+        project.buildWorkflow.addPostBuildJob(`package-${language}`, {
+            ...(0, runner_options_1.filteredRunsOnOptions)(extraJobOptions.runsOn, extraJobOptions.runsOnGroup),
+            permissions: {
+                contents: workflows_model_1.JobPermission.READ,
+            },
+            tools: {
+                node: {
+                    version: this.options.workflowNodeVersion ?? "lts/*",
+                },
+                ...pacmak.publishTools,
+            },
+            steps: [
+                ...pacmak.bootstrapSteps,
+                workflow_steps_1.WorkflowSteps.checkout({
+                    with: {
+                        path: REPO_TEMP_DIRECTORY,
+                        ref: consts_2.PULL_REQUEST_REF,
+                        repository: consts_2.PULL_REQUEST_REPOSITORY,
+                        ...(project.github?.downloadLfs ? { lfs: true } : {}),
+                    },
+                }),
+                ...pacmak.packagingSteps,
+            ],
+            ...extraJobOptions,
+        });
+    }
+    addPackagingTask(project, packageAllTask, language) {
+        const packageTargetTask = project.tasks.addTask(`package:${language}`, {
+            description: `Create ${language} language bindings`,
+        });
+        const commandParts = ["jsii-pacmak", "-v"];
+        if (project.package.packageManager === javascript_1.NodePackageManager.PNPM) {
+            commandParts.push('--pack-command "pnpm pack"');
+        }
+        commandParts.push(`--target ${language}`);
+        packageTargetTask.exec(commandParts.join(" "));
+        packageAllTask.spawn(packageTargetTask);
+        return packageTargetTask;
+    }
+    pacmakForLanguage(project, target, packTask) {
+        const bootstrapSteps = [];
+        const packagingSteps = [];
+        // Generic bootstrapping for all target languages
+        bootstrapSteps.push(...(this.options.workflowBootstrapSteps ?? []));
+        if (project.package.packageManager === javascript_1.NodePackageManager.PNPM) {
+            bootstrapSteps.push({
+                name: "Setup pnpm",
+                uses: "pnpm/action-setup@v5",
+                with: { version: project.package.pnpmVersion },
+            });
+        }
+        else if (project.package.packageManager === javascript_1.NodePackageManager.BUN) {
+            bootstrapSteps.push({
+                name: "Setup bun",
+                uses: "oven-sh/setup-bun@v2",
+                with: { "bun-version": project.package.bunVersion },
+            });
+        }
+        else if ((0, util_1.isYarnBerry)(project.package.packageManager)) {
+            bootstrapSteps.push({
+                name: "Enable corepack",
+                run: "corepack enable",
+            });
+        }
+        const workDir = this.options.workspaceDirectory
+            ? `${REPO_TEMP_DIRECTORY}/${this.options.workspaceDirectory}`
+            : REPO_TEMP_DIRECTORY;
+        // Installation steps before packaging, but after checkout
+        packagingSteps.push({
+            name: "Install Dependencies",
+            run: `cd ${REPO_TEMP_DIRECTORY} && ${project.package.installCommand}`,
+        }, {
+            name: "Extract build artifact",
+            run: `tar --strip-components=1 -xzvf ${project.artifactsDirectory}/js/*.tgz -C ${workDir}`,
+        }, {
+            name: `Move build artifact out of the way`,
+            run: `mv ${project.artifactsDirectory} ${BUILD_ARTIFACT_OLD_DIR}`,
+        }, {
+            name: `Create ${target} artifact`,
+            run: `cd ${workDir} && ${project.runTaskCommand(packTask)}`,
+        }, {
+            name: `Collect ${target} artifact`,
+            run: `mv ${workDir}/${project.artifactsDirectory} ${project.artifactsDirectory}`,
+        });
+        return {
+            publishTools: consts_1.JSII_TOOLCHAIN[target],
+            bootstrapSteps,
+            packagingSteps,
+        };
+    }
+}
+exports.JsiiBuild = JsiiBuild;
+_a = JSII_RTTI_SYMBOL_1;
+JsiiBuild[_a] = { fqn: "projen.cdk.JsiiBuild", version: "0.99.68" };
+const publishTo = {
+    js: "publishToNpm",
+    java: "publishToMaven",
+    python: "publishToPyPi",
+    dotnet: "publishToNuget",
+    go: "publishToGo",
+};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsii-build.js","sourceRoot":"","sources":["../../src/cdk/jsii-build.ts"],"names":[],"mappings":"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","sourcesContent":["import type { IConstruct, IMixin } from \"constructs\";\nimport type { Task } from \"..\";\nimport type { JsiiPacmakTarget } from \"./consts\";\nimport { JSII_TOOLCHAIN } from \"./consts\";\nimport { JsiiDocgen } from \"./jsii-docgen\";\nimport type {\n  JsiiDotNetTarget,\n  JsiiGoTarget,\n  JsiiJavaTarget,\n  JsiiPythonTarget,\n} from \"./jsii-project\";\nimport {\n  PULL_REQUEST_REF,\n  PULL_REQUEST_REPOSITORY,\n} from \"../build/private/consts\";\nimport { WorkflowSteps } from \"../github/workflow-steps\";\nimport type { Job, Step, Tools } from \"../github/workflows-model\";\nimport { JobPermission } from \"../github/workflows-model\";\nimport { NodePackageManager } from \"../javascript\";\nimport { isYarnBerry } from \"../javascript/util\";\nimport type {\n  CommonPublishOptions,\n  NpmPublishOptions,\n  Publisher,\n} from \"../release\";\nimport { filteredRunsOnOptions } from \"../runner-options\";\nimport { TypeScriptProject } from \"../typescript\";\n\nconst REPO_TEMP_DIRECTORY = \".repo\";\nconst BUILD_ARTIFACT_OLD_DIR = \"dist.old\";\n\n/**\n * Options for `JsiiBuild`.\n */\nexport interface JsiiBuildOptions {\n  /**\n   * Publish to maven\n   * @default - no publishing\n   */\n  readonly publishToMaven?: JsiiJavaTarget;\n\n  /**\n   * Publish to pypi\n   * @default - no publishing\n   */\n  readonly publishToPypi?: JsiiPythonTarget;\n\n  /**\n   * Publish Go bindings to a git repository.\n   * @default - no publishing\n   */\n  readonly publishToGo?: JsiiGoTarget;\n\n  /**\n   * Publish to NuGet\n   * @default - no publishing\n   */\n  readonly publishToNuget?: JsiiDotNetTarget;\n\n  /**\n   * Automatically run API compatibility test against the latest version published to npm after compilation.\n   *\n   * - You can manually run compatibility tests using `yarn compat` if this feature is disabled.\n   * - You can ignore compatibility failures by adding lines to a \".compatignore\" file.\n   *\n   * @default false\n   */\n  readonly compat?: boolean;\n\n  /**\n   * Name of the ignore file for API compatibility tests.\n   *\n   * @default \".compatignore\"\n   */\n  readonly compatIgnore?: string;\n\n  /**\n   * Accepts a list of glob patterns. Files matching any of those patterns will be excluded from the TypeScript compiler input.\n   *\n   * By default, jsii will include all *.ts files (except .d.ts files) in the TypeScript compiler input.\n   * This can be problematic for example when the package's build or test procedure generates .ts files\n   * that cannot be compiled with jsii's compiler settings.\n   */\n  readonly excludeTypescript?: string[];\n\n  /**\n   * File path for generated docs.\n   * @default \"API.md\"\n   */\n  readonly docgenFilePath?: string;\n\n  /**\n   * Emit a compressed version of the assembly\n   * @default false\n   */\n  readonly compressAssembly?: boolean;\n\n  /**\n   * Version of the jsii compiler to use.\n   *\n   * Set to \"*\" if you want to manually manage the version of jsii in your\n   * project by managing updates to `package.json` on your own.\n   *\n   * NOTE: The jsii compiler releases since 5.0.0 are not semantically versioned\n   * and should remain on the same minor, so we recommend using a `~` dependency\n   * (e.g. `~5.0.0`).\n   *\n   * @default \"~5.9.0\"\n   * @pjnew \"~5.9.0\"\n   */\n  readonly jsiiVersion?: string;\n\n  /**\n   * The stability of the package.\n   *\n   * @default \"stable\"\n   */\n  readonly stability?: string;\n\n  /**\n   * Generate a MarkDown file describing the jsii API.\n   *\n   * @default true\n   */\n  readonly docgen?: boolean;\n\n  /**\n   * Whether to publish to npm.\n   *\n   * @default true\n   */\n  readonly releaseToNpm?: boolean;\n\n  /**\n   * Whether to use trusted publishing for npm.\n   *\n   * @default false\n   */\n  readonly npmTrustedPublishing?: boolean;\n\n  /**\n   * Options for publishing npm package to AWS CodeArtifact.\n   *\n   * @default - undefined\n   */\n  readonly codeArtifactOptions?: NpmPublishOptions[\"codeArtifactOptions\"];\n\n  /**\n   * Relative path of the package within the repository.\n   *\n   * This is used in monorepo setups where the package is not at the root.\n   * Packaging steps will extract build artifacts into this subdirectory.\n   *\n   * @default \".\" - root of the repository\n   */\n  readonly workspaceDirectory?: string;\n\n  /**\n   * The node version to use in packaging workflows.\n   *\n   * @default \"lts/*\"\n   */\n  readonly workflowNodeVersion?: string;\n\n  /**\n   * Additional steps to run before packaging in workflows.\n   *\n   * @default []\n   */\n  readonly workflowBootstrapSteps?: Array<Step>;\n}\n\n/**\n * A mixin that adds jsii compilation, multi-language packaging, and publishing\n * capabilities to any TypeScript project.\n *\n * This implements the constructs `IMixin` interface and is applied using the\n * `.with()` method on any construct.\n *\n * @example\n * const project = new TypeScriptProject({ disableTsconfig: true, ... });\n * project.with(new JsiiBuild({\n *   jsiiVersion: '~5.9.0',\n *   publishToMaven: { ... },\n * }));\n */\nexport class JsiiBuild implements IMixin {\n  private readonly options: JsiiBuildOptions;\n  private readonly extraJobOptions: Partial<Job>;\n\n  constructor(\n    options: JsiiBuildOptions = {},\n    extraJobOptions?: Record<string, unknown>,\n  ) {\n    this.options = options;\n    this.extraJobOptions = (extraJobOptions ?? {}) as Partial<Job>;\n  }\n\n  /**\n   * Returns true if the construct is a TypeScriptProject.\n   */\n  public supports(construct: IConstruct): construct is TypeScriptProject {\n    return construct instanceof TypeScriptProject;\n  }\n\n  /**\n   * Applies jsii configuration to the target TypeScriptProject.\n   */\n  public applyTo(project: IConstruct): void {\n    if (!this.supports(project)) {\n      return;\n    }\n\n    const options = { ...this.options };\n    const srcdir = project.srcdir;\n    const libdir = project.libdir;\n\n    project.addFields({ types: `${libdir}/index.d.ts` });\n\n    const compressAssembly = options.compressAssembly ?? false;\n\n    // this is an unhelpful warning\n    const jsiiFlags = [\"--silence-warnings=reserved-word\"];\n    if (compressAssembly) {\n      jsiiFlags.push(\"--compress-assembly\");\n    }\n\n    const compatIgnore = options.compatIgnore ?? \".compatignore\";\n\n    project.addFields({ stability: options.stability ?? \"stable\" });\n\n    if (options.stability === \"deprecated\") {\n      project.addFields({ deprecated: true });\n    }\n\n    project.compileTask.reset([\"jsii\", ...jsiiFlags].join(\" \"));\n    project.watchTask.reset([\"jsii\", \"-w\", ...jsiiFlags].join(\" \"));\n\n    const compatTask = project.addTask(\"compat\", {\n      description: \"Perform API compatibility check against latest version\",\n      exec: `jsii-diff npm:$(node -p \"require(\\'./package.json\\').name\") -k --ignore-file ${compatIgnore} || (echo \"\\nUNEXPECTED BREAKING CHANGES: add keys such as \\'removed:constructs.Node.of\\' to ${compatIgnore} to skip.\\n\" && exit 1)`,\n    });\n\n    if (options.compat ?? false) {\n      project.compileTask.spawn(compatTask);\n    }\n\n    // Create a new package:all task, it will be filled with language targets later\n    const packageAllTask = project.addTask(\"package-all\", {\n      description: \"Packages artifacts for all target languages\",\n    });\n\n    // in jsii we consider the entire repo (post build) as the build artifact\n    // which is then used to create the language bindings in separate jobs.\n    const packageJsTask = this.addPackagingTask(project, packageAllTask, \"js\");\n\n    // When running inside CI we initially only package js. Other targets are packaged in separate jobs.\n    // Outside of CI (i.e locally) we simply package all targets.\n    project.packageTask.reset();\n    project.packageTask.spawn(packageJsTask, {\n      // Only run in CI\n      condition: `node -e \"if (!process.env.CI) process.exit(1)\"`,\n    });\n    project.packageTask.spawn(packageAllTask, {\n      // Don't run in CI\n      condition: `node -e \"if (process.env.CI) process.exit(1)\"`,\n    });\n\n    const targets: Record<string, any> = {};\n\n    const jsii: any = {\n      outdir: project.artifactsDirectory,\n      targets,\n      tsc: {\n        outDir: libdir,\n        rootDir: srcdir,\n      },\n    };\n\n    if (options.excludeTypescript) {\n      jsii.excludeTypescript = options.excludeTypescript;\n    }\n\n    project.addFields({ jsii });\n\n    const extraJobOptions: Partial<Job> = this.extraJobOptions;\n\n    if (options.releaseToNpm !== false) {\n      const npmjs: NpmPublishOptions = {\n        registry: project.package.npmRegistry,\n        npmTokenSecret: project.package.npmTokenSecret,\n        npmProvenance: project.package.npmProvenance,\n        codeArtifactOptions: options.codeArtifactOptions,\n        trustedPublishing: options.npmTrustedPublishing ?? false,\n      };\n      this.addTargetToBuild(project, packageJsTask, \"js\", extraJobOptions);\n      this.addTargetToRelease(project, packageJsTask, \"js\", npmjs);\n    }\n\n    const maven = options.publishToMaven;\n    if (maven) {\n      targets.java = {\n        package: maven.javaPackage,\n        maven: {\n          groupId: maven.mavenGroupId,\n          artifactId: maven.mavenArtifactId,\n        },\n      };\n\n      const task = this.addPackagingTask(project, packageAllTask, \"java\");\n      this.addTargetToBuild(project, task, \"java\", extraJobOptions);\n      this.addTargetToRelease(project, task, \"java\", maven);\n    }\n\n    const pypi = options.publishToPypi;\n    if (pypi) {\n      targets.python = {\n        distName: pypi.distName,\n        module: pypi.module,\n      };\n\n      const task = this.addPackagingTask(project, packageAllTask, \"python\");\n      this.addTargetToBuild(project, task, \"python\", extraJobOptions);\n      this.addTargetToRelease(project, task, \"python\", pypi);\n    }\n\n    const nuget = options.publishToNuget;\n    if (nuget) {\n      targets.dotnet = {\n        namespace: nuget.dotNetNamespace,\n        packageId: nuget.packageId,\n        iconUrl: nuget.iconUrl,\n      };\n\n      const task = this.addPackagingTask(project, packageAllTask, \"dotnet\");\n      this.addTargetToBuild(project, task, \"dotnet\", extraJobOptions);\n      this.addTargetToRelease(project, task, \"dotnet\", nuget);\n    }\n\n    const golang = options.publishToGo;\n    if (golang) {\n      targets.go = {\n        moduleName: golang.moduleName,\n        packageName: golang.packageName,\n        versionSuffix: golang.versionSuffix,\n      };\n\n      const task = this.addPackagingTask(project, packageAllTask, \"go\");\n      this.addTargetToBuild(project, task, \"go\", extraJobOptions);\n      this.addTargetToRelease(project, task, \"go\", golang);\n    }\n\n    // If jsiiVersion is \"*\", don't specify anything so the user can manage.\n    // Otherwise, use `jsiiVersion`\n    const jsiiVersion = options.jsiiVersion ?? \"~5.9.0\";\n    const jsiiSuffix = jsiiVersion === \"*\" ? \"\" : `@${jsiiVersion}`;\n    project.addDevDeps(\n      `jsii${jsiiSuffix}`,\n      `jsii-rosetta${jsiiSuffix}`,\n      \"jsii-diff\",\n      \"jsii-pacmak\",\n    );\n\n    project.gitignore.exclude(\".jsii\", \"tsconfig.json\");\n    project.npmignore?.include(\".jsii\");\n\n    if (options.docgen ?? true) {\n      // If jsiiVersion is \"*\", don't specify anything so the user can manage.\n      // Otherwise use a version that is compatible with all supported jsii releases.\n      const docgenVersion = options.jsiiVersion === \"*\" ? \"*\" : \"^10.5.0\";\n      new JsiiDocgen(project, {\n        version: docgenVersion,\n        filePath: options.docgenFilePath,\n      });\n    }\n\n    // jsii updates .npmignore, so we make it writable\n    if (project.npmignore) {\n      project.npmignore.readonly = false;\n    }\n  }\n\n  /**\n   * Adds a target language to the release workflow.\n   */\n  private addTargetToRelease(\n    project: TypeScriptProject,\n    packTask: Task,\n    language: JsiiPacmakTarget,\n    target:\n      | JsiiPythonTarget\n      | JsiiDotNetTarget\n      | JsiiGoTarget\n      | JsiiJavaTarget\n      | NpmPublishOptions,\n  ) {\n    if (!project.release) {\n      return;\n    }\n\n    const pacmak = this.pacmakForLanguage(project, language, packTask);\n    const prePublishSteps = [\n      ...pacmak.bootstrapSteps,\n      WorkflowSteps.checkout({\n        with: {\n          path: REPO_TEMP_DIRECTORY,\n          ...(project.github?.downloadLfs ? { lfs: true } : {}),\n        },\n      }),\n      ...pacmak.packagingSteps,\n    ];\n    const commonPublishOptions: CommonPublishOptions = {\n      publishTools: pacmak.publishTools,\n      prePublishSteps,\n    };\n\n    const handler: PublishTo = publishTo[language];\n    project.release?.publisher[handler]({\n      ...commonPublishOptions,\n      ...target,\n    });\n  }\n\n  /**\n   * Adds a target language to the build workflow.\n   */\n  private addTargetToBuild(\n    project: TypeScriptProject,\n    packTask: Task,\n    language: JsiiPacmakTarget,\n    extraJobOptions: Partial<Job>,\n  ) {\n    if (!project.buildWorkflow) {\n      return;\n    }\n    const pacmak = this.pacmakForLanguage(project, language, packTask);\n\n    project.buildWorkflow.addPostBuildJob(`package-${language}`, {\n      ...filteredRunsOnOptions(\n        extraJobOptions.runsOn,\n        extraJobOptions.runsOnGroup,\n      ),\n      permissions: {\n        contents: JobPermission.READ,\n      },\n      tools: {\n        node: {\n          version: this.options.workflowNodeVersion ?? \"lts/*\",\n        },\n        ...pacmak.publishTools,\n      },\n      steps: [\n        ...pacmak.bootstrapSteps,\n        WorkflowSteps.checkout({\n          with: {\n            path: REPO_TEMP_DIRECTORY,\n            ref: PULL_REQUEST_REF,\n            repository: PULL_REQUEST_REPOSITORY,\n            ...(project.github?.downloadLfs ? { lfs: true } : {}),\n          },\n        }),\n        ...pacmak.packagingSteps,\n      ],\n      ...extraJobOptions,\n    });\n  }\n\n  private addPackagingTask(\n    project: TypeScriptProject,\n    packageAllTask: Task,\n    language: JsiiPacmakTarget,\n  ): Task {\n    const packageTargetTask = project.tasks.addTask(`package:${language}`, {\n      description: `Create ${language} language bindings`,\n    });\n    const commandParts = [\"jsii-pacmak\", \"-v\"];\n\n    if (project.package.packageManager === NodePackageManager.PNPM) {\n      commandParts.push('--pack-command \"pnpm pack\"');\n    }\n\n    commandParts.push(`--target ${language}`);\n\n    packageTargetTask.exec(commandParts.join(\" \"));\n\n    packageAllTask.spawn(packageTargetTask);\n    return packageTargetTask;\n  }\n\n  private pacmakForLanguage(\n    project: TypeScriptProject,\n    target: JsiiPacmakTarget,\n    packTask: Task,\n  ): {\n    publishTools: Tools;\n    bootstrapSteps: Array<Step>;\n    packagingSteps: Array<Step>;\n  } {\n    const bootstrapSteps: Array<Step> = [];\n    const packagingSteps: Array<Step> = [];\n\n    // Generic bootstrapping for all target languages\n    bootstrapSteps.push(...(this.options.workflowBootstrapSteps ?? []));\n    if (project.package.packageManager === NodePackageManager.PNPM) {\n      bootstrapSteps.push({\n        name: \"Setup pnpm\",\n        uses: \"pnpm/action-setup@v5\",\n        with: { version: project.package.pnpmVersion },\n      });\n    } else if (project.package.packageManager === NodePackageManager.BUN) {\n      bootstrapSteps.push({\n        name: \"Setup bun\",\n        uses: \"oven-sh/setup-bun@v2\",\n        with: { \"bun-version\": project.package.bunVersion },\n      });\n    } else if (isYarnBerry(project.package.packageManager)) {\n      bootstrapSteps.push({\n        name: \"Enable corepack\",\n        run: \"corepack enable\",\n      });\n    }\n\n    const workDir = this.options.workspaceDirectory\n      ? `${REPO_TEMP_DIRECTORY}/${this.options.workspaceDirectory}`\n      : REPO_TEMP_DIRECTORY;\n\n    // Installation steps before packaging, but after checkout\n    packagingSteps.push(\n      {\n        name: \"Install Dependencies\",\n        run: `cd ${REPO_TEMP_DIRECTORY} && ${project.package.installCommand}`,\n      },\n      {\n        name: \"Extract build artifact\",\n        run: `tar --strip-components=1 -xzvf ${project.artifactsDirectory}/js/*.tgz -C ${workDir}`,\n      },\n      {\n        name: `Move build artifact out of the way`,\n        run: `mv ${project.artifactsDirectory} ${BUILD_ARTIFACT_OLD_DIR}`,\n      },\n      {\n        name: `Create ${target} artifact`,\n        run: `cd ${workDir} && ${project.runTaskCommand(packTask)}`,\n      },\n      {\n        name: `Collect ${target} artifact`,\n        run: `mv ${workDir}/${project.artifactsDirectory} ${project.artifactsDirectory}`,\n      },\n    );\n\n    return {\n      publishTools: JSII_TOOLCHAIN[target],\n      bootstrapSteps,\n      packagingSteps,\n    };\n  }\n}\n\ntype PublishTo = keyof Publisher &\n  (\n    | \"publishToNpm\"\n    | \"publishToMaven\"\n    | \"publishToPyPi\"\n    | \"publishToNuget\"\n    | \"publishToGo\"\n  );\n\ntype PublishToTarget = { [K in JsiiPacmakTarget]: PublishTo };\nconst publishTo: PublishToTarget = {\n  js: \"publishToNpm\",\n  java: \"publishToMaven\",\n  python: \"publishToPyPi\",\n  dotnet: \"publishToNuget\",\n  go: \"publishToGo\",\n};\n"]}

package/lib/cdk/jsii-docgen.js

@@ -33,5 +33,5 @@ class JsiiDocgen extends component_1.Component {
 }
 exports.JsiiDocgen = JsiiDocgen;
 _a = JSII_RTTI_SYMBOL_1;
-JsiiDocgen[_a] = { fqn: "projen.cdk.JsiiDocgen", version: "0.99.66" };
+JsiiDocgen[_a] = { fqn: "projen.cdk.JsiiDocgen", version: "0.99.68" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/cdk/jsii-project.d.ts

@@ -151,23 +151,7 @@ export interface JsiiGoTarget extends GoPublishOptions {
  * @pjid jsii
  */
 export declare class JsiiProject extends TypeScriptProject {
-    private readonly packageAllTask;
-    private readonly packageJsTask;
     constructor(options: JsiiProjectOptions);
-    /**
-     * Adds a target language to the release workflow.
-     * @param language
-     * @returns
-     */
-    private addTargetToRelease;
-    /**
-     * Adds a target language to the build workflow
-     * @param language
-     * @returns
-     */
-    private addTargetToBuild;
-    private addPackagingTask;
-    private pacmakForLanguage;
     /**
      * Generates the runs-on config for Jobs.
      * Throws error if 'runsOn' and 'runsOnGroup' are both set.