add ability to pass middleware to @astrojs/node when using standalone…

.changeset/nervous-ladybugs-wonder.md

@@ -0,0 +1,5 @@
+---
+'@astrojs/node': minor
+---
+
+add ability to pass node middleware to @astrojs/node when using standalone mode

packages/integrations/node/src/index.ts

@@ -38,6 +38,9 @@ export default function createIntegration(userOptions: UserOptions): AstroIntegr
 	if (!userOptions?.mode) {
 		throw new AstroError(`Setting the 'mode' option is required.`);
 	}
+	if (userOptions.mode !== 'standalone' && userOptions.standaloneMiddleware) {
+		throw new AstroError(`'standaloneMiddleware' option is only available in 'standalone' mode.`);
+	}
 
 	let _options: Options;
 	return {

packages/integrations/node/src/standalone.ts

@@ -22,6 +22,20 @@ export default function standalone(app: NodeApp, options: Options) {
 	const host = process.env.HOST ?? hostOptions(options.host);
 	const handler = createStandaloneHandler(app, options);
 	const server = createServer(handler, host, port);
+
+	// optionally add standalone middleware (if passed)
+	if (options.standaloneMiddleware) {
+		import(options.standaloneMiddleware)
+			.then((middleware) => {
+				server.updateServerListener((req: http.IncomingMessage, res: http.ServerResponse) => {
+					middleware.default(req, res, () => {
+						handler(req, res);
+					});
+				});
+			})
+			.catch(() => {});
+	}
+
 	server.server.listen(port, host);
 	if (process.env.ASTRO_NODE_LOGGING !== 'disabled') {
 		logListeningOn(app.getAdapterLogger(), server.server, options);
@@ -72,6 +86,11 @@ export function createServer(listener: http.RequestListener, host: string, port:
 		httpServer.addListener('error', reject);
 	});
 
+	const updateServerListener = (middleware: http.RequestListener) => {
+		httpServer.removeListener('request', listener);
+		httpServer.addListener('request', middleware);
+	}
+
 	const previewable = {
 		host,
 		port,
@@ -87,6 +106,7 @@ export function createServer(listener: http.RequestListener, host: string, port:
 
 	return {
 		server: httpServer,
+		updateServerListener,
 		...previewable,
 	};
 }

packages/integrations/node/src/types.ts

@@ -10,6 +10,10 @@ export interface UserOptions {
 	 * - 'standalone' - Build to a standalone server. The server starts up just by running the built script.
 	 */
 	mode: 'middleware' | 'standalone';
+	/**
+	 * Optional file path that (default) exports middleware function to be used in the standalone mode.
+	 */
+	standaloneMiddleware?: string;
 }
 
 export interface Options extends UserOptions {

packages/integrations/node/test/fixtures/node-middleware/src/node-middleware.mjs

@@ -0,0 +1,40 @@
+const combineMiddleware = (...middlewares) => {
+    return (req, res, next) => {
+        let index = 0;
+
+        const run = (err) => {
+            if (err) {
+                return next(err);
+            }
+            if (index >= middlewares.length) {
+                return next();
+            }
+            const middleware = middlewares[index++];
+            try {
+                middleware(req, res, run);
+            } catch (error) {
+                next(error);
+            }
+        };
+
+        run();
+    };
+};
+
+const middleware_one = (req, res, next) => {
+    if (req.url === '/middleware-one') {
+        res.end('This is middleware one');
+    } else {
+        next();
+    }
+};
+
+const middleware_two = (req, res, next) => {
+    if (req.url === '/middleware-two') {
+        res.end('This is middleware two');
+    } else {
+        next();
+    }
+};
+
+export default combineMiddleware(middleware_one, middleware_two);

packages/integrations/node/test/node-middleware.test.js

@@ -86,3 +86,126 @@ describe('behavior from middleware, middleware', () => {
 		assert.equal(body.text().includes("Here's a random number"), true);
 	});
 });
+
+describe('behavior from middleware, standalone `mode` passing `standaloneMiddleware` path', () => {
+	/** @type {import('./test-utils').Fixture} */
+	let fixture;
+	let server;
+
+	before(async () => {
+		process.env.PRERENDER = false;
+		fixture = await loadFixture({
+			root: './fixtures/node-middleware/',
+			output: 'server',
+			adapter: nodejs(
+				{
+					mode: 'standalone',
+					standaloneMiddleware: new URL('./fixtures/node-middleware/src/node-middleware.mjs', import.meta.url).toString(),
+				}
+			),
+		});
+		await fixture.build();
+		const { startServer } = await fixture.loadAdapterEntryModule();
+		let res = await startServer();
+		server = res.server;
+		await waitServerListen(server.server);
+	});
+
+	after(async () => {
+		await server.stop();
+		await fixture.clean();
+		delete process.env.PRERENDER;
+	});
+
+	describe('middleware-one', async () => {
+		it('when mode is standalone, calling middleware-one', async () => {
+			const res = await fetch(`http://${server.host}:${server.port}/middleware-one`);
+
+			assert.equal(res.status, 200);
+
+			const html = await res.text();
+			const $ = cheerio.load(html);
+
+			const body = $('body');
+			assert.equal(body.text().includes('This is middleware one'), true);
+		});
+	});
+
+	describe('middleware-two', async () => {
+		it('when mode is standalone, calling middleware-two', async () => {
+			const res = await fetch(`http://${server.host}:${server.port}/middleware-two`);
+
+			assert.equal(res.status, 200);
+
+			const html = await res.text();
+			const $ = cheerio.load(html);
+
+			const body = $('body');
+			assert.equal(body.text().includes('This is middleware two'), true);
+		});
+	});
+});
+
+describe('behavior from middleware, standalone `mode` dont pass `standaloneMiddleware` option', () => {
+	/** @type {import('./test-utils').Fixture} */
+
+	it('when mode is `middleware` and `standaloneMiddleware` is passed.', async () => {
+		try {
+			await loadFixture({
+				root: './fixtures/node-middleware/',
+				output: 'server',
+				adapter: nodejs({ mode: 'middleware', standaloneMiddleware: new URL('./fixtures/node-middleware/src/node-middleware.mjs', import.meta.url).toString() }),
+			});
+			assert.fail('should have thrown an error');
+		} catch (err) {
+			assert.equal(err.message, `'standaloneMiddleware' option is only available in 'standalone' mode.`);
+		}
+	});
+});
+
+describe('behavior from middleware, standalone mode with incorrect standaloneMiddleware path', () => {
+	/** @type {import('./test-utils').Fixture} */
+	let fixture;
+	let server;
+
+	before(async () => {
+		process.env.PRERENDER = false;
+		fixture = await loadFixture({
+			root: './fixtures/node-middleware/',
+			output: 'server',
+			adapter: nodejs({ mode: 'standalone', standaloneMiddleware: `wrong-path/node-middleware.mjs` }),
+		});
+		await fixture.build();
+		const { startServer } = await fixture.loadAdapterEntryModule();
+		let res = startServer();
+		server = res.server;
+		await waitServerListen(server.server);
+	});
+
+	after(async () => {
+		await server.stop();
+		await fixture.clean();
+		delete process.env.PRERENDER;
+	});
+
+	describe('404', async () => {
+		it('when mode is standalone and wrong standaloneMiddleware path, 404 page', async () => {
+			const res = await fetch(`http://${server.host}:${server.port}/error-page`);
+
+			assert.equal(res.status, 404);
+
+			const html = await res.text();
+			const $ = cheerio.load(html);
+
+			const body = $('body');
+			assert.equal(body.text().includes('Page does not exist'), true);
+		});
+	});
+
+	describe('200', async () => {
+		it('when mode is standalone and wrong standaloneMiddleware path, 200 page', async () => {
+			const res = await fetch(`http://${server.host}:${server.port}/`);
+			assert.equal(res.status, 200);
+		});
+	});
+});