@radatek/microserver 2.3.0 → 2.3.1

package/microserver.d.ts

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.3.0
+ * @version 2.3.1
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -739,9 +739,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 +750,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 +769,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 */
@@ -802,20 +798,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.1
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -2916,6 +2916,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) {
@@ -3035,54 +3038,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 +3077,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.1",
   "description": "HTTP MicroServer",
   "author": "Darius Kisonas",
   "license": "MIT",