@adonisjs/assembler 6.1.3-4 → 6.1.3-5

package/src/dev_server.ts

@@ -7,17 +7,15 @@
  * 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 type { Watcher } from '@poppinss/chokidar-ts'
 
-import { watch } from './watch.js'
-import { run, runNode } from './run.js'
 import type { DevServerOptions } from './types.js'
+import { AssetsDevServer } from './assets_dev_server.js'
+import { getPort, isDotEnvFile, isRcFile, runNode, watch } from './helpers.js'
 
 /**
  * Instance of CLIUI
@@ -41,14 +39,16 @@ export class DevServer {
   #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
 
+  #httpServer?: ExecaChildProcess<string>
+  #watcher?: ReturnType<Watcher['watch']>
+  #assetsServer?: AssetsDevServer
+
   /**
    * Getting reference to colors library from logger
    */
@@ -73,24 +73,6 @@ export class DevServer {
     )
   }
 
-  /**
-   * 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
    */
@@ -115,97 +97,18 @@ export class DevServer {
     }
   }
 
-  /**
-   * 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, {
+    this.#httpServer = 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) => {
+    this.#httpServer.on('message', (message) => {
       if (this.#isAdonisJSReadyMessage(message)) {
         ui.sticker()
           .useColors(this.#colors)
@@ -220,12 +123,13 @@ export class DevServer {
       }
     })
 
-    this.#httpServerProcess
+    this.#httpServer
       .then((result) => {
         this.#logger.warning(`underlying HTTP server closed with status code "${result.exitCode}"`)
         if (mode === 'nonblocking') {
           this.#onClose?.(result.exitCode)
           this.#watcher?.close()
+          this.#assetsServer?.stop()
         }
       })
       .catch((error) => {
@@ -233,73 +137,61 @@ export class DevServer {
         this.#logger.fatal(error)
         this.#onError?.(error)
         this.#watcher?.close()
+        this.#assetsServer?.stop()
       })
   }
 
   /**
-   * 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.
+   * Starts the assets server
    */
   #startAssetsServer() {
-    const assetsBundler = this.#options.assets
-    if (!assetsBundler?.serve) {
-      return
-    }
+    this.#assetsServer = new AssetsDevServer(this.#cwd, this.#options.assets)
+    this.#assetsServer.start()
+  }
 
-    this.#logger.info(`starting "${assetsBundler.driver}" dev server...`)
-    this.#assetsServerProcess = run(this.#cwd, {
-      script: assetsBundler.cmd,
+  /**
+   * Restarts the HTTP server
+   */
+  #restartHTTPServer(port: string) {
+    if (this.#httpServer) {
+      this.#httpServer.removeAllListeners()
+      this.#httpServer.kill('SIGKILL')
+    }
 
-      /**
-       * 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,
-    })
+    this.#startHTTPServer(port, 'blocking')
+  }
 
-    /**
-     * Log child process messages
-     */
-    this.#assetsServerProcess.stdout?.on('data', (data) => {
-      if (assetsBundler.driver === 'vite') {
-        this.#logViteDevServerMessage(data)
-      } else {
-        this.#logAssetsDevServerMessage(data)
-      }
-    })
+  /**
+   * Handles a non TypeScript file change
+   */
+  #handleFileChange(action: string, port: string, relativePath: string) {
+    if (isDotEnvFile(relativePath) || isRcFile(relativePath)) {
+      this.#clearScreen()
+      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+      this.#restartHTTPServer(port)
+      return
+    }
 
-    this.#assetsServerProcess.stderr?.on('data', (data) => {
-      if (assetsBundler.driver === 'vite') {
-        this.#logViteDevServerMessage(data)
-      } else {
-        this.#logAssetsDevServerMessage(data)
-      }
-    })
+    if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+      this.#clearScreen()
+      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+      this.#restartHTTPServer(port)
+      return
+    }
 
-    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)
-      })
+    if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+      this.#clearScreen()
+      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+    }
   }
 
   /**
-   * Restart the development server
+   * Handles TypeScript source file change
    */
-  #restart(port: string) {
-    if (this.#httpServerProcess) {
-      this.#httpServerProcess.removeAllListeners()
-      this.#httpServerProcess.kill('SIGKILL')
-    }
-
-    this.#startHTTPServer(port, 'blocking')
+  #handleSourceFileChange(action: string, port: string, relativePath: string) {
+    this.#clearScreen()
+    this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+    this.#restartHTTPServer(port)
   }
 
   /**
@@ -307,6 +199,7 @@ export class DevServer {
    */
   setLogger(logger: Logger) {
     this.#logger = logger
+    this.#assetsServer?.setLogger(logger)
     return this
   }
 
@@ -334,8 +227,7 @@ export class DevServer {
   async start() {
     this.#clearScreen()
     this.#logger.info('starting HTTP server...')
-    this.#startHTTPServer(String(await this.#getPort()), 'nonblocking')
-
+    this.#startHTTPServer(String(await getPort(this.#cwd)), 'nonblocking')
     this.#startAssetsServer()
   }
 
@@ -343,13 +235,14 @@ export class DevServer {
    * Start the development server in watch mode
    */
   async startAndWatch(ts: typeof tsStatic, options?: { poll: boolean }) {
-    const port = String(await this.#getPort())
+    const port = String(await getPort(this.#cwd))
     this.#isWatching = true
 
     this.#clearScreen()
-    this.#logger.info('starting HTTP server...')
 
+    this.#logger.info('starting HTTP server...')
     this.#startHTTPServer(port, 'blocking')
+
     this.#startAssetsServer()
 
     /**
@@ -387,84 +280,27 @@ export class DevServer {
     /**
      * 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)
-    })
+    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 other files
+     * Changes in non-TypeScript source 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}`)
-      }
-    })
+    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/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 })
+}