@akanjs/server 0.0.39 → 0.0.40

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/server",
-  "version": "0.0.39",
+  "version": "0.0.40",
   "type": "commonjs",
   "scripts": {
     "postinstall": "pnpm install @nestjs/mongoose@^10.1.0"
@@ -20,47 +20,5 @@
   "engines": {
     "node": ">=22"
   },
-  "dependencies": {
-    "@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",
-    "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"
-  }
+  "dependencies": {}
 }

package/src/boot.d.ts

@@ -0,0 +1,49 @@
+import { SshOptions } from 'tunnel-ssh';
+import { INestApplication, DynamicModule } from '@nestjs/common';
+
+type Environment = "testing" | "debug" | "develop" | "main";
+interface BaseEnv {
+    repoName: string;
+    serveDomain: string;
+    appName: string;
+    environment: Environment;
+    operationType: "server" | "client";
+    operationMode: "local" | "edge" | "cloud" | "module";
+    networkType: "mainnet" | "testnet" | "debugnet";
+    tunnelUsername: string;
+    tunnelPassword: string;
+}
+type BackendEnv = BaseEnv & {
+    hostname: string | null;
+    appCode: number;
+    mongo: {
+        username?: string;
+        password?: string;
+        sshOptions?: SshOptions;
+    };
+    redis?: {
+        sshOptions?: SshOptions;
+    };
+    port?: number;
+    mongoUri?: string;
+    redisUri?: string;
+    meiliUri?: string;
+    onCleanup?: () => Promise<void>;
+};
+
+interface AppCreateForm {
+    registerModules: (options: any) => (DynamicModule | null)[];
+    serverMode?: "federation" | "batch" | "all" | "none";
+    env: BackendEnv;
+    log?: boolean;
+}
+interface BackendApp {
+    nestApp: INestApplication;
+    close: () => Promise<void>;
+}
+declare const createNestApp: ({ registerModules, serverMode, env, log }: AppCreateForm) => Promise<{
+    nestApp: INestApplication<any>;
+    close: () => Promise<void>;
+}>;
+
+export { type BackendApp, createNestApp };

package/src/boot.js

@@ -0,0 +1,258 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var 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");
+function _ts_decorate(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+__name(_ts_decorate, "_ts_decorate");
+const createNestApp = /* @__PURE__ */ __name(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 AuthMiddleWare {
+    static {
+      __name(this, "AuthMiddleWare");
+    }
+    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 = _ts_decorate([
+    (0, import_common2.Injectable)()
+  ], AuthMiddleWare);
+  const redisClient = await (0, import_redis.createClient)({
+    url: redisUri
+  }).connect();
+  let SubDatabaseModule = class SubDatabaseModule {
+    static {
+      __name(this, "SubDatabaseModule");
+    }
+  };
+  SubDatabaseModule = _ts_decorate([
+    (0, import_common2.Global)(),
+    (0, import_common2.Module)({
+      providers: [
+        {
+          provide: "REDIS_CLIENT",
+          useValue: redisClient
+        },
+        {
+          provide: "MEILI_CLIENT",
+          useFactory: /* @__PURE__ */ __name(() => new import_meilisearch.MeiliSearch({
+            host: meiliUri,
+            apiKey: (0, import_nest.generateMeiliKey)(env)
+          }), "useFactory")
+        }
+      ],
+      exports: [
+        "REDIS_CLIENT",
+        "MEILI_CLIENT"
+      ]
+    })
+  ], SubDatabaseModule);
+  let AppModule = class AppModule {
+    static {
+      __name(this, "AppModule");
+    }
+    configure(consumer) {
+      consumer.apply(AuthMiddleWare).forRoutes({
+        path: "*",
+        method: import_common2.RequestMethod.ALL
+      });
+    }
+  };
+  AppModule = _ts_decorate([
+    (0, import_common2.Module)({
+      imports: [
+        import_bull.BullModule.forRoot({
+          redis: redisUri
+        }),
+        import_schedule.ScheduleModule.forRoot(),
+        import_graphql.GraphQLModule.forRootAsync({
+          imports: [],
+          useFactory: /* @__PURE__ */ __name(() => ({
+            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
+          }), "useFactory"),
+          driver: import_apollo.ApolloDriver
+        }),
+        import_mongoose.MongooseModule.forRootAsync({
+          useFactory: /* @__PURE__ */ __name(() => ({
+            uri: mongoUri,
+            autoIndex: import_base.baseEnv.environment !== "main"
+          }), "useFactory")
+        }),
+        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: /* @__PURE__ */ __name(async () => {
+      await app.close();
+      await redisIoAdapter.destroy();
+      await redisClient.quit();
+    }, "close")
+  };
+}, "createNestApp");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createNestApp
+});

package/src/controller.d.ts

@@ -0,0 +1,9 @@
+import { T as Type } from '../types-H2HI4YUe.js';
+
+declare const controllerOf: (sigRef: Type, allSrvs: {
+    [key: string]: Type;
+}) => {
+    new (): {};
+};
+
+export { controllerOf };

package/src/controller.js

@@ -0,0 +1,96 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var 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 = /* @__PURE__ */ __name((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;
+}, "controllerOf");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  controllerOf
+});

package/src/gql.d.ts

@@ -0,0 +1,77 @@
+import { G as GqlScalar, D as DocumentModel, B as BaseObject } from '../types-CUkhtrLV.js';
+import { T as Type } from '../types-H2HI4YUe.js';
+import { FilterQuery, AccumulatorOperator } from 'mongoose';
+import { Dayjs } from 'dayjs';
+import { a as Doc } from '../dbDecorators-z3rJpvxp.js';
+import * as Nest from '@nestjs/graphql';
+import { ValueNode } from 'graphql';
+import 'fs';
+import 'stream';
+
+declare class Enum<T> {
+    readonly values: T[];
+    readonly value: T;
+    readonly valueMap: Map<T, number>;
+    constructor(values: T[]);
+    has(value: T): boolean;
+    indexOf(value: T): number;
+    find(callback: (value: T, index: number, array: T[]) => boolean): T;
+    findIndex(callback: (value: T, index: number, array: T[]) => boolean): number;
+    filter(callback: (value: T, index: number, array: T[]) => boolean): T[];
+    map<R>(callback: (value: T, index: number, array: T[]) => R): R[];
+    forEach(callback: (value: T, index: number, array: T[]) => void): void;
+}
+
+declare const fieldTypes: readonly ["email", "password", "url"];
+type FieldType = (typeof fieldTypes)[number];
+interface ConstantFieldProps {
+    nullable?: boolean;
+    ref?: string;
+    refPath?: string;
+    refType?: "child" | "parent" | "relation";
+    default?: string | number | boolean | object | null | Enum<string | number>;
+    type?: FieldType;
+    fieldType?: "property" | "hidden" | "resolve";
+    immutable?: boolean;
+    min?: number;
+    max?: number;
+    enum?: Enum<string | number>;
+    select?: boolean;
+    minlength?: number;
+    maxlength?: number;
+    query?: FilterQuery<any> | (() => FilterQuery<any>);
+    accumulate?: AccumulatorOperator;
+    example?: string | number | boolean | Dayjs | string[] | number[] | boolean[] | Dayjs[];
+    of?: GqlScalar;
+    validate?: (value: any, model: any) => boolean;
+    text?: "search" | "filter";
+}
+type ConstantFieldMeta = ConstantFieldProps & {
+    nullable: boolean;
+    default: any;
+    fieldType: "property" | "hidden" | "resolve";
+    immutable: boolean;
+    select: boolean;
+} & {
+    key: string;
+    name: string;
+    isClass: boolean;
+    isScalar: boolean;
+    modelRef: Type;
+    arrDepth: number;
+    isArray: boolean;
+    optArrDepth: number;
+    isMap: boolean;
+};
+
+declare class DateScalar implements Nest.CustomScalar<Date, Dayjs> {
+    description: string;
+    parseValue(value: number): Dayjs;
+    serialize(value: Dayjs): Date;
+    parseLiteral(ast: ValueNode): Dayjs;
+}
+declare const applyNestField: (model: Type, fieldMeta: ConstantFieldMeta, type?: "object" | "input") => void;
+declare const generateGqlInput: <InputModel>(inputRef: Type<InputModel>) => Type<DocumentModel<InputModel>>;
+declare const generateGql: <ObjectModel>(objectRef: Type<ObjectModel>) => Type<ObjectModel extends BaseObject ? Doc<ObjectModel> : DocumentModel<ObjectModel>>;
+
+export { DateScalar, applyNestField, generateGql, generateGqlInput };