@eggjs/koa-static-cache 6.1.0 → 7.0.0-beta.13

package/README.md

@@ -1,8 +1,6 @@
-# Koa Static Cache
+# eggjs/koa-static-cache
 
 [![NPM version][npm-image]][npm-url]
-[![Node.js CI](https://github.com/eggjs/koa-static-cache/actions/workflows/nodejs.yml/badge.svg)](https://github.com/eggjs/koa-static-cache/actions/workflows/nodejs.yml)
-[![Test coverage][codecov-image]][codecov-url]
 [![Known Vulnerabilities][snyk-image]][snyk-url]
 [![npm download][download-image]][download-url]
 [![Node.js Version](https://img.shields.io/node/v/@eggjs/koa-static-cache.svg?style=flat)](https://nodejs.org/en/download/)
@@ -10,8 +8,6 @@
 
 [npm-image]: https://img.shields.io/npm/v/@eggjs/koa-static-cache.svg?style=flat-square
 [npm-url]: https://npmjs.org/package/@eggjs/koa-static-cache
-[codecov-image]: https://img.shields.io/codecov/c/github/eggjs/koa-static-cache.svg?style=flat-square
-[codecov-url]: https://codecov.io/github/eggjs/koa-static-cache?branch=master
 [snyk-image]: https://snyk.io/test/npm/@eggjs/koa-static-cache/badge.svg?style=flat-square
 [snyk-url]: https://snyk.io/test/npm/@eggjs/koa-static-cache
 [download-image]: https://img.shields.io/npm/dm/@eggjs/koa-static-cache.svg?style=flat-square
@@ -43,9 +39,11 @@ npm install @eggjs/koa-static-cache
 const path = require('path');
 const { staticCache } = require('@eggjs/koa-static-cache');
 
-app.use(staticCache(path.join(__dirname, 'public'), {
-  maxAge: 365 * 24 * 60 * 60
-}));
+app.use(
+  staticCache(path.join(__dirname, 'public'), {
+    maxAge: 365 * 24 * 60 * 60,
+  })
+);
 ```
 
 - `options.dir` (str) - the directory you wish to serve, default to `process.cwd`.
@@ -68,9 +66,9 @@ For example, if you have this `alias` object:
 ```js
 const options = {
   alias: {
-    '/favicon.png': '/favicon-32.png'
-  }
-}
+    '/favicon.png': '/favicon-32.png',
+  },
+};
 ```
 
 Then requests to `/favicon.png` will actually return `/favicon-32.png` without redirects or anything.
@@ -86,8 +84,8 @@ This allows you to do two things:
 Instead of doing:
 
 ```js
-app.use(staticCache('/public/js'))
-app.use(staticCache('/public/css'))
+app.use(staticCache('/public/js'));
+app.use(staticCache('/public/css'));
 ```
 
 You can do this:
@@ -111,9 +109,15 @@ For example, if you want to change the max age of `/package.json`, you can do th
 ```js
 const files = {};
 
-app.use(staticCache('/public', {
-  maxAge: 60 * 60 * 24 * 365
-}, files));
+app.use(
+  staticCache(
+    '/public',
+    {
+      maxAge: 60 * 60 * 24 * 365,
+    },
+    files
+  )
+);
 
 files['/package.json'].maxAge = 60 * 60 * 24 * 30;
 ```
@@ -126,11 +130,13 @@ You can pass in a lru cache instance which has tow methods: `get(key)` and `set(
 const LRU = require('lru-cache');
 const files = new LRU({ max: 1000 });
 
-app.use(staticCache({
-  dir: '/public',
-  dynamic: true,
-  files,
-}));
+app.use(
+  staticCache({
+    dir: '/public',
+    dynamic: true,
+    files,
+  })
+);
 ```
 
 ## License
@@ -139,6 +145,6 @@ app.use(staticCache({
 
 ## Contributors
 
-[![Contributors](https://contrib.rocks/image?repo=eggjs/koa-static-cache)](https://github.com/eggjs/koa-static-cache/graphs/contributors)
+[![Contributors](https://contrib.rocks/image?repo=eggjs/egg)](https://github.com/eggjs/egg/graphs/contributors)
 
 Made with [contributors-img](https://contrib.rocks).

package/dist/index.d.ts

@@ -0,0 +1,101 @@
+//#region src/index.d.ts
+type FileFilter = (path: string) => boolean;
+interface FileMeta {
+  maxAge?: number;
+  cacheControl?: string | ((path: string) => string);
+  buffer?: Buffer;
+  zipBuffer?: Buffer;
+  type?: string;
+  mime?: string;
+  mtime?: Date;
+  path?: string;
+  md5?: string;
+  length?: number;
+}
+interface FileMap {
+  [path: string]: FileMeta;
+}
+interface FileStore {
+  get(key: string): unknown;
+  set(key: string, value: unknown): void;
+}
+interface Options {
+  /**
+   * The root directory from which to serve static assets
+   * Default to `process.cwd`
+   */
+  dir?: string;
+  /**
+   * The max age for cache control
+   * Default to `0`
+   */
+  maxAge?: number;
+  /**
+   * The cache control header for static files
+   * Default to `undefined`
+   * Overrides `options.maxAge`
+   */
+  cacheControl?: string | ((path: string) => string);
+  /**
+   * store the files in memory instead of streaming from the filesystem on each request
+   */
+  buffer?: boolean;
+  /**
+   * when request's accept-encoding include gzip, files will compressed by gzip
+   * Default to `false`
+   */
+  gzip?: boolean;
+  /**
+   * try use gzip files, loaded from disk, like nginx gzip_static
+   * Default to `false`
+   */
+  usePrecompiledGzip?: boolean;
+  /**
+   * object map of aliases
+   * Default to `{}`
+   */
+  alias?: Record<string, string>;
+  /**
+   * the url prefix you wish to add
+   * Default to `''`
+   */
+  prefix?: string;
+  /**
+   * filter files at init dir, for example - skip non build (source) files.
+   * If array set - allow only listed files
+   * Default to `undefined`
+   */
+  filter?: FileFilter | string[];
+  /**
+   * dynamic load file which not cached on initialization
+   * Default to `false
+   */
+  dynamic?: boolean;
+  /**
+   * caches the assets on initialization or not,
+   * always work together with `options.dynamic`
+   * Default to `true`
+   */
+  preload?: boolean;
+  /**
+   * file store for caching
+   * Default to `undefined`
+   */
+  files?: FileMap | FileStore;
+}
+type Next = () => Promise<void>;
+declare class FileManager {
+  store?: FileStore;
+  map?: FileMap;
+  constructor(store?: FileStore | FileMap);
+  get(key: string): unknown;
+  set(key: string, value: FileMeta): void;
+}
+type MiddlewareFunc = (ctx: any, next: Next) => Promise<void> | void;
+declare function staticCache(): MiddlewareFunc;
+declare function staticCache(dir: string): MiddlewareFunc;
+declare function staticCache(options: Options): MiddlewareFunc;
+declare function staticCache(dir: string, options: Options): MiddlewareFunc;
+declare function staticCache(dir: string, options: Options, files: FileMap | FileStore): MiddlewareFunc;
+//#endregion
+export { FileFilter, FileManager, FileMap, FileMeta, FileStore, Options, staticCache };

package/dist/index.js

@@ -0,0 +1,158 @@
+import crypto from "node:crypto";
+import { debuglog, promisify } from "node:util";
+import fs from "node:fs/promises";
+import { createReadStream, readFileSync, statSync } from "node:fs";
+import zlib from "node:zlib";
+import path from "node:path";
+import mime from "mime-types";
+import { compressible } from "@eggjs/compressible";
+import readDir from "fs-readdir-recursive";
+import { decodeURIComponent, exists } from "utility";
+
+//#region src/index.ts
+const debug = debuglog("egg/koa-static-cache");
+const gzip = promisify(zlib.gzip);
+var FileManager = class {
+	store;
+	map;
+	constructor(store) {
+		if (store && typeof store.set === "function" && typeof store.get === "function") this.store = store;
+		else this.map = store || Object.create(null);
+	}
+	get(key) {
+		return this.store ? this.store.get(key) : this.map[key];
+	}
+	set(key, value) {
+		if (this.store) return this.store.set(key, value);
+		this.map[key] = value;
+	}
+};
+function staticCache(dirOrOptions, options = {}, filesStoreOrMap) {
+	let dir = "";
+	if (typeof dirOrOptions === "string") dir = dirOrOptions;
+	else if (dirOrOptions) options = dirOrOptions;
+	if (!dir && options.dir) dir = options.dir;
+	if (!dir) dir = process.cwd();
+	dir = path.normalize(dir);
+	debug("staticCache dir: %s", dir);
+	options.prefix = (options.prefix ?? "").replace(/\/*$/, "/");
+	const files = new FileManager(filesStoreOrMap ?? options.files);
+	const enableGzip = !!options.gzip;
+	const filePrefix = path.normalize(options.prefix.replace(/^\//, ""));
+	let fileFilter = () => {
+		return true;
+	};
+	if (Array.isArray(options.filter)) fileFilter = (file) => {
+		return options.filter.includes(file);
+	};
+	if (typeof options.filter === "function") fileFilter = options.filter;
+	if (options.preload !== false) {
+		debug("preload: %s", dir);
+		readDir(dir, (filename) => {
+			return !filename.startsWith(".") && filename !== "node_modules";
+		}).filter(fileFilter).forEach((name) => {
+			loadFile(name, dir, options, files);
+		});
+		debug("preload end");
+	}
+	debug("prepare middleware");
+	return async (ctx, next) => {
+		if (ctx.method !== "HEAD" && ctx.method !== "GET") return await next();
+		if (!ctx.path.startsWith(options.prefix)) return await next();
+		let filename = path.normalize(decodeURIComponent(ctx.path));
+		if (options.alias && options.alias[filename]) filename = options.alias[filename];
+		let file = files.get(filename);
+		if (!file) {
+			if (!options.dynamic) return await next();
+			if (path.basename(filename)[0] === ".") return await next();
+			if (filename.charAt(0) === path.sep) filename = filename.slice(1);
+			if (options.prefix !== "/") {
+				if (filename.indexOf(filePrefix) !== 0) return await next();
+				filename = filename.slice(filePrefix.length);
+			}
+			const fullpath = path.join(dir, filename);
+			if (!fullpath.startsWith(dir)) return await next();
+			const stats = await exists(fullpath);
+			if (!stats) return await next();
+			if (!stats.isFile()) return await next();
+			file = loadFile(filename, dir, options, files);
+		}
+		ctx.status = 200;
+		if (enableGzip) ctx.vary("Accept-Encoding");
+		if (!file.buffer) {
+			const stats = await fs.stat(file.path);
+			if (stats.mtime.getTime() !== file.mtime.getTime()) {
+				file.mtime = stats.mtime;
+				file.md5 = void 0;
+				file.length = stats.size;
+			}
+		}
+		ctx.response.lastModified = file.mtime;
+		if (file.md5) ctx.response.etag = file.md5;
+		if (ctx.fresh) {
+			ctx.status = 304;
+			return;
+		}
+		ctx.type = file.type;
+		ctx.length = file.zipBuffer ? file.zipBuffer.length : file.length;
+		ctx.set("cache-control", file.cacheControl ?? "public, max-age=" + file.maxAge);
+		if (file.md5) ctx.set("content-md5", file.md5);
+		if (ctx.method === "HEAD") return;
+		const acceptGzip = ctx.acceptsEncodings("gzip") === "gzip";
+		if (file.zipBuffer) {
+			if (acceptGzip) {
+				ctx.set("content-encoding", "gzip");
+				ctx.body = file.zipBuffer;
+			} else ctx.body = file.buffer;
+			return;
+		}
+		const shouldGzip = enableGzip && file.length > 1024 && acceptGzip && file.type && compressible(file.type);
+		if (file.buffer) {
+			if (shouldGzip) {
+				const gzFile = files.get(filename + ".gz");
+				if (options.usePrecompiledGzip && gzFile && gzFile.buffer) file.zipBuffer = gzFile.buffer;
+				else file.zipBuffer = await gzip(file.buffer);
+				ctx.set("content-encoding", "gzip");
+				ctx.body = file.zipBuffer;
+			} else ctx.body = file.buffer;
+			return;
+		}
+		const stream = createReadStream(file.path);
+		if (!file.md5) {
+			const hash = crypto.createHash("md5");
+			stream.on("data", hash.update.bind(hash));
+			stream.on("end", () => {
+				file.md5 = hash.digest("base64");
+			});
+		}
+		ctx.body = stream;
+		if (shouldGzip) {
+			ctx.remove("content-length");
+			ctx.set("content-encoding", "gzip");
+			ctx.body = stream.pipe(zlib.createGzip());
+		}
+	};
+}
+/**
+* load file and add file content to cache
+*/
+function loadFile(name, dir, options, fileManager) {
+	const pathname = path.normalize(path.join(options.prefix, name));
+	if (!fileManager.get(pathname)) fileManager.set(pathname, {});
+	const obj = fileManager.get(pathname);
+	const filename = obj.path = path.join(dir, name);
+	const stats = statSync(filename);
+	const buffer = readFileSync(filename);
+	obj.cacheControl = typeof options.cacheControl === "function" ? options.cacheControl(filename) : options.cacheControl;
+	obj.maxAge = (typeof obj.maxAge === "number" ? obj.maxAge : options.maxAge) || 0;
+	obj.type = obj.mime = mime.lookup(pathname) || "application/octet-stream";
+	obj.mtime = stats.mtime;
+	obj.length = stats.size;
+	obj.md5 = crypto.createHash("md5").update(buffer).digest("base64");
+	debug("file: %s", JSON.stringify(obj, null, 2));
+	if (options.buffer) obj.buffer = buffer;
+	return obj;
+}
+
+//#endregion
+export { FileManager, staticCache };

package/package.json

@@ -1,10 +1,7 @@
 {
   "name": "@eggjs/koa-static-cache",
   "description": "Static cache middleware for koa",
-  "version": "6.1.0",
-  "publishConfig": {
-    "access": "public"
-  },
+  "version": "7.0.0-beta.13",
   "keywords": [
     "koa",
     "middleware",
@@ -17,73 +14,58 @@
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/eggjs/koa-static-cache.git"
+    "url": "git://github.com/eggjs/egg.git",
+    "directory": "packages/koa-static-cache"
   },
   "bugs": {
-    "url": "https://github.com/eggjs/koa-static-cache/issues"
+    "url": "https://github.com/eggjs/egg/issues"
   },
+  "homepage": "https://github.com/eggjs/egg/tree/next/packages/koa-static-cache",
   "engines": {
-    "node": ">= 18.19.0"
+    "node": ">=22.18.0"
   },
   "dependencies": {
     "@eggjs/compressible": "^3.0.0",
     "fs-readdir-recursive": "^1.1.0",
-    "mime-types": "^2.1.35",
-    "utility": "^2.4.0"
+    "mime-types": "^3.0.0",
+    "utility": "^2.5.0"
   },
   "devDependencies": {
-    "@arethetypeswrong/cli": "^0.17.4",
-    "@eggjs/bin": "7",
-    "@eggjs/koa": "2",
-    "@eggjs/supertest": "8",
-    "@eggjs/tsconfig": "1",
     "@types/fs-readdir-recursive": "^1.1.3",
-    "@types/mime-types": "^2.1.4",
-    "@types/mocha": "10",
-    "@types/node": "22",
-    "eslint": "8",
-    "eslint-config-egg": "14",
-    "rimraf": "6",
-    "tshy": "3",
-    "tshy-after": "1",
-    "typescript": "5",
-    "ylru": "2"
-  },
-  "scripts": {
-    "lint": "eslint --cache src test --ext .ts",
-    "pretest": "npm run clean && npm run lint -- --fix",
-    "test": "egg-bin test",
-    "preci": "npm run clean &&  npm run lint",
-    "ci": "egg-bin cov",
-    "postci": "npm run prepublishOnly && npm run clean",
-    "clean": "rimraf dist",
-    "prepublishOnly": "tshy && tshy-after && attw --pack"
+    "@types/mime-types": "^3.0.0",
+    "@types/node": "24.5.2",
+    "oxlint": "^1.18.0",
+    "oxlint-tsgolint": "^0.2.0",
+    "rimraf": "^6.0.1",
+    "tsdown": "^0.15.4",
+    "typescript": "5.9.2",
+    "vitest": "4.0.0-beta.13",
+    "ylru": "^2.0.0",
+    "@eggjs/bin": "8.0.0-beta.13",
+    "@eggjs/koa": "3.1.0-beta.13",
+    "@eggjs/supertest": "9.0.0-beta.13",
+    "@eggjs/tsconfig": "3.1.0-beta.13"
   },
   "type": "module",
-  "tshy": {
-    "exports": {
-      ".": "./src/index.ts",
-      "./package.json": "./package.json"
-    }
-  },
   "exports": {
-    ".": {
-      "import": {
-        "types": "./dist/esm/index.d.ts",
-        "default": "./dist/esm/index.js"
-      },
-      "require": {
-        "types": "./dist/commonjs/index.d.ts",
-        "default": "./dist/commonjs/index.js"
-      }
-    },
+    ".": "./dist/index.js",
     "./package.json": "./package.json"
   },
+  "publishConfig": {
+    "access": "public"
+  },
   "files": [
-    "dist",
-    "src"
+    "dist"
   ],
-  "types": "./dist/commonjs/index.d.ts",
-  "main": "./dist/commonjs/index.js",
-  "module": "./dist/esm/index.js"
-}
+  "types": "./dist/index.d.ts",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit",
+    "lint": "oxlint --type-aware",
+    "lint:fix": "npm run lint -- --fix",
+    "test": "npm run lint:fix && vitest run",
+    "ci": "vitest run --coverage"
+  }
+}

package/dist/commonjs/index.d.ts

@@ -1,99 +0,0 @@
-export type FileFilter = (path: string) => boolean;
-export interface FileMeta {
-    maxAge?: number;
-    cacheControl?: string;
-    buffer?: Buffer;
-    zipBuffer?: Buffer;
-    type?: string;
-    mime?: string;
-    mtime?: Date;
-    path?: string;
-    md5?: string;
-    length?: number;
-}
-export interface FileMap {
-    [path: string]: FileMeta;
-}
-export interface FileStore {
-    get(key: string): unknown;
-    set(key: string, value: unknown): void;
-}
-export interface Options {
-    /**
-     * The root directory from which to serve static assets
-     * Default to `process.cwd`
-     */
-    dir?: string;
-    /**
-     * The max age for cache control
-     * Default to `0`
-     */
-    maxAge?: number;
-    /**
-     * The cache control header for static files
-     * Default to `undefined`
-     * Overrides `options.maxAge`
-     */
-    cacheControl?: string;
-    /**
-     * store the files in memory instead of streaming from the filesystem on each request
-     */
-    buffer?: boolean;
-    /**
-     * when request's accept-encoding include gzip, files will compressed by gzip
-     * Default to `false`
-     */
-    gzip?: boolean;
-    /**
-     * try use gzip files, loaded from disk, like nginx gzip_static
-     * Default to `false`
-     */
-    usePrecompiledGzip?: boolean;
-    /**
-     * object map of aliases
-     * Default to `{}`
-     */
-    alias?: Record<string, string>;
-    /**
-     * the url prefix you wish to add
-     * Default to `''`
-     */
-    prefix?: string;
-    /**
-     * filter files at init dir, for example - skip non build (source) files.
-     * If array set - allow only listed files
-     * Default to `undefined`
-     */
-    filter?: FileFilter | string[];
-    /**
-     * dynamic load file which not cached on initialization
-     * Default to `false
-     */
-    dynamic?: boolean;
-    /**
-     * caches the assets on initialization or not,
-     * always work together with `options.dynamic`
-     * Default to `true`
-     */
-    preload?: boolean;
-    /**
-     * file store for caching
-     * Default to `undefined`
-     */
-    files?: FileMap | FileStore;
-}
-type Next = () => Promise<void>;
-export declare class FileManager {
-    store?: FileStore;
-    map?: FileMap;
-    constructor(store?: FileStore | FileMap);
-    get(key: string): unknown;
-    set(key: string, value: FileMeta): void;
-}
-type MiddlewareFunc = (ctx: any, next: Next) => Promise<void> | void;
-export declare function staticCache(): MiddlewareFunc;
-export declare function staticCache(dir: string): MiddlewareFunc;
-export declare function staticCache(options: Options): MiddlewareFunc;
-export declare function staticCache(dir: string, options: Options): MiddlewareFunc;
-export declare function staticCache(dir: string, options: Options, files: FileMap | FileStore): MiddlewareFunc;
-export {};