jsii 5.9.6-dev.0 → 5.9.7-dev.0

package/testspee/scripts/minify-sources.sh

@@ -0,0 +1,26 @@
+#!/bin/bash
+
+###
+# Uses esbuild to minify the built aws-cdk-lib Javascript files to reduce module size
+# and speed up loading times.
+#
+# In local testing, this changed the average time for loading `aws-cdk-lib` from
+# 1112ms to 832ms (25% reduction).
+#
+# There are potentially even more savings available if we were to bundle each submodule
+# into a single file; however, experiments with this (so far) have not worked due to circular
+# dependencies in imports that lead to errors like "... is not a constructor". There are also
+# potentially concerns with relative file usage (e.g., `__dirname`) in source. For now, this helps a bit.
+###
+
+scriptdir=$(cd $(dirname $0) && pwd)
+cd ${scriptdir}/..
+
+find . -name '*.js' ! -name '.eslintrc.js' ! -path '*node_modules*' | xargs npx esbuild \
+  --platform=node \
+  --format=cjs \
+  --minify-whitespace \
+  --minify-syntax \
+  --tsconfig=tsconfig.json \
+  --allow-overwrite \
+  --outdir=.

package/testspee/scripts/verify-imports-resolve-same.ts

@@ -0,0 +1,142 @@
+/* eslint-disable no-console */
+/**
+ * Verify that the two styles of imports we support:
+ *
+ *    import { aws_ec2 } from 'aws-cdk-lib';
+ *    import * as aws_ec2 from 'aws-cdk-lib/aws-ec2';
+ *
+ * Resolve to the same source file when analyzed using the TypeScript compiler.
+ *
+ * This is necessary for Rosetta's analysis and translation of examples: we need
+ * to know what submodule we're importing here, and we need to be able to deal
+ * with both styles since both are used interchangeably.
+ */
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+
+// eslint-disable-next-line import/no-extraneous-dependencies
+import * as ts from 'typescript';
+
+async function main() {
+  // First make a tempdir and symlink `aws-cdk-lib` into it so we can refer to it
+  // as if it was an installed module.
+  await withTemporaryDirectory(async (tmpDir) => {
+    await fs.mkdirp(path.join(tmpDir, 'node_modules'));
+    await fs.symlink(path.resolve(__dirname, '..'), path.join(tmpDir, 'node_modules', 'aws-cdk-lib'));
+
+    const import1 = 'import { aws_ec2 } from "aws-cdk-lib";';
+    const import2 = 'import * as aws_ec2 from "aws-cdk-lib/aws-ec2";';
+
+    const src1 = await compileAndResolve(path.join(tmpDir, 'program1.ts'), import1, 'aws_ec2');
+    const src2 = await compileAndResolve(path.join(tmpDir, 'program2.ts'), import2, 'aws_ec2');
+
+    if (src1 !== src2) {
+      console.error('Import mismatch!');
+      console.error('\n    ', import1, '\n');
+      console.error('resolves to', src1);
+      console.error('\n    ', import2, '\n');
+      console.error('resolves to', src2);
+      process.exitCode = 1;
+    }
+  });
+}
+
+async function compileAndResolve(fileName: string, contents: string, symbolName: string) {
+  await fs.writeFile(fileName, contents + `\n\nconsole.log(${symbolName});`, { encoding: 'utf-8' });
+  const program = ts.createProgram({ rootNames: [fileName], options: STANDARD_COMPILER_OPTIONS });
+
+  const sourceFile = program.getSourceFile(fileName);
+  if (!sourceFile) {
+    throw new Error(`Could not find sourcefile back: ${fileName}`);
+  }
+
+  const diags = [
+    ...program.getGlobalDiagnostics(),
+    ...program.getDeclarationDiagnostics(sourceFile),
+    ...program.getSyntacticDiagnostics(sourceFile),
+    ...program.getSemanticDiagnostics(sourceFile),
+  ];
+  if (diags.length > 0) {
+    console.error(ts.formatDiagnostics(diags, {
+      getNewLine: () => '\n',
+      getCurrentDirectory: () => path.dirname(fileName),
+      getCanonicalFileName: (f) => path.resolve(f),
+    }));
+    throw new Error('Compilation failed');
+  }
+
+  // Find the 'console.log()' back and resolve the symbol inside
+  const logStmt = assertNode(sourceFile.statements[1], ts.isExpressionStatement);
+  const logCall = assertNode(logStmt.expression, ts.isCallExpression);
+  const ident = assertNode(logCall.arguments[0], ts.isIdentifier);
+
+  let sym = program.getTypeChecker().getSymbolAtLocation(ident);
+
+  // Resolve alias if applicable
+  // eslint-disable-next-line no-bitwise
+  while (sym && ((sym.flags & ts.SymbolFlags.Alias) !== 0)) {
+    sym = program.getTypeChecker().getAliasedSymbol(sym);
+  }
+
+  if (!sym) {
+    throw new Error(`Could not resolve: ${symbolName} in '${contents}'`);
+  }
+
+  // Return the filename
+  const srcFile = sym.declarations?.[0].getSourceFile().fileName.replace(/[.](ts|js|d\.ts)$/, '');
+  if (!srcFile) {
+    console.log(sym);
+    throw new Error(`Symbol ${symbolName} in '${contents}' does not resolve to a source location`);
+  }
+  return srcFile;
+}
+
+export async function withTemporaryDirectory<T>(callback: (dir: string) => Promise<T>): Promise<T> {
+  const tmpdir = await fs.mkdtemp(path.join(os.tmpdir(), path.basename(__filename)));
+  try {
+    return await callback(tmpdir);
+  } finally {
+    await fs.remove(tmpdir);
+  }
+}
+
+function assertNode<A extends ts.Node>(x: ts.Node, assert: (x: ts.Node) => x is A): A {
+  if (!assert(x)) {
+    throw new Error(`Not the right type of node, expecting ${assert.name}, got ${ts.SyntaxKind[x.kind]}`);
+  }
+  return x;
+}
+
+export const STANDARD_COMPILER_OPTIONS: ts.CompilerOptions = {
+  alwaysStrict: true,
+  charset: 'utf8',
+  declaration: true,
+  experimentalDecorators: true,
+  inlineSourceMap: true,
+  inlineSources: true,
+  lib: ['lib.es2016.d.ts', 'lib.es2017.object.d.ts', 'lib.es2017.string.d.ts'],
+  module: ts.ModuleKind.CommonJS,
+  noEmitOnError: true,
+  noFallthroughCasesInSwitch: true,
+  noImplicitAny: true,
+  noImplicitReturns: true,
+  noImplicitThis: true,
+  noUnusedLocals: false, // Important, becomes super annoying without this
+  noUnusedParameters: false, // Important, becomes super annoying without this
+  resolveJsonModule: true,
+  strict: true,
+  strictNullChecks: true,
+  strictPropertyInitialization: true,
+  stripInternal: true,
+  target: ts.ScriptTarget.ES2019,
+  // Incremental builds
+  incremental: true,
+  tsBuildInfoFile: '.tsbuildinfo',
+};
+
+main().catch((e) => {
+  // eslint-disable-next-line no-console
+  console.error(e);
+  process.exitCode = 1;
+});

package/testspee/scripts/verify-imports-shielded.ts

@@ -0,0 +1,57 @@
+/**
+ * Check that the imports from 'aws-cdk-lib' we expect to work, work, and those we have shielded off don't work.
+ */
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+
+async function main() {
+  // First make a tempdir and symlink `aws-cdk-lib` into it so we can refer to it
+  // as if it was an installed module.
+  await withTemporaryDirectory(async (tmpDir) => {
+    await fs.mkdirp(path.join(tmpDir, 'node_modules'));
+    await fs.symlink(path.resolve(__dirname, '..'), path.join(tmpDir, 'node_modules', 'aws-cdk-lib'));
+
+    assertImportSucceeds('aws-cdk-lib');
+    assertImportFails('aws-cdk-lib/LICENSE', 'ERR_PACKAGE_PATH_NOT_EXPORTED');
+    assertImportFails('aws-cdk-lib/aws-s3/lib/bucket', 'ERR_PACKAGE_PATH_NOT_EXPORTED');
+    assertImportSucceeds('aws-cdk-lib/aws-s3');
+
+    function assertImportSucceeds(name: string) {
+      require.resolve(name, { paths: [tmpDir] });
+    }
+
+    function assertImportFails(name: string, code: string) {
+      try {
+        require.resolve(name, { paths: [tmpDir] });
+
+        // eslint-disable-next-line no-console
+        console.error(`Import of '${name}' should have produced an error, but didn't.`);
+        process.exitCode = 1;
+      } catch (e: any) {
+        if (e.code !== code) {
+          // eslint-disable-next-line no-console
+          console.error(`Import of '${name}' should have produced error ${code}, but got ${(e as any).code}.`);
+          process.exitCode = 1;
+        }
+      }
+    }
+  });
+}
+
+
+export async function withTemporaryDirectory<T>(callback: (dir: string) => Promise<T>): Promise<T> {
+  const tmpdir = await fs.mkdtemp(path.join(os.tmpdir(), path.basename(__filename)));
+  try {
+    return await callback(tmpdir);
+  } finally {
+    await fs.remove(tmpdir);
+  }
+}
+
+
+main().catch((e) => {
+  // eslint-disable-next-line no-console
+  console.error(e);
+  process.exitCode = 1;
+});

package/testspee/scripts/verify-stripped-exp.ts

@@ -0,0 +1,158 @@
+// +------------------------------------------------------------------------------------------------
+// | this script is executed post packaging to verify that experimental modules in aws-cdk-lib includes **only**  L1 autogenerated files.
+// | The purpose is to avoid publishing L2 of experimental modules with aws-cdk-lib
+// |
+import { spawnSync } from 'child_process';
+import * as console from 'console';
+import * as os from 'os';
+import * as path from 'path';
+import * as fs from 'fs-extra';
+
+async function main(tempDir: string) {
+  console.log('🧐 Verifying all experimental modules includes only L1s files...');
+  const cwd = process.cwd();
+  const awsCdkModulesRepoPath = path.join(findWorkspacePath(), 'packages', '@aws-cdk');
+  // eslint-disable-next-line @typescript-eslint/no-require-imports
+  const version = require('./../package.json').version;
+  const tarFullPath = path.join(cwd, 'dist', 'js', `aws-cdk-lib@${version}.jsii.tgz`);
+
+  const invalidCfnModules = new Map<string, Array<String>>();
+  const invalidModules = new Array<string>();
+
+  // install the tarball in a temp directory
+  console.log(`installing aws-cdk-lib from dist/js into ${tempDir}`);
+  exec('npm', ['install', '--prefix', tempDir, tarFullPath]);
+  const installedAwsCdkLibPath = path.join(tempDir, 'node_modules', 'aws-cdk-lib', 'lib');
+
+  for (const module of fs.readdirSync(awsCdkModulesRepoPath)) {
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const pkgJson = require(path.join(awsCdkModulesRepoPath, module, 'package.json'));
+    if (pkgJson.stability !== 'experimental') {
+      continue;
+    }
+    if (pkgJson['cdk-build']?.cloudformation) {
+      // if a cfn module, verify only the allowed files exists
+      const files = await listAllFiles(path.join(installedAwsCdkLibPath, module));
+      const invalidFiles = new Array();
+      files.forEach(file => {
+        if (!isAllowedFile(file)) {
+          invalidFiles.push(file);
+        }
+      });
+      if (invalidFiles.length > 0) {
+        invalidCfnModules.set(module, invalidFiles);
+      }
+    } else {
+      // not a cfn module, verify it was entirely removed
+      if (fs.existsSync(path.join(installedAwsCdkLibPath, module))) {
+        invalidModules.push(module);
+      }
+    }
+  }
+
+  if (invalidCfnModules.size > 0 || invalidModules.length > 0) {
+    if (invalidCfnModules.size > 0 ) {
+      console.log('cfn module with invalid files:');
+      for (let [module, files] of invalidCfnModules.entries()) {
+        console.log(`${module}:`);
+        files.forEach(file => console.log(`\t ${file}`));
+      }
+    }
+    console.log('---------------------------------------------');
+    if (invalidModules.length > 0) {
+      console.log('non-cfn experimental modules:');
+      invalidModules.forEach(m => console.log(`\t ${m}`));
+    }
+    throw new Error('Verification Error');
+  }
+}
+
+const tempDir = fs.mkdtempSync(os.tmpdir());
+
+main(tempDir).then(
+  () => {
+    fs.removeSync(tempDir);
+    console.log('✅ All experimental modules includes only L1s files!');
+    process.exit(0);
+  },
+  (err) => {
+    process.stderr.write(`${err}\n`);
+    process.stderr.write(`❌ Verification failed, Some experimental modules includes non L1 files, see details above. Inspect working directory: '${tempDir}'`);
+    process.exit(1);
+  },
+);
+
+
+/**
+ * Spawn sync with error handling
+ */
+function exec(cmd: string, args: string[]) {
+  const proc = spawnSync(cmd, args);
+
+  if (proc.error) {
+    throw proc.error;
+  }
+
+  if (proc.status !== 0) {
+    if (proc.stdout || proc.stderr) {
+      throw new Error(`${cmd} exited with status ${proc.status}; stdout: ${proc.stdout?.toString().trim()}\n\n\nstderr: ${proc.stderr?.toString().trim()}`);
+    }
+    throw new Error(`${cmd} exited with status ${proc.status}`);
+  }
+
+  return proc;
+}
+
+const GENERATED_SUFFIX_REGEX = new RegExp(/generated\.(js|d\.ts)$/);
+const ALLOWED_FILES = ['.jsiirc.json', 'index.ts', 'index.js', 'index.d.ts'];
+
+/**
+ * Recursively collect all files in dir
+ */
+async function listAllFiles(dir: string) {
+  const ret = new Array();
+
+  async function recurse(part: string) {
+    const files = await fs.readdir(part);
+    for (const file of files) {
+      const fullPath = path.join(part, file);
+      if ((await fs.stat(fullPath)).isDirectory()) {
+        await recurse(fullPath);
+      } else {
+        ret.push(file);
+      }
+    }
+  }
+  await recurse(dir);
+  return ret;
+}
+
+/**
+ * Find the workspace root path. Walk up the directory tree until you find lerna.json
+ */
+function findWorkspacePath() {
+
+  return _findRootPath(process.cwd());
+
+  function _findRootPath(part: string): string {
+    if (part === path.resolve(part, '..')) {
+      throw new Error('couldn\'t find a \'lerna.json\' file when walking up the directory tree, are you in a aws-cdk project?');
+    }
+
+    if (fs.existsSync(path.resolve(part, 'lerna.json'))) {
+      return part;
+    }
+    return _findRootPath(path.resolve(part, '..'));
+  }
+}
+
+/**
+ * @param file
+ * @returns true if the file allowed in an L1 only modules, otherwise false
+ */
+function isAllowedFile(file: string) {
+  if (GENERATED_SUFFIX_REGEX.test(file)) {
+    return true;
+  }
+  return ALLOWED_FILES.includes(file);
+}