@dnax/core 0.0.1

package/driver/mongo/rest.ts

@@ -0,0 +1,1214 @@
+import moment from "moment";
+import { sessionStorage } from "../../lib/asyncLocalStorage";
+import { getCollection } from "../../lib/collection";
+import { getTenant } from "../../lib/tenant";
+import type { Actions, Collection, Tenant } from "./../../types/index";
+import { isArray, omit } from "radash";
+import { ClientSession, MongoClient, ObjectId } from "mongodb";
+import { contextError, fn, toJson } from "../../utils";
+import * as v from "valibot";
+import type { Context } from "hono";
+
+import type {
+  findOneParam,
+  findParam,
+  queryParam,
+  updateParams,
+} from "./@types";
+import {
+  buildPipeline,
+  toBson,
+  formatData,
+  randomCode,
+  hashPasswordAuto,
+  cleanData,
+  transformAllDate,
+  deepSetId,
+} from "./utils";
+import { Cfg } from "../../config";
+
+type options = {
+  tenant_id: string;
+  c?: Context;
+  useHook?: boolean;
+  customApi?: boolean;
+};
+
+type optionCb = {
+  useHook?: boolean;
+  cleanDeep?: boolean;
+};
+
+const omitUpdate = [
+  "$set._id",
+  "$set.id",
+  "$set.createdAt",
+  "$set.updatedAt",
+  "$unset",
+  "$rename",
+];
+
+class useRest {
+  #useHook: boolean;
+  #c: Context | undefined;
+  #tenant: Tenant;
+  #tenant_id: string;
+  #session: ClientSession | null | undefined;
+  #customApi = false;
+  constructor(options: options) {
+    this.#c = options.c;
+    this.#customApi = options.customApi ?? false;
+    this.#tenant_id = options.tenant_id;
+    this.#session = null;
+    this.#tenant = getTenant(this.#tenant_id);
+    this.#useHook = options?.useHook ?? true;
+    /*  if (options?.useHook == undefined || options?.useHook == null) {
+      this.#useHook = true;
+    } else {
+      this.#useHook = options.useHook;
+    } */
+  }
+
+  validator(
+    collection: string,
+    data: any,
+    options: { partial: boolean } = {
+      partial: false,
+    }
+  ): { valid: boolean; output: any; error: any } {
+    let col = getCollection(collection, this.#tenant_id);
+    let valid = true;
+    let output = data;
+    let error;
+    /*  let issue = err?.issues[0] || {};
+    let msg = `Field : ${issue?.path[0]?.key} - ${issue?.message}`;
+    */
+    try {
+      if (col?.schema) {
+        if (options.partial) {
+          var issue = v.safeParse(v.partial(col.schema), data);
+          output = issue.output;
+        } else {
+          var issue = v.safeParse(col.schema, data);
+          output = issue.output;
+        }
+        if (issue?.success) {
+        } else {
+          valid = false;
+          error = `Field : ${issue?.issues[0]?.path[0]?.key} - ${issue?.issues[0]?.message}`;
+        }
+      }
+    } catch (err: any) {
+      error = err?.message;
+      valid = false;
+    }
+
+    return {
+      valid: valid,
+      output,
+      error: error,
+    };
+  }
+
+  async aggregate(
+    collection: string,
+    pipeline: Array<object>,
+    options?: optionCb
+  ) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let result = {
+          docs: [],
+        };
+        let useHook = options?.useHook ?? this.#useHook;
+        let sharedData = {};
+        let col = getCollection(collection, this.#tenant_id);
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            io: Cfg.io,
+            sharedData: sharedData,
+            pipeline: pipeline,
+            c: this.#c,
+            driver: "mongodb",
+            action: "aggregate",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeAggregate && useHook) {
+          await col.hooks.beforeAggregate({
+            io: Cfg.io,
+            sharedData: sharedData,
+            pipeline: pipeline,
+            c: this.#c,
+            driver: "mongodb",
+            action: "aggregate",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        result.docs = await this.#tenant.database.db
+          ?.collection(collection)
+          .aggregate(pipeline, {
+            allowDiskUse: true,
+          })
+          .toArray();
+
+        if (col?.hooks?.afterAggregate && useHook) {
+          await col.hooks.afterAggregate({
+            io: Cfg.io,
+            sharedData: sharedData,
+            docs: result.docs,
+            c: this.#c,
+            driver: "mongodb",
+            action: "aggregate",
+            session: sessionStorage(),
+            result: result.docs,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        return resolve(result.docs);
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+  async insertOne(collection: string, data: object, options?: optionCb) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let sharedData = {};
+        let useHook = options?.useHook ?? this.#useHook;
+        let col = getCollection(collection, this.#tenant_id);
+        if (!col) return fn.error(`Collection ${collection} not found`, 404);
+
+        if (col?.customApi?.insertOne && !this.#customApi) {
+          let result = await col?.customApi?.insertOne({
+            io: Cfg.io,
+            session: sessionStorage(),
+            data: data,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              customApi: true,
+            }),
+          });
+          return resolve(result);
+        }
+
+        // Processing before validation
+        data = await randomCode(data, col);
+        data = await hashPasswordAuto(data, col);
+        data = transformAllDate(data);
+        data = deepSetId(col, data);
+
+        var { valid, output, error } = this.validator(collection, data);
+        if (!valid) fn.error(error, 400);
+
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            io: Cfg.io,
+            data: data,
+            c: this.#c,
+            driver: "mongodb",
+            action: "insertOne",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeInsert && useHook) {
+          await col.hooks.beforeInsert({
+            sharedData: sharedData,
+            data: data,
+            io: Cfg.io,
+            c: this.#c,
+            driver: "mongodb",
+            action: "insertOne",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        await this.#tenant.database.db?.collection(collection).insertOne(
+          formatData(data, {
+            action: "insertOne",
+            tenant_id: this.#tenant_id,
+            collection: collection,
+          }),
+          {
+            session: this.#session ? this.#session : undefined,
+          }
+        );
+
+        if (col?.hooks?.afterInsert && useHook) {
+          await col.hooks.afterInsert({
+            sharedData: sharedData,
+            data: data,
+            c: this.#c,
+            io: Cfg.io,
+            driver: "mongodb",
+            result: data,
+            action: "insertOne",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+        return resolve(data);
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+  async insertMany(
+    collection: string,
+    data: Array<object>,
+    options?: optionCb
+  ) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let sharedData = {};
+        let col = getCollection(collection, this.#tenant_id);
+        let useHook = options?.useHook ?? this.#useHook;
+        if (!col) return fn.error(`Collection ${collection} not found`, 404);
+
+        if (col?.customApi?.insertMany && !this.#customApi) {
+          let result = await col?.customApi?.insertMany({
+            io: Cfg.io,
+            session: sessionStorage(),
+            data: data,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              customApi: true,
+            }),
+          });
+          return resolve(result);
+        }
+
+        for await (let d of data) {
+          // Processing before validation
+          d = await randomCode(d, col);
+          d = await hashPasswordAuto(d, col);
+          d = deepSetId(col, d);
+          var { valid, output, error } = this.validator(collection, d);
+          if (!valid) fn.error(error, 400);
+        }
+
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            data: data,
+            io: Cfg.io,
+            c: this.#c,
+            driver: "mongodb",
+            action: "insertMany",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeInsert && useHook) {
+          await col.hooks.beforeInsert({
+            sharedData: sharedData,
+            data: data,
+            io: Cfg.io,
+            c: this.#c,
+            driver: "mongodb",
+            action: "insertMany",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        await this.#tenant.database.db?.collection(collection).insertMany(
+          formatData(data, {
+            collection: collection,
+            action: "insertMany",
+            tenant_id: this.#tenant_id,
+          }),
+          {
+            session: this.#session ? this.#session : undefined,
+          }
+        );
+
+        if (col?.hooks?.afterInsert && useHook) {
+          await col.hooks.afterInsert({
+            sharedData: sharedData,
+            data: data,
+            c: this.#c,
+            io: Cfg.io,
+            driver: "mongodb",
+            action: "insertMany",
+            result: data,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        return resolve(data);
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  /**
+   *
+   * @param collection - Collection name
+   * @param params - Find params
+   * @param options
+   */
+  async find(
+    collection: string,
+    params: findParam,
+    options?: optionCb
+  ): Promise<object[]> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let useHook = options?.useHook ?? this.#useHook;
+        let sharedData = {};
+        let result = {
+          docs: [],
+        };
+
+        let col = getCollection(collection, this.#tenant_id);
+
+        if (col?.customApi?.find && !this.#customApi) {
+          let result = await col?.customApi?.find({
+            io: Cfg.io,
+            session: sessionStorage(),
+            params: params,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              customApi: true,
+            }),
+          });
+          return resolve(result);
+        }
+
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            c: this.#c,
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "find",
+            params: params,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeFind && useHook) {
+          await col.hooks.beforeFind({
+            sharedData: sharedData,
+            c: this.#c,
+            driver: "mongodb",
+            action: "find",
+            io: Cfg.io,
+            params: params,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        result.docs = await this.#tenant.database.db
+          ?.collection(collection)
+          .aggregate(formatData(buildPipeline(params, col)), {
+            allowDiskUse: true,
+          })
+          .toArray();
+
+        if (col?.hooks?.afterFind && useHook) {
+          await col.hooks.afterFind({
+            sharedData: sharedData,
+            c: this.#c,
+            io: Cfg.io,
+            driver: "mongodb",
+            action: "find",
+            params: params,
+            session: sessionStorage(),
+            result: result.docs,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        return resolve(toJson(result.docs));
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+  async findOne(
+    collection: string,
+    id: string,
+    params?: findOneParam,
+    options?: optionCb
+  ): Promise<object | null> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let sharedData = {};
+        let docs: Array<any> | any = [];
+        let useHook = options?.useHook ?? this.#useHook;
+
+        let col = getCollection(collection, this.#tenant_id);
+
+        if (col?.customApi?.findOne && !this.#customApi) {
+          let result = await col?.customApi?.findOne({
+            io: Cfg.io,
+            session: sessionStorage(),
+            id: id,
+            params: params,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              customApi: true,
+            }),
+          });
+          return resolve(result);
+        }
+
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            id: id,
+            io: Cfg.io,
+            c: this.#c,
+            driver: "mongodb",
+            action: "findOne",
+            params: params,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeFind && useHook) {
+          await col.hooks.beforeFind({
+            sharedData: sharedData,
+            c: this.#c,
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "find",
+            params: params,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        let params_: findParam = {};
+        if (typeof id === "string") {
+          params_ = {
+            ...params,
+            $match: {
+              _id: id,
+            },
+            $limit: 1,
+          };
+        }
+
+        docs = await this.#tenant.database.db
+          ?.collection(collection)
+          .aggregate(
+            formatData(
+              buildPipeline(params_, getCollection(collection, this.#tenant_id))
+            ),
+            {
+              allowDiskUse: true,
+            }
+          )
+          .toArray();
+
+        if (col?.hooks?.afterFind && useHook) {
+          await col.hooks.afterFind({
+            sharedData: sharedData,
+            c: this.#c,
+            io: Cfg.io,
+            driver: "mongodb",
+            action: "findOne",
+            params: params,
+            session: sessionStorage(),
+            result: docs,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        return resolve(docs?.length ? toJson(docs[0]) : null);
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+
+  async updateOne(
+    collection: string,
+    id: string,
+    update: updateParams,
+    options?: optionCb
+  ): Promise<object> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let result = {
+          doc: null,
+        };
+        let col = getCollection(collection, this.#tenant_id);
+        if (!col) return fn.error(`Collection ${collection} not found`, 404);
+
+        if (col?.customApi?.updateOne && !this.#customApi) {
+          let result = await col?.customApi?.updateOne({
+            io: Cfg.io,
+            session: sessionStorage(),
+            update: update,
+            id: id,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              customApi: true,
+            }),
+          });
+          return resolve(result);
+        }
+
+        let sharedData = {};
+        let useHook = options?.useHook ?? this.#useHook;
+
+        //@ts-expect-error
+        update = omit(update, omitUpdate);
+
+        if (update?.$set) {
+          update.$set = deepSetId(col, update.$set);
+          update.$set = transformAllDate(update.$set);
+          update.$set = await hashPasswordAuto(update.$set, col);
+          //   data = transformAllDate(data);
+          // data = deepSetId(col, data);
+          var { valid, output, error } = this.validator(
+            collection,
+            update.$set,
+            {
+              partial: true,
+            }
+          );
+
+          // update.$set = output;
+
+          //console.log(valid, error);
+
+          if (!valid) fn?.error(error, 400);
+        }
+
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            id: id,
+            io: Cfg.io,
+            c: this.#c,
+            driver: "mongodb",
+            action: "updateOne",
+            update: update,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeUpdate && useHook) {
+          await col.hooks.beforeUpdate({
+            sharedData: sharedData,
+            c: this.#c,
+            id: id,
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "updateOne",
+            update: update,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (typeof id == "string") {
+          result.doc = await this.#tenant.database.db
+            ?.collection(collection)
+            .findOneAndUpdate(
+              {
+                _id: new ObjectId(id),
+              },
+              {
+                ...formatData(omit(update, omitUpdate)),
+                $currentDate: {
+                  updatedAt: true,
+                },
+              },
+              {
+                returnDocument: "after",
+                session: this.#session ? this.#session : undefined,
+              }
+            );
+        }
+
+        if (col?.hooks?.afterUpdate && useHook) {
+          await col.hooks.afterUpdate({
+            sharedData: sharedData,
+            c: this.#c,
+            driver: "mongodb",
+            id: id,
+            io: Cfg.io,
+            action: "updateOne",
+            update: update,
+            session: sessionStorage(),
+            result: result.doc,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        return resolve(result.doc);
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+
+  async findOneAndUpdate(
+    collection: string,
+    filter: object,
+    update: updateParams,
+    options?: optionCb
+  ): Promise<object> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let result = {
+          doc: null,
+        };
+        let col = getCollection(collection, this.#tenant_id);
+        if (!col) return fn.error(`Collection ${collection} not found`, 404);
+
+        let sharedData = {};
+        let useHook = options?.useHook ?? this.#useHook;
+
+        //@ts-expect-error
+        update = omit(update, omitUpdate);
+
+        if (update.$set) {
+          update.$set = deepSetId(col, update.$set);
+          var { valid, output, error } = this.validator(
+            collection,
+            update.$set,
+            {
+              partial: true,
+            }
+          );
+          //  update.$set = output;
+          if (!valid) fn.error(error, 400);
+        }
+
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            filter: filter || {},
+            c: this.#c,
+            io: Cfg.io,
+            driver: "mongodb",
+            action: "findOneAndUpdate",
+            update: update,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeUpdate && useHook) {
+          await col.hooks.beforeUpdate({
+            sharedData: sharedData,
+            c: this.#c,
+            filter: filter || {},
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "findOneAndUpdate",
+            update: update,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (typeof id == "string") {
+          result.doc = await this.#tenant.database.db
+            ?.collection(collection)
+            .findOneAndUpdate(
+              {
+                ...(filter || {}),
+              },
+              {
+                ...formatData(omit(update, omitUpdate)),
+                $currentDate: {
+                  updatedAt: true,
+                },
+              },
+              {
+                upsert: true,
+                returnDocument: "after",
+                session: this.#session ? this.#session : undefined,
+              }
+            );
+        }
+
+        if (col?.hooks?.afterUpdate && useHook) {
+          await col.hooks.afterUpdate({
+            sharedData: sharedData,
+            c: this.#c,
+            driver: "mongodb",
+            id: id,
+            action: "updateOne",
+            update: update,
+            session: sessionStorage(),
+            result: result.doc,
+            io: Cfg.io,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        return resolve(result.doc);
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+
+  async updateMany(
+    collection: string,
+    ids: Array<string>,
+    update: updateParams,
+    options?: optionCb
+  ): Promise<object> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let sharedData = {};
+        let result = {
+          docs: [],
+        };
+        let col = getCollection(collection, this.#tenant_id);
+        if (!col) return fn.error(`Collection ${collection} not found`, 404);
+
+        if (col?.customApi?.updateMany && !this.#customApi) {
+          let result = await col?.customApi?.updateMany({
+            io: Cfg.io,
+            session: sessionStorage(),
+            update: update,
+            ids: ids,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              customApi: true,
+            }),
+          });
+          return resolve(result);
+        }
+
+        let useHook = options?.useHook ?? this.#useHook;
+
+        //@ts-expect-error
+        update = omit(update, omitUpdate);
+
+        if (update.$set) {
+          update.$set = deepSetId(col, update.$set);
+          update.$set = transformAllDate(update.$set);
+          update.$set = await hashPasswordAuto(update.$set, col);
+          var { valid, output, error } = this.validator(
+            collection,
+            update.$set,
+            {
+              partial: true,
+            }
+          );
+          //   update.$set = output;
+
+          if (!valid) fn.error(error, 400);
+        }
+
+        if (Array.isArray(ids)) {
+          if (!ids?.length) throw new contextError("List of id required", 400);
+
+          if (col?.hooks?.beforeOperation && useHook) {
+            await col.hooks.beforeOperation({
+              sharedData: sharedData,
+              ids: ids,
+              c: this.#c,
+              driver: "mongodb",
+              io: Cfg.io,
+              action: "updateMany",
+              update: update,
+              session: sessionStorage(),
+              rest: new useRest({
+                useHook: false,
+                tenant_id: this.#tenant_id,
+              }),
+            });
+          }
+
+          if (col?.hooks?.beforeUpdate && useHook) {
+            await col.hooks.beforeUpdate({
+              sharedData: sharedData,
+              c: this.#c,
+              ids: ids,
+              driver: "mongodb",
+              io: Cfg.io,
+              action: "updateMany",
+              update: update,
+              session: sessionStorage(),
+              rest: new useRest({
+                useHook: false,
+                tenant_id: this.#tenant_id,
+              }),
+            });
+          }
+
+          await this.#tenant.database.db?.collection(collection).updateMany(
+            {
+              _id: {
+                $in: ids.map((id) => new ObjectId(id)),
+              },
+            },
+            {
+              ...formatData(omit(update, omitUpdate)),
+              $currentDate: {
+                updatedAt: true,
+              },
+            },
+            {
+              session: this.#session ? this.#session : undefined,
+            }
+          );
+
+          result.docs = await this.#tenant.database.db
+            .collection(collection)
+            .find(
+              {
+                _id: {
+                  $in: ids.map((id) => new ObjectId(id)),
+                },
+              },
+              {
+                allowDiskUse: true,
+              }
+            )
+            .toArray();
+
+          if (col?.hooks?.afterUpdate && useHook) {
+            await col.hooks.afterUpdate({
+              sharedData: sharedData,
+              c: this.#c,
+              driver: "mongodb",
+              ids: ids,
+              action: "updateMany",
+              update: update,
+              session: sessionStorage(),
+              result: result.docs,
+              io: Cfg.io,
+              rest: new useRest({
+                useHook: false,
+                tenant_id: this.#tenant_id,
+              }),
+            });
+          }
+
+          return resolve(result.docs);
+        } else {
+          throw new contextError("List of id required", 400);
+        }
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+  async deleteOne(
+    collection: string,
+    id: string,
+    options?: optionCb
+  ): Promise<object> {
+    return new Promise(async (resolve, reject) => {
+      try {
+        if (!id) fn.error("Id is required", 400);
+        let useHook = options?.useHook ?? this.#useHook;
+
+        let col = getCollection(collection, this.#tenant_id);
+        let sharedData = {};
+
+        if (col?.customApi?.deleteOne && !this.#customApi) {
+          let result = await col?.customApi?.deleteOne({
+            io: Cfg.io,
+            session: sessionStorage(),
+            id: id,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              customApi: true,
+            }),
+          });
+          return resolve(result!);
+        }
+
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            id: id,
+            c: this.#c,
+            driver: "mongodb",
+            action: "deleteOne",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeDelete && useHook) {
+          await col.hooks.beforeDelete({
+            sharedData: sharedData,
+            id: id,
+            c: this.#c,
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "deleteOne",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        let doc = await this.#tenant.database.db
+          ?.collection(collection)
+          .findOneAndDelete(
+            {
+              _id: new ObjectId(id),
+            },
+            {
+              session: this.#session ? this.#session : undefined,
+            }
+          );
+
+        if (col?.hooks?.afterDelete && useHook) {
+          await col.hooks.afterDelete({
+            sharedData: sharedData,
+            id: id,
+            c: this.#c,
+            driver: "mongodb",
+            action: "deleteOne",
+            result: doc,
+            io: Cfg.io,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        return resolve(doc);
+      } catch (err) {
+        return resolve(err);
+      }
+    });
+  }
+  async deleteMany(collection: string, ids: Array<string>, options?: optionCb) {
+    return new Promise(async (resolve, reject) => {
+      try {
+        let useHook = options?.useHook ?? this.#useHook;
+
+        let sharedData = {};
+        let col = getCollection(collection, this.#tenant_id);
+
+        if (col?.customApi?.deleteMany && !this.#customApi) {
+          let result = await col?.customApi?.deleteMany({
+            io: Cfg.io,
+            session: sessionStorage(),
+            ids: ids,
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+              customApi: true,
+            }),
+          });
+          return resolve(result!);
+        }
+
+        let deletedIds: any = [];
+
+        if (!ids) fn.error("List of id required", 400);
+
+        if (col?.hooks?.beforeOperation && useHook) {
+          await col.hooks.beforeOperation({
+            sharedData: sharedData,
+            ids: ids,
+            c: this.#c,
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "deleteMany",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (col?.hooks?.beforeDelete && useHook) {
+          await col.hooks.beforeDelete({
+            sharedData: sharedData,
+            ids: ids,
+            c: this.#c,
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "deleteMany",
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        if (Array.isArray(ids)) {
+          await this.#tenant.database.db?.collection(collection).deleteMany(
+            {
+              _id: { $in: formatData(ids) },
+            },
+            {
+              session: this.#session ? this.#session : undefined,
+            }
+          );
+        }
+
+        if (col?.hooks?.afterDelete && useHook) {
+          await col.hooks.afterDelete({
+            sharedData: sharedData,
+            ids: ids,
+            c: this.#c,
+            driver: "mongodb",
+            io: Cfg.io,
+            action: "deleteMany",
+            result: deletedIds,
+            session: sessionStorage(),
+            rest: new useRest({
+              useHook: false,
+              tenant_id: this.#tenant_id,
+            }),
+          });
+        }
+
+        return resolve(deletedIds);
+      } catch (err) {
+        return reject(err);
+      }
+    });
+  }
+
+  async estimateDocumentCount(collection: string) {
+    return await this.#tenant.database.db
+      ?.collection(collection)
+      .estimatedDocumentCount();
+  }
+  async dropCollection(Collection: string) {
+    return await this.#tenant.database.db?.collection(Collection).drop();
+  }
+
+  async dropIndexes(Collection: string) {
+    return await this.#tenant.database.db?.collection(Collection).dropIndexes();
+  }
+
+  async dropIndex(Collection: string, indexName: string) {
+    return await this.#tenant.database.db
+      ?.collection(Collection)
+      .dropIndex(indexName);
+  }
+
+  startTransaction() {
+    if (!this.#session) {
+      this.#session = this.#tenant.database.client?.startSession();
+      this.#session?.startTransaction();
+    }
+  }
+  async commitTransaction() {
+    return new Promise(async (resolve, reject) => {
+      if (this.#session) {
+        await this.#session
+          ?.commitTransaction()
+          .then((e) => {
+            this.#session?.endSession();
+            this.#session = null;
+            resolve(true);
+          })
+          .catch((err) => {
+            reject(err);
+          });
+      }
+    });
+  }
+}
+
+export { useRest };