mockaton 11.0.1 → 11.1.0

package/Makefile

@@ -6,7 +6,7 @@ watch:
 
 
 test:
-	@node --test 'src/**/*.test.js'
+	@MOCKATON_WATCHER_DEBOUNCE_MS=0 node --test 'src/**/*.test.js'
 
 test-docker:
 	@docker run --rm --interactive --tty \
@@ -16,7 +16,7 @@ test-docker:
 		make test
 
 coverage:
-	@node --test --experimental-test-coverage \
+	@MOCKATON_WATCHER_DEBOUNCE_MS=0 node --test --experimental-test-coverage \
 		--test-reporter=spec --test-reporter-destination=stdout \
 		--test-reporter=lcov --test-reporter-destination=lcov.info \
 		'src/**/*.test.js'

package/README.md

@@ -77,7 +77,7 @@ get saved following Mockaton’s filename convention.
 
 ### Option 2: Fallback to Your Backend
 <details>
-<summary>Details</summary>
+<summary>Learn more…</summary>
 
 This option could be a bit elaborate if your backend uses third-party authentication,
 because you’d have to manually inject cookies or `sessionStorage` tokens.
@@ -93,7 +93,12 @@ They will be saved in your `config.mocksDir` following the filename convention.
 
 <br/>
 
+<br/>
+
+
 ## Motivation
+<details>
+<summary>Motivation…</summary>
 
 **No API state should be too hard to test.**
 With Mockaton, developers can achieve correctness and speed.
@@ -116,15 +121,41 @@ With Mockaton, developers can achieve correctness and speed.
   - checking out long-lived branches
   - bisecting bugs
 
+</details>
+
+
+
+## Use Cases
+<details>
+<summary>Use Cases…</summary>
+
+### Testing Backend or Frontend
+- Empty responses
+- Errors such as _Bad Request_ and _Internal Server Error_
+- Mocking third-party APIs
+- Polled resources (for triggering their different states)
+  - alerts
+  - notifications
+  - slow to build resources
+
+### Testing Frontend
+- Spinners by delaying responses
+- Setting up UI tests
+
+### Demoing complex backend states
+Sometimes, the ideal flow you need is too difficult to reproduce from the actual backend.
+For this, you can **Bulk Select** mocks by comments to simulate the complete states
+you want. For example, by adding `(demo-part1)`, `(demo-part2)` to the filenames.
+
+Similarly, you can deploy a **Standalone Demo Server** by compiling the frontend app and
+putting its built assets in `config.staticDir`. And simulate the flow by Bulk Selecting mocks.
+The [aot-fetch-demo repo](https://github.com/ericfortis/aot-fetch-demo) has a working example.
+
+</details>
 
 <br/>
 
-## Privacy and Security
-- Zero dependencies (no runtime and no build packages).
-- Does not write to disk. Except when you select ✅ **Save Mocks** for scraping mocks from a backend.
-- Does not initiate network connections (no logs, no telemetry).
-- Does not hijack your HTTP client.
-- Auditable. Organized and small &mdash; under 4 KLoC (half is UI and tests).
+
 
 <br/>
 
@@ -147,6 +178,16 @@ npx mockaton --port 2345
 curl localhost:2345/api/foo 
 ```
 
+5. Optionally, use a `mockaton.config.js`
+```js
+import { defineConfig } from 'mockaton'
+
+export default defineConfig({
+  port: 2345,
+})
+```
+
+
 ### Alternative Installations
 <details>
 <summary>With NPM (package.json)…</summary>
@@ -185,6 +226,9 @@ ln -s `realpath mockaton/src/cli.js` ~/bin/mockaton # some dir in your $PATH
 ## CLI Options
 The CLI options override their counterparts in `mockaton.config.js`
 
+<details>
+<summary>CLI Options…</summary>
+
 ```txt
 -c, --config <file>    (default: ./mockaton.config.js)
 
@@ -200,10 +244,17 @@ The CLI options override their counterparts in `mockaton.config.js`
 -h, --help             Show this help
 -v, --version          Show version
 ```
+</details>
 
 
 ## mockaton.config.js (Optional)
+Mockaton looks for a file `mockaton.config.js` in its current working directory.
+
+<details>
+<summary>Defaults Overview… </summary>
+
 As an overview, these are the defaults:
+
 ```js
 import {
   defineConfig,
@@ -247,11 +298,14 @@ export default defineConfig({
   ],
 
   onReady: await openInBrowser,
+  watcherEnabled: true
 })
 ```
 
+</details>
+
 <details>
-<summary><b>Config Documentation</b></summary>
+<summary><b>Config Documentation…</b></summary>
 
 ### `mocksDir?: string`
 Defaults to `'mockaton-mocks'`. 
@@ -495,11 +549,18 @@ Defaults to `'normal'`.
 - `normal`: info, mock access, warnings, and errors
 - `verbose`: normal + API access
 
+<br/>
+
+
+### `watcherEnabled?: boolean`
+Defaults to `true`. When `true`, newly added mocks get registered,
+or unregistered when deleting them.
+
 </details>
 
 
 <details>
-<summary>Programmatic Launch (Optional)</summary>
+<summary>Programmatic Launch (Optional)…</summary>
 
 
 ```js
@@ -536,32 +597,6 @@ permutations for out-of-stock, new-arrival, and discontinued.
 <br/>
 
 
-## Use Cases
-### Testing Backend or Frontend
-- Empty responses
-- Errors such as _Bad Request_ and _Internal Server Error_
-- Mocking third-party APIs
-- Polled resources (for triggering their different states)
-  - alerts
-  - notifications
-  - slow to build resources
-
-### Testing Frontend
-- Spinners by delaying responses
-- Setting up UI tests
-
-### Demoing complex backend states
-Sometimes, the ideal flow you need is too difficult to reproduce from the actual backend.
-For this, you can **Bulk Select** mocks by comments to simulate the complete states
-you want. For example, by adding `(demo-part1)`, `(demo-part2)` to the filenames.
-
-Similarly, you can deploy a **Standalone Demo Server** by compiling the frontend app and
-putting its built assets in `config.staticDir`. And simulate the flow by Bulk Selecting mocks.
-The [aot-fetch-demo repo](https://github.com/ericfortis/aot-fetch-demo) has a working example.
-
-
-<br/>
-
 
 ## You can write JSON mocks in JavaScript or TypeScript
 For example, `api/foo.GET.200.js`
@@ -841,6 +876,16 @@ await mockaton.reset()
 </details>
 
 
+<br/>
+
+## Privacy and Security
+- Zero dependencies (no runtime and no build packages).
+- Does not write to disk. Except when you select ✅ **Save Mocks** for scraping mocks from a backend.
+- Does not initiate network connections (no logs, no telemetry).
+- Does not hijack your HTTP client.
+- Auditable. Organized and small &mdash; under 4 KLoC (half is UI and tests).
+
+
 <br/>
 
 ## Alternatives worth learning as well
@@ -862,6 +907,12 @@ hijack the HTTP client in Node.js and browsers.
 - [Fetch Mock](https://github.com/wheresrhys/fetch-mock)
 - [Mentoss](https://github.com/humanwhocodes/mentoss) Has a server side too
 
+### Server Side
+
+- [Wire Mock](https://github.com/wiremock/wiremock)
+- [Mock](https://github.com/dhuan/mock)
+- [Swagger](https://swagger.io/)
+
 <br/>
 
 ---

package/index.d.ts

@@ -5,7 +5,7 @@ type Plugin = (
 	request: IncomingMessage,
 	response: OutgoingMessage
 ) => Promise<{
-	mime: string,
+	mime: string
 	body: string | Uint8Array
 }>
 
@@ -30,7 +30,7 @@ interface Config {
 	extraHeaders?: string[]
 	extraMimes?: { [fileExt: string]: string }
 
-	corsAllowed?: boolean,
+	corsAllowed?: boolean
 	corsOrigins?: string[]
 	corsMethods?: string[]
 	corsHeaders?: string[]
@@ -42,10 +42,13 @@ interface Config {
 	plugins?: [filenameTester: RegExp, plugin: Plugin][]
 
 	onReady?: (address: string) => void
+
+	watcherEnabled?: boolean
 }
 
 
 export function Mockaton(options: Partial<Config>): Promise<Server | undefined>
+
 export function defineConfig(options: Partial<Config>): Partial<Config>
 
 export const jsToJsonPlugin: Plugin

package/package.json

@@ -2,7 +2,7 @@
 	"name": "mockaton",
 	"description": "HTTP Mock Server",
 	"type": "module",
-	"version": "11.0.1",
+	"version": "11.1.0",
 	"main": "index.js",
 	"types": "index.d.ts",
 	"license": "MIT",

package/src/Api.js

@@ -12,7 +12,7 @@ import * as staticCollection from './staticCollection.js'
 import * as mockBrokersCollection from './mockBrokersCollection.js'
 import { config, ConfigValidator } from './config.js'
 import { DashboardHtml, CSP } from './DashboardHtml.js'
-import { sendOK, sendJSON, sendUnprocessableContent, sendFile, sendHTML } from './utils/http-response.js'
+import { sendOK, sendJSON, sendUnprocessable, sendFile, sendHTML } from './utils/http-response.js'
 import { API, LONG_POLL_SERVER_TIMEOUT, HEADER_SYNC_VERSION } from './ApiConstants.js'
 
 
@@ -81,7 +81,8 @@ function getState(_, response) {
 
 
 function longPollClientSyncVersion(req, response) {
-	if (uiSyncVersion.version !== Number(req.headers[HEADER_SYNC_VERSION])) {
+	const clientVersion = req.headers[HEADER_SYNC_VERSION]
+	if (clientVersion !== undefined && uiSyncVersion.version !== Number(clientVersion)) {
 		// e.g., tab was hidden while new mocks were added or removed
 		sendJSON(response, uiSyncVersion.version)
 		return
@@ -115,7 +116,7 @@ async function selectCookie(req, response) {
 
 	const error = cookie.setCurrent(cookieKey)
 	if (error)
-		sendUnprocessableContent(response, error?.message || error)
+		sendUnprocessable(response, error?.message || error)
 	else
 		sendJSON(response, cookie.list())
 }
@@ -126,7 +127,7 @@ async function selectMock(req, response) {
 
 	const broker = mockBrokersCollection.brokerByFilename(file)
 	if (!broker || !broker.hasMock(file))
-		sendUnprocessableContent(response, `Missing Mock: ${file}`)
+		sendUnprocessable(response, `Missing Mock: ${file}`)
 	else {
 		broker.selectFile(file)
 		sendJSON(response, broker)
@@ -139,7 +140,7 @@ async function toggle500(req, response) {
 
 	const broker = mockBrokersCollection.brokerByRoute(method, urlMask)
 	if (!broker)
-		sendUnprocessableContent(response, `Route does not exist: ${method} ${urlMask}`)
+		sendUnprocessable(response, `Route does not exist: ${method} ${urlMask}`)
 	else {
 		broker.toggle500()
 		sendJSON(response, broker)
@@ -152,9 +153,9 @@ async function setRouteIsDelayed(req, response) {
 
 	const broker = mockBrokersCollection.brokerByRoute(method, urlMask)
 	if (!broker)
-		sendUnprocessableContent(response, `Route does not exist: ${method} ${urlMask}`)
+		sendUnprocessable(response, `Route does not exist: ${method} ${urlMask}`)
 	else if (typeof delayed !== 'boolean')
-		sendUnprocessableContent(response, `Expected boolean for "delayed"`)
+		sendUnprocessable(response, `Expected boolean for "delayed"`)
 	else {
 		broker.setDelayed(delayed)
 		sendJSON(response, broker)
@@ -167,11 +168,11 @@ async function setRouteIsProxied(req, response) {
 
 	const broker = mockBrokersCollection.brokerByRoute(method, urlMask)
 	if (!broker)
-		sendUnprocessableContent(response, `Route does not exist: ${method} ${urlMask}`)
+		sendUnprocessable(response, `Route does not exist: ${method} ${urlMask}`)
 	else if (typeof proxied !== 'boolean')
-		sendUnprocessableContent(response, `Expected boolean for "proxied"`)
+		sendUnprocessable(response, `Expected boolean for "proxied"`)
 	else if (proxied && !config.proxyFallback)
-		sendUnprocessableContent(response, `There’s no proxy fallback`)
+		sendUnprocessable(response, `There’s no proxy fallback`)
 	else {
 		broker.setProxied(proxied)
 		sendJSON(response, broker)
@@ -183,7 +184,7 @@ async function updateProxyFallback(req, response) {
 	const fallback = await parseJSON(req)
 
 	if (!ConfigValidator.proxyFallback(fallback))
-		sendUnprocessableContent(response, `Invalid Proxy Fallback URL`)
+		sendUnprocessable(response, `Invalid Proxy Fallback URL`)
 	else {
 		config.proxyFallback = fallback
 		sendOK(response)
@@ -195,7 +196,7 @@ async function setCollectProxied(req, response) {
 	const collectProxied = await parseJSON(req)
 
 	if (!ConfigValidator.collectProxied(collectProxied))
-		sendUnprocessableContent(response, `Expected a boolean for "collectProxied"`)
+		sendUnprocessable(response, `Expected a boolean for "collectProxied"`)
 	else {
 		config.collectProxied = collectProxied
 		sendOK(response)
@@ -215,7 +216,7 @@ async function setCorsAllowed(req, response) {
 	const corsAllowed = await parseJSON(req)
 
 	if (!ConfigValidator.corsAllowed(corsAllowed))
-		sendUnprocessableContent(response, `Expected boolean for "corsAllowed"`)
+		sendUnprocessable(response, `Expected boolean for "corsAllowed"`)
 	else {
 		config.corsAllowed = corsAllowed
 		sendOK(response)
@@ -227,7 +228,7 @@ async function setGlobalDelay(req, response) {
 	const delay = await parseJSON(req)
 
 	if (!ConfigValidator.delay(delay))
-		sendUnprocessableContent(response, `Expected non-negative integer for "delay"`)
+		sendUnprocessable(response, `Expected non-negative integer for "delay"`)
 	else {
 		config.delay = delay
 		sendOK(response)
@@ -241,9 +242,9 @@ async function setStaticRouteStatusCode(req, response) {
 
 	const broker = staticCollection.brokerByRoute(urlMask)
 	if (!broker)
-		sendUnprocessableContent(response, `Static route does not exist: ${urlMask}`)
+		sendUnprocessable(response, `Static route does not exist: ${urlMask}`)
 	else if (!(status === 200 || status === 404))
-		sendUnprocessableContent(response, `Expected 200 or 404 status code`)
+		sendUnprocessable(response, `Expected 200 or 404 status code`)
 	else {
 		broker.setStatus(status)
 		sendOK(response)
@@ -256,9 +257,9 @@ async function setStaticRouteIsDelayed(req, response) {
 
 	const broker = staticCollection.brokerByRoute(urlMask)
 	if (!broker)
-		sendUnprocessableContent(response, `Static route does not exist: ${urlMask}`)
+		sendUnprocessable(response, `Static route does not exist: ${urlMask}`)
 	else if (typeof delayed !== 'boolean')
-		sendUnprocessableContent(response, `Expected boolean for "delayed"`)
+		sendUnprocessable(response, `Expected boolean for "delayed"`)
 	else {
 		broker.setDelayed(delayed)
 		sendOK(response)

package/src/ApiCommander.js

@@ -9,80 +9,49 @@ export class Commander {
 		this.#addr = addr
 	}
 
-	#patch = (api, body) =>
-		fetch(this.#addr + api, {
-			method: 'PATCH',
-			body: JSON.stringify(body)
-		})
-
 	/** @returns {JsonPromise<State>} */
 	getState = () =>
 		fetch(this.#addr + API.state)
 
-	/** @returns {JsonPromise<number>} */
-	getSyncVersion = (currSyncVer, abortSignal = undefined) =>
+	/** 
+	 * @param {number?} currSyncVer - On mismatch, it responds immediately. Otherwise, long polls.
+	 * @param {AbortSignal} abortSignal
+	 * @returns {JsonPromise<number>}
+	 */
+	getSyncVersion = (currSyncVer = undefined, abortSignal = undefined) =>
 		fetch(this.#addr + API.syncVersion, {
 			signal: AbortSignal.any([
 				abortSignal,
 				AbortSignal.timeout(LONG_POLL_SERVER_TIMEOUT + 1000)
 			].filter(Boolean)),
-			headers: {
-				[HEADER_SYNC_VERSION]: currSyncVer
-			}
+			headers: currSyncVer !== undefined 
+				? { [HEADER_SYNC_VERSION]: currSyncVer } 
+				: {}
 		})
 
 
-	reset() {
-		return this.#patch(API.reset)
-	}
-
-	setGlobalDelay(delay) {
-		return this.#patch(API.globalDelay, delay)
-	}
-
-	bulkSelectByComment(comment) {
-		return this.#patch(API.bulkSelect, comment)
-	}
-
-	selectCookie(cookieKey) {
-		return this.#patch(API.cookies, cookieKey)
-	}
-
-	setProxyFallback(proxyAddr) {
-		return this.#patch(API.fallback, proxyAddr)
-	}
-
-	setCollectProxied(shouldCollect) {
-		return this.#patch(API.collectProxied, shouldCollect)
-	}
-
-	setCorsAllowed(value) {
-		return this.#patch(API.cors, value)
-	}
-
-	
-	select(file) {
-		return this.#patch(API.select, file)
+	#patch(api, body) {
+		return fetch(this.#addr + api, {
+			method: 'PATCH',
+			body: JSON.stringify(body)
+		})
 	}
 
-	toggle500(method, urlMask) {
-		return this.#patch(API.toggle500, [method, urlMask])
-	}
+	reset = () => this.#patch(API.reset)
 
-	setRouteIsDelayed(method, urlMask, delayed) {
-		return this.#patch(API.delay, [method, urlMask, delayed])
-	}
+	selectCookie = label => this.#patch(API.cookies, label)
+	setGlobalDelay = delay => this.#patch(API.globalDelay, delay)
+	setCorsAllowed = value => this.#patch(API.cors, value)
+	setProxyFallback = proxyAddr => this.#patch(API.fallback, proxyAddr)
+	setCollectProxied = shouldCollect => this.#patch(API.collectProxied, shouldCollect)
 
-	setRouteIsProxied(method, urlMask, proxied) {
-		return this.#patch(API.proxied, [method, urlMask, proxied])
-	}
-	
+	select = file => this.#patch(API.select, file)
+	bulkSelectByComment = comment => this.#patch(API.bulkSelect, comment)
 
-	setStaticRouteIsDelayed(urlMask, delayed) {
-		return this.#patch(API.delayStatic, [urlMask, delayed])
-	}
+	toggle500 = (method, urlMask) => this.#patch(API.toggle500, [method, urlMask])
+	setRouteIsProxied = (method, urlMask, proxied) => this.#patch(API.proxied, [method, urlMask, proxied])
+	setRouteIsDelayed = (method, urlMask, delayed) => this.#patch(API.delay, [method, urlMask, delayed])
 
-	setStaticRouteStatus(urlMask, status) {
-		return this.#patch(API.staticStatus, [urlMask, status])
-	}
+	setStaticRouteStatus = (urlMask, status) => this.#patch(API.staticStatus, [urlMask, status])
+	setStaticRouteIsDelayed = (urlMask, delayed) => this.#patch(API.delayStatic, [urlMask, delayed])
 }

package/src/Dashboard.js

@@ -734,7 +734,7 @@ function SettingsIcon() {
  * The version increments when a mock file is added, removed, or renamed.
  */
 function initRealTimeUpdates() {
-	let oldVersion = -1
+	let oldVersion = undefined // undefined waits until next event or timeout 
 	let controller = new AbortController()
 
 	longPoll()
@@ -755,11 +755,9 @@ function initRealTimeUpdates() {
 					ErrorToast.close()
 
 				const version = await response.json()
-				const skipUpdate = oldVersion === -1
 				if (oldVersion !== version) { // because it could be < or >
 					oldVersion = version
-					if (!skipUpdate)
-						store.fetchState()
+					store.fetchState()
 				}
 				longPoll()
 			}

package/src/MockBroker.js

@@ -2,8 +2,8 @@ import { includesComment, extractComments, parseFilename } from './Filename.js'
 import { DEFAULT_MOCK_COMMENT } from './ApiConstants.js'
 
 
-/** 
- * MockBroker is a state for a particular route. It knows the available mock 
+/**
+ * MockBroker is a state for a particular route. It knows the available mock
  * files that can be served for the route, the currently selected file, etc.
  */
 export class MockBroker {
@@ -27,7 +27,7 @@ export class MockBroker {
 	}
 
 	register(file) {
-		if (this.auto500 && this.#is500(file)) // TESTME
+		if (this.auto500 && this.#is500(file))
 			this.selectFile(file)
 		this.mocks.push(file)
 		this.#sortMocks()
@@ -114,7 +114,7 @@ class UrlMatcher {
 	}
 
 	#disregardVariables(str) { // Stars out all parts that are in square brackets
-		return str.replace(/\[.*?]/g, '[^/]*')
+		return str.replace(/\[.*?]/g, '[^/]+')
 	}
 
 	// Appending a '/' so URLs ending with variables don't match

package/src/MockDispatcher.js

@@ -14,11 +14,11 @@ import { sendInternalServerError, sendMockNotFound } from './utils/http-response
 export async function dispatchMock(req, response) {
 	try {
 		const isHead = req.method === 'HEAD'
-		
+
 		let broker = mockBrokerCollection.brokerByRoute(req.method, req.url)
 		if (!broker && isHead)
 			broker = mockBrokerCollection.brokerByRoute('GET', req.url)
-		
+
 		if (config.proxyFallback && (!broker || broker.proxied)) {
 			await proxy(req, response, broker?.delayed ? calcDelay() : 0)
 			return
@@ -42,6 +42,7 @@ export async function dispatchMock(req, response) {
 		logger.accessMock(req.url, broker.file)
 		response.setHeader('Content-Type', mime)
 		response.setHeader('Content-Length', length(body))
+		
 		setTimeout(() => response.end(isHead ? null : body),
 			Number(broker.delayed && calcDelay()))
 	}

package/src/Mockaton.js

@@ -11,7 +11,7 @@ import { setCorsHeaders, isPreflight } from './utils/http-cors.js'
 import { watchMocksDir, watchStaticDir } from './Watcher.js'
 import { apiPatchRequests, apiGetRequests } from './Api.js'
 import { BodyReaderError, hasControlChars } from './utils/http-request.js'
-import { sendNoContent, sendInternalServerError, sendUnprocessableContent, sendTooLongURI, sendBadRequest } from './utils/http-response.js'
+import { sendNoContent, sendInternalServerError, sendUnprocessable, sendTooLongURI, sendBadRequest } from './utils/http-response.js'
 
 
 export function Mockaton(options) {
@@ -20,8 +20,11 @@ export function Mockaton(options) {
 
 		mockBrokerCollection.init()
 		staticCollection.init()
-		watchMocksDir()
-		watchStaticDir()
+
+		if (options.watcherEnabled) {
+			watchMocksDir()
+			watchStaticDir()
+		}
 
 		const server = createServer(onRequest)
 		server.on('error', reject)
@@ -75,7 +78,7 @@ async function onRequest(req, response) {
 	}
 	catch (error) {
 		if (error instanceof BodyReaderError)
-			sendUnprocessableContent(response, `${error.name}: ${error.message}`)
+			sendUnprocessable(response, `${error.name}: ${error.message}`)
 		else
 			sendInternalServerError(response, error)
 	}

package/src/ProxyRelay.js

@@ -6,7 +6,7 @@ import { extFor } from './utils/mime.js'
 import { write, isFile } from './utils/fs.js'
 import { makeMockFilename } from './Filename.js'
 import { readBody, BodyReaderError } from './utils/http-request.js'
-import { sendUnprocessableContent, sendBadGateway } from './utils/http-response.js'
+import { sendUnprocessable, sendBadGateway } from './utils/http-response.js'
 
 
 export async function proxy(req, response, delay) {
@@ -22,7 +22,7 @@ export async function proxy(req, response, delay) {
 	}
 	catch (error) { // TESTME
 		if (error instanceof BodyReaderError)
-			sendUnprocessableContent(response, error.name)
+			sendUnprocessable(response, error.name)
 		else
 			sendBadGateway(response, error)
 		return

package/src/StaticDispatcher.js

@@ -1,13 +1,12 @@
 import { join } from 'node:path'
 import { readFileSync } from 'node:fs'
 
+import { isFile } from './utils/fs.js'
 import { logger } from './utils/logger.js'
 import { mimeFor } from './utils/mime.js'
 import { brokerByRoute } from './staticCollection.js'
 import { config, calcDelay } from './config.js'
 import { sendMockNotFound, sendPartialContent } from './utils/http-response.js'
-import { execFileSync } from 'node:child_process'
-import { isFile } from './utils/fs.js'
 
 
 export async function dispatchStatic(req, response) {

package/src/Watcher.js

@@ -15,9 +15,10 @@ import * as mockBrokerCollection from './mockBrokersCollection.js'
  * and also renames, which are two events (delete + add).
  */
 export const uiSyncVersion = new class extends EventEmitter {
+	delay = Number(process.env.MOCKATON_WATCHER_DEBOUNCE_MS ?? 80)
 	version = 0
 
-	increment = this.#debounce(() => {
+	increment = /** @type {function} */ this.#debounce(() => {
 		this.version++
 		super.emit('ARR')
 	})
@@ -33,7 +34,7 @@ export const uiSyncVersion = new class extends EventEmitter {
 		let timer
 		return () => {
 			clearTimeout(timer)
-			timer = setTimeout(fn, 80)
+			timer = setTimeout(fn, this.delay)
 		}
 	}
 }
@@ -64,7 +65,7 @@ export function watchStaticDir() {
 	const dir = config.staticDir
 	if (!dir)
 		return
-	
+
 	watch(dir, { recursive: true, persistent: false }, (_, file) => {
 		if (!file)
 			return

package/src/config.js

@@ -49,7 +49,9 @@ const schema = {
 			[/\.(js|ts)$/, jsToJsonPlugin]
 		], Array.isArray],
 
-	onReady: [await openInBrowser, is(Function)]
+	onReady: [await openInBrowser, is(Function)],
+	
+	watcherEnabled: [true, is(Boolean)],
 }
 
 

package/src/mockBrokersCollection.js

@@ -41,20 +41,22 @@ export function init() {
 /** @returns {boolean} registered */
 export function registerMock(file, isFromWatcher = false) {
 	if (brokerByFilename(file)?.hasMock(file)
-		|| !isFileAllowed(basename(file)) // TESTME
+		|| !isFileAllowed(basename(file))
 		|| !filenameIsValid(file))
 		return false
 
 	const { method, urlMask } = parseFilename(file)
 	collection[method] ??= {}
 
-	if (!collection[method][urlMask])
-		collection[method][urlMask] = new MockBroker(file)
+	let broker = collection[method][urlMask]
+
+	if (!broker)
+		broker = collection[method][urlMask] = new MockBroker(file)
 	else
-		collection[method][urlMask].register(file)
+		broker.register(file)
 
-	if (isFromWatcher && !collection[method][urlMask].file) // TESTME e.g. auto500 is selected and adding a new one
-		collection[method][urlMask].selectDefaultFile()
+	if (isFromWatcher && !broker.file)
+		broker.selectDefaultFile()
 
 	return true
 }
@@ -83,8 +85,7 @@ export function unregisterMock(file) {
 /** @returns {MockBroker | undefined} */
 export function brokerByFilename(file) {
 	const { method, urlMask } = parseFilename(file)
-	if (collection[method])
-		return collection[method][urlMask]
+	return collection[method]?.[urlMask]
 }
 
 /**
@@ -113,7 +114,7 @@ export function extractAllComments() {
 }
 
 export function setMocksMatchingComment(comment) {
-	forEachBroker(b => 
+	forEachBroker(b =>
 		b.setByMatchingComment(comment))
 }
 

package/src/utils/http-response.js

@@ -53,7 +53,7 @@ export function sendTooLongURI(response) {
 	response.end()
 }
 
-export function sendUnprocessableContent(response, error) {
+export function sendUnprocessable(response, error) {
 	logger.access(response, error)
 	response.statusCode = 422
 	response.end(error)