@akanjs/server 0.0.34 → 0.0.36

package/index.js

@@ -1,21 +1,3781 @@
-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 });
+(() => {
+  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 Enum = class {
+    constructor(values) {
+      this.values = values;
+      this.valueMap = new Map(values.map((value, idx) => [value, idx]));
+    }
+    value;
+    // for type
+    valueMap;
+    has(value) {
+      return this.valueMap.has(value);
+    }
+    indexOf(value) {
+      const idx = this.valueMap.get(value);
+      if (idx === void 0)
+        throw new Error(`Value ${value} is not in enum`);
+      return idx;
+    }
+    find(callback) {
+      const val = this.values.find(callback);
+      if (val === void 0)
+        throw new Error(`Value not found in enum`);
+      return val;
+    }
+    findIndex(callback) {
+      const idx = this.values.findIndex(callback);
+      if (idx === -1)
+        throw new Error(`Value not found in enum`);
+      return idx;
+    }
+    filter(callback) {
+      return this.values.filter(callback);
+    }
+    map(callback) {
+      return this.values.map(callback);
+    }
+    forEach(callback) {
+      this.values.forEach(callback);
+    }
+  };
+  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 arraiedModel = (modelRef, arrDepth = 0) => {
+    let target = modelRef;
+    for (let i = 0; i < arrDepth; i++)
+      target = [target];
+    return target;
+  };
+  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/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 getFieldMetaMap = (modelRef) => {
+    const [target] = getNonArrayModel(modelRef);
+    const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
+    return new Map(metadataMap);
+  };
+  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");
+  var CnstStorage = class {
+  };
+  var getCnstMeta = (refName) => {
+    const cnst = Reflect.getMetadata(refName, CnstStorage.prototype);
+    if (!cnst)
+      throw new Error(`No cnst meta for ${refName}`);
+    return cnst;
+  };
+
+  // pkgs/@akanjs/constant/src/filterMeta.ts
+  var getFilterMeta = (filterRef) => {
+    const filterMeta = Reflect.getMetadata("filter", filterRef.prototype);
+    if (!filterMeta)
+      throw new Error("filterMeta is not defined");
+    return filterMeta;
+  };
+  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 getFilterQuery = (filterRef, key) => {
+    const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(filterRef.prototype);
+    const filterKeyMeta = filterKeyMetaMap.get(key);
+    if (!filterKeyMeta?.descriptor.value)
+      throw new Error(`filterKeyMeta is not defined for key: ${key}`);
+    return filterKeyMeta.descriptor.value;
+  };
+  var getFilterSort = (filterRef, key) => {
+    const filterMeta = getFilterMeta(filterRef);
+    const sort = filterMeta.sort[key];
+    return sort;
+  };
+  var getFilterSortMap = (filterRef) => {
+    const filterMeta = getFilterMeta(filterRef);
+    return filterMeta.sort;
+  };
+  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");
+
+  // 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);
+  var isValidDate = (d) => {
+    const format = "YYYY-MM-DD";
+    if (typeof d === "string") {
+      return (0, import_dayjs4.default)(d, format).isValid();
+    } else if ((0, import_dayjs2.isDayjs)(d))
+      return d.isValid();
+    else
+      return d instanceof Date && !isNaN(d.getTime());
+  };
+
+  // pkgs/@akanjs/common/src/pluralize.ts
+  var import_pluralize = __toESM(__require("pluralize"));
+
+  // pkgs/@akanjs/common/src/applyMixins.ts
+  var getAllPropertyDescriptors = (objRef) => {
+    const descriptors = {};
+    let current = objRef.prototype;
+    while (current) {
+      Object.getOwnPropertyNames(current).forEach((name) => {
+        descriptors[name] ??= Object.getOwnPropertyDescriptor(current, name);
+      });
+      current = Object.getPrototypeOf(current);
+    }
+    return descriptors;
+  };
+  var applyMixins = (derivedCtor, constructors, avoidKeys) => {
+    constructors.forEach((baseCtor) => {
+      Object.entries(getAllPropertyDescriptors(baseCtor)).forEach(([name, descriptor]) => {
+        if (name === "constructor" || avoidKeys?.has(name))
+          return;
+        Object.defineProperty(derivedCtor.prototype, name, { ...descriptor, configurable: true });
+      });
+    });
+  };
+
+  // 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/constant/src/baseGql.ts
+  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 getFullModelRef = (refName) => {
+    const modelRef = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
+    if (!modelRef)
+      throw new Error(`FullModel not found - ${refName}`);
+    return modelRef;
+  };
+  var getInputModelRef = (refName) => {
+    const modelRef = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
+    if (!modelRef)
+      throw new Error(`InputModel not found - ${refName}`);
+    return modelRef;
+  };
+  var getChildClassRefs = (target) => {
+    const metadatas = getFieldMetas(target);
+    const refMap = /* @__PURE__ */ new Map();
+    const childRefs = metadatas.filter((metadata) => metadata.isClass).reduce((acc, metadata) => {
+      return [...acc, metadata.modelRef, ...getChildClassRefs(metadata.modelRef)];
+    }, []);
+    childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set(getClassMeta(modelRef).refName, modelRef));
+    return [...refMap.values()];
+  };
+  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/server/src/gql.ts
+  var Nest = __toESM(__require("@nestjs/graphql"));
+  var import_graphql = __require("@nestjs/graphql");
+  var import_dayjs6 = __require("dayjs");
+  var import_graphql2 = __require("graphql");
+  var import_graphql_type_json = __toESM(__require("graphql-type-json"));
+  var DateScalar = class {
+    description = "Date custom scalar type";
+    parseValue(value) {
+      return dayjs(value);
+    }
+    serialize(value) {
+      if ((0, import_dayjs6.isDayjs)(value))
+        return value.toDate();
+      else
+        return new Date(value);
+    }
+    parseLiteral(ast) {
+      if (ast.kind === import_graphql2.Kind.INT)
+        return dayjs(ast.value);
+      else if (ast.kind === import_graphql2.Kind.STRING)
+        return dayjs(ast.value);
+      else
+        return null;
+    }
+  };
+  DateScalar = __decorateClass([
+    Nest.Scalar("Date", () => Date)
+  ], DateScalar);
+  var ObjectGqlStorage = class {
+  };
+  var InputGqlStorage = class {
+  };
+  var getPredefinedInqutGql = (refName) => {
+    const inputGql = Reflect.getMetadata(refName, InputGqlStorage.prototype);
+    return inputGql;
+  };
+  var setPredefinedInqutGql = (refName, inputGql) => {
+    Reflect.defineMetadata(refName, inputGql, InputGqlStorage.prototype);
+  };
+  var getPredefinedObjectGql = (refName) => {
+    const objectGql = Reflect.getMetadata(refName, ObjectGqlStorage.prototype);
+    return objectGql;
+  };
+  var setPredefinedObjectGql = (refName, objectGql) => {
+    Reflect.defineMetadata(refName, objectGql, ObjectGqlStorage.prototype);
+  };
+  var gqlNestFieldMap = /* @__PURE__ */ new Map([
+    [ID, Nest.ID],
+    [Int, Nest.Int],
+    [Float, Nest.Float],
+    [JSON2, import_graphql_type_json.default],
+    [Map, import_graphql_type_json.default]
+  ]);
+  var applyNestField = (model, fieldMeta, type = "object") => {
+    if (fieldMeta.fieldType === "hidden" && type === "object")
+      return;
+    const modelRef = fieldMeta.isClass ? type === "object" ? generateGql(fieldMeta.modelRef) : fieldMeta.isScalar ? generateGqlInput(fieldMeta.modelRef) : Nest.ID : gqlNestFieldMap.get(fieldMeta.modelRef) ?? fieldMeta.modelRef;
+    (0, import_graphql.Field)(() => arraiedModel(modelRef, fieldMeta.arrDepth), { nullable: fieldMeta.nullable })(
+      model.prototype,
+      fieldMeta.key
+    );
+  };
+  var generateGqlInput = (inputRef) => {
+    const classMeta = getClassMeta(inputRef);
+    const predefinedInputGql = getPredefinedInqutGql(classMeta.refName);
+    if (predefinedInputGql)
+      return predefinedInputGql;
+    const fieldMetas = getFieldMetas(inputRef);
+    class InputGql {
+    }
+    const inputGql = classMeta.type === "scalar" ? InputGql : getInputModelRef(classMeta.refName);
+    fieldMetas.forEach((fieldMeta) => {
+      applyNestField(inputGql, fieldMeta, "input");
+    });
+    (0, import_graphql.InputType)(classMeta.refName + (classMeta.type === "scalar" ? "Input" : ""))(inputGql);
+    setPredefinedInqutGql(classMeta.refName, inputGql);
+    return inputGql;
+  };
+  var generateGql = (objectRef) => {
+    const classMeta = getClassMeta(objectRef);
+    if (classMeta.type === "light") {
+      const fullModelRefName = classMeta.refName.slice(5);
+      const fullModelRef = getFullModelRef(fullModelRefName);
+      return generateGql(fullModelRef);
+    }
+    const predefinedObjectGql = getPredefinedObjectGql(classMeta.refName);
+    if (predefinedObjectGql)
+      return predefinedObjectGql;
+    const fieldMetas = getFieldMetas(objectRef);
+    class ObjectGql {
+    }
+    const objectGql = classMeta.type === "scalar" ? ObjectGql : getFullModelRef(classMeta.refName);
+    fieldMetas.forEach((fieldMeta) => {
+      applyNestField(objectGql, fieldMeta);
+    });
+    (0, import_graphql.ObjectType)(classMeta.refName)(objectGql);
+    setPredefinedObjectGql(classMeta.refName, objectGql);
+    return objectGql;
+  };
+
+  // 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/signal/src/immerify.ts
+  var import_immer = __require("immer");
+
+  // pkgs/@akanjs/signal/src/signalDecorators.ts
+  var import_reflect_metadata5 = __require("reflect-metadata");
+  var SignalStorage = class {
+  };
+  var getSignalRefsOnStorage = (refName) => {
+    const sigRefs = Reflect.getMetadata(refName, SignalStorage.prototype);
+    return sigRefs ?? [];
+  };
+  var setSignalRefOnStorage = (refName, signalRef) => {
+    Reflect.defineMetadata(refName, [...getSignalRefsOnStorage(refName), signalRef], SignalStorage.prototype);
+  };
+  var getDefaultArg = (argRef) => {
+    const [modelRef, arrDepth] = getNonArrayModel(argRef);
+    if (arrDepth)
+      return [];
+    const scalarArg = scalarArgMap.get(modelRef);
+    if (scalarArg)
+      return scalarArg;
+    else
+      return {};
+  };
+  function Signal(returnsOrObj) {
+    const returns = typeof returnsOrObj === "function" ? returnsOrObj : void 0;
+    const prefix = typeof returnsOrObj === "object" ? returnsOrObj.prefix : void 0;
+    return function(target) {
+      if (returns) {
+        const modelRef = returns();
+        const classMeta = getClassMeta(modelRef);
+        const gqlMetas = getGqlMetas(target);
+        const modelName = lowerlize(classMeta.refName);
+        const listName = `${modelName}ListIn`;
+        const slices = [
+          { refName: modelName, sliceName: modelName, argLength: 1, defaultArgs: [{}] },
+          ...gqlMetas.filter((gqlMeta) => {
+            const name = gqlMeta.signalOption.name ?? gqlMeta.key;
+            if (!name.includes(listName))
+              return false;
+            const [retRef, arrDepth] = getNonArrayModel(gqlMeta.returns());
+            return retRef.prototype === modelRef.prototype && arrDepth === 1;
+          }).map((gqlMeta) => {
+            const name = gqlMeta.signalOption.name ?? gqlMeta.key;
+            const sliceName = name.replace(listName, `${modelName}In`);
+            const [argMetas] = getArgMetas(target, gqlMeta.key);
+            const skipIdx = argMetas.findIndex((argMeta) => argMeta.name === "skip");
+            if (skipIdx === -1)
+              throw new Error(`Invalid Args for ${sliceName}`);
+            const argLength = skipIdx;
+            const queryArgRefs = argMetas.slice(0, skipIdx).map((argMeta) => argMeta.returns());
+            const defaultArgs = queryArgRefs.map(
+              (queryArgRef, idx) => argMetas[idx].argsOption.nullable ? null : getDefaultArg(queryArgRef)
+            );
+            return { refName: modelName, sliceName, argLength, defaultArgs };
+          })
+        ];
+        setSigMeta(target, { returns, prefix, slices, refName: modelName });
+        setSignalRefOnStorage(modelName, target);
+      } else {
+        const refName = typeof returnsOrObj === "object" ? lowerlize(returnsOrObj.name) : void 0;
+        if (!refName)
+          throw new Error("Signal name is required");
+        setSigMeta(target, { returns, prefix, slices: [], refName });
+        setSignalRefOnStorage(refName, target);
+      }
+    };
   }
-  return to;
-};
-var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var server_exports = {};
-module.exports = __toCommonJS(server_exports);
-__reExport(server_exports, require("./src"), module.exports);
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  ...require("./src")
-});
+  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")
+  };
+  function LogSignal(srv) {
+    class BaseSignal {
+    }
+    return BaseSignal;
+  }
+  var getSigMeta = (sigRef) => {
+    const sigMeta = Reflect.getMetadata("signal", sigRef.prototype);
+    if (!sigMeta)
+      throw new Error(`No SignalMeta found for ${sigRef.name}`);
+    return sigMeta;
+  };
+  var setSigMeta = (sigRef, sigMeta) => {
+    Reflect.defineMetadata("signal", sigMeta, sigRef.prototype);
+  };
+  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 getGqlMetas = (sigRef) => {
+    const gqlMetaMap = Reflect.getMetadata("gql", sigRef.prototype);
+    return gqlMetaMap ? [...gqlMetaMap.values()] : [];
+  };
+  var setGqlMetaMapOnPrototype = (prototype, gqlMetaMap) => {
+    Reflect.defineMetadata("gql", gqlMetaMap, prototype);
+  };
+  var getArgMetas = (sigRef, key) => {
+    const metas = Reflect.getMetadata("args", sigRef.prototype, key) ?? [];
+    const argMetas = metas.filter((meta) => !!meta.returns);
+    const internalArgMetas = metas.filter((meta) => !meta.returns);
+    return [argMetas, internalArgMetas];
+  };
+  var getArgMetasOnPrototype = (prototype, key) => {
+    return Reflect.getMetadata("args", prototype, key) ?? [];
+  };
+  var setArgMetasOnPrototype = (prototype, key, argMetas) => {
+    Reflect.defineMetadata("args", argMetas, prototype, key);
+  };
+  var getResolveFieldMetaMapOnPrototype = (prototype) => {
+    const resolveFieldMetaMap = Reflect.getMetadata("resolveField", prototype);
+    return resolveFieldMetaMap ?? /* @__PURE__ */ new Map();
+  };
+  var getResolveFieldMetas = (sigRef) => {
+    const resolveFieldMetaMap = Reflect.getMetadata("resolveField", sigRef.prototype);
+    return resolveFieldMetaMap ? [...resolveFieldMetaMap.values()] : [];
+  };
+  var setResolveFieldMetaMapOnPrototype = (prototype, resolveFieldMetaMap) => {
+    Reflect.defineMetadata("resolveField", resolveFieldMetaMap, prototype);
+  };
+  var getControllerPrefix = (sigMeta) => {
+    return sigMeta.returns ? lowerlize(getClassMeta(sigMeta.returns()).refName) : sigMeta.prefix;
+  };
+  var getControllerPath = (gqlMeta, paramArgMetas) => {
+    return gqlMeta.signalOption.path ?? [gqlMeta.signalOption.name ?? gqlMeta.key, ...paramArgMetas.map((argMeta) => `:${argMeta.name}`)].join("/");
+  };
+  var copySignal = (sigRef) => {
+    class CopiedSignal {
+    }
+    applyMixins(CopiedSignal, [sigRef]);
+    const sigMeta = getSigMeta(sigRef);
+    setSigMeta(CopiedSignal, sigMeta);
+    const gqlMetaMap = getGqlMetaMapOnPrototype(sigRef.prototype);
+    setGqlMetaMapOnPrototype(CopiedSignal.prototype, new Map(gqlMetaMap));
+    const resolveFieldMetaMap = getResolveFieldMetaMapOnPrototype(sigRef.prototype);
+    setResolveFieldMetaMapOnPrototype(CopiedSignal.prototype, new Map(resolveFieldMetaMap));
+    for (const endpointMeta of [...gqlMetaMap.values(), ...resolveFieldMetaMap.values()]) {
+      const argMetas = getArgMetasOnPrototype(sigRef.prototype, endpointMeta.key);
+      setArgMetasOnPrototype(CopiedSignal.prototype, endpointMeta.key, [...argMetas]);
+      const paramtypes = Reflect.getMetadata("design:paramtypes", sigRef.prototype, endpointMeta.key);
+      const argParamtypes = argMetas.filter((argMeta) => !!argMeta.returns).map((argMeta) => Object);
+      Reflect.defineMetadata("design:paramtypes", paramtypes ?? argParamtypes, CopiedSignal.prototype, endpointMeta.key);
+      Reflect.defineMetadata("design:paramtypes", paramtypes ?? argParamtypes, CopiedSignal.prototype, endpointMeta.key);
+    }
+    return CopiedSignal;
+  };
+
+  // pkgs/@akanjs/signal/src/gql.ts
+  var DefaultStorage = class {
+  };
+  var getPredefinedDefault = (refName) => {
+    const defaultData = Reflect.getMetadata(refName, DefaultStorage.prototype);
+    return defaultData;
+  };
+  var setPredefinedDefault = (refName, defaultData) => {
+    Reflect.defineMetadata(refName, defaultData, DefaultStorage.prototype);
+  };
+  var makeDefault = (target, option = {}) => {
+    const classMeta = getClassMeta(target);
+    const predefinedDefault = getPredefinedDefault(classMeta.refName);
+    if (predefinedDefault && !option.overwrite)
+      return predefinedDefault;
+    if (option.isChild && classMeta.type !== "scalar")
+      return null;
+    const metadatas = getFieldMetas(target);
+    const result = {};
+    for (const metadata of metadatas) {
+      if (metadata.fieldType === "hidden")
+        result[metadata.key] = null;
+      else if (metadata.default) {
+        if (typeof metadata.default === "function")
+          result[metadata.key] = metadata.default();
+        else if (metadata.default instanceof Enum)
+          result[metadata.key] = [...metadata.default.values];
+        else
+          result[metadata.key] = metadata.default;
+      } else if (metadata.isArray)
+        result[metadata.key] = [];
+      else if (metadata.nullable)
+        result[metadata.key] = null;
+      else if (metadata.isClass)
+        result[metadata.key] = metadata.isScalar ? makeDefault(metadata.modelRef) : null;
+      else
+        result[metadata.key] = scalarDefaultMap.get(metadata.modelRef);
+    }
+    setPredefinedDefault(classMeta.refName, result);
+    return result;
+  };
+  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_graphql3 = __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_graphql3.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_graphql3.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_graphql3.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_graphql4 = __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_graphql4.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 fs = __toESM(__require("fs"));
+
+  // pkgs/@akanjs/nest/src/verifyPayment.ts
+  var import_iap = __toESM(__require("iap"));
+
+  // 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");
+
+  // 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 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 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 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;
+    };
+  };
+
+  // pkgs/@akanjs/service/src/serviceDecorators.ts
+  var import_reflect_metadata7 = __require("reflect-metadata");
+  var import_common21 = __require("@nestjs/common");
+  var import_mongoose3 = __require("@nestjs/mongoose");
+  var ServiceStorage = class {
+  };
+  var getServiceRefs = (refName) => {
+    return Reflect.getMetadata(refName, ServiceStorage.prototype) ?? [];
+  };
+  var isServiceDefined = (srvRef) => {
+    return Reflect.getMetadata("service", srvRef.prototype) ?? false;
+  };
+  var setServiceDefined = (srvRef) => {
+    Reflect.defineMetadata("service", true, srvRef.prototype);
+  };
+  var getServiceMeta = (srvRef) => {
+    return Reflect.getMetadata("serviceMeta", srvRef.prototype);
+  };
+  var isServiceEnabled = (srvRef) => {
+    const meta = getServiceMeta(srvRef);
+    return meta?.enabled ?? false;
+  };
+  var getServiceInjectMetaMapOnPrototype = (prototype) => {
+    return Reflect.getMetadata("inject", prototype) ?? /* @__PURE__ */ new Map();
+  };
+  var serviceOf = (srvRef) => {
+    if (isServiceDefined(srvRef))
+      return srvRef;
+    const injectMetaMap = getServiceInjectMetaMapOnPrototype(srvRef.prototype);
+    for (const injectMeta of [...injectMetaMap.values()]) {
+      if (injectMeta.type === "Db")
+        (0, import_mongoose3.InjectModel)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+      else if (injectMeta.type === "Use")
+        (0, import_common21.Inject)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+      else if (injectMeta.type === "Srv") {
+        const services = getServiceRefs(injectMeta.name);
+        if (!services.length)
+          throw new Error(`Service ${injectMeta.name} not found`);
+        (0, import_common21.Inject)(services.at(-1))(srvRef.prototype, injectMeta.key);
+      } else if (injectMeta.type === "Queue")
+        (0, import_common21.Inject)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+      else
+        (0, import_common21.Inject)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+    }
+    (0, import_mongoose3.InjectConnection)()(srvRef.prototype, "connection");
+    (0, import_common21.Injectable)()(srvRef);
+    setServiceDefined(srvRef);
+    return srvRef;
+  };
+
+  // pkgs/@akanjs/server/src/resolver.ts
+  var import_common23 = __require("@nestjs/common");
+  var Nest2 = __toESM(__require("@nestjs/graphql"));
+  var import_graphql_type_json2 = __toESM(__require("graphql-type-json"));
+  var import_graphql_upload = __require("graphql-upload");
+  var scalarNestReturnMap = /* @__PURE__ */ new Map([
+    [Upload, import_graphql_upload.GraphQLUpload],
+    [ID, Nest2.ID],
+    [Int, Nest2.Int],
+    [Float, Nest2.Float],
+    [JSON2, import_graphql_type_json2.default],
+    [Boolean, Boolean],
+    [Date, Date],
+    [String, String],
+    [Map, import_graphql_type_json2.default]
+  ]);
+  var getNestReturn = (returns, type = "object") => {
+    const [model, arrDepth] = getNonArrayModel(returns());
+    const modelRef = scalarNestReturnMap.get(model) ?? (type === "object" ? generateGql(model) : generateGqlInput(model));
+    return () => arraiedModel(modelRef, arrDepth);
+  };
+  var internalArgMap = {
+    Parent: Nest2.Parent,
+    Account: Account3,
+    UserIp: UserIp2,
+    Access: Access2,
+    Self: Self2,
+    Me: Me2,
+    Req: Req2,
+    Res: Res2
+  };
+  var resolverOf = (sigRef, allSrvs) => {
+    const Rsv = copySignal(sigRef);
+    const sigMeta = getSigMeta(Rsv);
+    const gqlMetas = getGqlMetas(Rsv);
+    Object.keys(allSrvs).forEach((srv) => {
+      if (!isServiceEnabled(allSrvs[srv]))
+        return;
+      (0, import_common23.Inject)(allSrvs[srv])(Rsv.prototype, lowerlize(srv));
+    });
+    for (const gqlMeta of gqlMetas) {
+      if (gqlMeta.guards.some((guard) => guard === "None") || gqlMeta.signalOption.onlyFor === "restapi" || !["Query", "Mutation"].includes(gqlMeta.type))
+        continue;
+      else if (gqlMeta.signalOption.sso)
+        continue;
+      const [argMetas, internalArgMetas] = getArgMetas(Rsv, gqlMeta.key);
+      const descriptor = Object.getOwnPropertyDescriptor(Rsv.prototype, gqlMeta.key) ?? {};
+      for (const argMeta of argMetas) {
+        Nest2.Args({
+          name: argMeta.name,
+          type: getNestReturn(argMeta.returns, "input"),
+          ...argMeta.argsOption
+        })(Rsv.prototype, gqlMeta.key, argMeta.idx);
+      }
+      for (const internalArgMeta of internalArgMetas) {
+        const decorate = internalArgMap[internalArgMeta.type];
+        decorate(internalArgMeta.option ?? {})(Rsv.prototype, gqlMeta.key, internalArgMeta.idx);
+      }
+      (0, import_common23.UseGuards)(...gqlMeta.guards.map((guard) => authGuards_exports[guard]))(Rsv.prototype, gqlMeta.key, descriptor);
+      if (gqlMeta.type === "Query")
+        Nest2.Query(getNestReturn(gqlMeta.returns), gqlMeta.signalOption)(Rsv.prototype, gqlMeta.key, descriptor);
+      else if (gqlMeta.type === "Mutation")
+        Nest2.Mutation(getNestReturn(gqlMeta.returns), gqlMeta.signalOption)(Rsv.prototype, gqlMeta.key, descriptor);
+    }
+    const resolveFieldMetas = getResolveFieldMetas(Rsv);
+    if (sigMeta.returns) {
+      const modelRef = sigMeta.returns();
+      const fieldMetas = getFieldMetas(modelRef);
+      fieldMetas.filter((fieldMeta) => fieldMeta.isClass && !fieldMeta.isScalar).forEach((fieldMeta) => {
+        const classMeta = getClassMeta(fieldMeta.modelRef);
+        const modelName = lowerlize(classMeta.type === "light" ? classMeta.refName.slice(5) : classMeta.refName);
+        const className = capitalize(modelName);
+        const serviceName = `${modelName}Service`;
+        Rsv.prototype[fieldMeta.key] = async function(parent) {
+          const service = this[serviceName];
+          return fieldMeta.arrDepth ? await service[`load${className}Many`](parent[fieldMeta.key]) : await service[`load${className}`](parent[fieldMeta.key]);
+        };
+        Nest2.Parent()(Rsv.prototype, fieldMeta.key, 0);
+        Nest2.ResolveField(getNestReturn(() => arraiedModel(fieldMeta.modelRef, fieldMeta.arrDepth)))(
+          Rsv.prototype,
+          fieldMeta.key,
+          Object.getOwnPropertyDescriptor(Rsv.prototype, fieldMeta.key) ?? {}
+        );
+      });
+    }
+    for (const resolveFieldMeta of resolveFieldMetas) {
+      const [, internalArgMetas] = getArgMetas(Rsv, resolveFieldMeta.key);
+      for (const internalArgMeta of internalArgMetas) {
+        const decorate = internalArgMap[internalArgMeta.type];
+        decorate(internalArgMeta.option ?? {})(Rsv.prototype, resolveFieldMeta.key, internalArgMeta.idx);
+      }
+      Nest2.ResolveField(getNestReturn(resolveFieldMeta.returns))(
+        Rsv.prototype,
+        resolveFieldMeta.key,
+        Object.getOwnPropertyDescriptor(Rsv.prototype, resolveFieldMeta.key) ?? {}
+      );
+    }
+    if (sigMeta.returns)
+      Nest2.Resolver(getNestReturn(sigMeta.returns))(Rsv);
+    else
+      Nest2.Resolver()(Rsv);
+    return Rsv;
+  };
+
+  // pkgs/@akanjs/server/src/controller.ts
+  var import_common25 = __require("@nestjs/common");
+  var import_passport2 = __require("@nestjs/passport");
+  var import_platform_express = __require("@nestjs/platform-express");
+  var internalArgMap2 = {
+    // Parent: Nest.Parent,
+    Account: Account3,
+    UserIp: UserIp2,
+    Access: Access2,
+    Self: Self2,
+    Me: Me2,
+    Req: Req2,
+    Res: Res2
+  };
+  var controllerOf = (sigRef, allSrvs) => {
+    const sigMeta = getSigMeta(sigRef);
+    const gqlMetas = getGqlMetas(sigRef);
+    const prefix = getControllerPrefix(sigMeta);
+    const Ctrl = copySignal(sigRef);
+    Object.keys(allSrvs).forEach((srv) => {
+      if (!isServiceEnabled(allSrvs[srv]))
+        return;
+      (0, import_common25.Inject)(allSrvs[srv])(Ctrl.prototype, 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] = getArgMetas(Ctrl, gqlMeta.key);
+      internalArgMetas.forEach((internalArgMeta) => {
+        const internalDecorator = internalArgMap2[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] = getNonArrayModel(uploadArgMeta.returns());
+        if (modelRef.prototype !== 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_common25.UseInterceptors)((0, import_platform_express.FilesInterceptor)(uploadArgMeta.name))(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+        (0, import_common25.UploadedFiles)(MulterToUploadPipe)(Ctrl.prototype, gqlMeta.key, uploadArgMeta.idx);
+      }
+      const queryArgMetas = argMetas.filter((argMeta) => argMeta.type === "Query");
+      queryArgMetas.forEach((argMeta) => {
+        const [modelRef, arrDepth] = getNonArrayModel(argMeta.returns());
+        (0, import_common25.Query)(argMeta.name, ...getQueryPipes(modelRef, arrDepth))(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+      });
+      const paramArgMetas = argMetas.filter((argMeta) => argMeta.type === "Param");
+      paramArgMetas.forEach((argMeta) => {
+        (0, import_common25.Param)(argMeta.name)(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+      });
+      const path = getControllerPath(gqlMeta, paramArgMetas);
+      const bodyArgMetas = argMetas.filter((argMeta) => argMeta.type === "Body");
+      if (bodyArgMetas.length)
+        bodyArgMetas.forEach((argMeta) => {
+          (0, import_common25.Body)(argMeta.name, ...getBodyPipes(argMeta))(Ctrl.prototype, gqlMeta.key, argMeta.idx);
+        });
+      (0, import_common25.UseGuards)(
+        ...gqlMeta.guards.map((guard) => authGuards_exports[guard]),
+        ...gqlMeta.signalOption.sso ? [(0, import_passport2.AuthGuard)(gqlMeta.signalOption.sso)] : []
+      )(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+      if (gqlMeta.type === "Query")
+        (0, import_common25.Get)(path)(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+      else if (gqlMeta.type === "Mutation")
+        (0, import_common25.Post)(path)(Ctrl.prototype, gqlMeta.key, gqlMeta.descriptor);
+    }
+    if (prefix)
+      (0, import_common25.Controller)(prefix)(Ctrl);
+    else
+      (0, import_common25.Controller)()(Ctrl);
+    return Ctrl;
+  };
+
+  // pkgs/@akanjs/server/src/processor.ts
+  var import_bull = __require("@nestjs/bull");
+  var import_common27 = __require("@nestjs/common");
+  var convertProcessFunction = (gqlMeta, argMetas, internalArgMetas, fn) => {
+    return async function(job, done) {
+      const args = [];
+      argMetas.forEach((argMeta) => {
+        if (argMeta.type === "Msg")
+          args[argMeta.idx] = deserializeArg(argMeta, job.data[argMeta.idx]);
+        else
+          throw new Error(`Invalid ArgMeta Type ${argMeta.type}`);
+      });
+      internalArgMetas.forEach((internalArgMeta) => {
+        if (internalArgMeta.type === "Job")
+          args[internalArgMeta.idx] = job;
+        else
+          throw new Error(`Invalid InternalArgMeta Type ${internalArgMeta.type}`);
+      });
+      this.logger?.log(`Process-${gqlMeta.key} started`);
+      const result = await fn.apply(this, args);
+      this.logger?.log(`Process-${gqlMeta.key} finished`);
+      done(null, result);
+    };
+  };
+  var processorOf = (sigRef, allSrvs) => {
+    const sigMeta = getSigMeta(sigRef);
+    const serverMode = process.env.SERVER_MODE ?? "federation";
+    const gqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Process").filter(
+      (gqlMeta) => gqlMeta.signalOption.serverType === "all" || serverMode === "all" || gqlMeta.signalOption.serverType === serverMode
+    );
+    class QueueProcessor {
+    }
+    Object.keys(allSrvs).forEach((srv) => {
+      if (!isServiceEnabled(allSrvs[srv]))
+        return;
+      (0, import_common27.Inject)(allSrvs[srv])(QueueProcessor.prototype, lowerlize(srv));
+    });
+    for (const gqlMeta of gqlMetas) {
+      const [argMetas, internalArgMetas] = getArgMetas(sigRef, gqlMeta.key);
+      const descriptor = { ...Object.getOwnPropertyDescriptor(sigRef.prototype, gqlMeta.key) ?? {} };
+      descriptor.value = convertProcessFunction(
+        gqlMeta,
+        argMetas,
+        internalArgMetas,
+        descriptor.value
+      );
+      Object.defineProperty(QueueProcessor.prototype, gqlMeta.key, descriptor);
+      (0, import_bull.Process)(gqlMeta.key)(QueueProcessor.prototype, gqlMeta.key, descriptor);
+    }
+    (0, import_bull.Processor)(sigMeta.refName)(QueueProcessor);
+    return QueueProcessor;
+  };
+  var queueOf = (sigRef, queue) => {
+    const sigMeta = getSigMeta(sigRef);
+    const gqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Process");
+    for (const gqlMeta of gqlMetas) {
+      if (queue[gqlMeta.key])
+        throw new Error(`Queue already has ${gqlMeta.key} in ${sigMeta.refName}`);
+      queue[gqlMeta.key] = (...args) => queue.add(gqlMeta.key, args);
+    }
+    return queue;
+  };
+
+  // pkgs/@akanjs/document/src/dbDecorators.ts
+  var ModelDatabaseStorage = class {
+  };
+  var getAllDatabaseModelNames = () => {
+    const modelNames = Reflect.getMetadataKeys(ModelDatabaseStorage.prototype) ?? [];
+    return modelNames;
+  };
+
+  // pkgs/@akanjs/document/src/schema.ts
+  var import_mongoose4 = __require("mongoose");
+  var getDefaultSchemaOptions = () => ({
+    toJSON: { getters: false, virtuals: true },
+    toObject: { getters: false, virtuals: true },
+    _id: true,
+    id: true,
+    timestamps: true,
+    methods: {
+      refresh: async function() {
+        Object.assign(this, await this.constructor.findById(this._id));
+        return this;
+      }
+    },
+    statics: {
+      pickOne: async function(query, projection) {
+        const doc = await this.findOne(query, projection);
+        if (!doc)
+          throw new Error("No Document");
+        return doc;
+      },
+      pickById: async function(docId, projection) {
+        if (!docId)
+          throw new Error("No Document ID");
+        const doc = await this.findById(docId, projection);
+        if (!doc)
+          throw new Error("No Document");
+        return doc;
+      },
+      sample: async function(query, size = 1, aggregations = []) {
+        const objs = await this.aggregate([
+          { $match: convertAggregateMatch(query) },
+          { $sample: { size } },
+          ...aggregations
+        ]);
+        return objs.map((obj) => new this(obj));
+      },
+      sampleOne: async function(query, aggregations = []) {
+        const obj = await this.aggregate([
+          { $match: convertAggregateMatch(query) },
+          { $sample: { size: 1 } },
+          ...aggregations
+        ]);
+        return obj.length ? new this(obj[0]) : null;
+      },
+      addSummary: async function(prefix = "total", num = 1) {
+        const update = Array.isArray(prefix) ? {
+          $inc: {
+            ...prefix.reduce((acc, cur) => ({ ...acc, [`${cur}${this.modelName}`]: num }), {})
+          }
+        } : { $inc: { [`${prefix}${this.modelName}`]: num } };
+        await this.db.collection("summaries").updateOne({ status: "active" }, update);
+      },
+      moveSummary: async function(prev, next, num = 1) {
+        await this.db.collection("summaries").updateOne(
+          { status: "active" },
+          {
+            $inc: {
+              [`${prev}${this.modelName}`]: -num,
+              [`${next}${this.modelName}`]: num
+            }
+          }
+        );
+      },
+      subSummary: async function(prefix = "total", num = 1) {
+        const update = Array.isArray(prefix) ? {
+          $inc: {
+            ...prefix.reduce((acc, cur) => ({ ...acc, [`${cur}${this.modelName}`]: -num }), {})
+          }
+        } : { $inc: { [`${prefix}${this.modelName}`]: -num } };
+        await this.db.collection("summaries").updateOne({ status: "active" }, update);
+      }
+    }
+  });
+  var convertOperatorValue = (value) => {
+    if (Array.isArray(value))
+      return value.map((v) => convertOperatorValue(v));
+    else if (!value)
+      return value;
+    else if ((0, import_mongoose4.isValidObjectId)(value))
+      return new import_mongoose4.Types.ObjectId(value);
+    else if (isValidDate(value))
+      return dayjs(value).toDate();
+    else if (value.constructor !== Object)
+      return value;
+    else if (typeof value !== "object")
+      return value;
+    else
+      return Object.fromEntries(
+        Object.entries(value).map(([key, value2]) => [key, convertOperatorValue(value2)])
+      );
+  };
+  var convertAggregateMatch = (query) => {
+    return Object.fromEntries(
+      Object.entries(query).map(([key, value]) => {
+        return [key, convertOperatorValue(value)];
+      })
+    );
+  };
+
+  // pkgs/@akanjs/document/src/dataLoader.ts
+  var import_dataloader = __toESM(__require("dataloader"));
+  var import_lodash = __require("lodash");
+  var import_mongoose5 = __require("mongoose");
+  var Id = import_mongoose5.Types.ObjectId;
+  var ObjectId = import_mongoose5.Schema.Types.ObjectId;
+  var Mixed = import_mongoose5.Schema.Types.Mixed;
+  var createLoader = (model, fieldName = "_id", defaultQuery = {}) => {
+    return new import_dataloader.default(
+      (fields) => {
+        const query = { ...defaultQuery };
+        query[fieldName] = { $in: fields };
+        const data = model.find(query).then((list) => {
+          const listByKey = (0, import_lodash.keyBy)(list, fieldName);
+          return fields.map((id) => (0, import_lodash.get)(listByKey, id, null));
+        });
+        return data;
+      },
+      { name: "dataloader", cache: false }
+    );
+  };
+  var createArrayLoader = (model, fieldName = "_id", defaultQuery = {}) => {
+    return new import_dataloader.default((fields) => {
+      const query = { ...defaultQuery };
+      query[fieldName] = { $in: fields };
+      const data = model.find(query).then((list) => {
+        return fields.map((field) => list.filter((item) => field === item[fieldName]));
+      });
+      return data;
+    });
+  };
+  var createQueryLoader = (model, queryKeys, defaultQuery = {}) => {
+    return new import_dataloader.default(
+      (queries) => {
+        const query = {
+          $and: [{ $or: queries }, defaultQuery]
+        };
+        const getQueryKey = (query2) => queryKeys.map((key) => query2[key].toString()).join("");
+        const data = model.find(query).then((list) => {
+          const listByKey = (0, import_lodash.keyBy)(list, getQueryKey);
+          return queries.map((query2) => (0, import_lodash.get)(listByKey, getQueryKey(query2), null));
+        });
+        return data;
+      },
+      { name: "dataloader", cache: false }
+    );
+  };
+  var getLoaderMetaMapByPrototype = (prototype) => {
+    const loaderMetaMap = Reflect.getOwnMetadata("loaders", prototype) ?? /* @__PURE__ */ new Map();
+    return loaderMetaMap;
+  };
+  var getLoaderMetas = (target) => {
+    const metas = [...getLoaderMetaMapByPrototype(target.prototype).values()];
+    return metas;
+  };
+
+  // pkgs/@akanjs/document/src/database.ts
+  var CacheDatabase = class {
+    constructor(refName, redis) {
+      this.refName = refName;
+      this.redis = redis;
+      this.logger = new Logger(`${refName}Cache`);
+    }
+    logger;
+    async set(topic, key, value, option = {}) {
+      const setOption = { PXAT: option.expireAt?.toDate().getTime() };
+      await this.redis.set(`${this.refName}:${topic}:${key}`, value, setOption);
+    }
+    async get(topic, key) {
+      const value = await this.redis.get(`${this.refName}:${topic}:${key}`);
+      return value;
+    }
+    async delete(topic, key) {
+      await this.redis.del(`${this.refName}:${topic}:${key}`);
+    }
+  };
+  var SearchDatabase = class {
+    constructor(refName, meili) {
+      this.refName = refName;
+      this.meili = meili;
+      this.logger = new Logger(`${refName}Search`);
+      this.index = meili.index(lowerlize(refName));
+    }
+    logger;
+    index;
+    async searchIds(searchText, option = {}) {
+      const { skip = 0, limit = DEFAULT_PAGE_SIZE, sort } = option;
+      if (!searchText) {
+        const { results, total } = await this.index.getDocuments({ offset: skip ?? 0, limit: limit ?? 0 });
+        return { ids: results.map((result) => result.id), total };
+      }
+      const { hits, estimatedTotalHits } = await this.index.search(searchText, {
+        offset: skip ?? 0,
+        limit: limit ?? 0,
+        sort: sort ?? [],
+        filter: option.filter,
+        attributesToRetrieve: ["id"]
+      });
+      return { ids: hits.map((hit) => hit.id), total: estimatedTotalHits };
+    }
+    async count(searchText, option = {}) {
+      const { skip = 0, limit = DEFAULT_PAGE_SIZE, sort = "" } = option;
+      if (!searchText) {
+        const { results, total } = await this.index.getDocuments({ offset: skip ?? 0, limit: limit ?? 0 });
+        return total;
+      }
+      const { hits, estimatedTotalHits } = await this.index.search(searchText, {
+        offset: skip ?? 0,
+        limit: limit ?? 0,
+        filter: option.filter,
+        attributesToRetrieve: ["id"]
+      });
+      return estimatedTotalHits;
+    }
+  };
+  var DatabaseModelStorage = class {
+    __ModelType__ = "DatabaseModelStorage";
+  };
+  var databaseModelOf = (database, model, redis, meili) => {
+    const [modelName, className] = [database.refName, capitalize(database.refName)];
+    const insightFieldMetas = getFieldMetas(database.Insight);
+    const accumulator = Object.fromEntries(insightFieldMetas.map((fieldMeta) => [fieldMeta.key, fieldMeta.accumulate]));
+    const defaultInsight = Object.fromEntries(insightFieldMetas.map((fieldMeta) => [fieldMeta.key, fieldMeta.default]));
+    const makeSafeQuery = (query) => ({ removedAt: { $exists: false }, ...query ?? {} });
+    const makeSafeMatchStage = (query) => ({
+      $match: { removedAt: { $exists: false }, ...convertAggregateMatch(query) }
+    });
+    const getListQuery = (query, queryOption) => {
+      const find = makeSafeQuery(query);
+      const sort = getFilterSort(database.Filter, queryOption?.sort ?? "latest");
+      const skip = queryOption?.skip ?? 0;
+      const limit = queryOption?.limit === null ? DEFAULT_PAGE_SIZE : queryOption?.limit ?? 0;
+      const select = queryOption?.select;
+      const sample = queryOption?.sample;
+      return { find, sort, skip, limit, select, sample };
+    };
+    const getFindQuery = (query, queryOption) => {
+      const find = makeSafeQuery(query);
+      const sort = getFilterSort(database.Filter, queryOption?.sort ?? "latest");
+      const skip = queryOption?.skip ?? 0;
+      const select = queryOption?.select;
+      const sample = queryOption?.sample ?? false;
+      return { find, sort, skip, select, sample };
+    };
+    const getSearchSort = (sortKey) => {
+      const sort = getFilterSort(database.Filter, sortKey ?? "latest");
+      return Object.entries(sort).map(([key, value]) => `${key}:${value === 1 ? "asc" : "desc"}`);
+    };
+    const loader = createLoader(model);
+    const cacheDatabase = new CacheDatabase(database.refName, redis);
+    const searchDatabase = new SearchDatabase(database.refName, meili);
+    const DatabaseModel = Reflect.getMetadata(database.refName, DatabaseModelStorage.prototype) ?? class DatabaseModel {
+      logger = new Logger(`${modelName}Model`);
+      __model = model;
+      __cache = cacheDatabase;
+      __search = searchDatabase;
+      __loader = loader;
+      async __list(query, queryOption) {
+        const { find, sort, skip, limit, select, sample } = getListQuery(query, queryOption);
+        return sample ? await this.__model.sample(find, limit) : await this.__model.find(find, select).sort(sort).skip(skip).limit(limit);
+      }
+      async __listIds(query, queryOption) {
+        const { find, sort, skip, limit, sample } = getListQuery(query, queryOption);
+        return (sample ? await this.__model.sample(find, limit, [{ $project: { _id: 1 } }]) : await this.__model.find(find).sort(sort).skip(skip).limit(limit).select("_id")).map(({ _id }) => _id.toString());
+      }
+      async __find(query, queryOption) {
+        const { find, sort, skip, select, sample } = getFindQuery(query, queryOption);
+        const doc = sample ? await this.__model.sampleOne(find) : await this.__model.findOne(find, select).sort(sort).skip(skip);
+        if (!doc)
+          return null;
+        return doc;
+      }
+      async __findId(query, queryOption) {
+        const { find, sort, skip, sample } = getFindQuery(query, queryOption);
+        const doc = sample ? await this.__model.sampleOne(find, [{ $project: { _id: 1 } }]) : await this.__model.findOne(find).sort(sort).skip(skip).select("_id");
+        if (!doc)
+          return null;
+        return doc._id.toString();
+      }
+      async __pick(query, queryOption) {
+        const { find, sort, skip, select, sample } = getFindQuery(query, queryOption);
+        const doc = sample ? await this.__model.sampleOne(find) : await this.__model.findOne(find, select).sort(sort).skip(skip);
+        if (!doc)
+          throw new Error(`No Document (${database.refName}): ${JSON.stringify(query)}`);
+        return doc;
+      }
+      async __pickId(query, queryOption) {
+        const { find, sort, skip, sample } = getFindQuery(query, queryOption);
+        const doc = sample ? await this.__model.sampleOne(find, [{ $project: { _id: 1 } }]) : await this.__model.findOne(find).sort(sort).skip(skip).select("_id");
+        if (!doc)
+          throw new Error(`No Document (${database.refName}): ${JSON.stringify(query)}`);
+        return doc._id.toString();
+      }
+      async __exists(query) {
+        const find = makeSafeQuery(query);
+        const existingId = await this.__model.exists(find);
+        return existingId?.toString() ?? null;
+      }
+      async __count(query) {
+        const find = makeSafeQuery(query);
+        return await this.__model.countDocuments(find);
+      }
+      async __insight(query) {
+        if (!accumulator)
+          throw new Error(`No Insight (${database.refName})`);
+        const res = await this.__model.aggregate([
+          makeSafeMatchStage(query),
+          { $group: { _id: null, ...accumulator } }
+        ]);
+        const data = res[0];
+        return data ?? defaultInsight;
+      }
+      async getDefaultSummary(addQuery = {}) {
+        if (!database.Summary)
+          return {};
+        const fieldMetas = getFieldMetas(database.Summary);
+        const summary = {};
+        await Promise.all(
+          fieldMetas.filter((fieldMeta) => !!fieldMeta.query).map(async (fieldMeta) => {
+            const query = typeof fieldMeta.query === "function" ? fieldMeta.query() : fieldMeta.query;
+            summary[fieldMeta.key] = query ? await model.countDocuments({ ...query, ...addQuery }) : fieldMeta.default;
+          })
+        );
+        return summary;
+      }
+      async [`get${className}`](id) {
+        const doc = await this.__loader.load(id);
+        if (!doc)
+          throw new Error(`No Document (${database.refName}): ${id}`);
+        return doc;
+      }
+      async [`load${className}`](id) {
+        return id ? await this.__loader.load(id) : null;
+      }
+      async [`load${className}Many`](ids) {
+        return await this.__loader.loadMany(ids);
+      }
+      async [`create${className}`](data) {
+        return await new this.__model(data).save();
+      }
+      async [`update${className}`](id, data) {
+        const doc = await this.__model.pickById(id);
+        return await doc.set(data).save();
+      }
+      async [`remove${className}`](id) {
+        const doc = await this.__model.pickById(id);
+        return await doc.set({ removedAt: dayjs() }).save();
+      }
+      async [`search${className}`](searchText, queryOption = {}) {
+        const { skip, limit, sort } = queryOption;
+        const { ids, total } = await this.__search.searchIds(searchText, { skip, limit, sort: getSearchSort(sort) });
+        const docs = await this.__loader.loadMany(ids);
+        return { docs, count: total };
+      }
+      async [`searchDocs${className}`](searchText, queryOption = {}) {
+        const { skip, limit, sort } = queryOption;
+        const { ids } = await this.__search.searchIds(searchText, { skip, limit, sort: getSearchSort(sort) });
+        return await this.__loader.loadMany(ids);
+      }
+      async [`searchCount${className}`](searchText) {
+        return await this.__search.count(searchText);
+      }
+    };
+    DatabaseModel.prototype[className] = model;
+    DatabaseModel.prototype[`${modelName}Loader`] = loader;
+    DatabaseModel.prototype[`${modelName}Cache`] = cacheDatabase;
+    DatabaseModel.prototype[`${modelName}Search`] = searchDatabase;
+    const getQueryDataFromKey = (queryKey, args) => {
+      const lastArg = args.at(-1);
+      const hasQueryOption = lastArg && typeof lastArg === "object" && (typeof lastArg.select === "object" || typeof lastArg.skip === "number" || typeof lastArg.limit === "number" || typeof lastArg.sort === "string");
+      const queryFn = getFilterQuery(database.Filter, queryKey);
+      const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
+      const queryOption = hasQueryOption ? lastArg : {};
+      return { query, queryOption };
+    };
+    const filterKeyMetaMap = getFilterKeyMetaMapOnPrototype(database.Filter.prototype);
+    const queryKeys = [...filterKeyMetaMap.keys()];
+    queryKeys.forEach((queryKey) => {
+      const queryFn = getFilterQuery(database.Filter, queryKey);
+      DatabaseModel.prototype[`list${capitalize(queryKey)}`] = async function(...args) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__list(query, queryOption);
+      };
+      DatabaseModel.prototype[`listIds${capitalize(queryKey)}`] = async function(...args) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__listIds(query, queryOption);
+      };
+      DatabaseModel.prototype[`find${capitalize(queryKey)}`] = async function(...args) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__find(query, queryOption);
+      };
+      DatabaseModel.prototype[`findId${capitalize(queryKey)}`] = async function(...args) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__findId(query, queryOption);
+      };
+      DatabaseModel.prototype[`pick${capitalize(queryKey)}`] = async function(...args) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__pick(query, queryOption);
+      };
+      DatabaseModel.prototype[`pickId${capitalize(queryKey)}`] = async function(...args) {
+        const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+        return this.__pickId(query, queryOption);
+      };
+      DatabaseModel.prototype[`exists${capitalize(queryKey)}`] = async function(...args) {
+        const query = queryFn(...args);
+        return this.__exists(query);
+      };
+      DatabaseModel.prototype[`count${capitalize(queryKey)}`] = async function(...args) {
+        const query = queryFn(...args);
+        return this.__count(query);
+      };
+      DatabaseModel.prototype[`insight${capitalize(queryKey)}`] = async function(...args) {
+        const query = queryFn(...args);
+        return this.__insight(query);
+      };
+    });
+    const loaderMetas = getLoaderMetas(database.Model);
+    loaderMetas.forEach((loaderMeta) => {
+      const loader2 = loaderMeta.type === "Field" ? createLoader(model, loaderMeta.fieldName) : loaderMeta.type === "ArrayField" ? createArrayLoader(model, loaderMeta.fieldName) : loaderMeta.type === "Query" ? createQueryLoader(model, loaderMeta.queryKeys ?? []) : null;
+      DatabaseModel.prototype[loaderMeta.key] = loader2;
+    });
+    Object.getOwnPropertyNames(database.Model.prototype).forEach((key) => {
+      DatabaseModel.prototype[key] = database.Model.prototype[key];
+    });
+    const createDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `create${className}`);
+    if (createDescriptor)
+      Transaction()(DatabaseModel.prototype, `create${className}`, createDescriptor);
+    const updateDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `update${className}`);
+    if (updateDescriptor)
+      Transaction()(DatabaseModel.prototype, `update${className}`, updateDescriptor);
+    const removeDescriptor = Object.getOwnPropertyDescriptor(DatabaseModel.prototype, `remove${className}`);
+    if (removeDescriptor)
+      Transaction()(DatabaseModel.prototype, `remove${className}`, removeDescriptor);
+    Reflect.defineMetadata(database.refName, DatabaseModel, DatabaseModelStorage.prototype);
+    return new DatabaseModel();
+  };
+
+  // pkgs/@akanjs/server/src/module.ts
+  var import_bull2 = __require("@nestjs/bull");
+  var import_common34 = __require("@nestjs/common");
+  var import_mongoose7 = __require("@nestjs/mongoose");
+
+  // pkgs/@akanjs/server/src/schema.ts
+  var import_mongoose6 = __require("mongoose");
+  var ScalarSchemaStorage = class {
+  };
+  var SchemaStorage = class {
+  };
+  var scalarMongoTypeMap = /* @__PURE__ */ new Map([
+    [ID, ObjectId],
+    [Int, Number],
+    [Float, Number],
+    [JSON2, import_mongoose6.Schema.Types.Mixed],
+    [Map, Map],
+    [String, String],
+    [Boolean, Boolean],
+    [Date, Date]
+  ]);
+  var applyMongoProp = (schemaProps, fieldMeta) => {
+    if (["id", "createdAt", "updatedAt"].includes(fieldMeta.key) || fieldMeta.fieldType === "resolve")
+      return;
+    const type = fieldMeta.isClass ? fieldMeta.isScalar ? createSchema(fieldMeta.modelRef) : ObjectId : scalarMongoTypeMap.get(fieldMeta.modelRef) ?? fieldMeta.modelRef;
+    let prop = {};
+    if (fieldMeta.optArrDepth) {
+      prop.type = type;
+      prop.required = true;
+      if (fieldMeta.isClass && !fieldMeta.refPath)
+        prop.ref = getClassMeta(fieldMeta.modelRef).refName;
+      if (fieldMeta.refPath)
+        prop.refPath = fieldMeta.refPath;
+      if (typeof fieldMeta.min === "number")
+        prop.min = fieldMeta.min;
+      if (typeof fieldMeta.max === "number")
+        prop.max = fieldMeta.max;
+      if (fieldMeta.enum)
+        prop.enum = [...fieldMeta.enum.values, ...fieldMeta.nullable ? [null] : []];
+      if (typeof fieldMeta.minlength === "number")
+        prop.minlength = fieldMeta.minlength;
+      if (typeof fieldMeta.maxlength === "number")
+        prop.maxlength = fieldMeta.maxlength;
+      if (fieldMeta.validate) {
+        prop.validate = function(value) {
+          return fieldMeta.validate?.(fieldMeta.name === "Date" && !!value ? dayjs() : value, this) ?? true;
+        };
+      }
+      prop = { type: arraiedModel(prop, fieldMeta.optArrDepth), default: [], required: true };
+      if (fieldMeta.modelRef.prototype === Date.prototype) {
+        prop.get = (dates) => dates.map((date) => dayjs(date));
+        prop.set = (days) => days.map((day) => day.toDate());
+      }
+      if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === ID.prototype) {
+        prop.get = (ids) => ids.map((id) => id.toString());
+        prop.set = (ids) => ids.map((id) => new import_mongoose6.Types.ObjectId(id));
+      }
+    } else {
+      prop.type = arraiedModel(type, fieldMeta.arrDepth);
+      prop.required = !fieldMeta.nullable;
+      if (fieldMeta.isMap) {
+        prop.of = scalarMongoTypeMap.get(fieldMeta.of) ?? createSchema(fieldMeta.of);
+        if (!fieldMeta.default)
+          prop.default = /* @__PURE__ */ new Map();
+      }
+      if (fieldMeta.default !== null) {
+        if (typeof fieldMeta.default === "function")
+          prop.default = function() {
+            const def = fieldMeta.default(this);
+            return (0, import_dayjs2.isDayjs)(def) ? def.toDate() : def;
+          };
+        else
+          prop.default = (0, import_dayjs2.isDayjs)(fieldMeta.default) ? fieldMeta.default.toDate() : fieldMeta.default instanceof Enum ? [...fieldMeta.default.values] : fieldMeta.default;
+      }
+      if (typeof fieldMeta.immutable !== "undefined")
+        prop.immutable = fieldMeta.immutable;
+      if (fieldMeta.isClass && !fieldMeta.refPath)
+        prop.ref = getClassMeta(fieldMeta.modelRef).refName;
+      if (fieldMeta.refPath)
+        prop.refPath = fieldMeta.refPath;
+      if (typeof fieldMeta.min === "number")
+        prop.min = fieldMeta.min;
+      if (typeof fieldMeta.max === "number")
+        prop.max = fieldMeta.max;
+      if (fieldMeta.enum)
+        prop.enum = [...fieldMeta.enum.values, ...fieldMeta.nullable ? [null] : []];
+      if (typeof fieldMeta.select === "boolean")
+        prop.select = fieldMeta.select;
+      if (typeof fieldMeta.minlength === "number")
+        prop.minlength = fieldMeta.minlength;
+      if (typeof fieldMeta.maxlength === "number")
+        prop.maxlength = fieldMeta.maxlength;
+      if (fieldMeta.nullable) {
+        prop.get = (v) => v === void 0 ? void 0 : v;
+        prop.set = (v) => v === null ? void 0 : v;
+      }
+      if (fieldMeta.modelRef.prototype === Date.prototype) {
+        prop.get = (date) => date ? dayjs(date) : void 0;
+        prop.set = (day) => day ? dayjs(day).toDate() : void 0;
+      }
+      if (fieldMeta.isClass && !fieldMeta.isScalar || fieldMeta.modelRef.prototype === ID.prototype) {
+        prop.get = (id) => id ? id.toString() : void 0;
+        prop.set = (id) => id ? new import_mongoose6.Types.ObjectId(id) : void 0;
+      }
+      if (fieldMeta.isClass && fieldMeta.isScalar && fieldMeta.default === null && !fieldMeta.nullable) {
+        prop.default = makeDefault(fieldMeta.modelRef);
+      }
+      if (fieldMeta.validate) {
+        prop.validate = function(value) {
+          return fieldMeta.validate?.(fieldMeta.name === "Date" && !!value ? dayjs() : value, this) ?? true;
+        };
+      }
+    }
+    schemaProps[fieldMeta.key] = prop;
+  };
+  var createSchema = (modelRef) => {
+    const classMeta = getClassMeta(modelRef);
+    const schemaMeta = Reflect.getMetadata(classMeta.refName, ScalarSchemaStorage.prototype);
+    if (schemaMeta)
+      return schemaMeta;
+    const fieldMetas = getFieldMetas(modelRef);
+    const schemaProps = {};
+    fieldMetas.forEach((fieldMeta) => {
+      applyMongoProp(schemaProps, fieldMeta);
+    });
+    const schema = new import_mongoose6.Schema(schemaProps);
+    Reflect.defineMetadata(classMeta.refName, schema, ScalarSchemaStorage.prototype);
+    return schema;
+  };
+  var schemaOf = (modelRef, docRef, middleware) => {
+    const classMeta = getClassMeta(docRef);
+    const schemaMeta = Reflect.getMetadata(classMeta.refName, SchemaStorage.prototype);
+    if (schemaMeta)
+      return schemaMeta;
+    const fieldMetas = getFieldMetas(docRef);
+    const schemaProps = {
+      createdAt: {
+        type: Date,
+        get: (date) => date ? dayjs(date) : date,
+        set: (day) => day ? dayjs(day).toDate() : day
+      },
+      updatedAt: {
+        type: Date,
+        get: (date) => date ? dayjs(date) : date,
+        set: (day) => day ? dayjs(day).toDate() : day
+      }
+    };
+    fieldMetas.forEach((fieldMeta) => {
+      applyMongoProp(schemaProps, fieldMeta);
+    });
+    const schema = new import_mongoose6.Schema(schemaProps, getDefaultSchemaOptions());
+    schema.methods.refresh = async function() {
+      Object.assign(this, await this.constructor.findById(this._id));
+      return this;
+    };
+    Object.getOwnPropertyNames(docRef.prototype).forEach((name) => {
+      if (name === "constructor")
+        return;
+      schema.methods[name] = Object.getOwnPropertyDescriptor(docRef.prototype, name)?.value;
+    });
+    schema.pre("save", async function(next) {
+      const model = this.constructor;
+      if (this.isNew)
+        model.addSummary(["total", this.status]);
+      else if (!!this.removedAt && this.isModified("removedAt"))
+        model.subSummary(["total", this.status]);
+      next();
+    });
+    const onSchema = Object.getOwnPropertyDescriptor(middleware.prototype, "onSchema")?.value;
+    onSchema?.(schema);
+    schema.index({ removedAt: -1 });
+    Reflect.defineMetadata(classMeta.refName, schema, SchemaStorage.prototype);
+    return schema;
+  };
+  var addSchema = (modelRef, docRef, inputRef, middleware) => {
+    const originDocClassMeta = getClassMeta(docRef);
+    const originInputClassMeta = getClassMeta(inputRef);
+    const originDoc = getFullModelRef(originDocClassMeta.refName);
+    const originInput = getInputModelRef(originInputClassMeta.refName);
+    const classMeta = getClassMeta(docRef);
+    const modelSchema = Reflect.getMetadata(classMeta.refName, SchemaStorage.prototype);
+    if (!modelSchema)
+      throw new Error(`Schema of ${classMeta.refName} not found`);
+    const fieldMetas = getFieldMetas(docRef);
+    const schemaProps = {
+      createdAt: {
+        type: Date,
+        get: (date) => date ? dayjs(date) : date,
+        set: (day) => day ? dayjs(day).toDate() : day
+      },
+      updatedAt: {
+        type: Date,
+        get: (date) => date ? dayjs(date) : date,
+        set: (day) => day ? dayjs(day).toDate() : day
+      }
+    };
+    fieldMetas.forEach((fieldMeta) => {
+      applyMongoProp(schemaProps, fieldMeta);
+      applyNestField(originDoc, fieldMeta);
+    });
+    const inputFieldMetas = getFieldMetas(inputRef);
+    inputFieldMetas.forEach((fieldMeta) => {
+      applyNestField(originInput, fieldMeta, "input");
+    });
+    const schema = new import_mongoose6.Schema(schemaProps, getDefaultSchemaOptions());
+    modelSchema.add(schema);
+    Object.getOwnPropertyNames(docRef.prototype).forEach((name) => {
+      if (name === "constructor")
+        return;
+      modelSchema.methods[name] = Object.getOwnPropertyDescriptor(docRef.prototype, name)?.value;
+    });
+    const onSchema = Object.getOwnPropertyDescriptor(middleware.prototype, "onSchema")?.value;
+    onSchema?.(modelSchema);
+    return modelSchema;
+  };
+
+  // pkgs/@akanjs/server/src/websocket.ts
+  var import_common32 = __require("@nestjs/common");
+  var import_websockets = __require("@nestjs/websockets");
+  var import_operators2 = __require("rxjs/operators");
+  var internalArgMap3 = { Account: Account3, UserIp: UserIp2, Access: Access2, Self: Self2, Me: Me2, Ws: Ws2 };
+  var TransformInterceptor = class {
+    intercept(context, next) {
+      const [, gqlKey] = [context.getArgByIndex(1), context.getArgByIndex(3)];
+      return next.handle().pipe((0, import_operators2.map)((data) => ({ event: gqlKey, data })));
+    }
+  };
+  TransformInterceptor = __decorateClass([
+    (0, import_common32.Injectable)()
+  ], TransformInterceptor);
+  var makeRoomId = (gqlKey, argValues) => `${gqlKey}-${argValues.join("-")}`;
+  var getPubsubInterceptor = (argMetas) => {
+    let PubsubInterceptor = class {
+      async intercept(context, next) {
+        const [socket, { __subscribe__, ...body }, gqlKey] = [context.getArgByIndex(0), context.getArgByIndex(1), context.getArgByIndex(3)];
+        const roomId = makeRoomId(
+          gqlKey,
+          argMetas.map((argMeta) => body[argMeta.name])
+        );
+        if (__subscribe__)
+          await socket.join(roomId);
+        else
+          await socket.leave(roomId);
+        return next.handle().pipe((0, import_operators2.map)(() => ({ event: gqlKey, data: { roomId, __subscribe__ } })));
+      }
+    };
+    PubsubInterceptor = __decorateClass([
+      (0, import_common32.Injectable)()
+    ], PubsubInterceptor);
+    return PubsubInterceptor;
+  };
+  var websocketOf = (sigRef, allSrvs) => {
+    const sigMeta = getSigMeta(sigRef);
+    class WsGateway {
+      __sigRef__ = sigRef;
+    }
+    Object.keys(allSrvs).forEach((srv) => {
+      if (!isServiceEnabled(allSrvs[srv]))
+        return;
+      (0, import_common32.Inject)(allSrvs[srv])(WsGateway.prototype, lowerlize(srv));
+    });
+    const messageGqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Message");
+    for (const gqlMeta of messageGqlMetas) {
+      const descriptor = { ...Object.getOwnPropertyDescriptor(sigRef.prototype, gqlMeta.key) ?? {} };
+      Object.defineProperty(WsGateway.prototype, gqlMeta.key, descriptor);
+      const [argMetas, internalArgMetas] = getArgMetas(sigRef, gqlMeta.key);
+      argMetas.forEach((argMeta) => {
+        if (argMeta.type !== "Msg")
+          throw new Error(`Argument of Message should be Msg ${sigMeta.refName}-${gqlMeta.key}-${argMeta.name}`);
+        (0, import_websockets.MessageBody)(argMeta.name, ...getBodyPipes(argMeta))(WsGateway.prototype, gqlMeta.key, argMeta.idx);
+      });
+      internalArgMetas.forEach((internalArgMeta) => {
+        const internalDecorator = internalArgMap3[internalArgMeta.type];
+        internalDecorator(internalArgMeta.option ?? {})(WsGateway.prototype, gqlMeta.key, internalArgMeta.idx);
+      });
+      (0, import_common32.UseInterceptors)(TransformInterceptor)(WsGateway.prototype, gqlMeta.key, gqlMeta.descriptor);
+      (0, import_websockets.SubscribeMessage)(gqlMeta.key)(WsGateway.prototype, gqlMeta.key, descriptor);
+    }
+    const pubsubGqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Pubsub");
+    for (const gqlMeta of pubsubGqlMetas) {
+      const descriptor = { ...Object.getOwnPropertyDescriptor(sigRef.prototype, gqlMeta.key) ?? {} };
+      Object.defineProperty(WsGateway.prototype, gqlMeta.key, descriptor);
+      const [argMetas, internalArgMetas] = getArgMetas(sigRef, gqlMeta.key);
+      argMetas.forEach((argMeta) => {
+        if (argMeta.type !== "Room")
+          throw new Error(`Argument of Message should be Room ${sigMeta.refName}-${gqlMeta.key}-${argMeta.name}`);
+        (0, import_websockets.MessageBody)(argMeta.name, ...getBodyPipes(argMeta))(WsGateway.prototype, gqlMeta.key, argMeta.idx);
+      });
+      internalArgMetas.forEach((internalArgMeta) => {
+        const internalDecorator = internalArgMap3[internalArgMeta.type];
+        internalDecorator(internalArgMeta.option ?? {})(WsGateway.prototype, gqlMeta.key, internalArgMeta.idx);
+      });
+      (0, import_common32.UseInterceptors)(getPubsubInterceptor(argMetas))(WsGateway.prototype, gqlMeta.key, gqlMeta.descriptor);
+      (0, import_websockets.SubscribeMessage)(gqlMeta.key)(WsGateway.prototype, gqlMeta.key, descriptor);
+    }
+    (0, import_websockets.WebSocketGateway)({ cors: { origin: "*" }, transports: ["websocket"] })(WsGateway);
+    return WsGateway;
+  };
+  var websocketServerOf = (sigRef) => {
+    const pubsubGqlMetas = getGqlMetas(sigRef).filter((gqlMeta) => gqlMeta.type === "Pubsub");
+    let Websocket = class {
+      server;
+    };
+    __decorateClass([
+      (0, import_websockets.WebSocketServer)()
+    ], Websocket.prototype, "server", 2);
+    Websocket = __decorateClass([
+      (0, import_common32.Injectable)(),
+      (0, import_websockets.WebSocketGateway)({ cors: { origin: "*" }, transports: ["websocket"] })
+    ], Websocket);
+    for (const gqlMeta of pubsubGqlMetas) {
+      const [argMetas] = getArgMetas(sigRef, gqlMeta.key);
+      Websocket.prototype[gqlMeta.key] = function(...args) {
+        const roomId = makeRoomId(
+          gqlMeta.key,
+          argMetas.map((argMeta) => args[argMeta.idx])
+        );
+        this.server.to(roomId).emit(roomId, args.at(-1));
+      };
+    }
+    return Websocket;
+  };
+
+  // pkgs/@akanjs/server/src/module.ts
+  var hasWebsocket = (signal) => getGqlMetas(signal).some((gqlMeta) => ["Message", "Pubsub"].includes(gqlMeta.type));
+  var hasProcessor = (signal) => getGqlMetas(signal).some((gqlMeta) => gqlMeta.type === "Process");
+  var filterSrvs = (srvs) => Object.fromEntries(Object.entries(srvs).filter(([_, srv]) => !!srv));
+  var databaseModuleOf = ({
+    constant,
+    database,
+    signal,
+    service,
+    uses = {},
+    useAsyncs = {},
+    providers = [],
+    extended
+  }, allSrvs) => {
+    if (!isServiceEnabled(service))
+      return null;
+    const [modelName, className] = [lowerlize(constant.refName), capitalize(constant.refName)];
+    const mongoToken = (0, import_mongoose7.getModelToken)(className);
+    let DatabaseModule = class {
+    };
+    DatabaseModule = __decorateClass([
+      (0, import_common34.Global)(),
+      (0, import_common34.Module)({
+        imports: [
+          import_mongoose7.MongooseModule.forFeature([
+            {
+              name: className,
+              schema: extended ? addSchema(database.Model, database.Doc, database.Input, database.Middleware) : schemaOf(database.Model, database.Doc, database.Middleware)
+            }
+          ]),
+          ...hasProcessor(signal) ? [
+            import_bull2.BullModule.registerQueue({
+              name: modelName,
+              defaultJobOptions: { removeOnComplete: true, removeOnFail: true }
+            })
+          ] : []
+        ],
+        providers: [
+          serviceOf(service),
+          resolverOf(signal, filterSrvs(allSrvs)),
+          ...hasProcessor(signal) ? [
+            processorOf(signal, filterSrvs(allSrvs)),
+            { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [(0, import_bull2.getQueueToken)(modelName)] }
+          ] : [],
+          ...hasWebsocket(signal) ? [websocketOf(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: websocketServerOf(signal) }] : [],
+          ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
+          ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+          {
+            provide: `${modelName}Model`,
+            useFactory: (model, redis, meili) => {
+              return databaseModelOf(database, model, redis, meili);
+            },
+            inject: [mongoToken, "REDIS_CLIENT", "MEILI_CLIENT"]
+          },
+          ...providers
+        ],
+        controllers: [controllerOf(signal, filterSrvs(allSrvs))],
+        exports: [service]
+      })
+    ], DatabaseModule);
+    return DatabaseModule;
+  };
+  var serviceModuleOf = ({ signal, service, uses = {}, useAsyncs = {}, providers = [] }, allSrvs) => {
+    if (!isServiceEnabled(service))
+      return null;
+    const sigMeta = getSigMeta(signal);
+    const [modelName, className] = [lowerlize(sigMeta.refName), capitalize(sigMeta.refName)];
+    let ServiceModule = class {
+    };
+    ServiceModule = __decorateClass([
+      (0, import_common34.Global)(),
+      (0, import_common34.Module)({
+        imports: [
+          ...hasProcessor(signal) ? [
+            import_bull2.BullModule.registerQueue({
+              name: modelName,
+              defaultJobOptions: { removeOnComplete: true, removeOnFail: true }
+            })
+          ] : []
+        ],
+        providers: [
+          serviceOf(service),
+          resolverOf(signal, filterSrvs(allSrvs)),
+          ...hasWebsocket(signal) ? [websocketOf(signal, filterSrvs(allSrvs)), { provide: "Websocket", useClass: websocketServerOf(signal) }] : [],
+          ...hasProcessor(signal) ? [
+            processorOf(signal, filterSrvs(allSrvs)),
+            { provide: `${className}Queue`, useFactory: (queue) => queue, inject: [(0, import_bull2.getQueueToken)(modelName)] }
+          ] : [],
+          ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
+          ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+          ...providers
+        ],
+        controllers: [controllerOf(signal, filterSrvs(allSrvs))],
+        exports: [service]
+      })
+    ], ServiceModule);
+    return ServiceModule;
+  };
+  var scalarModuleOf = ({ signals, uses = {}, useAsyncs = {}, providers = [], enabled = true }, allSrvs) => {
+    if (!enabled)
+      return null;
+    let ScalarModule = class {
+    };
+    ScalarModule = __decorateClass([
+      (0, import_common34.Global)(),
+      (0, import_common34.Module)({
+        imports: [],
+        providers: [
+          ...signals.map((signal) => resolverOf(signal, filterSrvs(allSrvs))),
+          ...signals.filter(hasWebsocket).map((signal) => [
+            websocketOf(signal, filterSrvs(allSrvs)),
+            { provide: "Websocket", useClass: websocketServerOf(signal) }
+          ]).flat(),
+          ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
+          ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+          ...providers
+        ],
+        controllers: signals.map((signal) => controllerOf(signal, filterSrvs(allSrvs)))
+      })
+    ], ScalarModule);
+    return ScalarModule;
+  };
+  var scalarModulesOf = ({ constants }, allSrvs) => {
+    const signals = constants.filter((modelRef) => {
+      const childRefs = getChildClassRefs(modelRef);
+      return childRefs.some((childRef) => {
+        const classMeta = getClassMeta(childRef);
+        return ["full", "light"].includes(classMeta.type);
+      });
+    }).map((modelRef) => {
+      let ScalarSignal = class extends LogSignal({}) {
+      };
+      ScalarSignal = __decorateClass([
+        Signal(() => modelRef)
+      ], ScalarSignal);
+      return ScalarSignal;
+    });
+    let ScalarModule = class {
+    };
+    ScalarModule = __decorateClass([
+      (0, import_common34.Global)(),
+      (0, import_common34.Module)({
+        imports: [],
+        providers: [...signals.map((signal) => resolverOf(signal, filterSrvs(allSrvs)))]
+        // controllers: signals.map((signal) => controllerOf(signal, filterSrvs(allSrvs))),
+      })
+    ], ScalarModule);
+    return ScalarModule;
+  };
+  var batchModuleOf = ({
+    service,
+    uses = {},
+    useAsyncs = {},
+    providers = []
+  }) => {
+    if (!isServiceEnabled(service))
+      return null;
+    let BatchModule = class {
+    };
+    BatchModule = __decorateClass([
+      (0, import_common34.Global)(),
+      (0, import_common34.Module)({
+        imports: [],
+        providers: [
+          serviceOf(service),
+          ...Object.entries(uses).map(([key, useValue]) => ({ provide: capitalize(key), useValue })),
+          ...Object.entries(useAsyncs).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+          ...providers
+        ],
+        exports: [service]
+      })
+    ], BatchModule);
+    return BatchModule;
+  };
+  var useGlobals = ({ uses, useAsyncs, injects }) => {
+    let GlobalsModule = class {
+    };
+    GlobalsModule = __decorateClass([
+      (0, import_common34.Global)(),
+      (0, import_common34.Module)({
+        imports: [],
+        providers: [
+          ...Object.entries(uses ?? {}).map(([key, useValue]) => ({
+            provide: capitalize(key),
+            useValue
+          })),
+          ...Object.entries(useAsyncs ?? {}).map(([key, useFactory]) => ({ provide: capitalize(key), useFactory })),
+          ...Object.entries(injects ?? {}).map(([key, inject]) => ({ provide: capitalize(key), useClass: inject }))
+        ],
+        exports: [
+          ...Object.keys(uses ?? {}).map((key) => capitalize(key)),
+          ...Object.keys(useAsyncs ?? {}).map((key) => capitalize(key)),
+          ...Object.keys(injects ?? {}).map((key) => capitalize(key))
+        ]
+      })
+    ], GlobalsModule);
+    return GlobalsModule;
+  };
+
+  // pkgs/@akanjs/server/src/boot.ts
+  var import_apollo2 = __require("@nestjs/apollo");
+  var import_bull3 = __require("@nestjs/bull");
+  var import_common38 = __require("@nestjs/common");
+  var import_core2 = __require("@nestjs/core");
+  var import_graphql5 = __require("@nestjs/graphql");
+  var import_mongoose9 = __require("@nestjs/mongoose");
+  var import_schedule2 = __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_upload2 = __require("graphql-upload");
+  var import_meilisearch = __require("meilisearch");
+  var import_path = __require("path");
+  var import_redis2 = __require("redis");
+
+  // pkgs/@akanjs/server/src/searchDaemon.ts
+  var import_common36 = __require("@nestjs/common");
+  var import_mongoose8 = __require("@nestjs/mongoose");
+  var hasTextField2 = (modelRef) => {
+    const fieldMetas = getFieldMetas(modelRef);
+    return fieldMetas.some(
+      (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField2(fieldMeta.modelRef)
+    );
+  };
+  var getTextFieldKeys = (modelRef) => {
+    const allSearchFields = [];
+    const allFilterFields = [];
+    const fieldMetaMap = getFieldMetaMap(modelRef);
+    const fieldMetas = [...fieldMetaMap.values()];
+    const stringTextFields = fieldMetas.filter((fieldMeta) => !!fieldMeta.text).map((fieldMeta) => {
+      if (fieldMeta.text === "filter")
+        allFilterFields.push(fieldMeta.key);
+      else if (fieldMeta.text === "search")
+        allSearchFields.push(fieldMeta.key);
+      return fieldMeta.key;
+    });
+    const scalarTextFields = fieldMetas.filter(
+      (fieldMeta) => fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField2(fieldMeta.modelRef)
+    ).map((fieldMeta) => fieldMeta.key);
+    const deepFields = scalarTextFields.map((key) => {
+      const fieldMeta = fieldMetaMap.get(key);
+      if (!fieldMeta)
+        throw new Error(`No fieldMeta for ${key}`);
+      const { stringTextFields: stringTextFields2, allTextFields, allSearchFields: allSearchFields2, allFilterFields: allFilterFields2 } = getTextFieldKeys(
+        fieldMeta.modelRef
+      );
+      allFilterFields2.push(...allSearchFields2.map((field) => `${key}.${field}`));
+      allSearchFields2.push(...stringTextFields2.map((field) => `${key}.${field}`));
+      return [
+        ...stringTextFields2.map((field) => `${key}.${field}`),
+        ...allTextFields.map((field) => `${key}.${field}`)
+      ];
+    }).flat();
+    return {
+      stringTextFields,
+      scalarTextFields,
+      allTextFields: [...stringTextFields, ...deepFields],
+      allSearchFields,
+      allFilterFields
+    };
+  };
+  var makeTextFilter = (modelRef) => {
+    const fieldMetaMap = getFieldMetaMap(modelRef);
+    const { stringTextFields, scalarTextFields } = getTextFieldKeys(modelRef);
+    const filterData = (data, assignObj = {}) => {
+      if (Array.isArray(data))
+        return data.map((d) => filterData(d));
+      return Object.assign(
+        Object.fromEntries([
+          ...stringTextFields.map((key) => [key, data[key]]),
+          ...scalarTextFields.map((key) => {
+            const fieldMeta = fieldMetaMap.get(key);
+            if (!fieldMeta)
+              throw new Error(`No fieldMeta for ${key}`);
+            const filterFunc = makeTextFilter(fieldMeta.modelRef);
+            return [key, filterFunc(data[key])];
+          })
+        ]),
+        assignObj
+      );
+    };
+    return filterData;
+  };
+  var getSortableAttributes = (refName) => {
+    const cnst = getCnstMeta(refName);
+    const sortMap = getFilterSortMap(cnst.Filter);
+    const sortFields = Object.values(sortMap).filter((val) => typeof val === "object").map((sort) => Object.keys(sort)).flat();
+    return [...new Set(sortFields)];
+  };
+  var SearchDaemon = class {
+    constructor(connection, meili) {
+      this.connection = connection;
+      this.meili = meili;
+    }
+    logger = new Logger("SearchDaemon");
+    async onModuleInit() {
+      const databaseModelNames = getAllDatabaseModelNames();
+      const indexes = (await this.meili.getIndexes({ limit: 1e3 })).results;
+      const indexMap = new Map(indexes.map((index) => [index.uid, index]));
+      const indexCreationNames = [];
+      const indexUpdateNames = [];
+      for (const modelName of databaseModelNames) {
+        const indexName = lowerlize(modelName);
+        const modelRef = getFullModelRef(modelName);
+        if (!hasTextField2(modelRef))
+          continue;
+        const index = indexMap.get(indexName);
+        if (!index)
+          indexCreationNames.push(indexName);
+        else if (index.primaryKey !== "id")
+          indexUpdateNames.push(indexName);
+      }
+      for (const indexName of indexCreationNames)
+        await this.meili.createIndex(indexName, { primaryKey: "id" });
+      for (const indexName of indexUpdateNames)
+        await this.meili.updateIndex(indexName, { primaryKey: "id" });
+      for (const modelName of databaseModelNames) {
+        const indexName = lowerlize(modelName);
+        const model = this.connection.models[modelName];
+        const modelRef = getFullModelRef(modelName);
+        if (!hasTextField2(modelRef))
+          continue;
+        const searchIndex = this.meili.index(indexName);
+        const { stringTextFields, scalarTextFields, allSearchFields, allFilterFields } = getTextFieldKeys(modelRef);
+        const settings = await searchIndex.getSettings();
+        const allSearchFieldSet = new Set(allSearchFields);
+        const allFilterFieldSet = new Set(allFilterFields);
+        const searchFieldSet = new Set(settings.searchableAttributes);
+        const filterFieldSet = new Set(settings.filterableAttributes);
+        const needUpdateSetting = !allSearchFields.every((field) => searchFieldSet.has(field)) || !allFilterFields.every((field) => filterFieldSet.has(field)) || !settings.searchableAttributes?.every((field) => allSearchFieldSet.has(field)) || !settings.filterableAttributes?.every((field) => allFilterFieldSet.has(field));
+        if (needUpdateSetting) {
+          this.logger.info(`update index settings (${modelName})`);
+          await searchIndex.updateSettings({
+            searchableAttributes: allSearchFields,
+            filterableAttributes: allFilterFields,
+            sortableAttributes: getSortableAttributes(indexName)
+          });
+        }
+        const stringTextFieldSet = new Set(stringTextFields);
+        const scalarTextFieldSet = new Set(scalarTextFields);
+        const filterText = makeTextFilter(modelRef);
+        model.watch().on("change", async (data) => {
+          try {
+            const id = data.documentKey._id.toString();
+            if (data.operationType === "delete") {
+              this.logger.trace(`delete text doc (${modelName}): ${id}`);
+              return await searchIndex.deleteDocument(id);
+            } else if (data.operationType === "insert") {
+              this.logger.trace(`insert text doc (${modelName}): ${data.documentKey._id}`);
+              if (!data.fullDocument)
+                throw new Error("No fullDocument");
+              const textFilteredData = filterText(data.fullDocument);
+              return await searchIndex.addDocuments([textFilteredData]);
+            } else if (data.operationType === "update") {
+              const updatedFields = data.updateDescription?.updatedFields ?? {};
+              const isRemoved = !!updatedFields.removedAt;
+              if (isRemoved) {
+                this.logger.trace(`remove text doc (${modelName}): ${id}`);
+                return await searchIndex.deleteDocument(id);
+              }
+              this.logger.trace(`update text doc (${modelName}): ${data.documentKey._id}`);
+              const updatedFieldKeys = Object.keys(updatedFields);
+              const removedFieldKeys = data.updateDescription?.removedFields ?? [];
+              const isScalarTextFieldUpdated = [...updatedFieldKeys, ...removedFieldKeys].map((key) => key.split(".")[0]).some((key) => scalarTextFieldSet.has(key));
+              if (isScalarTextFieldUpdated) {
+                const doc = await model.findById(data.documentKey._id);
+                if (!doc)
+                  this.logger.error(`No doc for ${data.documentKey._id}`);
+                const textFilteredData = filterText(doc, { id });
+                return await searchIndex.updateDocuments([textFilteredData]);
+              } else {
+                const updateKeys = updatedFieldKeys.filter((key) => stringTextFieldSet.has(key));
+                const removeKeys = removedFieldKeys.filter((key) => stringTextFieldSet.has(key));
+                if (!updateKeys.length && !removeKeys.length)
+                  return;
+                const textFilteredData = Object.fromEntries([
+                  ["id", id],
+                  ...updateKeys.map((key) => [key, updatedFields[key]]),
+                  ...removeKeys.map((key) => [key, null])
+                ]);
+                return await searchIndex.updateDocuments([textFilteredData]);
+              }
+            }
+          } catch (e) {
+            this.logger.error(e);
+          }
+        });
+      }
+    }
+  };
+  SearchDaemon = __decorateClass([
+    (0, import_common36.Injectable)(),
+    __decorateParam(0, (0, import_mongoose8.InjectConnection)()),
+    __decorateParam(1, (0, import_common36.Inject)("MEILI_CLIENT"))
+  ], SearchDaemon);
+  var SearchDaemonModule = class {
+  };
+  SearchDaemonModule = __decorateClass([
+    (0, import_common36.Global)(),
+    (0, import_common36.Module)({
+      providers: [SearchDaemon]
+    })
+  ], SearchDaemonModule);
+
+  // pkgs/@akanjs/server/src/boot.ts
+  var createNestApp = async ({ registerModules, serverMode = "federation", env, log = true }) => {
+    const backendLogger = new Logger("Backend");
+    if (log)
+      backendLogger.rawLog(logo);
+    const jwtSecret = generateJwtSecret(env.appName, env.environment);
+    const [redisUri, mongoUri, meiliUri] = await Promise.all([
+      env.redisUri ?? generateRedisUri({ ...env, ...env.redis?.sshOptions ? { sshOptions: env.redis.sshOptions } : {} }),
+      env.mongoUri ?? generateMongoUri({
+        ...env,
+        ...env.mongo.username ? { username: env.mongo.username } : {},
+        password: env.mongo.password,
+        ...env.mongo.sshOptions ? { sshOptions: env.mongo.sshOptions } : {}
+      }),
+      env.meiliUri ?? generateMeiliUri(env)
+    ]);
+    if (env.operationMode === "local") {
+      backendLogger.verbose(`connect to redis: ${redisUri}`);
+      backendLogger.verbose(`connect to mongo: ${mongoUri}`);
+      backendLogger.verbose(`connect to meili: ${meiliUri}`);
+    }
+    initMongoDB({ logging: baseEnv.environment !== "main", sendReport: false });
+    import_events.default.EventEmitter.defaultMaxListeners = 1e3;
+    let AuthMiddleWare = class {
+      use(req, res, next) {
+        const requestHeader = req;
+        requestHeader.account = verifyToken(
+          jwtSecret,
+          requestHeader.headers.authorization ?? (requestHeader.cookies?.jwt ? `Bearer ${requestHeader.cookies.jwt}` : void 0)
+        );
+        requestHeader.userAgent = requestHeader["user-agent"];
+        next();
+      }
+    };
+    AuthMiddleWare = __decorateClass([
+      (0, import_common38.Injectable)()
+    ], AuthMiddleWare);
+    const redisClient = await (0, import_redis2.createClient)({ url: redisUri }).connect();
+    let SubDatabaseModule = class {
+    };
+    SubDatabaseModule = __decorateClass([
+      (0, import_common38.Global)(),
+      (0, import_common38.Module)({
+        providers: [
+          { provide: "REDIS_CLIENT", useValue: redisClient },
+          {
+            provide: "MEILI_CLIENT",
+            useFactory: () => new import_meilisearch.MeiliSearch({ host: meiliUri, apiKey: generateMeiliKey(env) })
+          }
+        ],
+        exports: ["REDIS_CLIENT", "MEILI_CLIENT"]
+      })
+    ], SubDatabaseModule);
+    let AppModule = class {
+      configure(consumer) {
+        consumer.apply(AuthMiddleWare).forRoutes({ path: "*", method: import_common38.RequestMethod.ALL });
+      }
+    };
+    AppModule = __decorateClass([
+      (0, import_common38.Module)({
+        imports: [
+          import_bull3.BullModule.forRoot({ redis: redisUri }),
+          import_schedule2.ScheduleModule.forRoot(),
+          import_graphql5.GraphQLModule.forRootAsync({
+            imports: [],
+            useFactory: () => ({
+              useGlobalPrefix: true,
+              autoSchemaFile: (0, import_path.join)(process.cwd(), "src/schema.gql"),
+              sortSchema: true,
+              playground: baseEnv.environment !== "main",
+              introspection: baseEnv.environment !== "main",
+              uploads: false,
+              debug: false
+            }),
+            driver: import_apollo2.ApolloDriver
+          }),
+          import_mongoose9.MongooseModule.forRootAsync({
+            useFactory: () => ({ uri: mongoUri, autoIndex: baseEnv.environment !== "main" })
+          }),
+          SubDatabaseModule,
+          useGlobals({
+            injects: { SearchClient, DatabaseClient, CacheClient }
+          }),
+          ...["batch", "all"].includes(serverMode) && baseEnv.operationMode !== "edge" ? [SearchDaemonModule] : [],
+          ...registerModules(env).filter((m) => !!m)
+        ],
+        providers: [DateScalar]
+      })
+    ], AppModule);
+    const app = await import_core2.NestFactory.create(AppModule, { logger: backendLogger });
+    const redisIoAdapter = new RedisIoAdapter(app, { jwtSecret });
+    await redisIoAdapter.connectToRedis(redisUri);
+    app.enableShutdownHooks();
+    const udp = import_dgram.default.createSocket("udp4");
+    client.setUdp(udp);
+    if (["federation", "all"].includes(serverMode)) {
+      app.setGlobalPrefix(process.env.GLOBAL_PREFIX ?? "/backend");
+      app.enableCors({
+        origin: "*",
+        methods: "GET,HEAD,PUT,PATCH,POST,DELETE",
+        preflightContinue: false,
+        optionsSuccessStatus: 204,
+        allowedHeaders: "DNT,Keep-Alive,User-Agent,X-Requested-With,If-Modified-Since,Cache-Control,Content-Type,Range,Authorization,apollo-require-preflight"
+      });
+      if (env.operationMode !== "local" && process.env.USE_REDIS_IO_ADAPTER !== "false")
+        app.useWebSocketAdapter(redisIoAdapter);
+      app.use((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_upload2.graphqlUploadExpress)());
+      app.use((0, import_cookie_parser.default)());
+      app.useGlobalInterceptors(new LoggingInterceptor());
+      app.useGlobalInterceptors(new TimeoutInterceptor());
+      app.useGlobalInterceptors(new CacheInterceptor(redisClient));
+      app.useGlobalFilters(new AllExceptionsFilter());
+      await app.listen(process.env.PORT ?? env.port ?? 8080);
+      backendLogger.log(`\u{1F680} Server is running on: ${await app.getUrl()}`);
+    } else {
+      await app.init();
+      backendLogger.log(`\u{1F680} Batch Server is running`);
+    }
+    if (module.hot) {
+      module.hot.accept();
+      module.hot.dispose(() => {
+        void app.close();
+      });
+    }
+    return {
+      nestApp: app,
+      close: async () => {
+        await app.close();
+        await redisIoAdapter.destroy();
+        await redisClient.quit();
+      }
+    };
+  };
+})();
+//! Nextjs는 환경변수를 build time에 그냥 하드코딩으로 값을 넣어버림. operationMode같은것들 잘 동작안할 수 있음. 추후 수정 필요.
+//! 임시 적용 테스트
+//! 잘되는지 확인 필요