mockaton 8.22.0 → 8.23.0

package/README.md

@@ -1,4 +1,4 @@
-<img src="src/logo.svg" alt="Mockaton Logo" width="210" style="margin-top: 30px"/>
+<img src="src/Logo.svg" alt="Mockaton Logo" width="210" style="margin-top: 30px"/>
 
 ![NPM Version](https://img.shields.io/npm/v/mockaton)
 ![NPM Version](https://img.shields.io/npm/l/mockaton)
@@ -92,8 +92,9 @@ api/videos.GET.<b>500</b>.txt   # Internal Server Error
 ## Scraping Mocks from your Backend
 
 ### Option 1: Browser Extension
-With the companion [browser-devtools extension](https://github.com/ericfortis/download-http-requests-browser-ext)
-you can download all the HTTP responses at once, and they
+With the companion [browser-devtools
+extension](https://github.com/ericfortis/download-http-requests-browser-ext)
+you can download all the HTTP responses, and they
 get saved following Mockaton’s filename convention.
 
 ### Option 2: Fallback to Your Backend
@@ -117,260 +118,50 @@ They will be saved in your `config.mocksDir` following the filename convention.
 
 
 ## Basic Usage
-```sh
-npm install mockaton --save-dev
-```
-
-Create a `my-mockaton.js` file
-```js
-import { resolve } from 'node:path'
-import { Mockaton } from 'mockaton'
-
-
-Mockaton({
-  mocksDir: resolve('my-mocks-dir'), // must exist
-  port: 2345
-}) // The Config section below documents more options
-```
+Mockaton is a Node.js program with no dependencies.
 
+### Create a Sample Mock
+The default `--mocks-dir` is **mockaton-mocks** in the current working directory.
 ```sh
-node my-mockaton.js
+mkdir -p mockaton-mocks/api/
+echo "[1,2,3]" > mockaton-mocks/api/foo.GET.200.json
 ```
 
-<details>
-<summary>About TypeScript in Node < 23.6</summary>
-If you want to write mocks in TypeScript in a version older than Node 23.6:
-
-```shell
-npm install tsx
-node --import=tsx my-mockaton.js
-```
-</details>
-
-
-<br/>
-
-## Demo App (Vite + React)
-
-```sh  
-git clone https://github.com/ericfortis/mockaton.git
-cd mockaton/demo-app-vite
-npm install 
-
-npm run mockaton
-npm run start # in another terminal
-```
-
-The demo app has a list of colors containing all of their possible states. For example,
-permutations for out-of-stock, new-arrival, and discontinued.
-
-<img src="./demo-app-vite/pixaton-tests/pic-for-readme.vp740x880.light.gold.png" alt="Mockaton Demo App Screenshot" width="740" />
-
-<br/>
-<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`
-
-**Option A:** An Object, Array, or String is sent as JSON.
-
-```js
-export default { foo: 'bar' }
-```
-
-**Option B:** Function
-
-Return a `string | Buffer | Uint8Array`, but don’t call `response.end()`
-
-```js
-export default (request, response) =>
-  JSON.stringify({ foo: 'bar' })
+### Install and Run
+```sh
+npm install mockaton
+npx mockaton --port 2345
 ```
 
-Think of these functions as HTTP handlers. For example,
-you can intercept requests to write to a database.
-
-<details>
-<summary><b>See Intercepting Requests Examples</b></summary>
-
-Imagine you have an initial list of colors, and
-you want to concatenate newly added colors.
-
-`api/colors.POST.201.js`
-```js
-import { parseJSON } from 'mockaton'
-
-
-export default async function insertColor(request, response) {
-  const color = await parseJSON(request)
-  globalThis.newColorsDatabase ??= []
-  globalThis.newColorsDatabase.push(color)
-
-  // These two lines are not needed but you can change their values
-  //   response.statusCode = 201 // default derived from filename
-  //   response.setHeader('Content-Type', 'application/json') // unconditional default
-
-  return JSON.stringify({ msg: 'CREATED' })
-}
-```
+## CLI Options
 
-`api/colors.GET.200.js`
-```js
-import colorsFixture from './colors.json' with { type: 'json' }
+```txt
+-c, --config <file>       (default: ./mockaton.config.js)
 
+-m, --mocks-dir <dir>     (default: ./mockaton-mocks/)
+-s, --static-dir <dir>    (default: ./mockaton-static-mocks/)
 
-export default function listColors() {
-  return JSON.stringify([
-    ...colorsFixture,
-    ...(globalThis.newColorsDatabase || [])
-  ])
-}
+-H, --host <host>         (default: 127.0.0.1)
+-p, --port <port>         (default: 0) which means auto-assigned
 ```
-</details>
-
-<br/>
-
-**What if I need to serve a static .js or .ts?**
 
-**Option A:** Put it in your `config.staticDir` without the `.GET.200.js` extension.
 
-**Option B:** Read it and return it. For example:
+## mockaton.config.js
+Optionally, use a `mockaton.config.js` file
 ```js
-export default function (_, response) {
-  response.setHeader('Content-Type', 'application/javascript')
-  return readFileSync('./some-dir/foo.js', 'utf8')
-}
-```
+import { defineConfig } from 'mockaton'
 
-<br/>
-
-## Mock Filename Convention
-
-### Extension
-
-The last three dots are reserved for the HTTP Method,
-Response Status Code, and File Extension.
-
-```
-api/user.GET.200.json
+export default defineConfig({
+  port: 2345,
+  mocksDir: 'my-mocks-dir',
+  delayJitter: 0.5,
+  // …
+}) 
 ```
 
-You can also use `.empty` or `.unknown` if you don’t
-want a `Content-Type` header in the response.
-
 <details>
-<summary>Supported Methods</summary>
-<p>From <code>require('node:http').METHODS</code></p>
-<p>
-	ACL, BIND, CHECKOUT,
-	CONNECT, COPY, DELETE,
-	GET, HEAD, LINK,
-	LOCK, M-SEARCH, MERGE,
-	MKACTIVITY, MKCALENDAR, MKCOL,
-	MOVE, NOTIFY, OPTIONS,
-	PATCH, POST, PROPFIND,
-	PROPPATCH, PURGE, PUT,
-	QUERY, REBIND, REPORT,
-	SEARCH, SOURCE, SUBSCRIBE,
-	TRACE, UNBIND, UNLINK,
-	UNLOCK, UNSUBSCRIBE
-</p>
-</details>
-
-<br/>
-
-### Dynamic parameters
-Anything within square brackets is always matched. 
-
-For example, for <a href="#">/api/company/<b>123</b>/user/<b>789</b></a>,
-the filename could be:
-
-<pre><code>api/company/<b>[id]</b>/user/<b>[uid]</b>.GET.200.json</code></pre>
-
-<br/>
+<summary><b>See all config options</b></summary>
 
-### Comments
-Comments are anything within parentheses, including them.
-They are ignored for routing purposes, so they have no effect
-on the URL mask. For example, these two are for `/api/foo`
-<pre>
-api/foo<b>(my comment)</b>.GET.200.json
-api/foo.GET.200.json
-</pre>
-
-A filename can have many comments.
-
-<br/>
-
-### Default mock for a route
-You can add the comment: `(default)`.
-Otherwise, the first file in **alphabetical order** wins.
-
-<pre>
-api/user<b>(default)</b>.GET.200.json
-</pre>
-
-<br/>
-
-### Query string params
-The query string is ignored for routing purposes. In other words, it’s only used for
-documenting the URL contract.
-<pre>
-api/video<b>?limit=[limit]</b>.GET.200.json
-</pre>
-
-On Windows, filenames containing "?" are [not
-permitted](https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file), but since that’s part of the query
-string it’s ignored anyway.
-
-<br/>
-
-### Index-like routes
-If you have <a href="#">api/foo</a> and <a href="#">api/foo/bar</a>, you have two options:
-
-**Option A.** Standard naming:
-```
-api/foo.GET.200.json
-api/foo/bar.GET.200.json
-```
-
-**Option B.** Omit the URL on the filename:
-```text
-api/foo/.GET.200.json
-api/foo/bar.GET.200.json
-```
-
-<br/>
-
-## Config
 ### `mocksDir: string`
 This is the only required field. The directory must exist.
 
@@ -598,6 +389,235 @@ config.onReady = () => {}
 
 At any rate, you can trigger any command besides opening a browser.
 
+
+
+
+</details>
+
+
+
+<br/>
+
+## Demo App (Vite + React)
+
+```sh  
+git clone https://github.com/ericfortis/mockaton.git
+cd mockaton/demo-app-vite
+npm install 
+
+npm run mockaton
+npm run start # in another terminal
+```
+
+The demo app has a list of colors containing all of their possible states. For example,
+permutations for out-of-stock, new-arrival, and discontinued.
+
+<img src="./demo-app-vite/pixaton-tests/pic-for-readme.vp740x880.light.gold.png" alt="Mockaton Demo App Screenshot" width="740" />
+
+<br/>
+<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`
+
+**Option A:** An Object, Array, or String is sent as JSON.
+
+```js
+export default { foo: 'bar' }
+```
+
+**Option B:** Function
+
+Return a `string | Buffer | Uint8Array`, but don’t call `response.end()`
+
+```js
+export default (request, response) =>
+  JSON.stringify({ foo: 'bar' })
+```
+
+Think of these functions as HTTP handlers. For example,
+you can intercept requests to write to a database.
+
+<details>
+<summary><b>See Intercepting Requests Examples</b></summary>
+
+Imagine you have an initial list of colors, and
+you want to concatenate newly added colors.
+
+`api/colors.POST.201.js`
+```js
+import { parseJSON } from 'mockaton'
+
+
+export default async function insertColor(request, response) {
+  const color = await parseJSON(request)
+  globalThis.newColorsDatabase ??= []
+  globalThis.newColorsDatabase.push(color)
+
+  // These two lines are not needed but you can change their values
+  //   response.statusCode = 201 // default derived from filename
+  //   response.setHeader('Content-Type', 'application/json') // unconditional default
+
+  return JSON.stringify({ msg: 'CREATED' })
+}
+```
+
+`api/colors.GET.200.js`
+```js
+import colorsFixture from './colors.json' with { type: 'json' }
+
+
+export default function listColors() {
+  return JSON.stringify([
+    ...colorsFixture,
+    ...(globalThis.newColorsDatabase || [])
+  ])
+}
+```
+</details>
+
+<br/>
+
+**What if I need to serve a static .js or .ts?**
+
+**Option A:** Put it in your `config.staticDir` without the `.GET.200.js` extension.
+
+**Option B:** Read it and return it. For example:
+```js
+export default function (_, response) {
+  response.setHeader('Content-Type', 'application/javascript')
+  return readFileSync('./some-dir/foo.js', 'utf8')
+}
+```
+
+<br/>
+
+## Mock Filename Convention
+
+### Extension
+
+The last three dots are reserved for the HTTP Method,
+Response Status Code, and File Extension.
+
+```
+api/user.GET.200.json
+```
+
+You can also use `.empty` or `.unknown` if you don’t
+want a `Content-Type` header in the response.
+
+<details>
+<summary>Supported Methods</summary>
+<p>From <code>require('node:http').METHODS</code></p>
+<p>
+	ACL, BIND, CHECKOUT,
+	CONNECT, COPY, DELETE,
+	GET, HEAD, LINK,
+	LOCK, M-SEARCH, MERGE,
+	MKACTIVITY, MKCALENDAR, MKCOL,
+	MOVE, NOTIFY, OPTIONS,
+	PATCH, POST, PROPFIND,
+	PROPPATCH, PURGE, PUT,
+	QUERY, REBIND, REPORT,
+	SEARCH, SOURCE, SUBSCRIBE,
+	TRACE, UNBIND, UNLINK,
+	UNLOCK, UNSUBSCRIBE
+</p>
+</details>
+
+<br/>
+
+### Dynamic parameters
+Anything within square brackets is always matched. 
+
+For example, for <a href="#">/api/company/<b>123</b>/user/<b>789</b></a>,
+the filename could be:
+
+<pre><code>api/company/<b>[id]</b>/user/<b>[uid]</b>.GET.200.json</code></pre>
+
+<br/>
+
+### Comments
+Comments are anything within parentheses, including them.
+They are ignored for routing purposes, so they have no effect
+on the URL mask. For example, these two are for `/api/foo`
+<pre>
+api/foo<b>(my comment)</b>.GET.200.json
+api/foo.GET.200.json
+</pre>
+
+A filename can have many comments.
+
+<br/>
+
+### Default mock for a route
+You can add the comment: `(default)`.
+Otherwise, the first file in **alphabetical order** wins.
+
+<pre>
+api/user<b>(default)</b>.GET.200.json
+</pre>
+
+<br/>
+
+### Query string params
+The query string is ignored for routing purposes. In other words, it’s only used for
+documenting the URL contract.
+<pre>
+api/video<b>?limit=[limit]</b>.GET.200.json
+</pre>
+
+On Windows, filenames containing "?" are [not
+permitted](https://learn.microsoft.com/en-us/windows/win32/fileio/naming-a-file), but since that’s part of the query
+string it’s ignored anyway.
+
+<br/>
+
+### Index-like routes
+If you have <a href="#">api/foo</a> and <a href="#">api/foo/bar</a>, you have two options:
+
+**Option A.** Standard naming:
+```
+api/foo.GET.200.json
+api/foo/bar.GET.200.json
+```
+
+**Option B.** Omit the URL on the filename:
+```text
+api/foo/.GET.200.json
+api/foo/bar.GET.200.json
+```
+
+<br/>
+
 <br/>
 
 ## Commander API
@@ -694,4 +714,4 @@ hijack the client (e.g., `fetch`) in Node.js and browsers.
 
 ---
 
-![](./fixtures-mocks/api/user/avatar.GET.200.png)
+![](mockaton-mocks/api/user/avatar.GET.200.png)

package/index.d.ts

@@ -10,7 +10,7 @@ type Plugin = (
 }>
 
 interface Config {
-	mocksDir: string
+	mocksDir?: string
 	staticDir?: string
 	ignore?: RegExp
 
@@ -44,7 +44,8 @@ interface Config {
 }
 
 
-export function Mockaton(options: Config): Server
+export function Mockaton(options: Partial<Config>): Server
+export function defineConfig(options: Partial<Config>): Config
 
 export const jsToJsonPlugin: Plugin
 

package/index.js

@@ -1,6 +1,15 @@
+import { config } from './src/config.js'
+
 export { Mockaton } from './src/Mockaton.js'
-export { Commander } from './src/Commander.js'
+export { Commander } from './src/ApiCommander.js'
 
 export { jwtCookie } from './src/utils/jwt.js'
-export { parseJSON } from './src/utils/http-request.js'
+export { openInBrowser } from './src/utils/openInBrowser.js'
 export { jsToJsonPlugin } from './src/MockDispatcher.js'
+export { parseJSON, SUPPORTED_METHODS } from './src/utils/http-request.js'
+
+/** @param {Partial<Config>} opts */
+export const defineConfig = opts => ({
+	...config,
+	...opts
+})

package/package.json

@@ -2,22 +2,19 @@
 	"name": "mockaton",
 	"description": "HTTP Mock Server",
 	"type": "module",
-	"version": "8.22.0",
+	"version": "8.23.0",
 	"main": "index.js",
 	"types": "index.d.ts",
 	"license": "MIT",
 	"repository": "https://github.com/ericfortis/mockaton",
-	"keywords": [
-		"mock-server",
-		"rest-api",
-		"mock",
-		"api",
-		"testing"
-	],
+	"keywords": ["mock-server", "rest-api", "mock", "api", "testing"],
+	"bin": {
+		"mockaton": "src/cli.js"
+	},
 	"scripts": {
 		"test": "node --test \"src/**/*.test.js\"",
 		"coverage": "node --test --test-reporter=lcov --test-reporter-destination=.coverage/lcov.info --experimental-test-coverage \"src/**/*.test.js\"",
-		"start": "node --watch dev-mockaton.js",
+		"start": "node --watch src/cli.js -c dev.config.js",
 		"pixaton": "node --test --import=./pixaton-tests/_setup.js --experimental-test-isolation=none \"pixaton-tests/**/*.test.js\"",
 		"outdated": "npm outdated --parseable | awk -F: '{ printf \"npm i %-30s ;# %s\\n\", $4, $2 }'"
 	},

package/src/Api.js

@@ -16,11 +16,11 @@ import { sendOK, sendJSON, sendUnprocessableContent, sendFile } from './utils/ht
 
 const dashboardAssets = [
 	'/ApiConstants.js',
-	'/Commander.js',
+	'/ApiCommander.js',
 	'/Dashboard.css',
 	'/Dashboard.js',
 	'/Filename.js',
-	'/logo.svg'
+	'/Logo.svg'
 ]
 
 export const apiGetRequests = new Map([

package/src/Dashboard.js

@@ -1,6 +1,6 @@
 import { DEFAULT_500_COMMENT, HEADER_FOR_502 } from './ApiConstants.js'
 import { parseFilename } from './Filename.js'
-import { Commander } from './Commander.js'
+import { Commander } from './ApiCommander.js'
 
 
 const Strings = {
@@ -144,7 +144,7 @@ function Header() {
 		r('header', null,
 			r('img', {
 				alt: Strings.title,
-				src: 'mockaton/logo.svg',
+				src: 'mockaton/Logo.svg',
 				width: 160
 			}),
 			r('div', null,
@@ -885,7 +885,7 @@ function syntaxJSON(json) {
 	text(json.slice(lastIndex))
 	return frag
 }
-syntaxJSON.regex = /("(?:\\u[a-fA-F0-9]{4}|\\[^u]|[^\\"])*")(\s*:)?|([{}\[\],:]+)|\S+/g
+syntaxJSON.regex = /("(?:\\u[a-fA-F0-9]{4}|\\[^u]|[^\\"])*")(\s*:)?|([{}\[\],:\s]+)|\S+/g
 // Capture group order: [string, optional colon, punc]
 
 

package/src/Mockaton.js

@@ -16,15 +16,24 @@ import { sendNoContent, sendInternalServerError, sendUnprocessableContent } from
 process.on('unhandledRejection', error => { throw error })
 
 export function Mockaton(options) {
-	setup(options)
+	const error = setup(options)
+	if (error) {
+		console.error(error)
+		process.exitCode = 1
+		return
+	}
+
 	mockBrokerCollection.init()
 	staticCollection.init()
 	watchMocksDir()
 	watchStaticDir()
 
-	return createServer(onRequest).listen(config.port, config.host, function (error) {
+	const server = createServer(onRequest)
+
+	server.listen(config.port, config.host, function (error) {
 		if (error) {
 			console.error(error)
+			process.exit(1)
 			return
 		}
 		const { address, port } = this.address()
@@ -33,8 +42,16 @@ export function Mockaton(options) {
 		console.log('Dashboard', url + API.dashboard)
 		config.onReady(url + API.dashboard)
 	})
+
+	server.on('error', error => {
+		console.error(error.message)
+		process.exit(1)
+	})
+
+	return server
 }
 
+
 async function onRequest(req, response) {
 	response.on('error', console.error)
 

package/src/cli.js

@@ -0,0 +1,68 @@
+#!/usr/bin/env node
+
+import { join } from 'node:path'
+import { parseArgs } from 'node:util'
+
+import { isFile } from './utils/fs.js'
+import { Mockaton } from '../index.js'
+import pkgJSON from '../package.json' with { type: 'json' }
+
+
+const args = parseArgs({
+	options: {
+		config: { short: 'c', type: 'string' },
+
+		port: { short: 'p', type: 'string' },
+		host: { short: 'H', type: 'string' },
+
+		'mocks-dir': { short: 'm', type: 'string' },
+		'static-dir': { short: 's', type: 'string' },
+
+		help: { short: 'h', type: 'boolean' },
+		version: { short: 'v', type: 'boolean' }
+	}
+}).values
+
+
+if (args.version)
+	console.log(pkgJSON.version)
+
+else if (args.help)
+	console.log(`
+Usage: mockaton [options]
+
+Options:
+  -c, --config <file>       (default: ./mockaton.config.js)
+  
+  -m, --mocks-dir <dir>     (default: ./mockaton-mocks/)
+  -s, --static-dir <dir>    (default: ./mockaton-static-mocks/)
+  
+  -H, --host <host>         (default: 127.0.0.1)
+  -p, --port <port>         (default: 0) which means auto-assigned
+  
+  -h, --help                Show this help
+  -v, --version             Show version
+
+Notes:
+  * mockaton.config.js supports more options, see:
+      https://github.com/ericfortis/mockaton?tab=readme-ov-file#config
+  * CLI options override their mockaton.config.js counterparts`)
+
+else if (args.config && !isFile(args.config)) {
+	console.error(`Invalid config file: ${args.config}`)
+	process.exitCode = 1
+}
+else {
+	const userConf = join(process.cwd(), args.config ?? 'mockaton.config.js')
+	const opts = isFile(userConf)
+		? (await import(userConf)).default ?? {}
+		: {}
+
+	if (args.host) opts.host = args.host
+	if (args.port) opts.port = Number(args.port)
+
+	if (args['mocks-dir']) opts.mocksDir = args['mocks-dir']
+	if (args['static-dir']) opts.staticDir = args['static-dir']
+
+	Mockaton(opts)
+}

package/src/config.js

@@ -1,4 +1,5 @@
-import { realpathSync } from 'node:fs'
+import { join, isAbsolute } from 'node:path'
+
 import { isDirectory } from './utils/fs.js'
 import { openInBrowser } from './utils/openInBrowser.js'
 import { jsToJsonPlugin } from './MockDispatcher.js'
@@ -14,8 +15,8 @@ import { validateCorsAllowedMethods, validateCorsAllowedOrigins } from './utils/
  * 	]
  * }} */
 const schema = {
-	mocksDir: ['', isDirectory],
-	staticDir: ['', optional(isDirectory)],
+	mocksDir: [join(process.cwd(), 'mockaton-mocks'), isDirectory],
+	staticDir: [join(process.cwd(), 'mockaton-static-mocks'), optional(isDirectory)],
 	ignore: [/(\.DS_Store|~)$/, is(RegExp)],
 
 	host: ['127.0.0.1', is(String)],
@@ -65,18 +66,30 @@ export const config = Object.seal(defaults)
 export const ConfigValidator = Object.freeze(validators)
 
 
+/** @param {Partial<Config>} options */
+export function setup(options) {
+	if (options.mocksDir && !isAbsolute(options.mocksDir)) 
+		options.mocksDir = join(process.cwd(), options.mocksDir)
+	
+	if (options.staticDir && !isAbsolute(options.staticDir))
+		options.staticDir = join(process.cwd(), options.staticDir)
+	
+	if (!options.staticDir && !isDirectory(defaults.staticDir))
+		options.staticDir = ''
+
+	try {
+		Object.assign(config, options)
+		validate(config, ConfigValidator)
+	}
+	catch (err) {
+		return err.message
+	}
+}
+
+
 export const isFileAllowed = f => !config.ignore.test(f)
 
 export const calcDelay = () => config.delayJitter
 	? config.delay * (1 + Math.random() * config.delayJitter)
 	: config.delay
 
-
-export function setup(options) {
-	Object.assign(config, options)
-	validate(config, ConfigValidator)
-
-	config.mocksDir = realpathSync(config.mocksDir)
-	if (config.staticDir)
-		config.staticDir = realpathSync(config.staticDir)
-}