velocious 1.0.431 → 1.0.433

package/build/src/http-server/development-reloader.js

@@ -1,240 +1,209 @@
 // @ts-check
-
-import {watch as fsWatch} from "fs"
-import fs from "fs/promises"
-import Logger from "../logger.js"
-import path from "path"
-
+import { watch as fsWatch } from "fs";
+import fs from "fs/promises";
+import Logger from "../logger.js";
+import path from "path";
 const RELOADABLE_EXTENSIONS = new Set([
-  ".cjs",
-  ".ejs",
-  ".js",
-  ".json",
-  ".mjs"
-])
-
+    ".cjs",
+    ".ejs",
+    ".js",
+    ".json",
+    ".mjs"
+]);
 /**
  * Development-only file watcher that asks the HTTP server to recycle workers
  * when application source files change.
  */
 export default class VelociousHttpServerDevelopmentReloader {
-  /**
-   * Runs constructor.
-   * @param {object} args - Options object.
-   * @param {import("../configuration.js").default} args.configuration - Configuration instance.
-   * @param {function({changedPath: string}) : Promise<void>} args.onReload - Reload callback.
-   * @param {number} [args.debounceMs] - Debounce window for grouped changes.
-   * @param {typeof fsWatch} [args.watchFactory] - File watch factory.
-   * @param {typeof fs.readdir} [args.readdir] - Directory reader.
-   * @param {typeof fs.stat} [args.stat] - Stat reader.
-   */
-  constructor({configuration, onReload, debounceMs = 75, watchFactory = fsWatch, readdir = fs.readdir, stat = fs.stat}) {
-    this.configuration = configuration
-    this.debounceMs = debounceMs
-    this.logger = new Logger("DevelopmentReloader", {configuration})
-    this.onReload = onReload
-    this.readdir = readdir
-    this.stat = stat
-    this.watchFactory = watchFactory
-
     /**
-     * Narrows the runtime value to the documented type.
-      @type {ReturnType<typeof setTimeout> | undefined} */
-    this.reloadTimer = undefined
-
+     * Runs constructor.
+     * @param {object} args - Options object.
+     * @param {import("../configuration.js").default} args.configuration - Configuration instance.
+     * @param {function({changedPath: string}) : Promise<void>} args.onReload - Reload callback.
+     * @param {number} [args.debounceMs] - Debounce window for grouped changes.
+     * @param {typeof fsWatch} [args.watchFactory] - File watch factory.
+     * @param {typeof fs.readdir} [args.readdir] - Directory reader.
+     * @param {typeof fs.stat} [args.stat] - Stat reader.
+     */
+    constructor({ configuration, onReload, debounceMs = 75, watchFactory = fsWatch, readdir = fs.readdir, stat = fs.stat }) {
+        this.configuration = configuration;
+        this.debounceMs = debounceMs;
+        this.logger = new Logger("DevelopmentReloader", { configuration });
+        this.onReload = onReload;
+        this.readdir = readdir;
+        this.stat = stat;
+        this.watchFactory = watchFactory;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {ReturnType<typeof setTimeout> | undefined} */
+        this.reloadTimer = undefined;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {string | undefined} */
+        this.pendingChangedPath = undefined;
+        /**
+         * Narrows the runtime value to the documented type.
+          @type {Map<string, import("fs").FSWatcher>} */
+        this.watchers = new Map();
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {string | undefined} */
-    this.pendingChangedPath = undefined
-
+     * Runs start.
+     * @returns {Promise<void>} - Resolves when watching has started.
+     */
+    async start() {
+        for (const rootPath of this.watchRootPaths()) {
+            await this.watchDirectoryRecursive(rootPath);
+        }
+    }
     /**
-     * Narrows the runtime value to the documented type.
-      @type {Map<string, import("fs").FSWatcher>} */
-    this.watchers = new Map()
-  }
-
-  /**
-   * Runs start.
-   * @returns {Promise<void>} - Resolves when watching has started.
-   */
-  async start() {
-    for (const rootPath of this.watchRootPaths()) {
-      await this.watchDirectoryRecursive(rootPath)
+     * Runs watch root paths.
+     * @returns {string[]} - Source directories to watch.
+     */
+    watchRootPaths() {
+        const rootPaths = new Set();
+        const configurationDirectory = this.configuration.getDirectory();
+        rootPaths.add(path.join(configurationDirectory, "src"));
+        for (const backendProject of this.configuration.getBackendProjects()) {
+            if (!backendProject?.path)
+                continue;
+            rootPaths.add(path.join(backendProject.path, "src"));
+        }
+        return Array.from(rootPaths);
     }
-  }
-
-  /**
-   * Runs watch root paths.
-   * @returns {string[]} - Source directories to watch.
-   */
-  watchRootPaths() {
-    const rootPaths = new Set()
-    const configurationDirectory = this.configuration.getDirectory()
-
-    rootPaths.add(path.join(configurationDirectory, "src"))
-
-    for (const backendProject of this.configuration.getBackendProjects()) {
-      if (!backendProject?.path) continue
-      rootPaths.add(path.join(backendProject.path, "src"))
+    /**
+     * Runs watch directory recursive.
+     * @param {string} directoryPath - Directory path.
+     * @returns {Promise<void>} - Resolves when child directories are watched.
+     */
+    async watchDirectoryRecursive(directoryPath) {
+        const resolvedDirectoryPath = path.resolve(directoryPath);
+        if (this.watchers.has(resolvedDirectoryPath))
+            return;
+        let entries;
+        try {
+            entries = await this.readdir(resolvedDirectoryPath, { withFileTypes: true });
+        }
+        catch (error) {
+            if ( /**
+                 * Narrows the runtime value to the documented type.
+                  @type {{code?: string}} */(error)?.code === "ENOENT")
+                return;
+            throw error;
+        }
+        const watcher = this.watchFactory(resolvedDirectoryPath, (eventType, fileName) => {
+            void this.onWatcherEvent({
+                directoryPath: resolvedDirectoryPath,
+                eventType,
+                fileName
+            });
+        });
+        watcher.on("error", this.onWatcherError);
+        this.watchers.set(resolvedDirectoryPath, watcher);
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            await this.watchDirectoryRecursive(path.join(resolvedDirectoryPath, entry.name));
+        }
     }
-
-    return Array.from(rootPaths)
-  }
-
-  /**
-   * Runs watch directory recursive.
-   * @param {string} directoryPath - Directory path.
-   * @returns {Promise<void>} - Resolves when child directories are watched.
-   */
-  async watchDirectoryRecursive(directoryPath) {
-    const resolvedDirectoryPath = path.resolve(directoryPath)
-
-    if (this.watchers.has(resolvedDirectoryPath)) return
-
-    let entries
-
-    try {
-      entries = await this.readdir(resolvedDirectoryPath, {withFileTypes: true})
-    } catch (error) {
-      if (/**
-           * Narrows the runtime value to the documented type.
-            @type {{code?: string}} */ (error)?.code === "ENOENT") return
-      throw error
+    /**
+     * Runs on watcher event.
+     * @param {object} args - Options object.
+     * @param {string} args.directoryPath - Watched directory path.
+     * @param {string} args.eventType - Watch event type.
+     * @param {string | Buffer | null} args.fileName - Relative changed filename.
+     * @returns {Promise<void>} - Resolves when complete.
+     */
+    async onWatcherEvent({ directoryPath, eventType, fileName }) {
+        const changedPath = fileName
+            ? path.join(directoryPath, fileName.toString())
+            : directoryPath;
+        await this.watchPotentialDirectory(changedPath);
+        if (!this.shouldReloadPath({ changedPath, fileName }))
+            return;
+        this.scheduleReload(changedPath);
+        await this.logger.debug(() => ["Queued development hot reload", { changedPath, eventType }]);
     }
-
-    const watcher = this.watchFactory(resolvedDirectoryPath, (eventType, fileName) => {
-      void this.onWatcherEvent({
-        directoryPath: resolvedDirectoryPath,
-        eventType,
-        fileName
-      })
-    })
-
-    watcher.on("error", this.onWatcherError)
-    this.watchers.set(resolvedDirectoryPath, watcher)
-
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue
-
-      await this.watchDirectoryRecursive(path.join(resolvedDirectoryPath, entry.name))
+    /**
+     * Runs should reload path.
+     * @param {object} args - Options object.
+     * @param {string} args.changedPath - Changed path.
+     * @param {string | Buffer | null} args.fileName - Raw filename from fs.watch.
+     * @returns {boolean} - Whether the path should trigger reload.
+     */
+    shouldReloadPath({ changedPath, fileName }) {
+        if (!fileName)
+            return true;
+        const extension = path.extname(changedPath).toLowerCase();
+        return RELOADABLE_EXTENSIONS.has(extension);
     }
-  }
-
-  /**
-   * Runs on watcher event.
-   * @param {object} args - Options object.
-   * @param {string} args.directoryPath - Watched directory path.
-   * @param {string} args.eventType - Watch event type.
-   * @param {string | Buffer | null} args.fileName - Relative changed filename.
-   * @returns {Promise<void>} - Resolves when complete.
-   */
-  async onWatcherEvent({directoryPath, eventType, fileName}) {
-    const changedPath = fileName
-      ? path.join(directoryPath, fileName.toString())
-      : directoryPath
-
-    await this.watchPotentialDirectory(changedPath)
-
-    if (!this.shouldReloadPath({changedPath, fileName})) return
-
-    this.scheduleReload(changedPath)
-
-    await this.logger.debug(() => ["Queued development hot reload", {changedPath, eventType}])
-  }
-
-  /**
-   * Runs should reload path.
-   * @param {object} args - Options object.
-   * @param {string} args.changedPath - Changed path.
-   * @param {string | Buffer | null} args.fileName - Raw filename from fs.watch.
-   * @returns {boolean} - Whether the path should trigger reload.
-   */
-  shouldReloadPath({changedPath, fileName}) {
-    if (!fileName) return true
-
-    const extension = path.extname(changedPath).toLowerCase()
-
-    return RELOADABLE_EXTENSIONS.has(extension)
-  }
-
-  /**
-   * Runs watch potential directory.
-   * @param {string} changedPath - Candidate directory path.
-   * @returns {Promise<void>} - Resolves when any new directory watchers are added.
-   */
-  async watchPotentialDirectory(changedPath) {
-    try {
-      const stat = await this.stat(changedPath)
-
-      if (stat.isDirectory()) {
-        await this.watchDirectoryRecursive(changedPath)
-      }
-    } catch (error) {
-      if (/**
-           * Narrows the runtime value to the documented type.
-            @type {{code?: string}} */ (error)?.code !== "ENOENT") {
-        throw error
-      }
+    /**
+     * Runs watch potential directory.
+     * @param {string} changedPath - Candidate directory path.
+     * @returns {Promise<void>} - Resolves when any new directory watchers are added.
+     */
+    async watchPotentialDirectory(changedPath) {
+        try {
+            const stat = await this.stat(changedPath);
+            if (stat.isDirectory()) {
+                await this.watchDirectoryRecursive(changedPath);
+            }
+        }
+        catch (error) {
+            if ( /**
+                 * Narrows the runtime value to the documented type.
+                  @type {{code?: string}} */(error)?.code !== "ENOENT") {
+                throw error;
+            }
+        }
     }
-  }
-
-  /**
-   * Runs schedule reload.
-   * @param {string} changedPath - Changed path.
-   * @returns {void} - No return value.
-   */
-  scheduleReload(changedPath) {
-    this.pendingChangedPath = changedPath
-
-    if (this.reloadTimer) {
-      clearTimeout(this.reloadTimer)
+    /**
+     * Runs schedule reload.
+     * @param {string} changedPath - Changed path.
+     * @returns {void} - No return value.
+     */
+    scheduleReload(changedPath) {
+        this.pendingChangedPath = changedPath;
+        if (this.reloadTimer) {
+            clearTimeout(this.reloadTimer);
+        }
+        this.reloadTimer = setTimeout(() => {
+            void this.flushReload();
+        }, this.debounceMs);
     }
-
-    this.reloadTimer = setTimeout(() => {
-      void this.flushReload()
-    }, this.debounceMs)
-  }
-
-  /**
-   * Runs flush reload.
-   * @returns {Promise<void>} - Resolves when the queued reload is handled.
-   */
-  async flushReload() {
-    this.reloadTimer = undefined
-
-    const changedPath = this.pendingChangedPath
-
-    if (!changedPath) return
-
-    this.pendingChangedPath = undefined
-    await this.onReload({changedPath})
-  }
-
-  /**
-   * On watcher error.
-   * @param {Error} error - Watcher error.
-   * @returns {void} - No return value.
-   */
-  onWatcherError = (error) => {
-    void this.logger.warn("Development hot reload watcher error", error)
-  }
-
-  /**
-   * Runs stop.
-   * @returns {Promise<void>} - Resolves when watchers are closed.
-   */
-  async stop() {
-    if (this.reloadTimer) {
-      clearTimeout(this.reloadTimer)
-      this.reloadTimer = undefined
+    /**
+     * Runs flush reload.
+     * @returns {Promise<void>} - Resolves when the queued reload is handled.
+     */
+    async flushReload() {
+        this.reloadTimer = undefined;
+        const changedPath = this.pendingChangedPath;
+        if (!changedPath)
+            return;
+        this.pendingChangedPath = undefined;
+        await this.onReload({ changedPath });
     }
-
-    this.pendingChangedPath = undefined
-
-    for (const watcher of this.watchers.values()) {
-      watcher.close()
+    /**
+     * On watcher error.
+     * @param {Error} error - Watcher error.
+     * @returns {void} - No return value.
+     */
+    onWatcherError = (error) => {
+        void this.logger.warn("Development hot reload watcher error", error);
+    };
+    /**
+     * Runs stop.
+     * @returns {Promise<void>} - Resolves when watchers are closed.
+     */
+    async stop() {
+        if (this.reloadTimer) {
+            clearTimeout(this.reloadTimer);
+            this.reloadTimer = undefined;
+        }
+        this.pendingChangedPath = undefined;
+        for (const watcher of this.watchers.values()) {
+            watcher.close();
+        }
+        this.watchers.clear();
     }
-
-    this.watchers.clear()
-  }
 }
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"development-reloader.js","sourceRoot":"","sources":["../../../src/http-server/development-reloader.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {watch as fsWatch} from \"fs\"\nimport fs from \"fs/promises\"\nimport Logger from \"../logger.js\"\nimport path from \"path\"\n\nconst RELOADABLE_EXTENSIONS = new Set([\n  \".cjs\",\n  \".ejs\",\n  \".js\",\n  \".json\",\n  \".mjs\"\n])\n\n/**\n * Development-only file watcher that asks the HTTP server to recycle workers\n * when application source files change.\n */\nexport default class VelociousHttpServerDevelopmentReloader {\n  /**\n   * Runs constructor.\n   * @param {object} args - Options object.\n   * @param {import(\"../configuration.js\").default} args.configuration - Configuration instance.\n   * @param {function({changedPath: string}) : Promise<void>} args.onReload - Reload callback.\n   * @param {number} [args.debounceMs] - Debounce window for grouped changes.\n   * @param {typeof fsWatch} [args.watchFactory] - File watch factory.\n   * @param {typeof fs.readdir} [args.readdir] - Directory reader.\n   * @param {typeof fs.stat} [args.stat] - Stat reader.\n   */\n  constructor({configuration, onReload, debounceMs = 75, watchFactory = fsWatch, readdir = fs.readdir, stat = fs.stat}) {\n    this.configuration = configuration\n    this.debounceMs = debounceMs\n    this.logger = new Logger(\"DevelopmentReloader\", {configuration})\n    this.onReload = onReload\n    this.readdir = readdir\n    this.stat = stat\n    this.watchFactory = watchFactory\n\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {ReturnType<typeof setTimeout> | undefined} */\n    this.reloadTimer = undefined\n\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {string | undefined} */\n    this.pendingChangedPath = undefined\n\n    /**\n     * Narrows the runtime value to the documented type.\n      @type {Map<string, import(\"fs\").FSWatcher>} */\n    this.watchers = new Map()\n  }\n\n  /**\n   * Runs start.\n   * @returns {Promise<void>} - Resolves when watching has started.\n   */\n  async start() {\n    for (const rootPath of this.watchRootPaths()) {\n      await this.watchDirectoryRecursive(rootPath)\n    }\n  }\n\n  /**\n   * Runs watch root paths.\n   * @returns {string[]} - Source directories to watch.\n   */\n  watchRootPaths() {\n    const rootPaths = new Set()\n    const configurationDirectory = this.configuration.getDirectory()\n\n    rootPaths.add(path.join(configurationDirectory, \"src\"))\n\n    for (const backendProject of this.configuration.getBackendProjects()) {\n      if (!backendProject?.path) continue\n      rootPaths.add(path.join(backendProject.path, \"src\"))\n    }\n\n    return Array.from(rootPaths)\n  }\n\n  /**\n   * Runs watch directory recursive.\n   * @param {string} directoryPath - Directory path.\n   * @returns {Promise<void>} - Resolves when child directories are watched.\n   */\n  async watchDirectoryRecursive(directoryPath) {\n    const resolvedDirectoryPath = path.resolve(directoryPath)\n\n    if (this.watchers.has(resolvedDirectoryPath)) return\n\n    let entries\n\n    try {\n      entries = await this.readdir(resolvedDirectoryPath, {withFileTypes: true})\n    } catch (error) {\n      if (/**\n           * Narrows the runtime value to the documented type.\n            @type {{code?: string}} */ (error)?.code === \"ENOENT\") return\n      throw error\n    }\n\n    const watcher = this.watchFactory(resolvedDirectoryPath, (eventType, fileName) => {\n      void this.onWatcherEvent({\n        directoryPath: resolvedDirectoryPath,\n        eventType,\n        fileName\n      })\n    })\n\n    watcher.on(\"error\", this.onWatcherError)\n    this.watchers.set(resolvedDirectoryPath, watcher)\n\n    for (const entry of entries) {\n      if (!entry.isDirectory()) continue\n\n      await this.watchDirectoryRecursive(path.join(resolvedDirectoryPath, entry.name))\n    }\n  }\n\n  /**\n   * Runs on watcher event.\n   * @param {object} args - Options object.\n   * @param {string} args.directoryPath - Watched directory path.\n   * @param {string} args.eventType - Watch event type.\n   * @param {string | Buffer | null} args.fileName - Relative changed filename.\n   * @returns {Promise<void>} - Resolves when complete.\n   */\n  async onWatcherEvent({directoryPath, eventType, fileName}) {\n    const changedPath = fileName\n      ? path.join(directoryPath, fileName.toString())\n      : directoryPath\n\n    await this.watchPotentialDirectory(changedPath)\n\n    if (!this.shouldReloadPath({changedPath, fileName})) return\n\n    this.scheduleReload(changedPath)\n\n    await this.logger.debug(() => [\"Queued development hot reload\", {changedPath, eventType}])\n  }\n\n  /**\n   * Runs should reload path.\n   * @param {object} args - Options object.\n   * @param {string} args.changedPath - Changed path.\n   * @param {string | Buffer | null} args.fileName - Raw filename from fs.watch.\n   * @returns {boolean} - Whether the path should trigger reload.\n   */\n  shouldReloadPath({changedPath, fileName}) {\n    if (!fileName) return true\n\n    const extension = path.extname(changedPath).toLowerCase()\n\n    return RELOADABLE_EXTENSIONS.has(extension)\n  }\n\n  /**\n   * Runs watch potential directory.\n   * @param {string} changedPath - Candidate directory path.\n   * @returns {Promise<void>} - Resolves when any new directory watchers are added.\n   */\n  async watchPotentialDirectory(changedPath) {\n    try {\n      const stat = await this.stat(changedPath)\n\n      if (stat.isDirectory()) {\n        await this.watchDirectoryRecursive(changedPath)\n      }\n    } catch (error) {\n      if (/**\n           * Narrows the runtime value to the documented type.\n            @type {{code?: string}} */ (error)?.code !== \"ENOENT\") {\n        throw error\n      }\n    }\n  }\n\n  /**\n   * Runs schedule reload.\n   * @param {string} changedPath - Changed path.\n   * @returns {void} - No return value.\n   */\n  scheduleReload(changedPath) {\n    this.pendingChangedPath = changedPath\n\n    if (this.reloadTimer) {\n      clearTimeout(this.reloadTimer)\n    }\n\n    this.reloadTimer = setTimeout(() => {\n      void this.flushReload()\n    }, this.debounceMs)\n  }\n\n  /**\n   * Runs flush reload.\n   * @returns {Promise<void>} - Resolves when the queued reload is handled.\n   */\n  async flushReload() {\n    this.reloadTimer = undefined\n\n    const changedPath = this.pendingChangedPath\n\n    if (!changedPath) return\n\n    this.pendingChangedPath = undefined\n    await this.onReload({changedPath})\n  }\n\n  /**\n   * On watcher error.\n   * @param {Error} error - Watcher error.\n   * @returns {void} - No return value.\n   */\n  onWatcherError = (error) => {\n    void this.logger.warn(\"Development hot reload watcher error\", error)\n  }\n\n  /**\n   * Runs stop.\n   * @returns {Promise<void>} - Resolves when watchers are closed.\n   */\n  async stop() {\n    if (this.reloadTimer) {\n      clearTimeout(this.reloadTimer)\n      this.reloadTimer = undefined\n    }\n\n    this.pendingChangedPath = undefined\n\n    for (const watcher of this.watchers.values()) {\n      watcher.close()\n    }\n\n    this.watchers.clear()\n  }\n}\n"]}