@adonisjs/assembler 6.1.3-4 → 6.1.3-6

package/src/test_runner.ts

@@ -0,0 +1,339 @@
+/*
+ * @adonisjs/assembler
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import picomatch from 'picomatch'
+import type tsStatic from 'typescript'
+import { type ExecaChildProcess } from 'execa'
+import { cliui, type Logger } from '@poppinss/cliui'
+import type { Watcher } from '@poppinss/chokidar-ts'
+
+import type { TestRunnerOptions } from './types.js'
+import { AssetsDevServer } from './assets_dev_server.js'
+import { getPort, isDotEnvFile, runNode, watch } from './helpers.js'
+
+/**
+ * Instance of CLIUI
+ */
+const ui = cliui()
+
+/**
+ * Exposes the API to start the development. Optionally, the watch API can be
+ * used to watch for file changes and restart the development server.
+ *
+ * The Dev server performs the following actions
+ *
+ * - Assigns a random PORT, when PORT inside .env file is in use
+ * - Uses tsconfig.json file to collect a list of files to watch.
+ * - Uses metaFiles from .adonisrc.json file to collect a list of files to watch.
+ * - Restart HTTP server on every file change.
+ */
+export class TestRunner {
+  #cwd: URL
+  #logger = ui.logger
+  #options: TestRunnerOptions
+  #scriptFile: string = 'bin/test.js'
+  #isMetaFile: picomatch.Matcher
+  #isTestFile: picomatch.Matcher
+
+  /**
+   * In watch mode, after a file is changed, we wait for the current
+   * set of tests to finish before triggering a re-run. Therefore,
+   * we use this flag to know if we are already busy in running
+   * tests and ignore file-changes.
+   */
+  #isBusy: boolean = false
+
+  #onError?: (error: any) => any
+  #onClose?: (exitCode: number) => any
+
+  #testScript?: ExecaChildProcess<string>
+  #watcher?: ReturnType<Watcher['watch']>
+  #assetsServer?: AssetsDevServer
+
+  /**
+   * Getting reference to colors library from logger
+   */
+  get #colors() {
+    return this.#logger.getColors()
+  }
+
+  constructor(cwd: URL, options: TestRunnerOptions) {
+    this.#cwd = cwd
+    this.#options = options
+    this.#isMetaFile = picomatch((this.#options.metaFiles || []).map(({ pattern }) => pattern))
+    this.#isTestFile = picomatch(
+      this.#options.suites
+        .filter((suite) => {
+          if (this.#options.filters.suites) {
+            this.#options.filters.suites.includes(suite.name)
+          }
+
+          return true
+        })
+        .map((suite) => suite.files)
+        .flat(1)
+    )
+  }
+
+  /**
+   * Converts all known filters to CLI args.
+   *
+   * The following code snippet may seem like repetitive code. But, it
+   * is done intentionally to have visibility around how each filter
+   * is converted to an arg.
+   */
+  #convertFiltersToArgs(filters: TestRunnerOptions['filters']): string[] {
+    const args: string[] = []
+
+    if (filters.suites) {
+      args.push(...filters.suites)
+    }
+
+    if (filters.files) {
+      args.push('--files')
+      args.push(filters.files.join(','))
+    }
+
+    if (filters.groups) {
+      args.push('--groups')
+      args.push(filters.groups.join(','))
+    }
+
+    if (filters.tags) {
+      args.push('--tags')
+      args.push(filters.tags.join(','))
+    }
+
+    if (filters.ignoreTags) {
+      args.push('--ignore-tags')
+      args.push(filters.ignoreTags.join(','))
+    }
+
+    if (filters.tests) {
+      args.push('--ignore-tests')
+      args.push(filters.tests.join(','))
+    }
+
+    if (filters.match) {
+      args.push('--match')
+      args.push(filters.match.join(','))
+    }
+
+    return args
+  }
+
+  /**
+   * Conditionally clear the terminal screen
+   */
+  #clearScreen() {
+    if (this.#options.clearScreen) {
+      process.stdout.write('\u001Bc')
+    }
+  }
+
+  /**
+   * Runs tests
+   */
+  #runTests(port: string, filtersArgs: string[], mode: 'blocking' | 'nonblocking') {
+    this.#isBusy = true
+
+    this.#testScript = runNode(this.#cwd, {
+      script: this.#scriptFile,
+      env: { PORT: port, ...this.#options.env },
+      nodeArgs: this.#options.nodeArgs,
+      scriptArgs: filtersArgs.concat(this.#options.scriptArgs),
+    })
+
+    this.#testScript
+      .then((result) => {
+        if (mode === 'nonblocking') {
+          this.#onClose?.(result.exitCode)
+          this.#watcher?.close()
+          this.#assetsServer?.stop()
+        }
+      })
+      .catch((error) => {
+        this.#logger.warning(`unable to run test script "${this.#scriptFile}"`)
+        this.#logger.fatal(error)
+        this.#onError?.(error)
+        this.#watcher?.close()
+        this.#assetsServer?.stop()
+      })
+      .finally(() => {
+        this.#isBusy = false
+      })
+  }
+
+  /**
+   * Starts the assets server
+   */
+  #startAssetsServer() {
+    this.#assetsServer = new AssetsDevServer(this.#cwd, this.#options.assets)
+    this.#assetsServer.setLogger(this.#logger)
+    this.#assetsServer.start()
+  }
+
+  /**
+   * Handles a non TypeScript file change
+   */
+  #handleFileChange(action: string, port: string, filters: string[], relativePath: string) {
+    if (this.#isBusy) {
+      return
+    }
+
+    if (isDotEnvFile(relativePath) || this.#isMetaFile(relativePath)) {
+      this.#clearScreen()
+      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+      this.#runTests(port, filters, 'blocking')
+    }
+  }
+
+  /**
+   * Handles TypeScript source file change
+   */
+  #handleSourceFileChange(action: string, port: string, filters: string[], relativePath: string) {
+    if (this.#isBusy) {
+      return
+    }
+
+    this.#clearScreen()
+    this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+
+    /**
+     * If changed file is a test file after considering the initial filters,
+     * then only run that file
+     */
+    if (this.#isTestFile(relativePath)) {
+      this.#runTests(
+        port,
+        this.#convertFiltersToArgs({
+          ...this.#options.filters,
+          files: [relativePath],
+        }),
+        'blocking'
+      )
+      return
+    }
+
+    this.#runTests(port, filters, 'blocking')
+  }
+
+  /**
+   * Set a custom CLI UI logger
+   */
+  setLogger(logger: Logger) {
+    this.#logger = logger
+    this.#assetsServer?.setLogger(logger)
+    return this
+  }
+
+  /**
+   * Add listener to get notified when dev server is
+   * closed
+   */
+  onClose(callback: (exitCode: number) => any): this {
+    this.#onClose = callback
+    return this
+  }
+
+  /**
+   * Add listener to get notified when dev server exists
+   * with an error
+   */
+  onError(callback: (error: any) => any): this {
+    this.#onError = callback
+    return this
+  }
+
+  /**
+   * Runs tests
+   */
+  async run() {
+    const port = String(await getPort(this.#cwd))
+    const initialFilters = this.#convertFiltersToArgs(this.#options.filters)
+
+    this.#clearScreen()
+    this.#startAssetsServer()
+
+    this.#logger.info('booting application to run tests...')
+    this.#runTests(port, initialFilters, 'nonblocking')
+  }
+
+  /**
+   * Run tests in watch mode
+   */
+  async runAndWatch(ts: typeof tsStatic, options?: { poll: boolean }) {
+    const port = String(await getPort(this.#cwd))
+    const initialFilters = this.#convertFiltersToArgs(this.#options.filters)
+
+    this.#clearScreen()
+    this.#startAssetsServer()
+
+    this.#logger.info('booting application to run tests...')
+    this.#runTests(port, initialFilters, 'blocking')
+
+    /**
+     * Create watcher using tsconfig.json file
+     */
+    const output = watch(this.#cwd, ts, options || {})
+    if (!output) {
+      this.#onClose?.(1)
+      return
+    }
+
+    /**
+     * Storing reference to watcher, so that we can close it
+     * when HTTP server exists with error
+     */
+    this.#watcher = output.chokidar
+
+    /**
+     * Notify the watcher is ready
+     */
+    output.watcher.on('watcher:ready', () => {
+      this.#logger.info('watching file system for changes...')
+    })
+
+    /**
+     * Cleanup when watcher dies
+     */
+    output.chokidar.on('error', (error) => {
+      this.#logger.warning('file system watcher failure')
+      this.#logger.fatal(error)
+      this.#onError?.(error)
+      output.chokidar.close()
+    })
+
+    /**
+     * Changes in TypeScript source file
+     */
+    output.watcher.on('source:add', ({ relativePath }) =>
+      this.#handleSourceFileChange('add', port, initialFilters, relativePath)
+    )
+    output.watcher.on('source:change', ({ relativePath }) =>
+      this.#handleSourceFileChange('update', port, initialFilters, relativePath)
+    )
+    output.watcher.on('source:unlink', ({ relativePath }) =>
+      this.#handleSourceFileChange('delete', port, initialFilters, relativePath)
+    )
+
+    /**
+     * Changes in non-TypeScript source files
+     */
+    output.watcher.on('add', ({ relativePath }) =>
+      this.#handleFileChange('add', port, initialFilters, relativePath)
+    )
+    output.watcher.on('change', ({ relativePath }) =>
+      this.#handleFileChange('update', port, initialFilters, relativePath)
+    )
+    output.watcher.on('unlink', ({ relativePath }) =>
+      this.#handleFileChange('delete', port, initialFilters, relativePath)
+    )
+  }
+}

package/src/types.ts

@@ -33,17 +33,27 @@ export type MetaFile = {
   reloadServer: boolean
 }
 
+/**
+ * Test suite defined in ".adonisrc.json" file
+ */
+export type Suite = {
+  files: string[]
+  name: string
+}
+
 /**
  * Options accepted by assets bundler
  */
 export type AssetsBundlerOptions =
   | {
       serve: false
+      args?: string[]
       driver?: string
       cmd?: string
     }
   | {
       serve: true
+      args: string[]
       driver: string
       cmd: string
     }
@@ -60,6 +70,37 @@ export type DevServerOptions = {
   assets?: AssetsBundlerOptions
 }
 
+/**
+ * Options accepted by the test runner
+ */
+export type TestRunnerOptions = {
+  /**
+   * Filter arguments are provided as a key-value
+   * pair, so that we can mutate them (if needed)
+   */
+  filters: Partial<{
+    tests: string[]
+    suites: string[]
+    groups: string[]
+    files: string[]
+    match: string[]
+    tags: string[]
+    ignoreTags: string[]
+  }>
+
+  /**
+   * All other tags are provided as a collection of
+   * arguments
+   */
+  scriptArgs: string[]
+  nodeArgs: string[]
+  clearScreen?: boolean
+  env?: NodeJS.ProcessEnv
+  metaFiles?: MetaFile[]
+  assets?: AssetsBundlerOptions
+  suites: Suite[]
+}
+
 /**
  * Options accepted by the project bundler
  */

package/build/src/parse_config.d.ts

@@ -1,4 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import type tsStatic from 'typescript';
-export declare function parseConfig(cwd: string | URL, ts: typeof tsStatic): tsStatic.ParsedCommandLine | undefined;
-//# sourceMappingURL=parse_config.d.ts.map

package/build/src/parse_config.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse_config.d.ts","sourceRoot":"","sources":["../../src/parse_config.ts"],"names":[],"mappings":";AASA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AAOtC,wBAAgB,WAAW,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,EAAE,EAAE,OAAO,QAAQ,0CAejE"}

package/build/src/parse_config.js

@@ -1,15 +0,0 @@
-import { ConfigParser } from '@poppinss/chokidar-ts';
-export function parseConfig(cwd, ts) {
-    const { config, error } = new ConfigParser(cwd, 'tsconfig.json', ts).parse();
-    if (error) {
-        const compilerHost = ts.createCompilerHost({});
-        console.log(ts.formatDiagnosticsWithColorAndContext([error], compilerHost));
-        return;
-    }
-    if (config.errors.length) {
-        const compilerHost = ts.createCompilerHost({});
-        console.log(ts.formatDiagnosticsWithColorAndContext(config.errors, compilerHost));
-        return;
-    }
-    return config;
-}

package/build/src/run.d.ts

@@ -1,5 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import type { RunOptions } from './types.js';
-export declare function runNode(cwd: string | URL, options: RunOptions): import("execa").ExecaChildProcess<string>;
-export declare function run(cwd: string | URL, options: Omit<RunOptions, 'nodeArgs'>): import("execa").ExecaChildProcess<string>;
-//# sourceMappingURL=run.d.ts.map

package/build/src/run.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"run.d.ts","sourceRoot":"","sources":["../../src/run.ts"],"names":[],"mappings":";AAUA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,YAAY,CAAA;AAkB5C,wBAAgB,OAAO,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,OAAO,EAAE,UAAU,6CAgB7D;AAKD,wBAAgB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,OAAO,EAAE,IAAI,CAAC,UAAU,EAAE,UAAU,CAAC,6CAe3E"}

package/build/src/run.js

@@ -1,37 +0,0 @@
-import { execaNode, execa } from 'execa';
-const DEFAULT_NODE_ARGS = [
-    '--loader=ts-node/esm',
-    '--no-warnings',
-    '--experimental-import-meta-resolve',
-];
-export function runNode(cwd, options) {
-    const childProcess = execaNode(options.script, options.scriptArgs, {
-        nodeOptions: DEFAULT_NODE_ARGS.concat(options.nodeArgs),
-        preferLocal: true,
-        windowsHide: false,
-        localDir: cwd,
-        cwd,
-        buffer: false,
-        stdio: options.stdio || 'inherit',
-        env: {
-            ...(options.stdio === 'pipe' ? { FORCE_COLOR: 'true' } : {}),
-            ...options.env,
-        },
-    });
-    return childProcess;
-}
-export function run(cwd, options) {
-    const childProcess = execa(options.script, options.scriptArgs, {
-        preferLocal: true,
-        windowsHide: false,
-        localDir: cwd,
-        cwd,
-        buffer: false,
-        stdio: options.stdio || 'inherit',
-        env: {
-            ...(options.stdio === 'pipe' ? { FORCE_COLOR: 'true' } : {}),
-            ...options.env,
-        },
-    });
-    return childProcess;
-}

package/build/src/watch.d.ts

@@ -1,9 +0,0 @@
-/// <reference types="node" resolution-mode="require"/>
-import type tsStatic from 'typescript';
-import { Watcher } from '@poppinss/chokidar-ts';
-import type { WatchOptions } from './types.js';
-export declare function watch(cwd: string | URL, ts: typeof tsStatic, options: WatchOptions): {
-    watcher: Watcher;
-    chokidar: import("chokidar").FSWatcher;
-} | undefined;
-//# sourceMappingURL=watch.d.ts.map

package/build/src/watch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"watch.d.ts","sourceRoot":"","sources":["../../src/watch.ts"],"names":[],"mappings":";AASA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AAEtC,OAAO,EAAE,OAAO,EAAE,MAAM,uBAAuB,CAAA;AAE/C,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAM9C,wBAAgB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,EAAE,EAAE,EAAE,OAAO,QAAQ,EAAE,OAAO,EAAE,YAAY;;;cASlF"}

package/build/src/watch.js

@@ -1,12 +0,0 @@
-import { fileURLToPath } from 'node:url';
-import { Watcher } from '@poppinss/chokidar-ts';
-import { parseConfig } from './parse_config.js';
-export function watch(cwd, ts, options) {
-    const config = parseConfig(cwd, ts);
-    if (!config) {
-        return;
-    }
-    const watcher = new Watcher(typeof cwd === 'string' ? cwd : fileURLToPath(cwd), config);
-    const chokidar = watcher.watch(['.'], { usePolling: options.poll });
-    return { watcher, chokidar };
-}

package/src/parse_config.ts

@@ -1,32 +0,0 @@
-/*
- * @adonisjs/assembler
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import type tsStatic from 'typescript'
-import { ConfigParser } from '@poppinss/chokidar-ts'
-
-/**
- * Parses tsconfig.json and prints errors using typescript compiler
- * host
- */
-export function parseConfig(cwd: string | URL, ts: typeof tsStatic) {
-  const { config, error } = new ConfigParser(cwd, 'tsconfig.json', ts).parse()
-  if (error) {
-    const compilerHost = ts.createCompilerHost({})
-    console.log(ts.formatDiagnosticsWithColorAndContext([error], compilerHost))
-    return
-  }
-
-  if (config!.errors.length) {
-    const compilerHost = ts.createCompilerHost({})
-    console.log(ts.formatDiagnosticsWithColorAndContext(config!.errors, compilerHost))
-    return
-  }
-
-  return config
-}

package/src/run.ts

@@ -1,65 +0,0 @@
-/*
- * @adonisjs/assembler
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import { execaNode, execa } from 'execa'
-import type { RunOptions } from './types.js'
-
-/**
- * Default set of args to pass in order to run TypeScript
- * source
- */
-const DEFAULT_NODE_ARGS = [
-  // Use ts-node/esm loader. The project must install it
-  '--loader=ts-node/esm',
-  // Disable annonying warnings
-  '--no-warnings',
-  // Enable expiremental meta resolve for cases where someone uses magic import string
-  '--experimental-import-meta-resolve',
-]
-
-/**
- * Runs a Node.js script as a child process and inherits the stdio streams
- */
-export function runNode(cwd: string | URL, options: RunOptions) {
-  const childProcess = execaNode(options.script, options.scriptArgs, {
-    nodeOptions: DEFAULT_NODE_ARGS.concat(options.nodeArgs),
-    preferLocal: true,
-    windowsHide: false,
-    localDir: cwd,
-    cwd,
-    buffer: false,
-    stdio: options.stdio || 'inherit',
-    env: {
-      ...(options.stdio === 'pipe' ? { FORCE_COLOR: 'true' } : {}),
-      ...options.env,
-    },
-  })
-
-  return childProcess
-}
-
-/**
- * Runs a script as a child process and inherits the stdio streams
- */
-export function run(cwd: string | URL, options: Omit<RunOptions, 'nodeArgs'>) {
-  const childProcess = execa(options.script, options.scriptArgs, {
-    preferLocal: true,
-    windowsHide: false,
-    localDir: cwd,
-    cwd,
-    buffer: false,
-    stdio: options.stdio || 'inherit',
-    env: {
-      ...(options.stdio === 'pipe' ? { FORCE_COLOR: 'true' } : {}),
-      ...options.env,
-    },
-  })
-
-  return childProcess
-}

package/src/watch.ts

@@ -1,29 +0,0 @@
-/*
- * @adonisjs/assembler
- *
- * (c) AdonisJS
- *
- * For the full copyright and license information, please view the LICENSE
- * file that was distributed with this source code.
- */
-
-import type tsStatic from 'typescript'
-import { fileURLToPath } from 'node:url'
-import { Watcher } from '@poppinss/chokidar-ts'
-
-import type { WatchOptions } from './types.js'
-import { parseConfig } from './parse_config.js'
-
-/**
- * Watches the file system using tsconfig file
- */
-export function watch(cwd: string | URL, ts: typeof tsStatic, options: WatchOptions) {
-  const config = parseConfig(cwd, ts)
-  if (!config) {
-    return
-  }
-
-  const watcher = new Watcher(typeof cwd === 'string' ? cwd : fileURLToPath(cwd), config!)
-  const chokidar = watcher.watch(['.'], { usePolling: options.poll })
-  return { watcher, chokidar }
-}