@radatek/microserver 3.0.3 → 3.0.4

package/README.md

@@ -0,0 +1,193 @@
+## HTTP MicroServer
+
+Lightweight all-in-one http web server without dependencies
+
+Features:
+  - fast REST API router
+  - form/json body decoder
+  - file upload
+  - websockets
+  - authentication
+  - plain/hashed passwords
+  - virtual hosts
+  - static files
+  - rewrite
+  - redirect
+  - reverse proxy routes
+  - trust ip for reverse proxy
+  - json file storage with autosave
+  - tls with automatic certificate reload
+  - data model with validation and mongodb interface
+  - typescript model schema translation
+  - simple file/memory storage
+  - promises as middleware
+  - controller class
+  - access rights per route
+  - access rights per model field
+
+### Usage examples:
+
+Simple router:
+
+```ts
+import { MicroServer, AccessDenied, StandardPlugins, StaticPlugin } from '@radatek/microserver'
+
+const server = new MicroServer({
+  listen: 8080,
+  auth: {
+    users: {
+      usr: {
+        password: 'secret'
+      }
+    }
+  }
+})
+server.use(StandardPlugins)
+server.use('GET /api/hello/:id',
+  (req: ServerRequset, res: ServerResponse) =>
+    ({message:'Hello ' + req.params.id + '!'}))
+server.use('POST /api/login',
+  (req: ServerRequset, res: ServerResponse) =>
+  {
+    const user = await req.auth.login(req.body.user, req.body.password)
+    return user ? {user} : new AccessDenied()
+  })
+server.use('GET /api/protected', 'acl:auth',
+  (req: ServerRequset, res: ServerResponse) =>
+    ({message:'Secret resource'}))
+server.use(StaticPlugin, {root:'public'})
+```
+
+Using WebSockets
+
+```ts
+import { MicroServer, WebSocketsPlugin } from '@radatek/microserver'
+
+const server = new MicroServer({
+  listen: 8080
+})
+server.use(WebSocketsPlugin)
+server.use('WEBSOCKET /ws', (req: ServerRequset, res: ServerResponse) => {
+  req.websocket.on('message', (data) => console.log(data))
+  req.websocket.on('close', () => console.log('closed'))
+})
+```
+
+Using data schema:
+
+```js
+import { MicroServer, Model, MicroCollection } from '@radatek/microserver'
+
+const db = new MicroCollectionStore('./data')
+// or using MicroDB collection
+//const db = new MicroDB('microdb://data')
+
+const usersCollection = await db.collection('users')
+
+const userProfile = new Model({
+  _id: 'string',
+  name: { type: 'string', required: true },
+  email: { type: 'string', format: 'email' },
+  password: { type: 'string', canRead: false },
+  role: { type: 'string' },
+  acl: { type: 'object' },
+}, { collection: usersCollection, name: 'user' })
+
+const server = new MicroServer({
+  listen:8080,
+  auth: {
+    users: (user, password) => userProfile.get(password ? {_id: user, password } : {_id: user})
+  }
+})
+
+await userProfile.insert({name: 'admin', password: 'secret', role: 'admin', acl: {'user/*': true}})
+
+server.use('POST /login', async (req) => {
+  const user = await req.auth.login(req.body.user, req.body.password)
+  return user ? { user } : 403
+})
+// authenticated user allways has auth access
+server.use('GET /profile', 'acl:auth', req => ({ user: req.user }))
+// get all users if role='admin'
+server.use('GET /admin/users', 'role:admin', userProfile)
+// get user by id if has acl 'user/get'
+server.use('GET /admin/user/:id', 'acl:user/get', userProfile)
+// insert new user if role='admin' and has acl 'user/insert'
+server.use('POST /admin/user', 'role:admin', 'acl:user/insert', userProfile)
+// update user if has acl 'user/update'
+server.use('PUT /admin/user/:id', 'acl:user/update', userProfile)
+// delete user if has acl 'user/update'
+server.use('DELETE /admin/user/:id', 'acl:user/delete', userProfile)
+```
+
+Using controller:
+
+```ts
+const server = new MicroServer({
+  listen: 8080,
+  auth: {
+    users: {
+      usr: {
+        password: 'secret',
+        acl: {
+          user: true,
+          'user/insert': true
+        }
+      }
+    }
+  }
+})
+server.use(StandardPlugins)
+
+new MicroCollectionStore('data') // initialize simple file store for models
+//new MicroCollectionStore() // initialize simple memory store for models
+
+class RestApi extends Controller {
+  static acl = '' // default acl
+
+  gethello(id) { // same as 'GET /hello'
+    return {message:'Hello ' + id + '!'}
+  }
+
+  async post_login() { // same as 'POST /login'
+    const user = await this.auth.login(this.body.user, this.body.password)
+    return user ? {user} : 403
+  }
+
+  static 'acl:protected' = 'user'
+  static 'url:protected' = 'GET /protected'
+  protected() {
+    return {message:'Protected'}
+  }
+}
+
+server.use('/api', RestApi)
+
+const AddressModel = new Model({
+  street: String,
+  city: String
+})
+
+const UserModel = Model.define({
+  name: { type: String, require: true },
+  address: AddressModel
+})
+
+class UserController extends Controller<typeof UserModel> {
+  static model = UserModel
+  static name = 'user'
+
+  static 'acl:get' = 'user/get'
+  async get(id: string) { // same as 'GET user'
+    return {user: await this.model.findOne({id})}
+  }
+
+  static 'acl:insert' = 'user/insert'
+  async insert() { // same as 'POST user'
+    await this.model.insert(this.req.body)
+    return {}
+  }
+}
+
+server.use('/api/user', UserController)
+```

package/microserver.d.ts

@@ -87,10 +87,15 @@ export declare class ServerRequest<T = any> extends http.IncomingMessage {
     /** Request raw body size */
     rawBodySize: number;
     private constructor();
+    /** Extend http.IncomingMessage */
     static extend(req: http.IncomingMessage, res: http.ServerResponse, server: MicroServer): ServerRequest;
+    /** Check if request is ready */
     get isReady(): boolean;
+    /** Wait for request to be ready, usualy used to wait for file upload */
     waitReady(): Promise<void>;
+    /** Signal request as ready */
     setReady(err?: Error): void;
+    /** Set request body */
     setBody(body: ServerRequestBody<T>): void;
     /** Update request url */
     updateUrl(url: string): this;
@@ -108,9 +113,10 @@ export declare class ServerRequest<T = any> extends http.IncomingMessage {
 /** Extends http.ServerResponse */
 export declare class ServerResponse<T = any> extends http.ServerResponse {
     readonly req: ServerRequest<T>;
+    /** Should response be json */
     isJson: boolean;
-    headersOnly: boolean;
     private constructor();
+    /** Extends http.ServerResponse */
     static extend(res: http.ServerResponse): void;
     /** Send error reponse */
     error(error: string | number | Error): void;
@@ -167,11 +173,13 @@ interface MicroServerEvents {
 }
 /** Lighweight HTTP server */
 export declare class MicroServer extends EventEmitter {
+    /** MicroServer configuration */
     config: MicroServerConfig;
+    /** Authorization object */
     auth?: Auth;
-    /** all sockets */
+    /** All sockets */
     sockets: Set<net.Socket> | undefined;
-    /** server instances */
+    /** Server instances */
     servers: Set<net.Server> | undefined;
     /** @param {MicroServerConfig} [config] MicroServer configuration  */
     constructor(config?: MicroServerConfig);
@@ -184,40 +192,39 @@ export declare class MicroServer extends EventEmitter {
     waitReady(): Promise<void>;
     /** Listen server, should be used only if config.listen is not set */
     listen(config: ListenConfig): Promise<void>;
-    /** bind middleware or create one from string like: 'redirect:302,https://redirect.to', 'error:422', 'param:name=value', 'acl:users/get', 'model:User', 'group:Users', 'user:admin' */
-    _bind(fn: string | Function | object): Function;
     /** Default server handler */
     handler(req: ServerRequest, res: ServerResponse): void;
-    /** Last request handler */
-    handlerLast(req: ServerRequest, res: ServerResponse, next?: Function): any;
     /** Clear routes and middlewares */
     clear(): this;
     /**
-     * Add middleware route.
+     * Add middleware, plugin or routes to server.
      * Middlewares may return promises for res.jsonSuccess(...), throw errors for res.error(...), return string or {} for res.send(...)
      * RouteURL: 'METHOD /suburl', 'METHOD', '* /suburl'
      */
     use(...args: [
         Middleware | Plugin | ControllerClass | RoutesSet
     ] | [Promise<Middleware | Plugin | ControllerClass | RoutesSet>] | RoutesList | [RouteURL, RoutesSet] | [PluginClass | Promise<PluginClass>, options?: any]): Promise<void>;
+    /** Add middleware to stack, with optional priority */
     addStack(middleware: Middleware): void;
+    /** Get plugin */
     getPlugin(id: string): Plugin | undefined;
+    /** Wait for plugin */
     waitPlugin(id: string): Promise<Plugin>;
-    /** Add route, alias to `server.router.use(url, ...args)` */
+    /** Add route, alias to `server.use(url, ...args)` */
     all(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
-    /** Add route, alias to `server.router.use('GET ' + url, ...args)` */
+    /** Add route, alias to `server.use('GET ' + url, ...args)` */
     get(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
-    /** Add route, alias to `server.router.use('POST ' + url, ...args)` */
+    /** Add route, alias to `server.use('POST ' + url, ...args)` */
     post(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
-    /** Add route, alias to `server.router.use('PUT ' + url, ...args)` */
+    /** Add route, alias to `server.use('PUT ' + url, ...args)` */
     put(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
-    /** Add route, alias to `server.router.use('PATCH ' + url, ...args)` */
+    /** Add route, alias to `server.use('PATCH ' + url, ...args)` */
     patch(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
-    /** Add route, alias to `server.router.use('DELETE ' + url, ...args)` */
+    /** Add route, alias to `server.use('DELETE ' + url, ...args)` */
     delete(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
-    /** Add websocket handler, alias to `server.router.use('WEBSOCKET ' + url, ...args)` */
+    /** Add websocket handler, alias to `server.use('WEBSOCKET ' + url, ...args)` */
     websocket(url: `/${string}`, ...args: RoutesMiddleware[]): MicroServer;
-    /** Add router hook, alias to `server.router.hook(url, ...args)` */
+    /** Add router hook, alias to `server.hook(url, ...args)` */
     hook(url: RouteURL, ...args: RoutesMiddleware[]): MicroServer;
     /** Check if middleware allready added */
     has(mid: Middleware): boolean;
@@ -263,8 +270,6 @@ export declare class CorsPlugin extends Plugin {
 export declare class MethodsPlugin extends Plugin {
     priority: number;
     name: string;
-    _methods: string;
-    _methodsIdx: Record<string, boolean>;
     constructor(methods?: string);
     handler(req: ServerRequest, res: ServerResponse, next: Function): any;
 }
@@ -274,7 +279,6 @@ export interface BodyOptions {
 export declare class BodyPlugin extends Plugin {
     priority: number;
     name: string;
-    _maxBodySize: number;
     constructor(options?: BodyOptions);
     handler(req: ServerRequest, res: ServerResponse, next: () => void): void;
 }
@@ -292,8 +296,6 @@ export interface UploadFile {
 export declare class UploadPlugin extends Plugin {
     priority: number;
     name: string;
-    _maxFileSize: number;
-    _uploadDir?: string;
     constructor(options?: UploadOptions);
     handler(req: ServerRequest, res: ServerResponse, next: () => void): void;
 }
@@ -335,7 +337,6 @@ export declare class WebSocket extends EventEmitter {
     ping(buffer?: Buffer): void;
     /** Send pong frame */
     pong(buffer?: Buffer): void;
-    protected _sendFrame(opcode: number, data: Buffer, cb?: () => void): void;
     on<K extends keyof WebSocketEvents>(event: K, listener: WebSocketEvents[K]): this;
     addListener<K extends keyof WebSocketEvents>(event: K, listener: WebSocketEvents[K]): this;
     once<K extends keyof WebSocketEvents>(event: K, listener: WebSocketEvents[K]): this;
@@ -344,9 +345,8 @@ export declare class WebSocket extends EventEmitter {
 }
 export declare class WebSocketPlugin extends Plugin {
     name: string;
-    _handler: (req: ServerRequest, socket: net.Socket, head: any) => void;
     constructor(options?: any, server?: MicroServer);
-    addUpgradeHandler(srv: http.Server): void;
+    private addUpgradeHandler;
     upgradeHandler(server: MicroServer, req: ServerRequest, socket: net.Socket, head: any): void;
 }
 /** Trust proxy plugin, adds `req.ip` and `req.localip` */
@@ -447,6 +447,7 @@ export declare class StaticFilesPlugin extends Plugin {
     constructor(options?: StaticFilesOptions | string, server?: MicroServer);
     /** Default static files handler */
     handler(req: ServerRequest, res: ServerResponse, next: Function): any;
+    /** Send static file */
     serveFile(req: ServerRequest, res: ServerResponse, options: ServeFileOptions): void;
 }
 /** Proxy plugin options */
@@ -705,7 +706,9 @@ export declare class FileStore {
     constructor(options?: FileStoreOptions);
     /** cleanup cache */
     cleanup(): void;
+    /** close store */
     close(): Promise<void>;
+    /** sync data to disk */
     sync(): Promise<void>;
     /** load json file data */
     load(name: string, autosave?: boolean): Promise<any>;
@@ -923,10 +926,12 @@ export declare class MicroCollection<TSchema extends ModelSchema = any> {
     deleteOne(query: Query): Promise<number>;
     /** Delete all matching documents */
     deleteMany(query: Query): Promise<number>;
+    /** Update one matching document */
     updateOne(query: Query, update: Record<string, any>, options?: FindOptions): Promise<{
         upsertedId: any;
         modifiedCount: number;
     }>;
+    /** Update many matching documents */
     updateMany(query: Query, update: Record<string, any>, options?: FindOptions): Promise<{
         upsertedId: any;
         modifiedCount: number;

package/microserver.js

@@ -122,6 +122,7 @@ export class ServerRequest extends http.IncomingMessage {
         super(new net.Socket());
         ServerRequest.extend(this, res, server);
     }
+    /** Extend http.IncomingMessage */
     static extend(req, res, server) {
         const reqNew = Object.setPrototypeOf(req, ServerRequest.prototype);
         let ip = req.socket.remoteAddress || '::1';
@@ -153,9 +154,11 @@ export class ServerRequest extends http.IncomingMessage {
         reqNew.updateUrl(req.url || '/');
         return reqNew;
     }
+    /** Check if request is ready */
     get isReady() {
         return this._isReady === undefined;
     }
+    /** Wait for request to be ready, usualy used to wait for file upload */
     async waitReady() {
         if (this._isReady === undefined)
             return;
@@ -163,9 +166,11 @@ export class ServerRequest extends http.IncomingMessage {
         if (res && res instanceof Error)
             throw res;
     }
+    /** Signal request as ready */
     setReady(err) {
         this._isReady?.resolve(err);
     }
+    /** Set request body */
     setBody(body) {
         this._body = body;
     }
@@ -205,19 +210,19 @@ export class ServerRequest extends http.IncomingMessage {
 }
 /** Extends http.ServerResponse */
 export class ServerResponse extends http.ServerResponse {
+    /** Should response be json */
     isJson;
-    headersOnly;
     constructor(server) {
         super(new http.IncomingMessage(new net.Socket()));
         ServerRequest.extend(this.req, this, server);
         ServerResponse.extend(this);
     }
+    /** Extends http.ServerResponse */
     static extend(res) {
         Object.setPrototypeOf(res, ServerResponse.prototype);
         Object.assign(res, {
             statusCode: 200,
-            isJson: false,
-            headersOnly: false
+            isJson: false
         });
     }
     /** Send error reponse */
@@ -282,7 +287,7 @@ export class ServerResponse extends http.ServerResponse {
                 return (data.pipe(this, { end: true }), void 0);
             if (data instanceof Buffer) {
                 this.setHeader('Content-Length', data.byteLength);
-                if (this.headersOnly)
+                if (this.statusCode === 304 || this.req.method === 'HEAD')
                     this.end();
                 else
                     this.end(data);
@@ -301,7 +306,7 @@ export class ServerResponse extends http.ServerResponse {
                 this.setHeader('Content-Type', 'text/plain');
         }
         this.setHeader('Content-Length', Buffer.byteLength(data, 'utf8'));
-        if (this.headersOnly)
+        if (this.statusCode === 304 || this.req.method === 'HEAD')
             this.end();
         else
             this.end(data, 'utf8');
@@ -356,15 +361,17 @@ export class ServerResponse extends http.ServerResponse {
 }
 /** Lighweight HTTP server */
 export class MicroServer extends EventEmitter {
+    /** MicroServer configuration */
     config;
+    /** Authorization object */
     auth;
     _plugins = {};
     _stack = [];
     _router = new RouterPlugin();
     _worker = new Worker();
-    /** all sockets */
+    /** All sockets */
     sockets;
-    /** server instances */
+    /** Server instances */
     servers;
     /** @param {MicroServerConfig} [config] MicroServer configuration  */
     constructor(config) {
@@ -491,7 +498,7 @@ export class MicroServer extends EventEmitter {
         });
         return this._worker.wait('listen');
     }
-    /** bind middleware or create one from string like: 'redirect:302,https://redirect.to', 'error:422', 'param:name=value', 'acl:users/get', 'model:User', 'group:Users', 'user:admin' */
+    /* bind middleware or create one from string like: 'redirect:302,https://redirect.to', 'error:422', 'param:name=value', 'acl:users/get', 'model:User', 'group:Users', 'user:admin' */
     _bind(fn) {
         if (typeof fn === 'string') {
             let name = fn;
@@ -591,15 +598,6 @@ export class MicroServer extends EventEmitter {
         ServerRequest.extend(req, res, this);
         ServerResponse.extend(res);
         this._router.walk(this._stack, req, res, () => res.error(404));
-        //this.handlerRouter(req, res, () => this.handlerLast(req, res))
-    }
-    /** Last request handler */
-    handlerLast(req, res, next) {
-        if (res.headersSent || res.closed)
-            return;
-        if (!next)
-            next = () => res.error(404);
-        return next();
     }
     /** Clear routes and middlewares */
     clear() {
@@ -610,7 +608,7 @@ export class MicroServer extends EventEmitter {
         return this;
     }
     /**
-     * Add middleware route.
+     * Add middleware, plugin or routes to server.
      * Middlewares may return promises for res.jsonSuccess(...), throw errors for res.error(...), return string or {} for res.send(...)
      * RouteURL: 'METHOD /suburl', 'METHOD', '* /suburl'
      */
@@ -704,6 +702,7 @@ export class MicroServer extends EventEmitter {
             this._worker.endJob('plugin:' + plugin.name);
         }
     }
+    /** Add middleware to stack, with optional priority */
     addStack(middleware) {
         if (middleware.plugin?.name && this.getPlugin(middleware.plugin.name))
             throw new Error(`Plugin ${middleware.plugin.name} already added`);
@@ -711,9 +710,11 @@ export class MicroServer extends EventEmitter {
         const idx = this._stack.findLastIndex(f => (f.priority || 0) <= priority);
         this._stack.splice(idx + 1, 0, middleware);
     }
+    /** Get plugin */
     getPlugin(id) {
         return this._plugins[id];
     }
+    /** Wait for plugin */
     async waitPlugin(id) {
         const p = this.getPlugin(id);
         if (p)
@@ -722,42 +723,42 @@ export class MicroServer extends EventEmitter {
         await this._worker.wait('plugin:' + id);
         return this.getPlugin(id);
     }
-    /** Add route, alias to `server.router.use(url, ...args)` */
+    /** Add route, alias to `server.use(url, ...args)` */
     all(url, ...args) {
         this.use('* ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.use('GET ' + url, ...args)` */
+    /** Add route, alias to `server.use('GET ' + url, ...args)` */
     get(url, ...args) {
         this.use('GET ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.use('POST ' + url, ...args)` */
+    /** Add route, alias to `server.use('POST ' + url, ...args)` */
     post(url, ...args) {
         this.use('POST ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.use('PUT ' + url, ...args)` */
+    /** Add route, alias to `server.use('PUT ' + url, ...args)` */
     put(url, ...args) {
         this.use('PUT ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.use('PATCH ' + url, ...args)` */
+    /** Add route, alias to `server.use('PATCH ' + url, ...args)` */
     patch(url, ...args) {
         this.use('PATCH ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.use('DELETE ' + url, ...args)` */
+    /** Add route, alias to `server.use('DELETE ' + url, ...args)` */
     delete(url, ...args) {
         this.use('DELETE ' + url, ...args);
         return this;
     }
-    /** Add websocket handler, alias to `server.router.use('WEBSOCKET ' + url, ...args)` */
+    /** Add websocket handler, alias to `server.use('WEBSOCKET ' + url, ...args)` */
     websocket(url, ...args) {
         this.use('WEBSOCKET ' + url, ...args);
         return this;
     }
-    /** Add router hook, alias to `server.router.hook(url, ...args)` */
+    /** Add router hook, alias to `server.hook(url, ...args)` */
     hook(url, ...args) {
         const m = url.match(/^([A-Z]+) (.*)/) || ['', 'hook', url];
         this._router.add(m[1], m[2], args.filter(m => m).map(m => this._bind(m)), false);
@@ -800,7 +801,6 @@ class RouterItem {
 class RouterPlugin extends Plugin {
     priority = 100;
     name = 'router';
-    //stack: Middleware[] = []
     _tree = {};
     constructor() {
         super();
@@ -923,7 +923,8 @@ class RouterPlugin extends Plugin {
         this._tree = {};
     }
     handler(req, res, next) {
-        this.walk(this._getStack(req.pathname, ['hook', req.method, '*']), req, res, next);
+        const method = req.method === 'HEAD' ? 'GET' : req.method || 'GET';
+        this.walk(this._getStack(req.pathname, ['hook', method, '*']), req, res, next);
     }
 }
 export class CorsPlugin extends Plugin {
@@ -980,10 +981,6 @@ export class MethodsPlugin extends Plugin {
             res.setHeader('Allow', this._methods);
             return res.status(405).end();
         }
-        if (req.method === 'HEAD') {
-            req.method = 'GET';
-            res.headersOnly = true;
-        }
         return next();
     }
 }
@@ -996,7 +993,7 @@ export class BodyPlugin extends Plugin {
         this._maxBodySize = options?.maxBodySize || defaultMaxBodySize;
     }
     handler(req, res, next) {
-        if (req.complete || req.method === 'GET') {
+        if (req.complete || req.method === 'GET' || req.method === 'HEAD') {
             if (!req.body)
                 req.setBody({});
             return next();
@@ -1052,7 +1049,7 @@ export class UploadPlugin extends Plugin {
         this._uploadDir = options?.uploadDir;
     }
     handler(req, res, next) {
-        if (!req.readable || req.method === 'GET')
+        if (!req.readable || req.method === 'GET' || req.method === 'HEAD')
             return next();
         const contentType = req.headers['content-type'] || '';
         if (!contentType.startsWith('multipart/form-data'))
@@ -1710,7 +1707,7 @@ export class StaticFilesPlugin extends Plugin {
     }
     /** Default static files handler */
     handler(req, res, next) {
-        if (req.method !== 'GET')
+        if (req.method !== 'GET' && req.method !== 'HEAD')
             return next();
         if (!('path' in req.params)) { // global handler
             if (req.path.startsWith(this.prefix) && (req.path === this.prefix || req.path[this.prefix.length] === '/')) {
@@ -1751,6 +1748,7 @@ export class StaticFilesPlugin extends Plugin {
             });
         });
     }
+    /** Send static file */
     serveFile(req, res, options) {
         const filePath = path.isAbsolute(options.path) ? options.path : path.join(options.root || this.root, options.path);
         const statRes = (err, stats) => {
@@ -1773,14 +1771,12 @@ export class StaticFilesPlugin extends Plugin {
             res.setHeader('Content-Length', stats.size);
             if (options.etag !== false) {
                 const etag = '"' + etagPrefix + stats.mtime.getTime().toString(32) + '"';
-                if (req.headers['if-none-match'] === etag || req.headers['if-modified-since'] === stats.mtime.toUTCString()) {
+                if (req.headers['if-none-match'] === etag || req.headers['if-modified-since'] === stats.mtime.toUTCString())
                     res.statusCode = 304;
-                    res.headersOnly = true;
-                }
             }
             if (options.maxAge)
                 res.setHeader('Cache-Control', 'max-age=' + options.maxAge);
-            if (res.headersOnly) {
+            if (res.statusCode === 304 || req.method === 'HEAD') {
                 res.end();
                 return;
             }
@@ -2577,11 +2573,13 @@ export class FileStore {
         });
         return p;
     }
+    /** close store */
     async close() {
         await this.sync();
         this._iter = 0;
         this._cache = {};
     }
+    /** sync data to disk */
     async sync() {
         for (const name in this._cache) {
             for (const key in this._cache)
@@ -3313,10 +3311,12 @@ export class MicroCollection {
     async deleteMany(query) {
         return (await this.updateMany(query, {}, { delete: true })).modifiedCount;
     }
+    /** Update one matching document */
     async updateOne(query, update, options) {
         const res = await this.updateMany(query, update, { ...options, limit: 1 });
         return res;
     }
+    /** Update many matching documents */
     async updateMany(query, update, options) {
         let res = { upsertedId: undefined, modifiedCount: 0 };
         if (!query)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radatek/microserver",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "description": "HTTP MicroServer",
   "author": "Darius Kisonas",
   "license": "MIT",