@akanjs/document 0.0.99 → 0.0.101

package/index.js

@@ -1 +1,21 @@
-export * from "./src";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var document_exports = {};
+module.exports = __toCommonJS(document_exports);
+__reExport(document_exports, require("./src"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./src")
+});

package/index.mjs

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@akanjs/document",
-  "version": "0.0.99",
-  "type": "module",
+  "version": "0.0.101",
+  "type": "commonjs",
   "publishConfig": {
     "access": "public"
   },
@@ -21,8 +21,8 @@
   },
   "exports": {
     ".": {
-      "require": "./index.cjs",
-      "import": "./index.js"
+      "require": "./index.js",
+      "import": "./index.mjs"
     }
   },
   "esbuild": {

package/src/dataLoader.js

@@ -1,17 +1,58 @@
-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;
+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 __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 = (model, fieldName = "_id", defaultQuery = {}) => {
-  return new DataLoader(
+  return new import_dataloader.default(
     (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));
+        const listByKey = (0, import_lodash.keyBy)(list, fieldName);
+        return fields.map((id) => (0, import_lodash.get)(listByKey, id, null));
       });
       return data;
     },
@@ -19,7 +60,7 @@ const createLoader = (model, fieldName = "_id", defaultQuery = {}) => {
   );
 };
 const createArrayLoader = (model, fieldName = "_id", defaultQuery = {}) => {
-  return new DataLoader((fields) => {
+  return new import_dataloader.default((fields) => {
     const query = { ...defaultQuery };
     query[fieldName] = { $in: fields };
     const data = model.find(query).then((list) => {
@@ -29,20 +70,20 @@ const createArrayLoader = (model, fieldName = "_id", defaultQuery = {}) => {
   });
 };
 const createArrayElementLoader = (model, fieldName = "_id", defaultQuery = {}) => {
-  return new DataLoader(
+  return new import_dataloader.default(
     (fields) => {
       const query = { ...defaultQuery };
       query[fieldName] = { $in: fields };
       const data = model.find(query).then((list) => {
-        const flat = flatMap(
+        const flat = (0, import_lodash.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));
+        const listByKey = (0, import_lodash.groupBy)(flat, (dat) => dat.key);
+        return fields.map((id) => (0, import_lodash.get)(listByKey, id, null));
       });
       return data;
     },
@@ -50,15 +91,15 @@ const createArrayElementLoader = (model, fieldName = "_id", defaultQuery = {}) =
   );
 };
 const createQueryLoader = (model, queryKeys, defaultQuery = {}) => {
-  return new DataLoader(
+  return new import_dataloader.default(
     (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));
+        const listByKey = (0, import_lodash.keyBy)(list, getQueryKey);
+        return queries.map((query2) => (0, import_lodash.get)(listByKey, getQueryKey(query2), null));
       });
       return data;
     },
@@ -96,7 +137,8 @@ const Loader = {
     };
   }
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   DataLoader,
   Id,
   Loader,
@@ -107,4 +149,4 @@ export {
   createLoader,
   createQueryLoader,
   getLoaderMetas
-};
+});

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.js

@@ -1,20 +1,36 @@
-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";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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");
 class CacheDatabase {
   constructor(refName, redis) {
     this.refName = refName;
     this.redis = redis;
-    this.logger = new Logger(`${refName}Cache`);
+    this.logger = new import_common.Logger(`${refName}Cache`);
   }
   logger;
   async set(topic, key, value, option = {}) {
@@ -33,13 +49,13 @@ class SearchDatabase {
   constructor(refName, meili) {
     this.refName = refName;
     this.meili = meili;
-    this.logger = new Logger(`${refName}Search`);
-    this.index = meili.index(lowerlize(refName));
+    this.logger = new import_common.Logger(`${refName}Search`);
+    this.index = meili.index((0, import_common.lowerlize)(refName));
   }
   logger;
   index;
   async searchIds(searchText, option = {}) {
-    const { skip = 0, limit = DEFAULT_PAGE_SIZE, sort } = 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 };
@@ -54,7 +70,7 @@ class SearchDatabase {
     return { ids: hits.map((hit) => hit.id), total: estimatedTotalHits };
   }
   async count(searchText, option = {}) {
-    const { skip = 0, limit = DEFAULT_PAGE_SIZE, sort = "" } = 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;
@@ -73,40 +89,40 @@ class DatabaseModelStorage {
 }
 const databaseModelOf = (database, model, redis, meili) => {
   //! 잘되는지 확인 필요
-  const [modelName, className] = [database.refName, capitalize(database.refName)];
-  const insightFieldMetas = getFieldMetas(database.Insight);
+  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 = (query) => ({ removedAt: { $exists: false }, ...query ?? {} });
   const makeSafeMatchStage = (query) => ({
-    $match: { removedAt: { $exists: false }, ...convertAggregateMatch(query) }
+    $match: { removedAt: { $exists: false }, ...(0, import_schema.convertAggregateMatch)(query) }
   });
   const getListQuery = (query, queryOption) => {
     const find = makeSafeQuery(query);
-    const sort = getFilterSort(database.Filter, queryOption?.sort ?? "latest");
+    const sort = (0, import_constant.getFilterSort)(database.Filter, queryOption?.sort ?? "latest");
     const skip = queryOption?.skip ?? 0;
-    const limit = queryOption?.limit === null ? DEFAULT_PAGE_SIZE : queryOption?.limit ?? 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 };
   };
   const getFindQuery = (query, queryOption) => {
     const find = makeSafeQuery(query);
-    const sort = getFilterSort(database.Filter, queryOption?.sort ?? "latest");
+    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 };
   };
   const getSearchSort = (sortKey) => {
-    const sort = getFilterSort(database.Filter, sortKey ?? "latest");
+    const sort = (0, import_constant.getFilterSort)(database.Filter, sortKey ?? "latest");
     return Object.entries(sort).map(([key, value]) => `${key}:${value === 1 ? "asc" : "desc"}`);
   };
-  const loader = createLoader(model);
+  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 {
-    logger = new Logger(`${modelName}Model`);
+    logger = new import_common.Logger(`${modelName}Model`);
     __model = model;
     __cache = cacheDatabase;
     __search = searchDatabase;
@@ -169,7 +185,7 @@ const databaseModelOf = (database, model, redis, meili) => {
     async getDefaultSummary(addQuery = {}) {
       if (!database.Summary)
         return {};
-      const fieldMetas = getFieldMetas(database.Summary);
+      const fieldMetas = (0, import_constant.getFieldMetas)(database.Summary);
       const summary = {};
       await Promise.all(
         fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map(async (fieldMeta) => {
@@ -200,7 +216,7 @@ const databaseModelOf = (database, model, redis, meili) => {
     }
     async [`remove${className}`](id) {
       const doc = await this.__model.pickById(id);
-      return await doc.set({ removedAt: dayjs() }).save();
+      return await doc.set({ removedAt: (0, import_base.dayjs)() }).save();
     }
     async [`search${className}`](searchText, queryOption = {}) {
       const { skip, limit, sort } = queryOption;
@@ -224,55 +240,55 @@ const databaseModelOf = (database, model, redis, meili) => {
   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 queryFn = (0, import_constant.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 filterKeyMetaMap = (0, import_constant.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 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${capitalize(queryKey)}`] = async function(...args) {
+    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${capitalize(queryKey)}`] = async function(...args) {
+    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${capitalize(queryKey)}`] = async function(...args) {
+    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${capitalize(queryKey)}`] = async function(...args) {
+    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${capitalize(queryKey)}`] = async function(...args) {
+    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${capitalize(queryKey)}`] = async function(...args) {
+    DatabaseModel.prototype[`exists${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
       const query = queryFn(...args);
       return this.__exists(query);
     };
-    DatabaseModel.prototype[`count${capitalize(queryKey)}`] = async function(...args) {
+    DatabaseModel.prototype[`count${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
       const query = queryFn(...args);
       return this.__count(query);
     };
-    DatabaseModel.prototype[`insight${capitalize(queryKey)}`] = async function(...args) {
+    DatabaseModel.prototype[`insight${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
       const query = queryFn(...args);
       return this.__insight(query);
     };
   });
-  const loaderMetas = getLoaderMetas(database.Model);
+  const loaderMetas = (0, import_dataLoader.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;
+    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) => {
@@ -280,16 +296,17 @@ const databaseModelOf = (database, model, redis, meili) => {
   });
   const createDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `create${className}`);
   if (createDescriptor)
-    Transaction()(DatabaseModel.prototype, `create${className}`, createDescriptor);
+    (0, import_nest.Transaction)()(DatabaseModel.prototype, `create${className}`, createDescriptor);
   const updateDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `update${className}`);
   if (updateDescriptor)
-    Transaction()(DatabaseModel.prototype, `update${className}`, updateDescriptor);
+    (0, import_nest.Transaction)()(DatabaseModel.prototype, `update${className}`, updateDescriptor);
   const removeDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `remove${className}`);
   if (removeDescriptor)
-    Transaction()(DatabaseModel.prototype, `remove${className}`, removeDescriptor);
+    (0, import_nest.Transaction)()(DatabaseModel.prototype, `remove${className}`, removeDescriptor);
   Reflect.defineMetadata(database.refName, DatabaseModel, DatabaseModelStorage.prototype);
   return new DatabaseModel();
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   databaseModelOf
-};
+});