@radatek/microserver 2.1.0 → 2.2.1

package/{dist/microserver.d.ts → microserver.d.ts}

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.1.0
+ * @version 2.2.1
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -40,8 +40,9 @@ export type Routes = () => {
 export declare abstract class Plugin {
     name?: string;
     priority?: number;
-    handler?(req: ServerRequest, res: ServerResponse, next: Function): void;
-    routes?: () => Routes | Routes;
+    handler?(req: ServerRequest, res: ServerResponse, next: Function): Promise<string | object | void> | string | object | void;
+    routes?(): Promise<Routes> | Routes;
+    initialise?(): Promise<void> | void;
     constructor(router: Router, ...args: any);
 }
 interface PluginClass {
@@ -222,6 +223,14 @@ export interface Middleware {
     priority?: number;
     plugin?: Plugin;
 }
+declare class Waiter {
+    get busy(): boolean;
+    startJob(): void;
+    endJob(id?: string): void;
+    get nextId(): string;
+    wait(id: string): Promise<void>;
+    resolve(id: string): void;
+}
 /** Router */
 export declare class Router extends EventEmitter {
     server: MicroServer;
@@ -229,8 +238,11 @@ export declare class Router extends EventEmitter {
     plugins: {
         [key: string]: Plugin;
     };
+    _waiter: Waiter;
     /** @param {MicroServer} server  */
     constructor(server: MicroServer);
+    /** 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;
     /** Handler */
     handler(req: ServerRequest, res: ServerResponse, next: Function, method?: string): any;
     /** Clear routes and middlewares */
@@ -241,54 +253,55 @@ export declare 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: any): Router;
+    use(...args: any): Promise<void>;
+    waitPlugin(id: string): Promise<Plugin>;
     /** Add hook */
-    hook(url: string, ...mid: Middleware[]): Router;
+    hook(url: string, ...mid: Middleware[]): void;
     /** Check if middleware allready added */
     has(mid: Middleware): boolean;
 }
@@ -364,23 +377,22 @@ export declare class MicroServer extends EventEmitter {
     sockets: Set<net.Socket>;
     /** server instances */
     servers: Set<net.Server>;
+    _waiter: Waiter;
     static plugins: {
         [key: string]: PluginClass;
     };
-    get plugins(): {
-        [key: string]: Plugin;
-    };
     constructor(config: MicroServerConfig);
     /** Add one time listener or call immediatelly for 'ready' */
     once(name: string, cb: Function): this;
     /** Add listener and call immediatelly for 'ready'  */
     on(name: string, cb: Function): this;
+    isReady(): boolean;
+    waitReady(): Promise<void>;
+    waitPlugin(id: string): Promise<void>;
     /** Listen server, should be used only if config.listen is not set */
-    listen(config?: ListenConfig): Promise<unknown>;
-    /** 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;
+    listen(config?: ListenConfig): Promise<void>;
     /** Add middleware, routes, etc.. see {router.use} */
-    use(...args: any): MicroServer;
+    use(...args: any): Promise<void>;
     /** Default server handler */
     handler(req: ServerRequest, res: ServerResponse): void;
     protected requestInit(req: ServerRequest, res?: ServerResponse): void;

package/{dist/microserver.js → microserver.js}

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.1.0
+ * @version 2.2.1
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -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: '/',
@@ -692,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
@@ -903,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  */
@@ -912,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;
@@ -1013,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: {} };
@@ -1049,7 +1182,6 @@ export class Router extends EventEmitter {
         if (!item[key])
             item[key] = [];
         item[key].push(...middlewares);
-        return this;
     }
     /** Clear routes and middlewares */
     clear() {
@@ -1063,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') {
@@ -1142,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;
         }
@@ -1150,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) {
@@ -1169,42 +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);
         }
-        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) {
@@ -1212,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) {
@@ -1220,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) => {
@@ -1255,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);
@@ -1263,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) + '';
@@ -1293,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));
         });
-    }
-    /** 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);
+        return this._waiter.wait('ready');
     }
     /** 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) {
@@ -1592,8 +1645,8 @@ 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.use(url, ...args)` */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@radatek/microserver",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "description": "HTTP MicroServer",
   "author": "Darius Kisonas",
   "license": "MIT",
@@ -11,12 +11,9 @@
     "httpserver"
   ],
   "type": "module",
-  "main": "./dist/microserver.js",
-  "module": "./dist/microserver.js",
-  "types": "./dist/microserver.d.ts",
-  "files": [
-    "dist"
-  ],
+  "main": "microserver.js",
+  "module": "microserver.js",
+  "types": "microserver.d.ts",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/radateklt/microserver.git"

package/readme.md

@@ -1,139 +0,0 @@
-## 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
-  - 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 } from '@radatek/microserver'
-
-const server = new MicroServer({
-  listen: 8080,
-  auth: {
-    users: {
-      usr: {
-        password: 'secret'
-      }
-    }
-  }
-})
-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('static', {root:'public'})
-```
-
-Using data schema:
-
-```js
-import { MicroServer, Model, MicroCollection, FileStore } from '@radatek/microserver'
-
-const usersCollection = new MicroCollection({ store: new FileStore({ dir: 'data' }), name: 'users' })
-// or using MicroDB collection
-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}
-      }
-    }
-  }
-})
-
-class RestApi extends Controller {
-  static acl = '' // default acl
-
-  gethello(id) {
-    return {message:'Hello ' + id + '!'}
-  }
-
-  async postlogin() {
-    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)
-```