@radatek/microserver 2.3.1 → 2.3.3

package/microserver.d.ts

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.3.1
+ * @version 2.3.3
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -128,6 +128,7 @@ export interface WebSocketOptions {
     autoPong?: boolean;
     permessageDeflate?: boolean;
     maxWindowBits?: number;
+    timeout?: number;
     deflate?: boolean;
 }
 /** WebSocket class */
@@ -198,8 +199,8 @@ export declare class WebSocket extends EventEmitter {
  * ```
 */
 export declare class Controller<T extends Model<any> = any> {
-    protected req: ServerRequest<T>;
-    protected res: ServerResponse<T>;
+    req: ServerRequest<T>;
+    res: ServerResponse<T>;
     get model(): T | undefined;
     constructor(req: ServerRequest<T>, res: ServerResponse<T>);
     /** Generate routes for this controller */
@@ -213,12 +214,11 @@ export interface Middleware {
     plugin?: Plugin;
 }
 declare class Waiter {
-    get busy(): boolean;
-    startJob(): void;
+    isBusy(id?: string): boolean;
+    startJob(id?: string): void;
     endJob(id?: string): void;
     get nextId(): string;
-    wait(id: string): Promise<void>;
-    resolve(id: string): void;
+    wait(id?: string): Promise<void>;
 }
 /** Router */
 export declare class Router extends EventEmitter {
@@ -373,7 +373,7 @@ export declare class MicroServer extends EventEmitter {
     once(name: string, cb: Function): this;
     /** Add listener and call immediatelly for 'ready'  */
     on(name: string, cb: Function): this;
-    isReady(): boolean;
+    get isReady(): boolean;
     waitReady(): Promise<void>;
     waitPlugin(id: string): Promise<void>;
     /** Listen server, should be used only if config.listen is not set */
@@ -538,6 +538,33 @@ export interface AuthOptions {
     /** Interal next cache cleanup time */
     cacheCleanup?: number;
 }
+export interface AuthOptionsInternal extends AuthOptions {
+    /** Authentication token */
+    token: Buffer;
+    /** Users */
+    users: (usr: string, psw?: string) => Promise<UserInfo | undefined>;
+    /** Default ACL */
+    defaultAcl: {
+        [key: string]: boolean;
+    };
+    /** Expire time in seconds */
+    expire: number;
+    /** Authentication mode */
+    mode: 'cookie' | 'token';
+    /** Authentication realm for basic authentication */
+    realm: string;
+    /** Redirect URL */
+    redirect: string;
+    /** Authentication cache */
+    cache: {
+        [key: string]: {
+            data: UserInfo;
+            time: number;
+        };
+    };
+    /** Interal next cache cleanup time */
+    cacheCleanup: number;
+}
 /** Authentication class */
 export declare class Auth {
     /** Server request */
@@ -545,10 +572,8 @@ export declare class Auth {
     /** Server response */
     res: ServerResponse | undefined;
     /** Authentication options */
-    options: AuthOptions;
-    /** Get user function */
-    users: ((usr: string, psw?: string, salt?: string) => Promise<UserInfo | undefined>);
-    constructor(options?: AuthOptions);
+    options: AuthOptionsInternal;
+    constructor(options: AuthOptionsInternal, req?: ServerRequest, res?: ServerResponse);
     /** Decode token */
     decode(data: string): {
         data: string;
@@ -708,12 +733,22 @@ export type ModelDocument<T extends ModelSchema> = {
 export declare interface ModelCollections {
     collection(name: string): Promise<MicroCollection>;
 }
+export declare class Models {
+}
 export declare class Model<TSchema extends ModelSchema> {
-    static collections?: ModelCollections;
-    static models: Record<string, Model<any>>;
-    static schema(schema: ModelSchema): ModelSchema;
+    static collections: ModelCollections;
+    static models: Models;
+    static set db(db: any);
+    static get db(): any;
+    /** Dynamic model extension */
+    static dynamic<T extends Model<any>>(model: T, options: {
+        controller?: Controller;
+        collection?: MicroCollection<any>;
+        req?: ServerRequest;
+    } | Controller): T;
+    static register<K extends string, T extends Model<any>>(name: K, model: T): typeof Model;
     /** Define model */
-    static define<T extends ModelSchema>(name: string, schema: T, options?: {
+    static define<K extends string, T extends ModelSchema>(name: K, schema: T, options?: {
         collection?: MicroCollection | Promise<MicroCollection>;
         class?: typeof Model;
     }): Model<T>;
@@ -778,7 +813,7 @@ export declare interface FindOptions {
 }
 /** Collection factory */
 export declare class MicroCollectionStore {
-    constructor(dataPath?: string);
+    constructor(dataPath?: string, storeTimeDelay?: number);
     /** Get collection */
     collection(name: string): Promise<MicroCollection>;
 }

package/microserver.js

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.3.1
+ * @version 2.3.3
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -457,8 +457,10 @@ export class WebSocket extends EventEmitter {
             maxPayload: 1024 * 1024,
             permessageDeflate: false,
             maxWindowBits: 15,
+            timeout: 120000,
             ...options
         };
+        this._socket.setTimeout(this._options.timeout || 120000);
         const key = req.headers['sec-websocket-key'];
         const upgrade = req.headers.upgrade;
         const version = +(req.headers['sec-websocket-version'] || 0);
@@ -836,10 +838,6 @@ export class Controller {
                 method = keyMatch[1];
                 url = keyMatch[2].startsWith('/') ? keyMatch[2] : ('/' + prefix + keyMatch[2]);
             }
-            if (!url && !method) {
-                method = 'GET';
-                url = '/' + prefix + key;
-            }
             if (!method)
                 return;
             let autoAcl = method.toLowerCase();
@@ -906,14 +904,7 @@ export class Controller {
                     req.model = modelName instanceof Model ? modelName : Model.models[modelName];
                     if (!obj.model)
                         throw new InvalidData(modelName, 'model');
-                    const modelOptions = { ...obj.model.options, user: req.user, params: req.params };
-                    req.model = new Proxy(req.model, {
-                        get: (target, prop) => {
-                            if (prop === 'options')
-                                return modelOptions;
-                            return target[prop];
-                        }
-                    });
+                    req.model = Model.dynamic(req.model, { controller: obj });
                 }
                 return func.apply(obj, req.paramsList);
             });
@@ -922,46 +913,53 @@ export class Controller {
         return routes;
     }
 }
-class Waiter {
+class WaiterJob {
     constructor() {
-        this._waiters = {};
-        this._id = 0;
+        this._waiters = [];
         this._busy = 0;
     }
-    get busy() {
-        return this._busy > 0;
-    }
-    startJob() {
+    start() {
         this._busy++;
     }
-    endJob(id) {
+    end() {
         this._busy--;
+        for (const resolve of this._waiters.splice(0))
+            resolve();
+    }
+    async wait() {
         if (!this._busy)
-            this.resolve(id || 'ready');
+            return;
+        return new Promise(resolve => this._waiters.push(resolve));
     }
-    get nextId() {
-        return (++this._id).toString();
+}
+class Waiter {
+    constructor() {
+        this._id = 0;
+        this._waiters = {};
     }
-    async wait(id) {
-        return new Promise(resolve => (this._waiters[id] = this._waiters[id] || []).push(resolve));
+    isBusy(id) {
+        const waiter = this._waiters[id || 'ready'];
+        return !!waiter?._busy;
     }
-    resolve(id) {
-        const resolvers = this._waiters[id];
-        if (resolvers)
-            for (const resolve of resolvers)
-                resolve(undefined);
-        delete this._waiters[id];
+    startJob(id) {
+        let waiter = this._waiters[id || 'ready'];
+        if (!waiter)
+            waiter = this._waiters[id || 'ready'] = new WaiterJob();
+        waiter._busy++;
     }
-}
-class EmitterWaiter extends Waiter {
-    constructor(emitter) {
-        super();
-        this._emitter = emitter;
+    endJob(id) {
+        const waiter = this._waiters[id || 'ready'];
+        if (waiter)
+            waiter.end();
     }
-    resolve(id) {
-        if (id === 'ready')
-            this._emitter.emit(id);
-        super.resolve(id);
+    get nextId() {
+        return (++this._id).toString();
+    }
+    async wait(id) {
+        const waiter = this._waiters[id || 'ready'];
+        if (!waiter)
+            return;
+        return waiter.wait();
     }
 }
 /** Router */
@@ -1361,7 +1359,7 @@ export class Router extends EventEmitter {
         if (plugin.routes)
             await this.use(isFunction(plugin.routes) ? await plugin.routes() : plugin.routes);
         if (added)
-            this._waiter.resolve(added);
+            this.emit(added);
     }
     async waitPlugin(id) {
         if (!this.plugins[id])
@@ -1384,12 +1382,9 @@ export class Router extends EventEmitter {
 export class MicroServer extends EventEmitter {
     constructor(config) {
         super();
-        this._waiter = new EmitterWaiter(this);
+        this._waiter = new Waiter();
         this._methods = {};
         let promise = Promise.resolve();
-        this._init = (f, ...args) => {
-            promise = promise.then(() => f.apply(this, args)).catch(e => this.emit('error', e));
-        };
         this.config = {
             maxBodySize: defaultMaxBodySize,
             methods: defaultMethods,
@@ -1406,17 +1401,20 @@ export class MicroServer extends EventEmitter {
             if (config[key])
                 this.router.use(MicroServer.plugins[key], config[key]);
         }
-        if (config.listen)
-            this._init(() => {
-                this.listen({
-                    tls: config.tls,
-                    listen: config.listen || 8080
-                });
+        if (config.listen) {
+            this._waiter.startJob();
+            this.listen({
+                tls: config.tls,
+                listen: config.listen || 8080
+            }).then(() => {
+                this._waiter.endJob();
             });
+        }
+        this._waiter.wait().then(() => this.emit('ready'));
     }
     /** Add one time listener or call immediatelly for 'ready' */
     once(name, cb) {
-        if (name === 'ready' && this.isReady())
+        if (name === 'ready' && this.isReady)
             cb();
         else
             super.once(name, cb);
@@ -1424,18 +1422,18 @@ export class MicroServer extends EventEmitter {
     }
     /** Add listener and call immediatelly for 'ready'  */
     on(name, cb) {
-        if (name === 'ready' && this.isReady())
+        if (name === 'ready' && this.isReady)
             cb();
         super.on(name, cb);
         return this;
     }
-    isReady() {
-        return !this._waiter.busy;
+    get isReady() {
+        return !this._waiter.isBusy();
     }
     async waitReady() {
-        if (this.isReady())
+        if (this.isReady)
             return;
-        return this._waiter.wait("ready");
+        return this._waiter.wait();
     }
     async waitPlugin(id) {
         await this.router.waitPlugin(id);
@@ -1467,7 +1465,7 @@ export class MicroServer extends EventEmitter {
         }
         const reg = /^((?<proto>\w+):\/\/)?(?<host>(\[[^\]]+\]|[a-z][^:,]+|\d+\.\d+\.\d+\.\d+))?:?(?<port>\d+)?/;
         listen.split(',').forEach(listen => {
-            this._waiter.startJob();
+            this._waiter.startJob('listen');
             let { proto, host, port } = reg.exec(listen)?.groups || {};
             let srv;
             switch (proto) {
@@ -1494,20 +1492,20 @@ export class MicroServer extends EventEmitter {
             }
             this.servers.add(srv);
             if (port === '0') // skip listening
-                this._waiter.endJob();
+                this._waiter.endJob('listen');
             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();
+                    this._waiter.endJob('listen');
                 });
             }
             srv.on('error', err => {
                 srv.close();
                 this.servers.delete(srv);
                 if (!srv._ready)
-                    this._waiter.endJob();
+                    this._waiter.endJob('listen');
                 this.emit('error', err);
             });
             srv.on('connection', s => {
@@ -1516,7 +1514,7 @@ export class MicroServer extends EventEmitter {
             });
             srv.on('upgrade', this.handlerUpgrade.bind(this));
         });
-        return this._waiter.wait('ready');
+        return this._waiter.wait('listen');
     }
     /** Add middleware, routes, etc.. see {router.use} */
     use(...args) {
@@ -1663,7 +1661,6 @@ export class MicroServer extends EventEmitter {
             this.sockets.clear();
         }).then(() => {
             this.emit('close');
-            this._waiter.resolve("close");
         });
     }
     /** Add route, alias to `server.router.use(url, ...args)` */
@@ -2006,31 +2003,12 @@ ProxyPlugin.validHeaders = {
 MicroServer.plugins.proxy = ProxyPlugin;
 /** Authentication class */
 export class Auth {
-    constructor(options) {
-        let token = options?.token || defaultToken;
-        if (!token || token.length !== 32)
-            token = defaultToken;
-        if (token.length !== 32)
-            token = crypto.createHash('sha256').update(token).digest();
-        if (!(token instanceof Buffer))
-            token = Buffer.from(token);
-        this.options = {
-            token,
-            users: options?.users,
-            mode: options?.mode || 'cookie',
-            defaultAcl: options?.defaultAcl || { '*': false },
-            expire: options?.expire || defaultExpire,
-            cache: options?.cache || {}
-        };
-        if (typeof options?.users === 'function')
-            this.users = options.users;
-        else
-            this.users = async (usrid, psw) => {
-                const users = this.options.users;
-                const usr = users?.[usrid];
-                if (usr && (psw === undefined || this.checkPassword(usrid, psw, usr.password || '')))
-                    return usr;
-            };
+    constructor(options, req, res) {
+        this.options = options;
+        this.req = req;
+        this.res = res;
+        if (req)
+            req.auth = this;
     }
     /** Decode token */
     decode(data) {
@@ -2106,7 +2084,7 @@ export class Auth {
             data = JSON.stringify(usr);
         else if (typeof usr === 'string') {
             if (psw !== undefined) {
-                const userInfo = await this.users(usr, psw);
+                const userInfo = await this.options.users(usr, psw);
                 data = userInfo?.id || userInfo?._id;
             }
             else
@@ -2123,7 +2101,7 @@ export class Auth {
         if (typeof usr === 'object')
             usrInfo = usr;
         if (typeof usr === 'string')
-            usrInfo = await this.users(usr, psw, options?.salt);
+            usrInfo = await this.options.users(usr, psw);
         if (usrInfo?.id || usrInfo?._id) {
             const expire = Math.min(34560000, options?.expire || this.options.expire || defaultExpire);
             const expireTime = new Date().getTime() + expire * 1000;
@@ -2289,17 +2267,32 @@ class AuthPlugin extends Plugin {
             ...options,
             cacheCleanup: new Date().getTime()
         };
-        if (this.options.token === defaultToken)
+        if (options?.token === defaultToken)
             console.warn('Default token in auth plugin');
+        let token = options?.token || defaultToken;
+        if (!token || token.length !== 32)
+            token = defaultToken;
+        if (token.length !== 32)
+            token = crypto.createHash('sha256').update(token).digest();
+        if (!(token instanceof Buffer))
+            token = Buffer.from(token);
+        this.options.token = token;
+        if (typeof options?.users === 'function')
+            this.options.users = (usr, psw) => options.users(usr, psw);
+        else {
+            this.options.users = async (usrid, psw) => {
+                const users = this.options.users;
+                const usr = users?.[usrid];
+                if (usr && (psw === undefined || router.auth?.checkPassword(usrid, psw, usr.password || '')))
+                    return usr;
+            };
+        }
         router.auth = new Auth(this.options);
     }
     /** Authentication middleware */
     async handler(req, res, next) {
         const options = this.options, cache = options.cache;
-        const auth = new Auth(options);
-        req.auth = auth;
-        auth.req = req;
-        auth.res = res;
+        const auth = new Auth(this.options, req, res);
         const authorization = req.headers.authorization || '';
         if (authorization.startsWith('Basic ')) {
             let usr = cache?.[authorization];
@@ -2308,7 +2301,7 @@ class AuthPlugin extends Plugin {
             else {
                 const usrpsw = Buffer.from(authorization.slice(6), 'base64').toString('utf-8'), pos = usrpsw.indexOf(':'), username = usrpsw.slice(0, pos), psw = usrpsw.slice(pos + 1);
                 if (username && psw)
-                    req.user = await auth.users(username, psw);
+                    req.user = await auth.options.users(username, psw);
                 if (!req.user)
                     return res.error(401);
                 if (cache) // 1 hour to expire in cache
@@ -2354,7 +2347,7 @@ class AuthPlugin extends Plugin {
                     catch (e) { }
                 }
                 else {
-                    req.user = await auth.users(usrData.data);
+                    req.user = await auth.options.users(usrData.data);
                     if (!req.user) {
                         req.auth.logout();
                         return new AccessDenied();
@@ -2383,7 +2376,7 @@ export class FileStore {
         this._dir = options?.dir || 'data';
         this._cacheTimeout = options?.cacheTimeout || 2000;
         this._cacheItems = options?.cacheItems || 10;
-        this._debounceTimeout = options?.debounceTimeout || 1000;
+        this._debounceTimeout = options?.debounceTimeout ?? 1000;
         this._iter = 0;
     }
     /** cleanup cache */
@@ -2435,16 +2428,16 @@ export class FileStore {
             if (item && new Date().getTime() - item.atime < this._cacheTimeout)
                 return item.data;
             try {
-                const stat = await fs.promises.lstat(path.join(this._dir, name));
-                if (item?.mtime !== stat.mtime.getTime()) {
-                    let data = JSON.parse(await fs.promises.readFile(path.join(this._dir, name), 'utf8') || '{}');
+                const stat = await fs.promises.lstat(path.join(this._dir, name)).catch(() => null);
+                if (!stat || item?.mtime !== stat.mtime.getTime()) {
+                    let data = stat ? JSON.parse(await fs.promises.readFile(path.join(this._dir, name), 'utf8').catch(() => '') || '{}') : {};
                     this._iter++;
                     this.cleanup();
                     if (autosave)
                         data = this.observe(data, () => this.save(name, data));
                     this._cache[name] = {
                         atime: new Date().getTime(),
-                        mtime: stat.mtime.getTime(),
+                        mtime: stat?.mtime.getTime() || new Date().getTime(),
                         data: data
                     };
                     return data;
@@ -2573,19 +2566,64 @@ function newObjectId() {
             break;
     return (new Date().getTime() / 1000 | 0).toString(16) + globalObjectId.toString('hex');
 }
+class ModelCollectionsInternal {
+    constructor() {
+        this._wait = new Promise(resolve => this._ready = resolve);
+    }
+    set db(db) {
+        Promise.resolve(db).then(db => this._ready(this._db = db));
+    }
+    get db() {
+        return this._db;
+    }
+    async collection(name) {
+        const db = await this._wait;
+        return db.collection(name);
+    }
+}
+export class Models {
+}
 export class Model {
-    static schema(schema) {
-        return schema;
+    static set db(db) {
+        this.collections.db = db;
+    }
+    static get db() {
+        return this.collections.db;
+    }
+    /** Dynamic model extension */
+    static dynamic(model, options) {
+        if (options instanceof Controller)
+            options = { controller: options };
+        const collection = options?.collection || model.collection;
+        const modelOptions = { ...model.options };
+        const req = options.req || options.controller?.req;
+        if (req) {
+            modelOptions.user = req.user;
+            modelOptions.params = req.params;
+        }
+        return new Proxy(model, {
+            get: (target, prop) => {
+                if (prop === 'collection')
+                    return collection;
+                if (prop === 'options')
+                    return modelOptions;
+                return target[prop];
+            }
+        });
+    }
+    static register(name, model) {
+        Model.models[name] = model;
+        return this;
     }
     /** Define model */
     static define(name, schema, options) {
         options = options || {};
-        if (!options.collection && this.collections)
+        if (!options.collection)
             options.collection = this.collections.collection(name);
         const inst = options?.class
             ? new options.class(schema, { name, ...options })
             : new Model(schema, { name, ...options });
-        Model.models[name] = inst;
+        this.register(name, inst);
         return inst;
     }
     /** Create model acording to description */
@@ -2963,13 +3001,16 @@ export class Model {
         }
     }
 }
+Model.collections = new ModelCollectionsInternal();
 Model.models = {};
 /** Collection factory */
 export class MicroCollectionStore {
-    constructor(dataPath) {
+    constructor(dataPath, storeTimeDelay) {
         this._collections = new Map();
         if (dataPath)
-            this._store = new FileStore({ dir: dataPath.replace(/^\w+:\/\//, '') });
+            this._store = new FileStore({ dir: dataPath.replace(/^\w+:\/\//, ''), debounceTimeout: storeTimeDelay ?? 1000 });
+        if (!Model.db)
+            Model.db = this;
     }
     /** Get collection */
     async collection(name) {

package/package.json

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