@adonisjs/assembler 6.1.3-1 → 6.1.3-10

package/build/src/test_runner.js

@@ -0,0 +1,314 @@
+/*
+ * @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 { cliui } from '@poppinss/cliui';
+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;
+    #logger = ui.logger;
+    #options;
+    #scriptFile = 'bin/test.js';
+    #isMetaFile;
+    #isTestFile;
+    #scriptArgs;
+    #initialFiltersArgs;
+    /**
+     * 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 = false;
+    #onError;
+    #onClose;
+    #testScript;
+    #watcher;
+    #assetsServer;
+    /**
+     * Getting reference to colors library from logger
+     */
+    get #colors() {
+        return this.#logger.getColors();
+    }
+    constructor(cwd, options) {
+        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) {
+                return this.#options.filters.suites.includes(suite.name);
+            }
+            return true;
+        })
+            .map((suite) => suite.files)
+            .flat(1));
+        this.#scriptArgs = this.#convertOptionsToArgs();
+        this.#initialFiltersArgs = this.#convertFiltersToArgs(this.#options.filters);
+    }
+    /**
+     * Converts options to CLI args
+     */
+    #convertOptionsToArgs() {
+        const args = [];
+        if (this.#options.reporters) {
+            args.push('--reporters');
+            args.push(this.#options.reporters.join(','));
+        }
+        if (this.#options.timeout !== undefined) {
+            args.push('--timeout');
+            args.push(String(this.#options.timeout));
+        }
+        if (this.#options.failed) {
+            args.push('--failed');
+        }
+        if (this.#options.retries !== undefined) {
+            args.push('--timeout');
+            args.push(String(this.#options.retries));
+        }
+        return args;
+    }
+    /**
+     * 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) {
+        const args = [];
+        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(','));
+        }
+        return args;
+    }
+    /**
+     * Conditionally clear the terminal screen
+     */
+    #clearScreen() {
+        if (this.#options.clearScreen) {
+            process.stdout.write('\u001Bc');
+        }
+    }
+    /**
+     * Runs tests
+     */
+    #runTests(port, mode, filters) {
+        this.#isBusy = true;
+        const scriptArgs = filters
+            ? this.#convertFiltersToArgs(filters).concat(this.#scriptArgs)
+            : this.#initialFiltersArgs.concat(this.#scriptArgs);
+        this.#testScript = runNode(this.#cwd, {
+            script: this.#scriptFile,
+            env: { PORT: port, ...this.#options.env },
+            nodeArgs: this.#options.nodeArgs,
+            scriptArgs,
+        });
+        this.#testScript
+            .then((result) => {
+            if (mode === 'nonblocking') {
+                this.#onClose?.(result.exitCode);
+                this.close();
+            }
+        })
+            .catch((error) => {
+            if (mode === 'nonblocking') {
+                this.#onError?.(error);
+                this.close();
+            }
+        })
+            .finally(() => {
+            this.#isBusy = false;
+        });
+    }
+    /**
+     * Restarts the HTTP server
+     */
+    #rerunTests(port, filters) {
+        if (this.#testScript) {
+            this.#testScript.removeAllListeners();
+            this.#testScript.kill('SIGKILL');
+        }
+        this.#runTests(port, 'blocking', filters);
+    }
+    /**
+     * 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, port, relativePath) {
+        if (this.#isBusy) {
+            return;
+        }
+        if (isDotEnvFile(relativePath) || this.#isMetaFile(relativePath)) {
+            this.#clearScreen();
+            this.#logger.log(`${this.#colors.green(action)} ${relativePath}`);
+            this.#rerunTests(port);
+        }
+    }
+    /**
+     * Handles TypeScript source file change
+     */
+    #handleSourceFileChange(action, port, relativePath) {
+        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.#rerunTests(port, {
+                ...this.#options.filters,
+                files: [relativePath],
+            });
+            return;
+        }
+        this.#rerunTests(port);
+    }
+    /**
+     * Set a custom CLI UI logger
+     */
+    setLogger(logger) {
+        this.#logger = logger;
+        this.#assetsServer?.setLogger(logger);
+        return this;
+    }
+    /**
+     * Add listener to get notified when dev server is
+     * closed
+     */
+    onClose(callback) {
+        this.#onClose = callback;
+        return this;
+    }
+    /**
+     * Add listener to get notified when dev server exists
+     * with an error
+     */
+    onError(callback) {
+        this.#onError = callback;
+        return this;
+    }
+    /**
+     * Close watchers and running child processes
+     */
+    async close() {
+        await this.#watcher?.close();
+        this.#assetsServer?.stop();
+        if (this.#testScript) {
+            this.#testScript.removeAllListeners();
+            this.#testScript.kill('SIGKILL');
+        }
+    }
+    /**
+     * Runs tests
+     */
+    async run() {
+        const port = String(await getPort(this.#cwd));
+        this.#clearScreen();
+        this.#startAssetsServer();
+        this.#logger.info('booting application to run tests...');
+        this.#runTests(port, 'nonblocking');
+    }
+    /**
+     * Run tests in watch mode
+     */
+    async runAndWatch(ts, options) {
+        const port = String(await getPort(this.#cwd));
+        this.#clearScreen();
+        this.#startAssetsServer();
+        this.#logger.info('booting application to run tests...');
+        this.#runTests(port, '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, relativePath));
+        output.watcher.on('source:change', ({ relativePath }) => this.#handleSourceFileChange('update', port, relativePath));
+        output.watcher.on('source:unlink', ({ relativePath }) => this.#handleSourceFileChange('delete', port, relativePath));
+        /**
+         * Changes in non-TypeScript source files
+         */
+        output.watcher.on('add', ({ relativePath }) => this.#handleFileChange('add', port, relativePath));
+        output.watcher.on('change', ({ relativePath }) => this.#handleFileChange('update', port, relativePath));
+        output.watcher.on('unlink', ({ relativePath }) => this.#handleFileChange('delete', port, relativePath));
+    }
+}

package/build/src/types.d.ts

@@ -1,4 +1,7 @@
 /// <reference types="node" resolution-mode="require"/>
+/**
+ * Options needed to run a script file
+ */
 export type RunOptions = {
     script: string;
     scriptArgs: string[];
@@ -6,22 +9,43 @@ export type RunOptions = {
     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 | 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[];
@@ -30,6 +54,41 @@ export type DevServerOptions = {
     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[];
+        tags: string[];
+        ignoreTags: string[];
+    }>;
+    reporters?: string[];
+    timeout?: number;
+    retries?: number;
+    failed?: boolean;
+    /**
+     * 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/types.js

@@ -1 +1,9 @@
+/*
+ * @adonisjs/assembler
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adonisjs/assembler",
-  "version": "6.1.3-1",
+  "version": "6.1.3-10",
   "description": "Provides utilities to run AdonisJS development server and build project for production",
   "main": "build/index.js",
   "type": "module",
@@ -13,11 +13,15 @@
     ".": "./build/index.js",
     "./types": "./build/src/types.js"
   },
+  "engines": {
+    "node": ">=18.16.0"
+  },
   "scripts": {
     "pretest": "npm run lint",
-    "test": "cross-env NODE_DEBUG=chokidar:ts c8 npm run vscode:test",
+    "test": "cross-env NODE_DEBUG=chokidar:ts c8 npm run quick:test",
     "lint": "eslint . --ext=.ts",
     "clean": "del-cli build",
+    "typecheck": "tsc --noEmit",
     "compile": "npm run lint && npm run clean && tsc",
     "build": "npm run compile",
     "release": "np",
@@ -25,7 +29,7 @@
     "sync-labels": "github-label-sync --labels .github/labels.json adonisjs/assembler",
     "format": "prettier --write .",
     "prepublishOnly": "npm run build",
-    "vscode:test": "node --loader=ts-node/esm bin/test.ts"
+    "quick:test": "node --loader=ts-node/esm bin/test.ts"
   },
   "keywords": [
     "adonisjs",
@@ -35,42 +39,38 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@commitlint/cli": "^17.4.4",
-    "@commitlint/config-conventional": "^17.4.4",
-    "@japa/assert": "^1.4.1",
-    "@japa/file-system": "^1.0.1",
-    "@japa/run-failed-tests": "^1.1.1",
-    "@japa/runner": "^2.5.1",
-    "@japa/spec-reporter": "^1.3.3",
-    "@swc/core": "^1.3.39",
-    "@types/node": "^18.15.0",
-    "c8": "^7.13.0",
+    "@adonisjs/eslint-config": "^1.1.7",
+    "@adonisjs/prettier-config": "^1.1.7",
+    "@adonisjs/tsconfig": "^1.1.7",
+    "@commitlint/cli": "^17.6.6",
+    "@commitlint/config-conventional": "^17.6.6",
+    "@japa/assert": "^2.0.0-1",
+    "@japa/file-system": "^2.0.0-1",
+    "@japa/runner": "^3.0.0-3",
+    "@swc/core": "^1.3.67",
+    "@types/node": "^20.4.1",
+    "@types/picomatch": "^2.3.0",
+    "c8": "^8.0.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
-    "eslint": "^8.36.0",
-    "eslint-config-prettier": "^8.7.0",
-    "eslint-plugin-adonis": "^3.0.3",
-    "eslint-plugin-prettier": "^4.2.1",
+    "eslint": "^8.44.0",
     "github-label-sync": "^2.3.1",
     "husky": "^8.0.3",
-    "np": "^7.6.3",
-    "p-event": "^5.0.1",
-    "prettier": "^2.8.4",
+    "np": "^8.0.4",
+    "p-event": "^6.0.0",
+    "prettier": "^2.8.8",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.5"
+    "typescript": "^5.1.6"
   },
   "dependencies": {
-    "@adonisjs/env": "^4.2.0-0",
-    "@poppinss/chokidar-ts": "^4.1.0-1",
-    "@poppinss/cliui": "^6.1.1-1",
-    "@types/fs-extra": "^11.0.1",
-    "@types/picomatch": "^2.3.0",
-    "cpy": "^9.0.1",
+    "@adonisjs/env": "^4.2.0-3",
+    "@poppinss/chokidar-ts": "^4.1.0-4",
+    "@poppinss/cliui": "^6.1.1-3",
+    "cpy": "^8.1.2",
     "execa": "^7.0.0",
-    "fs-extra": "^11.1.0",
-    "get-port": "^6.1.2",
+    "get-port": "^7.0.0",
     "picomatch": "^2.3.1",
-    "slash": "^5.0.0"
+    "slash": "^5.1.0"
   },
   "peerDependencies": {
     "typescript": "^4.0.0 || ^5.0.0"
@@ -83,36 +83,6 @@
     "url": "https://github.com/adonisjs/assembler/issues"
   },
   "homepage": "https://github.com/adonisjs/assembler#readme",
-  "eslintConfig": {
-    "extends": [
-      "plugin:adonis/typescriptPackage",
-      "prettier"
-    ],
-    "plugins": [
-      "prettier"
-    ],
-    "rules": {
-      "prettier/prettier": [
-        "error",
-        {
-          "endOfLine": "auto"
-        }
-      ]
-    }
-  },
-  "eslintIgnore": [
-    "build"
-  ],
-  "prettier": {
-    "trailingComma": "es5",
-    "semi": false,
-    "singleQuote": true,
-    "useTabs": false,
-    "quoteProps": "consistent",
-    "bracketSpacing": true,
-    "arrowParens": "always",
-    "printWidth": 100
-  },
   "commitlint": {
     "extends": [
       "@commitlint/config-conventional"
@@ -136,7 +106,14 @@
     "exclude": [
       "tests/**",
       "build/**",
-      "examples/**"
+      "examples/**",
+      "src/dev_server.ts",
+      "src/test_runner.ts",
+      "src/assets_dev_server.ts"
     ]
-  }
+  },
+  "eslintConfig": {
+    "extends": "@adonisjs/eslint-config/package"
+  },
+  "prettier": "@adonisjs/prettier-config"
 }

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