mockaton 6.4.6 → 7.0.0

package/README.md

@@ -12,35 +12,41 @@ my-mocks-dir/api/user/[user-id].GET.200.json
 [This browser extension](https://github.com/ericfortis/devtools-ext-tar-http-requests)
 can be used for downloading a TAR of your XHR requests following that convention.
 
-## What do I use Mockaton for?
+## What do I use it for?
 - I’m a frontend dev, so I don’t have to spin up and maintain hefty or complex backends.
-- For a deterministic and comprehensive state. Having all the possible
-  state variants at once lets me visually spot inadvertent bugs right away.
+- For a deterministic and comprehensive backend state. For example, having all the possible
+  state variants of a particular collection helps for spotting inadvertent bugs. And having those
+  assorted responses are not easy to trigger from the backend.
 - Testing empty responses.
 - Testing spinners by delaying responses.
-- Triggering errors such as Bad Request and Internal Server Error.
+- Testing errors such as _Bad Request_ and _Internal Server Error_.
 - Triggering notifications and alerts.
-- As check-in the mocks in the repo, when bisecting a bug, I don’t
+- Prototyping before the backend API is developed.
+- Setting up tests.
+- If you commit the mocks in the repo, when bisecting a bug, you don’t
   have to sync the frontend with many backend repos.
   - Similarly, I can check out long-lived branches that have old API contracts.
-- Prototyping before the backend API is developed.
 - As API documentation.
-- Setting up tests.
 
 ## Alternatives
 - Chrome DevTools allows for [overriding responses](https://developer.chrome.com/docs/devtools/overrides)
 - Reverse Proxies such as [Burp](https://portswigger.net/burp) are also handy for overriding responses.
-- [Storybook](https://storybook.js.org)
+- Storybook’s [MSW](https://storybook.js.org/addons/msw-storybook-addon)
 
 ### Caveats
-- Syncing the mocks. The browser extension mentioned above helps.
+- Syncing the mocks, but the browser extension mentioned above helps.
 
 
 ## Getting Started
 The best way to learn _Mockaton_ is by checking out this repo and
 exploring its [sample-mocks/](./sample-mocks) directory. Then, run
-[`./_usage_example.js`](./_usage_example.js) and you’ll see this dashboard:
+[`./_usage_example.js`](./_usage_example.js) and you’ll see the dashboard.
+
+You can select mock files without resetting Mockaton. The _Reset_
+button is for when you add, remove, or rename a mock file.
 
+The dropdown lets you pick a mock variant, details in the next section. Next to it is a
+_Delay_ toggler, and a button for sending _500 - Internal Server Error_ on that endpoint.
 
 <img src="./README-dashboard.png" style="max-width:820px"/>
 
@@ -282,60 +288,52 @@ Config.onReady = open
 
 ---
 
-## API
-
-### Select a mock for a route
+## HTTP API
+`Commander` is a wrapper for the Mockaton HTTP API.
+All of its methods return their `fetch` response promise.
 ```js
-fetch(addr + '/mockaton/edit', {
-  method: 'PATCH',
-  body: JSON.stringify({
-    file: 'api/foo.200.GET.json',
-    delayed: true // optional
-  })
-})
+import { Commander } from 'mockaton'
+
+
+const myMockatonAddr = 'http://localhost:2345'
+const commander = new Commander(myMockatonAddr)
 ```
 
+### Select a mock file for a route
+```js
+await commander.select('api/foo.200.GET.json')
+```
 ### Select all mocks that have a particular comment
 ```js
-fetch(addr + '/mockaton/bulk-select-by-comment', {
-  method: 'PATCH',
-  body: JSON.stringify('(demo-a)')
-})
+await commander.bulkSelectByComment('(demo-a)')
 ```
 
-### List Cookies
-Sends a list of the available cookies along with an "is selected" boolean flag.
+### Set Route is Delayed Flag
 ```js
-fetch(addr + '/mockaton/cookies')
+await commander.setRouteIsDelayed('GET', '/api/foo', true)
 ```
 
 ### Select a cookie
-In `Config.cookies`, each key is the label used for changing it.
+In `Config.cookies`, each key is the label used for selecting it.
 ```js
-fetch(addr + '/mockaton/cookies', {
-  method: 'PATCH',
-  body: JSON.stringify('My Normal User')
-})
+await commander.selectCookie('My Normal User')
 ```
 
-### Update Fallback Proxy
+### Set Fallback Proxy
 ```js
-fetch(addr + '/mockaton/fallback', {
-  method: 'PATCH',
-  body: JSON.stringify('http://example.com')
-})
+await commander.setProxyFallback('http://example.com')
 ```
+Pass an empty string to disable it.
 
 ### Reset
 Re-initialize the collection. So if you added or removed mocks they
 will be considered. The selected mocks, cookies, and delays go
-back to default, but `Config.proxyFalllback` is not affected.
+back to default, but `Config.proxyFallback` is not affected.
 ```js
-fetch(addr + '/mockaton/reset', {
-  method: 'PATCH'
-})
+await commander.reset()
 ```
 
+
 ## TODO
-- Dashboard. List `staticDir` and indicate if it’s overriding some mock.
 - Refactor Tests
+- Dashboard. List `staticDir` and indicate if it’s overriding some mock.

package/Tests.js

@@ -11,8 +11,9 @@ import { writeFileSync, mkdtempSync, mkdirSync } from 'node:fs'
 import { Config } from './src/Config.js'
 import { mimeFor } from './src/utils/mime.js'
 import { Mockaton } from './src/Mockaton.js'
+import { Commander } from './src/Commander.js'
 import { parseFilename } from './src/Filename.js'
-import { API, DF, DEFAULT_500_COMMENT, DEFAULT_MOCK_COMMENT } from './src/ApiConstants.js'
+import { API, DEFAULT_500_COMMENT, DEFAULT_MOCK_COMMENT } from './src/ApiConstants.js'
 
 
 const tmpDir = mkdtempSync(tmpdir()) + '/'
@@ -36,6 +37,12 @@ const fixtureDefaultInName = [
 	'default my route body content'
 ]
 
+const fixtureDelayed = [
+	'/api/delayed',
+	'api/delayed.GET.200.json',
+	'Route_To_Be_Delayed'
+]
+
 const fixtures = [
 	[
 		'/api',
@@ -45,6 +52,7 @@ const fixtures = [
 
 	// Exact route paths
 	fixtureDefaultInName,
+	fixtureDelayed,
 	[
 		'/api/the-route',
 		'api/the-route(default).GET.200.json',
@@ -135,6 +143,8 @@ writeStatic('index.html', '<h1>Static</h1>')
 writeStatic('assets/app.js', 'const app = 1')
 writeStatic('another-entry/index.html', '<h1>Another</h1>')
 
+
+
 const server = Mockaton({
 	mocksDir: tmpDir,
 	staticDir: staticTmpDir,
@@ -151,7 +161,19 @@ const server = Mockaton({
 })
 server.on('listening', runTests)
 
+function mockatonAddr() {
+	const { address, port } = server.address()
+	return `http://${address}:${port}`
+}
+
+function request(path, options = {}) {
+	return fetch(`${mockatonAddr()}${path}`, options)
+}
+
+let commander
 async function runTests() {
+	commander = new Commander(mockatonAddr())
+
 	await testItRendersDashboard()
 	await test404()
 
@@ -160,11 +182,7 @@ async function runTests() {
 
 	await testDefaultMock()
 
-	await testItUpdatesDelayAndFile(
-		'/api/alternative',
-		'api/alternative(comment-2).GET.200.json',
-		JSON.stringify({ comment: 2 }))
-
+	await testItUpdatesRouteDelay(...fixtureDelayed)
 	await testBadRequestWhenUpdatingNonExistingMockAlternative()
 
 	await testAutogenerates500(
@@ -176,14 +194,14 @@ async function runTests() {
 		'api/.GET.500.txt',
 		'keeps non-autogenerated 500')
 
-	await reset()
+	await commander.reset()
 	await testItUpdatesTheCurrentSelectedMock(
 		'/api/alternative',
 		'api/alternative(comment-2).GET.200.json',
 		200,
 		JSON.stringify({ comment: 2 }))
 
-	await reset()
+	await commander.reset()
 	await testExtractsAllComments([
 		'(comment-1)',
 		'(comment-2)',
@@ -197,7 +215,7 @@ async function runTests() {
 		['/api/my-route', 'api/my-route(comment-2).GET.200.json', { comment: 2 }]
 	])
 
-	await reset()
+	await commander.reset()
 	for (const [url, file, body] of fixtures)
 		await testMockDispatching(url, file, body)
 
@@ -212,9 +230,6 @@ async function runTests() {
 	server.close()
 }
 
-async function reset() {
-	await request(API.reset, { method: 'PATCH' })
-}
 
 async function testItRendersDashboard() {
 	const res = await request(API.dashboard)
@@ -259,10 +274,7 @@ async function testDefaultMock() {
 }
 
 async function testItUpdatesTheCurrentSelectedMock(url, file, expectedStatus, expectedBody) {
-	await request(API.edit, {
-		method: 'PATCH',
-		body: JSON.stringify({ [DF.file]: file })
-	})
+	await commander.select(file)
 	const res = await request(url)
 	const body = await res.text()
 	await describe('url: ' + url, () => {
@@ -271,19 +283,14 @@ async function testItUpdatesTheCurrentSelectedMock(url, file, expectedStatus, ex
 	})
 }
 
-async function testItUpdatesDelayAndFile(url, file, expectedBody) {
-	await request(API.edit, {
-		method: 'PATCH',
-		body: JSON.stringify({
-			[DF.file]: file,
-			[DF.delayed]: true
-		})
-	})
+async function testItUpdatesRouteDelay(url, file, expectedBody) {
+	const { method } = parseFilename(file)
+	await commander.setRouteIsDelayed(method, url, true)
 	const now = new Date()
 	const res = await request(url)
 	const body = await res.text()
 	await describe('url: ' + url, () => {
-		it('body is: ' + expectedBody, () => equal(body, expectedBody))
+		it('body is: ' + expectedBody, () => equal(body, JSON.stringify(expectedBody)))
 		it('delay', () => equal((new Date()).getTime() - now.getTime() > Config.delay, true))
 	})
 }
@@ -291,20 +298,14 @@ async function testItUpdatesDelayAndFile(url, file, expectedBody) {
 async function testBadRequestWhenUpdatingNonExistingMockAlternative() {
 	await it('There are mocks for /api/the-route but not this one', async () => {
 		const missingFile = 'api/the-route(non-existing-variant).GET.200.json'
-		const res = await request(API.edit, {
-			method: 'PATCH',
-			body: JSON.stringify({ [DF.file]: missingFile })
-		})
+		const res = await commander.select(missingFile)
 		equal(res.status, 400)
 		equal(await res.text(), `Missing Mock: ${missingFile}`)
 	})
 }
 
 async function testAutogenerates500(url, file) {
-	await request(API.edit, {
-		method: 'PATCH',
-		body: JSON.stringify({ [DF.file]: file })
-	})
+	await commander.select(file)
 	const res = await request(url)
 	const body = await res.text()
 	await describe('autogenerated in-memory 500', () => {
@@ -314,10 +315,7 @@ async function testAutogenerates500(url, file) {
 }
 
 async function testPreservesExiting500(url, file, expectedBody) {
-	await request(API.edit, {
-		method: 'PATCH',
-		body: JSON.stringify({ [DF.file]: file })
-	})
+	await commander.select(file)
 	const res = await request(url)
 	const body = await res.text()
 	await describe('preserves existing 500', () => {
@@ -327,17 +325,14 @@ async function testPreservesExiting500(url, file, expectedBody) {
 }
 
 async function testExtractsAllComments(expected) {
-	const res = await request(API.comments)
+	const res = await commander.listComments()
 	const body = await res.json()
 	await it('Extracts all comments without duplicates', () =>
 		deepEqual(body, expected))
 }
 
 async function testItBulkSelectsByComment(comment, tests) {
-	await request(API.bulkSelect, {
-		method: 'PATCH',
-		body: JSON.stringify(comment)
-	})
+	await commander.bulkSelectByComment(comment)
 	for (const [url, file, body] of tests)
 		await testMockDispatching(url, file, body)
 }
@@ -346,7 +341,7 @@ async function testItBulkSelectsByComment(comment, tests) {
 async function testItUpdatesUserRole() {
 	await describe('Cookie', () => {
 		it('Defaults to the first key:value', async () => {
-			const res = await request(API.cookies)
+			const res = await commander.listCookies()
 			deepEqual(await res.json(), [
 				['userA', true],
 				['userB', false]
@@ -354,11 +349,8 @@ async function testItUpdatesUserRole() {
 		})
 
 		it('Update the selected cookie', async () => {
-			await request(API.cookies, {
-				method: 'PATCH',
-				body: JSON.stringify('userB')
-			})
-			const res = await request(API.cookies)
+			await commander.selectCookie('userB')
+			const res = await commander.listCookies()
 			deepEqual(await res.json(), [
 				['userA', false],
 				['userB', true]
@@ -374,7 +366,7 @@ export default function (req, response) {
   response.setHeader('content-type', 'custom-mime')
   return 'SOME_STRING'
 }`)
-		await reset() // for registering the file
+		await commander.reset() // for registering the file
 		await testMockDispatching('/api/js-func',
 			'api/js-func.POST.200.js',
 			'SOME_STRING',
@@ -416,7 +408,7 @@ async function testInvalidFilenamesAreIgnored() {
 		write('api/_INVALID_FILENAME_CONVENTION_.json', '')
 		write('api/bad-filename-method._INVALID_METHOD_.200.json', '')
 		write('api/bad-filename-status.GET._INVALID_STATUS_.json', '')
-		await reset()
+		await commander.reset()
 		equal(consoleErrorSpy.mock.calls[0].arguments[0], 'Invalid Filename Convention')
 		equal(consoleErrorSpy.mock.calls[1].arguments[0], 'Unrecognized HTTP Method: "_INVALID_METHOD_"')
 		equal(consoleErrorSpy.mock.calls[2].arguments[0], 'Invalid HTTP Response Status: "NaN"')
@@ -432,10 +424,7 @@ async function testEnableFallbackSoRoutesWithoutMocksGetRelayed() {
 		})
 		await promisify(fallbackServer.listen).bind(fallbackServer, 0, '127.0.0.1')()
 
-		await request(API.fallback, { // Enable fallback
-			method: 'PATCH',
-			body: JSON.stringify(`http://localhost:${fallbackServer.address().port}`)
-		})
+		await commander.setProxyFallback(`http://localhost:${fallbackServer.address().port}`)
 		await it('Relays to fallback server', async () => {
 			const res = await request('/non-existing-mock')
 			equal(res.headers.get('custom_header'), 'my_custom_header')
@@ -461,8 +450,3 @@ function _write(absPath, data) {
 	writeFileSync(absPath, data, 'utf8')
 }
 
-function request(path, options = {}) {
-	const { address, port } = server.address()
-	return fetch(`http://${address}:${port}${path}`, options)
-}
-

package/index.d.ts

@@ -18,6 +18,29 @@ interface Config {
 	onReady?: (address: string) => void
 }
 
+
 export function Mockaton(options: Config): Server
 
+
 export function jwtCookie(cookieName: string, payload: any): string
+
+
+export class Commander {
+	constructor(addr: string)
+
+	select(file: string): Promise<Response>
+
+	bulkSelectByComment(comment: string): Promise<Response>
+
+	setRouteIsDelayed(routeMethod: string, routeUrlMask: string, delayed: boolean): Promise<Response>
+
+	selectCookie(cookieKey: string): Promise<Response>
+
+	setProxyFallback(proxyAddr: string): Promise<Response>
+
+	reset(): Promise<Response>
+
+	listCookies(): Promise<Response>
+
+	listComments(): Promise<Response>
+}

package/index.js

@@ -1,2 +1,3 @@
 export { Mockaton } from './src/Mockaton.js'
 export { jwtCookie } from './src/utils/jwt.js'
+export { Commander } from './src/Commander.js'

package/package.json

@@ -2,7 +2,7 @@
 	"name": "mockaton",
 	"description": "A deterministic server-side for developing and testing frontend clients",
 	"type": "module",
-	"version": "6.4.6",
+	"version": "7.0.0",
 	"main": "index.js",
 	"types": "index.d.ts",
 	"license": "MIT",

package/src/Api.js

@@ -25,7 +25,8 @@ export const apiGetRequests = new Map([
 ])
 
 export const apiPatchRequests = new Map([
-	[API.edit, updateBroker],
+	[API.select, selectMock],
+	[API.delay, setRouteIsDelayed],
 	[API.reset, reinitialize],
 	[API.cookies, selectCookie],
 	[API.fallback, updateProxyFallback],
@@ -45,6 +46,7 @@ function reinitialize(_, response) {
 	sendOK(response)
 }
 
+
 async function selectCookie(req, response) {
 	try {
 		cookie.setCurrent(await parseJSON(req))
@@ -55,16 +57,14 @@ async function selectCookie(req, response) {
 	}
 }
 
-async function updateBroker(req, response) {
+
+async function selectMock(req, response) {
 	try {
-		const body = await parseJSON(req)
-		const file = body[DF.file]
+		const file = await parseJSON(req)
 		const broker = mockBrokersCollection.getBrokerByFilename(file)
 		if (!broker || !broker.mockExists(file))
 			throw `Missing Mock: ${file}`
 
-		if (DF.delayed in body)
-			broker.updateDelay(body[DF.delayed])
 		broker.updateFile(file)
 		sendOK(response)
 	}
@@ -73,6 +73,26 @@ async function updateBroker(req, response) {
 	}
 }
 
+
+async function setRouteIsDelayed(req, response) {
+	try {
+		const body = await parseJSON(req)
+		const broker = mockBrokersCollection.getBrokerForUrl(
+			body[DF.routeMethod],
+			body[DF.routeUrlMask])
+
+		if (!broker)
+			throw `Route does not exist: ${body[DF.routeUrlMask]} ${body[DF.routeUrlMask]}`
+
+		broker.updateDelay(body[DF.delayed])
+		sendOK(response)
+	}
+	catch (error) {
+		sendBadRequest(response, error)
+	}
+}
+
+
 async function updateProxyFallback(req, response) {
 	try {
 		Config.proxyFallback = await parseJSON(req)
@@ -83,6 +103,7 @@ async function updateProxyFallback(req, response) {
 	}
 }
 
+
 async function bulkUpdateBrokersByCommentTag(req, response) {
 	try {
 		mockBrokersCollection.setMocksMatchingComment(await parseJSON(req))

package/src/ApiConstants.js

@@ -3,7 +3,8 @@ export const API = {
 	dashboard: MOUNT,
 	bulkSelect: MOUNT + '/bulk-select-by-comment',
 	comments: MOUNT + '/comments',
-	edit: MOUNT + '/edit',
+	select: MOUNT + '/select',
+	delay: MOUNT + '/delay',
 	mocks: MOUNT + '/mocks',
 	reset: MOUNT + '/reset',
 	cookies: MOUNT + '/cookies',
@@ -11,8 +12,9 @@ export const API = {
 }
 
 export const DF = { // Dashboard Fields (XHR)
-	delayed: 'delayed',
-	file: 'file'
+	routeMethod: 'route_method',
+	routeUrlMask: 'route_url_mask',
+	delayed: 'delayed'
 }
 
 export const DEFAULT_500_COMMENT = '(Mockaton 500)'

package/src/Commander.js

@@ -0,0 +1,54 @@
+import { API, DF } from './ApiConstants.js'
+
+
+export class Commander {
+	#addr = ''
+	constructor(addr) {
+		this.#addr = addr
+	}
+
+	select(file) {
+		return this.#patch(API.select, file)
+	}
+	bulkSelectByComment(comment) {
+		return this.#patch(API.bulkSelect, comment)
+	}
+
+	setRouteIsDelayed(routeMethod, routeUrlMask, delayed) {
+		return this.#patch(API.delay, {
+			[DF.routeMethod]: routeMethod,
+			[DF.routeUrlMask]: routeUrlMask,
+			[DF.delayed]: delayed
+		})
+	}
+
+	listCookies() {
+		return this.#get(API.cookies)
+	}
+	selectCookie(cookieKey) {
+		return this.#patch(API.cookies, cookieKey)
+	}
+
+	listComments() {
+		return this.#get(API.comments)
+	}
+
+	setProxyFallback(proxyAddr) {
+		return this.#patch(API.fallback, proxyAddr)
+	}
+
+	reset() {
+		return this.#patch(API.reset)
+	}
+
+
+	#get(api) {
+		return fetch(this.#addr + api)
+	}
+	#patch(api, body) {
+		return fetch(this.#addr + api, {
+			method: 'PATCH',
+			body: JSON.stringify(body)
+		})
+	}
+}

package/src/Dashboard.js

@@ -133,7 +133,7 @@ function SectionByMethod({ method, brokers }) {
 					r('tr', null,
 						r('td', null, r(PreviewLink, { method, urlMask })),
 						r('td', null, r(MockSelector, { broker })),
-						r('td', null, r(DelayToggler, { broker })),
+						r('td', null, r(DelayRouteToggler, { broker })),
 						r('td', null, r(InternalServerErrorToggler, { broker }))
 					))))
 }
@@ -188,9 +188,9 @@ function MockSelector({ broker }) {
 				this.style.fontWeight = this.value === this.options[0].value // default is selected
 					? 'normal'
 					: 'bold'
-				fetch(API.edit, {
+				fetch(API.select, {
 					method: 'PATCH',
-					body: JSON.stringify({ [DF.file]: this.value })
+					body: JSON.stringify(this.value)
 				})
 					.then(() => {
 						this.closest('tr').querySelector('a').click()
@@ -205,7 +205,7 @@ function MockSelector({ broker }) {
 		}, file))))
 }
 
-function DelayToggler({ broker }) {
+function DelayRouteToggler({ broker }) {
 	const name = broker.currentMock.file
 	const checked = Boolean(broker.currentMock.delay)
 	return (
@@ -219,10 +219,12 @@ function DelayToggler({ broker }) {
 				name,
 				checked,
 				onChange(event) {
-					fetch(API.edit, {
+					const { method, urlMask } = parseFilename(this.name)
+					fetch(API.delay, {
 						method: 'PATCH',
 						body: JSON.stringify({
-							[DF.file]: this.name,
+							[DF.routeMethod]: method,
+							[DF.routeUrlMask]: urlMask,
 							[DF.delayed]: event.currentTarget.checked
 						})
 					})
@@ -252,13 +254,11 @@ function InternalServerErrorToggler({ broker }) {
 				name,
 				checked,
 				onChange(event) {
-					fetch(API.edit, {
+					fetch(API.select, {
 						method: 'PATCH',
-						body: JSON.stringify({
-							[DF.file]: event.currentTarget.checked
-								? items.find(f => parseFilename(f).status === 500)
-								: items[0]
-						})
+						body: JSON.stringify(event.currentTarget.checked
+							? items.find(f => parseFilename(f).status === 500)
+							: items[0])
 					})
 						.then(init)
 						.catch(console.error)

package/src/MockDispatcher.js

@@ -1,5 +1,5 @@
 import { join } from 'node:path'
-import { readFileSync } from 'node:fs'
+import { readFileSync as read } from 'node:fs'
 
 import { proxy } from './ProxyRelay.js'
 import { cookie } from './cookie.js'
@@ -11,34 +11,40 @@ import { sendInternalServerError, sendNotFound, sendBadRequest } from './utils/h
 
 
 export async function dispatchMock(req, response) {
-	const broker = mockBrokerCollection.getBrokerForUrl(req.method, req.url)
-	if (!broker) {
-		if (Config.proxyFallback)
-			await proxy(req, response)
-		else
-			sendNotFound(response)
-		return
-	}
-
 	try {
+		const broker = mockBrokerCollection.getBrokerForUrl(req.method, req.url)
+		if (!broker) {
+			if (Config.proxyFallback)
+				await proxy(req, response)
+			else
+				sendNotFound(response)
+			return
+		}
+
 		const { file, status, delay } = broker
 		console.log(decodeURIComponent(req.url), ' → ', file)
+		const filePath = join(Config.mocksDir, file)
 
-		let mockText
+		let mockBody
 		if (file.endsWith('.js')) {
 			response.setHeader('Content-Type', mimeFor('.json'))
-			mockText = await jsMockText(file, req, response)
+			const jsExport = (await import(filePath + '?' + Date.now())).default // date for cache busting
+			mockBody = typeof jsExport === 'function'
+				? await jsExport(req, response)
+				: JSON.stringify(jsExport, null, 2)
 		}
 		else {
 			response.setHeader('Content-Type', mimeFor(file))
-			mockText = broker.isTemp500 ? '' : readMock(file)
+			mockBody = broker.isTemp500
+				? ''
+				: read(filePath)
 		}
-		
+
 		if (cookie.getCurrent())
 			response.setHeader('Set-Cookie', cookie.getCurrent())
 
 		response.writeHead(status, Config.extraHeaders)
-		setTimeout(() => response.end(mockText), delay)
+		setTimeout(() => response.end(mockBody), delay)
 	}
 	catch (error) {
 		if (error instanceof JsonBodyParserError)
@@ -49,19 +55,3 @@ export async function dispatchMock(req, response) {
 			sendInternalServerError(response, error)
 	}
 }
-
-async function jsMockText(file, req, response) {
-	const jsExport = await importDefault(file)
-	return typeof jsExport === 'function'
-		? await jsExport(req, response)
-		: JSON.stringify(jsExport, null, 2)
-}
-
-function readMock(file) {
-	return readFileSync(join(Config.mocksDir, file))
-}
-
-async function importDefault(file) {
-	// The date param is just for cache busting
-	return (await import(join(Config.mocksDir, file) + '?' + Date.now())).default
-}

package/src/Mockaton.js

@@ -11,31 +11,33 @@ import { apiPatchRequests, apiGetRequests } from './Api.js'
 export function Mockaton(options) {
 	setup(options)
 	mockBrokerCollection.init()
+	const server = createServer(onRequest)
+	server.listen(Config.port, Config.host, (error) => {
+		const { address, port } = server.address()
+		const url = `http://${address}:${port}`
+		console.log('Listening', url)
+		console.log('Dashboard', url + API.dashboard)
+		if (error)
+			console.error(error)
+		else
+			Config.onReady(url + API.dashboard)
+	})
+	return server
+}
 
-	return createServer(async (req, response) => {
-		response.setHeader('Server', 'Mockaton')
+async function onRequest(req, response) {
+	response.setHeader('Server', 'Mockaton')
 
-		const { url, method } = req
-		if (method === 'GET' && apiGetRequests.has(url))
-			apiGetRequests.get(url)(req, response)
+	const { url, method } = req
+	if (method === 'GET' && apiGetRequests.has(url))
+		apiGetRequests.get(url)(req, response)
 
-		else if (method === 'PATCH' && apiPatchRequests.has(url))
-			await apiPatchRequests.get(url)(req, response)
+	else if (method === 'PATCH' && apiPatchRequests.has(url))
+		await apiPatchRequests.get(url)(req, response)
 
-		else if (isStatic(req))
-			await dispatchStatic(req, response)
+	else if (isStatic(req))
+		await dispatchStatic(req, response)
 
-		else
-			await dispatchMock(req, response)
-	})
-		.listen(Config.port, Config.host, function (error) {
-			const { address, port } = this.address()
-			const url = `http://${address}:${port}`
-			console.log('Listening', url)
-			console.log('Dashboard', url + API.dashboard)
-			if (error)
-				console.error(error)
-			else
-				Config.onReady(url + API.dashboard)
-		})
+	else
+		await dispatchMock(req, response)
 }