@akanjs/nest 0.0.33 → 0.0.35

package/index.js

@@ -1,21 +1,2134 @@
-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 nest_exports = {};
-module.exports = __toCommonJS(nest_exports);
-__reExport(nest_exports, require("./src"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./src")
-});
+(() => {
+  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 __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+    get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+  }) : x)(function(x) {
+    if (typeof require !== "undefined")
+      return require.apply(this, arguments);
+    throw Error('Dynamic require of "' + x + '" is not supported');
+  });
+  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 __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 __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+  var __accessCheck = (obj, member, msg) => {
+    if (!member.has(obj))
+      throw TypeError("Cannot " + msg);
+  };
+  var __privateGet = (obj, member, getter) => {
+    __accessCheck(obj, member, "read from private field");
+    return getter ? getter.call(obj) : member.get(obj);
+  };
+  var __privateAdd = (obj, member, value) => {
+    if (member.has(obj))
+      throw TypeError("Cannot add the same private member more than once");
+    member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+  };
+  var __privateMethod = (obj, member, method) => {
+    __accessCheck(obj, member, "access private method");
+    return method;
+  };
+
+  // pkgs/@akanjs/base/src/base.ts
+  var version = "0.9.0";
+  var logo = `
+     _    _                  _     
+    / \\  | | ____ _ _ __    (_)___ 
+   / _ \\ | |/ / _' | '_ \\   | / __|
+  / ___ \\|   < (_| | | | |_ | \\__ \\
+ /_/   \\_\\_|\\_\\__,_|_| |_(_)/ |___/
+                          |__/      ver ${version}
+? See more details on docs  https://www.akanjs.com/docs
+\u2605 Star Akanjs on GitHub     https://github.com/aka-bassman/akanjs
+
+`;
+
+  // pkgs/@akanjs/base/src/baseEnv.ts
+  var appName = process.env.NEXT_PUBLIC_APP_NAME ?? "unknown";
+  var repoName = process.env.NEXT_PUBLIC_REPO_NAME ?? "unknown";
+  var serveDomain = process.env.NEXT_PUBLIC_SERVE_DOMAIN ?? "unknown";
+  if (appName === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_APP_NAME is required");
+  if (repoName === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_REPO_NAME is required");
+  if (serveDomain === "unknown")
+    throw new Error("environment variable NEXT_PUBLIC_SERVE_DOMAIN is required");
+  var environment = process.env.NEXT_PUBLIC_ENV ?? "debug";
+  var operationType = typeof window !== "undefined" ? "client" : process.env.NEXT_RUNTIME ? "client" : "server";
+  var operationMode = process.env.NEXT_PUBLIC_OPERATION_MODE ?? "cloud";
+  var networkType = process.env.NEXT_PUBLIC_NETWORK_TYPE ?? (environment === "main" ? "mainnet" : environment === "develop" ? "testnet" : "debugnet");
+  var tunnelUsername = process.env.SSU_TUNNEL_USERNAME ?? "root";
+  var tunnelPassword = process.env.SSU_TUNNEL_PASSWORD ?? repoName;
+  var baseEnv = {
+    repoName,
+    serveDomain,
+    appName,
+    environment,
+    operationType,
+    operationMode,
+    networkType,
+    tunnelUsername,
+    tunnelPassword
+  };
+  var side = typeof window === "undefined" ? "server" : "client";
+  var renderMode = process.env.RENDER_ENV ?? "ssr";
+  var clientHost = process.env.NEXT_PUBLIC_CLIENT_HOST ?? (operationMode === "local" || side === "server" ? "localhost" : window.location.hostname);
+  var clientPort = parseInt(
+    process.env.NEXT_PUBLIC_CLIENT_PORT ?? (operationMode === "local" ? renderMode === "ssr" ? "4200" : "4201" : "443")
+  );
+  var clientHttpProtocol = side === "client" ? window.location.protocol : clientHost === "localhost" ? "http:" : "https:";
+  var clientHttpUri = `${clientHttpProtocol}//${clientHost}${clientPort === 443 ? "" : `:${clientPort}`}`;
+  var serverHost = process.env.SERVER_HOST ?? (operationMode === "local" ? typeof window === "undefined" ? "localhost" : window.location.host.split(":")[0] : renderMode === "csr" ? `${appName}-${environment}.${serveDomain}` : side === "client" ? window.location.host.split(":")[0] : operationMode === "cloud" ? `backend-svc.${appName}-${environment}.svc.cluster.local` : "localhost");
+  var serverPort = parseInt(
+    process.env.SERVER_PORT ?? (operationMode === "local" || side === "server" ? "8080" : "443")
+  );
+  var serverHttpProtocol = side === "client" ? window.location.protocol : "http:";
+  var serverHttpUri = `${serverHttpProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}/backend`;
+  var serverGraphqlUri = `${serverHttpUri}/graphql`;
+  var serverWsProtocol = serverHttpProtocol === "http:" ? "ws:" : "wss:";
+  var serverWsUri = `${serverWsProtocol}//${serverHost}${serverPort === 443 ? "" : `:${serverPort}`}`;
+  var baseClientEnv = {
+    ...baseEnv,
+    side,
+    renderMode,
+    websocket: true,
+    clientHost,
+    clientPort,
+    clientHttpProtocol,
+    clientHttpUri,
+    serverHost,
+    serverPort,
+    serverHttpProtocol,
+    serverHttpUri,
+    serverGraphqlUri,
+    serverWsProtocol,
+    serverWsUri
+  };
+
+  // pkgs/@akanjs/base/src/scalar.ts
+  var import_dayjs = __toESM(__require("dayjs"));
+  var dayjs = import_dayjs.default;
+  var Int = class {
+    __Scalar__;
+  };
+  var Upload = class {
+    __Scalar__;
+    filename;
+    mimetype;
+    encoding;
+    createReadStream;
+  };
+  var Float = class {
+    __Scalar__;
+  };
+  var ID = class {
+    __Scalar__;
+  };
+  var JSON2 = class {
+    __Scalar__;
+  };
+  var getNonArrayModel = (arraiedModel2) => {
+    let arrDepth = 0;
+    let target = arraiedModel2;
+    while (Array.isArray(target)) {
+      target = target[0];
+      arrDepth++;
+    }
+    return [target, arrDepth];
+  };
+  var applyFnToArrayObjects = (arraiedData, fn) => {
+    if (Array.isArray(arraiedData))
+      return arraiedData.map((data) => applyFnToArrayObjects(data, fn));
+    return fn(arraiedData);
+  };
+  var scalarSet = /* @__PURE__ */ new Set([String, Boolean, Date, ID, Int, Float, Upload, JSON2, Map]);
+  var scalarNameMap = /* @__PURE__ */ new Map([
+    [ID, "ID"],
+    [Int, "Int"],
+    [Float, "Float"],
+    [String, "String"],
+    [Boolean, "Boolean"],
+    [Date, "Date"],
+    [Upload, "Upload"],
+    [JSON2, "JSON"],
+    [Map, "Map"]
+  ]);
+  var scalarArgMap = /* @__PURE__ */ new Map([
+    [ID, null],
+    [String, ""],
+    [Boolean, false],
+    [Date, dayjs(/* @__PURE__ */ new Date(-1))],
+    [Int, 0],
+    [Float, 0],
+    [JSON2, {}],
+    [Map, {}]
+  ]);
+  var scalarDefaultMap = /* @__PURE__ */ new Map([
+    [ID, null],
+    [String, ""],
+    [Boolean, false],
+    [Date, dayjs(/* @__PURE__ */ new Date(-1))],
+    [Int, 0],
+    [Float, 0],
+    [JSON2, {}]
+  ]);
+  var isGqlScalar = (modelRef) => scalarSet.has(modelRef);
+  var isGqlMap = (modelRef) => modelRef === Map;
+
+  // pkgs/@akanjs/common/src/isDayjs.ts
+  var import_dayjs2 = __require("dayjs");
+
+  // pkgs/@akanjs/common/src/isQueryEqual.ts
+  var import_dayjs3 = __toESM(__require("dayjs"));
+
+  // pkgs/@akanjs/common/src/isValidDate.ts
+  var import_dayjs4 = __toESM(__require("dayjs"));
+  var import_customParseFormat = __toESM(__require("dayjs/plugin/customParseFormat"));
+  import_dayjs4.default.extend(import_customParseFormat.default);
+
+  // pkgs/@akanjs/common/src/pluralize.ts
+  var import_pluralize = __toESM(__require("pluralize"));
+
+  // pkgs/@akanjs/common/src/capitalize.ts
+  var capitalize = (str) => {
+    return str.charAt(0).toUpperCase() + str.slice(1);
+  };
+
+  // pkgs/@akanjs/common/src/Logger.ts
+  var import_dayjs5 = __toESM(__require("dayjs"));
+  var logLevels = ["trace", "verbose", "debug", "log", "info", "warn", "error"];
+  var clc = {
+    bold: (text) => `\x1B[1m${text}\x1B[0m`,
+    green: (text) => `\x1B[32m${text}\x1B[39m`,
+    yellow: (text) => `\x1B[33m${text}\x1B[39m`,
+    red: (text) => `\x1B[31m${text}\x1B[39m`,
+    magentaBright: (text) => `\x1B[95m${text}\x1B[39m`,
+    cyanBright: (text) => `\x1B[96m${text}\x1B[39m`
+  };
+  var colorizeMap = {
+    trace: clc.bold,
+    verbose: clc.cyanBright,
+    debug: clc.magentaBright,
+    log: clc.green,
+    info: clc.green,
+    warn: clc.yellow,
+    error: clc.red
+  };
+  var Logger = class _Logger {
+    static #ignoreCtxSet = /* @__PURE__ */ new Set([
+      "InstanceLoader",
+      "RoutesResolver",
+      "RouterExplorer",
+      "NestFactory",
+      "WebSocketsController",
+      "GraphQLModule",
+      "NestApplication"
+    ]);
+    static level = process.env.NEXT_PUBLIC_LOG_LEVEL ?? "log";
+    static #levelIdx = logLevels.findIndex((l) => l === process.env.NEXT_PUBLIC_LOG_LEVEL);
+    static #startAt = (0, import_dayjs5.default)();
+    static setLevel(level) {
+      this.level = level;
+      this.#levelIdx = logLevels.findIndex((l) => l === level);
+    }
+    name;
+    constructor(name) {
+      this.name = name;
+    }
+    trace(msg, context = "") {
+      if (_Logger.#levelIdx <= 0)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "trace");
+    }
+    verbose(msg, context = "") {
+      if (_Logger.#levelIdx <= 1)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "verbose");
+    }
+    debug(msg, context = "") {
+      if (_Logger.#levelIdx <= 2)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "debug");
+    }
+    log(msg, context = "") {
+      if (_Logger.#levelIdx <= 3)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "log");
+    }
+    info(msg, context = "") {
+      if (_Logger.#levelIdx <= 4)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "info");
+    }
+    warn(msg, context = "") {
+      if (_Logger.#levelIdx <= 5)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "warn");
+    }
+    error(msg, context = "") {
+      if (_Logger.#levelIdx <= 6)
+        _Logger.#printMessages(this.name ?? "App", msg, context, "error");
+    }
+    raw(msg, method) {
+      _Logger.rawLog(msg, method);
+    }
+    rawLog(msg, method) {
+      _Logger.rawLog(msg, method);
+    }
+    static trace(msg, context = "") {
+      if (_Logger.#levelIdx <= 0)
+        _Logger.#printMessages("App", msg, context, "trace");
+    }
+    static verbose(msg, context = "") {
+      if (_Logger.#levelIdx <= 1)
+        _Logger.#printMessages("App", msg, context, "verbose");
+    }
+    static debug(msg, context = "") {
+      if (_Logger.#levelIdx <= 2)
+        _Logger.#printMessages("App", msg, context, "debug");
+    }
+    static log(msg, context = "") {
+      if (_Logger.#levelIdx <= 3)
+        _Logger.#printMessages("App", msg, context, "log");
+    }
+    static info(msg, context = "") {
+      if (_Logger.#levelIdx <= 4)
+        _Logger.#printMessages("App", msg, context, "info");
+    }
+    static warn(msg, context = "") {
+      if (_Logger.#levelIdx <= 5)
+        _Logger.#printMessages("App", msg, context, "warn");
+    }
+    static error(msg, context = "") {
+      if (_Logger.#levelIdx <= 6)
+        _Logger.#printMessages("App", msg, context, "error");
+    }
+    static #colorize(msg, logLevel) {
+      return colorizeMap[logLevel](msg);
+    }
+    static #printMessages(name, content, context, logLevel, writeStreamType = logLevel === "error" ? "stderr" : "stdout") {
+      if (this.#ignoreCtxSet.has(context))
+        return;
+      const now = (0, import_dayjs5.default)();
+      const processMsg = this.#colorize(
+        `[${name ?? "App"}] ${global.process?.pid ?? "window"} -`,
+        logLevel
+      );
+      const timestampMsg = now.format("MM/DD/YYYY, HH:mm:ss A");
+      const logLevelMsg = this.#colorize(logLevel.toUpperCase().padStart(7, " "), logLevel);
+      const contextMsg = context ? clc.yellow(`[${context}] `) : "";
+      const contentMsg = this.#colorize(content, logLevel);
+      const timeDiffMsg = clc.yellow(`+${now.diff(_Logger.#startAt, "ms")}ms`);
+      if (typeof window === "undefined")
+        process[writeStreamType].write(
+          `${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
+`
+        );
+      else
+        console.log(`${processMsg} ${timestampMsg} ${logLevelMsg} ${contextMsg} ${contentMsg} ${timeDiffMsg}
+`);
+    }
+    static rawLog(msg, method) {
+      this.raw(`${msg}
+`, method);
+    }
+    static raw(msg, method) {
+      if (typeof window === "undefined" && method !== "console" && global.process)
+        global.process.stdout.write(msg);
+      else
+        console.log(msg);
+    }
+  };
+
+  // pkgs/@akanjs/common/src/lowerlize.ts
+  var lowerlize = (str) => {
+    return str.charAt(0).toLowerCase() + str.slice(1);
+  };
+
+  // pkgs/@akanjs/common/src/sleep.ts
+  var sleep = async (ms) => {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve(true);
+      }, ms);
+    });
+  };
+
+  // pkgs/@akanjs/signal/src/client.ts
+  var import_core = __require("@urql/core");
+  var import_socket = __require("socket.io-client");
+  var SocketIo = class {
+    socket;
+    roomSubscribeMap = /* @__PURE__ */ new Map();
+    constructor(uri) {
+      this.socket = (0, import_socket.io)(uri, { transports: ["websocket"] });
+      this.socket.on("connect", () => {
+        this.roomSubscribeMap.forEach((option) => {
+          this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+        });
+      });
+    }
+    on(event, callback) {
+      this.socket.on(event, callback);
+    }
+    removeListener(event, callback) {
+      this.socket.removeListener(event, callback);
+    }
+    removeAllListeners() {
+      this.socket.removeAllListeners();
+    }
+    hasListeners(event) {
+      return this.socket.hasListeners(event);
+    }
+    emit(key, data) {
+      this.socket.emit(key, data);
+    }
+    subscribe(option) {
+      if (!this.roomSubscribeMap.has(option.roomId)) {
+        this.roomSubscribeMap.set(option.roomId, option);
+        this.socket.emit(option.key, { ...option.message, __subscribe__: true });
+      }
+      this.socket.on(option.roomId, option.handleEvent);
+    }
+    unsubscribe(roomId, handleEvent) {
+      this.socket.removeListener(roomId, handleEvent);
+      const option = this.roomSubscribeMap.get(roomId);
+      if (this.hasListeners(roomId) || !option)
+        return;
+      this.roomSubscribeMap.delete(roomId);
+      this.socket.emit(option.key, { ...option.message, __subscribe__: false });
+    }
+    disconnect() {
+      this.socket.disconnect();
+      return this;
+    }
+  };
+  var Client = class _Client {
+    static globalIoMap = /* @__PURE__ */ new Map();
+    static tokenStore = /* @__PURE__ */ new Map();
+    async waitUntilWebSocketConnected(ws = baseClientEnv.serverWsUri) {
+      if (baseClientEnv.side === "server")
+        return true;
+      while (!this.getIo(ws).socket.connected) {
+        Logger.verbose("waiting for websocket to initialize...");
+        await sleep(300);
+      }
+    }
+    isInitialized = false;
+    uri = baseClientEnv.serverGraphqlUri;
+    ws = baseClientEnv.serverWsUri;
+    udp = null;
+    gql = (0, import_core.createClient)({ url: this.uri, fetch, exchanges: [import_core.cacheExchange, import_core.fetchExchange] });
+    jwt = null;
+    async getJwt() {
+      const isNextServer = baseClientEnv.side === "server" && baseEnv.operationType === "client";
+      if (isNextServer) {
+        const nextHeaders = __require("next/headers");
+        return (await nextHeaders.cookies?.())?.get("jwt")?.value ?? (await nextHeaders.headers?.())?.get("jwt") ?? this.jwt ?? null;
+      } else
+        return _Client.tokenStore.get(this) ?? null;
+    }
+    io = null;
+    init(data = {}) {
+      Object.assign(this, data);
+      this.setLink(data.uri);
+      this.setIo(data.ws);
+      this.isInitialized = true;
+    }
+    setIo(ws = baseClientEnv.serverWsUri) {
+      this.ws = ws;
+      const existingIo = _Client.globalIoMap.get(ws);
+      if (existingIo) {
+        this.io = existingIo;
+        return;
+      }
+      this.io = new SocketIo(ws);
+      _Client.globalIoMap.set(ws, this.io);
+    }
+    getIo(ws = baseClientEnv.serverWsUri) {
+      const existingIo = _Client.globalIoMap.get(ws);
+      if (existingIo)
+        return existingIo;
+      const io2 = new SocketIo(ws);
+      _Client.globalIoMap.set(ws, io2);
+      return io2;
+    }
+    setLink(uri = baseClientEnv.serverGraphqlUri) {
+      this.uri = uri;
+      this.gql = (0, import_core.createClient)({
+        url: this.uri,
+        fetch,
+        exchanges: [import_core.cacheExchange, import_core.fetchExchange],
+        // requestPolicy: "network-only",
+        fetchOptions: () => {
+          return {
+            headers: {
+              "apollo-require-preflight": "true",
+              ...this.jwt ? { authorization: `Bearer ${this.jwt}` } : {}
+            }
+          };
+        }
+      });
+    }
+    setJwt(jwt3) {
+      _Client.tokenStore.set(this, jwt3);
+    }
+    reset() {
+      this.io?.disconnect();
+      this.io = null;
+      this.jwt = null;
+    }
+    clone(data = {}) {
+      const newClient = new _Client();
+      newClient.init({ ...this, ...data });
+      if (data.jwt)
+        _Client.tokenStore.set(newClient, data.jwt);
+      return newClient;
+    }
+    terminate() {
+      this.reset();
+      _Client.globalIoMap.forEach((io2) => io2.disconnect());
+      this.isInitialized = false;
+    }
+    setUdp(udp) {
+      this.udp = udp;
+    }
+  };
+  var client = new Client();
+
+  // pkgs/@akanjs/constant/src/types.ts
+  var DEFAULT_PAGE_SIZE = 20;
+
+  // pkgs/@akanjs/constant/src/scalar.ts
+  var import_reflect_metadata = __require("reflect-metadata");
+  var scalarExampleMap = /* @__PURE__ */ new Map([
+    [ID, "1234567890abcdef12345678"],
+    [Int, 0],
+    [Float, 0],
+    [String, "String"],
+    [Boolean, true],
+    [Date, (/* @__PURE__ */ new Date()).toISOString()],
+    [Upload, "FileUpload"],
+    [JSON2, {}],
+    [Map, {}]
+  ]);
+  var getClassMeta = (modelRef) => {
+    const [target] = getNonArrayModel(modelRef);
+    const classMeta = Reflect.getMetadata("class", target.prototype);
+    if (!classMeta)
+      throw new Error(`No ClassMeta for this target ${target.name}`);
+    return classMeta;
+  };
+  var getFieldMetas = (modelRef) => {
+    const [target] = getNonArrayModel(modelRef);
+    const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
+    const keySortMap = { id: -1, createdAt: 1, updatedAt: 2, removedAt: 3 };
+    return [...metadataMap.values()].sort((a, b) => (keySortMap[a.key] ?? 0) - (keySortMap[b.key] ?? 0));
+  };
+  var getFieldMetaMapOnPrototype = (prototype) => {
+    const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
+    return new Map(metadataMap);
+  };
+  var setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
+    Reflect.defineMetadata("fields", new Map(metadataMap), prototype);
+  };
+
+  // pkgs/@akanjs/constant/src/fieldMeta.ts
+  var applyFieldMeta = (modelRef, arrDepth, option, optionArrDepth) => {
+    const isArray = arrDepth > 0;
+    const isClass = !isGqlScalar(modelRef);
+    const isMap = isGqlMap(modelRef);
+    const { refName, type } = isClass ? getClassMeta(modelRef) : { refName: "", type: "scalar" };
+    const name = isClass ? refName : scalarNameMap.get(modelRef) ?? "Unknown";
+    if (isMap && !option.of)
+      throw new Error("Map type must have 'of' option");
+    return (prototype, key) => {
+      const metadata = {
+        nullable: option.nullable ?? false,
+        ref: option.ref,
+        refPath: option.refPath,
+        refType: option.refType,
+        default: option.default ?? (isArray ? [] : null),
+        type: option.type,
+        fieldType: option.fieldType ?? "property",
+        immutable: option.immutable ?? false,
+        min: option.min,
+        max: option.max,
+        enum: option.enum,
+        select: option.select ?? true,
+        minlength: option.minlength,
+        maxlength: option.maxlength,
+        query: option.query,
+        accumulate: option.accumulate,
+        example: option.example,
+        validate: option.validate,
+        key,
+        name,
+        isClass,
+        isScalar: type === "scalar",
+        modelRef,
+        arrDepth,
+        isArray,
+        optArrDepth: optionArrDepth,
+        isMap,
+        of: option.of,
+        text: option.text
+      };
+      const metadataMap = getFieldMetaMapOnPrototype(prototype);
+      metadataMap.set(key, metadata);
+      setFieldMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var makeField = (customOption) => (returns, fieldOption) => {
+    const [modelRef, arrDepth] = getNonArrayModel(returns());
+    if (!fieldOption)
+      return applyFieldMeta(modelRef, arrDepth, { ...customOption }, arrDepth);
+    const [opt, optArrDepth] = getNonArrayModel(fieldOption);
+    return applyFieldMeta(modelRef, arrDepth, { ...opt, ...customOption }, optArrDepth);
+  };
+  var Field = {
+    Prop: makeField({ fieldType: "property" }),
+    Hidden: makeField({ fieldType: "hidden", nullable: true }),
+    Secret: makeField({ fieldType: "hidden", select: false, nullable: true }),
+    Resolve: makeField({ fieldType: "resolve" })
+  };
+
+  // pkgs/@akanjs/constant/src/constantDecorator.ts
+  var import_reflect_metadata2 = __require("reflect-metadata");
+
+  // pkgs/@akanjs/constant/src/filterMeta.ts
+  var setFilterMeta = (filterRef, filterMeta) => {
+    const existingFilterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+    if (existingFilterMeta)
+      Object.assign(filterMeta.sort, existingFilterMeta.sort);
+    Reflect.defineMetadata("filter", filterMeta, filterRef.prototype);
+  };
+  var getFilterKeyMetaMapOnPrototype = (prototype) => {
+    const metadataMap = Reflect.getMetadata("filterKey", prototype) ?? /* @__PURE__ */ new Map();
+    return new Map(metadataMap);
+  };
+  var setFilterKeyMetaMapOnPrototype = (prototype, metadataMap) => {
+    Reflect.defineMetadata("filterKey", new Map(metadataMap), prototype);
+  };
+  var applyFilterKeyMeta = (option) => {
+    return (prototype, key, descriptor) => {
+      const metadata = { key, ...option, descriptor };
+      const metadataMap = getFilterKeyMetaMapOnPrototype(prototype);
+      metadataMap.set(key, metadata);
+      setFilterKeyMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var makeFilter = (customOption) => (fieldOption) => {
+    return applyFilterKeyMeta({ ...customOption, ...fieldOption });
+  };
+  var getFilterArgMetasOnPrototype = (prototype, key) => {
+    const filterArgMetas = Reflect.getMetadata("filterArg", prototype, key) ?? [];
+    return filterArgMetas;
+  };
+  var setFilterArgMetasOnPrototype = (prototype, key, filterArgMetas) => {
+    Reflect.defineMetadata("filterArg", filterArgMetas, prototype, key);
+  };
+  var applyFilterArgMeta = (name, returns, argOption) => {
+    return (prototype, key, idx) => {
+      const [modelRef, arrDepth] = getNonArrayModel(returns());
+      const [opt, optArrDepth] = getNonArrayModel(argOption ?? {});
+      const filterArgMeta = { name, ...opt, modelRef, arrDepth, isArray: arrDepth > 0, optArrDepth };
+      const filterArgMetas = getFilterArgMetasOnPrototype(prototype, key);
+      filterArgMetas[idx] = filterArgMeta;
+      setFilterArgMetasOnPrototype(prototype, key, filterArgMetas);
+    };
+  };
+  var Filter = {
+    Mongo: makeFilter({ type: "mongo" }),
+    // Meili: makeFilter({ fieldType: "hidden", nullable: true }),
+    Arg: applyFilterArgMeta
+  };
+
+  // pkgs/@akanjs/constant/src/baseGql.ts
+  var import_reflect_metadata3 = __require("reflect-metadata");
+  var defaultFieldMeta = {
+    fieldType: "property",
+    immutable: false,
+    select: true,
+    isClass: false,
+    isScalar: true,
+    nullable: false,
+    isArray: false,
+    arrDepth: 0,
+    optArrDepth: 0,
+    default: null,
+    isMap: false
+  };
+  var idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: ID };
+  var createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
+  var updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
+  var removedAtFieldMeta = {
+    ...defaultFieldMeta,
+    key: "removedAt",
+    name: "Date",
+    modelRef: Date,
+    nullable: true,
+    default: null
+  };
+
+  // pkgs/@akanjs/constant/src/classMeta.ts
+  var import_reflect_metadata4 = __require("reflect-metadata");
+  var InputModelStorage = class {
+  };
+  var LightModelStorage = class {
+  };
+  var FullModelStorage = class {
+  };
+  var ScalarModelStorage = class {
+  };
+  var FilterModelStorage = class {
+  };
+  var hasTextField = (modelRef) => {
+    const fieldMetas = getFieldMetas(modelRef);
+    return fieldMetas.some(
+      (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
+    );
+  };
+  var applyClassMeta = (type, modelType, storage) => {
+    return function(refName) {
+      return function(target) {
+        const modelRef = target;
+        const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
+        Reflect.defineMetadata("class", classMeta, modelRef.prototype);
+        Reflect.defineMetadata(refName, modelRef, storage.prototype);
+      };
+    };
+  };
+  var applyFilterMeta = (storage) => {
+    return function(refName) {
+      return function(target) {
+        const modelRef = target;
+        setFilterMeta(modelRef, { refName, sort: {} });
+        Reflect.defineMetadata(refName, modelRef, storage.prototype);
+      };
+    };
+  };
+  var Model = {
+    Light: applyClassMeta("light", "data", LightModelStorage),
+    Object: applyClassMeta("full", "ephemeral", FullModelStorage),
+    Full: applyClassMeta("full", "data", FullModelStorage),
+    Input: applyClassMeta("input", "data", InputModelStorage),
+    Scalar: applyClassMeta("scalar", "data", ScalarModelStorage),
+    Summary: applyClassMeta("scalar", "summary", ScalarModelStorage),
+    Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
+    Filter: applyFilterMeta(FilterModelStorage)
+  };
+
+  // pkgs/@akanjs/signal/src/immerify.ts
+  var import_immer = __require("immer");
+
+  // pkgs/@akanjs/signal/src/signalDecorators.ts
+  var import_reflect_metadata5 = __require("reflect-metadata");
+  var createArgMetaDecorator = (type) => {
+    return function(option = {}) {
+      return function(prototype, key, idx) {
+        const argMetas = getArgMetasOnPrototype(prototype, key);
+        argMetas[idx] = { key, idx, type, option };
+        setArgMetasOnPrototype(prototype, key, argMetas);
+      };
+    };
+  };
+  var Account = createArgMetaDecorator("Account");
+  var defaultAccount = {
+    __InternalArg__: "Account",
+    appName: baseEnv.appName,
+    environment: baseEnv.environment
+  };
+  var Self = createArgMetaDecorator("Self");
+  var Me = createArgMetaDecorator("Me");
+  var UserIp = createArgMetaDecorator("UserIp");
+  var Access = createArgMetaDecorator("Access");
+  var Req = createArgMetaDecorator("Req");
+  var Res = createArgMetaDecorator("Res");
+  var Ws = createArgMetaDecorator("Ws");
+  var Job = createArgMetaDecorator("Job");
+  var getQuery = (allow2) => function(returns, signalOption = {}, guards = []) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption,
+        key,
+        descriptor,
+        guards: [allow2, ...guards],
+        type: "Query"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var getMutation = (allow2) => function(returns, signalOption = {}, guards = []) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption,
+        key,
+        descriptor,
+        guards: [allow2, ...guards],
+        type: "Mutation"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var getMessage = (allow2) => function(returns, signalOption = {}, guards = []) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption,
+        key,
+        descriptor,
+        guards: [allow2, ...guards],
+        type: "Message"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var getPubsub = (allow2) => function(returns, signalOption = {}, guards = []) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption,
+        key,
+        descriptor,
+        guards: [allow2, ...guards],
+        type: "Pubsub"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var getProcess = (serverType) => function(returns, signalOption = {}) {
+    return (prototype, key, descriptor) => {
+      const metadataMap = getGqlMetaMapOnPrototype(prototype);
+      metadataMap.set(key, {
+        returns,
+        signalOption: { ...signalOption, serverType: lowerlize(serverType) },
+        key,
+        descriptor,
+        guards: ["None"],
+        type: "Process"
+      });
+      setGqlMetaMapOnPrototype(prototype, metadataMap);
+    };
+  };
+  var Query = {
+    Public: getQuery("Public"),
+    Every: getQuery("Every"),
+    Admin: getQuery("Admin"),
+    User: getQuery("User"),
+    SuperAdmin: getQuery("SuperAdmin"),
+    None: getQuery("None"),
+    Owner: getQuery("Owner")
+  };
+  var Mutation = {
+    Public: getMutation("Public"),
+    Every: getMutation("Every"),
+    Admin: getMutation("Admin"),
+    User: getMutation("User"),
+    SuperAdmin: getMutation("SuperAdmin"),
+    None: getMutation("None"),
+    Owner: getMutation("Owner")
+  };
+  var Message = {
+    Public: getMessage("Public"),
+    Every: getMessage("Every"),
+    Admin: getMessage("Admin"),
+    User: getMessage("User"),
+    SuperAdmin: getMessage("SuperAdmin"),
+    None: getMessage("None"),
+    Owner: getMessage("Owner")
+  };
+  var Pubsub = {
+    Public: getPubsub("Public"),
+    Every: getPubsub("Every"),
+    Admin: getPubsub("Admin"),
+    User: getPubsub("User"),
+    SuperAdmin: getPubsub("SuperAdmin"),
+    None: getPubsub("None"),
+    Owner: getPubsub("Owner")
+  };
+  var Process = {
+    Federation: getProcess("Federation"),
+    Batch: getProcess("Batch"),
+    All: getProcess("All")
+  };
+  var getArg = (type) => function(name, returns, argsOption = {}) {
+    return function(prototype, key, idx) {
+      const argMetas = getArgMetasOnPrototype(prototype, key);
+      argMetas[idx] = { name, returns, argsOption, key, idx, type };
+      setArgMetasOnPrototype(prototype, key, argMetas);
+    };
+  };
+  var Arg = {
+    Body: getArg("Body"),
+    Param: getArg("Param"),
+    Query: getArg("Query"),
+    Upload: getArg("Upload"),
+    Msg: getArg("Msg"),
+    Room: getArg("Room")
+  };
+  var getGqlMeta = (sigRef, key) => {
+    const gqlMetaMap = Reflect.getMetadata("gql", sigRef.prototype);
+    if (!gqlMetaMap)
+      throw new Error(`No GqlMeta found for ${sigRef.name}`);
+    const gqlMeta = gqlMetaMap.get(key);
+    if (!gqlMeta)
+      throw new Error(`No GqlMeta found for ${key}`);
+    return gqlMeta;
+  };
+  var getGqlMetaMapOnPrototype = (prototype) => {
+    const gqlMetaMap = Reflect.getMetadata("gql", prototype);
+    return gqlMetaMap ?? /* @__PURE__ */ new Map();
+  };
+  var setGqlMetaMapOnPrototype = (prototype, gqlMetaMap) => {
+    Reflect.defineMetadata("gql", gqlMetaMap, prototype);
+  };
+  var getArgMetasOnPrototype = (prototype, key) => {
+    return Reflect.getMetadata("args", prototype, key) ?? [];
+  };
+  var setArgMetasOnPrototype = (prototype, key, argMetas) => {
+    Reflect.defineMetadata("args", argMetas, prototype, key);
+  };
+
+  // pkgs/@akanjs/signal/src/gql.ts
+  var scalarDeserializeMap = /* @__PURE__ */ new Map([
+    [Date, (value) => dayjs(value)],
+    [String, (value) => value],
+    [ID, (value) => value],
+    [Boolean, (value) => value],
+    [Int, (value) => value],
+    [Float, (value) => value],
+    [JSON2, (value) => value]
+  ]);
+  var getDeserializeFn = (inputRef) => {
+    const deserializeFn = scalarDeserializeMap.get(inputRef);
+    if (!deserializeFn)
+      return (value) => value;
+    return deserializeFn;
+  };
+  var deserializeInput = (value, inputRef, arrDepth) => {
+    if (arrDepth && Array.isArray(value))
+      return value.map((v) => deserializeInput(v, inputRef, arrDepth - 1));
+    else if (inputRef.prototype === Map.prototype) {
+      const [valueRef] = getNonArrayModel(inputRef);
+      const deserializeFn = getDeserializeFn(valueRef);
+      return Object.fromEntries(
+        [...value.entries()].map(([key, val]) => [key, applyFnToArrayObjects(val, deserializeFn)])
+      );
+    } else if (isGqlScalar(inputRef)) {
+      const deserializeFn = getDeserializeFn(inputRef);
+      return deserializeFn(value);
+    }
+    const classMeta = getClassMeta(inputRef);
+    if (classMeta.type !== "scalar")
+      return value;
+    else
+      return Object.fromEntries(
+        getFieldMetas(inputRef).map((fieldMeta) => [
+          fieldMeta.key,
+          deserializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
+        ])
+      );
+  };
+  var deserializeArg = (argMeta, value) => {
+    const [returnRef, arrDepth] = getNonArrayModel(argMeta.returns());
+    if (argMeta.argsOption.nullable && (value === null || value === void 0))
+      return null;
+    else if (!argMeta.argsOption.nullable && (value === null || value === void 0))
+      throw new Error(`Invalid Value (Nullable) in ${argMeta.name} for value ${value}`);
+    return deserializeInput(value, returnRef, arrDepth);
+  };
+
+  // pkgs/@akanjs/signal/src/baseFetch.ts
+  var nativeFetch = fetch;
+  var baseFetch = Object.assign(nativeFetch, {
+    client,
+    clone: function(option = {}) {
+      return {
+        ...this,
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-call, @typescript-eslint/no-unsafe-member-access
+        client: this.client.clone(option)
+      };
+    }
+  });
+
+  // pkgs/@akanjs/nest/src/authorization.ts
+  var import_apollo = __require("@nestjs/apollo");
+  var jwt = __toESM(__require("jsonwebtoken"));
+  var verifyToken = (secret, authorization) => {
+    const [type, token] = authorization?.split(" ") ?? [void 0, void 0];
+    if (!token || type !== "Bearer")
+      return defaultAccount;
+    try {
+      const account = jwt.verify(token, secret);
+      if (account.appName !== baseEnv.appName || account.environment !== baseEnv.environment)
+        return defaultAccount;
+      return {
+        __InternalArg__: "Account",
+        self: account.self && !account.self.removedAt ? account.self : void 0,
+        me: account.me && !account.me.removedAt ? account.me : void 0,
+        appName: account.appName,
+        environment: account.environment
+      };
+    } catch (e) {
+      return defaultAccount;
+    }
+  };
+  var allow = (account, roles, userId) => {
+    if (!account)
+      throw new import_apollo.AuthenticationError("No Authentication Account");
+    for (const role of roles) {
+      if (role === "user" && account.self?.roles.includes("user"))
+        return true;
+      else if (role === "admin" && account.me?.roles.includes("admin"))
+        return true;
+      else if (role === "superAdmin" && account.me?.roles.includes("superAdmin"))
+        return true;
+    }
+    throw new import_apollo.AuthenticationError(
+      `No Authentication With Roles: ${roles.join(", ")}, Your roles are ${[
+        ...account.self?.roles ?? [],
+        ...account.me?.roles ?? []
+      ].join(", ")}${!account.self?.roles.length && !account.me?.roles.length ? " (No Roles)" : ""}`
+    );
+  };
+
+  // pkgs/@akanjs/nest/src/authGuards.ts
+  var authGuards_exports = {};
+  __export(authGuards_exports, {
+    Admin: () => Admin,
+    Every: () => Every,
+    None: () => None,
+    Owner: () => Owner,
+    Public: () => Public,
+    SuperAdmin: () => SuperAdmin,
+    User: () => User,
+    getArgs: () => getArgs,
+    getRequest: () => getRequest,
+    getResponse: () => getResponse,
+    getSocket: () => getSocket
+  });
+  var import_common6 = __require("@nestjs/common");
+  var import_graphql = __require("@nestjs/graphql");
+  var getRequest = (context) => {
+    const type = context.getType();
+    if (type === "ws")
+      throw new Error("Getting Request in Websocket is not allowed");
+    return type === "http" ? context.switchToHttp().getRequest() : import_graphql.GqlExecutionContext.create(context).getContext().req;
+  };
+  var getResponse = (context) => {
+    const type = context.getType();
+    if (type === "ws")
+      throw new Error("Getting Response in Websocket is not allowed");
+    return type === "http" ? context.switchToHttp().getResponse() : import_graphql.GqlExecutionContext.create(context).getContext().req.res;
+  };
+  var getArgs = (context) => {
+    const type = context.getType();
+    if (type === "ws")
+      throw new Error("Getting Args in Websocket is not allowed");
+    if (type === "graphql")
+      return import_graphql.GqlExecutionContext.create(context).getArgs();
+    else if (type === "http") {
+      const { params, query, body } = context.switchToHttp().getRequest();
+      return { ...params, ...query, ...body };
+    } else
+      throw new Error("Getting Args in Unknown context is not allowed");
+  };
+  var getSocket = (context) => {
+    const type = context.getType();
+    if (type !== "ws")
+      throw new Error("Getting Socket in Http or GraphQL is not allowed");
+    const socket = context.getArgByIndex(0);
+    return socket;
+  };
+  var Public = class {
+    canActivate(context) {
+      return true;
+    }
+  };
+  Public = __decorateClass([
+    (0, import_common6.Injectable)()
+  ], Public);
+  var None = class {
+    canActivate() {
+      return false;
+    }
+  };
+  None = __decorateClass([
+    (0, import_common6.Injectable)()
+  ], None);
+  var Every = class {
+    canActivate(context) {
+      const { account } = getRequest(context);
+      return allow(account, ["user", "admin", "superAdmin"]);
+    }
+  };
+  Every = __decorateClass([
+    (0, import_common6.Injectable)()
+  ], Every);
+  var Owner = class {
+    canActivate(context) {
+      const { account } = getRequest(context);
+      return allow(account, ["user", "admin", "superAdmin"]);
+    }
+  };
+  Owner = __decorateClass([
+    (0, import_common6.Injectable)()
+  ], Owner);
+  var Admin = class {
+    canActivate(context) {
+      const { account } = getRequest(context);
+      return allow(account, ["admin", "superAdmin"]);
+    }
+  };
+  Admin = __decorateClass([
+    (0, import_common6.Injectable)()
+  ], Admin);
+  var SuperAdmin = class {
+    canActivate(context) {
+      const { account } = getRequest(context);
+      return allow(account, ["superAdmin"]);
+    }
+  };
+  SuperAdmin = __decorateClass([
+    (0, import_common6.Injectable)()
+  ], SuperAdmin);
+  var User = class {
+    canActivate(context) {
+      const { account } = getRequest(context);
+      return allow(account, ["user"]);
+    }
+  };
+  User = __decorateClass([
+    (0, import_common6.Injectable)()
+  ], User);
+
+  // pkgs/@akanjs/nest/src/authentication.ts
+  var import_common7 = __require("@nestjs/common");
+  var import_ua_parser_js = __toESM(__require("ua-parser-js"));
+  var Account3 = (0, import_common7.createParamDecorator)((option, context) => {
+    const { account } = getRequest(context);
+    return account;
+  });
+  var Self2 = (0, import_common7.createParamDecorator)((option, context) => {
+    const { account } = getRequest(context);
+    const self = account.self;
+    if (!self && !option.nullable)
+      throw new import_common7.UnauthorizedException("No or Invalid Account in Self (User)");
+    return self;
+  });
+  var Me2 = (0, import_common7.createParamDecorator)((option, context) => {
+    const { account } = getRequest(context);
+    const me = account.me;
+    if (!me && !option.nullable)
+      throw new import_common7.UnauthorizedException("No or Invalid Account in Me (Admin)");
+    return me;
+  });
+  var UserIp2 = (0, import_common7.createParamDecorator)((option, context) => {
+    const req = getRequest(context);
+    const ip = req.ip;
+    if (!ip && !option.nullable)
+      throw new import_common7.UnauthorizedException("Invalid IP");
+    return { ip };
+  });
+  var Access2 = (0, import_common7.createParamDecorator)((option, context) => {
+    const req = getRequest(context);
+    const res = new import_ua_parser_js.default(req.userAgent).getResult();
+    if (!req.userAgent && !option.nullable)
+      throw new import_common7.UnauthorizedException("Invalid UserAgent");
+    return {
+      ...req.geolocation ? JSON.parse(req.geolocation) : {},
+      osName: res.os.name,
+      osVersion: res.os.version,
+      browserName: res.browser.name,
+      browserVersion: res.browser.version,
+      mobileModel: res.device.model,
+      mobileVendor: res.device.vendor,
+      deviceType: res.device.type ?? "desktop",
+      at: dayjs(),
+      period: 0
+    };
+  });
+  var Req2 = (0, import_common7.createParamDecorator)((option, context) => {
+    return getRequest(context);
+  });
+  var Res2 = (0, import_common7.createParamDecorator)((option, context) => {
+    return getResponse(context);
+  });
+  var Ws2 = (0, import_common7.createParamDecorator)((option, context) => {
+    const socket = context.getArgByIndex(0);
+    const { __subscribe__ } = context.getArgByIndex(1);
+    return {
+      socket,
+      subscribe: __subscribe__,
+      onDisconnect: (handler) => {
+        socket.on("disconnect", handler);
+      },
+      onSubscribe: (handler) => {
+        if (__subscribe__)
+          handler();
+      },
+      onUnsubscribe: (handler) => {
+        if (!__subscribe__)
+          handler();
+      }
+    };
+  });
+
+  // pkgs/@akanjs/nest/src/interceptors.ts
+  var import_common9 = __require("@nestjs/common");
+  var import_graphql2 = __require("@nestjs/graphql");
+  var import_rxjs = __require("rxjs");
+  var import_operators = __require("rxjs/operators");
+  var _logger, _CACHE_PREFIX, _generateCacheKey, generateCacheKey_fn, _getCache, getCache_fn, _setCache, setCache_fn;
+  var CacheInterceptor = class {
+    constructor(redis) {
+      this.redis = redis;
+      __privateAdd(this, _generateCacheKey);
+      __privateAdd(this, _getCache);
+      __privateAdd(this, _setCache);
+      __privateAdd(this, _logger, new Logger("CacheInterceptor"));
+      __privateAdd(this, _CACHE_PREFIX, "signal:");
+    }
+    async intercept(context, next) {
+      const handler = context.getHandler();
+      const signalKey = handler.name;
+      const gqlMeta = getGqlMeta(context.getClass(), signalKey);
+      if (gqlMeta.type !== "Query" || !gqlMeta.signalOption.cache) {
+        if (gqlMeta.signalOption.cache)
+          __privateGet(this, _logger).warn(`CacheInterceptor: ${signalKey} is not Query endpoint or cache is not set`);
+        return next.handle();
+      }
+      const args = getArgs(context);
+      const cacheKey = __privateMethod(this, _generateCacheKey, generateCacheKey_fn).call(this, signalKey, args);
+      const cachedData = await __privateMethod(this, _getCache, getCache_fn).call(this, cacheKey);
+      if (cachedData) {
+        __privateGet(this, _logger).debug(`Cache hit for key: ${cacheKey}`);
+        return next.handle().pipe(
+          (0, import_operators.map)(() => cachedData),
+          (0, import_operators.catchError)((error) => {
+            const errorMessage = error instanceof Error ? error.message : "Unknown error";
+            __privateGet(this, _logger).error(`Error in cache interceptor for ${cacheKey}: ${errorMessage}`);
+            return (0, import_rxjs.throwError)(() => error);
+          })
+        );
+      }
+      return next.handle().pipe(
+        (0, import_operators.map)((data) => {
+          const cacheDuration = gqlMeta.signalOption.cache;
+          if (typeof cacheDuration === "number") {
+            void __privateMethod(this, _setCache, setCache_fn).call(this, cacheKey, data, cacheDuration);
+            __privateGet(this, _logger).debug(`Cache set for key: ${cacheKey}`);
+          }
+          return data;
+        }),
+        (0, import_operators.catchError)((error) => {
+          const errorMessage = error instanceof Error ? error.message : "Unknown error";
+          __privateGet(this, _logger).error(`Error in cache interceptor for ${cacheKey}: ${errorMessage}`);
+          return (0, import_rxjs.throwError)(() => error);
+        })
+      );
+    }
+  };
+  _logger = new WeakMap();
+  _CACHE_PREFIX = new WeakMap();
+  _generateCacheKey = new WeakSet();
+  generateCacheKey_fn = function(signalKey, args) {
+    return `${__privateGet(this, _CACHE_PREFIX)}${signalKey}:${JSON.stringify(args)}`;
+  };
+  _getCache = new WeakSet();
+  getCache_fn = async function(key) {
+    try {
+      const cached = await this.redis.get(key);
+      if (!cached)
+        return null;
+      const { data } = JSON.parse(cached);
+      return data;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      __privateGet(this, _logger).error(`Error retrieving cache for key ${key}: ${errorMessage}`);
+      return null;
+    }
+  };
+  _setCache = new WeakSet();
+  setCache_fn = async function(key, data, ttlMs) {
+    try {
+      const cacheData = { data, timestamp: Date.now() };
+      await this.redis.set(key, JSON.stringify(cacheData), { PX: ttlMs });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : "Unknown error";
+      __privateGet(this, _logger).error(`Error setting cache for key ${key}: ${errorMessage}`);
+    }
+  };
+  CacheInterceptor = __decorateClass([
+    (0, import_common9.Injectable)(),
+    __decorateParam(0, (0, import_common9.Inject)("REDIS_CLIENT"))
+  ], CacheInterceptor);
+  var TimeoutInterceptor = class {
+    intercept(context, next) {
+      const gqlMeta = getGqlMeta(context.getClass(), context.getHandler().name);
+      const timeoutMs = gqlMeta.signalOption.timeout ?? 3e4;
+      if (timeoutMs === 0)
+        return next.handle();
+      return next.handle().pipe(
+        (0, import_operators.timeout)(timeoutMs),
+        (0, import_operators.catchError)((err) => {
+          if (err instanceof import_rxjs.TimeoutError)
+            return (0, import_rxjs.throwError)(() => new import_common9.RequestTimeoutException());
+          return (0, import_rxjs.throwError)(() => err);
+        })
+      );
+    }
+  };
+  TimeoutInterceptor = __decorateClass([
+    (0, import_common9.Injectable)()
+  ], TimeoutInterceptor);
+  var LoggingInterceptor = class {
+    logger = new Logger("IO");
+    intercept(context, next) {
+      const gqlReq = context.getArgByIndex(3);
+      const req = getRequest(context);
+      const reqType = gqlReq?.parentType?.name ?? req.method;
+      const reqName = gqlReq?.fieldName ?? req.url;
+      const before = Date.now();
+      const ip = import_graphql2.GqlExecutionContext.create(context).getContext().req.ip;
+      this.logger.debug(`Before ${reqType}-${reqName} / ${ip} / ${before}`);
+      return next.handle().pipe(
+        (0, import_operators.tap)(() => {
+          const after = Date.now();
+          this.logger.debug(`After  ${reqType}-${reqName} / ${ip} / ${after} (${after - before}ms)`);
+        })
+      );
+    }
+  };
+  LoggingInterceptor = __decorateClass([
+    (0, import_common9.Injectable)()
+  ], LoggingInterceptor);
+
+  // pkgs/@akanjs/nest/src/redis-io.adapter.ts
+  var import_platform_socket = __require("@nestjs/platform-socket.io");
+  var import_redis_adapter = __require("@socket.io/redis-adapter");
+  var import_redis = __require("redis");
+  var RedisIoAdapter = class extends import_platform_socket.IoAdapter {
+    adapterConstructor;
+    logger = new Logger("RedisIoAdapter");
+    server;
+    pubClient;
+    subClient;
+    option;
+    constructor(appOrHttpServer, option) {
+      super(appOrHttpServer);
+      this.option = option;
+    }
+    async connectToRedis(url) {
+      this.pubClient = (0, import_redis.createClient)({ url });
+      this.subClient = this.pubClient.duplicate();
+      this.pubClient.on("disconnect", (err) => {
+        this.logger.error(`Redis pub database is disconnected. Error: ${err}`);
+        void this.pubClient.connect();
+      });
+      this.subClient.on("disconnect", (err) => {
+        this.logger.error(`Redis sub database is disconnected. Error: ${err}`);
+        void this.subClient.connect();
+      });
+      this.pubClient.on("error", (err) => {
+        this.logger.error(`Redis pub database is errored. Error: ${err}`);
+        const reconnect = async () => {
+          await this.pubClient.quit();
+          await sleep(1e3);
+          await this.pubClient.connect();
+        };
+        void reconnect();
+      });
+      this.subClient.on("error", (err) => {
+        this.logger.error(`Redis sub database is errored. Error: ${err}`);
+        const reconnect = async () => {
+          await this.subClient.quit();
+          await sleep(1e3);
+          await this.subClient.connect();
+        };
+        void reconnect();
+      });
+      await Promise.all([this.pubClient.connect(), this.subClient.connect()]);
+      this.adapterConstructor = (0, import_redis_adapter.createAdapter)(this.pubClient, this.subClient);
+    }
+    createIOServer(port, options) {
+      this.server = super.createIOServer(port, options);
+      this.server.adapter(this.adapterConstructor);
+      return this.server;
+    }
+    async destroy() {
+      await Promise.all([this.pubClient.quit(), this.subClient.quit()]);
+      await this.close(this.server);
+      this.logger.log("RedisIoAdapter is closed");
+    }
+  };
+
+  // pkgs/@akanjs/nest/src/pipes.ts
+  var import_common11 = __require("@nestjs/common");
+  var import_stream = __require("stream");
+  var ArrayifyPipe = class {
+    transform(value, metadata) {
+      return Array.isArray(value) ? value : value.split(",");
+    }
+  };
+  ArrayifyPipe = __decorateClass([
+    (0, import_common11.Injectable)()
+  ], ArrayifyPipe);
+  var IntPipe = class {
+    transform(value, metadata) {
+      return Array.isArray(value) ? value.map(parseInt) : [parseInt(value)];
+    }
+  };
+  IntPipe = __decorateClass([
+    (0, import_common11.Injectable)()
+  ], IntPipe);
+  var FloatPipe = class {
+    transform(value, metadata) {
+      return Array.isArray(value) ? value.map(parseFloat) : [parseFloat(value)];
+    }
+  };
+  FloatPipe = __decorateClass([
+    (0, import_common11.Injectable)()
+  ], FloatPipe);
+  var BooleanPipe = class {
+    transform(value, metadata) {
+      return Array.isArray(value) ? value.map((v) => Boolean(v)) : [Boolean(value)];
+    }
+  };
+  BooleanPipe = __decorateClass([
+    (0, import_common11.Injectable)()
+  ], BooleanPipe);
+  var DayjsPipe = class {
+    transform(value, metadata) {
+      return Array.isArray(value) ? value.map(dayjs) : [dayjs(value)];
+    }
+  };
+  DayjsPipe = __decorateClass([
+    (0, import_common11.Injectable)()
+  ], DayjsPipe);
+  var JSONPipe = class {
+    transform(value, metadata) {
+      const transformable = typeof value === "string" && value.length;
+      const obj = transformable ? JSON.parse(atob(value)) : value;
+      return obj;
+    }
+  };
+  JSONPipe = __decorateClass([
+    (0, import_common11.Injectable)()
+  ], JSONPipe);
+  var convertToFileStream = (value) => ({
+    filename: value.originalname,
+    mimetype: value.mimetype,
+    encoding: value.encoding,
+    createReadStream: () => import_stream.Readable.from(value.buffer)
+  });
+  var MulterToUploadPipe = class {
+    transform(value, metadata) {
+      return Array.isArray(value) ? value.map(convertToFileStream) : convertToFileStream(value);
+    }
+  };
+  MulterToUploadPipe = __decorateClass([
+    (0, import_common11.Injectable)()
+  ], MulterToUploadPipe);
+  var gqlScalarPipeMap = /* @__PURE__ */ new Map([
+    [Int, IntPipe],
+    [Float, FloatPipe],
+    [Boolean, BooleanPipe],
+    [Date, DayjsPipe],
+    [JSON2, JSONPipe]
+  ]);
+  var getQueryPipes = (modelRef, arrDepth) => {
+    const pipes = arrDepth ? [ArrayifyPipe] : [];
+    const scalarPipe = gqlScalarPipeMap.get(modelRef);
+    if (scalarPipe)
+      pipes.push(scalarPipe);
+    return pipes;
+  };
+  var getBodyPipes = (argMeta) => {
+    const [returnRef] = getNonArrayModel(argMeta.returns());
+    if (returnRef.prototype !== Date.prototype && !isGqlScalar(returnRef))
+      return [];
+    let BodyPipe = class {
+      transform(value, metadata) {
+        return deserializeArg(argMeta, value);
+      }
+    };
+    BodyPipe = __decorateClass([
+      (0, import_common11.Injectable)()
+    ], BodyPipe);
+    return [BodyPipe];
+  };
+
+  // pkgs/@akanjs/nest/src/exporter.ts
+  var exporter_exports = {};
+  __export(exporter_exports, {
+    FileSystem: () => FileSystem,
+    exportToCsv: () => exportToCsv,
+    exportToJson: () => exportToJson,
+    objPath: () => objPath,
+    readJson: () => readJson
+  });
+  var fs = __toESM(__require("fs"));
+  var objPath = (o, p) => p.split(".").reduce((a, v) => a[v], o);
+  var FileSystem = class {
+    filename = "";
+    dirname = "./";
+    writeStream;
+    constructor(dirname = "./", filename = "") {
+      this.dirname = dirname;
+      this.filename = filename;
+    }
+    async init() {
+      return new Promise((resolve, reject) => {
+        fs.mkdirSync(this.dirname, { recursive: true });
+        const writeStream = fs.createWriteStream(`${this.dirname}/${this.filename}.csv`);
+        if (!writeStream) {
+          reject(new Error("No WriteStream"));
+          return;
+        }
+        writeStream.once(`open`, () => {
+          this.writeStream = writeStream;
+          resolve(writeStream);
+        });
+      });
+    }
+    write(body) {
+      if (!this.writeStream)
+        throw new Error("no write stream");
+      return this.writeStream.write(`${body.replace(/\n/g, "")}
+`);
+    }
+    // async finish() {}
+  };
+  var exportToCsv = async ({ items, path, fields, delimiter, options }) => {
+    return new Promise((resolve, reject) => {
+      const dirs = path.split("/");
+      if (dirs.length > 1) {
+        const dirname = dirs.slice(-1).join("/");
+        if (!fs.existsSync(dirname))
+          fs.mkdirSync(dirname, { recursive: true });
+      }
+      if (!fields)
+        throw new Error("Fields Required");
+      const writeStream = !options?.append && fs.createWriteStream(path);
+      const header = fields.reduce((acc, cur) => acc + (delimiter ?? `,`) + cur) + `
+`;
+      if (!writeStream) {
+        reject(new Error("No WriteStream"));
+        return;
+      }
+      writeStream.once(`open`, () => {
+        writeStream.write(header);
+        for (const item of items) {
+          const data = fields.map((field) => objPath(item, field) ?? null).map((field) => String(field).replace(/\n/g, "").replace(/,/g, ""));
+          const body = data.reduce((acc, cur) => acc + (delimiter ?? `,`) + cur) + `
+`;
+          if (options?.append)
+            fs.appendFileSync(path, body);
+        }
+        resolve();
+      });
+    });
+  };
+  var exportToJson = (items, localPath) => {
+    const dirname = localPath.split("/").slice(0, -1).join("/");
+    if (!fs.existsSync(dirname))
+      fs.mkdirSync(dirname, { recursive: true });
+    fs.writeFileSync(localPath, JSON.stringify(items));
+  };
+  var readJson = (localPath) => JSON.parse(fs.readFileSync(localPath).toString("utf-8"));
+
+  // pkgs/@akanjs/nest/src/verifyPayment.ts
+  var import_iap = __toESM(__require("iap"));
+  var verifyPayment = async (payment) => {
+    return new Promise(
+      (resolve, reject) => (
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        import_iap.default.verifyPayment(payment.platform, { ...payment }, (error, response) => {
+          if (error)
+            reject(`App Purchase Verify Failed. ${response}`);
+          else
+            resolve(response);
+        })
+      )
+    );
+  };
+
+  // pkgs/@akanjs/nest/src/sso.ts
+  var import_common12 = __require("@nestjs/common");
+  var import_passport = __require("@nestjs/passport");
+  var appleSignin = __toESM(__require("apple-signin"));
+  var jwt2 = __toESM(__require("jsonwebtoken"));
+  var import_passport_apple = __require("passport-apple");
+  var import_passport_facebook = __require("passport-facebook");
+  var import_passport_github = __require("passport-github");
+  var import_passport_google_oauth20 = __require("passport-google-oauth20");
+  var import_passport_kakao = __require("passport-kakao");
+  var import_passport_naver = __require("passport-naver");
+  var getSsoProviders = (host, ssoOptions) => {
+    const origin = host === "localhost" ? "http://localhost:8080/backend" : `https://${host}/backend`;
+    const providers = [];
+    if (ssoOptions.kakao) {
+      let KakaoOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_kakao.Strategy, "kakao") {
+        constructor() {
+          super({
+            ...ssoOptions.kakao,
+            callbackURL: `${origin}/user/kakao/callback`,
+            scope: ["account_email", "profile_nickname"]
+          });
+        }
+        validate(jwt3, refreshToken, profile) {
+          return {
+            name: profile.displayName,
+            email: profile._json.kakao_account.email,
+            password: profile.id
+          };
+        }
+      };
+      KakaoOauthStrategy = __decorateClass([
+        (0, import_common12.Injectable)()
+      ], KakaoOauthStrategy);
+      providers.push(KakaoOauthStrategy);
+    }
+    if (ssoOptions.naver) {
+      let NaverOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_naver.Strategy, "naver") {
+        constructor() {
+          super({ ...ssoOptions.naver, callbackURL: `${origin}/user/naver/callback` });
+        }
+        validate(jwt3, refreshToken, profile) {
+          return {
+            name: profile.displayName,
+            email: profile._json.email,
+            password: profile.id
+          };
+        }
+      };
+      NaverOauthStrategy = __decorateClass([
+        (0, import_common12.Injectable)()
+      ], NaverOauthStrategy);
+      providers.push(NaverOauthStrategy);
+    }
+    if (ssoOptions.github) {
+      let GithubOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_github.Strategy, "github") {
+        constructor() {
+          super({ ...ssoOptions.github, callbackURL: `${origin}/user/github/callback`, scope: ["user"] });
+        }
+        validate(accessToken, _refreshToken, profile) {
+          return profile;
+        }
+      };
+      GithubOauthStrategy = __decorateClass([
+        (0, import_common12.Injectable)()
+      ], GithubOauthStrategy);
+      providers.push(GithubOauthStrategy);
+    }
+    if (ssoOptions.google) {
+      let GoogleOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_google_oauth20.Strategy, "google") {
+        constructor() {
+          super({ ...ssoOptions.google, callbackURL: `${origin}/user/google/callback`, scope: ["email", "profile"] });
+        }
+        validate(_accessToken, _refreshToken, profile) {
+          return profile;
+        }
+      };
+      GoogleOauthStrategy = __decorateClass([
+        (0, import_common12.Injectable)()
+      ], GoogleOauthStrategy);
+      providers.push(GoogleOauthStrategy);
+    }
+    if (ssoOptions.facebook) {
+      let FacebookOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_facebook.Strategy, "facebook") {
+        constructor() {
+          super({
+            ...ssoOptions.facebook,
+            callbackURL: `${origin}/user/facebook/callback`,
+            scope: ["email"],
+            profileFields: ["emails", "name"]
+          });
+        }
+        validate(_accessToken, _refreshToken, profile) {
+          return profile;
+        }
+      };
+      FacebookOauthStrategy = __decorateClass([
+        (0, import_common12.Injectable)()
+      ], FacebookOauthStrategy);
+      providers.push(FacebookOauthStrategy);
+    }
+    if (ssoOptions.apple) {
+      let AppleOauthStrategy = class extends (0, import_passport.PassportStrategy)(import_passport_apple.Strategy, "apple") {
+        constructor() {
+          super({
+            ...ssoOptions.apple,
+            callbackURL: `${origin}/user/apple/callback`,
+            passReqToCallback: true,
+            scope: ["name", "email"]
+          });
+        }
+        validate(req, accessToken, refreshToken, idToken, profile, cb) {
+          cb(null, idToken);
+        }
+      };
+      AppleOauthStrategy = __decorateClass([
+        (0, import_common12.Injectable)()
+      ], AppleOauthStrategy);
+      providers.push(AppleOauthStrategy);
+    }
+    return providers;
+  };
+  var verifyAppleUser = async (payload, origin, sso) => {
+    const signinAgent = appleSignin;
+    const clientSecret = signinAgent.getClientSecret({
+      clientID: sso.clientID,
+      teamId: sso.teamID,
+      keyIdentifier: sso.keyID,
+      privateKeyPath: sso.keyFilePath
+    });
+    const tokens = await signinAgent.getAuthorizationToken(payload.code, {
+      clientID: sso.clientID,
+      clientSecret,
+      redirectUri: `${origin}/user/apple/callback`
+    });
+    if (!tokens.id_token) {
+      throw new Error("No id_token found in Apple's response");
+    }
+    const data = jwt2.decode(tokens.id_token);
+    return { tokens, data };
+  };
+
+  // pkgs/@akanjs/nest/src/exceptions.ts
+  var import_common14 = __require("@nestjs/common");
+  var AllExceptionsFilter = class {
+    logger = new Logger("Exception Filter");
+    catch(exception, host) {
+      if (host.getType() !== "http") {
+        const gqlArgs = host.getArgByIndex(1);
+        const gqlReq = host.getArgByIndex(3);
+        const reqType2 = gqlReq?.parentType?.name ?? "unknown";
+        const reqName2 = gqlReq?.fieldName ?? "unknown";
+        this.logger.error(
+          `GraphQL Error
+Request: ${reqType2}-${reqName2}
+Args: ${JSON.stringify(gqlArgs, null, 2)}
+${exception.stack}`
+        );
+        throw exception;
+      }
+      const ctx = host.switchToHttp();
+      const res = ctx.getResponse();
+      const req = ctx.getRequest();
+      const reqType = req.method;
+      const reqName = req.url;
+      const status = exception instanceof import_common14.HttpException ? exception.getStatus() : null;
+      if (status) {
+        res.status(status).json({
+          statusCode: status,
+          timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+          path: req.url,
+          message: exception instanceof import_common14.HttpException ? exception.getResponse() : exception.message
+        });
+        this.logger.error(
+          `Http Error: ${status}
+Request: ${reqType}-${reqName}
+Body: ${JSON.stringify(req.body, null, 2)}
+${exception.stack}`
+        );
+      }
+    }
+  };
+  AllExceptionsFilter = __decorateClass([
+    (0, import_common14.Catch)()
+  ], AllExceptionsFilter);
+
+  // pkgs/@akanjs/nest/src/generateSecrets.ts
+  var import_crypto = __require("crypto");
+  var import_tunnel_ssh = __require("tunnel-ssh");
+  var generateHexStringFromSeed = (seed, length = 256) => {
+    let hexString = "";
+    let currentSeed = seed;
+    while (hexString.length < length * 2) {
+      const hash = (0, import_crypto.createHash)("sha256").update(currentSeed).digest("hex");
+      hexString += hash;
+      currentSeed = hash;
+    }
+    return hexString.substring(0, length * 2);
+  };
+  var generateJwtSecret = (appName2, environment2) => {
+    const seed = `${appName2}-${environment2}-jwt-secret`;
+    return generateHexStringFromSeed(seed);
+  };
+  var generateAeskey = (appName2, environment2) => {
+    const seed = `${appName2}-${environment2}-aes-key`;
+    return (0, import_crypto.createHash)("sha256").update(seed).digest("hex");
+  };
+  var DEFAULT_CLOUD_PORT = 3e4;
+  var getEnvironmentPort = (environment2) => environment2 === "main" ? 2e3 : environment2 === "develop" ? 1e3 : environment2 === "debug" ? 0 : 0;
+  var getServicePort = (appCode, service) => (service === "redis" ? 300 : service === "mongo" ? 400 : 500) + appCode % 10 * 10 + (appCode >= 10 ? 5 : 0);
+  var createDatabaseTunnel = async ({
+    appName: appName2,
+    environment: environment2,
+    type,
+    port,
+    sshOptions = {
+      host: `${appName2}-${environment2}.${baseEnv.serveDomain}`,
+      port: 32767,
+      username: baseEnv.tunnelUsername,
+      password: baseEnv.tunnelPassword
+    }
+  }) => {
+    const tunnelOptions = { autoClose: true, reconnectOnError: false };
+    const serverOptions = { port };
+    const forwardOptions = {
+      srcAddr: "0.0.0.0",
+      srcPort: port,
+      dstAddr: `${type}-0.${type}-svc.${appName2}-${environment2}`,
+      dstPort: type === "mongo" ? 27017 : type === "redis" ? 6379 : 7700
+    };
+    const [server, client2] = await (0, import_tunnel_ssh.createTunnel)(tunnelOptions, serverOptions, sshOptions, forwardOptions);
+    return `localhost:${port}`;
+  };
+  var generateRedisUri = async ({ appName: appName2, appCode, environment: environment2, operationMode: operationMode2, sshOptions }) => {
+    if (process.env.REDIS_URI)
+      return process.env.REDIS_URI;
+    const port = operationMode2 === "local" ? DEFAULT_CLOUD_PORT + getEnvironmentPort(environment2) + getServicePort(appCode, "redis") : 6379;
+    const url = operationMode2 === "cloud" ? `redis-svc.${appName2}-${environment2}.svc.cluster.local` : operationMode2 === "local" ? await createDatabaseTunnel({ appName: appName2, environment: environment2, type: "redis", port, sshOptions }) : "localhost:6379";
+    const uri = `redis://${url}`;
+    return uri;
+  };
+  var generateMongoUri = async ({
+    appName: appName2,
+    appCode,
+    environment: environment2,
+    operationMode: operationMode2,
+    username = `${appName2}-${environment2}-mongo-user`,
+    password,
+    sshOptions
+  }) => {
+    if (process.env.MONGO_URI)
+      return process.env.MONGO_URI;
+    const record = operationMode2 === "cloud" ? "mongodb+srv" : "mongodb";
+    const port = operationMode2 === "local" ? DEFAULT_CLOUD_PORT + getEnvironmentPort(environment2) + getServicePort(appCode, "mongo") : 27017;
+    const url = operationMode2 === "cloud" ? `mongo-svc.${appName2}-${environment2}.svc.cluster.local` : operationMode2 === "local" ? await createDatabaseTunnel({ appName: appName2, environment: environment2, type: "mongo", port, sshOptions }) : "localhost:27017";
+    const usernameEncoded = password ? encodeURIComponent(username) : null;
+    const passwordEncoded = password ? encodeURIComponent(password) : null;
+    const dbName = `${appName2}-${environment2}`;
+    const directConnection = operationMode2 === "cloud" ? false : true;
+    const authInfo = usernameEncoded ? `${usernameEncoded}:${passwordEncoded}@` : "";
+    const uri = `${record}://${authInfo}${url}/${dbName}?authSource=${dbName}&readPreference=primary&ssl=false&retryWrites=true&directConnection=${directConnection}`;
+    return uri;
+  };
+  var generateMeiliUri = ({ appName: appName2, appCode, environment: environment2, operationMode: operationMode2 }) => {
+    if (process.env.MEILI_URI)
+      return process.env.MEILI_URI;
+    const protocol = operationMode2 === "local" ? "https" : "http";
+    const url = operationMode2 === "cloud" ? `meili-0.meili-svc.${appName2}-${environment2}.svc.cluster.local:7700` : operationMode2 === "local" ? `${appName2}-${environment2}.${baseEnv.serveDomain}/search` : "localhost:7700";
+    const uri = `${protocol}://${url}`;
+    return uri;
+  };
+  var SALT_ROUNDS = 11;
+  var generateHost = (env) => {
+    if (process.env.HOST_NAME)
+      return process.env.HOST_NAME;
+    else if (env.hostname)
+      return env.hostname;
+    else if (env.operationMode === "local")
+      return "localhost";
+    else
+      return `${env.appName}-${env.environment}.${baseEnv.serveDomain}`;
+  };
+  var generateMeiliKey = ({ appName: appName2, environment: environment2 }) => {
+    return `meilisearch-key-${appName2}-${environment2}`;
+  };
+
+  // pkgs/@akanjs/nest/src/mongoose.ts
+  var import_mongoose = __toESM(__require("mongoose"));
+  var initMongoDB = ({
+    logging,
+    threshold = 5e3,
+    sendReport = false
+  }) => {
+    const mongoDBLogger = new Logger("MongoDB");
+    if (logging)
+      import_mongoose.default.set("debug", function(collection, method, ...methodArgs) {
+        mongoDBLogger.verbose(
+          `${collection}.${method}(${methodArgs.slice(0, -1).map((arg) => JSON.stringify(arg)).join(", ")})`
+        );
+      });
+    const originalExec = import_mongoose.default.Query.prototype.exec;
+    const getQueryInfo = (queryAgent) => {
+      const model = queryAgent.model;
+      const collectionName = model.collection.collectionName;
+      const dbName = model.db.name;
+      const query = queryAgent.getQuery();
+      const queryOptions = queryAgent.getOptions();
+      return { dbName, collectionName, query, queryOptions };
+    };
+    import_mongoose.default.Query.prototype.exec = function(...args) {
+      const start = Date.now();
+      return originalExec.apply(this, args).then((result) => {
+        const duration = Date.now() - start;
+        const { dbName, collectionName, query, queryOptions } = getQueryInfo(this);
+        if (logging)
+          mongoDBLogger.verbose(
+            `Queried ${dbName}.${collectionName}.query(${JSON.stringify(query)}, ${JSON.stringify(
+              queryOptions
+            )}) - ${duration}ms`
+          );
+        return result;
+      });
+    };
+    const originalAggregate = import_mongoose.default.Model.aggregate;
+    const getAggregateInfo = (aggregateModel) => {
+      const dbName = aggregateModel.db.db?.databaseName ?? "unknown";
+      const collectionName = aggregateModel.collection.collectionName;
+      return { dbName, collectionName };
+    };
+    import_mongoose.default.Model.aggregate = function(...args) {
+      const startTime = Date.now();
+      return originalAggregate.apply(this, args).then((result) => {
+        const duration = Date.now() - startTime;
+        const { dbName, collectionName } = getAggregateInfo(this);
+        if (logging)
+          mongoDBLogger.verbose(
+            `Aggregated ${dbName}.${collectionName}.aggregate(${args.map((arg) => JSON.stringify(arg)).join(", ")}) - ${duration}ms`
+          );
+        return result;
+      });
+    };
+    import_mongoose.default.set("transactionAsyncLocalStorage", true);
+  };
+
+  // pkgs/@akanjs/nest/src/searchClient.ts
+  var import_common16 = __require("@nestjs/common");
+  var SearchClient = class {
+    meili;
+    async getIndexNames() {
+      const { results } = await this.meili.getIndexes({ limit: 1e3 });
+      return results.map((index) => index.uid);
+    }
+    async getSearchResult(indexName, option) {
+      const { skip = 0, limit = DEFAULT_PAGE_SIZE, sort = "", searchString } = option;
+      if (!searchString) {
+        const { results, total } = await this.meili.index(indexName).getDocuments({ offset: skip, limit });
+        return { docs: results, skip, limit, sort, total };
+      }
+      const { hits, estimatedTotalHits } = await this.meili.index(indexName).search(searchString, { offset: skip, limit });
+      return { docs: hits, skip, limit, sort, total: estimatedTotalHits, query: searchString };
+    }
+    async upsertDocuments(indexName, documents) {
+      const task = await this.meili.index(indexName).addDocuments(documents);
+      return task;
+    }
+    async dropIndex(indexName) {
+      const task = await this.meili.index(indexName).delete();
+      return task;
+    }
+  };
+  __decorateClass([
+    (0, import_common16.Inject)("MEILI_CLIENT")
+  ], SearchClient.prototype, "meili", 2);
+  SearchClient = __decorateClass([
+    (0, import_common16.Injectable)()
+  ], SearchClient);
+
+  // pkgs/@akanjs/nest/src/cacheClient.ts
+  var import_common17 = __require("@nestjs/common");
+  var CacheClient = class {
+    redis;
+  };
+  __decorateClass([
+    (0, import_common17.Inject)("REDIS_CLIENT")
+  ], CacheClient.prototype, "redis", 2);
+  CacheClient = __decorateClass([
+    (0, import_common17.Injectable)()
+  ], CacheClient);
+
+  // pkgs/@akanjs/nest/src/databaseClient.ts
+  var import_common19 = __require("@nestjs/common");
+  var import_mongoose2 = __require("@nestjs/mongoose");
+  var DatabaseClient = class {
+    connection;
+    getModel(modelName) {
+      const model = this.connection.models[capitalize(modelName)];
+      return model;
+    }
+  };
+  __decorateClass([
+    (0, import_mongoose2.InjectConnection)()
+  ], DatabaseClient.prototype, "connection", 2);
+  DatabaseClient = __decorateClass([
+    (0, import_common19.Injectable)()
+  ], DatabaseClient);
+
+  // pkgs/@akanjs/nest/src/decorators.ts
+  var import_reflect_metadata6 = __require("reflect-metadata");
+  var import_schedule = __require("@nestjs/schedule");
+  var Try = () => {
+    return function(target, key, descriptor) {
+      const originMethod = descriptor.value;
+      descriptor.value = async function(...args) {
+        try {
+          const result = await originMethod.apply(this, args);
+          return result;
+        } catch (e) {
+          this.logger?.warn(`${key} action error return: ${e}`);
+        }
+      };
+    };
+  };
+  var Cron = (cronTime, { lock = true, serverMode, enabled = true } = {}) => {
+    return function(target, key, descriptor) {
+      const originMethod = descriptor.value;
+      let isRunning = false;
+      descriptor.value = async function(...args) {
+        if (lock && isRunning)
+          return this.logger?.warn(`Cronjob-${key} is already running, skipped`);
+        try {
+          isRunning = true;
+          this.logger?.verbose(`Cron Job-${key} started`);
+          const res = await originMethod.apply(this, args);
+          this.logger?.verbose(`Cron Job-${key} finished`);
+          isRunning = false;
+          return res;
+        } catch (e) {
+          this.logger?.error(`Cron Job-${key} error return: ${e}`);
+          isRunning = false;
+        }
+      };
+      if (!enabled)
+        return;
+      if (!serverMode || process.env.SERVER_MODE === "all" || serverMode === process.env.SERVER_MODE)
+        (0, import_schedule.Cron)(cronTime)(target, key, descriptor);
+    };
+  };
+  var getIntervalMetaMap = (prototype) => {
+    return Reflect.getMetadata("serviceInterval", prototype) ?? /* @__PURE__ */ new Map();
+  };
+  var setIntervalMetaMap = (prototype, intervalMetaMap) => {
+    Reflect.defineMetadata("serviceInterval", intervalMetaMap, prototype);
+  };
+  var Interval = (ms, { lock = true, serverMode, enabled = true } = {}) => {
+    return function(target, key, descriptor) {
+      const intervalMetaMap = getIntervalMetaMap(target);
+      if (intervalMetaMap.has(key))
+        return descriptor;
+      intervalMetaMap.set(key, descriptor.value);
+      setIntervalMetaMap(target, intervalMetaMap);
+      const originMethod = descriptor.value;
+      let isRunning = false;
+      descriptor.value = async function(...args) {
+        if (lock && isRunning)
+          return this.logger?.warn(`Cronjob-${key} is already running, skipped`);
+        try {
+          isRunning = true;
+          this.logger?.verbose(`Interval Job-${key} started`);
+          const res = await originMethod.apply(this, args);
+          this.logger?.verbose(`Interval Job-${key} finished`);
+          isRunning = false;
+          return res;
+        } catch (e) {
+          this.logger?.error(`Cronjob-${key} error return: ${e}`);
+          isRunning = false;
+        }
+      };
+      if (!enabled)
+        return;
+      if (!serverMode || process.env.SERVER_MODE === "all" || serverMode === process.env.SERVER_MODE)
+        (0, import_schedule.Interval)(ms)(target, key, descriptor);
+    };
+  };
+  var Transaction = () => {
+    return function(target, key, descriptor) {
+      const originMethod = descriptor.value;
+      descriptor.value = function(...args) {
+        if (!this.connection)
+          throw new Error(`No Connection in function ${key}`);
+        return new Promise((resolve, reject) => {
+          this.connection.transaction(async () => {
+            const res = await originMethod.apply(this, args);
+            resolve(res);
+          }).catch(reject);
+        });
+      };
+      return descriptor;
+    };
+  };
+  var Cache = (timeout2 = 1e3, getCacheKey) => {
+    return function(target, key, descriptor) {
+      const originMethod = descriptor.value;
+      const cacheMap = /* @__PURE__ */ new Map();
+      const timerMap = /* @__PURE__ */ new Map();
+      descriptor.value = async function(...args) {
+        const classType = this.__model ? "doc" : this.__databaseModel ? "service" : "class";
+        const model = this.__model ?? this.__databaseModel?.__model;
+        const cache = this.__cache ?? this.__databaseModel?.__cache;
+        const getCacheKeyFn = getCacheKey ?? JSON.stringify;
+        const cacheKey = `${classType}:${model.modelName}:${key}:${getCacheKeyFn(...args)}`;
+        const getCache = async (cacheKey2) => {
+          if (classType === "class")
+            return cacheMap.get(cacheKey2);
+          const cached = await cache.get(cacheKey2);
+          if (cached)
+            return JSON.parse(cached);
+          return null;
+        };
+        const setCache = async (cacheKey2, value) => {
+          if (classType === "class") {
+            const existingTimer = timerMap.get(cacheKey2);
+            if (existingTimer)
+              clearTimeout(existingTimer);
+            cacheMap.set(cacheKey2, value);
+            const timer = setTimeout(() => {
+              cacheMap.delete(cacheKey2);
+              timerMap.delete(cacheKey2);
+            }, timeout2);
+            timerMap.set(cacheKey2, timer);
+          } else
+            await cache.set(cacheKey2, JSON.stringify(value), { PX: timeout2 });
+        };
+        const cachedData = await getCache(cacheKey);
+        if (cachedData) {
+          this.logger?.trace(`${model.modelName} cache hit: ${cacheKey}`);
+          return cachedData;
+        }
+        const result = await originMethod.apply(this, args);
+        await setCache(cacheKey, result);
+        this.logger?.trace(`${model.modelName} cache set: ${cacheKey}`);
+        return result;
+      };
+    };
+  };
+})();
+//! Nextjs는 환경변수를 build time에 그냥 하드코딩으로 값을 넣어버림. operationMode같은것들 잘 동작안할 수 있음. 추후 수정 필요.