@adonisjs/assembler 6.1.3-3 → 6.1.3-5

package/src/bundler.ts

@@ -0,0 +1,267 @@
+/*
+ * @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, parseConfig } from './helpers.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,306 @@
+/*
+ * @adonisjs/assembler
+ *
+ * (c) AdonisJS
+ *
+ * For the full copyright and license information, please view the LICENSE
+ * file that was distributed with this source code.
+ */
+
+import picomatch from 'picomatch'
+import type tsStatic from 'typescript'
+import { type ExecaChildProcess } from 'execa'
+import { cliui, type Logger } from '@poppinss/cliui'
+import type { Watcher } from '@poppinss/chokidar-ts'
+
+import type { DevServerOptions } from './types.js'
+import { AssetsDevServer } from './assets_dev_server.js'
+import { getPort, isDotEnvFile, isRcFile, 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 DevServer {
+  #cwd: URL
+  #logger = ui.logger
+  #options: DevServerOptions
+  #isWatching: boolean = false
+  #scriptFile: string = 'bin/server.js'
+  #isMetaFileWithReloadsEnabled: picomatch.Matcher
+  #isMetaFileWithReloadsDisabled: picomatch.Matcher
+
+  #onError?: (error: any) => any
+  #onClose?: (exitCode: number) => any
+
+  #httpServer?: ExecaChildProcess<string>
+  #watcher?: ReturnType<Watcher['watch']>
+  #assetsServer?: AssetsDevServer
+
+  /**
+   * Getting reference to colors library from logger
+   */
+  get #colors() {
+    return this.#logger.getColors()
+  }
+
+  constructor(cwd: URL, options: 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)
+    )
+  }
+
+  /**
+   * 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')
+    }
+  }
+
+  /**
+   * Starts the HTTP server
+   */
+  #startHTTPServer(port: string, mode: 'blocking' | 'nonblocking') {
+    this.#httpServer = runNode(this.#cwd, {
+      script: this.#scriptFile,
+      env: { PORT: port, ...this.#options.env },
+      nodeArgs: this.#options.nodeArgs,
+      scriptArgs: this.#options.scriptArgs,
+    })
+
+    this.#httpServer.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.#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) => {
+        this.#logger.warning('unable to connect to underlying HTTP server process')
+        this.#logger.fatal(error)
+        this.#onError?.(error)
+        this.#watcher?.close()
+        this.#assetsServer?.stop()
+      })
+  }
+
+  /**
+   * Starts the assets server
+   */
+  #startAssetsServer() {
+    this.#assetsServer = new AssetsDevServer(this.#cwd, this.#options.assets)
+    this.#assetsServer.start()
+  }
+
+  /**
+   * Restarts the HTTP server
+   */
+  #restartHTTPServer(port: string) {
+    if (this.#httpServer) {
+      this.#httpServer.removeAllListeners()
+      this.#httpServer.kill('SIGKILL')
+    }
+
+    this.#startHTTPServer(port, 'blocking')
+  }
+
+  /**
+   * 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
+    }
+
+    if (this.#isMetaFileWithReloadsEnabled(relativePath)) {
+      this.#clearScreen()
+      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+      this.#restartHTTPServer(port)
+      return
+    }
+
+    if (this.#isMetaFileWithReloadsDisabled(relativePath)) {
+      this.#clearScreen()
+      this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+    }
+  }
+
+  /**
+   * Handles TypeScript source file change
+   */
+  #handleSourceFileChange(action: string, port: string, relativePath: string) {
+    this.#clearScreen()
+    this.#logger.log(`${this.#colors.green(action)} ${relativePath}`)
+    this.#restartHTTPServer(port)
+  }
+
+  /**
+   * Set a custom CLI UI logger
+   */
+  setLogger(logger: Logger) {
+    this.#logger = logger
+    this.#assetsServer?.setLogger(logger)
+    return this
+  }
+
+  /**
+   * Add listener to get notified when dev server is
+   * closed
+   */
+  onClose(callback: (exitCode: number) => any): this {
+    this.#onClose = callback
+    return this
+  }
+
+  /**
+   * Add listener to get notified when dev server exists
+   * with an error
+   */
+  onError(callback: (error: any) => any): this {
+    this.#onError = callback
+    return this
+  }
+
+  /**
+   * Start the development server
+   */
+  async start() {
+    this.#clearScreen()
+    this.#logger.info('starting HTTP server...')
+    this.#startHTTPServer(String(await getPort(this.#cwd)), 'nonblocking')
+    this.#startAssetsServer()
+  }
+
+  /**
+   * Start the development server in watch mode
+   */
+  async startAndWatch(ts: typeof tsStatic, options?: { poll: boolean }) {
+    const port = String(await getPort(this.#cwd))
+    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.#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)
+    )
+  }
+}