@akanjs/server 0.0.4

package/README.md

@@ -0,0 +1,11 @@
+# akan
+
+This library was generated with [Nx](https://nx.dev).
+
+## Building
+
+Run `nx build akan` to build the library.
+
+## Running unit tests
+
+Run `nx test akan` to execute the unit tests via [Jest](https://jestjs.io).

package/index.d.ts

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

package/index.js

@@ -0,0 +1,21 @@
+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 server_exports = {};
+module.exports = __toCommonJS(server_exports);
+__reExport(server_exports, require("./src"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ...require("./src")
+});

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@akanjs/server",
+  "version": "0.0.4",
+  "type": "commonjs",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/akan-team/akanjs.git",
+    "directory": "pkgs/@akanjs/server"
+  },
+  "dependencies": {
+    "@apollo/server": "4.11.2",
+    "@inquirer/prompts": "7.2.1",
+    "@nestjs/apollo": "12.2.2",
+    "@nestjs/bull": "10.2.3",
+    "@nestjs/common": "10.4.15",
+    "@nestjs/core": "10.4.15",
+    "@nestjs/graphql": "12.2.2",
+    "@nestjs/mongoose": "10.1.0",
+    "@nestjs/passport": "10.0.3",
+    "@nestjs/platform-express": "10.4.15",
+    "@nestjs/platform-socket.io": "10.4.15",
+    "@nestjs/schedule": "4.1.2",
+    "@nestjs/websockets": "10.4.15",
+    "@socket.io/redis-adapter": "8.3.0",
+    "@urql/core": "5.1.0",
+    "apple-signin": "1.0.9",
+    "body-parser": "1.20.3",
+    "bull": "4.16.5",
+    "class-transformer": "0.5.1",
+    "class-validator": "0.14.1",
+    "cookie-parser": "1.4.7",
+    "dataloader": "2.2.3",
+    "dayjs": "1.11.13",
+    "express": "4.21.2",
+    "graphql": "16.10.0",
+    "graphql-type-json": "0.3.2",
+    "graphql-upload": "12.0.0",
+    "iap": "1.1.1",
+    "immer": "10.1.1",
+    "jsonwebtoken": "9.0.2",
+    "lodash": "4.17.21",
+    "meilisearch": "0.47.0",
+    "mongoose": "8.9.3",
+    "next": "15.1.3",
+    "passport": "0.7.0",
+    "passport-apple": "2.0.2",
+    "passport-facebook": "3.0.0",
+    "passport-github": "1.1.0",
+    "passport-google-oauth20": "2.0.0",
+    "passport-kakao": "1.0.1",
+    "passport-naver": "1.0.6",
+    "picocolors": "1.1.1",
+    "pluralize": "8.0.0",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "redis": "4.7.0",
+    "reflect-metadata": "0.2.2",
+    "rxjs": "7.8.1",
+    "socket.io": "4.8.1",
+    "socket.io-client": "4.8.1",
+    "tunnel-ssh": "5.2.0",
+    "ua-parser-js": "1.0.40"
+  },
+  "main": "./index.js"
+}

package/src/boot.d.ts

@@ -0,0 +1,18 @@
+import { BackendEnv } from "@akanjs/base";
+import { DynamicModule, INestApplication } from "@nestjs/common";
+interface AppCreateForm {
+    registerModules: (options: any) => DynamicModule[];
+    registerBatches?: (options: any) => DynamicModule[];
+    serverMode?: "federation" | "batch" | "all" | "none";
+    env: BackendEnv;
+    log?: boolean;
+}
+export interface BackendApp {
+    nestApp: INestApplication;
+    close: () => Promise<void>;
+}
+export declare const createNestApp: ({ registerModules, registerBatches, serverMode, env, log, }: AppCreateForm) => Promise<{
+    nestApp: INestApplication<any>;
+    close: () => Promise<void>;
+}>;
+export {};

package/src/boot.js

@@ -0,0 +1,200 @@
+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 __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+var boot_exports = {};
+__export(boot_exports, {
+  createNestApp: () => createNestApp
+});
+module.exports = __toCommonJS(boot_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_nest = require("@akanjs/nest");
+var import_apollo = require("@nestjs/apollo");
+var import_bull = require("@nestjs/bull");
+var import_common2 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+var import_graphql = require("@nestjs/graphql");
+var import_mongoose = require("@nestjs/mongoose");
+var import_schedule = require("@nestjs/schedule");
+var import_body_parser = require("body-parser");
+var import_cookie_parser = __toESM(require("cookie-parser"));
+var import_events = __toESM(require("events"));
+var import_graphql_upload = require("graphql-upload");
+var import_meilisearch = require("meilisearch");
+var import_path = require("path");
+var import_redis = require("redis");
+var import_gql = require("./gql");
+var import_searchDaemon = require("./searchDaemon");
+const createNestApp = async ({
+  registerModules,
+  registerBatches,
+  serverMode = "federation",
+  env,
+  log = true
+}) => {
+  const backendLogger = new import_common.Logger("Backend");
+  if (log)
+    backendLogger.rawLog(import_base.logo);
+  const jwtSecret = (0, import_nest.generateJwtSecret)(env.appName, env.environment);
+  const [redisUri, mongoUri, meiliUri] = await Promise.all([
+    env.redisUri ?? (0, import_nest.generateRedisUri)({ ...env, ...env.redis?.sshOptions ? { sshOptions: env.redis.sshOptions } : {} }),
+    env.mongoUri ?? (0, import_nest.generateMongoUri)({
+      ...env,
+      ...env.mongo.username ? { username: env.mongo.username } : {},
+      password: env.mongo.password,
+      ...env.mongo.sshOptions ? { sshOptions: env.mongo.sshOptions } : {}
+    }),
+    env.meiliUri ?? (0, import_nest.generateMeiliUri)(env)
+  ]);
+  if (env.operationMode === "local") {
+    backendLogger.verbose(`connect to redis: ${redisUri}`);
+    backendLogger.verbose(`connect to mongo: ${mongoUri}`);
+    backendLogger.verbose(`connect to meili: ${meiliUri}`);
+  }
+  (0, import_nest.initMongoDB)({ logging: import_base.baseEnv.environment !== "main", sendReport: false });
+  import_events.default.EventEmitter.defaultMaxListeners = 1e3;
+  let AuthMiddleWare = class {
+    use(req, res, next) {
+      const requestHeader = req;
+      requestHeader.account = (0, import_nest.verifyToken)(
+        jwtSecret,
+        requestHeader.headers.authorization ?? (requestHeader.cookies?.jwt ? `Bearer ${requestHeader.cookies.jwt}` : void 0)
+      );
+      requestHeader.userAgent = requestHeader["user-agent"];
+      next();
+    }
+  };
+  AuthMiddleWare = __decorateClass([
+    (0, import_common2.Injectable)()
+  ], AuthMiddleWare);
+  const redisClient = (0, import_redis.createClient)({ url: redisUri });
+  let SubDatabaseModule = class {
+  };
+  SubDatabaseModule = __decorateClass([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      providers: [
+        { provide: "REDIS_CLIENT", useFactory: async () => await redisClient.connect() },
+        {
+          provide: "MEILI_CLIENT",
+          useFactory: () => new import_meilisearch.MeiliSearch({ host: meiliUri, apiKey: (0, import_nest.generateMeiliKey)(env) })
+        },
+        { provide: import_core.APP_INTERCEPTOR, useClass: import_nest.CacheInterceptor }
+      ],
+      exports: ["REDIS_CLIENT", "MEILI_CLIENT"]
+    })
+  ], SubDatabaseModule);
+  let AppModule = class {
+    configure(consumer) {
+      consumer.apply(AuthMiddleWare).forRoutes({ path: "*", method: import_common2.RequestMethod.ALL });
+    }
+  };
+  AppModule = __decorateClass([
+    (0, import_common2.Module)({
+      imports: [
+        import_bull.BullModule.forRoot({ redis: redisUri }),
+        import_schedule.ScheduleModule.forRoot(),
+        import_graphql.GraphQLModule.forRootAsync({
+          imports: [],
+          useFactory: () => ({
+            useGlobalPrefix: true,
+            autoSchemaFile: (0, import_path.join)(process.cwd(), "src/schema.gql"),
+            sortSchema: true,
+            playground: import_base.baseEnv.environment !== "main",
+            introspection: import_base.baseEnv.environment !== "main",
+            uploads: false,
+            debug: false
+          }),
+          driver: import_apollo.ApolloDriver
+        }),
+        import_mongoose.MongooseModule.forRootAsync({
+          useFactory: () => ({ uri: mongoUri, autoIndex: import_base.baseEnv.environment !== "main" })
+        }),
+        SubDatabaseModule,
+        ...["batch", "all"].includes(serverMode) && import_base.baseEnv.operationMode !== "edge" ? [import_searchDaemon.SearchDaemonModule] : [],
+        ...registerModules(env),
+        ...serverMode === "federation" || !registerBatches ? [] : registerBatches(env)
+      ],
+      providers: [import_gql.DateScalar]
+    })
+  ], AppModule);
+  const app = await import_core.NestFactory.create(AppModule, { logger: backendLogger });
+  const redisIoAdapter = new import_nest.RedisIoAdapter(app, { jwtSecret });
+  await redisIoAdapter.connectToRedis(redisUri);
+  app.enableShutdownHooks();
+  if (["federation", "all"].includes(serverMode)) {
+    app.setGlobalPrefix(process.env.GLOBAL_PREFIX ?? "/backend");
+    app.enableCors({
+      origin: "*",
+      methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+      preflightContinue: false,
+      optionsSuccessStatus: 204,
+      allowedHeaders: "DNT,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,apollo-require-preflight"
+    });
+    if (env.operationMode !== "local" && process.env.USE_REDIS_IO_ADAPTER !== "false")
+      app.useWebSocketAdapter(redisIoAdapter);
+    app.use((0, import_body_parser.json)({ limit: "100mb" }));
+    app.use((0, import_body_parser.urlencoded)({ limit: "100mb", extended: true }));
+    app.use("/backend/graphql", (0, import_graphql_upload.graphqlUploadExpress)());
+    app.use((0, import_cookie_parser.default)());
+    app.useGlobalInterceptors(new import_nest.LoggingInterceptor());
+    app.useGlobalInterceptors(new import_nest.TimeoutInterceptor());
+    app.useGlobalFilters(new import_nest.AllExceptionsFilter());
+    await app.listen(process.env.PORT ?? env.port ?? 8080);
+    backendLogger.log(`\u{1F680} Server is running on: ${await app.getUrl()}`);
+  } else {
+    await app.init();
+    backendLogger.log(`\u{1F680} Batch Server is running`);
+  }
+  if (module.hot) {
+    module.hot.accept();
+    module.hot.dispose(() => {
+      void app.close();
+    });
+  }
+  return {
+    nestApp: app,
+    close: async () => {
+      await app.close();
+      await redisIoAdapter.destroy();
+      await redisClient.quit();
+    }
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNestApp
+});

package/src/controller.d.ts

@@ -0,0 +1,6 @@
+import { Type } from "@akanjs/base";
+export declare const controllerOf: (sigRef: Type, allSrvs: {
+    [key: string]: Type;
+}) => {
+    new (): {};
+};

package/src/controller.js

@@ -0,0 +1,99 @@
+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 controller_exports = {};
+__export(controller_exports, {
+  controllerOf: () => controllerOf
+});
+module.exports = __toCommonJS(controller_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_nest = require("@akanjs/nest");
+var import_signal = require("@akanjs/signal");
+var import_common2 = require("@nestjs/common");
+var import_passport = require("@nestjs/passport");
+var import_platform_express = require("@nestjs/platform-express");
+const internalArgMap = {
+  // Parent: Nest.Parent,
+  Account: import_nest.Account,
+  UserIp: import_nest.UserIp,
+  Access: import_nest.Access,
+  Self: import_nest.Self,
+  Me: import_nest.Me,
+  Req: import_nest.Req,
+  Res: import_nest.Res
+};
+const controllerOf = (sigRef, allSrvs) => {
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+  const gqlMetas = (0, import_signal.getGqlMetas)(sigRef);
+  const prefix = (0, import_signal.getControllerPrefix)(sigMeta);
+  const Ctrl = (0, import_signal.copySignal)(sigRef);
+  Object.keys(allSrvs).forEach((srv) => {
+    (0, import_common2.Inject)(allSrvs[srv])(Ctrl.prototype, (0, import_common.lowerlize)(srv));
+  });
+  for (const gqlMeta of gqlMetas) {
+    if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "graphql" || !["Query", "Mutation"].includes(gqlMeta.type))
+      continue;
+    const [argMetas, internalArgMetas] = (0, import_signal.getArgMetas)(Ctrl, gqlMeta.key);
+    internalArgMetas.forEach((internalArgMeta) => {
+      const internalDecorator = internalArgMap[internalArgMeta.type];
+      internalDecorator(internalArgMeta.option ?? {})(Ctrl.prototype, gqlMeta.key, internalArgMeta.idx);
+    });
+    const uploadArgMeta = argMetas.find((argMeta) => argMeta.type === "Upload");
+    if (uploadArgMeta && gqlMeta.signalOption.onlyFor === "restapi") {
+      const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(uploadArgMeta.returns());
+      if (modelRef.prototype !== import_base.Upload.prototype)
+        throw new Error("Upload must be Upload");
+      else if (!arrDepth)
+        throw new Error(`Only Array of Upload is allowed - ${sigMeta.refName}/${gqlMeta.key}`);
+      (0, import_common2.UseInterceptors)((0, import_platform_express.FilesInterceptor)(uploadArgMeta.name))(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+      (0, import_common2.UploadedFiles)(import_nest.MulterToUploadPipe)(Ctrl.prototype, gqlMeta.key, uploadArgMeta.idx);
+    }
+    const queryArgMetas = argMetas.filter((argMeta) => argMeta.type === "Query");
+    queryArgMetas.forEach((argMeta) => {
+      const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
+      (0, import_common2.Query)(argMeta.name, ...(0, import_nest.getQueryPipes)(modelRef, arrDepth))(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+    });
+    const paramArgMetas = argMetas.filter((argMeta) => argMeta.type === "Param");
+    paramArgMetas.forEach((argMeta) => {
+      (0, import_common2.Param)(argMeta.name)(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+    });
+    const path = (0, import_signal.getControllerPath)(gqlMeta, paramArgMetas);
+    const bodyArgMetas = argMetas.filter((argMeta) => argMeta.type === "Body");
+    if (bodyArgMetas.length)
+      bodyArgMetas.forEach((argMeta) => {
+        (0, import_common2.Body)(argMeta.name, ...(0, import_nest.getBodyPipes)(argMeta))(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+      });
+    (0, import_common2.UseGuards)(
+      ...gqlMeta.guards.map((guard) => import_nest.guards[guard]),
+      ...gqlMeta.signalOption.sso ? [(0, import_passport.AuthGuard)(gqlMeta.signalOption.sso)] : []
+    )(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+    if (gqlMeta.type === "Query")
+      (0, import_common2.Get)(path)(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+    else if (gqlMeta.type === "Mutation")
+      (0, import_common2.Post)(path)(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+  }
+  if (prefix)
+    (0, import_common2.Controller)(prefix)(Ctrl);
+  else
+    (0, import_common2.Controller)()(Ctrl);
+  return Ctrl;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  controllerOf
+});

package/src/dataLoader.d.ts

@@ -0,0 +1,26 @@
+import type { Type } from "@akanjs/base";
+import DataLoader from "dataloader";
+import type { FilterQuery, Model } from "mongoose";
+import { Schema, Types } from "mongoose";
+export declare const Id: typeof Types.ObjectId;
+export declare const ObjectId: typeof Schema.Types.ObjectId;
+export declare const Mixed: typeof Schema.Types.Mixed;
+export { DataLoader };
+export declare const createLoader: <Key, Value>(model: Model<any>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<Key, Value, Key>;
+export declare const createArrayLoader: <K, V>(model: Model<unknown, unknown, unknown, unknown>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<K, V, K>;
+export declare const createArrayElementLoader: <K, V>(model: Model<unknown>, fieldName?: string, defaultQuery?: FilterQuery<unknown>) => DataLoader<K, V, K>;
+export declare const createQueryLoader: <Key, Value>(model: Model<any>, queryKeys: string[], defaultQuery?: FilterQuery<unknown>) => DataLoader<Key, Value, Key>;
+export interface LoaderMeta {
+    key: string;
+    type: "Field" | "ArrayField" | "Query";
+    fieldName?: string;
+    queryKeys?: string[];
+    defaultQuery: FilterQuery<unknown>;
+}
+export declare const getLoaderMetas: (target: Type) => LoaderMeta[];
+export type Loader<Field, Value> = DataLoader<Field, Value | null>;
+export declare const Loader: {
+    ByField: (fieldName: string, defaultQuery?: FilterQuery<unknown>) => (target: object, key: string) => void;
+    ByArrayField: (fieldName: string, defaultQuery?: FilterQuery<unknown>) => (target: object, key: string) => void;
+    ByQuery: (queryKeys: string[], defaultQuery?: FilterQuery<unknown>) => (target: object, key: string) => void;
+};

package/src/dataLoader.js

@@ -0,0 +1,152 @@
+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 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 }
+  );
+};
+const createArrayLoader = (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;
+  });
+};
+const createArrayElementLoader = (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 }
+  );
+};
+const createQueryLoader = (model, queryKeys, defaultQuery = {}) => {
+  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 = (0, import_lodash.keyBy)(list, getQueryKey);
+        return queries.map((query2) => (0, import_lodash.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);
+    };
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DataLoader,
+  Id,
+  Loader,
+  Mixed,
+  ObjectId,
+  createArrayElementLoader,
+  createArrayLoader,
+  createLoader,
+  createQueryLoader,
+  getLoaderMetas
+});