@radatek/microserver 2.2.2 → 2.3.1

package/microserver.d.ts

@@ -1,6 +1,6 @@
 /**
  * MicroServer
- * @version 2.2.2
+ * @version 2.3.1
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -32,11 +32,7 @@ export declare class WebSocketError extends Error {
     statusCode: number;
     constructor(text?: string, code?: number);
 }
-export type Routes = () => {
-    [key: string]: Array<any>;
-} | {
-    [key: string]: Array<any>;
-};
+export type Routes = () => Record<string, Array<any>> | Array<Array<any>>;
 export declare abstract class Plugin {
     name?: string;
     priority?: number;
@@ -48,8 +44,9 @@ export declare abstract class Plugin {
 interface PluginClass {
     new (router: Router, ...args: any): Plugin;
 }
+export type ServerRequestBody<T = any> = T extends Model<infer U extends ModelSchema> ? ModelDocument<U> : Record<string, any>;
 /** Extended http.IncomingMessage */
-export declare class ServerRequest extends http.IncomingMessage {
+export declare class ServerRequest<T = any> extends http.IncomingMessage {
     /** Request protocol: http or https */
     protocol: string;
     /** Request client IP */
@@ -67,13 +64,9 @@ export declare class ServerRequest extends http.IncomingMessage {
     /** Original url */
     originalUrl?: string;
     /** Query parameters */
-    query: {
-        [key: string]: string;
-    };
+    query: Record<string, string>;
     /** Router named parameters */
-    params: {
-        [key: string]: string;
-    };
+    params: Record<string, string>;
     /** Router named parameters list */
     paramsList: string[];
     /** Router */
@@ -83,7 +76,7 @@ export declare class ServerRequest extends http.IncomingMessage {
     /** Authenticated user info */
     user?: UserInfo;
     /** Model used for request */
-    model?: Model;
+    model?: T;
     /** Authentication token id */
     tokenId?: string;
     /** Request raw body */
@@ -96,13 +89,9 @@ export declare class ServerRequest extends http.IncomingMessage {
     /** Rewrite request url */
     rewrite(url: string): void;
     /** Request body: JSON or POST parameters */
-    get body(): {
-        [key: string]: any;
-    };
+    get body(): ServerRequestBody<T>;
     /** Alias to body */
-    get post(): {
-        [key: string]: any;
-    };
+    get post(): ServerRequestBody<T>;
     /** Get websocket */
     get websocket(): WebSocket;
     /** get files list in request */
@@ -111,8 +100,8 @@ export declare class ServerRequest extends http.IncomingMessage {
     bodyDecode(res: ServerResponse, options: any, next: () => void): void;
 }
 /** Extends http.ServerResponse */
-export declare class ServerResponse extends http.ServerResponse {
-    req: ServerRequest;
+export declare class ServerResponse<T = any> extends http.ServerResponse {
+    req: ServerRequest<T>;
     router: Router;
     isJson: boolean;
     headersOnly: boolean;
@@ -208,11 +197,11 @@ export declare class WebSocket extends EventEmitter {
  * }
  * ```
 */
-export declare class Controller {
-    protected req: ServerRequest;
-    protected res: ServerResponse;
-    model?: Model;
-    constructor(req: ServerRequest, res: ServerResponse);
+export declare class Controller<T extends Model<any> = any> {
+    protected req: ServerRequest<T>;
+    protected res: ServerResponse<T>;
+    get model(): T | undefined;
+    constructor(req: ServerRequest<T>, res: ServerResponse<T>);
     /** Generate routes for this controller */
     static routes(): any[];
 }
@@ -235,9 +224,7 @@ declare class Waiter {
 export declare class Router extends EventEmitter {
     server: MicroServer;
     auth?: Auth;
-    plugins: {
-        [key: string]: Plugin;
-    };
+    plugins: Record<string, Plugin>;
     _waiter: Waiter;
     /** @param {MicroServer} server  */
     constructor(server: MicroServer);
@@ -626,16 +613,14 @@ export declare class FileStore {
     /** save data */
     save(name: string, data: any): Promise<any>;
     /** load all files in directory */
-    all(name: string, autosave?: boolean): Promise<{
-        [key: string]: any;
-    }>;
+    all(name: string, autosave?: boolean): Promise<Record<string, any>>;
     /** delete data file */
     delete(name: string): Promise<void>;
     /** Observe data object */
     observe(data: object, cb: (data: object, key: string, value: any) => void): object;
 }
 /** Model validation options */
-interface ModelValidateOptions {
+interface ModelContextOptions {
     /** User info */
     user?: UserInfo;
     /** Request params */
@@ -651,23 +636,27 @@ interface ModelValidateOptions {
     /** is required */
     required?: boolean;
     /** projection fields */
-    projection?: Document;
+    projection?: Record<string, 0 | 1 | true | false>;
 }
 /** Model field validation options */
-interface ModelValidateFieldOptions extends ModelValidateOptions {
+interface ModelValidateFieldOptions extends ModelContextOptions {
     name: string;
-    field: FieldDescriptionInternal;
-    model: Model;
+    field: ResolvedFieldSchema;
+    model: Model<any>;
 }
 export interface ModelCallbackFunc {
     (options: any): any;
 }
+type ModelBasicCtorType = typeof String | typeof Number | typeof Boolean | typeof Date;
+type ModelBasicNamedType = 'string' | 'String' | 'number' | 'Number' | 'int' | 'Int' | 'integer' | 'Integer' | 'boolean' | 'Boolean' | 'object' | 'Object' | 'objectid' | 'ObjectId' | 'date' | 'Date' | 'any' | 'Any';
+type ModelBasicType = ModelBasicNamedType | ModelBasicCtorType | Model<any>;
+type ModelFieldSimpleType = ModelBasicType | [ModelBasicType] | [ModelBasicType, ...never[]];
 /** Model field description */
-export interface FieldDescriptionObject {
+export interface ModelFieldSchema {
     /** Field type */
-    type: string | Function | Model | Array<string | Function | Model>;
+    type: ModelFieldSimpleType;
     /** Is array */
-    array?: boolean;
+    array?: true | false;
     /** Is required */
     required?: boolean | string | ModelCallbackFunc;
     /** Can read */
@@ -677,7 +666,7 @@ export interface FieldDescriptionObject {
     /** Default value */
     default?: number | string | ModelCallbackFunc;
     /** Validate function */
-    validate?: (value: any, options: ModelValidateOptions) => string | number | object | null | Error | typeof Error;
+    validate?: (value: any, options: ModelContextOptions) => string | number | object | null | Error | typeof Error;
     /** Valid values */
     enum?: Array<string | number>;
     /** Minimum value for string and number */
@@ -687,87 +676,92 @@ export interface FieldDescriptionObject {
     /** Regex validation or 'email', 'url', 'date', 'time', 'date-time' */
     format?: string;
 }
-type FieldDescription = FieldDescriptionObject | string | Function | Model | FieldDescription[];
-interface FieldDescriptionInternal {
+interface ResolvedFieldSchema {
     type: string;
-    model?: Model;
+    model?: Model<any>;
     required?: ModelCallbackFunc;
     canRead: ModelCallbackFunc;
     canWrite: ModelCallbackFunc;
     default: ModelCallbackFunc;
     validate: (value: any, options: ModelValidateFieldOptions) => any;
 }
+export interface ModelSchema {
+    [K: string]: ModelFieldSchema | ModelFieldSimpleType;
+}
+type ModelDocumentTypeByName<T> = T extends 'string' | 'String' ? string : T extends 'number' | 'Number' | 'int' | 'Int' ? number : T extends 'boolean' | 'Boolean' ? boolean : T extends 'date' | 'Date' ? Date : T extends 'objectid' | 'ObjectId' ? string : T extends 'object' | 'Object' ? Record<string, any> : T extends 'any' | 'Any' ? any : never;
+type ModelDocumentTypeByCtor<T> = T extends typeof String ? string : T extends typeof Number ? number : T extends typeof Boolean ? boolean : T extends typeof Date ? Date : T extends typeof Object ? Record<string, any> : never;
+type ModelFieldTypeExtract<T extends ModelFieldSchema> = T['type'] extends string ? ModelDocumentTypeByName<T['type']> : T['type'] extends Array<infer U> ? Array<ModelDocumentType<U>> : T['type'] extends Function ? ModelDocumentTypeByCtor<T['type']> : T['type'] extends Model<infer U> ? ModelDocument<U> : never;
+type ModelDocumentType<T> = T extends string ? ModelDocumentTypeByName<T> : T extends Array<infer U> ? Array<ModelDocumentType<U>> : T extends Function ? ModelDocumentTypeByCtor<T> : T extends ModelFieldSchema ? ModelFieldTypeExtract<T> : T extends Model<infer U> ? ModelDocument<U> : never;
+export interface ModelDocumentField<T extends ModelFieldSchema> {
+    value: T['array'] extends true ? Array<ModelFieldTypeExtract<T>> : ModelFieldTypeExtract<T>;
+    required?: T['required'];
+    canRead?: T['canRead'];
+    canWrite?: T['canWrite'];
+    default?: T['default'];
+    validate?: T['validate'];
+}
+export type ModelDocument<T extends ModelSchema> = {
+    [K in keyof T]: ModelDocumentType<T[K]>;
+} & {
+    _id?: string;
+};
 export declare interface ModelCollections {
     collection(name: string): Promise<MicroCollection>;
 }
-export declare class Model {
+export declare class Model<TSchema extends ModelSchema> {
     static collections?: ModelCollections;
-    static models: {
-        [key: string]: Model;
-    };
+    static models: Record<string, Model<any>>;
+    static schema(schema: ModelSchema): ModelSchema;
     /** Define model */
-    static define(name: string, fields: {
-        [key: string]: FieldDescription;
-    }, options?: {
+    static define<T extends ModelSchema>(name: string, schema: T, options?: {
         collection?: MicroCollection | Promise<MicroCollection>;
         class?: typeof Model;
-    }): Model;
+    }): Model<T>;
     /** Model fields description */
-    model: {
-        [key: string]: FieldDescriptionInternal;
-    };
-    /** Model name */
-    name: string;
+    model: Record<string, ResolvedFieldSchema>;
     /** Model collection for persistance */
     collection?: MicroCollection | Promise<MicroCollection>;
+    /** Custom options */
+    options: Record<string, any>;
     /** Create model acording to description */
-    constructor(fields: {
-        [key: string]: FieldDescription;
-    }, options?: {
+    constructor(schema: TSchema, options?: {
         collection?: MicroCollection | Promise<MicroCollection>;
         name?: string;
     });
+    /** Get model name */
+    get name(): any;
     /** Validate data over model */
-    validate(data: Document, options?: ModelValidateOptions): Document;
+    document(data: Record<string, any>, options?: ModelContextOptions): ModelDocument<TSchema>;
     /** Generate filter for data queries */
-    getFilter(data: Document, options?: ModelValidateOptions): Document;
+    getFilter(data: Record<string, any>, options?: ModelContextOptions): Record<string, any>;
     /** Find one document */
-    findOne(query: Query, options?: ModelValidateOptions): Promise<Document | undefined>;
+    findOne(query: Query, options?: ModelContextOptions): Promise<ModelDocument<TSchema> | undefined>;
     /** Find many documents */
-    findMany(query: Query, options?: ModelValidateOptions): Promise<Document[]>;
+    findMany(query: Query, options?: ModelContextOptions): Promise<ModelDocument<TSchema>[]>;
     /** Insert a new document */
-    insert(data: Document, options?: ModelValidateOptions): Promise<void>;
+    insert(data: Record<string, any>, options?: ModelContextOptions): Promise<ModelDocument<TSchema>>;
     /** Update one matching document */
-    update(query: Query, options?: ModelValidateOptions): Promise<void>;
+    update(query: Record<string, any>, options?: ModelContextOptions): Promise<ModelDocument<TSchema>>;
     /** Delete one matching document */
-    delete(query: Query, options?: ModelValidateOptions): Promise<void>;
+    delete(query: Query, options?: ModelContextOptions): Promise<void>;
     /** Microserver middleware */
     handler(req: ServerRequest, res: ServerResponse): any;
 }
-export declare interface MicroCollectionOptions {
+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: Document | undefined, col: MicroCollection) => Promise<Document>;
+    save?: (id: string, doc: ModelDocument<T> | undefined, col: MicroCollection) => Promise<ModelDocument<T>>;
     /** Preloaded data object */
-    data?: {
-        [key: string]: Document;
-    };
+    data?: Record<string, ModelDocument<T>>;
 }
 export declare interface Query {
     [key: string]: any;
 }
-export declare interface Document {
-    [key: string]: any;
-}
 /** Cursor */
-export declare interface Cursor {
+export declare interface Cursor<T extends ModelSchema> {
     forEach(cb: Function, self?: any): Promise<number>;
-    all(): Promise<Document[]>;
+    all(): Promise<ModelDocument<T>[]>;
 }
 /** Find options */
 export declare interface FindOptions {
@@ -775,49 +769,49 @@ 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 */
     limit?: number;
 }
+/** Collection factory */
+export declare class MicroCollectionStore {
+    constructor(dataPath?: string);
+    /** Get collection */
+    collection(name: string): Promise<MicroCollection>;
+}
 /** minimalistic indexed mongo type collection with persistance for usage with Model */
-export declare class MicroCollection {
+export declare class MicroCollection<TSchema extends ModelSchema = any> {
     /** Collection name */
     name: string;
     /** Collection data */
-    data: {
-        [key: string]: Document;
-    };
-    /** Get collections factory */
-    static collections(options: MicroCollectionOptions): ModelCollections;
-    constructor(options?: MicroCollectionOptions);
-    /** check for collection is ready */
-    protected checkReady(): Promise<void>;
+    data: Record<string, ModelDocument<TSchema>>;
+    constructor(options?: MicroCollectionOptions<TSchema>);
     /** Query document with query filter */
-    protected queryDocument(query?: Query, data?: Document): Document;
+    protected queryDocument(query?: Query, data?: ModelDocument<TSchema>): ModelDocument<TSchema>;
     /** Count all documents */
     countDocuments(): Promise<number>;
     /** Find one matching document */
-    findOne(query: Query): Promise<Document | undefined>;
+    findOne(query: Query): Promise<ModelDocument<TSchema> | undefined>;
     /** Find all matching documents */
-    find(query: Query): Cursor;
+    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: Document): Promise<Document>;
+    insertOne(doc: ModelDocument<TSchema>): Promise<ModelDocument<TSchema>>;
     /** Insert multiple documents */
-    insertMany(docs: Document[]): Promise<Document[]>;
+    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: Document, 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.2.2
+ * @version 2.3.1
  * @package @radatek/microserver
  * @copyright Darius Kisonas 2022
  * @license MIT
@@ -789,6 +789,9 @@ const server = {};
  * ```
 */
 export class Controller {
+    get model() {
+        return this.req.model;
+    }
     constructor(req, res) {
         this.req = req;
         this.res = res;
@@ -810,7 +813,7 @@ export class Controller {
             let acl = thisStatic['acl:' + key] ?? thisStatic['acl'];
             const user = thisStatic['user:' + key] ?? thisStatic['user'];
             const group = thisStatic['group:' + key] ?? thisStatic['group'];
-            const model = thisStatic['model:' + key] ?? thisStatic['model'];
+            const modelName = thisStatic['model:' + key] ?? thisStatic['model'];
             let method = '';
             if (!url)
                 key = key.replaceAll('$', '/');
@@ -899,10 +902,18 @@ export class Controller {
             list.push((req, res) => {
                 res.isJson = true;
                 const obj = new this(req, res);
-                if (model) {
-                    req.model = obj.model = model instanceof Model ? model : Model.models[model];
+                if (modelName) {
+                    req.model = modelName instanceof Model ? modelName : Model.models[modelName];
                     if (!obj.model)
-                        throw new InvalidData(model, '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];
+                        }
+                    });
                 }
                 return func.apply(obj, req.paramsList);
             });
@@ -2563,26 +2574,31 @@ function newObjectId() {
     return (new Date().getTime() / 1000 | 0).toString(16) + globalObjectId.toString('hex');
 }
 export class Model {
+    static schema(schema) {
+        return schema;
+    }
     /** Define model */
-    static define(name, fields, options) {
+    static define(name, schema, options) {
         options = options || {};
         if (!options.collection && this.collections)
             options.collection = this.collections.collection(name);
         const inst = options?.class
-            ? new options.class(fields, { name, ...options })
-            : new Model(fields, { name, ...options });
+            ? new options.class(schema, { name, ...options })
+            : new Model(schema, { name, ...options });
         Model.models[name] = inst;
         return inst;
     }
     /** Create model acording to description */
-    constructor(fields, options) {
+    constructor(schema, options) {
+        /** Custom options */
+        this.options = {};
         const model = this.model = {};
-        this.name = options?.name || this.__proto__.constructor.name;
+        this.options.name = options?.name || this.__proto__.constructor.name;
         this.collection = options?.collection;
         this.handler = this.handler.bind(this);
-        for (const n in fields) {
+        for (const n in schema) {
             const modelField = this.model[n] = { name: n };
-            let field = fields[n];
+            let field = schema[n];
             let fieldType, isArray = false;
             if (typeof field === 'object' && !Array.isArray(field) && !(field instanceof Model))
                 fieldType = field.type;
@@ -2600,7 +2616,7 @@ export class Model {
             if (fieldType instanceof Model) {
                 modelField.model = fieldType;
                 fieldType = 'model';
-                validateType = (value, options) => modelField.model?.validate(value, options);
+                validateType = (value, options) => modelField.model?.document(value, options);
             }
             else {
                 fieldType = fieldType.toString().toLowerCase();
@@ -2760,8 +2776,12 @@ export class Model {
                 validators.push(field.validate);
         }
     }
+    /** Get model name */
+    get name() {
+        return this.options.name;
+    }
     /** Validate data over model */
-    validate(data, options) {
+    document(data, options) {
         options = options || {};
         const prefix = options.name ? options.name + '.' : '';
         if (options.validate === false)
@@ -2769,7 +2789,7 @@ export class Model {
         const res = {};
         for (const name in this.model) {
             const field = this.model[name];
-            const paramOptions = { ...options, field, name: prefix + name, model: this };
+            const paramOptions = { ...this.options, ...options, field, name: prefix + name, model: this };
             const canWrite = field.canWrite(paramOptions), canRead = field.canRead(paramOptions), required = field.required?.(paramOptions);
             if (options.readOnly) {
                 if (canRead === false || !field.type)
@@ -2837,7 +2857,7 @@ export class Model {
         for (const name in this.model) {
             if (!(name in res)) {
                 const field = this.model[name];
-                const paramOptions = { ...options, field, name, model: this };
+                const paramOptions = { ...this.options, ...options, field, name, model: this };
                 if ((!options?.required && name in data) || (field.required && field.default)) {
                     if (typeof field.required === 'function' && field.required(paramOptions) && field.default && (!(name in data) || field.canWrite(options) === false))
                         res[name] = options?.default !== false ? field.default.length ? field.default(paramOptions) : field.default() : data[name];
@@ -2859,8 +2879,9 @@ export class Model {
             this.collection = await this.collection;
         if (!this.collection)
             throw new AccessDenied('Database not configured');
-        const doc = await this.collection.findOne(this.getFilter(query, { readOnly: true, ...options }));
-        return doc ? this.validate(doc, { readOnly: true }) : undefined;
+        options = { readOnly: true, ...this.options, ...options };
+        const doc = await this.collection.findOne(this.getFilter(query, options));
+        return doc ? this.document(doc, options) : undefined;
     }
     /** Find many documents */
     async findMany(query, options) {
@@ -2869,7 +2890,8 @@ export class Model {
         if (!this.collection)
             throw new AccessDenied('Database not configured');
         const res = [];
-        await this.collection.find(this.getFilter(query || {}, options)).forEach((doc) => res.push(this.validate(doc, { readOnly: true })));
+        options = { readOnly: true, ...this.options, ...options };
+        await this.collection.find(this.getFilter(query || {}, options)).forEach((doc) => res.push(this.document(doc, options)));
         return res;
     }
     /** Insert a new document */
@@ -2882,8 +2904,9 @@ export class Model {
             this.collection = await this.collection;
         if (!this.collection)
             throw new AccessDenied('Database not configured');
+        options = { ...this.options, ...options };
         if (options?.validate !== false)
-            query = this.validate(query, options);
+            query = this.document(query, options);
         const unset = query.$unset || {};
         for (const n in query) {
             if (query[n] === undefined || query[n] === null) {
@@ -2893,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) {
@@ -2901,7 +2927,7 @@ export class Model {
         if (!this.collection)
             throw new AccessDenied('Database not configured');
         if (query._id)
-            await this.collection.deleteOne(this.getFilter(query, options));
+            await this.collection.deleteOne(this.getFilter(query, { ...this.options, ...options }));
     }
     /** Microserver middleware */
     handler(req, res) {
@@ -2939,36 +2965,27 @@ export class Model {
 }
 Model.models = {};
 /** Collection factory */
-class MicroCollections {
-    constructor(options) {
-        this.options = options;
+export class MicroCollectionStore {
+    constructor(dataPath) {
+        this._collections = new Map();
+        if (dataPath)
+            this._store = new FileStore({ dir: dataPath.replace(/^\w+:\/\//, '') });
     }
     /** Get collection */
     async collection(name) {
-        return new MicroCollection({ ...this.options, name });
+        if (!this._collections.has(name)) {
+            const data = await this._store?.load(name, true) || {};
+            this._collections.set(name, new MicroCollection({ data, name }));
+        }
+        return this._collections.get(name);
     }
 }
 /** minimalistic indexed mongo type collection with persistance for usage with Model */
 export class MicroCollection {
-    /** Get collections factory */
-    static collections(options) {
-        return new MicroCollections(options);
-    }
     constructor(options = {}) {
         this.name = options.name || this.constructor.name;
-        const load = options.load ?? (options.store && ((col) => options.store?.load(col.name, true)));
         this.data = options.data || {};
         this._save = options.save;
-        this._ready = load?.(this)?.catch(() => { }).then(data => {
-            this.data = data || {};
-        });
-    }
-    /** check for collection is ready */
-    async checkReady() {
-        if (this._ready) {
-            await this._ready;
-            this._ready = undefined;
-        }
     }
     /** Query document with query filter */
     queryDocument(query, data) {
@@ -2988,12 +3005,10 @@ export class MicroCollection {
     }
     /** Count all documents */
     async countDocuments() {
-        await this.checkReady();
         return Object.keys(this.data).length;
     }
     /** Find one matching document */
     async findOne(query) {
-        await this.checkReady();
         const id = query._id;
         if (id)
             return this.queryDocument(query, this.data[id]);
@@ -3005,7 +3020,6 @@ export class MicroCollection {
     find(query) {
         return {
             forEach: async (cb, self) => {
-                await this._ready;
                 let count = 0;
                 for (const id in this.data)
                     if (this.queryDocument(query, this.data[id])) {
@@ -3018,70 +3032,34 @@ export class MicroCollection {
                 return count;
             },
             all: async () => {
-                await this._ready;
                 return Object.values(this.data).filter(doc => this.queryDocument(query, doc));
             }
         };
     }
     /** Find and modify one matching document */
     async findAndModify(options) {
-        if (!options.query)
-            return 0;
-        await this.checkReady();
-        const id = ((options.upsert || options.new) && !options.query._id) ? newObjectId() : options.query._id;
-        if (!id) {
-            let count = 0;
-            this.find(options.query).forEach((doc) => {
-                if (this.queryDocument(options.query, doc)) {
-                    Object.assign(doc, options.update);
-                    if (this._save) {
-                        if (!this._ready)
-                            this._ready = Promise.resolve();
-                        this._ready = this._ready.then(async () => {
-                            this.data[doc._id] = await this._save?.(doc._id, doc, this) || this.data[doc._id];
-                        });
-                    }
-                    count++;
-                    if (options.limit && count >= options.limit)
-                        return false;
-                }
-            });
-            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) {
-        await this.checkReady();
         if (doc._id && this.data[doc._id])
             throw new InvalidData(`Document ${doc._id} dupplicate`);
+        doc = { ...doc };
         if (!doc._id)
-            doc._id = { _id: newObjectId(), ...doc };
-        else
-            doc = { ...doc };
+            doc._id = newObjectId();
         this.data[doc._id] = doc;
         if (this._save)
             this.data[doc._id] = doc = await this._save(doc._id, doc, this) || doc;
@@ -3089,7 +3067,6 @@ export class MicroCollection {
     }
     /** Insert multiple documents */
     async insertMany(docs) {
-        await this.checkReady();
         docs.forEach(doc => {
             if (doc._id && this.data[doc._id])
                 throw new InvalidData(`Document ${doc._id} dupplicate`);
@@ -3100,50 +3077,72 @@ export class MicroCollection {
     }
     /** Delete one matching document */
     async deleteOne(query) {
-        const id = query._id;
-        if (!id)
-            return;
-        await this.checkReady();
-        delete this.data[id];
+        return (await this.updateMany(query, {}, { delete: true, limit: 1 })).modifiedCount;
     }
     /** Delete all matching documents */
     async deleteMany(query) {
-        let count = 0;
-        await this.checkReady();
+        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++;
-                delete this.data[doc._id];
-                if (this._save) {
-                    if (!this._ready)
-                        this._ready = Promise.resolve();
-                    this._ready = this._ready.then(async () => { 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;
             }
         });
-        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
-        };
+        await promise;
+        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.2.2",
+  "version": "2.3.1",
   "description": "HTTP MicroServer",
   "author": "Darius Kisonas",
   "license": "MIT",