@radatek/microserver 2.0.2 → 2.2.0

package/dist/microserver.js

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.0.2
+ * @version 2.2.0
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -12,7 +12,7 @@ import tls from 'tls';
 import querystring from 'querystring';
 import { Readable } from 'stream';
 import fs from 'fs';
-import path from 'path';
+import path, { basename, extname } from 'path';
 import crypto from 'crypto';
 import zlib from 'zlib';
 import { EventEmitter } from 'events';
@@ -21,6 +21,9 @@ const defaultExpire = 24 * 60 * 60;
 const defaultMaxBodySize = 5 * 1024 * 1024;
 const defaultMethods = 'HEAD,GET,POST,PUT,PATCH,DELETE';
 function NOOP(...args) { }
+function isFunction(fn) {
+    return typeof fn === 'function' && !fn.prototype?.constructor;
+}
 export class Warning extends Error {
     constructor(text) {
         super(text);
@@ -71,8 +74,9 @@ export class ServerRequest extends http.IncomingMessage {
     _init(router) {
         Object.assign(this, {
             router,
+            auth: router.auth,
             protocol: 'encrypted' in this.socket && this.socket.encrypted ? 'https' : 'http',
-            get: {},
+            query: {},
             params: {},
             paramsList: [],
             path: '/',
@@ -92,8 +96,8 @@ export class ServerRequest extends http.IncomingMessage {
         this.pathname = pathname;
         this.path = pathname.slice(pathname.lastIndexOf('/'));
         this.baseUrl = pathname.slice(0, pathname.length - this.path.length);
-        this.get = {};
-        parsedUrl.searchParams.forEach((v, k) => this.get[k] = v);
+        this.query = {};
+        parsedUrl.searchParams.forEach((v, k) => this.query[k] = v);
     }
     /** Rewrite request url */
     rewrite(url) {
@@ -313,8 +317,9 @@ export class ServerResponse extends http.ServerResponse {
         this.statusCode = 200;
     }
     /** Send error reponse */
-    error(error, text) {
+    error(error) {
         let code = 0;
+        let text;
         if (error instanceof Error) {
             if ('statusCode' in error)
                 code = error.statusCode;
@@ -322,7 +327,7 @@ export class ServerResponse extends http.ServerResponse {
         }
         else if (typeof error === 'number') {
             code = error;
-            text = text || commonCodes[code] || 'Error';
+            text = commonCodes[code] || 'Error';
         }
         else
             text = error.toString();
@@ -399,19 +404,17 @@ export class ServerResponse extends http.ServerResponse {
         this.send(data);
     }
     /** Send json response in form { success: false, error: err } */
-    jsonError(error, code) {
+    jsonError(error) {
         this.isJson = true;
-        this.statusCode = code || 200;
         if (typeof error === 'number')
-            [code, error] = [error, http.STATUS_CODES[error] || 'Error'];
+            error = http.STATUS_CODES[error] || 'Error';
         if (error instanceof Error)
             return this.json(error);
         this.json(typeof error === 'string' ? { success: false, error } : { success: false, ...error });
     }
     /** Send json response in form { success: true, ... } */
-    jsonSuccess(data, code) {
+    jsonSuccess(data) {
         this.isJson = true;
-        this.statusCode = code || 200;
         if (data instanceof Error)
             return this.json(data);
         this.json(typeof data === 'string' ? { success: true, message: data } : { success: true, ...data });
@@ -427,6 +430,18 @@ export class ServerResponse extends http.ServerResponse {
         this.statusCode = code || 302;
         this.end();
     }
+    /** Set status code */
+    status(code) {
+        this.statusCode = code;
+        return this;
+    }
+    download(path, filename) {
+        StaticPlugin.serveFile(this.req, this, {
+            path: path,
+            filename: filename || basename(path),
+            mimeType: StaticPlugin.mimeTypes[extname(path)] || 'application/octet-stream'
+        });
+    }
 }
 const EMPTY_BUFFER = Buffer.alloc(0);
 const DEFLATE_TRAILER = Buffer.from([0x00, 0x00, 0xff, 0xff]);
@@ -681,7 +696,7 @@ export class WebSocket extends EventEmitter {
         headers = [
             `HTTP/1.1 ${code} ${http.STATUS_CODES[code]}`,
             'Connection: close',
-            'Content-Type: text/html',
+            'Content-Type: ' + message.startsWith('<') ? 'text/html' : 'text/plain',
             `Content-Length: ${Buffer.byteLength(message)}`,
             '',
             message
@@ -892,6 +907,48 @@ export class Controller {
         return routes;
     }
 }
+class Waiter {
+    constructor() {
+        this._waiters = {};
+        this._id = 0;
+        this._busy = 0;
+    }
+    get busy() {
+        return this._busy > 0;
+    }
+    startJob() {
+        this._busy++;
+    }
+    endJob(id) {
+        this._busy--;
+        if (!this._busy)
+            this.resolve(id || 'ready');
+    }
+    get nextId() {
+        return (++this._id).toString();
+    }
+    async wait(id) {
+        return new Promise(resolve => (this._waiters[id] = this._waiters[id] || []).push(resolve));
+    }
+    resolve(id) {
+        const resolvers = this._waiters[id];
+        if (resolvers)
+            for (const resolve of resolvers)
+                resolve(undefined);
+        delete this._waiters[id];
+    }
+}
+class EmitterWaiter extends Waiter {
+    constructor(emitter) {
+        super();
+        this._emitter = emitter;
+    }
+    resolve(id) {
+        if (id === 'ready')
+            this._emitter.emit(id);
+        super.resolve(id);
+    }
+}
 /** Router */
 export class Router extends EventEmitter {
     /** @param {MicroServer} server  */
@@ -901,8 +958,95 @@ export class Router extends EventEmitter {
         this._stack = [];
         this._stackAfter = [];
         this._tree = {};
+        this._waiter = new Waiter();
         this.server = server;
     }
+    /** 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;
+            let idx = name.indexOf(':');
+            if (idx < 0 && name.includes('=')) {
+                name = 'param:' + name;
+                idx = 5;
+            }
+            if (idx >= 0) {
+                const v = name.slice(idx + 1);
+                const type = name.slice(0, idx);
+                // predefined middlewares
+                switch (type) {
+                    // redirect:302,https://redirect.to
+                    case 'redirect': {
+                        let redirect = v.split(','), code = parseInt(v[0]);
+                        if (!code || code < 301 || code > 399)
+                            code = 302;
+                        return (req, res) => res.redirect(code, redirect[1] || v);
+                    }
+                    // error:422
+                    case 'error':
+                        return (req, res) => res.error(parseInt(v) || 422);
+                    // param:name=value
+                    case 'param': {
+                        idx = v.indexOf('=');
+                        if (idx > 0) {
+                            const prm = v.slice(0, idx), val = v.slice(idx + 1);
+                            return (req, res, next) => { req.params[prm] = val; return next(); };
+                        }
+                        break;
+                    }
+                    case 'model': {
+                        const model = v;
+                        return (req, res) => {
+                            res.isJson = true;
+                            req.params.model = model;
+                            req.model = Model.models[model];
+                            if (!req.model) {
+                                console.error(`Data model ${model} not defined for request ${req.path}`);
+                                return res.error(422);
+                            }
+                            return req.model.handler(req, res);
+                        };
+                    }
+                    // user:userid
+                    // group:user_groupid
+                    // acl:validacl
+                    case 'user':
+                    case 'group':
+                    case 'acl':
+                        return (req, res, next) => {
+                            if (type === 'user' && v === req.user?.id)
+                                return next();
+                            if (type === 'acl') {
+                                req.params.acl = v;
+                                if (req.auth?.acl(v))
+                                    return next();
+                            }
+                            if (type === 'group') {
+                                req.params.group = v;
+                                if (req.user?.group === v)
+                                    return next();
+                            }
+                            const accept = req.headers.accept || '';
+                            if (!res.isJson && req.auth?.options.redirect && req.method === 'GET' && !accept.includes('json') && (accept.includes('html') || accept.includes('*/*'))) {
+                                if (req.auth.options.redirect && req.url !== req.auth.options.redirect)
+                                    return res.redirect(302, req.auth.options.redirect);
+                                else if (req.auth.options.mode !== 'cookie') {
+                                    res.setHeader('WWW-Authenticate', `Basic realm="${req.auth.options.realm}"`);
+                                    return res.error(401);
+                                }
+                            }
+                            return res.error('Permission denied');
+                        };
+                }
+            }
+            throw new Error('Invalid option: ' + name);
+        }
+        if (fn && typeof fn === 'object' && 'handler' in fn && typeof fn.handler === 'function')
+            return fn.handler.bind(fn);
+        if (typeof fn !== 'function')
+            throw new Error('Invalid middleware: ' + String.toString.call(fn));
+        return fn.bind(this);
+    }
     /** Handler */
     handler(req, res, next, method) {
         const nextAfter = next;
@@ -1002,7 +1146,7 @@ export class Router extends EventEmitter {
                 url,
                 middlewares
             });
-        middlewares = middlewares.map(i => this.server.bind(i));
+        middlewares = middlewares.map(m => this.bind(m));
         let item = this._tree[method];
         if (!item)
             item = this._tree[method] = { tree: {} };
@@ -1038,7 +1182,6 @@ export class Router extends EventEmitter {
         if (!item[key])
             item[key] = [];
         item[key].push(...middlewares);
-        return this;
     }
     /** Clear routes and middlewares */
     clear() {
@@ -1052,71 +1195,79 @@ export class Router extends EventEmitter {
      *
      * @signature add(plugin: Plugin)
      * @param {Plugin} plugin plugin module instance
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(pluginid: string, ...args: any)
      * @param {string} pluginid pluginid module
      * @param {...any} args arguments passed to constructor
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(pluginClass: typeof Plugin, ...args: any)
      * @param {typeof Plugin} pluginClass plugin class
      * @param {...any} args arguments passed to constructor
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(middleware: Middleware)
      * @param {Middleware} middleware
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(methodUrl: string, ...middlewares: any)
      * @param {string} methodUrl 'METHOD /url' or '/url'
      * @param {...any} middlewares
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(methodUrl: string, controllerClass: typeof Controller)
      * @param {string} methodUrl 'METHOD /url' or '/url'
      * @param {typeof Controller} controllerClass
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(methodUrl: string, routes: Array<Array<any>>)
      * @param {string} methodUrl 'METHOD /url' or '/url'
      * @param {Array<Array<any>>} routes list with subroutes: ['METHOD /suburl', ...middlewares]
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(methodUrl: string, routes: Array<Array<any>>)
      * @param {string} methodUrl 'METHOD /url' or '/url'
      * @param {Array<Array<any>>} routes list with subroutes: ['METHOD /suburl', ...middlewares]
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(routes: { [key: string]: Array<any> })
      * @param { {[key: string]: Array<any>} } routes list with subroutes: 'METHOD /suburl': [...middlewares]
-     * @return {Router} current router
+     * @return {Promise<>}
      *
      * @signature add(methodUrl: string, routes: { [key: string]: Array<any> })
      * @param {string} methodUrl 'METHOD /url' or '/url'
      * @param { {[key: string]: Array<any>} } routes list with subroutes: 'METHOD /suburl': [...middlewares]
-     * @return {Router} current router
+     * @return {Promise<>}
      */
-    use(...args) {
+    async use(...args) {
         if (!args[0])
-            return this;
+            return;
+        this.server._waiter.startJob();
+        for (let i = 0; i < args.length; i++)
+            args[i] = await args[i];
         // use(plugin)
-        if (args[0] instanceof Plugin)
-            return this._plugin(args[0]);
+        if (args[0] instanceof Plugin) {
+            await this._plugin(args[0]);
+            return this.server._waiter.endJob();
+        }
         // use(pluginid, ...args)
         if (typeof args[0] === 'string' && MicroServer.plugins[args[0]]) {
             const constructor = MicroServer.plugins[args[0]];
             const plugin = new constructor(this, ...args.slice(1));
-            return this._plugin(plugin);
+            await this._plugin(plugin);
+            return this.server._waiter.endJob();
         }
         // use(PluginClass, ...args)
-        if (args[0].prototype instanceof Plugin) {
+        if (typeof args[0] === 'function' && args[0].prototype instanceof Plugin) {
             const plugin = new args[0](this, ...args.slice(1));
-            return this._plugin(plugin);
+            await this._plugin(plugin);
+            return this.server._waiter.endJob();
         }
         // use(middleware)
-        if (typeof args[0] === 'function') {
-            return this._middleware(args[0]);
+        if (isFunction(args[0])) {
+            this._middleware(args[0]);
+            return this.server._waiter.endJob();
         }
         let method = '*', url = '/';
         if (typeof args[0] === 'string') {
@@ -1131,7 +1282,7 @@ export class Router extends EventEmitter {
         }
         // use('/url', ControllerClass)
         if (typeof args[0] === 'function' && args[0].prototype instanceof Controller) {
-            const routes = args[0].routes();
+            const routes = await args[0].routes();
             if (routes)
                 args[0] = routes;
         }
@@ -1139,17 +1290,17 @@ export class Router extends EventEmitter {
         if (Array.isArray(args[0])) {
             if (method !== '*')
                 throw new Error('Invalid router usage');
-            args[0].forEach(item => {
+            for (const item of args[0]) {
                 if (Array.isArray(item)) {
                     // [methodUrl, ...middlewares]
                     if (typeof item[0] !== 'string' || !item[0].match(/^(\w+ )?\//))
                         throw new Error('Url expected');
-                    return this.use(item[0].replace(/\//, (url === '/' ? '' : url) + '/'), ...item.slice(1));
+                    await this.use(item[0].replace(/\//, (url === '/' ? '' : url) + '/'), ...item.slice(1));
                 }
                 else
                     throw new Error('Invalid param');
-            });
-            return this;
+            }
+            return this.server._waiter.endJob();
         }
         // use('/url', {'METHOD /url': [...middlewares], ... } ])
         if (typeof args[0] === 'object' && args[0].constructor === Object) {
@@ -1158,44 +1309,47 @@ export class Router extends EventEmitter {
             for (const [subUrl, subArgs] of Object.entries(args[0])) {
                 if (!subUrl.match(/^(\w+ )?\//))
                     throw new Error('Url expected');
-                this.use(subUrl.replace(/\//, (url === '/' ? '' : url) + '/'), ...(Array.isArray(subArgs) ? subArgs : [subArgs]));
+                await this.use(subUrl.replace(/\//, (url === '/' ? '' : url) + '/'), ...(Array.isArray(subArgs) ? subArgs : [subArgs]));
             }
-            return this;
+            return this.server._waiter.endJob();
         }
         // use('/url', ...middleware)
-        return this._add(method, url, 'next', args.filter((o) => o));
+        this._add(method, url, 'next', args.filter((o) => o));
+        return this.server._waiter.endJob();
     }
     _middleware(middleware) {
         if (!middleware)
-            return this;
+            return;
         const priority = (middleware?.priority || 0) - 1;
         const stack = priority < -1 ? this._stackAfter : this._stack;
         const idx = stack.findIndex(f => 'priority' in f
             && priority >= (f.priority || 0));
         stack.splice(idx < 0 ? stack.length : idx, 0, middleware);
-        return this;
     }
-    _plugin(plugin) {
+    async _plugin(plugin) {
+        let added;
         if (plugin.name) {
             if (this.plugins[plugin.name])
                 throw new Error(`Plugin ${plugin.name} already added`);
             this.plugins[plugin.name] = plugin;
+            added = plugin.name;
         }
+        await plugin.initialise?.();
         if (plugin.handler) {
             const middleware = plugin.handler.bind(plugin);
             middleware.plugin = plugin;
             middleware.priority = plugin.priority;
-            return this._middleware(middleware);
-        }
-        if (plugin.routes) {
-            if (typeof plugin.routes === 'function')
-                this.use(plugin.routes());
-            else
-                this.use(plugin.routes);
+            this._middleware(middleware);
         }
-        if (plugin.controller)
-            this.use(plugin.controller);
-        return this;
+        if (plugin.routes)
+            await this.use(isFunction(plugin.routes) ? await plugin.routes() : plugin.routes);
+        if (added)
+            this._waiter.resolve(added);
+    }
+    async waitPlugin(id) {
+        if (!this.plugins[id])
+            await this._waiter.wait(id);
+        return this.plugins[id];
     }
     /** Add hook */
     hook(url, ...mid) {
@@ -1203,7 +1357,7 @@ export class Router extends EventEmitter {
         let method = '*';
         if (m)
             [method, url] = [m[1], m[2]];
-        return this._add(method, url, 'hook', mid);
+        this._add(method, url, 'hook', mid);
     }
     /** Check if middleware allready added */
     has(mid) {
@@ -1211,10 +1365,9 @@ export class Router extends EventEmitter {
     }
 }
 export class MicroServer extends EventEmitter {
-    get plugins() { return this.router.plugins; }
     constructor(config) {
         super();
-        this._ready = false;
+        this._waiter = new EmitterWaiter(this);
         this._methods = {};
         let promise = Promise.resolve();
         this._init = (f, ...args) => {
@@ -1246,7 +1399,7 @@ export class MicroServer extends EventEmitter {
     }
     /** Add one time listener or call immediatelly for 'ready' */
     once(name, cb) {
-        if (name === 'ready' && this._ready)
+        if (name === 'ready' && this.isReady())
             cb();
         else
             super.once(name, cb);
@@ -1254,11 +1407,22 @@ export class MicroServer extends EventEmitter {
     }
     /** Add listener and call immediatelly for 'ready'  */
     on(name, cb) {
-        if (name === 'ready' && this._ready)
+        if (name === 'ready' && this.isReady())
             cb();
         super.on(name, cb);
         return this;
     }
+    isReady() {
+        return !this._waiter.busy;
+    }
+    async waitReady() {
+        if (this.isReady())
+            return;
+        return this._waiter.wait("ready");
+    }
+    async waitPlugin(id) {
+        await this.router.waitPlugin(id);
+    }
     /** Listen server, should be used only if config.listen is not set */
     listen(config) {
         const listen = (config?.listen || this.config.listen || 0) + '';
@@ -1284,164 +1448,62 @@ export class MicroServer extends EventEmitter {
                 });
             }
         }
-        return new Promise((resolve) => {
-            let readyCount = 0;
-            this._ready = false;
-            const ready = (srv) => {
-                if (srv)
-                    readyCount++;
-                if (readyCount >= this.servers.size) {
-                    if (!this._ready) {
-                        this._ready = true;
-                        if (this.servers.size === 0)
-                            this.close();
-                        else
-                            this.emit('ready');
-                        resolve();
-                    }
-                }
-            };
-            const reg = /^((?<proto>\w+):\/\/)?(?<host>(\[[^\]]+\]|[a-z][^:,]+|\d+\.\d+\.\d+\.\d+))?:?(?<port>\d+)?/;
-            listen.split(',').forEach(listen => {
-                let { proto, host, port } = reg.exec(listen)?.groups || {};
-                let srv;
-                switch (proto) {
-                    case 'tcp':
-                        if (!config?.handler)
-                            throw new Error('Handler is required for tcp');
-                        srv = net.createServer(handler);
-                        break;
-                    case 'tls':
-                        if (!config?.handler)
-                            throw new Error('Handler is required for tls');
-                        srv = tls.createServer(tlsOptions(), handler);
-                        tlsOptionsReload(srv);
-                        break;
-                    case 'https':
-                        port = port || '443';
-                        srv = https.createServer(tlsOptions(), handler);
-                        tlsOptionsReload(srv);
-                        break;
-                    default:
-                        port = port || '80';
-                        srv = http.createServer(handler);
-                        break;
-                }
-                this.servers.add(srv);
-                if (port === '0') // skip listening
-                    ready(srv);
-                else {
-                    srv.listen(parseInt(port), host?.replace(/[\[\]]/g, '') || '0.0.0.0', () => {
-                        const addr = srv.address();
-                        this.emit('listen', addr.port, addr.address, srv);
-                        ready(srv);
-                    });
-                }
-                srv.on('error', err => {
-                    this.servers.delete(srv);
-                    srv.close();
-                    ready();
-                    this.emit('error', err);
-                });
-                srv.on('connection', s => {
-                    this.sockets.add(s);
-                    s.once('close', () => this.sockets.delete(s));
+        const reg = /^((?<proto>\w+):\/\/)?(?<host>(\[[^\]]+\]|[a-z][^:,]+|\d+\.\d+\.\d+\.\d+))?:?(?<port>\d+)?/;
+        listen.split(',').forEach(listen => {
+            this._waiter.startJob();
+            let { proto, host, port } = reg.exec(listen)?.groups || {};
+            let srv;
+            switch (proto) {
+                case 'tcp':
+                    if (!config?.handler)
+                        throw new Error('Handler is required for tcp');
+                    srv = net.createServer(handler);
+                    break;
+                case 'tls':
+                    if (!config?.handler)
+                        throw new Error('Handler is required for tls');
+                    srv = tls.createServer(tlsOptions(), handler);
+                    tlsOptionsReload(srv);
+                    break;
+                case 'https':
+                    port = port || '443';
+                    srv = https.createServer(tlsOptions(), handler);
+                    tlsOptionsReload(srv);
+                    break;
+                default:
+                    port = port || '80';
+                    srv = http.createServer(handler);
+                    break;
+            }
+            this.servers.add(srv);
+            if (port === '0') // skip listening
+                this._waiter.endJob();
+            else {
+                srv.listen(parseInt(port), host?.replace(/[\[\]]/g, '') || '0.0.0.0', () => {
+                    const addr = srv.address();
+                    this.emit('listen', addr.port, addr.address, srv);
+                    srv._ready = true;
+                    this._waiter.endJob();
                 });
-                srv.on('upgrade', this.handlerUpgrade.bind(this));
-                ready();
+            }
+            srv.on('error', err => {
+                srv.close();
+                this.servers.delete(srv);
+                if (!srv._ready)
+                    this._waiter.endJob();
+                this.emit('error', err);
+            });
+            srv.on('connection', s => {
+                this.sockets.add(s);
+                s.once('close', () => this.sockets.delete(s));
             });
+            srv.on('upgrade', this.handlerUpgrade.bind(this));
         });
+        return this._waiter.wait('ready');
     }
-    /** 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;
-            let idx = name.indexOf(':');
-            if (idx < 0 && name.includes('=')) {
-                name = 'param:' + name;
-                idx = 5;
-            }
-            if (idx >= 0) {
-                const v = name.slice(idx + 1);
-                const type = name.slice(0, idx);
-                // predefined middlewares
-                switch (type) {
-                    // redirect:302,https://redirect.to
-                    case 'redirect': {
-                        let redirect = v.split(','), code = parseInt(v[0]);
-                        if (!code || code < 301 || code > 399)
-                            code = 302;
-                        return (req, res) => res.redirect(code, redirect[1] || v);
-                    }
-                    // error:422
-                    case 'error':
-                        return (req, res) => res.error(parseInt(v) || 422);
-                    // param:name=value
-                    case 'param': {
-                        idx = v.indexOf('=');
-                        if (idx > 0) {
-                            const prm = v.slice(0, idx), val = v.slice(idx + 1);
-                            return (req, res, next) => { req.params[prm] = val; return next(); };
-                        }
-                        break;
-                    }
-                    case 'model': {
-                        const model = v;
-                        return (req, res) => {
-                            res.isJson = true;
-                            req.params.model = model;
-                            req.model = Model.models[model];
-                            if (!req.model) {
-                                console.error(`Data model ${model} not defined for request ${req.path}`);
-                                return res.error(422);
-                            }
-                            return req.model.handler(req, res);
-                        };
-                    }
-                    // user:userid
-                    // group:user_groupid
-                    // acl:validacl
-                    case 'user':
-                    case 'group':
-                    case 'acl':
-                        return (req, res, next) => {
-                            if (type === 'user' && v === req.user?.id)
-                                return next();
-                            if (type === 'acl') {
-                                req.params.acl = v;
-                                if (req.auth?.acl(v))
-                                    return next();
-                            }
-                            if (type === 'group') {
-                                req.params.group = v;
-                                if (req.user?.group === v)
-                                    return next();
-                            }
-                            const accept = req.headers.accept || '';
-                            if (!res.isJson && req.auth?.options.redirect && req.method === 'GET' && !accept.includes('json') && (accept.includes('html') || accept.includes('*/*'))) {
-                                if (req.auth.options.redirect && req.url !== req.auth.options.redirect)
-                                    return res.redirect(302, req.auth.options.redirect);
-                                else if (req.auth.options.mode !== 'cookie') {
-                                    res.setHeader('WWW-Authenticate', `Basic realm="${req.auth.options.realm}"`);
-                                    return res.error(401);
-                                }
-                            }
-                            return res.error('Permission denied');
-                        };
-                }
-            }
-            throw new Error('Invalid option: ' + name);
-        }
-        if (fn && typeof fn === 'object' && 'handler' in fn && typeof fn.handler === 'function')
-            return fn.handler.bind(fn);
-        if (typeof fn !== 'function')
-            throw new Error('Invalid middleware: ' + String.toString.call(fn));
-        return fn.bind(this);
-    }
-    /** Add middleware, routes, etc.. see {Router.add} */
+    /** Add middleware, routes, etc.. see {router.use} */
     use(...args) {
-        this.router.use(...args);
-        return this;
+        return this.router.use(...args);
     }
     /** Default server handler */
     handler(req, res) {
@@ -1583,36 +1645,41 @@ export class MicroServer extends EventEmitter {
             }
             this.sockets.clear();
         }).then(() => {
-            this._ready = false;
             this.emit('close');
+            this._waiter.resolve("close");
         });
     }
-    /** Add route, alias to `server.router.add('GET ' + url, ...args)` */
+    /** Add route, alias to `server.router.use(url, ...args)` */
+    all(url, ...args) {
+        this.router.use(url, ...args);
+        return this;
+    }
+    /** Add route, alias to `server.router.use('GET ' + url, ...args)` */
     get(url, ...args) {
         this.router.use('GET ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.add('POST ' + url, ...args)` */
+    /** Add route, alias to `server.router.use('POST ' + url, ...args)` */
     post(url, ...args) {
         this.router.use('POST ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.add('PUT ' + url, ...args)` */
+    /** Add route, alias to `server.router.use('PUT ' + url, ...args)` */
     put(url, ...args) {
         this.router.use('PUT ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.add('PATCH ' + url, ...args)` */
+    /** Add route, alias to `server.router.use('PATCH ' + url, ...args)` */
     patch(url, ...args) {
         this.router.use('PATCH ' + url, ...args);
         return this;
     }
-    /** Add route, alias to `server.router.add('DELETE ' + url, ...args)` */
+    /** Add route, alias to `server.router.use('DELETE ' + url, ...args)` */
     delete(url, ...args) {
         this.router.use('DELETE ' + url, ...args);
         return this;
     }
-    /** Add websocket handler, alias to `server.router.add('WEBSOCKET ' + url, ...args)` */
+    /** Add websocket handler, alias to `server.router.use('WEBSOCKET ' + url, ...args)` */
     websocket(url, ...args) {
         this.router.use('WEBSOCKET ' + url, ...args);
         return this;
@@ -1697,7 +1764,7 @@ class StaticPlugin extends Plugin {
             options = {};
         if (typeof options === 'string')
             options = { path: options };
-        this.mimeTypes = { ...StaticPlugin.mimeTypes, ...options.mimeTypes };
+        this.mimeTypes = options.mimeTypes ? { ...StaticPlugin.mimeTypes, ...options.mimeTypes } : Object.freeze(StaticPlugin.mimeTypes);
         this.root = path.resolve((options.root || options?.path || 'public').replace(/^\//, '')) + path.sep;
         this.ignore = (options.ignore || []).map((p) => path.normalize(path.join(this.root, p)) + path.sep);
         this.index = options.index || 'index.html';
@@ -1714,7 +1781,7 @@ class StaticPlugin extends Plugin {
         let filename = path.normalize(path.join(this.root, (req.params && req.params.path) || req.pathname));
         if (!filename.startsWith(this.root)) // check root access
             return next();
-        const firstch = path.basename(filename)[0];
+        const firstch = basename(filename)[0];
         if (firstch === '.' || firstch === '_') // hidden file
             return next();
         if (filename.endsWith(path.sep))
@@ -1736,27 +1803,61 @@ class StaticPlugin extends Plugin {
                 req.filename = filename;
                 return handler.call(this, req, res, next);
             }
-            const etagMatch = req.headers['if-none-match'];
-            const etagTime = req.headers['if-modified-since'];
-            const etag = '"' + etagPrefix + stats.mtime.getTime().toString(32) + '"';
-            res.setHeader('Content-Type', mimeType);
-            if (this.lastModified || req.params.lastModified)
+            StaticPlugin.serveFile(req, res, {
+                path: filename,
+                mimeType,
+                stats
+            });
+        });
+    }
+    static serveFile(req, res, options) {
+        const filePath = options.root ? path.join(options.root, options.path) : options.path;
+        const statRes = (err, stats) => {
+            if (err)
+                return res.error(err);
+            if (!stats.isFile())
+                return res.error(404);
+            if (!res.getHeader('Content-Type')) {
+                if (options.mimeType)
+                    res.setHeader('Content-Type', options.mimeType);
+                else
+                    res.setHeader('Content-Type', this.mimeTypes[path.extname(options.path)] || 'application/octet-stream');
+            }
+            if (options.filename)
+                res.setHeader('Content-Disposition', 'attachment; filename="' + options.filename + '"');
+            if (options.lastModified !== false)
                 res.setHeader('Last-Modified', stats.mtime.toUTCString());
-            if (this.etag || req.params.etag)
-                res.setHeader('Etag', etag);
-            if (this.maxAge || req.params.maxAge)
-                res.setHeader('Cache-Control', 'max-age=' + (this.maxAge || req.params.maxAge));
+            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()) {
+                    res.statusCode = 304;
+                    res.headersOnly = true;
+                }
+            }
+            if (options.maxAge)
+                res.setHeader('Cache-Control', 'max-age=' + options.maxAge);
             if (res.headersOnly) {
-                res.setHeader('Content-Length', stats.size);
-                return res.end();
+                res.end();
+                return;
             }
-            if (etagMatch === etag || etagTime === stats.mtime.toUTCString()) {
-                res.statusCode = 304;
-                return res.end();
+            const streamOptions = { start: 0, end: stats.size - 1 };
+            if (options.range !== false) {
+                const range = req.headers['range'];
+                if (range && range.startsWith('bytes=')) {
+                    const parts = range.slice(6).split('-');
+                    streamOptions.start = parseInt(parts[0]) || 0;
+                    streamOptions.end = parts[1] ? parseInt(parts[1]) : stats.size - 1;
+                    res.setHeader('Content-Range', `bytes ${streamOptions.start}-${streamOptions.end}/${stats.size}`);
+                    res.setHeader('Content-Length', streamOptions.end - streamOptions.start + 1);
+                }
             }
-            res.setHeader('Content-Length', stats.size);
-            fs.createReadStream(filename).pipe(res);
-        });
+            fs.createReadStream(filePath, streamOptions).pipe(res);
+        };
+        if (!options.stats)
+            fs.stat(filePath, statRes);
+        else
+            statRes(null, options.stats);
     }
 }
 /** Default mime types */
@@ -1770,12 +1871,17 @@ StaticPlugin.mimeTypes = {
     '.css': 'text/css',
     '.png': 'image/png',
     '.jpg': 'image/jpeg',
-    '.mp3': 'audio/mpeg',
     '.svg': 'image/svg+xml',
+    '.mp3': 'audio/mpeg',
+    '.ogg': 'audio/ogg',
+    '.mp4': 'video/mp4',
     '.pdf': 'application/pdf',
     '.woff': 'application/x-font-woff',
     '.woff2': 'application/x-font-woff2',
-    '.ttf': 'application/x-font-ttf'
+    '.ttf': 'application/x-font-ttf',
+    '.gz': 'application/gzip',
+    '.zip': 'application/zip',
+    '.tgz': 'application/gzip',
 };
 MicroServer.plugins.static = StaticPlugin;
 export class ProxyPlugin extends Plugin {
@@ -2201,7 +2307,7 @@ class AuthPlugin extends Plugin {
         if (sid)
             token = sid.slice(sid.indexOf('=') + 1);
         if (!token)
-            token = req.get.token;
+            token = req.query.token;
         if (token) {
             const now = new Date().getTime();
             let usr, expire;
@@ -2794,7 +2900,7 @@ export class Model {
     /** Microserver middleware */
     handler(req, res) {
         res.isJson = true;
-        let filter, filterStr = req.get.filter;
+        let filter, filterStr = req.query.filter;
         if (filterStr) {
             try {
                 if (!filterStr.startsWith('{'))