mockaton 11.2.6 → 11.3.0

package/index.js

@@ -3,6 +3,6 @@ export { Commander } from './src/client/ApiCommander.js'
 export { Mockaton } from './src/server/Mockaton.js'
 export { jwtCookie } from './src/server/utils/jwt.js'
 export { jsToJsonPlugin } from './src/server/MockDispatcher.js'
-export { parseJSON, BodyReaderError } from './src/server/utils/http-request.js'
+export { parseJSON, BodyReaderError } from './src/server/utils/HttpIncomingMessage.js'
 
 export const defineConfig = opts => opts

package/package.json

@@ -2,14 +2,20 @@
 	"name": "mockaton",
 	"description": "HTTP Mock Server",
 	"type": "module",
-	"version": "11.2.6",
+	"version": "11.3.0",
 	"exports": {
 		".": {
 			"import": "./index.js",
 			"types": "./index.d.ts"
 		}
 	},
+	"files": [
+		"src",
+		"index.js",
+		"index.d.ts"
+	],
 	"license": "MIT",
+	"homepage": "https://mockaton.com",
 	"repository": "https://github.com/ericfortis/mockaton",
 	"keywords": [
 		"mock-server",

package/src/client/app-store.test.js

@@ -0,0 +1,81 @@
+import { test } from 'node:test'
+import { deepEqual } from 'node:assert'
+
+import { dittoSplitPaths, BrokerRowModel, t } from './app-store.js'
+
+
+test('dittoSplitPaths', () => {
+	const input = [
+		'/api/user',
+		'/api/user/avatar',
+		'/api/user/friends',
+		'/api/vid',
+		'/api/video/id',
+		'/api/video/stats',
+		'/v2/foo',
+		'/v2/foo/bar'
+	]
+	deepEqual(dittoSplitPaths(input), [
+		['', '/api/user'],
+		['/api/user/', 'avatar'],
+		['/api/user/', 'friends'],
+		['/api/', 'vid'],
+		['/api/', 'video/id'],
+		['/api/video/', 'stats'],
+		['', '/v2/foo'],
+		['/v2/foo/', 'bar']
+	])
+})
+
+
+test('BrokerRowModel', () => {
+	test('has Auto500 when is autogenerated 500', () => {
+		const broker = {
+			auto500: true,
+			file: 'api/user.GET.200.json',
+			mocks: ['api/user.GET.200.json']
+		}
+		const row = new BrokerRowModel(broker, false)
+		const opts = row.opts.map(([, n, selected]) => [n, selected])
+		deepEqual(opts, [
+			['200 json', false],
+			[t`Auto500`, true],
+		])
+	})
+
+	test('filename has extension except when empty or unknown', () => {
+		const broker = {
+			file: `api/user0.GET.200.empty`,
+			mocks: [
+				`api/user0.GET.200.empty`,
+				`api/user1.GET.200.unknown`,
+				`api/user2.GET.200.json`,
+				`api/user3(another json).GET.200.json`,
+			]
+		}
+		const row = new BrokerRowModel(broker, false)
+		const opts = row.opts.map(([, n, selected]) => [n, selected])
+		deepEqual(opts, [
+			['200', true],
+			['200', false],
+			['200 json', false],
+			['200 json (another json)', false]
+		])
+		// TODO Think about, in cases like this, the only option the user has
+		//  for discerning empty and unknown is on the Previewer Title
+	})
+
+	test('appends "Proxied" label iff current is proxied', () => {
+		const broker = {
+			file: 'api/foo',
+			proxied: true,
+			mocks: [`api/foo.GET.200.json`]
+		}
+		const row = new BrokerRowModel(broker, true)
+		deepEqual(row.opts.map(([, n, selected]) => [n, selected]), [
+			['200 json', false],
+			[t`Proxied`, true]
+		])
+	})
+})
+

package/src/client/app.js

@@ -19,6 +19,7 @@ const CSS = {
 	GlobalDelayField: null,
 	GroupByMethod: null,
 	InternalServerErrorToggler: null,
+	Logo: null,
 	MenuTrigger: null,
 	Method: null,
 	MockList: null,
@@ -107,12 +108,16 @@ function App() {
 function Header() {
 	return (
 		r('header', null,
-			r('object', {
-				data: 'logo.svg',
-				type: 'image/svg+xml',
-				width: 120,
-				height: 22
-			}),
+			r('a', {
+					className: CSS.Logo,
+					href: 'https://mockaton.com',
+				},
+				r('object', {
+					data: 'logo.svg',
+					type: 'image/svg+xml',
+					width: 120,
+					height: 22
+				})),
 			r('div', null,
 				GlobalDelayField(),
 				BulkSelector(),
@@ -271,11 +276,17 @@ function SettingsMenu(id) {
 					}),
 					r('span', className(CSS.checkboxBody), t`Group by Method`)),
 
+				r('a', {
+					href: 'https://mockaton.com',
+					target: '_blank',
+					rel: 'noopener noreferrer'
+				}, t`Website`),
+				
 				r('a', {
 					href: 'https://github.com/ericfortis/mockaton',
 					target: '_blank',
 					rel: 'noopener noreferrer'
-				}, t`Documentation`),
+				}, t`Source Code`),
 
 				r('p', null, `v${store.mockatonVersion}`)
 			)))
@@ -914,3 +925,6 @@ function SyntaxXML(xml) {
 	return frag
 }
 
+
+/*
+ */

package/src/client/styles.css

@@ -133,10 +133,14 @@ header {
 	border-bottom: 1px solid var(--colorSecondaryActionBorder);
 	background: var(--colorHeaderBackground);
 
-	> object {
+	.Logo {
 		align-self: end;
 		margin-right: 22px;
-		margin-bottom: 5px;
+		margin-bottom: 3px;
+		
+		object {
+			pointer-events: none;
+		}
 	}
 
 	> div {

package/src/server/Api.js

@@ -21,9 +21,6 @@ import { config, ConfigValidator } from './config.js'
 import * as staticCollection from './staticCollection.js'
 import * as mockBrokersCollection from './mockBrokersCollection.js'
 
-import { parseJSON } from './utils/http-request.js'
-import { sendOK, sendJSON, sendUnprocessable, sendFile, sendHTML } from './utils/http-response.js'
-
 
 export const apiGetReqs = new Map([
 	[API.dashboard, serveDashboard],
@@ -61,17 +58,17 @@ export const apiPatchReqs = new Map([
 /** # GET */
 
 function serveDashboard(_, response) {
-	sendHTML(response, IndexHtml(config.hotReload), CSP)
+	response.html(IndexHtml(config.hotReload), CSP)
 }
 
 function serveStatic(f) {
 	return (_, response) => {
-		sendFile(response, join(CLIENT_DIR, f))
+		response.file(join(CLIENT_DIR, f))
 	}
 }
 
 function getState(_, response) {
-	sendJSON(response, {
+	response.json({
 		cookies: cookie.list(),
 		comments: mockBrokersCollection.extractAllComments(),
 
@@ -93,161 +90,161 @@ function getState(_, response) {
 function reinitialize(_, response) {
 	mockBrokersCollection.init()
 	staticCollection.init()
-	sendOK(response)
+	response.ok()
 }
 
 
 async function setCorsAllowed(req, response) {
-	const corsAllowed = await parseJSON(req)
+	const corsAllowed = await req.json()
 
 	if (!ConfigValidator.corsAllowed(corsAllowed))
-		sendUnprocessable(response, `Expected boolean for "corsAllowed"`)
+		response.unprocessable(`Expected boolean for "corsAllowed"`)
 	else {
 		config.corsAllowed = corsAllowed
-		sendOK(response)
+		response.ok()
 	}
 }
 
 
 async function setGlobalDelay(req, response) {
-	const delay = await parseJSON(req)
+	const delay = await req.json()
 
 	if (!ConfigValidator.delay(delay))
-		sendUnprocessable(response, `Expected non-negative integer for "delay"`)
+		response.unprocessable(`Expected non-negative integer for "delay"`)
 	else {
 		config.delay = delay
-		sendOK(response)
+		response.ok()
 	}
 }
 
 
 async function selectCookie(req, response) {
-	const cookieKey = await parseJSON(req)
+	const cookieKey = await req.json()
 
 	const error = cookie.setCurrent(cookieKey)
 	if (error)
-		sendUnprocessable(response, error?.message || error)
+		response.unprocessable(error?.message || error)
 	else
-		sendJSON(response, cookie.list())
+		response.json(cookie.list())
 }
 
 
 async function setProxyFallback(req, response) {
-	const fallback = await parseJSON(req)
+	const fallback = await req.json()
 
 	if (!ConfigValidator.proxyFallback(fallback))
-		sendUnprocessable(response, `Invalid Proxy Fallback URL`)
+		response.unprocessable(`Invalid Proxy Fallback URL`)
 	else {
 		config.proxyFallback = fallback
-		sendOK(response)
+		response.ok()
 	}
 }
 
 async function setCollectProxied(req, response) {
-	const collectProxied = await parseJSON(req)
+	const collectProxied = await req.json()
 
 	if (!ConfigValidator.collectProxied(collectProxied))
-		sendUnprocessable(response, `Expected a boolean for "collectProxied"`)
+		response.unprocessable(`Expected a boolean for "collectProxied"`)
 	else {
 		config.collectProxied = collectProxied
-		sendOK(response)
+		response.ok()
 	}
 }
 
 
 
 async function bulkUpdateBrokersByCommentTag(req, response) {
-	const comment = await parseJSON(req)
+	const comment = await req.json()
 
 	mockBrokersCollection.setMocksMatchingComment(comment)
-	sendOK(response)
+	response.ok()
 }
 
 
 async function selectMock(req, response) {
-	const file = await parseJSON(req)
+	const file = await req.json()
 
 	const broker = mockBrokersCollection.brokerByFilename(file)
 	if (!broker || !broker.hasMock(file))
-		sendUnprocessable(response, `Missing Mock: ${file}`)
+		response.unprocessable(`Missing Mock: ${file}`)
 	else {
 		broker.selectFile(file)
-		sendJSON(response, broker)
+		response.json(broker)
 	}
 }
 
 
 async function toggleRoute500(req, response) {
-	const [method, urlMask] = await parseJSON(req)
+	const [method, urlMask] = await req.json()
 
 	const broker = mockBrokersCollection.brokerByRoute(method, urlMask)
 	if (!broker)
-		sendUnprocessable(response, `Route does not exist: ${method} ${urlMask}`)
+		response.unprocessable(`Route does not exist: ${method} ${urlMask}`)
 	else {
 		broker.toggle500()
-		sendJSON(response, broker)
+		response.json(broker)
 	}
 }
 
 
 async function setRouteIsDelayed(req, response) {
-	const [method, urlMask, delayed] = await parseJSON(req)
+	const [method, urlMask, delayed] = await req.json()
 
 	const broker = mockBrokersCollection.brokerByRoute(method, urlMask)
 	if (!broker)
-		sendUnprocessable(response, `Route does not exist: ${method} ${urlMask}`)
+		response.unprocessable(`Route does not exist: ${method} ${urlMask}`)
 	else if (typeof delayed !== 'boolean')
-		sendUnprocessable(response, `Expected boolean for "delayed"`)
+		response.unprocessable(`Expected boolean for "delayed"`)
 	else {
 		broker.setDelayed(delayed)
-		sendJSON(response, broker)
+		response.json(broker)
 	}
 }
 
 
 async function setRouteIsProxied(req, response) {
-	const [method, urlMask, proxied] = await parseJSON(req)
+	const [method, urlMask, proxied] = await req.json()
 
 	const broker = mockBrokersCollection.brokerByRoute(method, urlMask)
 	if (!broker)
-		sendUnprocessable(response, `Route does not exist: ${method} ${urlMask}`)
+		response.unprocessable( `Route does not exist: ${method} ${urlMask}`)
 	else if (typeof proxied !== 'boolean')
-		sendUnprocessable(response, `Expected boolean for "proxied"`)
+		response.unprocessable(`Expected boolean for "proxied"`)
 	else if (proxied && !config.proxyFallback)
-		sendUnprocessable(response, `There’s no proxy fallback`)
+		response.unprocessable(`There’s no proxy fallback`)
 	else {
 		broker.setProxied(proxied)
-		sendJSON(response, broker)
+		response.json(broker)
 	}
 }
 
 
 
 async function setStaticRouteStatusCode(req, response) {
-	const [route, status] = await parseJSON(req)
+	const [route, status] = await req.json()
 
 	const broker = staticCollection.brokerByRoute(route)
 	if (!broker)
-		sendUnprocessable(response, `Static route does not exist: ${route}`)
+		response.unprocessable(`Static route does not exist: ${route}`)
 	else if (!(status === 200 || status === 404))
-		sendUnprocessable(response, `Expected 200 or 404 status code`)
+		response.unprocessable(`Expected 200 or 404 status code`)
 	else {
 		broker.setStatus(status)
-		sendOK(response)
+		response.ok()
 	}
 }
 
 
 async function setStaticRouteIsDelayed(req, response) {
-	const [route, delayed] = await parseJSON(req)
+	const [route, delayed] = await req.json()
 
 	const broker = staticCollection.brokerByRoute(route)
 	if (!broker)
-		sendUnprocessable(response, `Static route does not exist: ${route}`)
+		response.unprocessable(`Static route does not exist: ${route}`)
 	else if (typeof delayed !== 'boolean')
-		sendUnprocessable(response, `Expected boolean for "delayed"`)
+		response.unprocessable(`Expected boolean for "delayed"`)
 	else {
 		broker.setDelayed(delayed)
-		sendOK(response)
+		response.ok()
 	}
 }

package/src/server/MockDispatcher.js

@@ -4,7 +4,6 @@ import { pathToFileURL } from 'node:url'
 
 import { logger } from './utils/logger.js'
 import { mimeFor } from './utils/mime.js'
-import { sendInternalServerError, sendMockNotFound } from './utils/http-response.js'
 
 import { proxy } from './ProxyRelay.js'
 import { cookie } from './cookie.js'
@@ -25,7 +24,7 @@ export async function dispatchMock(req, response) {
 			return
 		}
 		if (!broker) {
-			sendMockNotFound(response)
+			response.mockNotFound()
 			return
 		}
 
@@ -52,9 +51,9 @@ export async function dispatchMock(req, response) {
 	}
 	catch (error) { // TESTME
 		if (error?.code === 'ENOENT') // mock-file has been deleted
-			sendMockNotFound(response)
+			response.mockNotFound()
 		else
-			sendInternalServerError(response, error)
+			response.internalServerError(error)
 	}
 }
 

package/src/server/Mockaton.js

@@ -3,12 +3,10 @@ import { createServer } from 'node:http'
 import pkgJSON from '../../package.json' with { type: 'json' }
 
 import { logger } from './utils/logger.js'
+import { ServerResponse } from './utils/HttpServerResponse.js'
+import { IncomingMessage } from './utils/HttpIncomingMessage.js'
 import { setCorsHeaders, isPreflight } from './utils/http-cors.js'
-import { BodyReaderError, hasControlChars } from './utils/http-request.js'
-import {
-	setHeaders, sendNoContent, sendInternalServerError,
-	sendUnprocessable, sendTooLongURI, sendBadRequest
-} from './utils/http-response.js'
+import { BodyReaderError, hasControlChars } from './utils/HttpIncomingMessage.js'
 
 import { API } from './ApiConstants.js'
 import { config, setup } from './config.js'
@@ -38,7 +36,7 @@ export function Mockaton(options) {
 		if (config.hotReload)
 			watchDevSPA()
 
-		const server = createServer(onRequest)
+		const server = createServer({ IncomingMessage, ServerResponse }, onRequest)
 		server.on('error', reject)
 		server.listen(config.port, config.host, () => {
 			const url = `http://${server.address().address}:${server.address().port}`
@@ -54,17 +52,17 @@ export function Mockaton(options) {
 async function onRequest(req, response) {
 	response.on('error', logger.warn)
 
-	setHeaders(response, ['Server', `Mockaton ${pkgJSON.version}`])
-	setHeaders(response, config.extraHeaders)
+	response.setHeader('Server', `Mockaton ${pkgJSON.version}`)
+	response.setHeaderList(config.extraHeaders)
 
 	const url = req.url || ''
 
 	if (url.length > 2048) {
-		sendTooLongURI(response)
+		response.uriTooLong()
 		return
 	}
 	if (hasControlChars(url)) {
-		sendBadRequest(response)
+		response.badRequest()
 		return
 	}
 
@@ -76,7 +74,7 @@ async function onRequest(req, response) {
 		const { pathname } = new URL(url, 'http://_')
 
 		if (isPreflight(req))
-			sendNoContent(response)
+			response.noContent()
 
 		else if (method === 'PATCH' && apiPatchReqs.has(pathname))
 			await apiPatchReqs.get(pathname)(req, response)
@@ -92,8 +90,8 @@ async function onRequest(req, response) {
 	}
 	catch (error) {
 		if (error instanceof BodyReaderError)
-			sendUnprocessable(response, `${error.name}: ${error.message}`)
+			response.unprocessable(`${error.name}: ${error.message}`)
 		else
-			sendInternalServerError(response, error)
+			response.internalServerError(error)
 	}
 }