first pass on new, simpler routing

Author: Dashron

example/ts/package-lock.json

@@ -1,32 +1,31 @@
 /**
  * client.ts
- * Copyright(c) 2021 Aaron Hedges <[email protected]>
+ * Copyright(c) 2025 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
  * This file is an example of using roads router in the client
  */
 
-import { Road, RoadsPJAX, ParseBodyMiddleware, RouterMiddleware, CookieMiddleware, Request } from 'roads';
-import applyPublicRotues from './routes/applyPublicRoutes';
+import { Road, RoadsPJAX, ParseBodyMiddleware, CookieMiddleware, Request } from 'roads';
+import applyPublicRoutes from './routes/applyPublicRoutes';
 import emptyTo404 from './middleware/emptyTo404';
 
 const road = new Road();
 
-road.use(function (method, url, body, headers, next) {
+road.beforeRoute(function (method, url, body, headers, next) {
 	console.log(`fake ${  method  } request to...`, url);
 	return next();
 });
 
 const pjax = new RoadsPJAX(road, document.getElementById('container') as HTMLAnchorElement, window);
 pjax.addTitleMiddleware('roads-title');
-road.use(emptyTo404);
-road.use(ParseBodyMiddleware.middleware);
+road.beforeRoute(emptyTo404);
+road.beforeRoute(ParseBodyMiddleware.middleware);
 // Todo: get this set up properly, then check cokie and stor val on the server
-road.use(CookieMiddleware.buildClientMiddleware(document));
+road.beforeRoute(CookieMiddleware.buildClientMiddleware(document));
 pjax.register();
 pjax.registerAdditionalElement(document.getElementById('home') as HTMLAnchorElement);
-const router = new RouterMiddleware.Router(road);
-applyPublicRotues(router);
+applyPublicRoutes(road);
 
 const testRequest = new Request(false, 'localhost', 8081);
 testRequest.request('GET', '/').then(response => {

example/ts/src/client.ts

@@ -1,15 +1,15 @@
 /**
  * addLayout.ts
- * Copyright(c) 2018 Aaron Hedges <[email protected]>
+ * Copyright(c) 2025 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
  * This file is an example of how to apply HTML layouts via a middleware system
  */
 
-import { Middleware } from 'roads/types/core/road';
 import { Response } from 'roads';
 const TITLE_KEY = 'page-title';
 import { StoreValsContext } from 'roads/types/middleware/storeVals';
+import { Route } from '../../../../types/core/router';
 
 /**
   * Example function to wrap an HTML body in the required surrounding HTML tags (commonly called a layout)
@@ -50,7 +50,7 @@ function wrapLayout(body: string | Buffer, vals: {
  * @param {object} headers - HTTP request headers
  * @param {function} next - When called, this function will execute the next step in the roads method chain
  */
-const addLayoutMiddleware: Middleware<StoreValsContext> = function addLayoutMiddleware (method, url, body, headers, next) {
+const addLayoutMiddleware: Route<StoreValsContext> = function addLayoutMiddleware (method, url, body, headers, next) {
 	return next()
 		.then((response) => {
 			if (!(response instanceof Response)) {

example/ts/src/middleware/addLayout.ts

@@ -1,13 +1,14 @@
 /**
  * emptyTo404.ts
- * Copyright(c) 2021 Aaron Hedges <[email protected]>
+ * Copyright(c) 2025 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
  * This file is an example of how to apply HTML layouts via a middleware system
  */
 
-import { Middleware, Context } from 'roads/types/core/road';
+import { Context } from 'roads/types/core/road';
 import { Response } from 'roads';
+import { Route } from '../../../../types/core/router';
 
 /**
  * This middleware translates missing responses into 404s
@@ -18,7 +19,7 @@ import { Response } from 'roads';
  * @param {object} headers - HTTP request headers
  * @param {function} next - When called, this function will execute the next step in the roads method chain
  */
-const emptyTo404: Middleware<Context> = function (method, url, body, headers, next) {
+const emptyTo404: Route<Context> = function (method, url, body, headers, next) {
 	return next()
 		.then((response) => {
 			if (!response) {

example/ts/src/middleware/emptyTo404.ts

@@ -1,6 +1,6 @@
 /**
  * applyPrivateRoutes.ts
- * Copyright(c) 2018 Aaron Hedges <[email protected]>
+ * Copyright(c) 2025 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
  * This file is an example of how to assign some private routes to a road server
@@ -9,7 +9,7 @@
 import * as fs from 'fs';
 import { CookieContext } from 'roads/types/middleware/cookieMiddleware';
 import { StoreValsContext } from 'roads/types/middleware/storeVals';
-import { RouterMiddleware, Response } from 'roads';
+import { Response, Road } from 'roads';
 const TITLE_KEY = 'page-title';
 
 /**
@@ -19,8 +19,8 @@ const TITLE_KEY = 'page-title';
   *
   * @param {SimpleRouter} router - The router that the routes will be added to
   */
-export default function applyPrivateRotues(router: RouterMiddleware.Router<StoreValsContext>): void {
-	router.addRoute<CookieContext>('GET', '/private', async function () {
+export default function applyPrivateRotues(road: Road<StoreValsContext>): void {
+	road.addRoute<CookieContext & StoreValsContext>('GET', '/private', async function () {
 		this.storeVal(TITLE_KEY, 'Private Resource');
 		this.setCookie('private_cookie', 'foo', {
 			httpOnly: true
@@ -36,13 +36,13 @@ export default function applyPrivateRotues(router: RouterMiddleware.Router<Store
 			<a href="/" data-roads="link">home</a>!<br />`);
 	});
 
-	router.addRoute('GET', '/privateJSON', async function () {
+	road.addRoute('GET', '/privateJSON', async function () {
 		this.storeVal('ignoreLayout', true);
 		return new Response(JSON.stringify({'private-success': true}));
 	});
 
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	router.addRoute('GET', 'client.js', async function (url, body, headers) {
+	road.addRoute('GET', 'client.js', async function (url, body, headers) {
 		this.storeVal('ignoreLayout', true);
 		// In the real world the body of the response should be created from a template engine.
 		return new Response(fs.readFileSync(`${__dirname  }/../../../public/client.js`).toString('utf-8'), 200, {

example/ts/src/routes/applyPrivateRoutes.ts

@@ -1,12 +1,12 @@
 /**
  * applyPublicRoutes.ts
- * Copyright(c) 2018 Aaron Hedges <[email protected]>
+ * Copyright(c) 2025 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
  * This file is an example of how to assign some public routes to a roads server
  */
 
-import { Response, RouterMiddleware } from 'roads';
+import { Response, Road } from 'roads';
 const TITLE_KEY = 'page-title';
 
 import { ParseBodyContext } from 'roads/types/middleware/parseBody';
@@ -24,8 +24,8 @@ interface ExampleRequestBody {
   *
   * @param {SimpleRouter} router - The router that the routes will be added to
   */
-export default function applyPublicRotues(router: RouterMiddleware.Router<StoreValsContext>): void {
-	router.addRoute('GET', '/', async function () {
+export default function applyPublicRoutes(road: Road<StoreValsContext>): void {
+	road.addRoute('GET', '/', async function () {
 		this.storeVal(TITLE_KEY, 'Root Resource');
 
 		// In the real world the body of the response should be created from a template engine.
@@ -39,7 +39,7 @@ export default function applyPublicRotues(router: RouterMiddleware.Router<StoreV
 		});
 	});
 
-	router.addRoute<CookieContext>('GET', '/public', async function () {
+	road.addRoute<CookieContext & StoreValsContext>('GET', '/public', async function () {
 		this.storeVal(TITLE_KEY, 'Public Resource');
 		console.log('Here are all cookies accessible to this code: ', this.getCookies());
 		console.log('Cookies are not set until you access the private route.');
@@ -59,7 +59,9 @@ export default function applyPublicRotues(router: RouterMiddleware.Router<StoreV
 	});
 
 	// eslint-disable-next-line @typescript-eslint/no-unused-vars
-	router.addRoute<ParseBodyContext<ExampleRequestBody>>('POST', '/postdata', async function (url, body, headers) {
+	road.addRoute<
+		StoreValsContext & ParseBodyContext<ExampleRequestBody>
+	>('POST', '/postdata', async function (url, body, headers) {
 		console.log(`You sent the message:${this.body?.message}`);
 		this.ignore_layout = true;
 		return new Response('', 302, { location: '/public' });

example/ts/src/routes/applyPublicRoutes.ts

@@ -1,6 +1,6 @@
 /**
  * server.ts
- * Copyright(c) 2021 Aaron Hedges <[email protected]>
+ * Copyright(c) 2025 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
  * This file starts up the HTTP roads server
@@ -17,19 +17,18 @@ import emptyTo404 from './middleware/emptyTo404';
 
 const road = new Road();
 
-road.use(function (method, url, body, headers, next) {
+road.beforeRoute(function (method, url, body, headers, next) {
 	console.log(`${method} ${url}`);
 	return next();
 });
 
 attachCommonMiddleware(road);
-road.use(CookieMiddleware.serverMiddleware);
-road.use(addLayout);
+road.beforeRoute(CookieMiddleware.serverMiddleware);
+road.beforeRoute(addLayout);
 
-const router = new RouterMiddleware.Router(road);
-applyPublicRotues(router);
-applyPrivateRoutes(router);
-road.use(emptyTo404);
+applyPublicRotues(road);
+applyPrivateRoutes(road);
+road.afterRoute(emptyTo404);
 
 const server = new Server(road, function (err: Error) {
 	console.log(err.stack);

example/ts/src/server.ts

@@ -1,6 +1,6 @@
 {
   "name": "roads",
-  "version": "8.0.0-alpha.3",
+  "version": "8.0.0-alpha.4",
   "author": {
     "name": "Aaron Hedges",
     "email": "[email protected]",

package.json

@@ -1,6 +1,6 @@
 /**
  * pjax.ts
- * Copyright(c) 2021 Aaron Hedges <[email protected]>
+ * Copyright(c) 2025 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
  * PJAX is a technique for speeding up webpages by automatically replacing links or
@@ -15,16 +15,17 @@
  *
  */
 
-import Road, { Middleware } from '../core/road';
+import Road, { Context } from '../core/road';
 import Response from '../core/response';
 import { StoreValsContext, middleware as storeValsMiddleware} from '../middleware/storeVals';
+import { Route } from '../core/router';
 
 /**
   * This is a helper class to make PJAX easier. PJAX is a clean way of improving the performance of webpages
   * by progressively turning standard HTML links into AJAX requests for portions of a web page.
   */
-export default class RoadsPjax {
-	protected _road: Road;
+export default class RoadsPjax<PjaxContext extends Context & StoreValsContext> {
+	protected _road: Road<PjaxContext>;
 	protected _page_title?: string;
 	protected _window: Window;
 	protected _container_element: HTMLElement;
@@ -38,7 +39,7 @@ export default class RoadsPjax {
 	 * @param {HTMLElement} containerElement - The element that will be filled with your roads output
 	 * @param {Window} window - The page's window object to help set page title url
 	 */
-	constructor(road: Road, containerElement: HTMLElement, window: Window) {
+	constructor(road: Road<PjaxContext>, containerElement: HTMLElement, window: Window) {
 		this._road = road;
 		this._page_title = undefined;
 		this._window = window;
@@ -62,11 +63,11 @@ export default class RoadsPjax {
 	 * @param {titleKey} string - The key of the title as stored in the "storeVals" middleware.
 	 * @returns {RoadsPjax} Returns the PJAX object. This is provided to allow for easy function chaining.
 	 */
-	addTitleMiddleware (titleKey: string): RoadsPjax {
+	addTitleMiddleware (titleKey: string): RoadsPjax<PjaxContext> {
 		// eslint-disable-next-line @typescript-eslint/no-this-alias
 		const pjaxObj = this;
 
-		const titleMiddleware: Middleware<StoreValsContext> = function (method, url, body, headers, next) {
+		const titleMiddleware: Route<StoreValsContext> = function (method, url, body, headers, next) {
 
 			return next().then((response) => {
 				if (this.getVal) {
@@ -77,8 +78,8 @@ export default class RoadsPjax {
 			});
 		};
 
-		this._road.use(storeValsMiddleware);
-		this._road.use(titleMiddleware);
+		this._road.beforeRoute(storeValsMiddleware);
+		this._road.beforeRoute(titleMiddleware);
 
 		return this;
 	}

src/client/pjax.ts

@@ -1,6 +1,6 @@
 /**
  * request.ts
- * Copyright(c) 2021 Aaron Hedges <[email protected]>
+ * Copyright(c) 2025 Aaron Hedges <[email protected]>
  * MIT Licensed
  *
  * This file exposes a Request object to offer an HTTP request library with a method signature that matches