{"inputs":{"src/types.ts":{"bytes":1545,"imports":[{"path":"<runtime>","kind":"import-statement","external":true}],"format":"esm"},"src/index.ts":{"bytes":11207,"imports":[{"path":"mime","kind":"import-statement","external":true},{"path":"src/types.ts","kind":"import-statement","original":"./types"},{"path":"<runtime>","kind":"import-statement","external":true}],"format":"esm"}},"outputs":{"dist/index.js.map":{"imports":[],"exports":[],"inputs":{},"bytes":19598},"dist/index.js":{"imports":[{"path":"mime","kind":"import-statement","external":true}],"exports":["CacheControl","InternalError","MethodNotAllowedError","NotFoundError","Options","getAssetFromKV","mapRequestToAsset","serveSinglePageApp"],"entryPoint":"src/index.ts","inputs":{"src/index.ts":{"bytesInOutput":7750},"src/types.ts":{"bytesInOutput":881}},"bytes":8942}}}

+34

-4

dist/index.d.ts

		@@ -1,5 +0,35 @@
		import { CacheControl, InternalError, MethodNotAllowedError, NotFoundError, Options } from "./types";
		declare global {
		const __STATIC_CONTENT: KVNamespace \| undefined, __STATIC_CONTENT_MANIFEST: string;
		const __STATIC_CONTENT: KVNamespace \| undefined;
		const __STATIC_CONTENT_MANIFEST: Record<string, string> \| undefined;
		}
		type CacheControl = {
		browserTTL: number;
		edgeTTL: number;
		bypassCache: boolean;
		};
		type AssetManifestType = Record<string, string>;
		type Options = {
		cacheControl: ((req: Request) => Partial<CacheControl>) \| Partial<CacheControl>;
		ASSET_NAMESPACE: KVNamespace;
		ASSET_MANIFEST: AssetManifestType \| string;
		mapRequestToAsset?: (req: Request, options?: Partial<Options>) => Request;
		defaultMimeType: string;
		defaultDocument: string;
		pathIsEncoded: boolean;
		defaultETag: "strong" \| "weak";
		};
		declare class KVError extends Error {
		constructor(message?: string, status?: number);
		status: number;
		}
		declare class MethodNotAllowedError extends KVError {
		constructor(message?: string, status?: number);
		}
		declare class NotFoundError extends KVError {
		constructor(message?: string, status?: number);
		}
		declare class InternalError extends KVError {
		constructor(message?: string, status?: number);
		}

		/**
		@@ -35,3 +65,3 @@ * maps the path of incoming request to the request pathKey to look up
		declare const getAssetFromKV: (event: Evt, options?: Partial<Options>) => Promise<Response>;
		export { getAssetFromKV, mapRequestToAsset, serveSinglePageApp };
		export { Options, CacheControl, MethodNotAllowedError, NotFoundError, InternalError, };

		export { type CacheControl, InternalError, MethodNotAllowedError, NotFoundError, type Options, getAssetFromKV, mapRequestToAsset, serveSinglePageApp };

+247

-287

dist/index.js

		@@ -1,56 +0,57 @@
		"use strict";
		var __createBinding = (this && this.__createBinding) \|\| (Object.create ? (function(o, m, k, k2) {
		if (k2 === undefined) k2 = k;
		var desc = Object.getOwnPropertyDescriptor(m, k);
		if (!desc \|\| ("get" in desc ? !m.__esModule : desc.writable \|\| desc.configurable)) {
		desc = { enumerable: true, get: function() { return m[k]; } };
		}
		Object.defineProperty(o, k2, desc);
		}) : (function(o, m, k, k2) {
		if (k2 === undefined) k2 = k;
		o[k2] = m[k];
		}));
		var __setModuleDefault = (this && this.__setModuleDefault) \|\| (Object.create ? (function(o, v) {
		Object.defineProperty(o, "default", { enumerable: true, value: v });
		}) : function(o, v) {
		o["default"] = v;
		});
		var __importStar = (this && this.__importStar) \|\| (function () {
		var ownKeys = function(o) {
		ownKeys = Object.getOwnPropertyNames \|\| function (o) {
		var ar = [];
		for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
		return ar;
		};
		return ownKeys(o);
		};
		return function (mod) {
		if (mod && mod.__esModule) return mod;
		var result = {};
		if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
		__setModuleDefault(result, mod);
		return result;
		};
		})();
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.InternalError = exports.NotFoundError = exports.MethodNotAllowedError = exports.mapRequestToAsset = exports.getAssetFromKV = void 0;
		exports.serveSinglePageApp = serveSinglePageApp;
		const mime = __importStar(require("mime"));
		const types_1 = require("./types");
		Object.defineProperty(exports, "InternalError", { enumerable: true, get: function () { return types_1.InternalError; } });
		Object.defineProperty(exports, "MethodNotAllowedError", { enumerable: true, get: function () { return types_1.MethodNotAllowedError; } });
		Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return types_1.NotFoundError; } });
		const defaultCacheControl = {
		browserTTL: null,
		edgeTTL: 2 * 60 * 60 * 24, // 2 days
		bypassCache: false, // do not bypass Cloudflare's cache
		import * as mime from 'mime';

		var __defProp = Object.defineProperty;
		var __name = (target, value) => __defProp(target, "name", { value, configurable: true });

		// src/types.ts
		var KVError = class _KVError extends Error {
		static {
		__name(this, "KVError");
		}
		constructor(message, status = 500) {
		super(message);
		Object.setPrototypeOf(this, new.target.prototype);
		this.name = _KVError.name;
		this.status = status;
		}
		status;
		};
		const parseStringAsObject = (maybeString) => typeof maybeString === "string"
		? JSON.parse(maybeString)
		: maybeString;
		const getAssetFromKVDefaultOptions = {
		ASSET_NAMESPACE: typeof __STATIC_CONTENT !== "undefined" ? __STATIC_CONTENT : undefined,
		ASSET_MANIFEST: typeof __STATIC_CONTENT_MANIFEST !== "undefined"
		? parseStringAsObject(__STATIC_CONTENT_MANIFEST)
		: {},
		var MethodNotAllowedError = class extends KVError {
		static {
		__name(this, "MethodNotAllowedError");
		}
		constructor(message = `Not a valid request method`, status = 405) {
		super(message, status);
		}
		};
		var NotFoundError = class extends KVError {
		static {
		__name(this, "NotFoundError");
		}
		constructor(message = `Not Found`, status = 404) {
		super(message, status);
		}
		};
		var InternalError = class extends KVError {
		static {
		__name(this, "InternalError");
		}
		constructor(message = `Internal Error in KV Asset Handler`, status = 500) {
		super(message, status);
		}
		};

		// src/index.ts
		var defaultCacheControl = {
		browserTTL: null,
		edgeTTL: 2 * 60 * 60 * 24,
		// 2 days
		bypassCache: false
		// do not bypass Cloudflare's cache
		};
		var parseStringAsObject = /* @__PURE__ */ __name((maybeString) => typeof maybeString === "string" ? JSON.parse(maybeString) : maybeString, "parseStringAsObject");
		function getAssetFromKVDefaultOptions() {
		return {
		ASSET_NAMESPACE: typeof __STATIC_CONTENT !== "undefined" ? __STATIC_CONTENT : void 0,
		ASSET_MANIFEST: typeof __STATIC_CONTENT_MANIFEST !== "undefined" ? parseStringAsObject(__STATIC_CONTENT_MANIFEST) : {},
		cacheControl: defaultCacheControl,
		@@ -60,250 +61,209 @@ defaultMimeType: "text/plain",
		pathIsEncoded: false,
		defaultETag: "strong",
		};
		defaultETag: "strong"
		};
		}
		__name(getAssetFromKVDefaultOptions, "getAssetFromKVDefaultOptions");
		function assignOptions(options) {
		// Assign any missing options passed in to the default
		// options.mapRequestToAsset is handled manually later
		return Object.assign({}, getAssetFromKVDefaultOptions, options);
		return Object.assign({}, getAssetFromKVDefaultOptions(), options);
		}
		/**
		* maps the path of incoming request to the request pathKey to look up
		* in bucket and in cache
		* e.g. for a path '/' returns '/index.html' which serves
		* the content of bucket/index.html
		* @param {Request} request incoming request
		*/
		const mapRequestToAsset = (request, options) => {
		options = assignOptions(options);
		const parsedUrl = new URL(request.url);
		let pathname = parsedUrl.pathname;
		if (pathname.endsWith("/")) {
		// If path looks like a directory append options.defaultDocument
		// e.g. If path is /about/ -> /about/index.html
		pathname = pathname.concat(options.defaultDocument);
		}
		else if (!mime.getType(pathname)) {
		// If path doesn't look like valid content
		// e.g. /about.me -> /about.me/index.html
		pathname = pathname.concat("/" + options.defaultDocument);
		}
		parsedUrl.pathname = pathname;
		return new Request(parsedUrl.toString(), request);
		};
		exports.mapRequestToAsset = mapRequestToAsset;
		/**
		* maps the path of incoming request to /index.html if it evaluates to
		* any HTML file.
		* @param {Request} request incoming request
		*/
		__name(assignOptions, "assignOptions");
		var mapRequestToAsset = /* @__PURE__ */ __name((request, options) => {
		options = assignOptions(options);
		const parsedUrl = new URL(request.url);
		let pathname = parsedUrl.pathname;
		if (pathname.endsWith("/")) {
		pathname = pathname.concat(options.defaultDocument);
		} else if (!mime.getType(pathname)) {
		pathname = pathname.concat("/" + options.defaultDocument);
		}
		parsedUrl.pathname = pathname;
		return new Request(parsedUrl.toString(), request);
		}, "mapRequestToAsset");
		function serveSinglePageApp(request, options) {
		options = assignOptions(options);
		// First apply the default handler, which already has logic to detect
		// paths that should map to HTML files.
		request = mapRequestToAsset(request, options);
		const parsedUrl = new URL(request.url);
		// Detect if the default handler decided to map to
		// a HTML file in some specific directory.
		if (parsedUrl.pathname.endsWith(".html")) {
		// If expected HTML file was missing, just return the root index.html (or options.defaultDocument)
		return new Request(`${parsedUrl.origin}/${options.defaultDocument}`, request);
		}
		else {
		// The default handler decided this is not an HTML page. It's probably
		// an image, CSS, or JS file. Leave it as-is.
		return request;
		}
		options = assignOptions(options);
		request = mapRequestToAsset(request, options);
		const parsedUrl = new URL(request.url);
		if (parsedUrl.pathname.endsWith(".html")) {
		return new Request(
		`${parsedUrl.origin}/${options.defaultDocument}`,
		request
		);
		} else {
		return request;
		}
		}
		const getAssetFromKV = async (event, options) => {
		options = assignOptions(options);
		const request = event.request;
		const ASSET_NAMESPACE = options.ASSET_NAMESPACE;
		const ASSET_MANIFEST = parseStringAsObject(options.ASSET_MANIFEST);
		if (typeof ASSET_NAMESPACE === "undefined") {
		throw new types_1.InternalError(`there is no KV namespace bound to the script`);
		__name(serveSinglePageApp, "serveSinglePageApp");
		var getAssetFromKV = /* @__PURE__ */ __name(async (event, options) => {
		options = assignOptions(options);
		const request = event.request;
		const ASSET_NAMESPACE = options.ASSET_NAMESPACE;
		const ASSET_MANIFEST = parseStringAsObject(
		options.ASSET_MANIFEST
		);
		if (typeof ASSET_NAMESPACE === "undefined") {
		throw new InternalError(`there is no KV namespace bound to the script`);
		}
		const rawPathKey = new URL(request.url).pathname.replace(/^\/+/, "");
		let pathIsEncoded = options.pathIsEncoded;
		let requestKey;
		if (options.mapRequestToAsset) {
		requestKey = options.mapRequestToAsset(request);
		} else if (ASSET_MANIFEST[rawPathKey]) {
		requestKey = request;
		} else if (ASSET_MANIFEST[decodeURIComponent(rawPathKey)]) {
		pathIsEncoded = true;
		requestKey = request;
		} else {
		const mappedRequest = mapRequestToAsset(request);
		const mappedRawPathKey = new URL(mappedRequest.url).pathname.replace(
		/^\/+/,
		""
		);
		if (ASSET_MANIFEST[decodeURIComponent(mappedRawPathKey)]) {
		pathIsEncoded = true;
		requestKey = mappedRequest;
		} else {
		requestKey = mapRequestToAsset(request, options);
		}
		const rawPathKey = new URL(request.url).pathname.replace(/^\/+/, ""); // strip any preceding /'s
		let pathIsEncoded = options.pathIsEncoded;
		let requestKey;
		// if options.mapRequestToAsset is explicitly passed in, always use it and assume user has own intentions
		// otherwise handle request as normal, with default mapRequestToAsset below
		if (options.mapRequestToAsset) {
		requestKey = options.mapRequestToAsset(request);
		}
		const SUPPORTED_METHODS = ["GET", "HEAD"];
		if (!SUPPORTED_METHODS.includes(requestKey.method)) {
		throw new MethodNotAllowedError(
		`${requestKey.method} is not a valid request method`
		);
		}
		const parsedUrl = new URL(requestKey.url);
		const pathname = pathIsEncoded ? decodeURIComponent(parsedUrl.pathname) : parsedUrl.pathname;
		let pathKey = pathname.replace(/^\/+/, "");
		const cache = caches.default;
		let mimeType = mime.getType(pathKey) \|\| options.defaultMimeType;
		if (mimeType.startsWith("text") \|\| mimeType === "application/javascript") {
		mimeType += "; charset=utf-8";
		}
		let shouldEdgeCache = false;
		if (typeof ASSET_MANIFEST !== "undefined") {
		if (ASSET_MANIFEST[pathKey]) {
		pathKey = ASSET_MANIFEST[pathKey];
		shouldEdgeCache = true;
		}
		else if (ASSET_MANIFEST[rawPathKey]) {
		requestKey = request;
		}
		const cacheKey = new Request(`${parsedUrl.origin}/${pathKey}`, request);
		const evalCacheOpts = (() => {
		switch (typeof options.cacheControl) {
		case "function":
		return options.cacheControl(request);
		case "object":
		return options.cacheControl;
		default:
		return defaultCacheControl;
		}
		else if (ASSET_MANIFEST[decodeURIComponent(rawPathKey)]) {
		pathIsEncoded = true;
		requestKey = request;
		})();
		const formatETag = /* @__PURE__ */ __name((entityId = pathKey, validatorType = options.defaultETag) => {
		if (!entityId) {
		return "";
		}
		else {
		const mappedRequest = mapRequestToAsset(request);
		const mappedRawPathKey = new URL(mappedRequest.url).pathname.replace(/^\/+/, "");
		if (ASSET_MANIFEST[decodeURIComponent(mappedRawPathKey)]) {
		pathIsEncoded = true;
		requestKey = mappedRequest;
		switch (validatorType) {
		case "weak":
		if (!entityId.startsWith("W/")) {
		if (entityId.startsWith(`"`) && entityId.endsWith(`"`)) {
		return `W/${entityId}`;
		}
		return `W/"${entityId}"`;
		}
		else {
		// use default mapRequestToAsset
		requestKey = mapRequestToAsset(request, options);
		return entityId;
		case "strong":
		if (entityId.startsWith(`W/"`)) {
		entityId = entityId.replace("W/", "");
		}
		if (!entityId.endsWith(`"`)) {
		entityId = `"${entityId}"`;
		}
		return entityId;
		default:
		return "";
		}
		const SUPPORTED_METHODS = ["GET", "HEAD"];
		if (!SUPPORTED_METHODS.includes(requestKey.method)) {
		throw new types_1.MethodNotAllowedError(`${requestKey.method} is not a valid request method`);
		}, "formatETag");
		options.cacheControl = Object.assign({}, defaultCacheControl, evalCacheOpts);
		if (options.cacheControl.bypassCache \|\| options.cacheControl.edgeTTL === null \|\| request.method == "HEAD") {
		shouldEdgeCache = false;
		}
		const shouldSetBrowserCache = typeof options.cacheControl.browserTTL === "number";
		let response = null;
		if (shouldEdgeCache) {
		response = await cache.match(cacheKey);
		}
		if (response) {
		if (response.status > 300 && response.status < 400) {
		if (response.body && "cancel" in Object.getPrototypeOf(response.body)) {
		response.body.cancel();
		}
		response = new Response(null, response);
		} else {
		const opts = {
		headers: new Headers(response.headers),
		status: 0,
		statusText: ""
		};
		opts.headers.set("cf-cache-status", "HIT");
		if (response.status) {
		opts.status = response.status;
		opts.statusText = response.statusText;
		} else if (opts.headers.has("Content-Range")) {
		opts.status = 206;
		opts.statusText = "Partial Content";
		} else {
		opts.status = 200;
		opts.statusText = "OK";
		}
		response = new Response(response.body, opts);
		}
		const parsedUrl = new URL(requestKey.url);
		const pathname = pathIsEncoded
		? decodeURIComponent(parsedUrl.pathname)
		: parsedUrl.pathname; // decode percentage encoded path only when necessary
		// pathKey is the file path to look up in the manifest
		let pathKey = pathname.replace(/^\/+/, ""); // remove prepended /
		// @ts-expect-error we should pick cf types here
		const cache = caches.default;
		let mimeType = mime.getType(pathKey) \|\| options.defaultMimeType;
		if (mimeType.startsWith("text") \|\| mimeType === "application/javascript") {
		mimeType += "; charset=utf-8";
		} else {
		const body = await ASSET_NAMESPACE.get(pathKey, "arrayBuffer");
		if (body === null) {
		throw new NotFoundError(
		`could not find ${pathKey} in your content namespace`
		);
		}
		let shouldEdgeCache = false; // false if storing in KV by raw file path i.e. no hash
		// check manifest for map from file path to hash
		if (typeof ASSET_MANIFEST !== "undefined") {
		if (ASSET_MANIFEST[pathKey]) {
		pathKey = ASSET_MANIFEST[pathKey];
		// if path key is in asset manifest, we can assume it contains a content hash and can be cached
		shouldEdgeCache = true;
		}
		}
		// TODO this excludes search params from cache, investigate ideal behavior
		const cacheKey = new Request(`${parsedUrl.origin}/${pathKey}`, request);
		// if argument passed in for cacheControl is a function then
		// evaluate that function. otherwise return the Object passed in
		// or default Object
		const evalCacheOpts = (() => {
		switch (typeof options.cacheControl) {
		case "function":
		return options.cacheControl(request);
		case "object":
		return options.cacheControl;
		default:
		return defaultCacheControl;
		}
		})();
		// formats the etag depending on the response context. if the entityId
		// is invalid, returns an empty string (instead of null) to prevent the
		// the potentially disastrous scenario where the value of the Etag resp
		// header is "null". Could be modified in future to base64 encode etc
		const formatETag = (entityId = pathKey, validatorType = options.defaultETag) => {
		if (!entityId) {
		return "";
		}
		switch (validatorType) {
		case "weak":
		if (!entityId.startsWith("W/")) {
		if (entityId.startsWith(`"`) && entityId.endsWith(`"`)) {
		return `W/${entityId}`;
		}
		return `W/"${entityId}"`;
		}
		return entityId;
		case "strong":
		if (entityId.startsWith(`W/"`)) {
		entityId = entityId.replace("W/", "");
		}
		if (!entityId.endsWith(`"`)) {
		entityId = `"${entityId}"`;
		}
		return entityId;
		default:
		return "";
		}
		};
		options.cacheControl = Object.assign({}, defaultCacheControl, evalCacheOpts);
		// override shouldEdgeCache if options say to bypassCache
		if (options.cacheControl.bypassCache \|\|
		options.cacheControl.edgeTTL === null \|\|
		request.method == "HEAD") {
		shouldEdgeCache = false;
		}
		// only set max-age if explicitly passed in a number as an arg
		const shouldSetBrowserCache = typeof options.cacheControl.browserTTL === "number";
		let response = null;
		response = new Response(body);
		if (shouldEdgeCache) {
		response = await cache.match(cacheKey);
		response.headers.set("Accept-Ranges", "bytes");
		response.headers.set("Content-Length", String(body.byteLength));
		if (!response.headers.has("etag")) {
		response.headers.set("etag", formatETag(pathKey));
		}
		response.headers.set(
		"Cache-Control",
		`max-age=${options.cacheControl.edgeTTL}`
		);
		event.waitUntil(cache.put(cacheKey, response.clone()));
		response.headers.set("CF-Cache-Status", "MISS");
		}
		if (response) {
		if (response.status > 300 && response.status < 400) {
		if (response.body && "cancel" in Object.getPrototypeOf(response.body)) {
		// Body exists and environment supports readable streams
		response.body.cancel();
		}
		else {
		// Environment doesnt support readable streams, or null repsonse body. Nothing to do
		}
		response = new Response(null, response);
		}
		else {
		// fixes #165
		const opts = {
		headers: new Headers(response.headers),
		status: 0,
		statusText: "",
		};
		opts.headers.set("cf-cache-status", "HIT");
		if (response.status) {
		opts.status = response.status;
		opts.statusText = response.statusText;
		}
		else if (opts.headers.has("Content-Range")) {
		opts.status = 206;
		opts.statusText = "Partial Content";
		}
		else {
		opts.status = 200;
		opts.statusText = "OK";
		}
		response = new Response(response.body, opts);
		}
		}
		response.headers.set("Content-Type", mimeType);
		if (response.status === 304) {
		const etag = formatETag(response.headers.get("etag"));
		const ifNoneMatch = cacheKey.headers.get("if-none-match");
		const proxyCacheStatus = response.headers.get("CF-Cache-Status");
		if (etag) {
		if (ifNoneMatch && ifNoneMatch === etag && proxyCacheStatus === "MISS") {
		response.headers.set("CF-Cache-Status", "EXPIRED");
		} else {
		response.headers.set("CF-Cache-Status", "REVALIDATED");
		}
		response.headers.set("etag", formatETag(etag, "weak"));
		}
		else {
		const body = await ASSET_NAMESPACE.get(pathKey, "arrayBuffer");
		if (body === null) {
		throw new types_1.NotFoundError(`could not find ${pathKey} in your content namespace`);
		}
		response = new Response(body);
		if (shouldEdgeCache) {
		response.headers.set("Accept-Ranges", "bytes");
		response.headers.set("Content-Length", String(body.byteLength));
		// set etag before cache insertion
		if (!response.headers.has("etag")) {
		response.headers.set("etag", formatETag(pathKey));
		}
		// determine Cloudflare cache behavior
		response.headers.set("Cache-Control", `max-age=${options.cacheControl.edgeTTL}`);
		event.waitUntil(cache.put(cacheKey, response.clone()));
		response.headers.set("CF-Cache-Status", "MISS");
		}
		}
		response.headers.set("Content-Type", mimeType);
		if (response.status === 304) {
		const etag = formatETag(response.headers.get("etag"));
		const ifNoneMatch = cacheKey.headers.get("if-none-match");
		const proxyCacheStatus = response.headers.get("CF-Cache-Status");
		if (etag) {
		if (ifNoneMatch && ifNoneMatch === etag && proxyCacheStatus === "MISS") {
		response.headers.set("CF-Cache-Status", "EXPIRED");
		}
		else {
		response.headers.set("CF-Cache-Status", "REVALIDATED");
		}
		response.headers.set("etag", formatETag(etag, "weak"));
		}
		}
		if (shouldSetBrowserCache) {
		response.headers.set("Cache-Control", `max-age=${options.cacheControl.browserTTL}`);
		}
		else {
		response.headers.delete("Cache-Control");
		}
		return response;
		};
		exports.getAssetFromKV = getAssetFromKV;
		}
		if (shouldSetBrowserCache) {
		response.headers.set(
		"Cache-Control",
		`max-age=${options.cacheControl.browserTTL}`
		);
		} else {
		response.headers.delete("Cache-Control");
		}
		return response;
		}, "getAssetFromKV");

		export { InternalError, MethodNotAllowedError, NotFoundError, getAssetFromKV, mapRequestToAsset, serveSinglePageApp };
		//# sourceMappingURL=index.js.map
		//# sourceMappingURL=index.js.map

+13

-13

package.json

		{
		"name": "@cloudflare/kv-asset-handler",
		"version": "0.4.0",
		"version": "0.4.1",
		"description": "Routes requests to KV assets",
		@@ -23,2 +23,3 @@ "keywords": [
		"author": "wrangler@cloudflare.com",
		"type": "module",
		"main": "dist/index.js",
		@@ -28,5 +29,3 @@ "types": "dist/index.d.ts",
		"src",
		"dist",
		"!src/test",
		"!dist/test"
		"dist"
		],
		@@ -37,9 +36,10 @@ "dependencies": {
		"devDependencies": {
		"@ava/typescript": "^4.1.0",
		"@cloudflare/workers-types": "^4.20250310.0",
		"@cloudflare/vitest-pool-workers": "^0.7.0",
		"@cloudflare/workers-types": "^4.20251125.0",
		"@types/mime": "^3.0.4",
		"@types/node": "^18.19.75",
		"@types/service-worker-mock": "^2.0.1",
		"ava": "^6.0.1",
		"service-worker-mock": "^2.0.5"
		"@types/node": "^20.19.9",
		"eslint": "^9.39.1",
		"tsup": "8.3.0",
		"vitest": "~2.1.0",
		"@cloudflare/eslint-config-shared": "1.1.0"
		},
		@@ -59,9 +59,9 @@ "engines": {
		"scripts": {
		"build": "tsc -d",
		"build": "tsup",
		"check:lint": "eslint . --max-warnings=0",
		"check:type": "tsc",
		"pretest": "npm run build",
		"test": "ava dist/test/*.js --verbose",
		"test:ci": "npm run build && ava dist/test/*.js --verbose"
		"test": "vitest",
		"test:ci": "vitest run"
		}
		}

+16

-19

src/index.ts

		@@ -11,7 +11,2 @@ import * as mime from "mime";

		declare global {
		const __STATIC_CONTENT: KVNamespace \| undefined,
		__STATIC_CONTENT_MANIFEST: string;
		}

		const defaultCacheControl: CacheControl = {
		@@ -28,15 +23,17 @@ browserTTL: null,

		const getAssetFromKVDefaultOptions: Partial<Options> = {
		ASSET_NAMESPACE:
		typeof __STATIC_CONTENT !== "undefined" ? __STATIC_CONTENT : undefined,
		ASSET_MANIFEST:
		typeof __STATIC_CONTENT_MANIFEST !== "undefined"
		? parseStringAsObject<AssetManifestType>(__STATIC_CONTENT_MANIFEST)
		: {},
		cacheControl: defaultCacheControl,
		defaultMimeType: "text/plain",
		defaultDocument: "index.html",
		pathIsEncoded: false,
		defaultETag: "strong",
		};
		function getAssetFromKVDefaultOptions(): Partial<Options> {
		return {
		ASSET_NAMESPACE:
		typeof __STATIC_CONTENT !== "undefined" ? __STATIC_CONTENT : undefined,
		ASSET_MANIFEST:
		typeof __STATIC_CONTENT_MANIFEST !== "undefined"
		? parseStringAsObject<AssetManifestType>(__STATIC_CONTENT_MANIFEST)
		: {},
		cacheControl: defaultCacheControl,
		defaultMimeType: "text/plain",
		defaultDocument: "index.html",
		pathIsEncoded: false,
		defaultETag: "strong",
		};
		}

		@@ -46,3 +43,3 @@ function assignOptions(options?: Partial<Options>): Options {
		// options.mapRequestToAsset is handled manually later
		return <Options>Object.assign({}, getAssetFromKVDefaultOptions, options);
		return <Options>Object.assign({}, getAssetFromKVDefaultOptions(), options);
		}
		@@ -49,0 +46,0 @@

+5

-0

src/types.ts

		@@ -0,1 +1,6 @@
		declare global {
		const __STATIC_CONTENT: KVNamespace \| undefined;
		const __STATIC_CONTENT_MANIFEST: Record<string, string> \| undefined;
		}

		export type CacheControl = {
		@@ -2,0 +7,0 @@ browserTTL: number;

-14

dist/mocks.d.ts

		export declare const getEvent: (request: Request) => Pick<FetchEvent, "request" \| "waitUntil">;
		export declare const mockKV: (kvStore: Record<string, string>) => {
		get: (path: string) => string;
		};
		export declare const mockManifest: () => string;
		export declare const mockCaches: () => {
		default: {
		match(key: Request): Promise<Response>;
		put(key: Request, val: Response): Promise<void>;
		};
		};
		export declare function mockRequestScope(): void;
		export declare function mockGlobalScope(): void;
		export declare const sleep: (milliseconds: number) => Promise<unknown>;

-153

dist/mocks.js

		"use strict";
		var __importDefault = (this && this.__importDefault) \|\| function (mod) {
		return (mod && mod.__esModule) ? mod : { "default": mod };
		};
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.sleep = exports.mockCaches = exports.mockManifest = exports.mockKV = exports.getEvent = void 0;
		exports.mockRequestScope = mockRequestScope;
		exports.mockGlobalScope = mockGlobalScope;
		const service_worker_mock_1 = __importDefault(require("service-worker-mock"));
		const HASH = "123HASHBROWN";
		const getEvent = (request) => {
		const waitUntil = async (maybePromise) => {
		await maybePromise;
		};
		return {
		request,
		waitUntil,
		};
		};
		exports.getEvent = getEvent;
		const store = {
		"key1.123HASHBROWN.txt": "val1",
		"key1.123HASHBROWN.png": "val1",
		"index.123HASHBROWN.html": "index.html",
		"cache.123HASHBROWN.html": "cache me if you can",
		"测试.123HASHBROWN.html": "My filename is non-ascii",
		"%not-really-percent-encoded.123HASHBROWN.html": "browser percent encoded",
		"%2F.123HASHBROWN.html": "user percent encoded",
		"你好.123HASHBROWN.html": "I shouldnt be served",
		"%E4%BD%A0%E5%A5%BD.123HASHBROWN.html": "Im important",
		"nohash.txt": "no hash but still got some result",
		"sub/blah.123HASHBROWN.png": "picturedis",
		"sub/index.123HASHBROWN.html": "picturedis",
		"client.123HASHBROWN": "important file",
		"client.123HASHBROWN/index.html": "Im here but serve my big bro above",
		"image.123HASHBROWN.png": "imagepng",
		"image.123HASHBROWN.webp": "imagewebp",
		"你好/index.123HASHBROWN.html": "My path is non-ascii",
		};
		const mockKV = (kvStore) => {
		return {
		get: (path) => kvStore[path] \|\| null,
		};
		};
		exports.mockKV = mockKV;
		const mockManifest = () => {
		return JSON.stringify({
		"key1.txt": `key1.${HASH}.txt`,
		"key1.png": `key1.${HASH}.png`,
		"cache.html": `cache.${HASH}.html`,
		"测试.html": `测试.${HASH}.html`,
		"你好.html": `你好.${HASH}.html`,
		"%not-really-percent-encoded.html": `%not-really-percent-encoded.${HASH}.html`,
		"%2F.html": `%2F.${HASH}.html`,
		"%E4%BD%A0%E5%A5%BD.html": `%E4%BD%A0%E5%A5%BD.${HASH}.html`,
		"index.html": `index.${HASH}.html`,
		"sub/blah.png": `sub/blah.${HASH}.png`,
		"sub/index.html": `sub/index.${HASH}.html`,
		client: `client.${HASH}`,
		"client/index.html": `client.${HASH}`,
		"image.png": `image.${HASH}.png`,
		"image.webp": `image.${HASH}.webp`,
		"你好/index.html": `你好/index.${HASH}.html`,
		});
		};
		exports.mockManifest = mockManifest;
		const cacheStore = new Map();
		const mockCaches = () => {
		return {
		default: {
		async match(key) {
		const cacheKey = {
		url: key.url,
		headers: {},
		};
		let response;
		if (key.headers.has("if-none-match")) {
		const makeStrongEtag = key.headers
		.get("if-none-match")
		.replace("W/", "");
		Reflect.set(cacheKey.headers, "etag", makeStrongEtag);
		response = cacheStore.get(JSON.stringify(cacheKey));
		}
		else {
		// if client doesn't send if-none-match, we need to iterate through these keys
		// and just test the URL
		const activeCacheKeys = Array.from(cacheStore.keys());
		for (const cacheStoreKey of activeCacheKeys) {
		if (JSON.parse(cacheStoreKey).url === key.url) {
		response = cacheStore.get(cacheStoreKey);
		}
		}
		}
		// TODO: write test to accomodate for rare scenarios with where range requests accomodate etags
		if (response && !key.headers.has("if-none-match")) {
		// this appears overly verbose, but is necessary to document edge cache behavior
		// The Range request header triggers the response header Content-Range ...
		const range = key.headers.get("range");
		if (range) {
		response.headers.set("content-range", `bytes ${range.split("=").pop()}/${response.headers.get("content-length")}`);
		}
		// ... which we are using in this repository to set status 206
		if (response.headers.has("content-range")) {
		// @ts-expect-error overridding status in this mock
		response.status = 206;
		}
		else {
		// @ts-expect-error overridding status in this mock
		response.status = 200;
		}
		const etag = response.headers.get("etag");
		if (etag && !etag.includes("W/")) {
		response.headers.set("etag", `W/${etag}`);
		}
		}
		return response;
		},
		async put(key, val) {
		const headers = new Headers(val.headers);
		const url = new URL(key.url);
		const resWithBody = new Response(val.body, { headers, status: 200 });
		const resNoBody = new Response(null, { headers, status: 304 });
		const cacheKey = {
		url: key.url,
		headers: {
		etag: `"${url.pathname.replace("/", "")}"`,
		},
		};
		cacheStore.set(JSON.stringify(cacheKey), resNoBody);
		cacheKey.headers = {};
		cacheStore.set(JSON.stringify(cacheKey), resWithBody);
		return;
		},
		},
		};
		};
		exports.mockCaches = mockCaches;
		// mocks functionality used inside worker request
		function mockRequestScope() {
		Object.assign(globalThis, (0, service_worker_mock_1.default)());
		Object.assign(globalThis, { __STATIC_CONTENT_MANIFEST: (0, exports.mockManifest)() });
		Object.assign(globalThis, { __STATIC_CONTENT: (0, exports.mockKV)(store) });
		Object.assign(globalThis, { caches: (0, exports.mockCaches)() });
		}
		// mocks functionality used on global isolate scope. such as the KV namespace bind
		function mockGlobalScope() {
		Object.assign(globalThis, { __STATIC_CONTENT_MANIFEST: (0, exports.mockManifest)() });
		Object.assign(globalThis, { __STATIC_CONTENT: (0, exports.mockKV)(store) });
		}
		const sleep = (milliseconds) => {
		return new Promise((resolve) => setTimeout(resolve, milliseconds));
		};
		exports.sleep = sleep;

-29

dist/types.d.ts

		export type CacheControl = {
		browserTTL: number;
		edgeTTL: number;
		bypassCache: boolean;
		};
		export type AssetManifestType = Record<string, string>;
		export type Options = {
		cacheControl: ((req: Request) => Partial<CacheControl>) \| Partial<CacheControl>;
		ASSET_NAMESPACE: KVNamespace;
		ASSET_MANIFEST: AssetManifestType \| string;
		mapRequestToAsset?: (req: Request, options?: Partial<Options>) => Request;
		defaultMimeType: string;
		defaultDocument: string;
		pathIsEncoded: boolean;
		defaultETag: "strong" \| "weak";
		};
		export declare class KVError extends Error {
		constructor(message?: string, status?: number);
		status: number;
		}
		export declare class MethodNotAllowedError extends KVError {
		constructor(message?: string, status?: number);
		}
		export declare class NotFoundError extends KVError {
		constructor(message?: string, status?: number);
		}
		export declare class InternalError extends KVError {
		constructor(message?: string, status?: number);
		}

-32

dist/types.js

		"use strict";
		Object.defineProperty(exports, "__esModule", { value: true });
		exports.InternalError = exports.NotFoundError = exports.MethodNotAllowedError = exports.KVError = void 0;
		class KVError extends Error {
		constructor(message, status = 500) {
		super(message);
		// see: typescriptlang.org/docs/handbook/release-notes/typescript-2-2.html
		Object.setPrototypeOf(this, new.target.prototype); // restore prototype chain
		this.name = KVError.name; // stack traces display correctly now
		this.status = status;
		}
		status;
		}
		exports.KVError = KVError;
		class MethodNotAllowedError extends KVError {
		constructor(message = `Not a valid request method`, status = 405) {
		super(message, status);
		}
		}
		exports.MethodNotAllowedError = MethodNotAllowedError;
		class NotFoundError extends KVError {
		constructor(message = `Not Found`, status = 404) {
		super(message, status);
		}
		}
		exports.NotFoundError = NotFoundError;
		class InternalError extends KVError {
		constructor(message = `Internal Error in KV Asset Handler`, status = 500) {
		super(message, status);
		}
		}
		exports.InternalError = InternalError;

-156

src/mocks.ts

		import makeServiceWorkerEnv from "service-worker-mock";

		const HASH = "123HASHBROWN";

		export const getEvent = (
		request: Request
		): Pick<FetchEvent, "request" \| "waitUntil"> => {
		const waitUntil = async (maybePromise: unknown) => {
		await maybePromise;
		};
		return {
		request,
		waitUntil,
		};
		};
		const store = {
		"key1.123HASHBROWN.txt": "val1",
		"key1.123HASHBROWN.png": "val1",
		"index.123HASHBROWN.html": "index.html",
		"cache.123HASHBROWN.html": "cache me if you can",
		"测试.123HASHBROWN.html": "My filename is non-ascii",
		"%not-really-percent-encoded.123HASHBROWN.html": "browser percent encoded",
		"%2F.123HASHBROWN.html": "user percent encoded",
		"你好.123HASHBROWN.html": "I shouldnt be served",
		"%E4%BD%A0%E5%A5%BD.123HASHBROWN.html": "Im important",
		"nohash.txt": "no hash but still got some result",
		"sub/blah.123HASHBROWN.png": "picturedis",
		"sub/index.123HASHBROWN.html": "picturedis",
		"client.123HASHBROWN": "important file",
		"client.123HASHBROWN/index.html": "Im here but serve my big bro above",
		"image.123HASHBROWN.png": "imagepng",
		"image.123HASHBROWN.webp": "imagewebp",
		"你好/index.123HASHBROWN.html": "My path is non-ascii",
		};
		export const mockKV = (kvStore: Record<string, string>) => {
		return {
		get: (path: string) => kvStore[path] \|\| null,
		};
		};

		export const mockManifest = () => {
		return JSON.stringify({
		"key1.txt": `key1.${HASH}.txt`,
		"key1.png": `key1.${HASH}.png`,
		"cache.html": `cache.${HASH}.html`,
		"测试.html": `测试.${HASH}.html`,
		"你好.html": `你好.${HASH}.html`,
		"%not-really-percent-encoded.html": `%not-really-percent-encoded.${HASH}.html`,
		"%2F.html": `%2F.${HASH}.html`,
		"%E4%BD%A0%E5%A5%BD.html": `%E4%BD%A0%E5%A5%BD.${HASH}.html`,
		"index.html": `index.${HASH}.html`,
		"sub/blah.png": `sub/blah.${HASH}.png`,
		"sub/index.html": `sub/index.${HASH}.html`,
		client: `client.${HASH}`,
		"client/index.html": `client.${HASH}`,
		"image.png": `image.${HASH}.png`,
		"image.webp": `image.${HASH}.webp`,
		"你好/index.html": `你好/index.${HASH}.html`,
		});
		};

		const cacheStore = new Map<string, Response>();
		interface CacheKey {
		url: string;
		headers: HeadersInit;
		}
		export const mockCaches = () => {
		return {
		default: {
		async match(key: Request) {
		const cacheKey: CacheKey = {
		url: key.url,
		headers: {},
		};
		let response;
		if (key.headers.has("if-none-match")) {
		const makeStrongEtag = key.headers
		.get("if-none-match")
		.replace("W/", "");
		Reflect.set(cacheKey.headers, "etag", makeStrongEtag);
		response = cacheStore.get(JSON.stringify(cacheKey));
		} else {
		// if client doesn't send if-none-match, we need to iterate through these keys
		// and just test the URL
		const activeCacheKeys: Array<string> = Array.from(cacheStore.keys());
		for (const cacheStoreKey of activeCacheKeys) {
		if (JSON.parse(cacheStoreKey).url === key.url) {
		response = cacheStore.get(cacheStoreKey);
		}
		}
		}
		// TODO: write test to accomodate for rare scenarios with where range requests accomodate etags
		if (response && !key.headers.has("if-none-match")) {
		// this appears overly verbose, but is necessary to document edge cache behavior
		// The Range request header triggers the response header Content-Range ...
		const range = key.headers.get("range");
		if (range) {
		response.headers.set(
		"content-range",
		`bytes ${range.split("=").pop()}/${response.headers.get(
		"content-length"
		)}`
		);
		}
		// ... which we are using in this repository to set status 206
		if (response.headers.has("content-range")) {
		// @ts-expect-error overridding status in this mock
		response.status = 206;
		} else {
		// @ts-expect-error overridding status in this mock
		response.status = 200;
		}
		const etag = response.headers.get("etag");
		if (etag && !etag.includes("W/")) {
		response.headers.set("etag", `W/${etag}`);
		}
		}
		return response;
		},
		async put(key: Request, val: Response) {
		const headers = new Headers(val.headers);
		const url = new URL(key.url);
		const resWithBody = new Response(val.body, { headers, status: 200 });
		const resNoBody = new Response(null, { headers, status: 304 });
		const cacheKey: CacheKey = {
		url: key.url,
		headers: {
		etag: `"${url.pathname.replace("/", "")}"`,
		},
		};
		cacheStore.set(JSON.stringify(cacheKey), resNoBody);
		cacheKey.headers = {};
		cacheStore.set(JSON.stringify(cacheKey), resWithBody);
		return;
		},
		},
		};
		};

		// mocks functionality used inside worker request
		export function mockRequestScope() {
		Object.assign(globalThis, makeServiceWorkerEnv());
		Object.assign(globalThis, { __STATIC_CONTENT_MANIFEST: mockManifest() });
		Object.assign(globalThis, { __STATIC_CONTENT: mockKV(store) });
		Object.assign(globalThis, { caches: mockCaches() });
		}

		// mocks functionality used on global isolate scope. such as the KV namespace bind
		export function mockGlobalScope() {
		Object.assign(globalThis, { __STATIC_CONTENT_MANIFEST: mockManifest() });
		Object.assign(globalThis, { __STATIC_CONTENT: mockKV(store) });
		}

		export const sleep = (milliseconds: number) => {
		return new Promise((resolve) => setTimeout(resolve, milliseconds));
		};

@cloudflare/kv-asset-handler - npm Package Compare versions

New alerts

Fixed alerts

Improved metrics

Worsened metrics