Osvědčené postupy pro Workers

// ✅ Good: Env is generated by wrangler types and always matches your config
// Do not manually define Env — it drifts from your actual bindings

export default {
	async fetch(request, env) {
		// env.MY_KV, env.MY_BUCKET, etc. are all correctly typed
		const value = await env.MY_KV.get("key");
		return new Response(value);
	},
};

// ✅ Good: Env is generated by wrangler types and always matches your config
// Do not manually define Env — it drifts from your actual bindings

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		// env.MY_KV, env.MY_BUCKET, etc. are all correctly typed
		const value = await env.MY_KV.get("key");
		return new Response(value);
	},
} satisfies ExportedHandler<Env>;

// 🔴 Bad: buffers the entire response body in memory
const badHandler = {
	async fetch(request, env) {
		const response = await fetch("https://api.example.com/large-dataset");
		const text = await response.text();
		return new Response(text);
	},
};

// ✅ Good: stream the response body through without buffering
export default {
	async fetch(request, env) {
		const response = await fetch("https://api.example.com/large-dataset");
		return new Response(response.body, response);
	},
};

// 🔴 Bad: buffers the entire response body in memory
const badHandler = {
	async fetch(request: Request, env: Env): Promise<Response> {
		const response = await fetch("https://api.example.com/large-dataset");
		const text = await response.text();
		return new Response(text);
	},
} satisfies ExportedHandler<Env>;

// ✅ Good: stream the response body through without buffering
export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const response = await fetch("https://api.example.com/large-dataset");
		return new Response(response.body, response);
	},
} satisfies ExportedHandler<Env>;

export default {
	async fetch(request, env) {
		const urls = [
			"https://api.example.com/part-1",
			"https://api.example.com/part-2",
			"https://api.example.com/part-3",
		];

		const { readable, writable } = new TransformStream();

		// ✅ Good: pipe each response body sequentially without buffering
		const pipeline = (async () => {
			for (const url of urls) {
				const response = await fetch(url);
				if (response.body) {
					// pipeTo with preventClose keeps the writable open for the next response
					await response.body.pipeTo(writable, {
						preventClose: true,
					});
				}
			}
			await writable.close();
		})();

		// Return the readable side immediately — data streams as it arrives
		return new Response(readable, {
			headers: { "Content-Type": "application/octet-stream" },
		});
	},
};

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const urls = [
			"https://api.example.com/part-1",
			"https://api.example.com/part-2",
			"https://api.example.com/part-3",
		];

		const { readable, writable } = new TransformStream();

		// ✅ Good: pipe each response body sequentially without buffering
		const pipeline = (async () => {
			for (const url of urls) {
				const response = await fetch(url);
				if (response.body) {
					// pipeTo with preventClose keeps the writable open for the next response
					await response.body.pipeTo(writable, {
						preventClose: true,
					});
				}
			}
			await writable.close();
		})();

		// Return the readable side immediately — data streams as it arrives
		return new Response(readable, {
			headers: { "Content-Type": "application/octet-stream" },
		});
	},
} satisfies ExportedHandler<Env>;

// 🔴 Bad: destructuring ctx loses the `this` binding
const badHandler = {
	async fetch(request, env, ctx) {
		const { waitUntil } = ctx; // "Illegal invocation" at runtime
		waitUntil(fetch("https://analytics.example.com/events"));
		return new Response("OK");
	},
};

// ✅ Good: send the response immediately, do background work after
export default {
	async fetch(request, env, ctx) {
		const data = await processRequest(request);

		ctx.waitUntil(logToAnalytics(env, data));
		ctx.waitUntil(updateCache(env, data));

		return Response.json(data);
	},
};

async function logToAnalytics(env, data) {
	await fetch("https://analytics.example.com/events", {
		method: "POST",
		body: JSON.stringify(data),
	});
}

async function updateCache(env, data) {
	await env.CACHE.put("latest", JSON.stringify(data));
}

// 🔴 Bad: destructuring ctx loses the `this` binding
const badHandler = {
	async fetch(
		request: Request,
		env: Env,
		ctx: ExecutionContext,
	): Promise<Response> {
		const { waitUntil } = ctx; // "Illegal invocation" at runtime
		waitUntil(fetch("https://analytics.example.com/events"));
		return new Response("OK");
	},
} satisfies ExportedHandler<Env>;

// ✅ Good: send the response immediately, do background work after
export default {
	async fetch(
		request: Request,
		env: Env,
		ctx: ExecutionContext,
	): Promise<Response> {
		const data = await processRequest(request);

		ctx.waitUntil(logToAnalytics(env, data));
		ctx.waitUntil(updateCache(env, data));

		return Response.json(data);
	},
} satisfies ExportedHandler<Env>;

async function logToAnalytics(env: Env, data: unknown): Promise<void> {
	await fetch("https://analytics.example.com/events", {
		method: "POST",
		body: JSON.stringify(data),
	});
}

async function updateCache(env: Env, data: unknown): Promise<void> {
	await env.CACHE.put("latest", JSON.stringify(data));
}

// 🔴 Bad: calling the REST API from a Worker
const badHandler = {
	async fetch(request, env) {
		const response = await fetch(
			"https://api.cloudflare.com/client/v4/accounts/ACCOUNT_ID/r2/buckets/BUCKET_NAME/objects/my-file",
			{ headers: { Authorization: `Bearer ${env.CF_API_TOKEN}` } },
		);
		return new Response(response.body);
	},
};

// ✅ Good: use the binding directly — no network hop, no auth needed
export default {
	async fetch(request, env) {
		const object = await env.MY_BUCKET.get("my-file");

		if (!object) {
			return new Response("Not found", { status: 404 });
		}

		return new Response(object.body, {
			headers: {
				"Content-Type":
					object.httpMetadata?.contentType ?? "application/octet-stream",
			},
		});
	},
};

// 🔴 Bad: calling the REST API from a Worker
const badHandler = {
	async fetch(request: Request, env: Env): Promise<Response> {
		const response = await fetch(
			"https://api.cloudflare.com/client/v4/accounts/ACCOUNT_ID/r2/buckets/BUCKET_NAME/objects/my-file",
			{ headers: { Authorization: `Bearer ${env.CF_API_TOKEN}` } },
		);
		return new Response(response.body);
	},
} satisfies ExportedHandler<Env>;

// ✅ Good: use the binding directly — no network hop, no auth needed
export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const object = await env.MY_BUCKET.get("my-file");

		if (!object) {
			return new Response("Not found", { status: 404 });
		}

		return new Response(object.body, {
			headers: {
				"Content-Type":
					object.httpMetadata?.contentType ?? "application/octet-stream",
			},
		});
	},
} satisfies ExportedHandler<Env>;

export default {
	async fetch(request, env) {
		const order = await request.json();

		if (order.type === "simple") {
			// ✅ Queue: single-step background job — send a message for async processing
			await env.ORDER_QUEUE.send({
				orderId: order.id,
				action: "send-confirmation-email",
			});
		} else {
			// ✅ Workflow: multi-step durable process — payment, fulfillment, notification
			const instance = await env.FULFILLMENT_WORKFLOW.create({
				params: { orderId: order.id },
			});
		}

		return Response.json({ status: "accepted" }, { status: 202 });
	},
};

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const order = await request.json<{ id: string; type: string }>();

		if (order.type === "simple") {
			// ✅ Queue: single-step background job — send a message for async processing
			await env.ORDER_QUEUE.send({
				orderId: order.id,
				action: "send-confirmation-email",
			});
		} else {
			// ✅ Workflow: multi-step durable process — payment, fulfillment, notification
			const instance = await env.FULFILLMENT_WORKFLOW.create({
				params: { orderId: order.id },
			});
		}

		return Response.json({ status: "accepted" }, { status: 202 });
	},
} satisfies ExportedHandler<Env>;

import { WorkerEntrypoint } from "cloudflare:workers";

// The "auth" Worker exposes RPC methods
export class AuthService extends WorkerEntrypoint {
	async verifyToken(token) {
		// Token verification logic
		return { userId: "user-123", valid: true };
	}
}

// The "api" Worker calls the auth Worker via a service binding
export default {
	async fetch(request, env) {
		const token = request.headers.get("Authorization")?.replace("Bearer ", "");

		if (!token) {
			return new Response("Unauthorized", { status: 401 });
		}

		// ✅ Good: call another Worker via service binding RPC — no network hop
		const auth = await env.AUTH_SERVICE.verifyToken(token);

		if (!auth.valid) {
			return new Response("Invalid token", { status: 403 });
		}

		return Response.json({ userId: auth.userId });
	},
};

import { WorkerEntrypoint } from "cloudflare:workers";

// The "auth" Worker exposes RPC methods
export class AuthService extends WorkerEntrypoint {
	async verifyToken(
		token: string,
	): Promise<{ userId: string; valid: boolean }> {
		// Token verification logic
		return { userId: "user-123", valid: true };
	}
}

// The "api" Worker calls the auth Worker via a service binding
export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const token = request.headers.get("Authorization")?.replace("Bearer ", "");

		if (!token) {
			return new Response("Unauthorized", { status: 401 });
		}

		// ✅ Good: call another Worker via service binding RPC — no network hop
		const auth = await env.AUTH_SERVICE.verifyToken(token);

		if (!auth.valid) {
			return new Response("Invalid token", { status: 403 });
		}

		return Response.json({ userId: auth.userId });
	},
} satisfies ExportedHandler<Env>;

import { Client } from "pg";

export default {
	async fetch(request, env) {
		// ✅ Good: create a new client per request — Hyperdrive pools the underlying connection
		const client = new Client({
			connectionString: env.HYPERDRIVE.connectionString,
		});

		try {
			await client.connect();
			const result = await client.query("SELECT id, name FROM users LIMIT 10");
			return Response.json(result.rows);
		} catch (e) {
			console.error(
				JSON.stringify({ message: "database query failed", error: String(e) }),
			);
			return Response.json({ error: "Database error" }, { status: 500 });
		}
	},
};

// 🔴 Bad: connecting directly to a remote database without Hyperdrive
// Every request pays the full TCP + TLS + auth cost (often 300-500ms)
const badHandler = {
	async fetch(request, env) {
		const client = new Client({
			connectionString: "postgres://user:[email protected]:5432/mydb",
		});
		await client.connect();
		const result = await client.query("SELECT id, name FROM users LIMIT 10");
		return Response.json(result.rows);
	},
};

import { Client } from "pg";

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		// ✅ Good: create a new client per request — Hyperdrive pools the underlying connection
		const client = new Client({
			connectionString: env.HYPERDRIVE.connectionString,
		});

		try {
			await client.connect();
			const result = await client.query("SELECT id, name FROM users LIMIT 10");
			return Response.json(result.rows);
		} catch (e) {
			console.error(
				JSON.stringify({ message: "database query failed", error: String(e) }),
			);
			return Response.json({ error: "Database error" }, { status: 500 });
		}
	},
} satisfies ExportedHandler<Env>;

// 🔴 Bad: connecting directly to a remote database without Hyperdrive
// Every request pays the full TCP + TLS + auth cost (often 300-500ms)
const badHandler = {
	async fetch(request: Request, env: Env): Promise<Response> {
		const client = new Client({
			connectionString: "postgres://user:[email protected]:5432/mydb",
		});
		await client.connect();
		const result = await client.query("SELECT id, name FROM users LIMIT 10");
		return Response.json(result.rows);
	},
} satisfies ExportedHandler<Env>;

import { DurableObject } from "cloudflare:workers";

// Parent Worker: upgrades HTTP to WebSocket and routes to a Durable Object
export default {
	async fetch(request, env) {
		if (request.headers.get("Upgrade") !== "websocket") {
			return new Response("Expected WebSocket", { status: 426 });
		}

		const stub = env.CHAT_ROOM.getByName("default-room");
		return stub.fetch(request);
	},
};

// Durable Object: manages WebSocket connections with hibernation
export class ChatRoom extends DurableObject {
	constructor(ctx, env) {
		super(ctx, env);
		// Auto ping/pong without waking the object
		this.ctx.setWebSocketAutoResponse(
			new WebSocketRequestResponsePair("ping", "pong"),
		);
	}

	async fetch(request) {
		const pair = new WebSocketPair();
		const [client, server] = Object.values(pair);

		// ✅ Good: acceptWebSocket enables hibernation
		this.ctx.acceptWebSocket(server);

		return new Response(null, { status: 101, webSocket: client });
	}

	// Called when a message arrives — the object wakes from hibernation if needed
	async webSocketMessage(ws, message) {
		for (const conn of this.ctx.getWebSockets()) {
			conn.send(typeof message === "string" ? message : "binary");
		}
	}

	async webSocketClose(ws, code, reason, wasClean) {
		// With web_socket_auto_reply_to_close (compat date >= 2026-04-07), the runtime
		// auto-replies to Close frames. Calling close() is safe but no longer required.
		ws.close(code, reason);
	}
}

import { DurableObject } from "cloudflare:workers";

// Parent Worker: upgrades HTTP to WebSocket and routes to a Durable Object
export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		if (request.headers.get("Upgrade") !== "websocket") {
			return new Response("Expected WebSocket", { status: 426 });
		}

		const stub = env.CHAT_ROOM.getByName("default-room");
		return stub.fetch(request);
	},
} satisfies ExportedHandler<Env>;

// Durable Object: manages WebSocket connections with hibernation
export class ChatRoom extends DurableObject {
	constructor(ctx: DurableObjectState, env: Env) {
		super(ctx, env);
		// Auto ping/pong without waking the object
		this.ctx.setWebSocketAutoResponse(
			new WebSocketRequestResponsePair("ping", "pong"),
		);
	}

	async fetch(request: Request): Promise<Response> {
		const pair = new WebSocketPair();
		const [client, server] = Object.values(pair);

		// ✅ Good: acceptWebSocket enables hibernation
		this.ctx.acceptWebSocket(server);

		return new Response(null, { status: 101, webSocket: client });
	}

	// Called when a message arrives — the object wakes from hibernation if needed
	async webSocketMessage(ws: WebSocket, message: string | ArrayBuffer) {
		for (const conn of this.ctx.getWebSockets()) {
			conn.send(typeof message === "string" ? message : "binary");
		}
	}

	async webSocketClose(
		ws: WebSocket,
		code: number,
		reason: string,
		wasClean: boolean,
	) {
		// With web_socket_auto_reply_to_close (compat date >= 2026-04-07), the runtime
		// auto-replies to Close frames. Calling close() is safe but no longer required.
		ws.close(code, reason);
	}
}

export default {
	async fetch(request, env) {
		const url = new URL(request.url);

		try {
			// ✅ Good: structured JSON — searchable and filterable in the dashboard
			console.log(
				JSON.stringify({
					message: "incoming request",
					method: request.method,
					path: url.pathname,
				}),
			);

			const result = await env.MY_KV.get(url.pathname);
			return new Response(result ?? "Not found", {
				status: result ? 200 : 404,
			});
		} catch (e) {
			// ✅ Good: console.error appears as "error" severity in Workers Observability
			console.error(
				JSON.stringify({
					message: "request failed",
					error: e instanceof Error ? e.message : String(e),
					path: url.pathname,
				}),
			);
			return Response.json({ error: "Internal server error" }, { status: 500 });
		}
	},
};

// 🔴 Bad: unstructured string logs are hard to query
const badHandler = {
	async fetch(request, env) {
		const url = new URL(request.url);
		console.log("Got a request to " + url.pathname);
		return new Response("OK");
	},
};

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const url = new URL(request.url);

		try {
			// ✅ Good: structured JSON — searchable and filterable in the dashboard
			console.log(
				JSON.stringify({
					message: "incoming request",
					method: request.method,
					path: url.pathname,
				}),
			);

			const result = await env.MY_KV.get(url.pathname);
			return new Response(result ?? "Not found", {
				status: result ? 200 : 404,
			});
		} catch (e) {
			// ✅ Good: console.error appears as "error" severity in Workers Observability
			console.error(
				JSON.stringify({
					message: "request failed",
					error: e instanceof Error ? e.message : String(e),
					path: url.pathname,
				}),
			);
			return Response.json({ error: "Internal server error" }, { status: 500 });
		}
	},
} satisfies ExportedHandler<Env>;

// 🔴 Bad: unstructured string logs are hard to query
const badHandler = {
	async fetch(request: Request, env: Env): Promise<Response> {
		const url = new URL(request.url);
		console.log("Got a request to " + url.pathname);
		return new Response("OK");
	},
} satisfies ExportedHandler<Env>;

// 🔴 Bad: global mutable state leaks between requests
let currentUser = null;

const badHandler = {
	async fetch(request, env, ctx) {
		// Storing request-scoped data globally means the next request sees stale data
		currentUser = request.headers.get("X-User-Id");
		const result = await handleRequest(currentUser, env);
		return Response.json(result);
	},
};

// ✅ Good: pass request-scoped data through function arguments
export default {
	async fetch(request, env, ctx) {
		const userId = request.headers.get("X-User-Id");
		const result = await handleRequest(userId, env);

		return Response.json(result);
	},
};

async function handleRequest(userId, env) {
	return { userId };
}

// 🔴 Bad: global mutable state leaks between requests
let currentUser: string | null = null;

const badHandler = {
	async fetch(
		request: Request,
		env: Env,
		ctx: ExecutionContext,
	): Promise<Response> {
		// Storing request-scoped data globally means the next request sees stale data
		currentUser = request.headers.get("X-User-Id");
		const result = await handleRequest(currentUser, env);
		return Response.json(result);
	},
} satisfies ExportedHandler<Env>;

// ✅ Good: pass request-scoped data through function arguments
export default {
	async fetch(
		request: Request,
		env: Env,
		ctx: ExecutionContext,
	): Promise<Response> {
		const userId = request.headers.get("X-User-Id");
		const result = await handleRequest(userId, env);

		return Response.json(result);
	},
} satisfies ExportedHandler<Env>;

async function handleRequest(userId: string | null, env: Env): Promise<object> {
	return { userId };
}

export default {
	async fetch(request, env, ctx) {
		const data = await request.json();

		// 🔴 Bad: floating promise — result is dropped, errors are swallowed
		fetch("https://api.example.com/webhook", {
			method: "POST",
			body: JSON.stringify(data),
		});

		// ✅ Good: await if you need the result before responding
		const response = await fetch("https://api.example.com/process", {
			method: "POST",
			body: JSON.stringify(data),
		});

		// ✅ Good: waitUntil if you do not need the result before responding
		ctx.waitUntil(
			fetch("https://api.example.com/webhook", {
				method: "POST",
				body: JSON.stringify(data),
			}),
		);

		return new Response("OK");
	},
};

export default {
	async fetch(
		request: Request,
		env: Env,
		ctx: ExecutionContext,
	): Promise<Response> {
		const data = await request.json();

		// 🔴 Bad: floating promise — result is dropped, errors are swallowed
		fetch("https://api.example.com/webhook", {
			method: "POST",
			body: JSON.stringify(data),
		});

		// ✅ Good: await if you need the result before responding
		const response = await fetch("https://api.example.com/process", {
			method: "POST",
			body: JSON.stringify(data),
		});

		// ✅ Good: waitUntil if you do not need the result before responding
		ctx.waitUntil(
			fetch("https://api.example.com/webhook", {
				method: "POST",
				body: JSON.stringify(data),
			}),
		);

		return new Response("OK");
	},
} satisfies ExportedHandler<Env>;

export default {
	async fetch(request, env) {
		// 🔴 Bad: Math.random() is predictable and not suitable for security
		const badToken = Math.random().toString(36).substring(2);

		// ✅ Good: cryptographically secure random UUID
		const sessionId = crypto.randomUUID();

		// ✅ Good: cryptographically secure random bytes for tokens
		const tokenBytes = new Uint8Array(32);
		crypto.getRandomValues(tokenBytes);
		const token = Array.from(tokenBytes)
			.map((b) => b.toString(16).padStart(2, "0"))
			.join("");

		return Response.json({ sessionId, token });
	},
};

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		// 🔴 Bad: Math.random() is predictable and not suitable for security
		const badToken = Math.random().toString(36).substring(2);

		// ✅ Good: cryptographically secure random UUID
		const sessionId = crypto.randomUUID();

		// ✅ Good: cryptographically secure random bytes for tokens
		const tokenBytes = new Uint8Array(32);
		crypto.getRandomValues(tokenBytes);
		const token = Array.from(tokenBytes)
			.map((b) => b.toString(16).padStart(2, "0"))
			.join("");

		return Response.json({ sessionId, token });
	},
} satisfies ExportedHandler<Env>;

async function verifyToken(provided, expected) {
	const encoder = new TextEncoder();

	// ✅ Good: hash both values to a fixed size, then compare in constant time
	// This avoids leaking the length of the expected value
	const [providedHash, expectedHash] = await Promise.all([
		crypto.subtle.digest("SHA-256", encoder.encode(provided)),
		crypto.subtle.digest("SHA-256", encoder.encode(expected)),
	]);

	return crypto.subtle.timingSafeEqual(providedHash, expectedHash);
}

// 🔴 Bad: direct string comparison leaks timing information
function verifyTokenInsecure(provided, expected) {
	return provided === expected;
}

async function verifyToken(
	provided: string,
	expected: string,
): Promise<boolean> {
	const encoder = new TextEncoder();

	// ✅ Good: hash both values to a fixed size, then compare in constant time
	// This avoids leaking the length of the expected value
	const [providedHash, expectedHash] = await Promise.all([
		crypto.subtle.digest("SHA-256", encoder.encode(provided)),
		crypto.subtle.digest("SHA-256", encoder.encode(expected)),
	]);

	return crypto.subtle.timingSafeEqual(providedHash, expectedHash);
}

// 🔴 Bad: direct string comparison leaks timing information
function verifyTokenInsecure(provided: string, expected: string): boolean {
	return provided === expected;
}

// 🔴 Bad: hides errors by falling through to origin
const badHandler = {
	async fetch(request, env, ctx) {
		ctx.passThroughOnException();
		const result = await handleRequest(request, env);
		return Response.json(result);
	},
};

// ✅ Good: explicit error handling with structured responses
export default {
	async fetch(request, env, ctx) {
		try {
			const result = await handleRequest(request, env);
			return Response.json(result);
		} catch (error) {
			const message = error instanceof Error ? error.message : "Unknown error";

			console.error(
				JSON.stringify({
					message: "unhandled error",
					error: message,
					path: new URL(request.url).pathname,
				}),
			);

			return Response.json({ error: "Internal server error" }, { status: 500 });
		}
	},
};

async function handleRequest(request, env) {
	return { status: "ok" };
}

// 🔴 Bad: hides errors by falling through to origin
const badHandler = {
	async fetch(
		request: Request,
		env: Env,
		ctx: ExecutionContext,
	): Promise<Response> {
		ctx.passThroughOnException();
		const result = await handleRequest(request, env);
		return Response.json(result);
	},
} satisfies ExportedHandler<Env>;

// ✅ Good: explicit error handling with structured responses
export default {
	async fetch(
		request: Request,
		env: Env,
		ctx: ExecutionContext,
	): Promise<Response> {
		try {
			const result = await handleRequest(request, env);
			return Response.json(result);
		} catch (error) {
			const message = error instanceof Error ? error.message : "Unknown error";

			console.error(
				JSON.stringify({
					message: "unhandled error",
					error: message,
					path: new URL(request.url).pathname,
				}),
			);

			return Response.json({ error: "Internal server error" }, { status: 500 });
		}
	},
} satisfies ExportedHandler<Env>;

async function handleRequest(request: Request, env: Env): Promise<object> {
	return { status: "ok" };
}

import { describe, it, expect } from "vitest";
import { env } from "cloudflare:workers";

describe("KV operations", () => {
	it("should store and retrieve a value", async () => {
		await env.MY_KV.put("key", "value");
		const result = await env.MY_KV.get("key");
		expect(result).toBe("value");
	});

	it("should return null for missing keys", async () => {
		const result = await env.MY_KV.get("nonexistent");
		// ✅ Good: test the null case explicitly
		expect(result).toBeNull();
	});
});

import { describe, it, expect } from "vitest";
import { env } from "cloudflare:workers";

describe("KV operations", () => {
	it("should store and retrieve a value", async () => {
		await env.MY_KV.put("key", "value");
		const result = await env.MY_KV.get("key");
		expect(result).toBe("value");
	});

	it("should return null for missing keys", async () => {
		const result = await env.MY_KV.get("nonexistent");
		// ✅ Good: test the null case explicitly
		expect(result).toBeNull();
	});
});