@akanjs/document 0.0.40 → 0.0.41

package/src/dataLoader.js

@@ -1,184 +0,0 @@
-var __create = Object.create;
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var dataLoader_exports = {};
-__export(dataLoader_exports, {
-  DataLoader: () => import_dataloader.default,
-  Id: () => Id,
-  Loader: () => Loader,
-  Mixed: () => Mixed,
-  ObjectId: () => ObjectId,
-  createArrayElementLoader: () => createArrayElementLoader,
-  createArrayLoader: () => createArrayLoader,
-  createLoader: () => createLoader,
-  createQueryLoader: () => createQueryLoader,
-  getLoaderMetas: () => getLoaderMetas
-});
-module.exports = __toCommonJS(dataLoader_exports);
-var import_dataloader = __toESM(require("dataloader"));
-var import_lodash = require("lodash");
-var import_mongoose = require("mongoose");
-const Id = import_mongoose.Types.ObjectId;
-const ObjectId = import_mongoose.Schema.Types.ObjectId;
-const Mixed = import_mongoose.Schema.Types.Mixed;
-const createLoader = /* @__PURE__ */ __name((model, fieldName = "_id", defaultQuery = {}) => {
-  return new import_dataloader.default((fields) => {
-    const query = {
-      ...defaultQuery
-    };
-    query[fieldName] = {
-      $in: fields
-    };
-    const data = model.find(query).then((list) => {
-      const listByKey = (0, import_lodash.keyBy)(list, fieldName);
-      return fields.map((id) => (0, import_lodash.get)(listByKey, id, null));
-    });
-    return data;
-  }, {
-    name: "dataloader",
-    cache: false
-  });
-}, "createLoader");
-const createArrayLoader = /* @__PURE__ */ __name((model, fieldName = "_id", defaultQuery = {}) => {
-  return new import_dataloader.default((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;
-  });
-}, "createArrayLoader");
-const createArrayElementLoader = /* @__PURE__ */ __name((model, fieldName = "_id", defaultQuery = {}) => {
-  return new import_dataloader.default((fields) => {
-    const query = {
-      ...defaultQuery
-    };
-    query[fieldName] = {
-      $in: fields
-    };
-    const data = model.find(query).then((list) => {
-      const flat = (0, import_lodash.flatMap)(list, (dat) => dat[fieldName].map((datField) => ({
-        ...dat.toObject(),
-        key: datField
-      })));
-      const listByKey = (0, import_lodash.groupBy)(flat, (dat) => dat.key);
-      return fields.map((id) => (0, import_lodash.get)(listByKey, id, null));
-    });
-    return data;
-  }, {
-    name: "dataloader",
-    cache: false
-  });
-}, "createArrayElementLoader");
-const createQueryLoader = /* @__PURE__ */ __name((model, queryKeys, defaultQuery = {}) => {
-  return new import_dataloader.default((queries) => {
-    const query = {
-      $and: [
-        {
-          $or: queries
-        },
-        defaultQuery
-      ]
-    };
-    const getQueryKey = /* @__PURE__ */ __name((query2) => queryKeys.map((key) => query2[key].toString()).join(""), "getQueryKey");
-    const data = model.find(query).then((list) => {
-      const listByKey = (0, import_lodash.keyBy)(list, getQueryKey);
-      return queries.map((query2) => (0, import_lodash.get)(listByKey, getQueryKey(query2), null));
-    });
-    return data;
-  }, {
-    name: "dataloader",
-    cache: false
-  });
-}, "createQueryLoader");
-const getLoaderMetaMapByPrototype = /* @__PURE__ */ __name((prototype) => {
-  const loaderMetaMap = Reflect.getOwnMetadata("loaders", prototype) ?? /* @__PURE__ */ new Map();
-  return loaderMetaMap;
-}, "getLoaderMetaMapByPrototype");
-const getLoaderMetas = /* @__PURE__ */ __name((target) => {
-  const metas = [
-    ...getLoaderMetaMapByPrototype(target.prototype).values()
-  ];
-  return metas;
-}, "getLoaderMetas");
-const Loader = {
-  ByField: /* @__PURE__ */ __name((fieldName, defaultQuery = {}) => {
-    return function(target, key) {
-      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
-      loaderMetaMap.set(key, {
-        key,
-        type: "Field",
-        fieldName,
-        defaultQuery
-      });
-      Reflect.defineMetadata("loaders", loaderMetaMap, target);
-    };
-  }, "ByField"),
-  ByArrayField: /* @__PURE__ */ __name((fieldName, defaultQuery = {}) => {
-    return function(target, key) {
-      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
-      loaderMetaMap.set(key, {
-        key,
-        type: "ArrayField",
-        fieldName,
-        defaultQuery
-      });
-      Reflect.defineMetadata("loaders", loaderMetaMap, target);
-    };
-  }, "ByArrayField"),
-  ByQuery: /* @__PURE__ */ __name((queryKeys, defaultQuery = {}) => {
-    return function(target, key) {
-      const loaderMetaMap = getLoaderMetaMapByPrototype(target);
-      loaderMetaMap.set(key, {
-        key,
-        type: "Query",
-        queryKeys,
-        defaultQuery
-      });
-      Reflect.defineMetadata("loaders", loaderMetaMap, target);
-    };
-  }, "ByQuery")
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  DataLoader,
-  Id,
-  Loader,
-  Mixed,
-  ObjectId,
-  createArrayElementLoader,
-  createArrayLoader,
-  createLoader,
-  createQueryLoader,
-  getLoaderMetas
-});

package/src/database.js

@@ -1,410 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var database_exports = {};
-__export(database_exports, {
-  databaseModelOf: () => databaseModelOf
-});
-module.exports = __toCommonJS(database_exports);
-var import_base = require("@akanjs/base");
-var import_common = require("@akanjs/common");
-var import_constant = require("@akanjs/constant");
-var import_nest = require("@akanjs/nest");
-var import_dataLoader = require("./dataLoader");
-var import_schema = require("./schema");
-let CacheDatabase = class CacheDatabase2 {
-  static {
-    __name(this, "CacheDatabase");
-  }
-  refName;
-  redis;
-  logger;
-  constructor(refName, redis) {
-    this.refName = refName;
-    this.redis = redis;
-    this.logger = new import_common.Logger(`${refName}Cache`);
-  }
-  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}`);
-  }
-};
-let SearchDatabase = class SearchDatabase2 {
-  static {
-    __name(this, "SearchDatabase");
-  }
-  refName;
-  meili;
-  logger;
-  index;
-  constructor(refName, meili) {
-    this.refName = refName;
-    this.meili = meili;
-    this.logger = new import_common.Logger(`${refName}Search`);
-    this.index = meili.index((0, import_common.lowerlize)(refName));
-  }
-  async searchIds(searchText, option = {}) {
-    const { skip = 0, limit = import_constant.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 = import_constant.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;
-  }
-};
-let DatabaseModelStorage = class DatabaseModelStorage2 {
-  static {
-    __name(this, "DatabaseModelStorage");
-  }
-  __ModelType__ = "DatabaseModelStorage";
-};
-const databaseModelOf = /* @__PURE__ */ __name((database, model, redis, meili) => {
-  const [modelName, className] = [
-    database.refName,
-    (0, import_common.capitalize)(database.refName)
-  ];
-  const insightFieldMetas = (0, import_constant.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 = /* @__PURE__ */ __name((query) => ({
-    removedAt: {
-      $exists: false
-    },
-    ...query ?? {}
-  }), "makeSafeQuery");
-  const makeSafeMatchStage = /* @__PURE__ */ __name((query) => ({
-    $match: {
-      removedAt: {
-        $exists: false
-      },
-      ...(0, import_schema.convertAggregateMatch)(query)
-    }
-  }), "makeSafeMatchStage");
-  const getListQuery = /* @__PURE__ */ __name((query, queryOption) => {
-    const find = makeSafeQuery(query);
-    const sort = (0, import_constant.getFilterSort)(database.Filter, queryOption?.sort ?? "latest");
-    const skip = queryOption?.skip ?? 0;
-    const limit = queryOption?.limit === null ? import_constant.DEFAULT_PAGE_SIZE : queryOption?.limit ?? 0;
-    const select = queryOption?.select;
-    const sample = queryOption?.sample;
-    return {
-      find,
-      sort,
-      skip,
-      limit,
-      select,
-      sample
-    };
-  }, "getListQuery");
-  const getFindQuery = /* @__PURE__ */ __name((query, queryOption) => {
-    const find = makeSafeQuery(query);
-    const sort = (0, import_constant.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
-    };
-  }, "getFindQuery");
-  const getSearchSort = /* @__PURE__ */ __name((sortKey) => {
-    const sort = (0, import_constant.getFilterSort)(database.Filter, sortKey ?? "latest");
-    return Object.entries(sort).map(([key, value]) => `${key}:${value === 1 ? "asc" : "desc"}`);
-  }, "getSearchSort");
-  const loader = (0, import_dataLoader.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 {
-    static {
-      __name(this, "DatabaseModel");
-    }
-    logger = new import_common.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 = (0, import_constant.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: (0, import_base.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 = /* @__PURE__ */ __name((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 = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
-    const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
-    const queryOption = hasQueryOption ? lastArg : {};
-    return {
-      query,
-      queryOption
-    };
-  }, "getQueryDataFromKey");
-  const filterKeyMetaMap = (0, import_constant.getFilterKeyMetaMapOnPrototype)(database.Filter.prototype);
-  const queryKeys = [
-    ...filterKeyMetaMap.keys()
-  ];
-  queryKeys.forEach((queryKey) => {
-    const queryFn = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
-    DatabaseModel.prototype[`list${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__list(query, queryOption);
-    };
-    DatabaseModel.prototype[`listIds${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__listIds(query, queryOption);
-    };
-    DatabaseModel.prototype[`find${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__find(query, queryOption);
-    };
-    DatabaseModel.prototype[`findId${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__findId(query, queryOption);
-    };
-    DatabaseModel.prototype[`pick${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__pick(query, queryOption);
-    };
-    DatabaseModel.prototype[`pickId${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
-      return this.__pickId(query, queryOption);
-    };
-    DatabaseModel.prototype[`exists${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const query = queryFn(...args);
-      return this.__exists(query);
-    };
-    DatabaseModel.prototype[`count${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const query = queryFn(...args);
-      return this.__count(query);
-    };
-    DatabaseModel.prototype[`insight${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
-      const query = queryFn(...args);
-      return this.__insight(query);
-    };
-  });
-  const loaderMetas = (0, import_dataLoader.getLoaderMetas)(database.Model);
-  loaderMetas.forEach((loaderMeta) => {
-    const loader2 = loaderMeta.type === "Field" ? (0, import_dataLoader.createLoader)(model, loaderMeta.fieldName) : loaderMeta.type === "ArrayField" ? (0, import_dataLoader.createArrayLoader)(model, loaderMeta.fieldName) : loaderMeta.type === "Query" ? (0, import_dataLoader.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) (0, import_nest.Transaction)()(DatabaseModel.prototype, `create${className}`, createDescriptor);
-  const updateDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `update${className}`);
-  if (updateDescriptor) (0, import_nest.Transaction)()(DatabaseModel.prototype, `update${className}`, updateDescriptor);
-  const removeDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `remove${className}`);
-  if (removeDescriptor) (0, import_nest.Transaction)()(DatabaseModel.prototype, `remove${className}`, removeDescriptor);
-  Reflect.defineMetadata(database.refName, DatabaseModel, DatabaseModelStorage.prototype);
-  return new DatabaseModel();
-}, "databaseModelOf");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  databaseModelOf
-});