@eggjs/koa-static-cache 6.0.0

package/LICENSE

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2025 - present eggjs and the contributors.
+Copyright (c) 2013 Jonathan Ong me@jongleberry.com
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,144 @@
+# 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/)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://makeapullrequest.com)
+
+[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
+[download-url]: https://npmjs.org/package/@eggjs/koa-static-cache
+
+Static cache middleware for koa.
+
+Differences between this library and other libraries such as [static](https://github.com/koajs/static):
+
+- There is no directory or `index.html` support.
+- You may optionally store the data in memory - it streams by default.
+- Caches the assets on initialization - you need to restart the process to update the assets.(can turn off with options.preload = false)
+- Uses MD5 hash sum as an ETag.
+- Uses `.gz` files if present on disk, like nginx gzip_static module
+
+> Forked from https://github.com/koajs/static-cache, refactor with TypeScript to support CommonJS and ESM both.
+
+## Installation
+
+```bash
+npm install @eggjs/koa-static-cache
+```
+
+## API
+
+### staticCache([options])
+
+```js
+const path = require('path');
+const { staticCache } = require('@eggjs/koa-static-cache');
+
+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`.
+- `options.maxAge` (int) - cache control max age for the files, `0` by default.
+- `options.cacheControl` (str) - optional cache control header. Overrides `options.maxAge`.
+- `options.buffer` (bool) - store the files in memory instead of streaming from the filesystem on each request.
+- `options.gzip` (bool) - when request's accept-encoding include gzip, files will compressed by gzip.
+- `options.usePrecompiledGzip` (bool) - try use gzip files, loaded from disk, like nginx gzip_static
+- `options.alias` (obj) - object map of aliases. See below.
+- `options.prefix` (str) - the url prefix you wish to add, default to `''`.
+- `options.dynamic` (bool) - dynamic load file which not cached on initialization.
+- `options.filter` (function | array) - filter files at init dir, for example - skip non build (source) files. If array set - allow only listed files
+- `options.preload` (bool) - caches the assets on initialization or not, default to `true`. always work together with `options.dynamic`.
+- `options.files` (obj) - optional files object. See below.
+
+### Aliases
+
+For example, if you have this `alias` object:
+
+```js
+const options = {
+  alias: {
+    '/favicon.png': '/favicon-32.png'
+  }
+}
+```
+
+Then requests to `/favicon.png` will actually return `/favicon-32.png` without redirects or anything.
+This is particularly important when serving [favicons](https://github.com/audreyr/favicon-cheat-sheet) as you don't want to store duplicate images.
+
+### Files
+
+You can pass in an optional files object.
+This allows you to do two things:
+
+#### Combining directories into a single middleware
+
+Instead of doing:
+
+```js
+app.use(staticCache('/public/js'))
+app.use(staticCache('/public/css'))
+```
+
+You can do this:
+
+```js
+const files = {};
+
+// Mount the middleware
+app.use(staticCache('/public/js', {}, files));
+
+// Add additional files
+staticCache('/public/css', {}, files);
+```
+
+The benefit is that you'll have one less function added to the stack as well as doing one hash lookup instead of two.
+
+#### Editing the files object
+
+For example, if you want to change the max age of `/package.json`, you can do the following:
+
+```js
+const files = {};
+
+app.use(staticCache('/public', {
+  maxAge: 60 * 60 * 24 * 365
+}, files));
+
+files['/package.json'].maxAge = 60 * 60 * 24 * 30;
+```
+
+#### Using a LRU cache to avoid OOM when dynamic mode enabled
+
+You can pass in a lru cache instance which has tow methods: `get(key)` and `set(key, value)`.
+
+```js
+const LRU = require('lru-cache');
+const files = new LRU({ max: 1000 });
+
+app.use(staticCache({
+  dir: '/public',
+  dynamic: true,
+  files,
+}));
+```
+
+## License
+
+[MIT](LICENSE)
+
+## Contributors
+
+[![Contributors](https://contrib.rocks/image?repo=eggjs/koa-static-cache)](https://github.com/eggjs/koa-static-cache/graphs/contributors)
+
+Made with [contributors-img](https://contrib.rocks).

package/dist/commonjs/index.d.ts

@@ -0,0 +1,99 @@
+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 {};

package/dist/commonjs/index.js

@@ -0,0 +1,225 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FileManager = void 0;
+exports.staticCache = staticCache;
+const node_crypto_1 = __importDefault(require("node:crypto"));
+const node_util_1 = require("node:util");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_fs_1 = require("node:fs");
+const node_zlib_1 = __importDefault(require("node:zlib"));
+const node_path_1 = __importDefault(require("node:path"));
+const mime_types_1 = __importDefault(require("mime-types"));
+const compressible_1 = __importDefault(require("compressible"));
+const fs_readdir_recursive_1 = __importDefault(require("fs-readdir-recursive"));
+const utility_1 = require("utility");
+const debug = (0, node_util_1.debuglog)('@eggjs/koa-static-cache');
+const gzip = (0, node_util_1.promisify)(node_zlib_1.default.gzip);
+class FileManager {
+    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;
+    }
+}
+exports.FileManager = FileManager;
+function staticCache(dirOrOptions, options = {}, filesStoreOrMap) {
+    let dir = '';
+    if (typeof dirOrOptions === 'string') {
+        // dir priority than options.dir
+        dir = dirOrOptions;
+    }
+    else if (dirOrOptions) {
+        options = dirOrOptions;
+    }
+    if (!dir && options.dir) {
+        dir = options.dir;
+    }
+    if (!dir) {
+        // default to process.cwd
+        dir = process.cwd();
+    }
+    dir = node_path_1.default.normalize(dir);
+    debug('staticCache dir: %s', dir);
+    // prefix must be ASCII code
+    options.prefix = (options.prefix ?? '').replace(/\/*$/, '/');
+    const files = new FileManager(filesStoreOrMap ?? options.files);
+    const enableGzip = !!options.gzip;
+    const filePrefix = node_path_1.default.normalize(options.prefix.replace(/^\//, ''));
+    // option.filter
+    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) {
+        (0, fs_readdir_recursive_1.default)(dir).filter(fileFilter).forEach(name => {
+            loadFile(name, dir, options, files);
+        });
+    }
+    return async (ctx, next) => {
+        // only accept HEAD and GET
+        if (ctx.method !== 'HEAD' && ctx.method !== 'GET')
+            return await next();
+        // check prefix first to avoid calculate
+        if (!ctx.path.startsWith(options.prefix))
+            return await next();
+        // decode for `/%E4%B8%AD%E6%96%87`
+        // normalize for `//index`
+        let filename = node_path_1.default.normalize((0, utility_1.decodeURIComponent)(ctx.path));
+        // check alias
+        if (options.alias && options.alias[filename]) {
+            filename = options.alias[filename];
+        }
+        let file = files.get(filename);
+        // try to load file
+        if (!file) {
+            if (!options.dynamic)
+                return await next();
+            if (node_path_1.default.basename(filename)[0] === '.')
+                return await next();
+            if (filename.charAt(0) === node_path_1.default.sep) {
+                filename = filename.slice(1);
+            }
+            // trim prefix
+            if (options.prefix !== '/') {
+                if (filename.indexOf(filePrefix) !== 0) {
+                    return await next();
+                }
+                filename = filename.slice(filePrefix.length);
+            }
+            const fullpath = node_path_1.default.join(dir, filename);
+            // files that can be accessed should be under options.dir
+            if (!fullpath.startsWith(dir)) {
+                return await next();
+            }
+            const stats = await (0, utility_1.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 promises_1.default.stat(file.path);
+            if (stats.mtime.getTime() !== file.mtime.getTime()) {
+                file.mtime = stats.mtime;
+                file.md5 = undefined;
+                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
+            && (0, compressible_1.default)(file.type);
+        if (file.buffer) {
+            if (shouldGzip) {
+                const gzFile = files.get(filename + '.gz');
+                if (options.usePrecompiledGzip && gzFile && gzFile.buffer) {
+                    // if .gz file already read from disk
+                    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 = (0, node_fs_1.createReadStream)(file.path);
+        // update file hash
+        if (!file.md5) {
+            const hash = node_crypto_1.default.createHash('md5');
+            stream.on('data', hash.update.bind(hash));
+            stream.on('end', () => {
+                file.md5 = hash.digest('base64');
+            });
+        }
+        ctx.body = stream;
+        // enable gzip will remove content length
+        if (shouldGzip) {
+            ctx.remove('content-length');
+            ctx.set('content-encoding', 'gzip');
+            ctx.body = stream.pipe(node_zlib_1.default.createGzip());
+        }
+    };
+}
+/**
+ * load file and add file content to cache
+ */
+function loadFile(name, dir, options, fileManager) {
+    const pathname = node_path_1.default.normalize(node_path_1.default.join(options.prefix, name));
+    if (!fileManager.get(pathname)) {
+        fileManager.set(pathname, {});
+    }
+    const obj = fileManager.get(pathname);
+    const filename = obj.path = node_path_1.default.join(dir, name);
+    const stats = (0, node_fs_1.statSync)(filename);
+    const buffer = (0, node_fs_1.readFileSync)(filename);
+    obj.cacheControl = options.cacheControl;
+    obj.maxAge = obj.maxAge ? obj.maxAge : options.maxAge || 0;
+    obj.type = obj.mime = mime_types_1.default.lookup(pathname) || 'application/octet-stream';
+    obj.mtime = stats.mtime;
+    obj.length = stats.size;
+    obj.md5 = node_crypto_1.default.createHash('md5').update(buffer).digest('base64');
+    debug('file: %s', JSON.stringify(obj, null, 2));
+    if (options.buffer) {
+        obj.buffer = buffer;
+    }
+    return obj;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/commonjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}

package/dist/esm/index.d.ts

@@ -0,0 +1,99 @@
+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 {};

package/dist/esm/index.js

@@ -0,0 +1,217 @@
+import crypto from 'node:crypto';
+import { debuglog, promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import { createReadStream, statSync, readFileSync } from 'node:fs';
+import zlib from 'node:zlib';
+import path from 'node:path';
+import mime from 'mime-types';
+import compressible from 'compressible';
+import readDir from 'fs-readdir-recursive';
+import { exists, decodeURIComponent as safeDecodeURIComponent } from 'utility';
+const debug = debuglog('@eggjs/koa-static-cache');
+const gzip = promisify(zlib.gzip);
+export class FileManager {
+    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;
+    }
+}
+export function staticCache(dirOrOptions, options = {}, filesStoreOrMap) {
+    let dir = '';
+    if (typeof dirOrOptions === 'string') {
+        // dir priority than options.dir
+        dir = dirOrOptions;
+    }
+    else if (dirOrOptions) {
+        options = dirOrOptions;
+    }
+    if (!dir && options.dir) {
+        dir = options.dir;
+    }
+    if (!dir) {
+        // default to process.cwd
+        dir = process.cwd();
+    }
+    dir = path.normalize(dir);
+    debug('staticCache dir: %s', dir);
+    // prefix must be ASCII code
+    options.prefix = (options.prefix ?? '').replace(/\/*$/, '/');
+    const files = new FileManager(filesStoreOrMap ?? options.files);
+    const enableGzip = !!options.gzip;
+    const filePrefix = path.normalize(options.prefix.replace(/^\//, ''));
+    // option.filter
+    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) {
+        readDir(dir).filter(fileFilter).forEach(name => {
+            loadFile(name, dir, options, files);
+        });
+    }
+    return async (ctx, next) => {
+        // only accept HEAD and GET
+        if (ctx.method !== 'HEAD' && ctx.method !== 'GET')
+            return await next();
+        // check prefix first to avoid calculate
+        if (!ctx.path.startsWith(options.prefix))
+            return await next();
+        // decode for `/%E4%B8%AD%E6%96%87`
+        // normalize for `//index`
+        let filename = path.normalize(safeDecodeURIComponent(ctx.path));
+        // check alias
+        if (options.alias && options.alias[filename]) {
+            filename = options.alias[filename];
+        }
+        let file = files.get(filename);
+        // try to load file
+        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);
+            }
+            // trim prefix
+            if (options.prefix !== '/') {
+                if (filename.indexOf(filePrefix) !== 0) {
+                    return await next();
+                }
+                filename = filename.slice(filePrefix.length);
+            }
+            const fullpath = path.join(dir, filename);
+            // files that can be accessed should be under options.dir
+            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 = undefined;
+                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
+            && compressible(file.type);
+        if (file.buffer) {
+            if (shouldGzip) {
+                const gzFile = files.get(filename + '.gz');
+                if (options.usePrecompiledGzip && gzFile && gzFile.buffer) {
+                    // if .gz file already read from disk
+                    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);
+        // update file hash
+        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;
+        // enable gzip will remove content length
+        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 = options.cacheControl;
+    obj.maxAge = obj.maxAge ? 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;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"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"}

package/dist/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/dist/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "@eggjs/koa-static-cache",
+  "version": "6.0.0"
+}

package/package.json

@@ -0,0 +1,90 @@
+{
+  "name": "@eggjs/koa-static-cache",
+  "description": "Static cache middleware for koa",
+  "version": "6.0.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "koa",
+    "middleware",
+    "file",
+    "static",
+    "cache",
+    "gzip",
+    "sendfile"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/eggjs/koa-static-cache.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eggjs/koa-static-cache/issues"
+  },
+  "engines": {
+    "node": ">= 18.19.0"
+  },
+  "dependencies": {
+    "compressible": "^2.0.18",
+    "fs-readdir-recursive": "^1.1.0",
+    "mime-types": "^2.1.35",
+    "utility": "^2.4.0"
+  },
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.17.1",
+    "@eggjs/bin": "7",
+    "@eggjs/koa": "^2.20.6",
+    "@eggjs/supertest": "^8.1.1",
+    "@eggjs/tsconfig": "1",
+    "@types/compressible": "^2.0.2",
+    "@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.0.0"
+  },
+  "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"
+  },
+  "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"
+      }
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "dist",
+    "src"
+  ],
+  "types": "./dist/commonjs/index.d.ts",
+  "main": "./dist/commonjs/index.js",
+  "module": "./dist/esm/index.js"
+}

package/src/index.ts

@@ -0,0 +1,341 @@
+import crypto from 'node:crypto';
+import { debuglog, promisify } from 'node:util';
+import fs from 'node:fs/promises';
+import { createReadStream, statSync, readFileSync } from 'node:fs';
+import zlib from 'node:zlib';
+import path from 'node:path';
+import mime from 'mime-types';
+import compressible from 'compressible';
+import readDir from 'fs-readdir-recursive';
+import { exists, decodeURIComponent as safeDecodeURIComponent } from 'utility';
+
+const debug = debuglog('@eggjs/koa-static-cache');
+
+const gzip = promisify(zlib.gzip);
+
+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 class FileManager {
+  store?: FileStore;
+  map?: FileMap;
+
+  constructor(store?: FileStore | FileMap) {
+    if (store && typeof store.set === 'function' && typeof store.get === 'function') {
+      this.store = store as FileStore;
+    } else {
+      this.map = store || Object.create(null);
+    }
+  }
+
+  get(key: string) {
+    return this.store ? this.store.get(key) : this.map![key];
+  }
+
+  set(key: string, value: FileMeta) {
+    if (this.store) {
+      return this.store.set(key, value);
+    }
+    this.map![key] = value;
+  }
+}
+
+type MiddlewareFunc = (ctx: any, next: Next) => Promise<void> | void;
+
+export function staticCache(): MiddlewareFunc;
+export function staticCache(dir: string): MiddlewareFunc;
+export function staticCache(options: Options): MiddlewareFunc;
+export function staticCache(dir: string, options: Options): MiddlewareFunc;
+export function staticCache(dir: string, options: Options, files: FileMap | FileStore): MiddlewareFunc;
+export function staticCache(
+  dirOrOptions?: string | Options,
+  options: Options = {},
+  filesStoreOrMap?: FileMap | FileStore,
+): MiddlewareFunc {
+  let dir = '';
+  if (typeof dirOrOptions === 'string') {
+    // dir priority than options.dir
+    dir = dirOrOptions;
+  } else if (dirOrOptions) {
+    options = dirOrOptions;
+  }
+  if (!dir && options.dir) {
+    dir = options.dir;
+  }
+  if (!dir) {
+    // default to process.cwd
+    dir = process.cwd();
+  }
+  dir = path.normalize(dir);
+  debug('staticCache dir: %s', dir);
+
+  // prefix must be ASCII code
+  options.prefix = (options.prefix ?? '').replace(/\/*$/, '/');
+  const files = new FileManager(filesStoreOrMap ?? options.files);
+  const enableGzip = !!options.gzip;
+  const filePrefix = path.normalize(options.prefix.replace(/^\//, ''));
+
+  // option.filter
+  let fileFilter: FileFilter = () => { return true; };
+  if (Array.isArray(options.filter)) {
+    fileFilter = (file: string) => {
+      return (options.filter as string[]).includes(file);
+    };
+  }
+  if (typeof options.filter === 'function') {
+    fileFilter = options.filter;
+  }
+
+  if (options.preload !== false) {
+    readDir(dir).filter(fileFilter).forEach(name => {
+      loadFile(name, dir, options, files);
+    });
+  }
+
+  return async (ctx: any, next: Next) => {
+    // only accept HEAD and GET
+    if (ctx.method !== 'HEAD' && ctx.method !== 'GET') return await next();
+    // check prefix first to avoid calculate
+    if (!ctx.path.startsWith(options.prefix)) return await next();
+
+    // decode for `/%E4%B8%AD%E6%96%87`
+    // normalize for `//index`
+    let filename = path.normalize(safeDecodeURIComponent(ctx.path));
+
+    // check alias
+    if (options.alias && options.alias[filename]) {
+      filename = options.alias[filename];
+    }
+
+    let file = files.get(filename) as FileMeta;
+    // try to load file
+    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);
+      }
+
+      // trim prefix
+      if (options.prefix !== '/') {
+        if (filename.indexOf(filePrefix) !== 0) {
+          return await next();
+        }
+        filename = filename.slice(filePrefix.length);
+      }
+
+      const fullpath = path.join(dir, filename);
+      // files that can be accessed should be under options.dir
+      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 = undefined;
+        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
+      && compressible(file.type!);
+
+    if (file.buffer) {
+      if (shouldGzip) {
+
+        const gzFile = files.get(filename + '.gz') as FileMeta;
+        if (options.usePrecompiledGzip && gzFile && gzFile.buffer) {
+          // if .gz file already read from disk
+          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!);
+
+    // update file hash
+    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;
+    // enable gzip will remove content length
+    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: string, dir: string, options: Options, fileManager: FileManager) {
+  const pathname = path.normalize(path.join(options.prefix!, name));
+  if (!fileManager.get(pathname)) {
+    fileManager.set(pathname, {});
+  }
+  const obj = fileManager.get(pathname) as FileMeta;
+  const filename = obj.path = path.join(dir, name);
+  const stats = statSync(filename);
+  const buffer = readFileSync(filename);
+
+  obj.cacheControl = options.cacheControl;
+  obj.maxAge = obj.maxAge ? 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;
+}