@akanjs/document 0.0.54 → 0.0.55

package/index.mjs

@@ -0,0 +1 @@
+export * from "./src";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/document",
-  "version": "0.0.54",
+  "version": "0.0.55",
   "type": "commonjs",
   "publishConfig": {
     "access": "public"
@@ -18,5 +18,11 @@
     "dataloader": "^2.2.3",
     "lodash": "^4.17.21",
     "mongoose": "^8.9.3"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    }
   }
 }

package/src/dataLoader.mjs

@@ -0,0 +1,110 @@
+import DataLoader from "dataloader";
+import { flatMap, get, groupBy, keyBy } from "lodash";
+import { Schema, Types } from "mongoose";
+const Id = Types.ObjectId;
+const ObjectId = Schema.Types.ObjectId;
+const Mixed = Schema.Types.Mixed;
+const createLoader = (model, fieldName = "_id", defaultQuery = {}) => {
+  return new DataLoader(
+    (fields) => {
+      const query = { ...defaultQuery };
+      query[fieldName] = { $in: fields };
+      const data = model.find(query).then((list) => {
+        const listByKey = keyBy(list, fieldName);
+        return fields.map((id) => get(listByKey, id, null));
+      });
+      return data;
+    },
+    { name: "dataloader", cache: false }
+  );
+};
+const createArrayLoader = (model, fieldName = "_id", defaultQuery = {}) => {
+  return new DataLoader((fields) => {
+    const query = { ...defaultQuery };
+    query[fieldName] = { $in: fields };
+    const data = model.find(query).then((list) => {
+      return fields.map((field) => list.filter((item) => field === item[fieldName]));
+    });
+    return data;
+  });
+};
+const createArrayElementLoader = (model, fieldName = "_id", defaultQuery = {}) => {
+  return new DataLoader(
+    (fields) => {
+      const query = { ...defaultQuery };
+      query[fieldName] = { $in: fields };
+      const data = model.find(query).then((list) => {
+        const flat = flatMap(
+          list,
+          (dat) => dat[fieldName].map((datField) => ({
+            ...dat.toObject(),
+            key: datField
+          }))
+        );
+        const listByKey = groupBy(flat, (dat) => dat.key);
+        return fields.map((id) => get(listByKey, id, null));
+      });
+      return data;
+    },
+    { name: "dataloader", cache: false }
+  );
+};
+const createQueryLoader = (model, queryKeys, defaultQuery = {}) => {
+  return new DataLoader(
+    (queries) => {
+      const query = {
+        $and: [{ $or: queries }, defaultQuery]
+      };
+      const getQueryKey = (query2) => queryKeys.map((key) => query2[key].toString()).join("");
+      const data = model.find(query).then((list) => {
+        const listByKey = keyBy(list, getQueryKey);
+        return queries.map((query2) => get(listByKey, getQueryKey(query2), null));
+      });
+      return data;
+    },
+    { name: "dataloader", cache: false }
+  );
+};
+const getLoaderMetaMapByPrototype = (prototype) => {
+  const loaderMetaMap = Reflect.getOwnMetadata("loaders", prototype) ?? /* @__PURE__ */ new Map();
+  return loaderMetaMap;
+};
+const getLoaderMetas = (target) => {
+  const metas = [...getLoaderMetaMapByPrototype(target.prototype).values()];
+  return metas;
+};
+const Loader = {
+  ByField: (fieldName, defaultQuery = {}) => {
+    return function(target, key) {
+      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
+      loaderMetaMap.set(key, { key, type: "Field", fieldName, defaultQuery });
+      Reflect.defineMetadata("loaders", loaderMetaMap, target);
+    };
+  },
+  ByArrayField: (fieldName, defaultQuery = {}) => {
+    return function(target, key) {
+      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
+      loaderMetaMap.set(key, { key, type: "ArrayField", fieldName, defaultQuery });
+      Reflect.defineMetadata("loaders", loaderMetaMap, target);
+    };
+  },
+  ByQuery: (queryKeys, defaultQuery = {}) => {
+    return function(target, key) {
+      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
+      loaderMetaMap.set(key, { key, type: "Query", queryKeys, defaultQuery });
+      Reflect.defineMetadata("loaders", loaderMetaMap, target);
+    };
+  }
+};
+export {
+  DataLoader,
+  Id,
+  Loader,
+  Mixed,
+  ObjectId,
+  createArrayElementLoader,
+  createArrayLoader,
+  createLoader,
+  createQueryLoader,
+  getLoaderMetas
+};

package/src/database.mjs

@@ -0,0 +1,295 @@
+import { dayjs } from "@akanjs/base";
+import { capitalize, Logger, lowerlize } from "@akanjs/common";
+import {
+  DEFAULT_PAGE_SIZE,
+  getFieldMetas,
+  getFilterKeyMetaMapOnPrototype,
+  getFilterQuery,
+  getFilterSort
+} from "@akanjs/constant";
+import { Transaction } from "@akanjs/nest";
+import { createArrayLoader, createLoader, createQueryLoader, getLoaderMetas } from "./dataLoader";
+import { convertAggregateMatch } from "./schema";
+class CacheDatabase {
+  constructor(refName, redis) {
+    this.refName = refName;
+    this.redis = redis;
+    this.logger = new Logger(`${refName}Cache`);
+  }
+  logger;
+  async set(topic, key, value, option = {}) {
+    const setOption = { PXAT: option.expireAt?.toDate().getTime() };
+    await this.redis.set(`${this.refName}:${topic}:${key}`, value, setOption);
+  }
+  async get(topic, key) {
+    const value = await this.redis.get(`${this.refName}:${topic}:${key}`);
+    return value;
+  }
+  async delete(topic, key) {
+    await this.redis.del(`${this.refName}:${topic}:${key}`);
+  }
+}
+class SearchDatabase {
+  constructor(refName, meili) {
+    this.refName = refName;
+    this.meili = meili;
+    this.logger = new Logger(`${refName}Search`);
+    this.index = meili.index(lowerlize(refName));
+  }
+  logger;
+  index;
+  async searchIds(searchText, option = {}) {
+    const { skip = 0, limit = DEFAULT_PAGE_SIZE, sort } = option;
+    if (!searchText) {
+      const { results, total } = await this.index.getDocuments({ offset: skip ?? 0, limit: limit ?? 0 });
+      return { ids: results.map((result) => result.id), total };
+    }
+    const { hits, estimatedTotalHits } = await this.index.search(searchText, {
+      offset: skip ?? 0,
+      limit: limit ?? 0,
+      sort: sort ?? [],
+      filter: option.filter,
+      attributesToRetrieve: ["id"]
+    });
+    return { ids: hits.map((hit) => hit.id), total: estimatedTotalHits };
+  }
+  async count(searchText, option = {}) {
+    const { skip = 0, limit = DEFAULT_PAGE_SIZE, sort = "" } = option;
+    if (!searchText) {
+      const { results, total } = await this.index.getDocuments({ offset: skip ?? 0, limit: limit ?? 0 });
+      return total;
+    }
+    const { hits, estimatedTotalHits } = await this.index.search(searchText, {
+      offset: skip ?? 0,
+      limit: limit ?? 0,
+      filter: option.filter,
+      attributesToRetrieve: ["id"]
+    });
+    return estimatedTotalHits;
+  }
+}
+class DatabaseModelStorage {
+  __ModelType__ = "DatabaseModelStorage";
+}
+const databaseModelOf = (database, model, redis, meili) => {
+  //! 잘되는지 확인 필요
+  const [modelName, className] = [database.refName, capitalize(database.refName)];
+  const insightFieldMetas = getFieldMetas(database.Insight);
+  const accumulator = Object.fromEntries(insightFieldMetas.map((fieldMeta) => [fieldMeta.key, fieldMeta.accumulate]));
+  const defaultInsight = Object.fromEntries(insightFieldMetas.map((fieldMeta) => [fieldMeta.key, fieldMeta.default]));
+  const makeSafeQuery = (query) => ({ removedAt: { $exists: false }, ...query ?? {} });
+  const makeSafeMatchStage = (query) => ({
+    $match: { removedAt: { $exists: false }, ...convertAggregateMatch(query) }
+  });
+  const getListQuery = (query, queryOption) => {
+    const find = makeSafeQuery(query);
+    const sort = getFilterSort(database.Filter, queryOption?.sort ?? "latest");
+    const skip = queryOption?.skip ?? 0;
+    const limit = queryOption?.limit === null ? DEFAULT_PAGE_SIZE : queryOption?.limit ?? 0;
+    const select = queryOption?.select;
+    const sample = queryOption?.sample;
+    return { find, sort, skip, limit, select, sample };
+  };
+  const getFindQuery = (query, queryOption) => {
+    const find = makeSafeQuery(query);
+    const sort = getFilterSort(database.Filter, queryOption?.sort ?? "latest");
+    const skip = queryOption?.skip ?? 0;
+    const select = queryOption?.select;
+    const sample = queryOption?.sample ?? false;
+    return { find, sort, skip, select, sample };
+  };
+  const getSearchSort = (sortKey) => {
+    const sort = getFilterSort(database.Filter, sortKey ?? "latest");
+    return Object.entries(sort).map(([key, value]) => `${key}:${value === 1 ? "asc" : "desc"}`);
+  };
+  const loader = createLoader(model);
+  const cacheDatabase = new CacheDatabase(database.refName, redis);
+  const searchDatabase = new SearchDatabase(database.refName, meili);
+  const DatabaseModel = Reflect.getMetadata(database.refName, DatabaseModelStorage.prototype) ?? class DatabaseModel {
+    logger = new Logger(`${modelName}Model`);
+    __model = model;
+    __cache = cacheDatabase;
+    __search = searchDatabase;
+    __loader = loader;
+    async __list(query, queryOption) {
+      const { find, sort, skip, limit, select, sample } = getListQuery(query, queryOption);
+      return sample ? await this.__model.sample(find, limit) : await this.__model.find(find, select).sort(sort).skip(skip).limit(limit);
+    }
+    async __listIds(query, queryOption) {
+      const { find, sort, skip, limit, sample } = getListQuery(query, queryOption);
+      return (sample ? await this.__model.sample(find, limit, [{ $project: { _id: 1 } }]) : await this.__model.find(find).sort(sort).skip(skip).limit(limit).select("_id")).map(({ _id }) => _id.toString());
+    }
+    async __find(query, queryOption) {
+      const { find, sort, skip, select, sample } = getFindQuery(query, queryOption);
+      const doc = sample ? await this.__model.sampleOne(find) : await this.__model.findOne(find, select).sort(sort).skip(skip);
+      if (!doc)
+        return null;
+      return doc;
+    }
+    async __findId(query, queryOption) {
+      const { find, sort, skip, sample } = getFindQuery(query, queryOption);
+      const doc = sample ? await this.__model.sampleOne(find, [{ $project: { _id: 1 } }]) : await this.__model.findOne(find).sort(sort).skip(skip).select("_id");
+      if (!doc)
+        return null;
+      return doc._id.toString();
+    }
+    async __pick(query, queryOption) {
+      const { find, sort, skip, select, sample } = getFindQuery(query, queryOption);
+      const doc = sample ? await this.__model.sampleOne(find) : await this.__model.findOne(find, select).sort(sort).skip(skip);
+      if (!doc)
+        throw new Error(`No Document (${database.refName}): ${JSON.stringify(query)}`);
+      return doc;
+    }
+    async __pickId(query, queryOption) {
+      const { find, sort, skip, sample } = getFindQuery(query, queryOption);
+      const doc = sample ? await this.__model.sampleOne(find, [{ $project: { _id: 1 } }]) : await this.__model.findOne(find).sort(sort).skip(skip).select("_id");
+      if (!doc)
+        throw new Error(`No Document (${database.refName}): ${JSON.stringify(query)}`);
+      return doc._id.toString();
+    }
+    async __exists(query) {
+      const find = makeSafeQuery(query);
+      const existingId = await this.__model.exists(find);
+      return existingId?.toString() ?? null;
+    }
+    async __count(query) {
+      const find = makeSafeQuery(query);
+      return await this.__model.countDocuments(find);
+    }
+    async __insight(query) {
+      if (!accumulator)
+        throw new Error(`No Insight (${database.refName})`);
+      const res = await this.__model.aggregate([
+        makeSafeMatchStage(query),
+        { $group: { _id: null, ...accumulator } }
+      ]);
+      const data = res[0];
+      return data ?? defaultInsight;
+    }
+    async getDefaultSummary(addQuery = {}) {
+      if (!database.Summary)
+        return {};
+      const fieldMetas = getFieldMetas(database.Summary);
+      const summary = {};
+      await Promise.all(
+        fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map(async (fieldMeta) => {
+          const query = typeof fieldMeta.query === "function" ? fieldMeta.query() : fieldMeta.query;
+          summary[fieldMeta.key] = query ? await model.countDocuments({ ...query, ...addQuery }) : fieldMeta.default;
+        })
+      );
+      return summary;
+    }
+    async [`get${className}`](id) {
+      const doc = await this.__loader.load(id);
+      if (!doc)
+        throw new Error(`No Document (${database.refName}): ${id}`);
+      return doc;
+    }
+    async [`load${className}`](id) {
+      return id ? await this.__loader.load(id) : null;
+    }
+    async [`load${className}Many`](ids) {
+      return await this.__loader.loadMany(ids);
+    }
+    async [`create${className}`](data) {
+      return await new this.__model(data).save();
+    }
+    async [`update${className}`](id, data) {
+      const doc = await this.__model.pickById(id);
+      return await doc.set(data).save();
+    }
+    async [`remove${className}`](id) {
+      const doc = await this.__model.pickById(id);
+      return await doc.set({ removedAt: dayjs() }).save();
+    }
+    async [`search${className}`](searchText, queryOption = {}) {
+      const { skip, limit, sort } = queryOption;
+      const { ids, total } = await this.__search.searchIds(searchText, { skip, limit, sort: getSearchSort(sort) });
+      const docs = await this.__loader.loadMany(ids);
+      return { docs, count: total };
+    }
+    async [`searchDocs${className}`](searchText, queryOption = {}) {
+      const { skip, limit, sort } = queryOption;
+      const { ids } = await this.__search.searchIds(searchText, { skip, limit, sort: getSearchSort(sort) });
+      return await this.__loader.loadMany(ids);
+    }
+    async [`searchCount${className}`](searchText) {
+      return await this.__search.count(searchText);
+    }
+  };
+  DatabaseModel.prototype[className] = model;
+  DatabaseModel.prototype[`${modelName}Loader`] = loader;
+  DatabaseModel.prototype[`${modelName}Cache`] = cacheDatabase;
+  DatabaseModel.prototype[`${modelName}Search`] = searchDatabase;
+  const getQueryDataFromKey = (queryKey, args) => {
+    const lastArg = args.at(-1);
+    const hasQueryOption = lastArg && typeof lastArg === "object" && (typeof lastArg.select === "object" || typeof lastArg.skip === "number" || typeof lastArg.limit === "number" || typeof lastArg.sort === "string");
+    const queryFn = getFilterQuery(database.Filter, queryKey);
+    const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
+    const queryOption = hasQueryOption ? lastArg : {};
+    return { query, queryOption };
+  };
+  const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(database.Filter.prototype);
+  const queryKeys = [...filterKeyMetaMap.keys()];
+  queryKeys.forEach((queryKey) => {
+    const queryFn = getFilterQuery(database.Filter, queryKey);
+    DatabaseModel.prototype[`list${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__list(query, queryOption);
+    };
+    DatabaseModel.prototype[`listIds${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__listIds(query, queryOption);
+    };
+    DatabaseModel.prototype[`find${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__find(query, queryOption);
+    };
+    DatabaseModel.prototype[`findId${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__findId(query, queryOption);
+    };
+    DatabaseModel.prototype[`pick${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__pick(query, queryOption);
+    };
+    DatabaseModel.prototype[`pickId${capitalize(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__pickId(query, queryOption);
+    };
+    DatabaseModel.prototype[`exists${capitalize(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__exists(query);
+    };
+    DatabaseModel.prototype[`count${capitalize(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__count(query);
+    };
+    DatabaseModel.prototype[`insight${capitalize(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__insight(query);
+    };
+  });
+  const loaderMetas = getLoaderMetas(database.Model);
+  loaderMetas.forEach((loaderMeta) => {
+    const loader2 = loaderMeta.type === "Field" ? createLoader(model, loaderMeta.fieldName) : loaderMeta.type === "ArrayField" ? createArrayLoader(model, loaderMeta.fieldName) : loaderMeta.type === "Query" ? createQueryLoader(model, loaderMeta.queryKeys ?? []) : null;
+    DatabaseModel.prototype[loaderMeta.key] = loader2;
+  });
+  Object.getOwnPropertyNames(database.Model.prototype).forEach((key) => {
+    DatabaseModel.prototype[key] = database.Model.prototype[key];
+  });
+  const createDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `create${className}`);
+  if (createDescriptor)
+    Transaction()(DatabaseModel.prototype, `create${className}`, createDescriptor);
+  const updateDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `update${className}`);
+  if (updateDescriptor)
+    Transaction()(DatabaseModel.prototype, `update${className}`, updateDescriptor);
+  const removeDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `remove${className}`);
+  if (removeDescriptor)
+    Transaction()(DatabaseModel.prototype, `remove${className}`, removeDescriptor);
+  Reflect.defineMetadata(database.refName, DatabaseModel, DatabaseModelStorage.prototype);
+  return new DatabaseModel();
+};
+export {
+  databaseModelOf
+};

package/src/dbDecorators.mjs

@@ -0,0 +1,93 @@
+import {
+  getClassMeta,
+  getFieldMetaMap,
+  setFieldMetaMap
+} from "@akanjs/constant";
+const dbOf = (refName, Input, Doc, Model2, Middleware, Obj, Insight, Filter, Summary) => {
+  return { refName, Input, Doc, Model: Model2, Middleware, Obj, Insight, Filter, Summary };
+};
+class InputDatabaseStorage {
+}
+class DocumentDatabaseStorage {
+}
+class ModelDatabaseStorage {
+}
+class MiddlewareDatabaseStorage {
+}
+const getAllDatabaseModelNames = () => {
+  const modelNames = Reflect.getMetadataKeys(ModelDatabaseStorage.prototype) ?? [];
+  return modelNames;
+};
+const Database = {
+  Input: (returns) => {
+    return function(target) {
+      const modelRef = returns();
+      const classMeta = getClassMeta(modelRef);
+      Reflect.defineMetadata(classMeta.refName, target, InputDatabaseStorage.prototype);
+    };
+  },
+  Document: (returns) => {
+    return function(target) {
+      const modelRef = returns();
+      const classMeta = getClassMeta(modelRef);
+      Reflect.defineMetadata(classMeta.refName, target, DocumentDatabaseStorage.prototype);
+    };
+  },
+  Model: (returns) => {
+    return function(target) {
+      const modelRef = returns();
+      const classMeta = getClassMeta(modelRef);
+      Reflect.defineMetadata(classMeta.refName, target, ModelDatabaseStorage.prototype);
+    };
+  },
+  Middleware: (returns) => {
+    return function(target) {
+      const modelRef = returns();
+      const classMeta = getClassMeta(modelRef);
+      Reflect.defineMetadata(classMeta.refName, target, MiddlewareDatabaseStorage.prototype);
+    };
+  }
+};
+const Model = (docRef, cnst) => {
+  class DefaultModel {
+  }
+  return DefaultModel;
+};
+const into = Model;
+const AddModel = (modelRef, cnst) => {
+  return modelRef;
+};
+const inside = AddModel;
+const by = (modelRef, addRef) => {
+  if (!addRef)
+    return InputOrDocument(modelRef);
+  return AddInputOrDocument(modelRef, addRef);
+};
+const InputOrDocument = (inputRef) => {
+  return inputRef;
+};
+const AddInputOrDocument = (modelRef, addRef) => {
+  const fieldMetaMap = getFieldMetaMap(modelRef);
+  const addFieldMetas = getFieldMetaMap(addRef);
+  setFieldMetaMap(modelRef, new Map([...fieldMetaMap, ...addFieldMetas]));
+  return modelRef;
+};
+const beyond = (model, doc) => {
+  return class Middleware {
+    onSchema(schema) {
+    }
+  };
+};
+export {
+  Database,
+  DocumentDatabaseStorage,
+  InputDatabaseStorage,
+  MiddlewareDatabaseStorage,
+  ModelDatabaseStorage,
+  beyond,
+  by,
+  dbOf,
+  getAllDatabaseModelNames,
+  inside,
+  into
+};

package/src/index.mjs

@@ -0,0 +1,5 @@
+export * from "./dbDecorators";
+export * from "./schema";
+export * from "./types";
+export * from "./database";
+export * from "./dataLoader";

package/src/schema.mjs

@@ -0,0 +1,104 @@
+import { dayjs } from "@akanjs/base";
+import { isValidDate } from "@akanjs/common";
+import { isValidObjectId, Types } from "mongoose";
+const getDefaultSchemaOptions = () => ({
+  toJSON: { getters: false, virtuals: true },
+  toObject: { getters: false, virtuals: true },
+  _id: true,
+  id: true,
+  timestamps: true,
+  methods: {
+    refresh: async function() {
+      Object.assign(this, await this.constructor.findById(this._id));
+      return this;
+    }
+  },
+  statics: {
+    pickOne: async function(query, projection) {
+      const doc = await this.findOne(query, projection);
+      if (!doc)
+        throw new Error("No Document");
+      return doc;
+    },
+    pickById: async function(docId, projection) {
+      if (!docId)
+        throw new Error("No Document ID");
+      const doc = await this.findById(docId, projection);
+      if (!doc)
+        throw new Error("No Document");
+      return doc;
+    },
+    sample: async function(query, size = 1, aggregations = []) {
+      const objs = await this.aggregate([
+        { $match: convertAggregateMatch(query) },
+        { $sample: { size } },
+        ...aggregations
+      ]);
+      return objs.map((obj) => new this(obj));
+    },
+    sampleOne: async function(query, aggregations = []) {
+      const obj = await this.aggregate([
+        { $match: convertAggregateMatch(query) },
+        { $sample: { size: 1 } },
+        ...aggregations
+      ]);
+      return obj.length ? new this(obj[0]) : null;
+    },
+    addSummary: async function(prefix = "total", num = 1) {
+      const update = Array.isArray(prefix) ? {
+        $inc: {
+          ...prefix.reduce((acc, cur) => ({ ...acc, [`${cur}${this.modelName}`]: num }), {})
+        }
+      } : { $inc: { [`${prefix}${this.modelName}`]: num } };
+      await this.db.collection("summaries").updateOne({ status: "active" }, update);
+    },
+    moveSummary: async function(prev, next, num = 1) {
+      await this.db.collection("summaries").updateOne(
+        { status: "active" },
+        {
+          $inc: {
+            [`${prev}${this.modelName}`]: -num,
+            [`${next}${this.modelName}`]: num
+          }
+        }
+      );
+    },
+    subSummary: async function(prefix = "total", num = 1) {
+      const update = Array.isArray(prefix) ? {
+        $inc: {
+          ...prefix.reduce((acc, cur) => ({ ...acc, [`${cur}${this.modelName}`]: -num }), {})
+        }
+      } : { $inc: { [`${prefix}${this.modelName}`]: -num } };
+      await this.db.collection("summaries").updateOne({ status: "active" }, update);
+    }
+  }
+});
+const convertOperatorValue = (value) => {
+  if (Array.isArray(value))
+    return value.map((v) => convertOperatorValue(v));
+  else if (!value)
+    return value;
+  else if (isValidObjectId(value))
+    return new Types.ObjectId(value);
+  else if (isValidDate(value))
+    return dayjs(value).toDate();
+  else if (value.constructor !== Object)
+    return value;
+  else if (typeof value !== "object")
+    return value;
+  else
+    return Object.fromEntries(
+      Object.entries(value).map(([key, value2]) => [key, convertOperatorValue(value2)])
+    );
+};
+const convertAggregateMatch = (query) => {
+  return Object.fromEntries(
+    Object.entries(query).map(([key, value]) => {
+      return [key, convertOperatorValue(value)];
+    })
+  );
+};
+export {
+  convertAggregateMatch,
+  getDefaultSchemaOptions
+};