@akanjs/server 0.0.99 → 0.0.100

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 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/index.mjs

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

package/package.json

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

package/src/boot.js

@@ -1,5 +1,30 @@
+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--)
@@ -9,74 +34,58 @@ var __decorateClass = (decorators, target, key, kind) => {
     __defProp(target, key, result);
   return result;
 };
-import { baseEnv, logo } from "@akanjs/base";
-import { Logger } from "@akanjs/common";
-import {
-  AllExceptionsFilter,
-  CacheClient,
-  CacheInterceptor,
-  DatabaseClient,
-  generateJwtSecret,
-  generateMeiliKey,
-  generateMeiliUri,
-  generateMongoUri,
-  generateRedisUri,
-  initMongoDB,
-  LoggingInterceptor,
-  RedisIoAdapter,
-  SearchClient,
-  TimeoutInterceptor,
-  verifyToken
-} from "@akanjs/nest";
-import { client } from "@akanjs/signal";
-import { ApolloDriver } from "@nestjs/apollo";
-import { BullModule } from "@nestjs/bull";
-import {
-  Global,
-  Injectable,
-  Module,
-  RequestMethod
-} from "@nestjs/common";
-import { NestFactory } from "@nestjs/core";
-import { GraphQLModule } from "@nestjs/graphql";
-import { MongooseModule } from "@nestjs/mongoose";
-import { ScheduleModule } from "@nestjs/schedule";
-import { json, urlencoded } from "body-parser";
-import cookieParser from "cookie-parser";
-import dgram from "dgram";
-import events from "events";
-import { graphqlUploadExpress } from "graphql-upload";
-import { MeiliSearch } from "meilisearch";
-import { createClient } from "redis";
-import { DateScalar } from "./gql";
-import { useGlobals } from "./module";
-import { SearchDaemonModule } from "./searchDaemon";
+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_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 Logger("Backend");
+  const backendLogger = new import_common.Logger("Backend");
   if (log)
-    backendLogger.rawLog(logo);
-  const jwtSecret = generateJwtSecret(env.appName, env.environment);
+    backendLogger.rawLog(import_base.logo);
+  const jwtSecret = (0, import_nest.generateJwtSecret)(env.appName, env.environment);
   const [redisUri, mongoUri, meiliUri] = await Promise.all([
-    env.redisUri ?? generateRedisUri({ ...env, ...env.redis?.sshOptions ? { sshOptions: env.redis.sshOptions } : {} }),
-    env.mongoUri ?? generateMongoUri({
+    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 ?? generateMeiliUri(env)
+    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}`);
   }
-  initMongoDB({ logging: baseEnv.environment !== "main", sendReport: false });
-  events.EventEmitter.defaultMaxListeners = 1e3;
+  (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 = verifyToken(
+      requestHeader.account = (0, import_nest.verifyToken)(
         jwtSecret,
         requestHeader.headers.authorization ?? (requestHeader.cookies?.jwt ? `Bearer ${requestHeader.cookies.jwt}` : void 0)
       );
@@ -85,19 +94,19 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
     }
   };
   AuthMiddleWare = __decorateClass([
-    Injectable()
+    (0, import_common2.Injectable)()
   ], AuthMiddleWare);
-  const redisClient = await createClient({ url: redisUri }).connect();
+  const redisClient = await (0, import_redis.createClient)({ url: redisUri }).connect();
   let SubDatabaseModule = class {
   };
   SubDatabaseModule = __decorateClass([
-    Global(),
-    Module({
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
       providers: [
         { provide: "REDIS_CLIENT", useValue: redisClient },
         {
           provide: "MEILI_CLIENT",
-          useFactory: () => new MeiliSearch({ host: meiliUri, apiKey: generateMeiliKey(env) })
+          useFactory: () => new import_meilisearch.MeiliSearch({ host: meiliUri, apiKey: (0, import_nest.generateMeiliKey)(env) })
         }
       ],
       exports: ["REDIS_CLIENT", "MEILI_CLIENT"]
@@ -105,46 +114,46 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
   ], SubDatabaseModule);
   let AppModule = class {
     configure(consumer) {
-      consumer.apply(AuthMiddleWare).forRoutes({ path: "*", method: RequestMethod.ALL });
+      consumer.apply(AuthMiddleWare).forRoutes({ path: "*", method: import_common2.RequestMethod.ALL });
     }
   };
   AppModule = __decorateClass([
-    Module({
+    (0, import_common2.Module)({
       imports: [
-        BullModule.forRoot({ redis: redisUri }),
-        ScheduleModule.forRoot(),
-        GraphQLModule.forRootAsync({
+        import_bull.BullModule.forRoot({ redis: redisUri }),
+        import_schedule.ScheduleModule.forRoot(),
+        import_graphql.GraphQLModule.forRootAsync({
           imports: [],
           useFactory: () => ({
             useGlobalPrefix: true,
             autoSchemaFile: true,
             sortSchema: true,
-            playground: baseEnv.environment !== "main",
-            introspection: baseEnv.environment !== "main",
+            playground: import_base.baseEnv.environment !== "main",
+            introspection: import_base.baseEnv.environment !== "main",
             uploads: false,
             debug: false
           }),
-          driver: ApolloDriver
+          driver: import_apollo.ApolloDriver
         }),
-        MongooseModule.forRootAsync({
-          useFactory: () => ({ uri: mongoUri, autoIndex: baseEnv.environment !== "main" })
+        import_mongoose.MongooseModule.forRootAsync({
+          useFactory: () => ({ uri: mongoUri, autoIndex: import_base.baseEnv.environment !== "main" })
         }),
         SubDatabaseModule,
-        useGlobals({
-          injects: { SearchClient, DatabaseClient, CacheClient }
+        (0, import_module.useGlobals)({
+          injects: { SearchClient: import_nest.SearchClient, DatabaseClient: import_nest.DatabaseClient, CacheClient: import_nest.CacheClient }
         }),
-        ...["batch", "all"].includes(serverMode) && baseEnv.operationMode !== "edge" ? [SearchDaemonModule] : [],
+        ...["batch", "all"].includes(serverMode) && import_base.baseEnv.operationMode !== "edge" ? [import_searchDaemon.SearchDaemonModule] : [],
         ...registerModules(env).filter((m) => !!m)
       ],
-      providers: [DateScalar]
+      providers: [import_gql.DateScalar]
     })
   ], AppModule);
-  const app = await NestFactory.create(AppModule, { logger: backendLogger });
-  const redisIoAdapter = new RedisIoAdapter(app, { jwtSecret });
+  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 = dgram.createSocket("udp4");
-  client.setUdp(udp);
+  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({
@@ -156,14 +165,14 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
     });
     if (env.operationMode !== "local" && process.env.USE_REDIS_IO_ADAPTER !== "false")
       app.useWebSocketAdapter(redisIoAdapter);
-    app.use(json({ limit: "100mb" }));
-    app.use(urlencoded({ limit: "100mb", extended: true }));
-    app.use("/backend/graphql", graphqlUploadExpress());
-    app.use(cookieParser());
-    app.useGlobalInterceptors(new LoggingInterceptor());
-    app.useGlobalInterceptors(new TimeoutInterceptor());
-    app.useGlobalInterceptors(new CacheInterceptor(redisClient));
-    app.useGlobalFilters(new AllExceptionsFilter());
+    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 {
@@ -185,6 +194,7 @@ const createNestApp = async ({ registerModules, serverMode = "federation", env,
     }
   };
 };
-export {
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
   createNestApp
-};
+});

package/src/boot.mjs

@@ -0,0 +1,190 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+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;
+};
+import { baseEnv, logo } from "@akanjs/base";
+import { Logger } from "@akanjs/common";
+import {
+  AllExceptionsFilter,
+  CacheClient,
+  CacheInterceptor,
+  DatabaseClient,
+  generateJwtSecret,
+  generateMeiliKey,
+  generateMeiliUri,
+  generateMongoUri,
+  generateRedisUri,
+  initMongoDB,
+  LoggingInterceptor,
+  RedisIoAdapter,
+  SearchClient,
+  TimeoutInterceptor,
+  verifyToken
+} from "@akanjs/nest";
+import { client } from "@akanjs/signal";
+import { ApolloDriver } from "@nestjs/apollo";
+import { BullModule } from "@nestjs/bull";
+import {
+  Global,
+  Injectable,
+  Module,
+  RequestMethod
+} from "@nestjs/common";
+import { NestFactory } from "@nestjs/core";
+import { GraphQLModule } from "@nestjs/graphql";
+import { MongooseModule } from "@nestjs/mongoose";
+import { ScheduleModule } from "@nestjs/schedule";
+import { json, urlencoded } from "body-parser";
+import cookieParser from "cookie-parser";
+import dgram from "dgram";
+import events from "events";
+import { graphqlUploadExpress } from "graphql-upload";
+import { MeiliSearch } from "meilisearch";
+import { createClient } from "redis";
+import { DateScalar } from "./gql";
+import { useGlobals } from "./module";
+import { SearchDaemonModule } from "./searchDaemon";
+const createNestApp = async ({ registerModules, serverMode = "federation", env, log = true }) => {
+  const backendLogger = new Logger("Backend");
+  if (log)
+    backendLogger.rawLog(logo);
+  const jwtSecret = generateJwtSecret(env.appName, env.environment);
+  const [redisUri, mongoUri, meiliUri] = await Promise.all([
+    env.redisUri ?? generateRedisUri({ ...env, ...env.redis?.sshOptions ? { sshOptions: env.redis.sshOptions } : {} }),
+    env.mongoUri ?? generateMongoUri({
+      ...env,
+      ...env.mongo.username ? { username: env.mongo.username } : {},
+      password: env.mongo.password,
+      ...env.mongo.sshOptions ? { sshOptions: env.mongo.sshOptions } : {}
+    }),
+    env.meiliUri ?? generateMeiliUri(env)
+  ]);
+  if (env.operationMode === "local") {
+    backendLogger.verbose(`connect to redis: ${redisUri}`);
+    backendLogger.verbose(`connect to mongo: ${mongoUri}`);
+    backendLogger.verbose(`connect to meili: ${meiliUri}`);
+  }
+  initMongoDB({ logging: baseEnv.environment !== "main", sendReport: false });
+  events.EventEmitter.defaultMaxListeners = 1e3;
+  let AuthMiddleWare = class {
+    use(req, res, next) {
+      const requestHeader = req;
+      requestHeader.account = verifyToken(
+        jwtSecret,
+        requestHeader.headers.authorization ?? (requestHeader.cookies?.jwt ? `Bearer ${requestHeader.cookies.jwt}` : void 0)
+      );
+      requestHeader.userAgent = requestHeader["user-agent"];
+      next();
+    }
+  };
+  AuthMiddleWare = __decorateClass([
+    Injectable()
+  ], AuthMiddleWare);
+  const redisClient = await createClient({ url: redisUri }).connect();
+  let SubDatabaseModule = class {
+  };
+  SubDatabaseModule = __decorateClass([
+    Global(),
+    Module({
+      providers: [
+        { provide: "REDIS_CLIENT", useValue: redisClient },
+        {
+          provide: "MEILI_CLIENT",
+          useFactory: () => new MeiliSearch({ host: meiliUri, apiKey: generateMeiliKey(env) })
+        }
+      ],
+      exports: ["REDIS_CLIENT", "MEILI_CLIENT"]
+    })
+  ], SubDatabaseModule);
+  let AppModule = class {
+    configure(consumer) {
+      consumer.apply(AuthMiddleWare).forRoutes({ path: "*", method: RequestMethod.ALL });
+    }
+  };
+  AppModule = __decorateClass([
+    Module({
+      imports: [
+        BullModule.forRoot({ redis: redisUri }),
+        ScheduleModule.forRoot(),
+        GraphQLModule.forRootAsync({
+          imports: [],
+          useFactory: () => ({
+            useGlobalPrefix: true,
+            autoSchemaFile: true,
+            sortSchema: true,
+            playground: baseEnv.environment !== "main",
+            introspection: baseEnv.environment !== "main",
+            uploads: false,
+            debug: false
+          }),
+          driver: ApolloDriver
+        }),
+        MongooseModule.forRootAsync({
+          useFactory: () => ({ uri: mongoUri, autoIndex: baseEnv.environment !== "main" })
+        }),
+        SubDatabaseModule,
+        useGlobals({
+          injects: { SearchClient, DatabaseClient, CacheClient }
+        }),
+        ...["batch", "all"].includes(serverMode) && baseEnv.operationMode !== "edge" ? [SearchDaemonModule] : [],
+        ...registerModules(env).filter((m) => !!m)
+      ],
+      providers: [DateScalar]
+    })
+  ], AppModule);
+  const app = await NestFactory.create(AppModule, { logger: backendLogger });
+  const redisIoAdapter = new RedisIoAdapter(app, { jwtSecret });
+  await redisIoAdapter.connectToRedis(redisUri);
+  app.enableShutdownHooks();
+  const udp = dgram.createSocket("udp4");
+  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(json({ limit: "100mb" }));
+    app.use(urlencoded({ limit: "100mb", extended: true }));
+    app.use("/backend/graphql", graphqlUploadExpress());
+    app.use(cookieParser());
+    app.useGlobalInterceptors(new LoggingInterceptor());
+    app.useGlobalInterceptors(new TimeoutInterceptor());
+    app.useGlobalInterceptors(new CacheInterceptor(redisClient));
+    app.useGlobalFilters(new 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();
+    }
+  };
+};
+export {
+  createNestApp
+};