@adonisjs/assembler 6.1.3-3 → 6.1.3-5

package/src/helpers.ts

@@ -0,0 +1,162 @@
+/*
+ * @adonisjs/assembler
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import getRandomPort from 'get-port'
+import type tsStatic from 'typescript'
+import { fileURLToPath } from 'node:url'
+import { execaNode, execa } from 'execa'
+import { EnvLoader, EnvParser } from '@adonisjs/env'
+import { ConfigParser, Watcher } from '@poppinss/chokidar-ts'
+
+import type { RunOptions, WatchOptions } from './types.js'
+
+/**
+ * Default set of args to pass in order to run TypeScript
+ * source. Used by "run" and "runNode" scripts
+ */
+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',
+]
+
+/**
+ * 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
+}
+
+/**
+ * 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
+}
+
+/**
+ * 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 }
+}
+
+/**
+ * Check if file is an .env file
+ */
+export function isDotEnvFile(filePath: string) {
+  if (filePath === '.env') {
+    return true
+  }
+
+  return filePath.includes('.env.')
+}
+
+/**
+ * Check if file is .adonisrc.json file
+ */
+export function isRcFile(filePath: string) {
+  return filePath === '.adonisrc.json'
+}
+
+/**
+ * Returns the port to use after inspect the dot-env files inside
+ * a given directory.
+ *
+ * A random port is used when the specified port is in use. Following
+ * is the logic for finding a specified port.
+ *
+ * - The "process.env.PORT" value is used if exists.
+ * - The dot-env files are loaded using the "EnvLoader" and the PORT
+ *   value is by iterating over all the loaded files. The iteration
+ *   stops after first find.
+ */
+export async function getPort(cwd: URL): Promise<number> {
+  /**
+   * Use existing port if exists
+   */
+  if (process.env.PORT) {
+    return getRandomPort({ port: Number(process.env.PORT) })
+  }
+
+  /**
+   * Loop over files and use the port from their contents. Stops
+   * after first match
+   */
+  const files = await new EnvLoader(cwd).load()
+  for (let file of files) {
+    const envVariables = new EnvParser(file.contents).parse()
+    if (envVariables.PORT) {
+      return getRandomPort({ port: Number(envVariables.PORT) })
+    }
+  }
+
+  /**
+   * Use 3333 as the port
+   */
+  return getRandomPort({ port: 3333 })
+}

package/src/test_runner.ts

@@ -0,0 +1,338 @@
+/*
+ * @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.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

@@ -0,0 +1,110 @@
+/*
+ * @adonisjs/assembler
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+/**
+ * Options needed to run a script file
+ */
+export type RunOptions = {
+  script: string
+  scriptArgs: string[]
+  nodeArgs: string[]
+  stdio?: 'pipe' | 'inherit'
+  env?: NodeJS.ProcessEnv
+}
+
+/**
+ * Watcher options
+ */
+export type WatchOptions = {
+  poll?: boolean
+}
+
+/**
+ * Meta file config defined in ".adonisrc.json" file
+ */
+export type MetaFile = {
+  pattern: string
+  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
+    }
+
+/**
+ * Options accepted by the dev server
+ */
+export type DevServerOptions = {
+  scriptArgs: string[]
+  nodeArgs: string[]
+  clearScreen?: boolean
+  env?: NodeJS.ProcessEnv
+  metaFiles?: MetaFile[]
+  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
+ */
+export type BundlerOptions = {
+  metaFiles?: MetaFile[]
+  assets?: AssetsBundlerOptions
+}

package/build/src/parse_config.d.ts

@@ -1,3 +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;

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,4 +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>;

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,8 +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;

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 };
-}