Merge pull request #97 from jaredwray/feat-adding-in-image-routes

feat: adding in image routes

Author: jaredwray

.gitignore

@@ -13,4 +13,5 @@ package-lock.json
 DOCKER.md
 
 # AI
-.claude
+.claude
+.DS_Store

README.md

@@ -265,6 +265,16 @@ new MockHttp(options?)
   - `helmet?`: boolean - Use Helmet for security headers (default: true)
   - `apiDocs?`: boolean - Enable Swagger API documentation (default: true)
   - `httpBin?`: HttpBinOptions - Configure which httpbin routes to enable
+    - `httpMethods?`: boolean - Enable HTTP method routes (default: true)
+    - `redirects?`: boolean - Enable redirect routes (default: true)
+    - `requestInspection?`: boolean - Enable request inspection routes (default: true)
+    - `responseInspection?`: boolean - Enable response inspection routes (default: true)
+    - `statusCodes?`: boolean - Enable status code routes (default: true)
+    - `responseFormats?`: boolean - Enable response format routes (default: true)
+    - `cookies?`: boolean - Enable cookie routes (default: true)
+    - `anything?`: boolean - Enable anything routes (default: true)
+    - `auth?`: boolean - Enable authentication routes (default: true)
+    - `images?`: boolean - Enable image routes (default: true)
   - `hookOptions?`: HookifiedOptions - Hookified options
 
 ### Properties
@@ -334,6 +344,10 @@ Register "anything" catch-all routes.
 
 Register authentication routes (basic, bearer, digest, hidden-basic).
 
+#### `async registerImageRoutes(fastifyInstance?)`
+
+Register image routes (jpeg, png, svg, webp) with content negotiation support.
+
 ## Taps (Response Injection)
 
 Access the TapManager via `mockHttp.taps` to inject custom responses.

public/logo.jpg

@@ -26,6 +26,7 @@ import {
 	postRoute,
 	putRoute,
 } from "./routes/http-methods/index.js";
+import { imageRoutes } from "./routes/images/index.js";
 import { indexRoute } from "./routes/index.js";
 import {
 	absoluteRedirectRoute,
@@ -58,6 +59,7 @@ export type HttpBinOptions = {
 	cookies?: boolean;
 	anything?: boolean;
 	auth?: boolean;
+	images?: boolean;
 };
 
 export type MockHttpOptions = {
@@ -108,6 +110,7 @@ export class MockHttp extends Hookified {
 		cookies: true,
 		anything: true,
 		auth: true,
+		images: true,
 	};
 
 	private _server: FastifyInstance = Fastify();
@@ -317,7 +320,21 @@ export class MockHttp extends Hookified {
 
 			// Register the Helmet plugin for security headers
 			if (this._helmet) {
-				await this._server.register(fastifyHelmet);
+				await this._server.register(fastifyHelmet, {
+					contentSecurityPolicy: {
+						directives: {
+							defaultSrc: ["'self'"],
+							scriptSrc: ["'self'", "'unsafe-inline'", "'wasm-unsafe-eval'"],
+							styleSrc: ["'self'", "'unsafe-inline'"],
+							imgSrc: ["'self'", "data:", "https:"],
+							fontSrc: ["'self'", "data:"],
+							connectSrc: ["'self'"],
+							frameSrc: ["'self'"],
+							objectSrc: ["'none'"],
+							upgradeInsecureRequests: [],
+						},
+					},
+				});
 			}
 
 			if (this._apiDocs) {
@@ -334,6 +351,7 @@ export class MockHttp extends Hookified {
 				cookies,
 				anything,
 				auth,
+				images,
 			} = this._httpBin;
 
 			if (httpMethods) {
@@ -372,6 +390,10 @@ export class MockHttp extends Hookified {
 				await this.registerAuthRoutes();
 			}
 
+			if (images) {
+				await this.registerImageRoutes();
+			}
+
 			if (this._autoDetectPort) {
 				const originalPort = this._port;
 				this._port = await this.detectPort();
@@ -535,6 +557,17 @@ export class MockHttp extends Hookified {
 		await fastify.register(bearerAuthRoute);
 		await fastify.register(digestAuthRoute);
 	}
+
+	/**
+	 * Register the image routes.
+	 * @param fastifyInstance - the server instance to register the routes on.
+	 */
+	public async registerImageRoutes(
+		fastifyInstance?: FastifyInstance,
+	): Promise<void> {
+		const fastify = fastifyInstance ?? this._server;
+		await fastify.register(imageRoutes);
+	}
 }
 
 export const mockhttp = MockHttp;

public/logo.png

@@ -0,0 +1,200 @@
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import type {
+	FastifyInstance,
+	FastifyReply,
+	FastifyRequest,
+	FastifySchema,
+} from "fastify";
+
+const imageSchema: FastifySchema = {
+	description:
+		"Returns an image based on Accept header (supports jpeg, png, svg, webp)",
+	tags: ["Images"],
+	headers: {
+		type: "object",
+		properties: {
+			accept: {
+				type: "string",
+				description: "Accept header for content negotiation",
+			},
+		},
+	},
+	response: {
+		200: {
+			description: "Image file",
+			type: "string",
+			format: "binary",
+		},
+	},
+};
+
+const jpegSchema: FastifySchema = {
+	description: "Returns a JPEG image",
+	tags: ["Images"],
+	response: {
+		200: {
+			description: "JPEG image",
+			type: "string",
+			format: "binary",
+		},
+	},
+};
+
+const pngSchema: FastifySchema = {
+	description: "Returns a PNG image",
+	tags: ["Images"],
+	response: {
+		200: {
+			description: "PNG image",
+			type: "string",
+			format: "binary",
+		},
+	},
+};
+
+const svgSchema: FastifySchema = {
+	description: "Returns an SVG image",
+	tags: ["Images"],
+	response: {
+		200: {
+			description: "SVG image",
+			type: "string",
+			format: "binary",
+		},
+	},
+};
+
+const webpSchema: FastifySchema = {
+	description: "Returns a WEBP image",
+	tags: ["Images"],
+	response: {
+		200: {
+			description: "WEBP image",
+			type: "string",
+			format: "binary",
+		},
+	},
+};
+
+export const imageRoutes = (fastify: FastifyInstance) => {
+	const publicPath = join(process.cwd(), "public");
+
+	// Content negotiation route
+	fastify.get(
+		"/image",
+		{ schema: imageSchema },
+		async (request: FastifyRequest, reply: FastifyReply) => {
+			const accept = request.headers.accept || "";
+
+			let file = "logo.png";
+			let contentType = "image/png";
+
+			if (accept.includes("image/jpeg") || accept.includes("image/jpg")) {
+				file = "logo.jpg";
+				contentType = "image/jpeg";
+			} else if (
+				accept.includes("image/svg+xml") ||
+				accept.includes("image/svg")
+			) {
+				file = "logo.svg";
+				contentType = "image/svg+xml";
+			} else if (accept.includes("image/webp")) {
+				file = "logo.webp";
+				contentType = "image/webp";
+			} else if (accept.includes("image/png")) {
+				file = "logo.png";
+				contentType = "image/png";
+			}
+
+			try {
+				const imagePath = join(publicPath, file);
+				const imageBuffer = readFileSync(imagePath);
+
+				reply.type(contentType);
+				return imageBuffer;
+			} catch (error) {
+				/* v8 ignore next -- @preserve */
+				reply.code(500);
+				/* v8 ignore next -- @preserve */
+				return { error: `${error}` };
+			}
+		},
+	);
+
+	// JPEG specific route
+	fastify.get(
+		"/image/jpeg",
+		{ schema: jpegSchema },
+		async (_request: FastifyRequest, reply: FastifyReply) => {
+			try {
+				const imagePath = join(publicPath, "logo.jpg");
+				const imageBuffer = readFileSync(imagePath);
+				reply.type("image/jpeg");
+				return imageBuffer;
+			} catch (error) {
+				/* v8 ignore next -- @preserve */
+				reply.code(500);
+				/* v8 ignore next -- @preserve */
+				return { error: `${error}` };
+			}
+		},
+	);
+
+	// PNG specific route
+	fastify.get(
+		"/image/png",
+		{ schema: pngSchema },
+		async (_request: FastifyRequest, reply: FastifyReply) => {
+			try {
+				const imagePath = join(publicPath, "logo.png");
+				const imageBuffer = readFileSync(imagePath);
+				reply.type("image/png");
+				return imageBuffer;
+			} catch (error) {
+				/* v8 ignore next -- @preserve */
+				reply.code(500);
+				/* v8 ignore next -- @preserve */
+				return { error: `${error}` };
+			}
+		},
+	);
+
+	// SVG specific route
+	fastify.get(
+		"/image/svg",
+		{ schema: svgSchema },
+		async (_request: FastifyRequest, reply: FastifyReply) => {
+			try {
+				const imagePath = join(publicPath, "logo.svg");
+				const imageBuffer = readFileSync(imagePath);
+				reply.type("image/svg+xml");
+				return imageBuffer;
+			} catch (error) {
+				/* v8 ignore next -- @preserve */
+				reply.code(500);
+				/* v8 ignore next -- @preserve */
+				return { error: `${error}` };
+			}
+		},
+	);
+
+	// WEBP specific route
+	fastify.get(
+		"/image/webp",
+		{ schema: webpSchema },
+		async (_request: FastifyRequest, reply: FastifyReply) => {
+			try {
+				const imagePath = join(publicPath, "logo.webp");
+				const imageBuffer = readFileSync(imagePath);
+				reply.type("image/webp");
+				return imageBuffer;
+			} catch (error) {
+				/* v8 ignore next -- @preserve */
+				reply.code(500);
+				/* v8 ignore next -- @preserve */
+				return { error: `${error}` };
+			}
+		},
+	);
+};