cdk8s-cli 2.0.34 → 2.0.37

package/.gitattributes

@@ -8,6 +8,7 @@
 /.github/workflows/auto-approve.yml linguist-generated
 /.github/workflows/backport.yml linguist-generated
 /.github/workflows/build.yml linguist-generated
+/.github/workflows/integ.yml linguist-generated
 /.github/workflows/pull-request-lint.yml linguist-generated
 /.github/workflows/release-1.x.yml linguist-generated
 /.github/workflows/release.yml linguist-generated

package/.projenrc.ts

@@ -0,0 +1,185 @@
+import { Cdk8sCommon } from '@cdk8s/projen-common';
+import { github, typescript, JsonFile, DependencyType } from 'projen';
+import { addIntegTests } from './projenrc/integ';
+
+const project = new typescript.TypeScriptProject({
+  ...Cdk8sCommon.props,
+
+  projenrcTs: true,
+  name: 'cdk8s-cli',
+  description: 'This is the command line tool for Cloud Development Kit (CDK) for Kubernetes (cdk8s).',
+  repositoryUrl: 'https://github.com/cdk8s-team/cdk8s-cli.git',
+  projenUpgradeSecret: 'PROJEN_GITHUB_TOKEN',
+  authorName: 'Amazon Web Services',
+  authorUrl: 'https://aws.amazon.com',
+  minNodeVersion: '14.17.0',
+
+  keywords: [
+    'k8s',
+    'cdk8s',
+    'kubernetes',
+    'cli',
+    'tools',
+    'automation',
+    'containers',
+  ],
+
+  workflowBootstrapSteps: [{ run: 'pip3 install pipenv' }],
+
+  defaultReleaseBranch: '2.x',
+  majorVersion: 2,
+  releaseBranches: {
+    '1.x': {
+      majorVersion: 1,
+      npmDistTag: 'latest-1',
+    },
+  },
+
+  releaseToNpm: true,
+  bin: {
+    cdk8s: 'bin/cdk8s',
+  },
+  deps: [
+    'cdk8s',
+    'cdk8s-plus-22',
+    'codemaker',
+    'constructs',
+    'fs-extra@^8',
+    'jsii-srcmak',
+    'jsii-pacmak',
+    'sscaff',
+    'yaml',
+    'yargs@^15',
+    'json2jsii',
+    'colors',
+    'ajv',
+  ],
+  devDeps: [
+    '@cdk8s/projen-common',
+    '@types/fs-extra@^8',
+    '@types/json-schema',
+    'glob',
+    '@types/glob',
+    'typescript-json-schema',
+  ],
+
+  tsconfig: {
+    include: ['src/schemas/*.json'],
+  },
+
+  // run upgrade-dependencies workflow at a different hour than other cdk8s
+  // repos to decrease flakiness of integration tests caused by new versions of
+  // cdk8s and cdk8s+ being published to different languages at the same time
+  depsUpgradeOptions: {
+    // the latest versions of yaml require node > 12, which
+    // is a change we are still not willing to make.
+    exclude: ['yaml'],
+    workflowOptions: {
+      schedule: Cdk8sCommon.upgradeScheduleFor('cdk8s-cli'),
+    },
+  },
+});
+
+// ignore integration tests since they need to executed after packaging
+// and are defined in a separate tasks.
+project.jest?.addIgnorePattern('/test/integ/');
+
+project.gitignore.exclude('.vscode/');
+
+new Cdk8sCommon(project);
+
+// add @types/node as a regular dependency since it's needed to during "import"
+// to compile the generated jsii code.
+project.deps.removeDependency('@types/node', DependencyType.BUILD);
+project.deps.addDependency('@types/node@^12', DependencyType.RUNTIME);
+
+const schemas = project.addTask('schemas');
+schemas.exec('ts-node scripts/crd.schema.ts');
+
+project.compileTask.spawn(schemas);
+
+// run backport in clean directories every time.
+const backportHome = '/tmp/.backport/';
+const backportDir = `${backportHome}/repositories/cdk8s-team/cdk8s-cli`;
+const backportConfig = new JsonFile(project, '.backportrc.json', {
+  // see https://github.com/sqren/backport/blob/main/docs/config-file-options.md
+  obj: {
+    repoOwner: 'cdk8s-team',
+    repoName: 'cdk8s-cli',
+    signoff: true,
+    branchLabelMapping: {
+      '^backport-to-(.+)$': '$1',
+    },
+    prTitle: '{commitMessages}',
+    fork: false,
+    publishStatusCommentOnFailure: true,
+    publishStatusCommentOnSuccess: true,
+    publishStatusCommentOnAbort: true,
+    targetPRLabels: [project.autoApprove!.label],
+    dir: backportDir,
+  },
+});
+
+// backport task to branches based on pr labels
+const backportTask = createBackportTask();
+
+// backport tasks to the explicit release branches
+for (const branch of project.release!.branches) {
+  createBackportTask(branch);
+}
+
+const backportWorkflow = project.github!.addWorkflow('backport');
+backportWorkflow.on({ pullRequestTarget: { types: ['closed'] } });
+backportWorkflow.addJob('backport', {
+  runsOn: ['ubuntu-18.04'],
+  permissions: {
+    contents: github.workflows.JobPermission.WRITE,
+  },
+  steps: [
+    // needed in order to run the projen task as well
+    // as use the backport configuration in the repo.
+    {
+      name: 'checkout',
+      uses: 'actions/checkout@v3',
+      with: {
+        // required because we need the full history
+        // for proper backports.
+        'fetch-depth': 0,
+      },
+    },
+    {
+      name: 'Set Git Identity',
+      run: 'git config --global user.name "github-actions" && git config --global user.email "github-actions@github.com"',
+    },
+    {
+      name: 'backport',
+      if: 'github.event.pull_request.merged == true',
+      run: `npx projen ${backportTask.name}`,
+      env: {
+        GITHUB_TOKEN: '${{ secrets.PROJEN_GITHUB_TOKEN }}',
+        BACKPORT_PR_NUMBER: '${{ github.event.pull_request.number }}',
+      },
+    },
+  ],
+});
+
+function createBackportTask(branch?: string) {
+  const name = branch ? `backport:${branch}` : 'backport';
+  const task = project.addTask(name, { requiredEnv: ['BACKPORT_PR_NUMBER', 'GITHUB_TOKEN'] });
+  task.exec(`rm -rf ${backportHome}`);
+  task.exec(`mkdir -p ${backportHome}`);
+  task.exec(`cp ${backportConfig.path} ${backportHome}`);
+
+  const command = ['npx', 'backport', '--accesstoken', '${GITHUB_TOKEN}', '--pr', '${BACKPORT_PR_NUMBER}'];
+  if (branch) {
+    command.push(...['--branch', branch]);
+  } else {
+    command.push('--non-interactive');
+  }
+  task.exec(command.join(' '), { cwd: backportHome });
+  return task;
+}
+
+addIntegTests(project);
+
+project.synth();

package/lib/cli/cmds/init.js

@@ -61,6 +61,7 @@ class Command {
     }
 }
 async function determineDeps() {
+    var _a;
     const cdk8s = new ModuleVersion('cdk8s', { jsii: true });
     const cdk8sPlus = new ModuleVersion('cdk8s-plus-22', { jsii: true });
     const cdk8sCli = new ModuleVersion('cdk8s-cli');
@@ -76,8 +77,8 @@ async function determineDeps() {
         cdk8s_plus_version: cdk8sPlus.version,
         constructs_version: constructsVersion,
         jsii_version: jsii.version,
-        // do not attempt to install cdk8s cli if we are running in a test context
-        npm_cdk8s_cli: process.env.CDK8S_TEST ? undefined : cdk8sCli.npmDependency,
+        // when running tests, install the tarball created from our source
+        npm_cdk8s_cli: (_a = process.env.CDK8S_TARBALL) !== null && _a !== void 0 ? _a : cdk8sCli.npmDependency,
     };
 }
 class ModuleVersion {
@@ -123,4 +124,4 @@ class ModuleVersion {
     }
 }
 module.exports = new Command();
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../src/cli/cmds/init.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as fs from 'fs-extra';\nimport * as pacmak from 'jsii-pacmak';\nimport * as pacmakv from 'jsii-pacmak/lib/targets/version-utils';\nimport { sscaff } from 'sscaff';\nimport * as yargs from 'yargs';\n\nconst pkgroot = path.join(__dirname, '..', '..', '..');\n\nconst pkg = fs.readJsonSync(path.join(pkgroot, 'package.json'));\nconst constructsVersion = pkg.dependencies.constructs.replace('^', '');\n\nconst templatesDir = path.join(pkgroot, 'templates');\nconst availableTemplates = fs.readdirSync(templatesDir).filter(x => !x.startsWith('.'));\n\nclass Command implements yargs.CommandModule {\n  public readonly command = 'init TYPE';\n  public readonly describe = 'Create a new cdk8s project from a template.';\n  public readonly builder = (args: yargs.Argv) => args\n    .positional('TYPE', { demandOption: true, desc: 'Project type' })\n    .showHelpOnFail(false)\n    .choices('TYPE', availableTemplates);\n\n  public async handler(argv: any) {\n    if (fs.readdirSync('.').filter(f => !f.startsWith('.')).length > 0) {\n      console.error('Cannot initialize a project in a non-empty directory');\n      process.exit(1);\n    }\n\n    console.error(`Initializing a project from the ${argv.type} template`);\n    const templatePath = path.join(templatesDir, argv.type);\n    const deps: any = await determineDeps();\n\n    try {\n      await sscaff(templatePath, '.', deps);\n    } catch (er) {\n      const e = er as any;\n      throw new Error(`error during project initialization: ${e.stack}\\nSTDOUT:\\n${e.stdout?.toString()}\\nSTDERR:\\n${e.stderr?.toString()}`);\n    }\n  }\n}\n\nasync function determineDeps(): Promise<Deps> {\n  const cdk8s = new ModuleVersion('cdk8s', { jsii: true });\n  const cdk8sPlus = new ModuleVersion('cdk8s-plus-22', { jsii: true });\n  const cdk8sCli = new ModuleVersion('cdk8s-cli');\n  const jsii = new ModuleVersion('jsii');\n\n  return {\n    npm_cdk8s: cdk8s.npmDependency,\n    npm_cdk8s_plus: cdk8sPlus.npmDependency,\n    pypi_cdk8s: cdk8s.pypiDependency,\n    pypi_cdk8s_plus: cdk8sPlus.pypiDependency,\n    mvn_cdk8s: cdk8s.mavenDependency,\n    mvn_cdk8s_plus: cdk8sPlus.mavenDependency,\n    cdk8s_core_version: cdk8s.version,\n    cdk8s_plus_version: cdk8sPlus.version,\n    constructs_version: constructsVersion,\n    jsii_version: jsii.version,\n\n    // do not attempt to install cdk8s cli if we are running in a test context\n    npm_cdk8s_cli: process.env.CDK8S_TEST ? undefined : cdk8sCli.npmDependency,\n  };\n}\n\ninterface Deps {\n  npm_cdk8s: string;\n  npm_cdk8s_cli?: string;\n  npm_cdk8s_plus: string;\n  pypi_cdk8s: string;\n  pypi_cdk8s_plus: string;\n  mvn_cdk8s: string;\n  mvn_cdk8s_plus: string;\n  cdk8s_core_version: string;\n  cdk8s_plus_version: string;\n  constructs_version: string;\n  jsii_version: string;\n}\n\nclass ModuleVersion {\n  public readonly pypiVersion: string;\n  public readonly npmVersion: string;\n  public readonly mavenVersion: string;\n  public readonly version: string;\n\n  private readonly jsii: boolean;\n\n  constructor(private readonly moduleName: string, options: { jsii?: boolean } = { }) {\n    this.version = this.resolveVersion(moduleName);\n    this.npmVersion = this.version;\n    this.pypiVersion = pacmakv.toReleaseVersion(this.version, pacmak.TargetName.PYTHON);\n    this.mavenVersion = pacmakv.toReleaseVersion(this.version, pacmak.TargetName.JAVA);\n    this.jsii = options.jsii ?? false;\n  }\n\n  public get npmTarballFile() {\n    if (this.jsii) {\n      return `${this.moduleName}@${this.version}.jsii.tgz`;\n    } else {\n      return `${this.moduleName}-v${this.version}.tgz`;\n    }\n  }\n\n  public get pypiWheelFile() {\n    const [major, minor, patch, pre] = this.pypiVersion.split('.');\n    return `${this.moduleName.replace(/-/g, '_')}-${major}.${minor}.${patch}${pre ?? ''}-py3-none-any.whl`;\n  }\n\n  public get javaJarFile() {\n    return `org/cdk8s/${this.moduleName}/${this.mavenVersion}/${this.moduleName}-${this.mavenVersion}.jar`;\n  }\n\n  public get npmDependency() {\n    return `${this.moduleName}@^${this.npmVersion}`;\n  }\n\n  public get pypiDependency() {\n    return `${this.moduleName}~=${this.pypiVersion}`;\n  }\n\n  public get mavenDependency() {\n    return this.mavenVersion;\n  }\n\n  private resolveVersion(module: string): string {\n    if (module === 'cdk8s-cli') {\n      module = '../../../';\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    return require(`${module}/package.json`).version;\n  }\n}\n\n\nmodule.exports = new Command();\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"init.js","sourceRoot":"","sources":["../../../src/cli/cmds/init.ts"],"names":[],"mappings":"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","sourcesContent":["import * as path from 'path';\nimport * as fs from 'fs-extra';\nimport * as pacmak from 'jsii-pacmak';\nimport * as pacmakv from 'jsii-pacmak/lib/targets/version-utils';\nimport { sscaff } from 'sscaff';\nimport * as yargs from 'yargs';\n\nconst pkgroot = path.join(__dirname, '..', '..', '..');\n\nconst pkg = fs.readJsonSync(path.join(pkgroot, 'package.json'));\nconst constructsVersion = pkg.dependencies.constructs.replace('^', '');\n\nconst templatesDir = path.join(pkgroot, 'templates');\nconst availableTemplates = fs.readdirSync(templatesDir).filter(x => !x.startsWith('.'));\n\nclass Command implements yargs.CommandModule {\n  public readonly command = 'init TYPE';\n  public readonly describe = 'Create a new cdk8s project from a template.';\n  public readonly builder = (args: yargs.Argv) => args\n    .positional('TYPE', { demandOption: true, desc: 'Project type' })\n    .showHelpOnFail(false)\n    .choices('TYPE', availableTemplates);\n\n  public async handler(argv: any) {\n    if (fs.readdirSync('.').filter(f => !f.startsWith('.')).length > 0) {\n      console.error('Cannot initialize a project in a non-empty directory');\n      process.exit(1);\n    }\n\n    console.error(`Initializing a project from the ${argv.type} template`);\n    const templatePath = path.join(templatesDir, argv.type);\n    const deps: any = await determineDeps();\n\n    try {\n      await sscaff(templatePath, '.', deps);\n    } catch (er) {\n      const e = er as any;\n      throw new Error(`error during project initialization: ${e.stack}\\nSTDOUT:\\n${e.stdout?.toString()}\\nSTDERR:\\n${e.stderr?.toString()}`);\n    }\n  }\n}\n\nasync function determineDeps(): Promise<Deps> {\n  const cdk8s = new ModuleVersion('cdk8s', { jsii: true });\n  const cdk8sPlus = new ModuleVersion('cdk8s-plus-22', { jsii: true });\n  const cdk8sCli = new ModuleVersion('cdk8s-cli');\n  const jsii = new ModuleVersion('jsii');\n\n  return {\n    npm_cdk8s: cdk8s.npmDependency,\n    npm_cdk8s_plus: cdk8sPlus.npmDependency,\n    pypi_cdk8s: cdk8s.pypiDependency,\n    pypi_cdk8s_plus: cdk8sPlus.pypiDependency,\n    mvn_cdk8s: cdk8s.mavenDependency,\n    mvn_cdk8s_plus: cdk8sPlus.mavenDependency,\n    cdk8s_core_version: cdk8s.version,\n    cdk8s_plus_version: cdk8sPlus.version,\n    constructs_version: constructsVersion,\n    jsii_version: jsii.version,\n\n    // when running tests, install the tarball created from our source\n    npm_cdk8s_cli: process.env.CDK8S_TARBALL ?? cdk8sCli.npmDependency,\n  };\n}\n\ninterface Deps {\n  npm_cdk8s: string;\n  npm_cdk8s_cli?: string;\n  npm_cdk8s_plus: string;\n  pypi_cdk8s: string;\n  pypi_cdk8s_plus: string;\n  mvn_cdk8s: string;\n  mvn_cdk8s_plus: string;\n  cdk8s_core_version: string;\n  cdk8s_plus_version: string;\n  constructs_version: string;\n  jsii_version: string;\n}\n\nclass ModuleVersion {\n  public readonly pypiVersion: string;\n  public readonly npmVersion: string;\n  public readonly mavenVersion: string;\n  public readonly version: string;\n\n  private readonly jsii: boolean;\n\n  constructor(private readonly moduleName: string, options: { jsii?: boolean } = { }) {\n    this.version = this.resolveVersion(moduleName);\n    this.npmVersion = this.version;\n    this.pypiVersion = pacmakv.toReleaseVersion(this.version, pacmak.TargetName.PYTHON);\n    this.mavenVersion = pacmakv.toReleaseVersion(this.version, pacmak.TargetName.JAVA);\n    this.jsii = options.jsii ?? false;\n  }\n\n  public get npmTarballFile() {\n    if (this.jsii) {\n      return `${this.moduleName}@${this.version}.jsii.tgz`;\n    } else {\n      return `${this.moduleName}-v${this.version}.tgz`;\n    }\n  }\n\n  public get pypiWheelFile() {\n    const [major, minor, patch, pre] = this.pypiVersion.split('.');\n    return `${this.moduleName.replace(/-/g, '_')}-${major}.${minor}.${patch}${pre ?? ''}-py3-none-any.whl`;\n  }\n\n  public get javaJarFile() {\n    return `org/cdk8s/${this.moduleName}/${this.mavenVersion}/${this.moduleName}-${this.mavenVersion}.jar`;\n  }\n\n  public get npmDependency() {\n    return `${this.moduleName}@^${this.npmVersion}`;\n  }\n\n  public get pypiDependency() {\n    return `${this.moduleName}~=${this.pypiVersion}`;\n  }\n\n  public get mavenDependency() {\n    return this.mavenVersion;\n  }\n\n  private resolveVersion(module: string): string {\n    if (module === 'cdk8s-cli') {\n      module = '../../../';\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-require-imports\n    return require(`${module}/package.json`).version;\n  }\n}\n\n\nmodule.exports = new Command();\n"]}

package/package.json

@@ -15,6 +15,11 @@
     "default": "npx projen default",
     "eject": "npx projen eject",
     "eslint": "npx projen eslint",
+    "integ:init": "npx projen integ:init",
+    "integ:init:go-app": "npx projen integ:init:go-app",
+    "integ:init:java-app": "npx projen integ:init:java-app",
+    "integ:init:python-app": "npx projen integ:init:python-app",
+    "integ:init:typescript-app": "npx projen integ:init:typescript-app",
     "package": "npx projen package",
     "post-compile": "npx projen post-compile",
     "post-upgrade": "npx projen post-upgrade",
@@ -36,7 +41,7 @@
     "organization": false
   },
   "devDependencies": {
-    "@cdk8s/projen-common": "^0.0.18",
+    "@cdk8s/projen-common": "^0.0.19",
     "@types/fs-extra": "^8",
     "@types/glob": "^7.2.0",
     "@types/jest": "^26.0.24",
@@ -52,24 +57,25 @@
     "jest-junit": "^13",
     "json-schema": "^0.4.0",
     "npm-check-updates": "^12",
-    "projen": "^0.58.17",
+    "projen": "^0.58.21",
     "standard-version": "^9",
     "ts-jest": "^27",
+    "ts-node": "^10.8.1",
     "typescript": "~4.7.4",
     "typescript-json-schema": "^0.53.1"
   },
   "dependencies": {
     "@types/node": "^12",
     "ajv": "^8.11.0",
-    "cdk8s": "^2.3.40",
-    "cdk8s-plus-22": "^2.0.0-rc.32",
+    "cdk8s": "^2.3.41",
+    "cdk8s-plus-22": "^2.0.0-rc.36",
     "codemaker": "^1.61.0",
     "colors": "1.4.0",
-    "constructs": "^10.1.42",
+    "constructs": "^10.1.43",
     "fs-extra": "^8",
     "jsii-pacmak": "^1.61.0",
-    "jsii-srcmak": "^0.1.603",
-    "json2jsii": "^0.3.52",
+    "jsii-srcmak": "^0.1.604",
+    "json2jsii": "^0.3.53",
     "sscaff": "^1.2.274",
     "yaml": "2.0.0-11",
     "yargs": "^15"
@@ -88,7 +94,7 @@
   },
   "main": "lib/index.js",
   "license": "Apache-2.0",
-  "version": "2.0.34",
+  "version": "2.0.37",
   "jest": {
     "testMatch": [
       "<rootDir>/src/**/__tests__/**/*.ts?(x)",
@@ -105,10 +111,12 @@
     ],
     "coverageDirectory": "coverage",
     "coveragePathIgnorePatterns": [
-      "/node_modules/"
+      "/node_modules/",
+      "/test/integ/"
     ],
     "testPathIgnorePatterns": [
-      "/node_modules/"
+      "/node_modules/",
+      "/test/integ/"
     ],
     "watchPathIgnorePatterns": [
       "/node_modules/"

package/projenrc/integ.ts

@@ -0,0 +1,103 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { typescript, github } from 'projen';
+
+export function addIntegTests(project: typescript.TypeScriptProject) {
+
+  const integWorkflow = project.github!.addWorkflow('integ');
+  integWorkflow.on({ pullRequest: {}, workflowDispatch: {} });
+
+  const initTask = project.addTask('integ:init');
+  initTask.exec(`yarn run ${project.compileTask.name}`);
+  initTask.exec(`yarn run ${project.packageTask.name}`);
+  initTask.exec(jest('integ/init.test.ts'));
+
+  const templatesDir = path.join(__dirname, '..', 'templates');
+  for (const template of fs.readdirSync(templatesDir)) {
+    if (fs.statSync(path.join(templatesDir, template)).isDirectory()) {
+      const task = project.addTask(`integ:init:${template}`);
+      task.exec(`yarn run ${project.compileTask.name}`);
+      task.exec(`yarn run ${project.packageTask.name}`);
+      task.exec(jest(`integ/init.test.ts -t ${template}`));
+    }
+  }
+
+  // run all init tests on node 14
+  integWorkflow.addJob('init', {
+    runsOn: ['ubuntu-latest'],
+    permissions: { contents: github.workflows.JobPermission.READ },
+    steps: runSteps(initTask.name, '14', true, true),
+  });
+
+  // run typescript app on node 16 and 18 as well
+  const nodeVersions = [16, 18];
+  integWorkflow.addJob('init-typescript-app', {
+    runsOn: ['ubuntu-latest'],
+    strategy: {
+      failFast: false,
+      matrix: { domain: { nodeVersion: nodeVersions } },
+    },
+    permissions: {
+      contents: github.workflows.JobPermission.READ,
+    },
+    steps: runSteps('integ:init:typescript-app', '${{ matrix.nodeVersion }}', false, false),
+  });
+
+  project.autoMerge!.addConditions('status-success=init');
+
+  for (const nodeVersion of nodeVersions) {
+    project.autoMerge!.addConditions(`status-success=init-typescript-app (${nodeVersion})`);
+  }
+
+}
+
+function jest(args: string) {
+  // we override 'testPathIgnorePatterns' so that it matches only integration tests
+  return `jest --testPathIgnorePatterns "^((?!integ).)*$" --passWithNoTests --all --updateSnapshot --coverageProvider=v8 ${args}`;
+};
+
+function runSteps(task: string, nodeVersion: string, python: boolean, go: boolean): github.workflows.JobStep[] {
+  const steps: github.workflows.JobStep[] = [
+    { uses: 'actions/checkout@v2' },
+    {
+      name: 'Set up Node.js',
+      uses: 'actions/setup-node@v2',
+      with: { 'node-version': nodeVersion },
+    },
+    {
+      name: 'Install dependencies',
+      run: 'yarn install --frozen-lockfile',
+    },
+  ];
+
+  if (python) {
+    steps.push({
+      name: 'Set up Python 3.x',
+      uses: 'actions/setup-python@v2',
+      with: {
+        'python-version': '3.x',
+      },
+    });
+    steps.push({
+      name: 'Install pipenv',
+      run: 'pip install pipenv',
+    });
+  }
+
+  if (go) {
+    steps.push({
+      name: 'Set up Go',
+      uses: 'actions/setup-go@v2',
+      with: {
+        'go-version': '1.16',
+      },
+    });
+  }
+
+  steps.push({
+    name: 'Run integration tests',
+    run: `yarn run ${task}`,
+  },
+  );
+  return steps;
+}

package/templates/typescript-app/package.json

@@ -8,8 +8,8 @@
   "scripts": {
     "import": "cdk8s import",
     "synth": "cdk8s synth",
-    "compile": "tsc",
-    "watch": "tsc -w",
+    "compile": "./node_modules/typescript/bin/tsc",
+    "watch": "./node_modules/typescript/bin/tsc -w",
     "test": "jest",
     "build": "npm run compile && npm run test && npm run synth",
     "upgrade": "npm i cdk8s@latest cdk8s-cli@latest",