@adonisjs/assembler 6.1.3-3 → 6.1.3-4

package/LICENSE.md

@@ -1,6 +1,6 @@
 # The MIT License
 
-Copyright (c) 2023 AdonisJS Framework
+Copyright (c) 2023 Harminder Virk
 
 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

@@ -2,7 +2,7 @@
 
 <br />
 
-[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![synk-image]][synk-url]
+[![gh-workflow-image]][gh-workflow-url] [![npm-image]][npm-url] ![][typescript-image] [![license-image]][license-url] [![snyk-image]][snyk-url]
 
 ## 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.
@@ -32,5 +32,5 @@ AdonisJS Assembler is open-sourced software licensed under the [MIT license](LIC
 [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"
+[snyk-image]: https://img.shields.io/snyk/vulnerabilities/github/adonisjs/assembler?label=snyk%20Vulnerabilities&style=for-the-badge
+[snyk-url]: https://snyk.io/test/github/adonisjs/assembler?targetFile=package.json "snyk"

package/build/index.d.ts

@@ -1,2 +1,3 @@
 export { Bundler } from './src/bundler.js';
 export { DevServer } from './src/dev_server.js';
+//# sourceMappingURL=index.d.ts.map

package/build/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AASA,OAAO,EAAE,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAC1C,OAAO,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA"}

package/build/src/bundler.d.ts

@@ -8,3 +8,4 @@ export declare class Bundler {
     setLogger(logger: Logger): this;
     bundle(stopOnError?: boolean, client?: 'npm' | 'yarn' | 'pnpm'): Promise<boolean>;
 }
+//# sourceMappingURL=bundler.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"bundler.d.ts","sourceRoot":"","sources":["../../src/bundler.ts"],"names":[],"mappings":";AAYA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AAGtC,OAAO,EAAS,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAIpD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAA;AAUhD,qBAAa,OAAO;;gBAcN,GAAG,EAAE,GAAG,EAAE,EAAE,EAAE,OAAO,QAAQ,EAAE,OAAO,EAAE,cAAc;IAkIlE,SAAS,CAAC,MAAM,EAAE,MAAM;IAQlB,MAAM,CACV,WAAW,GAAE,OAAc,EAC3B,MAAM,GAAE,KAAK,GAAG,MAAM,GAAG,MAAc,GACtC,OAAO,CAAC,OAAO,CAAC;CAmFpB"}

package/build/src/dev_server.d.ts

@@ -13,3 +13,4 @@ export declare class DevServer {
         poll: boolean;
     }): Promise<void>;
 }
+//# sourceMappingURL=dev_server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dev_server.d.ts","sourceRoot":"","sources":["../../src/dev_server.ts"],"names":[],"mappings":";AAWA,OAAO,KAAK,QAAQ,MAAM,YAAY,CAAA;AAGtC,OAAO,EAAS,KAAK,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAKpD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AAkBlD,qBAAa,SAAS;;gBAqBR,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,gBAAgB;IAyP/C,SAAS,CAAC,MAAM,EAAE,MAAM;IASxB,OAAO,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,GAAG,GAAG,IAAI;IASlD,OAAO,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,GAAG,KAAK,GAAG,GAAG,IAAI;IAQtC,KAAK;IAWL,aAAa,CAAC,EAAE,EAAE,OAAO,QAAQ,EAAE,OAAO,CAAC,EAAE;QAAE,IAAI,EAAE,OAAO,CAAA;KAAE;CA6HrE"}

package/build/src/parse_config.d.ts

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

@@ -0,0 +1 @@
+{"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/run.d.ts

@@ -2,3 +2,4 @@
 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

@@ -0,0 +1 @@
+{"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/types.d.ts

@@ -34,3 +34,4 @@ export type BundlerOptions = {
     metaFiles?: MetaFile[];
     assets?: AssetsBundlerOptions;
 };
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/types.ts"],"names":[],"mappings":";AAYA,MAAM,MAAM,UAAU,GAAG;IACvB,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,KAAK,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;IAC1B,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;CACxB,CAAA;AAKD,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,CAAC,EAAE,OAAO,CAAA;CACf,CAAA;AAKD,MAAM,MAAM,QAAQ,GAAG;IACrB,OAAO,EAAE,MAAM,CAAA;IACf,YAAY,EAAE,OAAO,CAAA;CACtB,CAAA;AAKD,MAAM,MAAM,oBAAoB,GAC5B;IACE,KAAK,EAAE,KAAK,CAAA;IACZ,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,GAAG,CAAC,EAAE,MAAM,CAAA;CACb,GACD;IACE,KAAK,EAAE,IAAI,CAAA;IACX,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;CACZ,CAAA;AAKL,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,EAAE,MAAM,EAAE,CAAA;IACpB,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;IACvB,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAA;IACtB,MAAM,CAAC,EAAE,oBAAoB,CAAA;CAC9B,CAAA;AAKD,MAAM,MAAM,cAAc,GAAG;IAC3B,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAA;IACtB,MAAM,CAAC,EAAE,oBAAoB,CAAA;CAC9B,CAAA"}

package/build/src/watch.d.ts

@@ -6,3 +6,4 @@ export declare function watch(cwd: string | URL, ts: typeof tsStatic, options: W
     watcher: Watcher;
     chokidar: import("chokidar").FSWatcher;
 } | undefined;
+//# sourceMappingURL=watch.d.ts.map

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

@@ -0,0 +1 @@
+{"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/index.ts

@@ -0,0 +1,11 @@
+/*
+ * @adonisjs/assembler
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+export { Bundler } from './src/bundler.js'
+export { DevServer } from './src/dev_server.js'

package/package.json

@@ -1,12 +1,15 @@
 {
   "name": "@adonisjs/assembler",
-  "version": "6.1.3-3",
+  "version": "6.1.3-4",
   "description": "Provides utilities to run AdonisJS development server and build project for production",
   "main": "build/index.js",
   "type": "module",
   "files": [
+    "src",
+    "index.ts",
     "build/src",
     "build/index.d.ts",
+    "build/index.d.ts.map",
     "build/index.js"
   ],
   "exports": {
@@ -35,34 +38,34 @@
   "author": "virk,adonisjs",
   "license": "MIT",
   "devDependencies": {
-    "@commitlint/cli": "^17.4.4",
+    "@commitlint/cli": "^17.5.0",
     "@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",
+    "@swc/core": "^1.3.42",
+    "@types/node": "^18.15.10",
     "c8": "^7.13.0",
     "cross-env": "^7.0.3",
     "del-cli": "^5.0.0",
     "eslint": "^8.36.0",
-    "eslint-config-prettier": "^8.7.0",
+    "eslint-config-prettier": "^8.8.0",
     "eslint-plugin-adonis": "^3.0.3",
     "eslint-plugin-prettier": "^4.2.1",
     "github-label-sync": "^2.3.1",
     "husky": "^8.0.3",
-    "np": "^7.6.3",
+    "np": "^7.6.4",
     "p-event": "^5.0.1",
-    "prettier": "^2.8.4",
+    "prettier": "^2.8.7",
     "ts-node": "^10.9.1",
-    "typescript": "^4.9.5"
+    "typescript": "^5.0.2"
   },
   "dependencies": {
-    "@adonisjs/env": "^4.2.0-1",
-    "@poppinss/chokidar-ts": "^4.1.0-1",
-    "@poppinss/cliui": "^6.1.1-1",
+    "@adonisjs/env": "^4.2.0-2",
+    "@poppinss/chokidar-ts": "^4.1.0-2",
+    "@poppinss/cliui": "^6.1.1-2",
     "@types/picomatch": "^2.3.0",
     "cpy": "^9.0.1",
     "execa": "^7.0.0",

package/src/bundler.ts

@@ -0,0 +1,268 @@
+/*
+ * @adonisjs/assembler
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import slash from 'slash'
+import copyfiles from 'cpy'
+import fs from 'node:fs/promises'
+import type tsStatic from 'typescript'
+import { fileURLToPath } from 'node:url'
+import { join, relative } from 'node:path'
+import { cliui, type Logger } from '@poppinss/cliui'
+
+import { run } from './run.js'
+import { parseConfig } from './parse_config.js'
+import type { BundlerOptions } from './types.js'
+
+/**
+ * Instance of CLIUI
+ */
+const ui = cliui()
+
+/**
+ * The bundler class exposes the API to build an AdonisJS project.
+ */
+export class Bundler {
+  #cwd: URL
+  #cwdPath: string
+  #ts: typeof tsStatic
+  #logger = ui.logger
+  #options: BundlerOptions
+
+  /**
+   * Getting reference to colors library from logger
+   */
+  get #colors() {
+    return this.#logger.getColors()
+  }
+
+  constructor(cwd: URL, ts: typeof tsStatic, options: BundlerOptions) {
+    this.#cwd = cwd
+    this.#cwdPath = fileURLToPath(this.#cwd)
+    this.#ts = ts
+    this.#options = options
+  }
+
+  #getRelativeName(filePath: string) {
+    return slash(relative(this.#cwdPath, filePath))
+  }
+
+  /**
+   * Cleans up the build directory
+   */
+  async #cleanupBuildDirectory(outDir: string) {
+    await fs.rm(outDir, { recursive: true, force: true, maxRetries: 5 })
+  }
+
+  /**
+   * Runs assets bundler command to build assets.
+   */
+  async #buildAssets(): Promise<boolean> {
+    const assetsBundler = this.#options.assets
+    if (!assetsBundler?.serve) {
+      return true
+    }
+
+    try {
+      this.#logger.info('compiling frontend assets', { suffix: assetsBundler.cmd })
+      await run(this.#cwd, {
+        stdio: 'inherit',
+        script: assetsBundler.cmd,
+        scriptArgs: [],
+      })
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Runs tsc command to build the source.
+   */
+  async #runTsc(outDir: string): Promise<boolean> {
+    try {
+      await run(this.#cwd, {
+        stdio: 'inherit',
+        script: 'tsc',
+        scriptArgs: ['--outDir', outDir],
+      })
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Copy files to destination directory
+   */
+  async #copyFiles(files: string[], outDir: string) {
+    try {
+      await copyfiles(files, outDir, { cwd: this.#cwdPath })
+    } catch (error) {
+      if (!error.message.includes("the file doesn't exist")) {
+        throw error
+      }
+    }
+  }
+
+  /**
+   * Copy meta files to the output directory
+   */
+  async #copyMetaFiles(outDir: string, additionalFilesToCopy: string[]) {
+    const metaFiles = (this.#options.metaFiles || [])
+      .map((file) => file.pattern)
+      .concat(additionalFilesToCopy)
+
+    await this.#copyFiles(metaFiles, outDir)
+  }
+
+  /**
+   * Copies .adonisrc.json file to the destination
+   */
+  async #copyAdonisRcFile(outDir: string) {
+    const existingContents = JSON.parse(
+      await fs.readFile(join(this.#cwdPath, '.adonisrc.json'), 'utf-8')
+    )
+    const compiledContents = Object.assign({}, existingContents, {
+      typescript: false,
+      lastCompiledAt: new Date().toISOString(),
+    })
+
+    await fs.mkdir(outDir, { recursive: true })
+    await fs.writeFile(
+      join(outDir, '.adonisrc.json'),
+      JSON.stringify(compiledContents, null, 2) + '\n'
+    )
+  }
+
+  /**
+   * Returns the lock file name for a given packages client
+   */
+  #getClientLockFile(client: 'npm' | 'yarn' | 'pnpm') {
+    switch (client) {
+      case 'npm':
+        return 'package-lock.json'
+      case 'yarn':
+        return 'yarn.lock'
+      case 'pnpm':
+        return 'pnpm-lock.yaml'
+    }
+  }
+
+  /**
+   * Returns the installation command for a given packages client
+   */
+  #getClientInstallCommand(client: 'npm' | 'yarn' | 'pnpm') {
+    switch (client) {
+      case 'npm':
+        return 'npm ci --omit="dev"'
+      case 'yarn':
+        return 'yarn install --production'
+      case 'pnpm':
+        return 'pnpm i --prod'
+    }
+  }
+
+  /**
+   * Set a custom CLI UI logger
+   */
+  setLogger(logger: Logger) {
+    this.#logger = logger
+    return this
+  }
+
+  /**
+   * Bundles the application to be run in production
+   */
+  async bundle(
+    stopOnError: boolean = true,
+    client: 'npm' | 'yarn' | 'pnpm' = 'npm'
+  ): Promise<boolean> {
+    /**
+     * Step 1: Parse config file to get the build output directory
+     */
+    const config = parseConfig(this.#cwd, this.#ts)
+    if (!config) {
+      return false
+    }
+
+    /**
+     * Step 2: Cleanup existing build directory (if any)
+     */
+    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)
+
+    /**
+     * Step 3: Build frontend assets
+     */
+    if (!(await this.#buildAssets())) {
+      return false
+    }
+
+    /**
+     * Step 4: Build typescript source code
+     */
+    this.#logger.info('compiling typescript source', { suffix: 'tsc' })
+    const buildCompleted = await this.#runTsc(outDir)
+    await this.#copyFiles(['ace.js'], outDir)
+
+    /**
+     * Remove incomplete build directory when tsc build
+     * failed and stopOnError is set to true.
+     */
+    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
+    }
+
+    /**
+     * Step 5: Copy meta files to the build directory
+     */
+    const pkgFiles = ['package.json', this.#getClientLockFile(client)]
+    this.#logger.info('copying meta files to the output directory')
+    await this.#copyMetaFiles(outDir, pkgFiles)
+
+    /**
+     * Step 6: Copy .adonisrc.json file to the build directory
+     */
+    this.#logger.info('copying .adonisrc.json file to the output directory')
+    await this.#copyAdonisRcFile(outDir)
+
+    this.#logger.success('build completed')
+    this.#logger.log('')
+
+    /**
+     * Next steps
+     */
+    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/src/dev_server.ts

@@ -0,0 +1,470 @@
+/*
+ * @adonisjs/assembler
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import getPort from 'get-port'
+import picomatch from 'picomatch'
+import type tsStatic from 'typescript'
+import { type ExecaChildProcess } from 'execa'
+import type { Watcher } from '@poppinss/chokidar-ts'
+import { cliui, type Logger } from '@poppinss/cliui'
+import { EnvLoader, EnvParser } from '@adonisjs/env'
+
+import { watch } from './watch.js'
+import { run, runNode } from './run.js'
+import type { DevServerOptions } from './types.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 DevServer {
+  #cwd: URL
+  #logger = ui.logger
+  #options: DevServerOptions
+  #isWatching: boolean = false
+  #scriptFile: string = 'bin/server.js'
+  #httpServerProcess?: ExecaChildProcess<string>
+  #isMetaFileWithReloadsEnabled: picomatch.Matcher
+  #isMetaFileWithReloadsDisabled: picomatch.Matcher
+  #watcher?: ReturnType<Watcher['watch']>
+  #assetsServerProcess?: ExecaChildProcess<string>
+  #onError?: (error: any) => any
+  #onClose?: (exitCode: number) => any
+
+  /**
+   * Getting reference to colors library from logger
+   */
+  get #colors() {
+    return this.#logger.getColors()
+  }
+
+  constructor(cwd: URL, options: DevServerOptions) {
+    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)
+    )
+  }
+
+  /**
+   * Check if file is an .env file
+   */
+  #isDotEnvFile(filePath: string) {
+    if (filePath === '.env') {
+      return true
+    }
+
+    return filePath.includes('.env.')
+  }
+
+  /**
+   * Check if file is .adonisrc.json file
+   */
+  #isRcFile(filePath: string) {
+    return filePath === '.adonisrc.json'
+  }
+
+  /**
+   * Inspect if child process message is from AdonisJS HTTP server
+   */
+  #isAdonisJSReadyMessage(
+    message: unknown
+  ): message is { isAdonisJS: true; environment: 'web'; port: number; host: string } {
+    return (
+      message !== null &&
+      typeof message === 'object' &&
+      'isAdonisJS' in message &&
+      'environment' in message &&
+      message.environment === 'web'
+    )
+  }
+
+  /**
+   * Conditionally clear the terminal screen
+   */
+  #clearScreen() {
+    if (this.#options.clearScreen) {
+      process.stdout.write('\u001Bc')
+    }
+  }
+
+  /**
+   * Logs messages from vite dev server stdout and stderr
+   */
+  #logViteDevServerMessage(data: Buffer) {
+    const dataString = data.toString()
+    const lines = dataString.split('\n')
+
+    /**
+     * Logging VITE ready in message with proper
+     * spaces and newlines
+     */
+    if (dataString.includes('ready in')) {
+      console.log('')
+      console.log(dataString.trim())
+      return
+    }
+
+    /**
+     * Put a wrapper around vite network address log
+     */
+    if (dataString.includes('Local') && dataString.includes('Network')) {
+      const sticker = ui.sticker().useColors(this.#colors).useRenderer(this.#logger.getRenderer())
+
+      lines.forEach((line: string) => {
+        if (line.trim()) {
+          sticker.add(line)
+        }
+      })
+
+      sticker.render()
+      return
+    }
+
+    /**
+     * Log rest of the lines
+     */
+    lines.forEach((line: string) => {
+      if (line.trim()) {
+        console.log(line)
+      }
+    })
+  }
+
+  /**
+   * Logs messages from assets dev server stdout and stderr
+   */
+  #logAssetsDevServerMessage(data: Buffer) {
+    const dataString = data.toString()
+    const lines = dataString.split('\n')
+    lines.forEach((line: string) => {
+      if (line.trim()) {
+        console.log(line)
+      }
+    })
+  }
+
+  /**
+   * Returns PORT for starting the HTTP server with option to use
+   * a random PORT if main PORT is in use.
+   */
+  async #getPort(): Promise<number> {
+    /**
+     * Use existing port if exists
+     */
+    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 })
+  }
+
+  /**
+   * Starts the HTTP server
+   */
+  #startHTTPServer(port: string, mode: 'blocking' | 'nonblocking') {
+    this.#httpServerProcess = runNode(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()
+      })
+  }
+
+  /**
+   * Starts the assets bundler server. The assets bundler server process is
+   * considered as the secondary process and therefore we do not perform
+   * any cleanup if it dies.
+   */
+  #startAssetsServer() {
+    const assetsBundler = this.#options.assets
+    if (!assetsBundler?.serve) {
+      return
+    }
+
+    this.#logger.info(`starting "${assetsBundler.driver}" dev server...`)
+    this.#assetsServerProcess = run(this.#cwd, {
+      script: assetsBundler.cmd,
+
+      /**
+       * We do not inherit the stdio for vite and encore, because they then
+       * own the stdin and interrupts the `Ctrl + C`.
+       */
+      stdio: 'pipe',
+      scriptArgs: this.#options.scriptArgs,
+    })
+
+    /**
+     * Log child process messages
+     */
+    this.#assetsServerProcess.stdout?.on('data', (data) => {
+      if (assetsBundler.driver === 'vite') {
+        this.#logViteDevServerMessage(data)
+      } else {
+        this.#logAssetsDevServerMessage(data)
+      }
+    })
+
+    this.#assetsServerProcess.stderr?.on('data', (data) => {
+      if (assetsBundler.driver === 'vite') {
+        this.#logViteDevServerMessage(data)
+      } else {
+        this.#logAssetsDevServerMessage(data)
+      }
+    })
+
+    this.#assetsServerProcess
+      .then((result) => {
+        this.#logger.warning(
+          `"${assetsBundler.driver}" dev server closed with status code "${result.exitCode}"`
+        )
+      })
+      .catch((error) => {
+        this.#logger.warning(`unable to connect to "${assetsBundler.driver}" dev server`)
+        this.#logger.fatal(error)
+      })
+  }
+
+  /**
+   * Restart the development server
+   */
+  #restart(port: string) {
+    if (this.#httpServerProcess) {
+      this.#httpServerProcess.removeAllListeners()
+      this.#httpServerProcess.kill('SIGKILL')
+    }
+
+    this.#startHTTPServer(port, 'blocking')
+  }
+
+  /**
+   * Set a custom CLI UI logger
+   */
+  setLogger(logger: Logger) {
+    this.#logger = 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
+  }
+
+  /**
+   * Start the development server
+   */
+  async start() {
+    this.#clearScreen()
+    this.#logger.info('starting HTTP server...')
+    this.#startHTTPServer(String(await this.#getPort()), 'nonblocking')
+
+    this.#startAssetsServer()
+  }
+
+  /**
+   * Start the development server in watch mode
+   */
+  async startAndWatch(ts: typeof tsStatic, options?: { poll: boolean }) {
+    const port = String(await this.#getPort())
+    this.#isWatching = true
+
+    this.#clearScreen()
+    this.#logger.info('starting HTTP server...')
+
+    this.#startHTTPServer(port, 'blocking')
+    this.#startAssetsServer()
+
+    /**
+     * 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.#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)
+    })
+
+    /**
+     * Changes in other files
+     */
+    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/src/parse_config.ts

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

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

@@ -0,0 +1,69 @@
+/*
+ * @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
+}
+
+/**
+ * Options accepted by assets bundler
+ */
+export type AssetsBundlerOptions =
+  | {
+      serve: false
+      driver?: string
+      cmd?: string
+    }
+  | {
+      serve: true
+      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 project bundler
+ */
+export type BundlerOptions = {
+  metaFiles?: MetaFile[]
+  assets?: AssetsBundlerOptions
+}

package/src/watch.ts

@@ -0,0 +1,29 @@
+/*
+ * @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 }
+}