@radatek/microserver 2.3.0 → 2.3.2

package/microserver.d.ts

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.3.0
+ * @version 2.3.2
  * @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 */
@@ -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;
@@ -709,9 +734,10 @@ export declare interface ModelCollections {
     collection(name: string): Promise<MicroCollection>;
 }
 export declare class Model<TSchema extends ModelSchema> {
-    static collections?: ModelCollections;
+    static collections: ModelCollections;
     static models: Record<string, Model<any>>;
-    static schema(schema: ModelSchema): ModelSchema;
+    static set db(db: any);
+    static get db(): any;
     /** Define model */
     static define<T extends ModelSchema>(name: string, schema: T, options?: {
         collection?: MicroCollection | Promise<MicroCollection>;
@@ -739,9 +765,9 @@ export declare class Model<TSchema extends ModelSchema> {
     /** Find many documents */
     findMany(query: Query, options?: ModelContextOptions): Promise<ModelDocument<TSchema>[]>;
     /** Insert a new document */
-    insert(data: Record<string, any>, options?: ModelContextOptions): Promise<void>;
+    insert(data: Record<string, any>, options?: ModelContextOptions): Promise<ModelDocument<TSchema>>;
     /** Update one matching document */
-    update(query: Record<string, any>, options?: ModelContextOptions): Promise<void>;
+    update(query: Record<string, any>, options?: ModelContextOptions): Promise<ModelDocument<TSchema>>;
     /** Delete one matching document */
     delete(query: Query, options?: ModelContextOptions): Promise<void>;
     /** Microserver middleware */
@@ -750,10 +776,6 @@ export declare class Model<TSchema extends ModelSchema> {
 export declare interface MicroCollectionOptions<T extends ModelSchema = any> {
     /** Collection name */
     name?: string;
-    /** Collection persistent store */
-    store?: FileStore;
-    /** Custom data loader */
-    load?: (col: MicroCollection) => Promise<object>;
     /** Custom data saver */
     save?: (id: string, doc: ModelDocument<T> | undefined, col: MicroCollection) => Promise<ModelDocument<T>>;
     /** Preloaded data object */
@@ -773,8 +795,8 @@ export declare interface FindOptions {
     query?: Query;
     /** is upsert */
     upsert?: boolean;
-    /** is new */
-    new?: boolean;
+    /** is upsert */
+    delete?: boolean;
     /** update object */
     update?: Query;
     /** maximum number of hits */
@@ -782,7 +804,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>;
 }
@@ -802,20 +824,20 @@ export declare class MicroCollection<TSchema extends ModelSchema = any> {
     /** Find all matching documents */
     find(query: Query): Cursor<TSchema>;
     /** Find and modify one matching document */
-    findAndModify(options: FindOptions): Promise<number>;
+    findAndModify(options: FindOptions): Promise<ModelDocument<TSchema> | undefined>;
     /** Insert one document */
     insertOne(doc: ModelDocument<TSchema>): Promise<ModelDocument<TSchema>>;
     /** Insert multiple documents */
     insertMany(docs: ModelDocument<TSchema>[]): Promise<ModelDocument<TSchema>[]>;
     /** Delete one matching document */
-    deleteOne(query: Query): Promise<void>;
+    deleteOne(query: Query): Promise<number>;
     /** Delete all matching documents */
     deleteMany(query: Query): Promise<number>;
-    updateOne(query: Query, doc: ModelDocument<TSchema>, options?: FindOptions): Promise<{
+    updateOne(query: Query, update: Record<string, any>, options?: FindOptions): Promise<{
         upsertedId: any;
         modifiedCount: number;
     }>;
-    updateMany(query: Query, update: any, options?: FindOptions): Promise<{
+    updateMany(query: Query, update: Record<string, any>, options?: FindOptions): Promise<{
         upsertedId: any;
         modifiedCount: number;
     }>;

package/microserver.js

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.3.0
+ * @version 2.3.2
  * @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);
@@ -922,46 +924,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();
+    }
+    get nextId() {
+        return (++this._id).toString();
     }
-    resolve(id) {
-        if (id === 'ready')
-            this._emitter.emit(id);
-        super.resolve(id);
+    async wait(id) {
+        const waiter = this._waiters[id || 'ready'];
+        if (!waiter)
+            return;
+        return waiter.wait();
     }
 }
 /** Router */
@@ -1361,7 +1370,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 +1393,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 +1412,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 +1433,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 +1476,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 +1503,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 +1525,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 +1672,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 +2014,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 +2095,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 +2112,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 +2278,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 +2312,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 +2358,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 +2387,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 +2439,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,14 +2577,32 @@ 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 Model {
-    static schema(schema) {
-        return schema;
+    static set db(db) {
+        this.collections.db = db;
+    }
+    static get db() {
+        return this.collections.db;
     }
     /** 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 })
@@ -2916,6 +2938,9 @@ export class Model {
             }
         }
         const res = await this.collection.findAndModify({ query: this.getFilter(query, { required: true, validate: false, default: false }), update: query, upsert: options?.insert });
+        if (!res)
+            throw new NotFound('Document not found');
+        return res;
     }
     /** Delete one matching document */
     async delete(query, options) {
@@ -2960,13 +2985,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) {
@@ -3035,54 +3063,20 @@ export class MicroCollection {
     }
     /** Find and modify one matching document */
     async findAndModify(options) {
-        if (!options.query)
-            return 0;
-        const id = ((options.upsert || options.new) && !options.query._id) ? newObjectId() : options.query._id;
-        if (!id) {
-            let count = 0;
-            let promise = Promise.resolve();
-            this.find(options.query).forEach((doc) => {
-                if (this.queryDocument(options.query, doc)) {
-                    Object.assign(doc, options.update);
-                    if (this._save) {
-                        promise = promise.then(async () => {
-                            if (!doc._id)
-                                throw new Error('Internal error: missing _id in document');
-                            this.data[doc._id] = await this._save?.(doc._id, doc, this) || this.data[doc._id];
-                        });
-                    }
-                    count++;
-                    if (options.limit && count >= options.limit)
-                        return false;
-                }
-            });
-            await promise;
-            return count;
-        }
-        let doc = this.queryDocument(options.query, this.data[id]);
-        if (!doc) {
-            if (!options.upsert && !options.new)
-                throw new InvalidData(`Document not found`);
-            doc = { _id: id };
-            this.data[id] = doc;
-        }
-        else {
-            if (options.new)
-                throw new InvalidData(`Document dupplicate`);
-        }
-        if (options.update) {
-            for (const n in options.update) {
+        const res = await this.findOne(options.query || {});
+        if (res?._id) {
+            await this.updateOne({ _id: res._id }, options.update || {}, options);
+            return this.data[res._id];
+        }
+        if (options.upsert) {
+            const doc = { ...options.query };
+            for (const n in options.update)
                 if (!n.startsWith('$'))
                     doc[n] = options.update[n];
-            }
-            if (options.update.$unset) {
-                for (const n in options.update.$unset)
-                    delete doc[n];
-            }
+            if (options.update?.$set)
+                Object.assign(doc, options.update.$set);
+            return this.insertOne(doc);
         }
-        if (this._save)
-            this.data[id] = await this._save(id, doc, this) || doc;
-        return 1;
     }
     /** Insert one document */
     async insertOne(doc) {
@@ -3108,49 +3102,72 @@ export class MicroCollection {
     }
     /** Delete one matching document */
     async deleteOne(query) {
-        const id = query._id;
-        if (!id)
-            return;
-        delete this.data[id];
+        return (await this.updateMany(query, {}, { delete: true, limit: 1 })).modifiedCount;
     }
     /** Delete all matching documents */
     async deleteMany(query) {
-        let count = 0;
+        return (await this.updateMany(query, {}, { delete: true })).modifiedCount;
+    }
+    async updateOne(query, update, options) {
+        const res = await this.updateMany(query, update, { ...options, limit: 1 });
+        return res;
+    }
+    async updateMany(query, update, options) {
+        let res = { upsertedId: undefined, modifiedCount: 0 };
+        if (!query)
+            return res;
         let promise = Promise.resolve();
         this.find(query).forEach((doc) => {
             if (this.queryDocument(query, doc)) {
-                count++;
-                if (!doc._id)
-                    return;
-                delete this.data[doc._id];
-                if (this._save)
-                    promise = promise.then(async () => { doc._id && this._save?.(doc._id, undefined, this); });
+                if (options?.delete) {
+                    if (!doc._id)
+                        return;
+                    res.modifiedCount++;
+                    if (this._save)
+                        promise = promise.then(async () => { doc._id && this._save?.(doc._id, undefined, this); });
+                    delete this.data[doc._id];
+                }
+                else {
+                    Object.assign(doc, update);
+                    res.modifiedCount++;
+                    if (this._save) {
+                        promise = promise.then(async () => {
+                            if (!doc._id)
+                                throw new Error('Internal error: missing _id in document');
+                            this.data[doc._id] = await this._save?.(doc._id, doc, this) || this.data[doc._id];
+                        });
+                    }
+                }
+                if (options?.limit && res.modifiedCount >= options?.limit)
+                    return false;
             }
         });
         await promise;
-        return count;
-    }
-    async updateOne(query, doc, options) {
-        const count = await this.findAndModify({
-            query,
-            update: doc,
-            upsert: options?.upsert,
-            limit: 1
-        });
-        return {
-            upsertedId: undefined,
-            modifiedCount: count
-        };
-    }
-    async updateMany(query, update, options) {
-        const count = await this.findAndModify({
-            ...options,
-            query,
-            update
-        });
-        return {
-            upsertedId: undefined,
-            modifiedCount: count
-        };
+        if (res.modifiedCount || !options?.upsert || options?.delete)
+            return res;
+        if (!query._id)
+            query._id = res.upsertedId = newObjectId();
+        let doc = this.queryDocument(options.query, this.data[query._id]);
+        if (doc)
+            throw new InvalidData(`Document dupplicate`);
+        doc = { _id: query._id, ...query };
+        this.data[query._id] = doc;
+        if (update) {
+            for (const n in update) {
+                if (!n.startsWith('$'))
+                    doc[n] = update[n];
+            }
+            if (update.$set) {
+                for (const n in update.$set)
+                    doc[n] = update.$set[n];
+            }
+            if (update.$unset) {
+                for (const n in update.$unset)
+                    delete doc[n];
+            }
+        }
+        if (this._save)
+            this.data[query._id] = await this._save(query._id, doc, this) || doc;
+        return res;
     }
 }

package/package.json

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