@trenskow/app 0.5.3 → 0.5.7

package/README.md

@@ -232,21 +232,21 @@ Middleware can also use the context to provide data and services, which is then
 
 When a request is incoming, the `context`object looks like this.
 
-| Name             | Description                                                                                                                                                                                                                                 |            Type             |
-| ---------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | :-------------------------: |
-| `application`    | The application instance that has received the request.                                                                                                                                                                                     | [Application](#Application) |
-| `request`        | The request object from the HTTP server.                                                                                                                                                                                                    |     [Request](#Request)     |
-| `response`       | The response object from the HTTP server.                                                                                                                                                                                                   |    [Response](#Response)    |
-| `parameters`     | An empty object that will contain the parameters picked up when processing the parameters (if any) of the requested path.                                                                                                                   |           Object            |
-| `path`           | An object that has properties representing different paths.                                                                                                                                                                                 |           Object            |
-| `path.full`      | An array of strings that joined represent the path of the fully requested path.                                                                                                                                                             |       Array of String       |
-| `path.current`   | An array of strings that joined represents the path currently being processed.                                                                                                                                                              |       Array of String       |
-| `path.remaining` | An array of strings that joined represents the path that is above the currently processed path.                                                                                                                                             |                             |
-| `query`          | An object holding the URL query parameters as an object ([keys has been converted to camel case](#query-parameters)).                                                                                                                       |           Object            |
-| `state`          | A string indicating the current state of the request – possible values are `'routing'`, `'rendering'`, `'completed'` or `'aborted'`.                                                                                                        |           String            |
+| Name             | Description                                                  |            Type             |
+| ---------------- | ------------------------------------------------------------ | :-------------------------: |
+| `application`    | The application instance that has received the request.      | [Application](#Application) |
+| `request`        | The request object from the HTTP server.                     |     [Request](#Request)     |
+| `response`       | The response object from the HTTP server.                    |    [Response](#Response)    |
+| `parameters`     | An empty object that will contain the parameters picked up when processing the parameters (if any) of the requested path. |           Object            |
+| `path`           | An object that has properties representing different paths.  |           Object            |
+| `path.full`      | An array of strings that joined represent the path of the fully requested path. |       Array of String       |
+| `path.current`   | An array of strings that joined represents the path currently being processed. |       Array of String       |
+| `path.remaining` | An array of strings that joined represents the path that is above the currently processed path. Setting this will rewrite the remaining path. |       Array of String       |
+| `query`          | An object holding the URL query parameters as an object ([keys has been converted to camel case](#query-parameters)). |           Object            |
+| `state`          | A string indicating the current state of the request – possible values are `'routing'`, `'rendering'`, `'completed'` or `'aborted'`. |           String            |
 | `abort`          | A function that aborts the request. It takes the parameters `(error, brutally)`, where `error` is the error that needs to be handled by the [renderer](#renderer) – and `brutally` which indicates if the connection should also be closed. |        AsyncFunction        |
-| `render`         | A function that tells the application to stop processing the request and jump directly to the [renderer](#renderer).                                                                                                                        |          Function           |
-| `result`         | Whatever has been returned by the method handlers (should be written to the response in the [`renderer`](#renderer)).                                                                                                                       |             Any             |
+| `render`         | A function that tells the application to stop processing the request and jump directly to the [renderer](#renderer). |          Function           |
+| `result`         | Whatever has been returned by the method handlers (should be written to the response in the [`renderer`](#renderer)). |             Any             |
 
 ##### Example
 
@@ -495,15 +495,17 @@ This method takes care of handing a specified HTTP method.
 
 Supported HTTP methods are the same as those returned by [`http.METHODS`](https://nodejs.org/dist/latest/docs/api/http.html#httpmethods).
 
-No more routes will be processed, when one of these handlers return. The returned value is send to the [renderer](#renderer).
+You can only call these methods once per method per endpoint – calling it multiple times will result in only the last one getting used.
 
 > Returns the endpoint.
 
 ###### Parameters
 
-| Name       | Description                  |                           Type                           |      Required      | Default value |
-| ---------- | ---------------------------- | :------------------------------------------------------: | :----------------: | :-----------: |
-| `handlers` | A (or an array of) handlers. | Function, AsyncFunction or Array ([see also](#handlers)) | :white_check_mark: |               |
+| Name       | Description                    |                           Type                           |      Required      | Default value |
+| ---------- | ------------------------------ | :------------------------------------------------------: | :----------------: | :-----------: |
+| `handlers` | A (or an array of) handlers. * | Function, AsyncFunction or Array ([see also](#handlers)) | :white_check_mark: |               |
+
+> \* When more than one handler are provided all but the last are treated as `.use` handlers (but specific to the HTTP method). Only the return value of the last handler is sent to the renderer.
 
 ###### Example
 

package/lib/application.js

@@ -173,10 +173,13 @@ export default class Application extends EventEmitter {
 
 		if (path.substr(-1) === '/') path = path.slice(0, -1);
 
-		query = Object.fromEntries(query.split(/&/).map((entry) => {
-			const [key, value] = entry.split(/=/).map(decodeURIComponent);
-			return [caseit(key), value];
-		}));
+		query = Object.fromEntries(query
+			.split(/&/)
+			.filter((entry) => entry)
+			.map((entry) => {
+				const [key, value] = entry.split(/=/).map(decodeURIComponent);
+				return [caseit(key), value];
+			}));
 
 		let state = 'routing';
 
@@ -186,14 +189,20 @@ export default class Application extends EventEmitter {
 				.map(decodeURIComponent)
 				.slice(1),
 			position: -1,
-			async pushed(todo) {
-				this.position++;
+			async _walk(direction, todo) {
+				this.position += direction;
 				try {
-					await todo();
+					return await todo(path.component);
 				} finally {
-					this.position--;
+					this.position -= direction;
 				}
 			},
+			async pushed(todo) {
+				return this._walk(1, todo);
+			},
+			async popped(todo) {
+				return this._walk(-1, todo);
+			},
 			get isLast() {
 				return this.position === this.components.length;
 			},
@@ -216,12 +225,28 @@ export default class Application extends EventEmitter {
 				},
 				get remaining() {
 					return path.components.slice(path.position);
+				},
+				set remaining(remaining) {
+
+					if (typeof remaining === 'string') {
+						remaining = remaining
+							.split('/')
+							.filter((component) => component);
+					}
+
+					if (!Array.isArray(remaining)) {
+						remaining = [remaining];
+					}
+
+					remaining.forEach((component) => {
+						if (typeof component !== 'string') throw new Error('Path component must be a string.');
+					});
+
+					path.components = context.path.current.concat(remaining);
+
 				}
 			},
-			query: new Proxy(query, {
-				get: (target, property) => target[caseit(property)],
-				set: (target, property, value) => target[caseit(property)] = value
-			}),
+			query,
 			render: () => {
 				state = 'rendering';
 			},
@@ -231,9 +256,10 @@ export default class Application extends EventEmitter {
 					({ error, brutally } = error);
 				}
 
-				state = 'aborted';
-
-				if (error) context.result = error;
+				if (!['completed', 'aborted'].includes(state)) {
+					state = 'aborted';
+					if (error) context.result = error;
+				}
 
 				if (brutally) {
 					return new Promise((resolve, reject) => {
@@ -295,17 +321,13 @@ export default class Application extends EventEmitter {
 					});
 			});
 
-			context.response.statusCode = context.result ? 200 : 204;
+			if (context.response.statusCode === 200) {
+				context.response.statusCode = context.result ? 200 : 204;
+			}
 
 		} catch (error) {
 
-			if (typeof error.toJSON !== 'function') {
-				console.error(error.stack);
-				context.result = new ApiError.InternalError({ underlying: error });
-			} else {
-				context.result = error;
-			}
-
+			context.result = error;
 			context.response.statusCode = error.statusCode ?? 500;
 
 		}

package/lib/endpoint.js

@@ -59,6 +59,11 @@ export default class Endpoint extends Router {
 			throw new Error('Handler must be a function.');
 		}
 
+		const existing = this._layers.findIndex((layer) => layer.method === method);
+		if (existing !== -1) {
+			this._layers.splice(existing, 1);
+		}
+
 		this._layers.push({
 			type: 'method',
 			method,
@@ -193,15 +198,15 @@ export default class Endpoint extends Router {
 
 			case 'mount': {
 
-				return await path.pushed(async () => {
+				return await path.pushed(async (component) => {
 
-					if (!path.component) return await next();
+					if (!component) return path.popped(next);
 
-					if (matchPath(path.component, layer.path, context)) {
+					if (matchPath(component, layer.path, context)) {
 						return await layer.endpoint._route(path, context, next);
 					}
 
-					return await next();
+					return path.popped(next);
 
 				});
 
@@ -224,16 +229,16 @@ export default class Endpoint extends Router {
 
 			case 'parameter': {
 
-				return await path.pushed(async () => {
+				return await path.pushed(async (component) => {
 
-					if (!path.component) return await next();
+					if (!component) return await path.popped(next);
 
 					context.parameters[layer.name] = await layer.transform?.(
 						Object.fromEntries([
 							[ 'context', context ],
-							[ layer.name, path.component ]
+							[ layer.name, component ]
 						])
-					) || path.component;
+					) || component;
 
 					return await layer.endpoint._route(path, context, next);
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trenskow/app",
-  "version": "0.5.3",
+  "version": "0.5.7",
   "description": "A small HTTP router.",
   "type": "module",
   "main": "index.js",

package/test/index.js

@@ -74,6 +74,47 @@ describe('Application', () => {
 
 		});
 
+		it ('should ignore multiple GET method handlers and respond with 200 and `Hello, World!`.', async () => {
+
+			app.root(
+				new Endpoint()
+					.get(() => 'Ignore this!')
+					.post(() => 'Not used')
+					.get(() => 'Hello, World!')
+			);
+
+			await request
+				.get('/')
+				.expect('Content-Type', 'text/plain; charset=utf-8')
+				.expect(200, 'Hello, World!');
+
+		});
+
+		it ('should ignore GET method handler when path has been rewritten and respond with 200 and `Hello, World!`.', async () => {
+
+			app.root(
+				new Endpoint()
+					.use(({ path }) => {
+						if (path.remaining[0] === 'ignore') {
+							path.remaining = ['hello'];
+						}
+					})
+					.mounts.ignore(
+						new Endpoint()
+							.get(() => 'Ignore this!'))
+					.mounts.hello(
+						new Endpoint()
+							.get(() => 'Hello!')
+					)
+			);
+
+			await request
+				.get('/ignore')
+				.expect('Content-Type', 'text/plain; charset=utf-8')
+				.expect(200, 'Hello!');
+
+		});
+
 		it ('should respond with 404 when a mount is configured but another is requested.', async () => {
 
 			app.root(