projen 0.0.0

package/lib/cdk/jsii-project.js

@@ -0,0 +1,250 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.JsiiProject = exports.Stability = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const typescript_1 = require("../typescript");
+const consts_1 = require("./consts");
+const jsii_docgen_1 = require("./jsii-docgen");
+const EMAIL_REGEX = /(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|"(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21\x23-\x5b\x5d-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])*")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\x01-\x08\x0b\x0c\x0e-\x1f\x21-\x5a\x53-\x7f]|\\[\x01-\x09\x0b\x0c\x0e-\x7f])+)\])/;
+const URL_REGEX = /((([A-Za-z]{3,9}:(?:\/\/)?)(?:[\-;:&=\+\$,\w]+@)?[A-Za-z0-9\.\-]+|(?:www\.|[\-;:&=\+\$,\w]+@)[A-Za-z0-9\.\-]+)((?:\/[\+~%\/\.\w\-_]*)?\??(?:[\-\+=&;%@\.\w_]*)#?(?:[\.\!\/\\\w]*))?)/;
+/**
+ * @experimental
+ */
+var Stability;
+(function (Stability) {
+    Stability["EXPERIMENTAL"] = "experimental";
+    Stability["STABLE"] = "stable";
+    Stability["DEPRECATED"] = "deprecated";
+})(Stability = exports.Stability || (exports.Stability = {}));
+/**
+ * (experimental) Multi-language jsii library project.
+ *
+ * @experimental
+ * @pjid jsii
+ */
+class JsiiProject extends typescript_1.TypeScriptProject {
+    /**
+     * @experimental
+     */
+    constructor(options) {
+        var _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+        const { authorEmail, authorUrl } = parseAuthorAddress(options);
+        super({
+            repository: options.repositoryUrl,
+            authorName: options.author,
+            authorEmail,
+            authorUrl,
+            ...options,
+            releaseToNpm: false,
+            disableTsconfig: true,
+            docgen: false,
+        });
+        const srcdir = this.srcdir;
+        const libdir = this.libdir;
+        this.addFields({ types: `${libdir}/index.d.ts` });
+        // this is an unhelpful warning
+        const jsiiFlags = [
+            '--silence-warnings=reserved-word',
+            '--no-fix-peer-dependencies',
+        ].join(' ');
+        const compatIgnore = (_b = options.compatIgnore) !== null && _b !== void 0 ? _b : '.compatignore';
+        this.addFields({ stability: (_c = options.stability) !== null && _c !== void 0 ? _c : Stability.STABLE });
+        if (options.stability === Stability.DEPRECATED) {
+            this.addFields({ deprecated: true });
+        }
+        const compatTask = this.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)`,
+        });
+        const compat = (_d = options.compat) !== null && _d !== void 0 ? _d : false;
+        if (compat) {
+            this.compileTask.spawn(compatTask);
+        }
+        this.compileTask.reset(`jsii ${jsiiFlags}`);
+        this.watchTask.reset(`jsii -w ${jsiiFlags}`);
+        this.packageAllTask = this.addTask('package-all', {
+            description: 'Packages artifacts for all target languages',
+        });
+        this.packageTask.reset(`echo Skipping. Use 'npx projen ${this.packageAllTask.name}'`);
+        const targets = {};
+        const jsii = {
+            outdir: this.artifactsDirectory,
+            targets,
+            tsc: {
+                outDir: libdir,
+                rootDir: srcdir,
+            },
+        };
+        if (options.excludeTypescript) {
+            jsii.excludeTypescript = options.excludeTypescript;
+        }
+        this.addFields({ jsii });
+        if (options.releaseToNpm != false) {
+            const task = this.addPackagingTask('js');
+            (_e = this.release) === null || _e === void 0 ? void 0 : _e.publisher.publishToNpm({
+                ...this.pacmakForLanguage('js', task),
+                registry: this.package.npmRegistry,
+                npmTokenSecret: this.package.npmTokenSecret,
+            });
+            this.addPackagingTarget('js', task);
+        }
+        // we cannot call an option `java` because the java code generated by jsii
+        // does not compile due to a conflict between this option name and the `java`
+        // package (e.g. when `java.util.Objects` is referenced).
+        if ('java' in options) {
+            throw new Error('the "java" option is now called "publishToMaven"');
+        }
+        if (options.publishToMaven) {
+            targets.java = {
+                package: options.publishToMaven.javaPackage,
+                maven: {
+                    groupId: options.publishToMaven.mavenGroupId,
+                    artifactId: options.publishToMaven.mavenArtifactId,
+                },
+            };
+            const task = this.addPackagingTask('java');
+            (_f = this.release) === null || _f === void 0 ? void 0 : _f.publisher.publishToMaven({
+                ...this.pacmakForLanguage('java', task),
+                ...options.publishToMaven,
+            });
+            this.addPackagingTarget('java', task);
+        }
+        const pypi = (_g = options.publishToPypi) !== null && _g !== void 0 ? _g : options.python;
+        if (pypi) {
+            targets.python = {
+                distName: pypi.distName,
+                module: pypi.module,
+            };
+            const task = this.addPackagingTask('python');
+            (_h = this.release) === null || _h === void 0 ? void 0 : _h.publisher.publishToPyPi({
+                ...this.pacmakForLanguage('python', task),
+                ...pypi,
+            });
+            this.addPackagingTarget('python', task);
+        }
+        const nuget = (_j = options.publishToNuget) !== null && _j !== void 0 ? _j : options.dotnet;
+        if (nuget) {
+            targets.dotnet = {
+                namespace: nuget.dotNetNamespace,
+                packageId: nuget.packageId,
+            };
+            const task = this.addPackagingTask('dotnet');
+            (_k = this.release) === null || _k === void 0 ? void 0 : _k.publisher.publishToNuget({
+                ...this.pacmakForLanguage('dotnet', task),
+                ...nuget,
+            });
+            this.addPackagingTarget('dotnet', task);
+        }
+        const golang = options.publishToGo;
+        if (golang) {
+            targets.go = {
+                moduleName: golang.moduleName,
+            };
+            const task = this.addPackagingTask('go');
+            (_l = this.release) === null || _l === void 0 ? void 0 : _l.publisher.publishToGo({
+                ...this.pacmakForLanguage('go', task),
+                ...golang,
+            });
+            this.addPackagingTarget('go', task);
+        }
+        this.addDevDeps('jsii', 'jsii-diff');
+        this.gitignore.exclude('.jsii', 'tsconfig.json');
+        (_m = this.npmignore) === null || _m === void 0 ? void 0 : _m.include('.jsii');
+        if ((_o = options.docgen) !== null && _o !== void 0 ? _o : true) {
+            new jsii_docgen_1.JsiiDocgen(this);
+        }
+        // jsii updates .npmignore, so we make it writable
+        if (this.npmignore) {
+            this.npmignore.readonly = false;
+        }
+        // run `jsii-pacmak` at the end of the upgrade workflow because at the moment
+        // we don't have an ability to leverage the multiple build jobs in the upgrade workflow
+        // and we want to preserve the behavior of the old upgrade workflow.
+        if (this.upgradeWorkflow) {
+            this.upgradeWorkflow.containerOptions = { image: this.superchainImage };
+            this.upgradeWorkflow.addPostBuildSteps({
+                name: 'Verify language bindings',
+                run: this.runTaskCommand(this.packageAllTask),
+            });
+        }
+    }
+    /**
+     * Returns the jsii/superchain image that is compatible with the minimum node
+     * version of this project.
+     */
+    get superchainImage() {
+        return consts_1.determineSuperchainImage(this.minNodeVersion);
+    }
+    /**
+     * Adds a target language to the build workflow and creates a package task.
+     * @param language
+     * @returns
+     */
+    addPackagingTarget(language, packTask) {
+        var _b;
+        if (!this.buildWorkflow) {
+            return;
+        }
+        const pacmak = this.pacmakForLanguage(language, packTask);
+        this.buildWorkflow.addPostBuildJob(`package-${language}`, {
+            runsOn: ['ubuntu-latest'],
+            permissions: {},
+            tools: {
+                node: { version: '14.x' },
+                ...pacmak.publishTools,
+            },
+            steps: (_b = pacmak.prePublishSteps) !== null && _b !== void 0 ? _b : [],
+        });
+    }
+    addPackagingTask(language) {
+        const packageTask = this.tasks.addTask(`package:${language}`, {
+            description: `Create ${language} language bindings`,
+        });
+        packageTask.exec('jsii_version=$(node -p "JSON.parse(fs.readFileSync(\'.jsii\')).jsiiVersion.split(\' \')[0]")');
+        packageTask.exec(`npx jsii-pacmak@$jsii_version -v --target ${language}`);
+        this.packageAllTask.spawn(packageTask);
+        return packageTask;
+    }
+    pacmakForLanguage(target, packTask) {
+        return {
+            publishTools: consts_1.JSII_TOOLCHAIN[target],
+            prePublishSteps: [
+                {
+                    name: 'Install Dependencies',
+                    run: this.package.installCommand,
+                },
+                {
+                    name: `Create ${target} artifact`,
+                    run: `npx projen ${packTask.name}`,
+                },
+            ],
+        };
+    }
+}
+exports.JsiiProject = JsiiProject;
+_a = JSII_RTTI_SYMBOL_1;
+JsiiProject[_a] = { fqn: "projen.cdk.JsiiProject", version: "0.46.8" };
+function parseAuthorAddress(options) {
+    let authorEmail = options.authorEmail;
+    let authorUrl = options.authorUrl;
+    if (options.authorAddress) {
+        if (options.authorEmail && options.authorEmail !== options.authorAddress) {
+            throw new Error('authorEmail is deprecated and cannot be used in conjunction with authorAddress');
+        }
+        if (options.authorUrl && options.authorUrl !== options.authorAddress) {
+            throw new Error('authorUrl is deprecated and cannot be used in conjunction with authorAddress.');
+        }
+        if (EMAIL_REGEX.test(options.authorAddress)) {
+            authorEmail = options.authorAddress;
+        }
+        else if (URL_REGEX.test(options.authorAddress)) {
+            authorUrl = options.authorAddress;
+        }
+        else {
+            throw new Error(`authorAddress must be either an email address or a URL: ${options.authorAddress}`);
+        }
+    }
+    return { authorEmail, authorUrl };
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"jsii-project.js","sourceRoot":"","sources":["../../src/cdk/jsii-project.ts"],"names":[],"mappings":"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","sourcesContent":["import { Task } from '..';\nimport { Eslint } from '../javascript';\nimport { GoPublishOptions, MavenPublishOptions, PyPiPublishOptions, NugetPublishOptions, CommonPublishOptions } from '../release';\nimport { TypeScriptProject, TypeScriptProjectOptions } from '../typescript';\nimport { determineSuperchainImage, JsiiPacmakTarget, JSII_TOOLCHAIN } from './consts';\nimport { JsiiDocgen } from './jsii-docgen';\n\nconst EMAIL_REGEX = /(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)\\.){3}(?:25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])/;\nconst URL_REGEX = /((([A-Za-z]{3,9}:(?:\\/\\/)?)(?:[\\-;:&=\\+\\$,\\w]+@)?[A-Za-z0-9\\.\\-]+|(?:www\\.|[\\-;:&=\\+\\$,\\w]+@)[A-Za-z0-9\\.\\-]+)((?:\\/[\\+~%\\/\\.\\w\\-_]*)?\\??(?:[\\-\\+=&;%@\\.\\w_]*)#?(?:[\\.\\!\\/\\\\\\w]*))?)/;\n\nexport interface JsiiProjectOptions extends TypeScriptProjectOptions {\n                             \n  readonly rootdir?: string;\n\n                                                              \n  readonly repositoryUrl: string;\n\n                                                                             \n  readonly author: string;\n\n                                                                                  \n  readonly authorAddress: string;\n\n                                                               \n  readonly publishToMaven?: JsiiJavaTarget;\n\n                                                              \n  readonly publishToPypi?: JsiiPythonTarget;\n\n                                                                                       \n  readonly publishToGo?: JsiiGoTarget;\n\n                                                \n  readonly python?: JsiiPythonTarget;\n\n                                                               \n  readonly publishToNuget?: JsiiDotNetTarget;\n\n                                                 \n  readonly dotnet?: JsiiDotNetTarget;\n\n                                                                                                                                                                                                                                                                                                                                               \n  readonly compat?: boolean;\n\n                                                                                                        \n  readonly compatIgnore?: string;\n\n                                                                                                                                                                                                                                                                                                                                                                                                                             \n  readonly excludeTypescript?: string[];\n}\n\nexport enum Stability {\n  EXPERIMENTAL = 'experimental',\n  STABLE = 'stable',\n  DEPRECATED = 'deprecated'\n}\n\nexport interface JsiiJavaTarget extends MavenPublishOptions {\n  readonly javaPackage: string;\n  readonly mavenGroupId: string;\n  readonly mavenArtifactId: string;\n}\n\nexport interface JsiiPythonTarget extends PyPiPublishOptions {\n  readonly distName: string;\n  readonly module: string;\n}\n\nexport interface JsiiDotNetTarget extends NugetPublishOptions {\n  readonly dotNetNamespace: string;\n  readonly packageId: string;\n}\n\n                                  \nexport interface JsiiGoTarget extends GoPublishOptions {\n                                                                                                                                      \n  readonly moduleName: string;\n\n}\n\n                                                               \nexport class JsiiProject extends TypeScriptProject {\n  public readonly eslint?: Eslint;\n\n  private readonly packageAllTask: Task;\n\n  constructor(options: JsiiProjectOptions) {\n    const { authorEmail, authorUrl } = parseAuthorAddress(options);\n    super({\n      repository: options.repositoryUrl,\n      authorName: options.author,\n      authorEmail,\n      authorUrl,\n      ...options,\n      releaseToNpm: false, // we have a jsii release workflow\n      disableTsconfig: true, // jsii generates its own tsconfig.json\n      docgen: false, // we use jsii-docgen here so disable typescript docgen\n    });\n\n    const srcdir = this.srcdir;\n    const libdir = this.libdir;\n\n    this.addFields({ types: `${libdir}/index.d.ts` });\n\n    // this is an unhelpful warning\n    const jsiiFlags = [\n      '--silence-warnings=reserved-word',\n      '--no-fix-peer-dependencies',\n    ].join(' ');\n\n    const compatIgnore = options.compatIgnore ?? '.compatignore';\n\n    this.addFields({ stability: options.stability ?? Stability.STABLE });\n\n    if (options.stability === Stability.DEPRECATED) {\n      this.addFields({ deprecated: true });\n    }\n\n    const compatTask = this.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    const compat = options.compat ?? false;\n    if (compat) {\n      this.compileTask.spawn(compatTask);\n    }\n\n    this.compileTask.reset(`jsii ${jsiiFlags}`);\n    this.watchTask.reset(`jsii -w ${jsiiFlags}`);\n    this.packageAllTask = this.addTask('package-all', {\n      description: 'Packages artifacts for all target languages',\n    });\n\n    this.packageTask.reset(`echo Skipping. Use 'npx projen ${this.packageAllTask.name}'`);\n\n    const targets: Record<string, any> = {};\n\n    const jsii: any = {\n      outdir: this.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    this.addFields({ jsii });\n\n    if (options.releaseToNpm != false) {\n      const task = this.addPackagingTask('js');\n      this.release?.publisher.publishToNpm({\n        ...this.pacmakForLanguage('js', task),\n        registry: this.package.npmRegistry,\n        npmTokenSecret: this.package.npmTokenSecret,\n      });\n      this.addPackagingTarget('js', task);\n    }\n\n    // we cannot call an option `java` because the java code generated by jsii\n    // does not compile due to a conflict between this option name and the `java`\n    // package (e.g. when `java.util.Objects` is referenced).\n    if ('java' in options) {\n      throw new Error('the \"java\" option is now called \"publishToMaven\"');\n    }\n\n    if (options.publishToMaven) {\n      targets.java = {\n        package: options.publishToMaven.javaPackage,\n        maven: {\n          groupId: options.publishToMaven.mavenGroupId,\n          artifactId: options.publishToMaven.mavenArtifactId,\n        },\n      };\n\n      const task = this.addPackagingTask('java');\n\n      this.release?.publisher.publishToMaven({\n        ...this.pacmakForLanguage('java', task),\n        ...options.publishToMaven,\n      });\n\n      this.addPackagingTarget('java', task);\n    }\n\n    const pypi = options.publishToPypi ?? options.python;\n    if (pypi) {\n      targets.python = {\n        distName: pypi.distName,\n        module: pypi.module,\n      };\n\n      const task = this.addPackagingTask('python');\n      this.release?.publisher.publishToPyPi({\n        ...this.pacmakForLanguage('python', task),\n        ...pypi,\n      });\n\n      this.addPackagingTarget('python', task);\n    }\n\n    const nuget = options.publishToNuget ?? options.dotnet;\n    if (nuget) {\n      targets.dotnet = {\n        namespace: nuget.dotNetNamespace,\n        packageId: nuget.packageId,\n      };\n\n      const task = this.addPackagingTask('dotnet');\n      this.release?.publisher.publishToNuget({\n        ...this.pacmakForLanguage('dotnet', task),\n        ...nuget,\n      });\n\n      this.addPackagingTarget('dotnet', task);\n    }\n\n    const golang = options.publishToGo;\n    if (golang) {\n      targets.go = {\n        moduleName: golang.moduleName,\n      };\n\n      const task = this.addPackagingTask('go');\n      this.release?.publisher.publishToGo({\n        ...this.pacmakForLanguage('go', task),\n        ...golang,\n      });\n\n      this.addPackagingTarget('go', task);\n    }\n\n    this.addDevDeps(\n      'jsii',\n      'jsii-diff',\n    );\n\n    this.gitignore.exclude('.jsii', 'tsconfig.json');\n    this.npmignore?.include('.jsii');\n\n    if (options.docgen ?? true) {\n      new JsiiDocgen(this);\n    }\n\n    // jsii updates .npmignore, so we make it writable\n    if (this.npmignore) {\n      this.npmignore.readonly = false;\n    }\n\n    // run `jsii-pacmak` at the end of the upgrade workflow because at the moment\n    // we don't have an ability to leverage the multiple build jobs in the upgrade workflow\n    // and we want to preserve the behavior of the old upgrade workflow.\n    if (this.upgradeWorkflow) {\n      this.upgradeWorkflow.containerOptions = { image: this.superchainImage };\n      this.upgradeWorkflow.addPostBuildSteps({\n        name: 'Verify language bindings',\n        run: this.runTaskCommand(this.packageAllTask),\n      });\n    }\n  }\n\n  /**\n   * Returns the jsii/superchain image that is compatible with the minimum node\n   * version of this project.\n   */\n  private get superchainImage() {\n    return determineSuperchainImage(this.minNodeVersion);\n  }\n\n  /**\n   * Adds a target language to the build workflow and creates a package task.\n   * @param language\n   * @returns\n   */\n  private addPackagingTarget(language: JsiiPacmakTarget, packTask: Task) {\n    if (!this.buildWorkflow) {\n      return;\n    }\n\n    const pacmak = this.pacmakForLanguage(language, packTask);\n\n    this.buildWorkflow.addPostBuildJob(`package-${language}`, {\n      runsOn: ['ubuntu-latest'],\n      permissions: {},\n      tools: {\n        node: { version: '14.x' },\n        ...pacmak.publishTools,\n      },\n      steps: pacmak.prePublishSteps ?? [],\n    });\n  }\n\n  private addPackagingTask(language: JsiiPacmakTarget): Task {\n    const packageTask = this.tasks.addTask(`package:${language}`, {\n      description: `Create ${language} language bindings`,\n    });\n\n    packageTask.exec('jsii_version=$(node -p \"JSON.parse(fs.readFileSync(\\'.jsii\\')).jsiiVersion.split(\\' \\')[0]\")');\n    packageTask.exec(`npx jsii-pacmak@$jsii_version -v --target ${language}`);\n    this.packageAllTask.spawn(packageTask);\n    return packageTask;\n  }\n\n  private pacmakForLanguage(target: JsiiPacmakTarget, packTask: Task): CommonPublishOptions {\n    return {\n      publishTools: JSII_TOOLCHAIN[target],\n      prePublishSteps: [\n        {\n          name: 'Install Dependencies',\n          run: this.package.installCommand,\n        },\n        {\n          name: `Create ${target} artifact`,\n          run: `npx projen ${packTask.name}`,\n        },\n      ],\n    };\n  }\n}\n\nfunction parseAuthorAddress(options: JsiiProjectOptions) {\n  let authorEmail = options.authorEmail;\n  let authorUrl = options.authorUrl;\n  if (options.authorAddress) {\n    if (options.authorEmail && options.authorEmail !== options.authorAddress) {\n      throw new Error('authorEmail is deprecated and cannot be used in conjunction with authorAddress');\n    }\n\n    if (options.authorUrl && options.authorUrl !== options.authorAddress) {\n      throw new Error('authorUrl is deprecated and cannot be used in conjunction with authorAddress.');\n    }\n\n    if (EMAIL_REGEX.test(options.authorAddress)) {\n      authorEmail = options.authorAddress;\n    } else if (URL_REGEX.test(options.authorAddress)) {\n      authorUrl = options.authorAddress;\n    } else {\n      throw new Error(`authorAddress must be either an email address or a URL: ${options.authorAddress}`);\n    }\n  }\n  return { authorEmail, authorUrl };\n}\n\n"]}

package/lib/cdk8s/cdk8s-app-ts.d.ts

@@ -0,0 +1,111 @@
+import { TypeScriptAppProject, TypeScriptProjectOptions } from '../typescript';
+/**
+ * @experimental
+ */
+export interface Cdk8sTypeScriptAppOptions extends TypeScriptProjectOptions {
+    /**
+     * (experimental) Minimum target version this library is tested against.
+     *
+     * @default "1.0.0-beta.10"
+     * @experimental
+     * @featured true
+     */
+    readonly cdk8sVersion: string;
+    /**
+     * (experimental) constructs verion.
+     *
+     * @default "3.2.34"
+     * @experimental
+     */
+    readonly constructsVersion?: string;
+    /**
+     * (experimental) cdk8s-cli version.
+     *
+     * @default "cdk8sVersion"
+     * @experimental
+     */
+    readonly cdk8sCliVersion?: string;
+    /**
+     * (experimental) Use pinned version instead of caret version for CDK8s.
+     *
+     * You can use this to prevent yarn to mix versions for your CDK8s package and to prevent auto-updates.
+     * If you use experimental features this will let you define the moment you include breaking changes.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly cdk8sVersionPinning?: boolean;
+    /**
+     * (experimental) Use pinned version instead of caret version for CDK8s-cli.
+     *
+     * You can use this to prevent yarn to mix versions for your CDK8s package and to prevent auto-updates.
+     * If you use experimental features this will let you define the moment you include breaking changes.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly cdk8sCliVersionPinning?: boolean;
+    /**
+     * (experimental) Use pinned version instead of caret version for cdk8s-plus-17.
+     *
+     * You can use this to prevent yarn to mix versions for your CDK8s package and to prevent auto-updates.
+     * If you use experimental features this will let you define the moment you include breaking changes.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly cdk8sPlusVersionPinning?: boolean;
+    /**
+     * (experimental) Use pinned version instead of caret version for constructs.
+     *
+     * You can use this to prevent yarn to mix versions for your consructs package and to prevent auto-updates.
+     * If you use experimental features this will let you define the moment you include breaking changes.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly constructsVersionPinning?: boolean;
+    /**
+     * (experimental) The CDK8s app's entrypoint (relative to the source directory, which is "src" by default).
+     *
+     * @default "main.ts"
+     * @experimental
+     */
+    readonly appEntrypoint?: string;
+}
+/**
+ * (experimental) CDK8s app in TypeScript.
+ *
+ * @experimental
+ * @pjid cdk8s-app-ts
+ */
+export declare class Cdk8sTypeScriptApp extends TypeScriptAppProject {
+    /**
+     * (experimental) The CDK8s version this app is using.
+     *
+     * @experimental
+     */
+    readonly cdk8sVersion: string;
+    /**
+     * (experimental) The constructs version this app is using.
+     *
+     * @experimental
+     */
+    readonly constructsVersion: string;
+    /**
+     * (experimental) The cdk8s-cli version this app is using.
+     *
+     * @experimental
+     */
+    readonly cdk8sCliVersion: string;
+    /**
+     * (experimental) The CDK8s app entrypoint.
+     *
+     * @experimental
+     */
+    readonly appEntrypoint: string;
+    /**
+     * @experimental
+     */
+    constructor(options: Cdk8sTypeScriptAppOptions);
+}

package/lib/cdk8s/cdk8s-app-ts.js

@@ -0,0 +1,134 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Cdk8sTypeScriptApp = void 0;
+const JSII_RTTI_SYMBOL_1 = Symbol.for("jsii.rtti");
+const path = require("path");
+const fs = require("fs-extra");
+const component_1 = require("../component");
+const typescript_1 = require("../typescript");
+/**
+ * (experimental) CDK8s app in TypeScript.
+ *
+ * @experimental
+ * @pjid cdk8s-app-ts
+ */
+class Cdk8sTypeScriptApp extends typescript_1.TypeScriptAppProject {
+    /**
+     * @experimental
+     */
+    constructor(options) {
+        var _b, _c;
+        super({
+            ...options,
+            sampleCode: false,
+        });
+        if (!options.cdk8sVersion) {
+            throw new Error('Required field cdk8sVersion is not specified.');
+        }
+        // encode a hidden assumption further down the chain
+        if (this.srcdir !== 'src') {
+            throw new Error('sources are expected under the "src" directory');
+        }
+        // encode a hidden assumption further down the chain
+        if (this.testdir !== 'test') {
+            throw new Error('test sources are expected under the "test" directory');
+        }
+        this.appEntrypoint = (_b = options.appEntrypoint) !== null && _b !== void 0 ? _b : 'main.ts';
+        this.cdk8sVersion = options.cdk8sVersionPinning ? options.cdk8sVersion : `^${options.cdk8sVersion}`;
+        if (options.constructsVersion) {
+            this.constructsVersion = options.constructsVersionPinning ? options.constructsVersion : `^${options.constructsVersion}`;
+        }
+        else {
+            this.constructsVersion = '^3.2.34';
+        }
+        if (!!options.cdk8sCliVersion) {
+            this.cdk8sCliVersion = options.cdk8sCliVersionPinning ? options.cdk8sCliVersion : `^${options.cdk8sCliVersion}`;
+        }
+        else {
+            this.cdk8sCliVersion = this.cdk8sVersion;
+        }
+        // CLI
+        this.addDeps(`cdk8s@${this.cdk8sVersion}`, `constructs@${this.constructsVersion}`);
+        this.addDevDeps('ts-node@^9', `cdk8s-cli@${this.cdk8sCliVersion}`, `cdk8s@${this.cdk8sVersion}`, `constructs@${this.constructsVersion}`);
+        const synth = this.addTask('synth', {
+            description: 'Synthesizes your cdk8s app into dist (part of "yarn build")',
+            exec: 'cdk8s synth',
+        });
+        this.addTask('import', {
+            description: 'Imports API objects to your app by generating constructs.',
+            exec: 'cdk8s import',
+        });
+        this.gitignore.include('imports/');
+        this.gitignore.include('cdk8s.yaml');
+        // add synth to the build
+        this.postCompileTask.spawn(synth);
+        if ((_c = options.sampleCode) !== null && _c !== void 0 ? _c : true) {
+            new SampleCode(this);
+        }
+    }
+}
+exports.Cdk8sTypeScriptApp = Cdk8sTypeScriptApp;
+_a = JSII_RTTI_SYMBOL_1;
+Cdk8sTypeScriptApp[_a] = { fqn: "projen.cdk8s.Cdk8sTypeScriptApp", version: "0.46.8" };
+class SampleCode extends component_1.Component {
+    constructor(project) {
+        super(project);
+        this.appProject = project;
+    }
+    synthesize() {
+        const outdir = this.project.outdir;
+        const srcdir = path.join(outdir, this.appProject.srcdir);
+        if (fs.pathExistsSync(srcdir) && fs.readdirSync(srcdir).filter(x => x.endsWith('.ts'))) {
+            return;
+        }
+        const srcCode = `import { Construct } from 'constructs';
+import { App, Chart, ChartProps, ApiObject } from 'cdk8s';
+
+export class MyChart extends Chart {
+  constructor(scope: Construct, id: string, props: ChartProps = { }) {
+    super(scope, id, props);
+
+    const label = { app: 'hello-k8s' };
+
+
+
+    new ApiObject(this, 'deployment', {
+      apiVersion: "v1",
+      kind: "Pod",
+      metadata: {
+          namespace: "frontend",
+          name: "nginx",
+          labels: label,
+      },
+      spec: {
+          containers: [{
+              name: "nginx",
+              image: "nginx:1.14-alpine",
+              resources: {
+                  limits: {
+                      memory: "20Mi",
+                      cpu: 0.2,
+                  },
+              },
+          }],
+      },
+    });
+  }
+}
+
+const app = new App();
+new MyChart(app, 'hello');
+app.synth();`;
+        fs.mkdirpSync(srcdir);
+        fs.writeFileSync(path.join(srcdir, this.appProject.appEntrypoint), srcCode);
+        const appEntrypointName = path.basename(this.appProject.appEntrypoint, '.ts');
+        const cdk8sYaml = `language: typescript
+app: node lib/${appEntrypointName}.js
+imports:
+  - k8s
+    `;
+        fs.writeFileSync(path.join(outdir, 'cdk8s.yaml'), cdk8sYaml);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"cdk8s-app-ts.js","sourceRoot":"","sources":["../../src/cdk8s/cdk8s-app-ts.ts"],"names":[],"mappings":"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","sourcesContent":["\nimport * as path from 'path';\nimport * as fs from 'fs-extra';\nimport { Component } from '../component';\nimport { TypeScriptAppProject, TypeScriptProjectOptions } from '../typescript';\n\nexport interface Cdk8sTypeScriptAppOptions extends TypeScriptProjectOptions {\n                                                                                                                         \n  readonly cdk8sVersion: string;\n\n                                                              \n\n  readonly constructsVersion?: string;\n\n                                                                    \n\n  readonly cdk8sCliVersion?: string;\n\n                                                                                                                                                                                                                                                                                                                       \n  readonly cdk8sVersionPinning?: boolean;\n\n                                                                                                                                                                                                                                                                                                                           \n  readonly cdk8sCliVersionPinning?: boolean;\n\n                                                                                                                                                                                                                                                                                                                               \n  readonly cdk8sPlusVersionPinning?: boolean;\n\n                                                                                                                                                                                                                                                                                                                                \n  readonly constructsVersionPinning?: boolean;\n\n                                                                                                                                            \n  readonly appEntrypoint?: string;\n\n}\n\n                                                              \n\nexport class Cdk8sTypeScriptApp extends TypeScriptAppProject {\n\n                                                     \n  public readonly cdk8sVersion: string;\n\n                                                          \n  public readonly constructsVersion: string;\n\n                                                         \n\n  public readonly cdk8sCliVersion: string;\n\n                                         \n  public readonly appEntrypoint: string;\n\n  constructor(options: Cdk8sTypeScriptAppOptions) {\n    super({\n      ...options,\n      sampleCode: false,\n    });\n\n    if (!options.cdk8sVersion) {\n      throw new Error('Required field cdk8sVersion is not specified.');\n    }\n\n    // encode a hidden assumption further down the chain\n    if (this.srcdir !== 'src') {\n      throw new Error('sources are expected under the \"src\" directory');\n    }\n\n    // encode a hidden assumption further down the chain\n    if (this.testdir !== 'test') {\n      throw new Error('test sources are expected under the \"test\" directory');\n    }\n\n    this.appEntrypoint = options.appEntrypoint ?? 'main.ts';\n\n    this.cdk8sVersion = options.cdk8sVersionPinning ? options.cdk8sVersion : `^${options.cdk8sVersion}`;\n\n    if (options.constructsVersion) {\n      this.constructsVersion = options.constructsVersionPinning ? options.constructsVersion: `^${options.constructsVersion}`;\n    } else {\n      this.constructsVersion = '^3.2.34';\n    }\n\n    if (!! options.cdk8sCliVersion) {\n      this.cdk8sCliVersion = options.cdk8sCliVersionPinning ? options.cdk8sCliVersion: `^${options.cdk8sCliVersion}`;\n    } else {\n      this.cdk8sCliVersion = this.cdk8sVersion;\n    }\n\n\n    // CLI\n    this.addDeps(\n      `cdk8s@${this.cdk8sVersion}`,\n      `constructs@${this.constructsVersion}`,\n    );\n    this.addDevDeps(\n      'ts-node@^9',\n      `cdk8s-cli@${this.cdk8sCliVersion}`,\n      `cdk8s@${this.cdk8sVersion}`,\n      `constructs@${this.constructsVersion}`,\n    );\n\n    const synth = this.addTask('synth', {\n      description: 'Synthesizes your cdk8s app into dist (part of \"yarn build\")',\n      exec: 'cdk8s synth',\n    });\n\n    this.addTask('import', {\n      description: 'Imports API objects to your app by generating constructs.',\n      exec: 'cdk8s import',\n    });\n\n    this.gitignore.include('imports/');\n    this.gitignore.include('cdk8s.yaml');\n\n    // add synth to the build\n    this.postCompileTask.spawn(synth);\n\n    if (options.sampleCode ?? true) {\n      new SampleCode(this);\n    }\n  }\n\n}\n\nclass SampleCode extends Component {\n  private readonly appProject: Cdk8sTypeScriptApp;\n  constructor(project: Cdk8sTypeScriptApp) {\n    super(project);\n    this.appProject = project;\n  }\n\n  public synthesize() {\n    const outdir = this.project.outdir;\n    const srcdir = path.join(outdir, this.appProject.srcdir);\n    if (fs.pathExistsSync(srcdir) && fs.readdirSync(srcdir).filter(x => x.endsWith('.ts'))) {\n      return;\n    }\n\n    const srcCode = `import { Construct } from 'constructs';\nimport { App, Chart, ChartProps, ApiObject } from 'cdk8s';\n\nexport class MyChart extends Chart {\n  constructor(scope: Construct, id: string, props: ChartProps = { }) {\n    super(scope, id, props);\n\n    const label = { app: 'hello-k8s' };\n\n\n\n    new ApiObject(this, 'deployment', {\n      apiVersion: \"v1\",\n      kind: \"Pod\",\n      metadata: {\n          namespace: \"frontend\",\n          name: \"nginx\",\n          labels: label,\n      },\n      spec: {\n          containers: [{\n              name: \"nginx\",\n              image: \"nginx:1.14-alpine\",\n              resources: {\n                  limits: {\n                      memory: \"20Mi\",\n                      cpu: 0.2,\n                  },\n              },\n          }],\n      },\n    });\n  }\n}\n\nconst app = new App();\nnew MyChart(app, 'hello');\napp.synth();`;\n\n    fs.mkdirpSync(srcdir);\n    fs.writeFileSync(path.join(srcdir, this.appProject.appEntrypoint), srcCode);\n\n    const appEntrypointName = path.basename(this.appProject.appEntrypoint, '.ts');\n\n    const cdk8sYaml = `language: typescript\napp: node lib/${appEntrypointName}.js\nimports:\n  - k8s\n    `;\n\n    fs.writeFileSync(path.join(outdir, 'cdk8s.yaml'), cdk8sYaml);\n\n  }\n}"]}

package/lib/cdk8s/cdk8s-construct.d.ts

@@ -0,0 +1,79 @@
+import { ConstructLibrary, ConstructLibraryOptions } from '../cdk';
+/**
+ * @experimental
+ */
+export interface ConstructLibraryCdk8sOptions extends ConstructLibraryOptions {
+    /**
+     * (experimental) Minimum target version this library is tested against.
+     *
+     * @default "1.0.0-beta.10"
+     * @experimental
+     * @featured true
+     */
+    readonly cdk8sVersion: string;
+    /**
+     * (experimental) constructs verion.
+     *
+     * @default "3.2.34"
+     * @experimental
+     */
+    readonly constructsVersion?: string;
+    /**
+     * (experimental) Use pinned version instead of caret version for CDK8s.
+     *
+     * You can use this to prevent yarn to mix versions for your CDK8s package and to prevent auto-updates.
+     * If you use experimental features this will let you define the moment you include breaking changes.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly cdk8sVersionPinning?: boolean;
+    /**
+     * (experimental) Use pinned version instead of caret version for constructs.
+     *
+     * You can use this to prevent yarn to mix versions for your consructs package and to prevent auto-updates.
+     * If you use experimental features this will let you define the moment you include breaking changes.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly constructsVersionPinning?: boolean;
+    /**
+     * (experimental) Use pinned version instead of caret version for cdk8s-plus-17.
+     *
+     * You can use this to prevent yarn to mix versions for your CDK8s package and to prevent auto-updates.
+     * If you use experimental features this will let you define the moment you include breaking changes.
+     *
+     * @default false
+     * @experimental
+     */
+    readonly cdk8sPlusVersionPinning?: boolean;
+}
+/**
+ * (experimental) CDK8s construct library project.
+ *
+ * A multi-language (jsii) construct library which vends constructs designed to
+ * use within the CDK for Kubernetes (CDK8s), with a friendly workflow and
+ * automatic publishing to the construct catalog.
+ *
+ * @experimental
+ * @pjid cdk8s-construct
+ */
+export declare class ConstructLibraryCdk8s extends ConstructLibrary {
+    /**
+     * (experimental) The CDK8s version this app is using.
+     *
+     * @experimental
+     */
+    readonly cdk8sVersion: string;
+    /**
+     * (experimental) The constructs version this app is using.
+     *
+     * @experimental
+     */
+    readonly constructsVersion: string;
+    /**
+     * @experimental
+     */
+    constructor(options: ConstructLibraryCdk8sOptions);
+}