@trenskow/app 0.6.13 → 0.7.1

package/.vscode/launch.json

@@ -5,7 +5,7 @@
 	"version": "0.2.0",
 	"configurations": [
 		{
-			"type": "pwa-node",
+			"type": "node",
 			"request": "launch",
 			"name": "Test",
 			"skipFiles": [

package/README.md

@@ -123,21 +123,26 @@ import { Application, Endpoint } from '@trenskow/app';
 
 const app = new Application({ port: 8080 });
 
-(async () => {
-
-	return (await app
-		.root(
-			new Endpoint()
-				.mount('iam', await import('./iam.js')))
-		.renderer(async ({ result, response }) => {
+try {
+  
+  const root = new Endpoint()
+  	.mount('iam', await import('./iam.js'));
+  
+  const renderer = async ({ result, response }) => {
 			response.headers.contentType = 'text/plain';
 			response.end(result);
-		})
-		.start())
-		.port;
-
-})().then((port) => console.info(`Application is running on port ${app.port}`))
-	.catch(console.error);
+  };
+  
+	await app
+		.root(root)
+		.renderer(renderer)
+		.start();
+  
+  console.info(`Application is running on port ${app.port}`)
+  
+} catch (error) {
+  console.error(error);
+}
 ````
 
 ````javascript
@@ -216,7 +221,7 @@ Endpoints has the [`mount`](#mount) method, which "mounts" a router to the speci
 
 There is a variant of the `mount` method called [`parameter`](#parameter) which is used to mount an endpoint with a dynamic path – whereas the path is treated like an input parameter (like express' `.param` method). Parameters also supports a transform function, which is able to transform the parameter into something else (eg. a user identifier into a user object).
 
-Lastly there is the [`.middleware`](#middleware) method, which is used to attach middleware. Middleware is defined as a router, which is of the type [`Router`](#router-2) and therefore cannot act as an endpoint. You can regard them like transforms or service providers for the request.
+Lastly there is the [`.middleware`](#middleware) method, which is used to attach middleware. Middleware is defined as a router, which have the type [`Router`](#router-2) and therefore cannot act as an endpoint. You can regard them like transforms or service providers for the request.
 
 > `Endpoint` extends `Router`.
 
@@ -228,9 +233,9 @@ All handlers and routers support async functions (and non-async). No need to cal
 
 Where express gives you the `(req, res, next)` parameters for each handler, this application instead just provides a single parameter, the "`context` object", which contains all the information needed to process the request.
 
-Middleware can also use the context to provide data and services, which is then available for subsequent endpoints, routers and handlers.
+Middleware can assign values to the context to provide data and services, which is then available for subsequent endpoints, routers and handlers.
 
-When a request is incoming, the `context`object looks like this.
+When a request is incoming, the `context` object looks like this.
 
 | Name             | Description                                                  |            Type             |
 | ---------------- | ------------------------------------------------------------ | :-------------------------: |
@@ -241,7 +246,7 @@ When a request is incoming, the `context`object looks like this.
 | `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       |
+| `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 (useful when serving single page applications to a browser). |       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        |
@@ -267,15 +272,15 @@ JavaScript is a camel cased language. HTTP is a mixture of different case types.
 
 Case is automatically converted in both directions, so if you do `context.response.headers.contentType = 'application/json'` it will automatically be converted to `Content-Type: application/json` when the response is sent.
 
-The same goes for request headers like `Accept-Language: en` that is accessible through `context.request.headers.acceptLanguage`. 
+The same goes for request headers like `Accept-Language: en` which is accessible through `context.request.headers.acceptLanguage`. 
 
 ##### Query parameters
 
-Request with `?my-parameter=value` is accessible through `context.query.myParameter` .
+Request with quuries like `?my-parameter=value` is accessible through `context.query.myParameter` .
 
 ##### Mount paths
 
-When [match mode](#constructor) is set to `'loosely'` (default) a request withe the path component `my-route` or `my_route` will match an endpoint mounted at `myRoute`.
+When [match mode](#constructor) is set to `'loosely'` (default) a request with the path component `my-route` or `my_route` will match an endpoint mounted at `myRoute`.
 
 #### Endpoints, routers and handlers
 
@@ -287,22 +292,13 @@ Endpoints takes care of a path component. As example the `/this/is/my/path/` pat
 
 Endpoints can have a couple of things mounted / attached to it – those are.
 
-* Other endpoints
-	* using the [`.mount`](#mount) method of [`Endpoint`](#endpoint-2).
-
-* Parameters
+* Other endpoints (using the [`.mount`](#mount) method of [`Endpoint`](#endpoint-2))
+* Parameters (using the [`.parameter`](#parameter) method of [`Endpoint`](#endpoint-2))
 	* which is also a mounted endpoint – but where the path is dynamic and assigned to the `context.parameters` object.
-	* using the [`.parameter`](#parameter) method of [`Endpoint`](#endpoint-2)
-
-* Handlers
-	* using the [`.use`](#use) method of [`Router`](#router-2) or [`Endpoint`](#endpoint-2) 
-
-* Middleware
+* Handlers (using the [`.use`](#use) method of [`Router`](#router-2) or [`Endpoint`](#endpoint-2) )
+* Middleware (using the [`.middleware`](#middleware) method of  [`Endpoint`](#endpoint-2) )
 	* sets a [`Router`](#routers-2) router to that the request will be passed through.
-	* using the [`.middleware`](#middleware) method of  [`Endpoint`](#endpoint-2) 
-
-* Methods
-	* using the [`.get`, `.post`, `.put`, `.delete`, etc.](#get-post-put-delete-etc) method of [`Endpoint`](#endpoint-2)
+* Methods (using the [`.get`, `.post`, `.put`, `.delete`, etc.](#get-post-put-delete-etc) method of [`Endpoint`](#endpoint-2))
 	* When a method returns the request ends and the returned value is send to the client as a response (through the [`Application#renderer`](#renderer))
 
 
@@ -311,7 +307,7 @@ Endpoints can have a couple of things mounted / attached to it – those are.
 Whenever a function (such as [`.mount`](#mount) or [`.parameter`](#parameters) or [`.root`](#root)) takes an endpoint as a parameter, it can be provided in any of the following ways.
 
 * An instance of [`Endpoint`](#endpoint-2).
-* An object that has a `default` key that has an instance of `Endpoint` as the value (useful when using inline imports).
+* An object that has a `default` key that has an instance of `Endpoint` as the value (useful when using inline imports as `await import('my-endpoint.js')`).
 
 ##### Routers
 
@@ -322,7 +318,7 @@ A router is the same as above, except it only supports [`.use`](#use).
 As above, whenever a function takes a router as a parameter, it can be provided in any of the following ways.
 
 * An instance of [`Router`](#router-2).
-* An object that has a `default` key that has an instance of `Router` as the value (useful when using inline imports).
+* An object that has a `default` key that has an instance of `Router` as the value (useful when using inline imports as `await import('my-route.js')`).).
 
 ##### Handlers
 
@@ -340,7 +336,7 @@ Whenever a function takes a handler as a parameter, it can be provided in any of
 
 ### `Application`
 
-The `Application` class holds an application and is responsible for handling and bootstrapping request from the server. It does not provide any routing on it's own, instead it has a [`root`](#root) method, which is used to set the root router.
+The `Application` class holds an application and is responsible for handling and bootstrapping request from the server. It does not provide any routing on its own, instead it has a [`root`](#root) method, which is used to set the root router.
 
 > If no root route has been set, all requests will be responded with `404 Not Found`.
 
@@ -352,17 +348,17 @@ The `Application` class takes an "options" object as it's parameter.
 
 ##### Parameters
 
-| Name                     | Description                                                                                                                                       |           Type            | Required |        Default value         |
-| ------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------- | :-----------------------: | :------: | :--------------------------: |
-| options                  | An object representing the options.                                                                                                               |          Object           |          |              {}              |
-| `options.port`           | The port at which to listen for incoming connections.                                                                                             |          Number           |          | `0` (automatically assigned) |
+| Name                     | Description                                                  |           Type            | Required |        Default value         |
+| ------------------------ | ------------------------------------------------------------ | :-----------------------: | :------: | :--------------------------: |
+| options                  | An object representing the options.                          |          Object           |          |              {}              |
+| `options.port`           | The port at which to listen for incoming connections.        |          Number           |          | `0` (automatically assigned) |
 | `options.RequestType`    | An object that inherits from the [`Request`](#request-2) class (an `http.IncomingMessage` subclass) that is used as the request object in routes. |           class           |          |    [`Request`](#Request)     |
-| `options.ResponseType`   | An object that inherits from the [`Response`](#response-2) class (`http.ServerResponse` subclass) that is used as the response object in routes.  |           class           |          |   [`Response`](#Response)    |
-| `path`                   | An object that represents path related options.                                                                                                   |          Object           |          |             `{}`             |
-| `path.matchMode`         | Indicates [how to match requests to mounted paths](#mount-paths).                                                                                 | `'loosely'` or `'strict'` |          |         `'loosely'`          |
-| `options.server`         | An object that represents how to instantiate the HTTP server.                                                                                     |          Object           |          |             `{}`             |
-| `options.server.create`  | A function that is able to create a server.                                                                                                       |         Function          |          |     `http.createServer`      |
-| `options.server.options` | An object to be passed as options when creating a server.                                                                                         |          Object           |          |             `{}`             |
+| `options.ResponseType`   | An object that inherits from the [`Response`](#response-2) class (`http.ServerResponse` subclass) that is used as the response object in routes. |           class           |          |   [`Response`](#Response)    |
+| `path`                   | An object that represents path related options.              |          Object           |          |             `{}`             |
+| `path.matchMode`         | Indicates [how to match requests to mounted paths](#mount-paths) (eg. should the path be converted to camel case). | `'loosely'` or `'strict'` |          |         `'loosely'`          |
+| `options.server`         | An object that represents how to instantiate the HTTP server. |          Object           |          |             `{}`             |
+| `options.server.create`  | A function that is able to create a server.                  |         Function          |          |     `http.createServer`      |
+| `options.server.options` | An object to be passed as options when creating a server.    |          Object           |          |             `{}`             |
 
 #### Events
 
@@ -499,7 +495,7 @@ You can only call these methods once per method per endpoint – calling it mult
 
 These also ends routing. After a method route has been called, the routing will go strait to the renderer.
 
-> Notice: If no `head` method is implemented on endpoint, `get` will instead be called (if availble). When client requests a `head` the result will be ignored.
+> Notice: If no `head` method is implemented on endpoint, `get` will instead be called (if ). When client requests a `head` the result will be ignored.
 
 > Returns the endpoint.
 
@@ -518,11 +514,13 @@ Below is an example on how to use the method.
 ````javascript
 default export ({ endpoint }) => {  
 	endpoint
-		.get(async (context) => 'Hello, world!');
+		.get(
+            async (context) => 'Hello, world!',
+            () => console.info("Said hello."));
 };
 ````
 
-> In the above example `'Hello, world!'` is immediately send to the [renderer](#renderer) and the request ends.
+> In the above example `'Hello, world!'` is immediately send to the [renderer](#renderer) and the request ends. The second handler is also executed, but as it returns `undefined` its return value is ignored.
 
 ###### Catch all
 

package/lib/endpoint.js

@@ -65,7 +65,7 @@ export default class Endpoint extends Router {
 		}
 
 		this._layers.push({
-			type: 'method',
+			handler: this._handleMethod,
 			method,
 			handlers,
 			match
@@ -91,7 +91,7 @@ export default class Endpoint extends Router {
 		}
 
 		this._layers.push({
-			type: 'mount',
+			handler: this._handleMount,
 			path,
 			endpoint
 		});
@@ -130,7 +130,7 @@ export default class Endpoint extends Router {
 		}
 
 		this._layers.push({
-			type: 'parameter',
+			handler: this._handleParameter,
 			name,
 			transform,
 			endpoint
@@ -168,7 +168,7 @@ export default class Endpoint extends Router {
 		}
 
 		this._layers.push({
-			type: 'middleware',
+			handler: this._handleMiddleware,
 			router
 		});
 
@@ -183,7 +183,7 @@ export default class Endpoint extends Router {
 			if (path.isLast) {
 
 				const methods = this._layers
-					.filter((layer) => layer.type === 'method')
+					.filter((layer) => layer.handler === this._handleMethod)
 					.map((layer) => layer.method.toUpperCase())
 					.filter((value, index, array) => array.indexOf(value) === index);
 
@@ -202,80 +202,69 @@ export default class Endpoint extends Router {
 
 	}
 
-	async _handle(layer, path, context, next) {
+	async _handleMount(layer, path, context, next) {
 
-		switch (layer.type) {
+		return await path.pushed(async (component) => {
 
-			case 'mount': {
-
-				return await path.pushed(async (component) => {
-
-					if (!component) return path.popped(next);
-
-					if (matchPath(component, layer.path, context)) {
-						return await layer.endpoint._route(path, context, next);
-					}
-
-					return path.popped(next);
-
-				});
+			if (!component) return path.popped(next);
 
+			if (matchPath(component, layer.path, context)) {
+				return await layer.endpoint._route(path, context, next);
 			}
 
-			case 'method': {
+			return path.popped(next);
 
-				let underlyingMethod = context.request.method.toLowerCase();
+		});
 
-				if (underlyingMethod === 'head' && !this._layers.some((layer) => layer.method === 'head')) {
-					underlyingMethod = 'get';
-				}
+	}
 
-				if (layer.match === 'direct' && !path.isLast) return await next();
-				if (layer.method !== 'all' && layer.method !== underlyingMethod) return await next();
+	async _handleMethod(layer, path, context, next) {
 
-				for (let handler of layer.handlers) {
-					const result = await handler(context);
-					if (layer.underlyingMethod === 'head') return;
-					if (context.state !== 'routing') return;
-					if (typeof result !== 'undefined') context.result = result;
-				}
+		let underlyingMethod = context.request.method.toLowerCase();
 
-				return context.result;
+		if (underlyingMethod === 'head' && !this._layers.some((layer) => layer.method === 'head')) {
+			underlyingMethod = 'get';
+		}
 
-			}
+		if (layer.match === 'direct' && !path.isLast) return await next();
+		if (layer.method !== 'all' && layer.method !== underlyingMethod) return await next();
 
-			case 'parameter': {
+		for (let handler of layer.handlers) {
+			const result = await handler(context);
+			if (layer.underlyingMethod === 'head') return;
+			if (context.state !== 'routing') return;
+			if (typeof result !== 'undefined') context.result = result;
+		}
 
-				return await path.pushed(async (component) => {
+		return context.result;
 
-					if (!component) return await path.popped(next);
+	}
 
-					context.parameters[layer.name] = component;
+	async _handleParameter(layer, path, context, next) {
 
-					if (typeof layer.transform === 'function') {
-						context.parameters[layer.name] = await layer.transform(
-							Object.fromEntries([
-								['context', context],
-								[layer.name, component]
-							])
-						);
-					}
+		return await path.pushed(async (component) => {
 
-					return await layer.endpoint._route(path, context, next);
+			if (!component) return await path.popped(next);
 
-				});
+			context.parameters[layer.name] = component;
 
+			if (typeof layer.transform === 'function') {
+				context.parameters[layer.name] = await layer.transform(
+					Object.fromEntries([
+						['context', context],
+						[layer.name, component]
+					])
+				);
 			}
 
-			case 'middleware': {
-				return await layer.router._route(path, context, next);
-			}
+			return await layer.endpoint._route(path, context, next);
 
-			default:
-				return await super._handle(layer, path, context, next);
+		});
 
-		}
+	}
 
+	async _handleMiddleware(layer, path, context, next) {
+		return await layer.router._route(path, context, next);
 	}
 
 }

package/lib/index.js

@@ -13,6 +13,16 @@ import Request from './request.js';
 import Response from './response.js';
 import ApiError from '@trenskow/api-error';
 
+import { isObject, matchPath, resolveInlineImport } from './util.js';
+
 export default Application;
 
+Application.plugin = (plugin) => {
+	plugin({ Router, Endpoint, Application, Request, Response, Error: ApiError, util: {
+		isObject,
+		matchPath,
+		resolveInlineImport
+	} });
+};
+
 export { Router, Endpoint, Application, Request, Response, ApiError as Error };

package/lib/router.js

@@ -27,7 +27,7 @@ export default class Router {
 		}
 
 		this._layers.push({
-			type: 'use',
+			handler: this._handleUse,
 			handlers
 		});
 
@@ -48,7 +48,7 @@ export default class Router {
 		}
 
 		this._layers.push({
-			type: 'mixin',
+			handler: this._handleMixin,
 			router: router
 		});
 
@@ -68,27 +68,23 @@ export default class Router {
 
 	}
 
-	async _handle(layer, path, context, next) {
-
-		switch (layer.type) {
-
-			case 'use': {
+	async _handleUse(layer, _, context, next) {
 
-				for (let handler of layer.handlers) {
-					await handler(context);
-					if (context.state !== 'routing') return;
-				}
-
-				return await next();
+		for (let handler of layer.handlers) {
+			await handler(context);
+			if (context.state !== 'routing') return;
+		}
 
-			}
+		return await next();
 
-			case 'mixin': {
-				return await layer.router._route(path, context, next);
-			}
+	}
 
-		}
+	async _handleMixin(layer, path, context, next) {
+		return await layer.router._route(path, context, next);
+	}
 
+	async _handle(layer, path, context, next) {
+		return await layer.handler.call(this, layer, path, context, next);
 	}
 
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@trenskow/app",
-  "version": "0.6.13",
+  "version": "0.7.1",
   "description": "A small HTTP router.",
   "type": "module",
   "main": "index.js",
@@ -25,12 +25,12 @@
   },
   "homepage": "https://github.com/trenskow/app#readme",
   "devDependencies": {
-    "eslint": "^8.13.0",
+    "eslint": "^8.20.0",
     "mocha": "^10.0.0",
-    "supertest": "^6.2.2"
+    "supertest": "^6.2.4"
   },
   "dependencies": {
-    "@trenskow/api-error": "^2.2.6",
+    "@trenskow/api-error": "^2.3.2",
     "@trenskow/caseit": "^1.3.0"
   }
 }