@akanjs/server 0.0.45 → 0.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/server",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "type": "commonjs",
   "scripts": {
     "postinstall": "pnpm install @nestjs/mongoose@^10.1.0"
@@ -29,38 +29,17 @@
     "@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",
     "cookie-parser": "^1.4.7",
-    "dataloader": "^2.2.3",
     "dayjs": "^1.11.13",
     "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.3.2",
-    "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",
-    "pluralize": "^8.0.0",
     "redis": "^4.7.0",
-    "reflect-metadata": "^0.2.2",
-    "rxjs": "^7.8.1",
-    "socket.io-client": "^4.8.1",
-    "tunnel-ssh": "^5.2.0",
-    "ua-parser-js": "^1.0.40"
+    "rxjs": "^7.8.1"
   }
 }

package/src/boot.js

@@ -0,0 +1,197 @@
+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_signal = require("@akanjs/signal");
+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_dgram = __toESM(require("dgram"));
+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_module = require("./module");
+var import_searchDaemon = require("./searchDaemon");
+const createNestApp = async ({ registerModules, 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 = await (0, import_redis.createClient)({ url: redisUri }).connect();
+  let SubDatabaseModule = class {
+  };
+  SubDatabaseModule = __decorateClass([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      providers: [
+        { provide: "REDIS_CLIENT", useValue: redisClient },
+        {
+          provide: "MEILI_CLIENT",
+          useFactory: () => new import_meilisearch.MeiliSearch({ host: meiliUri, apiKey: (0, import_nest.generateMeiliKey)(env) })
+        }
+      ],
+      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,
+        (0, import_module.useGlobals)({
+          injects: { SearchClient: import_nest.SearchClient, DatabaseClient: import_nest.DatabaseClient, CacheClient: import_nest.CacheClient }
+        }),
+        ...["batch", "all"].includes(serverMode) && import_base.baseEnv.operationMode !== "edge" ? [import_searchDaemon.SearchDaemonModule] : [],
+        ...registerModules(env).filter((m) => !!m)
+      ],
+      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();
+  const udp = import_dgram.default.createSocket("udp4");
+  import_signal.client.setUdp(udp);
+  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.useGlobalInterceptors(new import_nest.CacheInterceptor(redisClient));
+    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();
+    }
+  };
+};

package/src/controller.js

@@ -0,0 +1,98 @@
+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_service = require("@akanjs/service");
+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) => {
+    if (!(0, import_service.isServiceEnabled)(allSrvs[srv]))
+      return;
+    (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;
+};

package/src/gql.js

@@ -0,0 +1,145 @@
+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 gql_exports = {};
+__export(gql_exports, {
+  DateScalar: () => DateScalar,
+  applyNestField: () => applyNestField,
+  generateGql: () => generateGql,
+  generateGqlInput: () => generateGqlInput
+});
+module.exports = __toCommonJS(gql_exports);
+var import_base = require("@akanjs/base");
+var import_constant = require("@akanjs/constant");
+var Nest = __toESM(require("@nestjs/graphql"));
+var import_graphql = require("@nestjs/graphql");
+var import_dayjs = require("dayjs");
+var import_graphql2 = require("graphql");
+var import_graphql_type_json = __toESM(require("graphql-type-json"));
+let DateScalar = class {
+  description = "Date custom scalar type";
+  parseValue(value) {
+    return (0, import_base.dayjs)(value);
+  }
+  serialize(value) {
+    if ((0, import_dayjs.isDayjs)(value))
+      return value.toDate();
+    else
+      return new Date(value);
+  }
+  parseLiteral(ast) {
+    if (ast.kind === import_graphql2.Kind.INT)
+      return (0, import_base.dayjs)(ast.value);
+    else if (ast.kind === import_graphql2.Kind.STRING)
+      return (0, import_base.dayjs)(ast.value);
+    else
+      return null;
+  }
+};
+DateScalar = __decorateClass([
+  Nest.Scalar("Date", () => Date)
+], DateScalar);
+class ObjectGqlStorage {
+}
+class InputGqlStorage {
+}
+const getPredefinedInqutGql = (refName) => {
+  const inputGql = Reflect.getMetadata(refName, InputGqlStorage.prototype);
+  return inputGql;
+};
+const setPredefinedInqutGql = (refName, inputGql) => {
+  Reflect.defineMetadata(refName, inputGql, InputGqlStorage.prototype);
+};
+const getPredefinedObjectGql = (refName) => {
+  const objectGql = Reflect.getMetadata(refName, ObjectGqlStorage.prototype);
+  return objectGql;
+};
+const setPredefinedObjectGql = (refName, objectGql) => {
+  Reflect.defineMetadata(refName, objectGql, ObjectGqlStorage.prototype);
+};
+const gqlNestFieldMap = /* @__PURE__ */ new Map([
+  [import_base.ID, Nest.ID],
+  [import_base.Int, Nest.Int],
+  [import_base.Float, Nest.Float],
+  [import_base.JSON, import_graphql_type_json.default],
+  [Map, import_graphql_type_json.default]
+]);
+const applyNestField = (model, fieldMeta, type = "object") => {
+  if (fieldMeta.fieldType === "hidden" && type === "object")
+    return;
+  const modelRef = fieldMeta.isClass ? type === "object" ? generateGql(fieldMeta.modelRef) : fieldMeta.isScalar ? generateGqlInput(fieldMeta.modelRef) : Nest.ID : gqlNestFieldMap.get(fieldMeta.modelRef) ?? fieldMeta.modelRef;
+  (0, import_graphql.Field)(() => (0, import_base.arraiedModel)(modelRef, fieldMeta.arrDepth), { nullable: fieldMeta.nullable })(
+    model.prototype,
+    fieldMeta.key
+  );
+};
+const generateGqlInput = (inputRef) => {
+  const classMeta = (0, import_constant.getClassMeta)(inputRef);
+  const predefinedInputGql = getPredefinedInqutGql(classMeta.refName);
+  if (predefinedInputGql)
+    return predefinedInputGql;
+  const fieldMetas = (0, import_constant.getFieldMetas)(inputRef);
+  class InputGql {
+  }
+  const inputGql = classMeta.type === "scalar" ? InputGql : (0, import_constant.getInputModelRef)(classMeta.refName);
+  fieldMetas.forEach((fieldMeta) => {
+    applyNestField(inputGql, fieldMeta, "input");
+  });
+  (0, import_graphql.InputType)(classMeta.refName + (classMeta.type === "scalar" ? "Input" : ""))(inputGql);
+  setPredefinedInqutGql(classMeta.refName, inputGql);
+  return inputGql;
+};
+const generateGql = (objectRef) => {
+  const classMeta = (0, import_constant.getClassMeta)(objectRef);
+  if (classMeta.type === "light") {
+    const fullModelRefName = classMeta.refName.slice(5);
+    const fullModelRef = (0, import_constant.getFullModelRef)(fullModelRefName);
+    return generateGql(fullModelRef);
+  }
+  const predefinedObjectGql = getPredefinedObjectGql(classMeta.refName);
+  if (predefinedObjectGql)
+    return predefinedObjectGql;
+  const fieldMetas = (0, import_constant.getFieldMetas)(objectRef);
+  class ObjectGql {
+  }
+  const objectGql = classMeta.type === "scalar" ? ObjectGql : (0, import_constant.getFullModelRef)(classMeta.refName);
+  fieldMetas.forEach((fieldMeta) => {
+    applyNestField(objectGql, fieldMeta);
+  });
+  (0, import_graphql.ObjectType)(classMeta.refName)(objectGql);
+  setPredefinedObjectGql(classMeta.refName, objectGql);
+  return objectGql;
+};

package/src/index.js

@@ -0,0 +1,26 @@
+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 src_exports = {};
+module.exports = __toCommonJS(src_exports);
+__reExport(src_exports, require("./gql"), module.exports);
+__reExport(src_exports, require("./resolver"), module.exports);
+__reExport(src_exports, require("./controller"), module.exports);
+__reExport(src_exports, require("./processor"), module.exports);
+__reExport(src_exports, require("./module"), module.exports);
+__reExport(src_exports, require("./types"), module.exports);
+__reExport(src_exports, require("./websocket"), module.exports);
+__reExport(src_exports, require("./boot"), module.exports);
+__reExport(src_exports, require("./searchDaemon"), module.exports);
+__reExport(src_exports, require("./schema"), module.exports);