@adonisjs/assembler 5.9.5 → 6.1.0-0

package/LICENSE.md

@@ -1,6 +1,6 @@
 # The MIT License
 
-Copyright 2022 Harminder Virk, contributors
+Copyright (c) 2023 AdonisJS Framework
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the 'Software'), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -1,49 +1,36 @@
-<div align="center">
-  <img src="https://res.cloudinary.com/adonisjs/image/upload/q_100/v1558612869/adonis-readme_zscycu.jpg" width="600px">
-</div>
+# @adonisjs/assembler
 
 <br />
 
-<div align="center">
-  <h3> Core Commands for building AdonisJS projects </h3>
-  <p>
-    Assembler contains a set of core commands to <strong>build and serve the AdonisJS typescript project</strong>, along with scaffolding <code>make</code> commands.
-  </p>
-</div>
+[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![synk-image]][synk-url]
 
-<br />
+## Introduction
+Assembler exports the API for starting the **AdonisJS development server**, **building project for production** and **running tests** in watch mode. Assembler must be used during development only.
+
+## Official Documentation
+The documentation is available on the official website
+
+## Contributing
+One of the primary goals of AdonisJS is to have a vibrant community of users and contributors who believes in the principles of the framework.
+
+We encourage you to read the [contribution guide](https://github.com/adonisjs/.github/blob/main/docs/CONTRIBUTING.md) before contributing to the framework.
 
-<div align="center">
-
-[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] [![synk-image]][synk-url]
-
-</div>
-
-<div align="center">
-  <h3>
-    <a href="https://adonisjs.com">
-      Website
-    </a>
-    <span> | </span>
-    <a href="https://docs.adonisjs.com/guides/installation">
-      Guides
-    </a>
-    <span> | </span>
-    <a href="CONTRIBUTING.md">
-      Contributing
-    </a>
-  </h3>
-</div>
-
-<div align="center">
-  <sub>Built with ❤︎ by <a href="https://twitter.com/AmanVirk1">Harminder Virk</a>
-</div>
-
-[gh-workflow-image]: https://img.shields.io/github/workflow/status/adonisjs/assembler/test?style=for-the-badge
+## Code of Conduct
+In order to ensure that the AdonisJS community is welcoming to all, please review and abide by the [Code of Conduct](https://github.com/adonisjs/.github/blob/main/docs/CODE_OF_CONDUCT.md).
+
+## License
+AdonisJS Assembler is open-sourced software licensed under the [MIT license](LICENSE.md).
+
+[gh-workflow-image]: https://img.shields.io/github/actions/workflow/status/adonisjs/assembler/test.yml?style=for-the-badge
 [gh-workflow-url]: https://github.com/adonisjs/assembler/actions/workflows/test.yml "Github action"
 
 [npm-image]: https://img.shields.io/npm/v/@adonisjs/assembler/latest.svg?style=for-the-badge&logo=npm
 [npm-url]: https://npmjs.org/package/@adonisjs/assembler/v/latest "npm"
 
+[typescript-image]: https://img.shields.io/badge/Typescript-294E80.svg?style=for-the-badge&logo=typescript
+
+[license-url]: LICENSE.md
+[license-image]: https://img.shields.io/github/license/adonisjs/ace?style=for-the-badge
+
 [synk-image]: https://img.shields.io/snyk/vulnerabilities/github/adonisjs/assembler?label=Synk%20Vulnerabilities&style=for-the-badge
 [synk-url]: https://snyk.io/test/github/adonisjs/assembler?targetFile=package.json "synk"

package/build/index.d.ts

@@ -0,0 +1,2 @@
+export { Bundler } from './src/bundler.js';
+export { DevServer } from './src/dev_server.js';

package/build/index.js

@@ -0,0 +1,2 @@
+export { Bundler } from './src/bundler.js';
+export { DevServer } from './src/dev_server.js';

package/build/src/bundler.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" resolution-mode="require"/>
+import type tsStatic from 'typescript';
+import { type Logger } from '@poppinss/cliui';
+import type { BundlerOptions } from './types.js';
+export declare class Bundler {
+    #private;
+    constructor(cwd: URL, ts: typeof tsStatic, options: BundlerOptions);
+    setLogger(logger: Logger): this;
+    bundle(stopOnError?: boolean, client?: 'npm' | 'yarn' | 'pnpm'): Promise<boolean>;
+}

package/build/src/bundler.js

@@ -0,0 +1,143 @@
+import fs from 'fs-extra';
+import slash from 'slash';
+import copyfiles from 'cpy';
+import { execa } from 'execa';
+import { join, relative } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { ConfigParser } from '@poppinss/chokidar-ts';
+import { cliui } from '@poppinss/cliui';
+const ui = cliui();
+export class Bundler {
+    #cwd;
+    #cwdPath;
+    #ts;
+    #logger = ui.logger;
+    #options;
+    get #colors() {
+        return this.#logger.getColors();
+    }
+    constructor(cwd, ts, options) {
+        this.#cwd = cwd;
+        this.#cwdPath = fileURLToPath(this.#cwd);
+        this.#ts = ts;
+        this.#options = options;
+    }
+    #getRelativeName(filePath) {
+        return slash(relative(this.#cwdPath, filePath));
+    }
+    async #cleanupBuildDirectory(outDir) {
+        await fs.remove(outDir);
+    }
+    async #runTsc(outDir) {
+        try {
+            await execa('tsc', ['--outDir', outDir], {
+                cwd: this.#cwd,
+                preferLocal: true,
+                localDir: this.#cwd,
+                windowsHide: false,
+                buffer: false,
+                stdio: 'inherit',
+            });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    async #copyFiles(files, outDir) {
+        try {
+            await copyfiles(files, outDir, { cwd: this.#cwdPath });
+        }
+        catch (error) {
+            if (!error.message.includes("the file doesn't exist")) {
+                throw error;
+            }
+        }
+    }
+    async #copyMetaFiles(outDir, additionalFilesToCopy) {
+        const metaFiles = (this.#options.metaFiles || [])
+            .map((file) => file.pattern)
+            .concat(additionalFilesToCopy);
+        await this.#copyFiles(metaFiles, outDir);
+    }
+    async #copyAdonisRcFile(outDir) {
+        const existingContents = await fs.readJSON(join(this.#cwdPath, '.adonisrc.json'));
+        const compiledContents = Object.assign({}, existingContents, {
+            typescript: false,
+            lastCompiledAt: new Date().toISOString(),
+        });
+        await fs.outputJSON(join(outDir, '.adonisrc.json'), compiledContents, { spaces: 2 });
+    }
+    #getClientLockFile(client) {
+        switch (client) {
+            case 'npm':
+                return 'package-lock.json';
+            case 'yarn':
+                return 'yarn.lock';
+            case 'pnpm':
+                return 'pnpm-lock.yaml';
+        }
+    }
+    #getClientInstallCommand(client) {
+        switch (client) {
+            case 'npm':
+                return 'npm ci --omit="dev"';
+            case 'yarn':
+                return 'yarn install --production';
+            case 'pnpm':
+                return 'pnpm i --prod';
+        }
+    }
+    setLogger(logger) {
+        this.#logger = logger;
+        return this;
+    }
+    async bundle(stopOnError = true, client = 'npm') {
+        const { config, error } = new ConfigParser(this.#cwd, 'tsconfig.json', this.#ts).parse();
+        if (error) {
+            const compilerHost = this.#ts.createCompilerHost({});
+            this.#logger.logError(this.#ts.formatDiagnosticsWithColorAndContext([error], compilerHost));
+            return false;
+        }
+        if (config.errors.length) {
+            const compilerHost = this.#ts.createCompilerHost({});
+            this.#logger.logError(this.#ts.formatDiagnosticsWithColorAndContext(config.errors, compilerHost));
+            return false;
+        }
+        if (!config) {
+            return false;
+        }
+        const outDir = config.options.outDir || fileURLToPath(new URL('build/', this.#cwd));
+        this.#logger.info('cleaning up output directory', { suffix: this.#getRelativeName(outDir) });
+        await this.#cleanupBuildDirectory(outDir);
+        this.#logger.info('compiling typescript source', { suffix: 'tsc' });
+        const buildCompleted = await this.#runTsc(outDir);
+        await this.#copyFiles(['ace.js'], outDir);
+        if (!buildCompleted && stopOnError) {
+            await this.#cleanupBuildDirectory(outDir);
+            const instructions = ui
+                .sticker()
+                .fullScreen()
+                .drawBorder((borderChar, colors) => colors.red(borderChar));
+            instructions.add(this.#colors.red('Cannot complete the build process as there are TypeScript errors.'));
+            instructions.add(this.#colors.red('Use "--ignore-ts-errors" flag to ignore TypeScript errors and continue the build.'));
+            this.#logger.logError(instructions.prepare());
+            return false;
+        }
+        const pkgFiles = ['package.json', this.#getClientLockFile(client)];
+        this.#logger.info('copying meta files to the output directory');
+        await this.#copyMetaFiles(outDir, pkgFiles);
+        this.#logger.info('copying .adonisrc.json file to the output directory');
+        await this.#copyAdonisRcFile(outDir);
+        this.#logger.success('build completed');
+        this.#logger.log('');
+        ui.instructions()
+            .useRenderer(this.#logger.getRenderer())
+            .heading('Run the following commands to start the server in production')
+            .add(this.#colors.cyan(`cd ${this.#getRelativeName(outDir)}`))
+            .add(this.#colors.cyan(this.#getClientInstallCommand(client)))
+            .add(this.#colors.cyan('node bin/server.js'))
+            .render();
+        return true;
+    }
+}

package/build/src/dev_server.d.ts

@@ -0,0 +1,15 @@
+/// <reference types="node" resolution-mode="require"/>
+import type tsStatic from 'typescript';
+import { type Logger } from '@poppinss/cliui';
+import type { DevServerOptions } from './types.js';
+export declare class DevServer {
+    #private;
+    constructor(cwd: URL, options: DevServerOptions);
+    setLogger(logger: Logger): this;
+    onClose(callback: (exitCode: number) => any): this;
+    onError(callback: (error: any) => any): this;
+    start(): Promise<void>;
+    startAndWatch(ts: typeof tsStatic, options?: {
+        poll: boolean;
+    }): Promise<void>;
+}

package/build/src/dev_server.js

@@ -0,0 +1,214 @@
+import getPort from 'get-port';
+import picomatch from 'picomatch';
+import { cliui } from '@poppinss/cliui';
+import { EnvLoader, EnvParser } from '@adonisjs/env';
+import { run } from './run.js';
+import { watch } from './watch.js';
+const ui = cliui();
+export class DevServer {
+    #cwd;
+    #logger = ui.logger;
+    #options;
+    #isWatching = false;
+    #scriptFile = 'bin/server.js';
+    #httpServerProcess;
+    #isMetaFileWithReloadsEnabled;
+    #isMetaFileWithReloadsDisabled;
+    #watcher;
+    #onError;
+    #onClose;
+    get #colors() {
+        return this.#logger.getColors();
+    }
+    constructor(cwd, options) {
+        this.#cwd = cwd;
+        this.#options = options;
+        this.#isMetaFileWithReloadsEnabled = picomatch((this.#options.metaFiles || [])
+            .filter(({ reloadServer }) => reloadServer === true)
+            .map(({ pattern }) => pattern));
+        this.#isMetaFileWithReloadsDisabled = picomatch((this.#options.metaFiles || [])
+            .filter(({ reloadServer }) => reloadServer !== true)
+            .map(({ pattern }) => pattern));
+    }
+    #isDotEnvFile(filePath) {
+        if (filePath === '.env') {
+            return true;
+        }
+        return filePath.includes('.env.');
+    }
+    #isRcFile(filePath) {
+        return filePath === '.adonisrc.json';
+    }
+    #isAdonisJSReadyMessage(message) {
+        return (message !== null &&
+            typeof message === 'object' &&
+            'isAdonisJS' in message &&
+            'environment' in message &&
+            message.environment === 'web');
+    }
+    #clearScreen() {
+        if (this.#options.clearScreen) {
+            process.stdout.write('\u001Bc');
+        }
+    }
+    async #getPort() {
+        if (process.env.PORT) {
+            return getPort({ port: Number(process.env.PORT) });
+        }
+        const files = await new EnvLoader(this.#cwd).load();
+        for (let file of files) {
+            const envVariables = new EnvParser(file.contents).parse();
+            if (envVariables.PORT) {
+                return getPort({ port: Number(envVariables.PORT) });
+            }
+        }
+        return getPort({ port: 3333 });
+    }
+    #startHTTPServer(port, mode) {
+        this.#httpServerProcess = run(this.#cwd, {
+            script: this.#scriptFile,
+            env: { PORT: port, ...this.#options.env },
+            nodeArgs: this.#options.nodeArgs,
+            scriptArgs: this.#options.scriptArgs,
+        });
+        this.#httpServerProcess.on('message', (message) => {
+            if (this.#isAdonisJSReadyMessage(message)) {
+                ui.sticker()
+                    .useColors(this.#colors)
+                    .useRenderer(this.#logger.getRenderer())
+                    .add(`Server address: ${this.#colors.cyan(`http://${message.host}:${message.port}`)}`)
+                    .add(`File system watcher: ${this.#colors.cyan(`${this.#isWatching ? 'enabled' : 'disabled'}`)}`)
+                    .render();
+            }
+        });
+        this.#httpServerProcess
+            .then((result) => {
+            this.#logger.warning(`underlying HTTP server closed with status code "${result.exitCode}"`);
+            if (mode === 'nonblocking') {
+                this.#onClose?.(result.exitCode);
+                this.#watcher?.close();
+            }
+        })
+            .catch((error) => {
+            this.#logger.warning('unable to connect to underlying HTTP server process');
+            this.#logger.fatal(error);
+            this.#onError?.(error);
+            this.#watcher?.close();
+        });
+    }
+    #restart(port) {
+        if (this.#httpServerProcess) {
+            this.#httpServerProcess.removeAllListeners();
+            this.#httpServerProcess.kill('SIGKILL');
+        }
+        this.#startHTTPServer(port, 'blocking');
+    }
+    setLogger(logger) {
+        this.#logger = logger;
+        return this;
+    }
+    onClose(callback) {
+        this.#onClose = callback;
+        return this;
+    }
+    onError(callback) {
+        this.#onError = callback;
+        return this;
+    }
+    async start() {
+        this.#clearScreen();
+        this.#logger.info('starting HTTP server...');
+        this.#startHTTPServer(String(await this.#getPort()), 'nonblocking');
+    }
+    async startAndWatch(ts, options) {
+        this.#isWatching = true;
+        this.#clearScreen();
+        const port = String(await this.#getPort());
+        this.#logger.info('starting HTTP server...');
+        this.#startHTTPServer(port, 'blocking');
+        const output = watch(this.#cwd, ts, options || {});
+        if (!output) {
+            this.#onClose?.(1);
+            return;
+        }
+        this.#watcher = output.chokidar;
+        output.watcher.on('watcher:ready', () => {
+            this.#logger.info('watching file system for changes...');
+        });
+        output.chokidar.on('error', (error) => {
+            this.#logger.warning('file system watcher failure');
+            this.#logger.fatal(error);
+            this.#onError?.(error);
+            output.chokidar.close();
+        });
+        output.watcher.on('source:add', ({ relativePath }) => {
+            this.#clearScreen();
+            this.#logger.log(`${this.#colors.green('add')} ${relativePath}`);
+            this.#restart(port);
+        });
+        output.watcher.on('source:change', ({ relativePath }) => {
+            this.#clearScreen();
+            this.#logger.log(`${this.#colors.green('update')} ${relativePath}`);
+            this.#restart(port);
+        });
+        output.watcher.on('source:unlink', ({ relativePath }) => {
+            this.#clearScreen();
+            this.#logger.log(`${this.#colors.green('delete')} ${relativePath}`);
+            this.#restart(port);
+        });
+        output.watcher.on('add', ({ relativePath }) => {
+            if (this.#isDotEnvFile(relativePath) || this.#isRcFile(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('add')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('add')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('add')} ${relativePath}`);
+            }
+        });
+        output.watcher.on('change', ({ relativePath }) => {
+            if (this.#isDotEnvFile(relativePath) || this.#isRcFile(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('update')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('update')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('update')} ${relativePath}`);
+            }
+        });
+        output.watcher.on('unlink', ({ relativePath }) => {
+            if (this.#isDotEnvFile(relativePath) || this.#isRcFile(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('delete')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('delete')} ${relativePath}`);
+                this.#restart(port);
+                return;
+            }
+            if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+                this.#clearScreen();
+                this.#logger.log(`${this.#colors.green('delete')} ${relativePath}`);
+            }
+        });
+    }
+}

package/build/src/run.d.ts

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

package/build/src/run.js

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

package/build/src/types.d.ts

@@ -0,0 +1,26 @@
+/// <reference types="node" resolution-mode="require"/>
+export type RunOptions = {
+    script: string;
+    scriptArgs: string[];
+    nodeArgs: string[];
+    env?: NodeJS.ProcessEnv;
+};
+export type WatchOptions = {
+    poll?: boolean;
+};
+export type DevServerOptions = {
+    scriptArgs: string[];
+    nodeArgs: string[];
+    clearScreen?: boolean;
+    env?: NodeJS.ProcessEnv;
+    metaFiles?: {
+        pattern: string;
+        reloadServer: boolean;
+    }[];
+};
+export type BundlerOptions = {
+    metaFiles?: {
+        pattern: string;
+        reloadServer: boolean;
+    }[];
+};

package/build/src/watch.d.ts

@@ -0,0 +1,8 @@
+/// <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

@@ -0,0 +1,18 @@
+import { fileURLToPath } from 'node:url';
+import { ConfigParser, Watcher } from '@poppinss/chokidar-ts';
+export function watch(cwd, ts, options) {
+    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;
+    }
+    const watcher = new Watcher(typeof cwd === 'string' ? cwd : fileURLToPath(cwd), config);
+    const chokidar = watcher.watch(['.'], { usePolling: options.poll });
+    return { watcher, chokidar };
+}