TINY-14141: Add skipTypecheck CLI option

CHANGELOG.md

@@ -6,6 +6,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## Unreleased
 
+### Added
+- Added a `--skipTypecheck` CLI option to skip typechecking before tests.
+
 ### Fixed
 - Fixed an issue where typechecking errors when using rspack would not recover and required restarting the server. #TINY-14130
 

modules/server/src/main/ts/BedrockAuto.ts

@@ -77,12 +77,27 @@ export const go = async (bedrockAutoSettings: BedrockAutoSettings): Promise<void
   const shutdown = (services: ((immediate?: boolean) => Promise<void>)[]) => (immediate?: boolean) => Promise.allSettled(services.map((fn) => fn(immediate)));
 
   try {
-
     const driverDeferred = defer<Attempt<unknown, Browser>>();
 
     const scratchDir = settings.name ? `scratch/${settings.name}` : `scratch/bedrock`;
 
-    const routesPromise = RunnerRoutes.generate('auto', settings.projectdir, settings.basedir, scratchDir, settings.config, settings.bundler, settings.testfiles, settings.chunk, settings.retries, settings.singleTimeout, settings.stopOnFailure, basePage, settings.coverage, settings.polyfills);
+    const routesPromise = RunnerRoutes.generate({
+      mode: 'auto',
+      projectdir: settings.projectdir,
+      basedir: settings.basedir,
+      scratchdir: scratchDir,
+      configFile: settings.config,
+      bundler: settings.bundler,
+      testfiles: settings.testfiles,
+      chunk: settings.chunk,
+      retries: settings.retries,
+      singleTimeout: settings.singleTimeout,
+      stopOnFailure: settings.stopOnFailure,
+      basePage,
+      coverage: settings.coverage,
+      polyfills: settings.polyfills,
+      skipTypecheck: settings.skipTypecheck
+    });
 
     const service = await Serve.start({
       ...settings,

modules/server/src/main/ts/BedrockManual.ts

@@ -14,8 +14,23 @@ export const go = async (bedrockManualSettings: BedrockManualSettings): Promise<
 
   const settings = SettingsResolver.resolveAndLog(bedrockManualSettings);
   const basePage = 'src/resources/html/bedrock.html';
-  const routes = RunnerRoutes.generate('manual', settings.projectdir, settings.basedir, 'scratch', settings.config, settings.bundler, settings.testfiles, settings.chunk, 0, settings.singleTimeout, true, basePage, settings.coverage, settings.polyfills);
-
+  const routes = RunnerRoutes.generate({
+    mode: 'manual',
+    projectdir: settings.projectdir,
+    basedir: settings.basedir,
+    scratchdir: 'scratch',
+    configFile: settings.config,
+    bundler: settings.bundler,
+    testfiles: settings.testfiles,
+    chunk: settings.chunk,
+    retries: 0,
+    singleTimeout: settings.singleTimeout,
+    stopOnFailure: true,
+    basePage,
+    coverage: settings.coverage,
+    polyfills: settings.polyfills,
+    skipTypecheck: settings.skipTypecheck
+  });
   const port = await portfinder.getPortPromise({
     port: 8000,
     stopPort: 20000
@@ -46,4 +61,3 @@ export const go = async (bedrockManualSettings: BedrockManualSettings): Promise<
 };
 
 export const mode = 'forManual';
-

modules/server/src/main/ts/bedrock/cli/ClOptions.ts

@@ -52,6 +52,14 @@ export const browser: ClOption = {
   ])
 };
 
+export const skipTypecheck: ClOption = {
+  name: 'skipTypecheck',
+  type: Boolean,
+  defaultValue: false,
+  description: 'Skip typechecking before tests',
+  validate: Extraction.any
+};
+
 export const bundler: ClOption = {
   name: 'bundler',
   type: String,

modules/server/src/main/ts/bedrock/cli/Clis.ts

@@ -33,7 +33,8 @@ const commonOptions = (directories: Directories) => {
     ClOptions.bucket,
     ClOptions.buckets,
     ClOptions.stopOnFailure,
-    ClOptions.verbose
+    ClOptions.verbose,
+    ClOptions.skipTypecheck
   ];
 };
 

modules/server/src/main/ts/bedrock/compiler/Compiler.ts

@@ -7,17 +7,10 @@ export interface Compiler {
   readonly generate: () => Promise<Buffer | string>;
 }
 
-export const compile = (args: { bundler: Types.Bundler; tsConfigFile: string; scratchDir: string; basedir: string; exitOnCompileError: boolean; files: string[]; coverage: string[]; polyfills: string[];
-}): Compiler => {
+export const compile = (args: Types.CompilerArgs): Compiler => {
   const {
     bundler,
-    tsConfigFile,
-    scratchDir,
-    basedir,
-    exitOnCompileError,
-    files,
-    coverage,
-    polyfills
+    ...compileArgs
   } = args;
 
   const getCompileFunc = (): Types.CompileFn => {
@@ -31,15 +24,7 @@ export const compile = (args: { bundler: Types.Bundler; tsConfigFile: string; sc
 
   const generate = async (): Promise<Buffer | string> => {
     const compile = getCompileFunc();
-    const compiledJsFilePath = await compile(
-      tsConfigFile,
-      scratchDir,
-      basedir,
-      exitOnCompileError,
-      files,
-      coverage,
-      polyfills
-    );
+    const compiledJsFilePath = await compile(compileArgs);
     return fs.readFileSync(compiledJsFilePath);
   };
 

modules/server/src/main/ts/bedrock/compiler/Rspack.ts

@@ -8,7 +8,7 @@ import { rspack, RspackOptions } from '@rspack/core';
 import { RspackDevServer } from '@rspack/dev-server';
 import { RspackCompileInfo, DevServerServeSettings, CompileFn } from './Types';
 
-const getWebPackConfigTs = (tsConfigFile: string, scratchFile: string, dest: string, manualMode: boolean, basedir: string): RspackOptions => {
+const getWebPackConfigTs = (tsConfigFile: string, scratchFile: string, dest: string, manualMode: boolean, basedir: string, skipTypecheck: boolean): RspackOptions => {
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   const { TsCheckerRspackPlugin } = require('ts-checker-rspack-plugin');
 
@@ -105,14 +105,14 @@ const getWebPackConfigTs = (tsConfigFile: string, scratchFile: string, dest: str
       new rspack.DefinePlugin({
         'process.env.NODE_ENV': JSON.stringify('development')
       }),
-      new TsCheckerRspackPlugin({
+      ...(!skipTypecheck ? [ new TsCheckerRspackPlugin({
         async: manualMode,
         typescript: {
           memoryLimit: manualMode ? 4096 : 2048,
           configFile: getTsConfigFile(),
           build: true
         }
-      })
+      }) ] : [])
     ],
 
     output: {
@@ -150,26 +150,34 @@ const compileTests = (compileInfo: RspackCompileInfo, exitOnCompileError: boolea
   });
 };
 
-const getTsCompileInfo = (tsConfigFile: string, scratchDir: string, basedir: string, manualMode: boolean): Promise<RspackCompileInfo> => {
+const getTsCompileInfo = (tsConfigFile: string, scratchDir: string, basedir: string, manualMode: boolean, skipTypecheck: boolean): Promise<RspackCompileInfo> => {
   return new Promise((resolve, reject) => {
     const scratchFile = path.join(scratchDir, 'compiled/tests-imports.ts');
     const dest = path.join(scratchDir, 'compiled/tests.js');
 
     if (!fs.existsSync(tsConfigFile)) {
       reject(`Could not find the required tsconfig file: ${tsConfigFile}`);
     } else {
-      const config = getWebPackConfigTs(tsConfigFile, scratchFile, dest, manualMode, basedir);
+      const config = getWebPackConfigTs(tsConfigFile, scratchFile, dest, manualMode, basedir, skipTypecheck);
       resolve({ scratchFile, dest, config });
     }
   });
 };
 
-const getCompileInfo = (tsConfigFile: string, scratchDir: string, basedir: string, manualMode: boolean): Promise<RspackCompileInfo> => {
-  return getTsCompileInfo(tsConfigFile, scratchDir, basedir, manualMode);
+const getCompileInfo = (tsConfigFile: string, scratchDir: string, basedir: string, manualMode: boolean, skipTypecheck: boolean): Promise<RspackCompileInfo> => {
+  return getTsCompileInfo(tsConfigFile, scratchDir, basedir, manualMode, skipTypecheck);
 };
 
-export const compile: CompileFn = async (tsConfigFile: string, scratchDir: string, basedir: string, exitOnCompileError: boolean, srcFiles: string[], _coverage: string[], polyfills: string[]): Promise<string> => {
-  const compileInfo = await getCompileInfo(tsConfigFile, scratchDir, basedir, false);
+export const compile: CompileFn = async ({
+  tsConfigFile,
+  scratchDir,
+  basedir,
+  exitOnCompileError,
+  srcFiles,
+  polyfills,
+  skipTypecheck
+}): Promise<string> => {
+  const compileInfo = await getCompileInfo(tsConfigFile, scratchDir, basedir, false, skipTypecheck);
   return compileTests(compileInfo, exitOnCompileError, srcFiles, polyfills);
 };
 
@@ -178,8 +186,9 @@ const isCompiledRequest = (url?: string) => url && url.startsWith('/compiled/');
 export const devserver = async (settings: DevServerServeSettings): Promise<Serve.ServeService> => {
   const scratchDir = path.resolve('scratch');
   const tsConfigFile = settings.config;
+  const skipTypecheck = settings.skipTypecheck;
 
-  const compileInfo = await getCompileInfo(tsConfigFile, scratchDir, settings.basedir, true);
+  const compileInfo = await getCompileInfo(tsConfigFile, scratchDir, settings.basedir, true, skipTypecheck);
   return Serve.startCustom(settings, (port, handler) => {
     const scratchFile = compileInfo.scratchFile;
     console.log(`Loading ${settings.testfiles.length} test files...`);

modules/server/src/main/ts/bedrock/compiler/Types.ts

@@ -6,6 +6,22 @@ export interface DevServerServeSettings extends Serve.ServeSettings {
   readonly config: string;
   readonly coverage: string[];
   readonly polyfills: string[];
+  readonly skipTypecheck: boolean;
+}
+
+export interface CompileArgs {
+  readonly tsConfigFile: string;
+  readonly scratchDir: string;
+  readonly basedir: string;
+  readonly exitOnCompileError: boolean;
+  readonly srcFiles: string[];
+  readonly coverage: string[];
+  readonly polyfills: string[];
+  readonly skipTypecheck: boolean;
+}
+
+export interface CompilerArgs extends CompileArgs {
+  readonly bundler: Bundler;
 }
 
 export type WebpackCompileInfo = CompileInfo<Configuration>;
@@ -17,14 +33,6 @@ export interface CompileInfo<T> {
   readonly config: T;
 }
 
-export type CompileFn = (
-  tsConfigFile: string,
-  scratchDir: string,
-  basedir: string,
-  exitOnCompileError: boolean,
-  srcFiles: string[],
-  coverage: string[],
-  polyfills: string[]
-) => Promise<string>;
+export type CompileFn = (args: CompileArgs) => Promise<string>;
 
 export type Bundler = 'rspack' | 'webpack';

modules/server/src/main/ts/bedrock/compiler/Webpack.ts

@@ -40,7 +40,7 @@ const webpackSharedRules = ([] as any[]).concat([
   }
 ]);
 
-const getWebPackConfigTs = (tsConfigFile: string, scratchFile: string, dest: string, coverage: string[], manualMode: boolean, basedir: string): webpack.Configuration => {
+const getWebPackConfigTs = (tsConfigFile: string, scratchFile: string, dest: string, coverage: string[], manualMode: boolean, basedir: string, skipTypecheck: boolean): webpack.Configuration => {
   // eslint-disable-next-line @typescript-eslint/no-var-requires
   const TsConfigPathsPlugin = require('tsconfig-paths-webpack-plugin');
   // eslint-disable-next-line @typescript-eslint/no-var-requires
@@ -116,14 +116,14 @@ const getWebPackConfigTs = (tsConfigFile: string, scratchFile: string, dest: str
     },
 
     plugins: [
-      new ForkTsCheckerWebpackPlugin({
+      ...(!skipTypecheck ? [ new ForkTsCheckerWebpackPlugin({
         async: manualMode,
         typescript: {
           memoryLimit: manualMode ? 4096 : 2048,
           configFile: tsConfigFile,
           build: true
         }
-      }),
+      }) ] : []),
       new webpack.WatchIgnorePlugin({
         paths: [
           // Ignore generated files. See https://github.com/TypeStrong/ts-loader#usage-with-webpack-watch
@@ -228,15 +228,15 @@ const compileTests = (compileInfo: WebpackCompileInfo, exitOnCompileError: boole
   });
 };
 
-const getTsCompileInfo = (tsConfigFile: string, scratchDir: string, basedir: string, manualMode: boolean, coverage: string[]): Promise<WebpackCompileInfo> => {
+const getTsCompileInfo = (tsConfigFile: string, scratchDir: string, basedir: string, manualMode: boolean, coverage: string[], skipTypecheck: boolean): Promise<WebpackCompileInfo> => {
   return new Promise((resolve, reject) => {
     const scratchFile = path.join(scratchDir, 'compiled/tests-imports.ts');
     const dest = path.join(scratchDir, 'compiled/tests.js');
 
     if (!fs.existsSync(tsConfigFile)) {
       reject(`Could not find the required tsconfig file: ${tsConfigFile}`);
     } else {
-      const config = getWebPackConfigTs(tsConfigFile, scratchFile, dest, coverage, manualMode, basedir);
+      const config = getWebPackConfigTs(tsConfigFile, scratchFile, dest, coverage, manualMode, basedir, skipTypecheck);
       resolve({ scratchFile, dest, config });
     }
   });
@@ -250,16 +250,25 @@ const getJsCompileInfo = (scratchDir: string, basedir: string, manualMode: boole
   return Promise.resolve({ scratchFile, dest, config });
 };
 
-const getCompileInfo = (tsConfigFile: string, scratchDir: string, basedir: string, manualMode: boolean, srcFiles: string[], coverage: string[]): Promise<WebpackCompileInfo> => {
+const getCompileInfo = (tsConfigFile: string, scratchDir: string, basedir: string, manualMode: boolean, srcFiles: string[], coverage: string[], skipTypecheck: boolean): Promise<WebpackCompileInfo> => {
   if (hasTs(srcFiles)) {
-    return getTsCompileInfo(tsConfigFile, scratchDir, basedir, manualMode, coverage);
+    return getTsCompileInfo(tsConfigFile, scratchDir, basedir, manualMode, coverage, skipTypecheck);
   } else {
     return getJsCompileInfo(scratchDir, basedir, manualMode, coverage);
   }
 };
 
-export const compile: CompileFn = async (tsConfigFile: string, scratchDir: string, basedir: string, exitOnCompileError: boolean, srcFiles: string[], coverage: string[], polyfills: string[]): Promise<string> => {
-  const compileInfo = await getCompileInfo(tsConfigFile, scratchDir, basedir, false, srcFiles, coverage);
+export const compile: CompileFn = async ({
+  tsConfigFile,
+  scratchDir,
+  basedir,
+  exitOnCompileError,
+  srcFiles,
+  coverage,
+  polyfills,
+  skipTypecheck
+}): Promise<string> => {
+  const compileInfo = await getCompileInfo(tsConfigFile, scratchDir, basedir, false, srcFiles, coverage, skipTypecheck);
   return compileTests(compileInfo, exitOnCompileError, srcFiles, polyfills);
 };
 
@@ -268,8 +277,9 @@ const isCompiledRequest = (request: { url: string }) => request.url.startsWith('
 export const devserver = async (settings: DevServerServeSettings): Promise<Serve.ServeService> => {
   const scratchDir = path.resolve('scratch');
   const tsConfigFile = settings.config;
+  const skipTypecheck = settings.skipTypecheck;
 
-  const compileInfo = await getCompileInfo(tsConfigFile, scratchDir, settings.basedir, true, settings.testfiles, settings.coverage);
+  const compileInfo = await getCompileInfo(tsConfigFile, scratchDir, settings.basedir, true, settings.testfiles, settings.coverage, skipTypecheck);
   return Serve.startCustom(settings, (port, handler) => {
     const scratchFile = compileInfo.scratchFile;
     console.log(`Loading ${settings.testfiles.length} test files...`);

modules/server/src/main/ts/bedrock/core/Settings.ts

@@ -19,6 +19,7 @@ export interface BedrockSettings {
   readonly verbose: boolean;
   readonly webdriverPort: number;
   readonly useSelenium: boolean;
+  readonly skipTypecheck: boolean;
 }
 
 export type BedrockManualSettings = BedrockSettings;