@akanjs/server 0.0.4

package/src/serviceDecorators.js

@@ -0,0 +1,491 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __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 serviceDecorators_exports = {};
+__export(serviceDecorators_exports, {
+  Cache: () => Cache,
+  Cron: () => Cron,
+  Db: () => Db,
+  DbService: () => DbService,
+  ExtendedSettingService: () => ExtendedSettingService,
+  ExtendedSummaryService: () => ExtendedSummaryService,
+  ExtendedUserService: () => ExtendedUserService,
+  Interval: () => Interval,
+  LogService: () => LogService,
+  MixSrvs: () => MixSrvs,
+  Queue: () => Queue,
+  Service: () => Service,
+  ServiceStorage: () => ServiceStorage,
+  Srv: () => Srv,
+  Transaction: () => Transaction,
+  Try: () => Try,
+  Use: () => Use,
+  Websocket: () => Websocket,
+  serviceOf: () => serviceOf
+});
+module.exports = __toCommonJS(serviceDecorators_exports);
+var import_reflect_metadata = require("reflect-metadata");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_common2 = require("@nestjs/common");
+var import_mongoose = require("@nestjs/mongoose");
+var import_schedule = require("@nestjs/schedule");
+class ServiceStorage {
+}
+const getServiceRefs = (refName) => {
+  return Reflect.getMetadata(refName, ServiceStorage.prototype) ?? [];
+};
+const setServiceRefs = (refName, services) => {
+  Reflect.defineMetadata(refName, services, ServiceStorage.prototype);
+};
+const isServiceDefined = (srvRef) => {
+  return Reflect.getMetadata("service", srvRef.prototype) ?? false;
+};
+const setServiceDefined = (srvRef) => {
+  Reflect.defineMetadata("service", true, srvRef.prototype);
+};
+const getServiceInjectMetaMapOnPrototype = (prototype) => {
+  return Reflect.getMetadata("inject", prototype) ?? /* @__PURE__ */ new Map();
+};
+const setServiceInjectMetaMapOnPrototype = (prototype, injectMetaMap) => {
+  Reflect.defineMetadata("inject", injectMetaMap, prototype);
+};
+function Service(name) {
+  return function(target) {
+    const services = getServiceRefs(name);
+    setServiceRefs(name, [...services, target]);
+    Reflect.defineMetadata(name, [...services, target], ServiceStorage.prototype);
+    return target;
+  };
+}
+function Srv(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Srv", key, name: name ?? (0, import_common.capitalize)(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Use(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Use", key, name: name ?? (0, import_common.capitalize)(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Queue(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Queue", key, name: name ?? (0, import_common.capitalize)(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Websocket(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Websocket", key, name: name ?? (0, import_common.capitalize)(key) });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+function Db(name) {
+  return function(prototype, key) {
+    const metadataMap = getServiceInjectMetaMapOnPrototype(prototype);
+    metadataMap.set(key, { type: "Db", key, name });
+    setServiceInjectMetaMapOnPrototype(prototype, metadataMap);
+  };
+}
+const serviceOf = (srvRef) => {
+  if (isServiceDefined(srvRef))
+    return srvRef;
+  const injectMetaMap = getServiceInjectMetaMapOnPrototype(srvRef.prototype);
+  for (const injectMeta of [...injectMetaMap.values()]) {
+    if (injectMeta.type === "Db")
+      (0, import_mongoose.InjectModel)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+    else if (injectMeta.type === "Use")
+      (0, import_common2.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_common2.Inject)(services.at(-1))(srvRef.prototype, injectMeta.key);
+    } else if (injectMeta.type === "Queue")
+      (0, import_common2.Inject)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+    else
+      (0, import_common2.Inject)(injectMeta.name)(srvRef.prototype, injectMeta.key);
+  }
+  (0, import_mongoose.InjectConnection)()(srvRef.prototype, "connection");
+  (0, import_common2.Injectable)()(srvRef);
+  setServiceDefined(srvRef);
+  return srvRef;
+};
+function MixSrvs(t1, t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20) {
+  class Mix extends t1 {
+  }
+  const injectMetadataMap = new Map(
+    [t2, t3, t4, t5, t6, t7, t8, t9, t10, t11, t12, t13, t14, t15, t16, t17, t18, t19, t20].filter((t) => !!t).reduce((acc, srvRef) => {
+      const injectMetadataMap2 = getServiceInjectMetaMapOnPrototype(srvRef);
+      (0, import_common.applyMixins)(Mix, [srvRef]);
+      return [...acc, ...injectMetadataMap2];
+    }, [])
+  );
+  Reflect.defineMetadata("service", false, Mix.prototype);
+  Reflect.defineMetadata("inject", injectMetadataMap, Mix.prototype);
+  return Mix;
+}
+const LogService = (name) => {
+  class LogService2 {
+    logger = new import_common.Logger(name);
+  }
+  return LogService2;
+};
+const DbService = (database, sigRef) => {
+  const [modelName, className] = [database.refName, (0, import_common.capitalize)(database.refName)];
+  class DbService2 {
+    logger = new import_common.Logger(`${modelName}Service`);
+    __databaseModel;
+    async __list(query, queryOption) {
+      return await this.__databaseModel.__list(query, queryOption);
+    }
+    async __listIds(query, queryOption) {
+      return await this.__databaseModel.__listIds(query, queryOption);
+    }
+    async __find(query, queryOption) {
+      return await this.__databaseModel.__find(query, queryOption);
+    }
+    async __findId(query, queryOption) {
+      return await this.__databaseModel.__findId(query, queryOption);
+    }
+    async __pick(query, queryOption) {
+      return await this.__databaseModel.__pick(query, queryOption);
+    }
+    async __pickId(query, queryOption) {
+      return await this.__databaseModel.__pickId(query, queryOption);
+    }
+    async __exists(query) {
+      return await this.__databaseModel.__exists(query);
+    }
+    async __count(query) {
+      return await this.__databaseModel.__count(query);
+    }
+    async __insight(query) {
+      return await this.__databaseModel.__insight(query);
+    }
+    async __search(searchText, queryOption) {
+      return await this.__databaseModel[`search${className}`](searchText, queryOption);
+    }
+    async __searchDocs(searchText, queryOption) {
+      return await this.__databaseModel[`searchDocs${className}`](searchText, queryOption);
+    }
+    async __searchCount(searchText) {
+      return await this.__databaseModel[`searchCount${className}`](searchText);
+    }
+    async _preCreate(data) {
+      return data;
+    }
+    async _postCreate(doc) {
+      return doc;
+    }
+    async _preUpdate(id, data) {
+      return data;
+    }
+    async _postUpdate(doc) {
+      return doc;
+    }
+    async _preRemove(id) {
+      return;
+    }
+    async _postRemove(doc) {
+      return doc;
+    }
+    async [`get${className}`](id) {
+      return await this.__databaseModel[`get${className}`](id);
+    }
+    async [`load${className}`](id) {
+      return await this.__databaseModel[`load${className}`](id);
+    }
+    async [`load${className}Many`](ids) {
+      return await this.__databaseModel[`load${className}Many`](ids);
+    }
+    async [`create${className}`](data) {
+      const input = await this._preCreate(data);
+      const doc = await this.__databaseModel[`create${className}`](input);
+      return await this._postCreate(doc);
+    }
+    async [`update${className}`](id, data) {
+      const input = await this._preUpdate(id, data);
+      const doc = await this.__databaseModel[`update${className}`](id, input);
+      return await this._postUpdate(doc);
+    }
+    async [`remove${className}`](id) {
+      await this._preRemove(id);
+      const doc = await this.__databaseModel[`remove${className}`](id);
+      return await this._postRemove(doc);
+    }
+    async [`search${className}`](query, queryOption) {
+      return await this.__databaseModel[`search${className}`](query, queryOption);
+    }
+    async [`searchDocs${className}`](query, queryOption) {
+      return await this.__databaseModel[`searchDocs${className}`](query, queryOption);
+    }
+    async [`searchCount${className}`](query) {
+      return await this.__databaseModel[`searchCount${className}`](query);
+    }
+  }
+  __decorateClass([
+    Use(`${modelName}Model`)
+  ], DbService2.prototype, "__databaseModel", 2);
+  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 = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
+    const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
+    const queryOption = hasQueryOption ? lastArg : {};
+    return { query, queryOption };
+  };
+  const filterKeyMetaMap = (0, import_constant.getFilterKeyMetaMapOnPrototype)(database.Filter.prototype);
+  const queryKeys = [...filterKeyMetaMap.keys()];
+  queryKeys.forEach((queryKey) => {
+    const queryFn = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
+    DbService2.prototype[`list${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__list(query, queryOption);
+    };
+    DbService2.prototype[`listIds${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__listIds(query, queryOption);
+    };
+    DbService2.prototype[`find${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__find(query, queryOption);
+    };
+    DbService2.prototype[`findId${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__findId(query, queryOption);
+    };
+    DbService2.prototype[`pick${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__pick(query, queryOption);
+    };
+    DbService2.prototype[`pickId${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const { query, queryOption } = getQueryDataFromKey(queryKey, args);
+      return this.__pickId(query, queryOption);
+    };
+    DbService2.prototype[`exists${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__exists(query);
+    };
+    DbService2.prototype[`count${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__count(query);
+    };
+    DbService2.prototype[`insight${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__insight(query);
+    };
+  });
+  Use(`${modelName}Model`)(DbService2.prototype, `${modelName}Model`);
+  return DbService2;
+};
+const ExtendedUserService = (database, srvRef, sigRef) => {
+  const filterKeyMetaMap = (0, import_constant.getFilterKeyMetaMapOnPrototype)(database.Filter.prototype);
+  const queryKeys = [...filterKeyMetaMap.keys()];
+  queryKeys.forEach((queryKey) => {
+    const queryFn = (0, import_constant.getFilterQuery)(database.Filter, queryKey);
+    srvRef.prototype[`list${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const queryOption = args.at(-1);
+      const hasQueryOption = typeof queryOption === "object" && (typeof queryOption.select === "object" || typeof queryOption.skip === "number" || typeof queryOption.limit === "number" || typeof queryOption.sort === "string");
+      const query = queryFn(...hasQueryOption ? args.slice(0, -1) : args);
+      return this.__list(query, queryOption);
+    };
+    srvRef.prototype[`insight${(0, import_common.capitalize)(queryKey)}`] = async function(...args) {
+      const query = queryFn(...args);
+      return this.__insight(query);
+    };
+  });
+  return srvRef;
+};
+const ExtendedSummaryService = (database, srvRef, sigRef) => {
+  return srvRef;
+};
+const ExtendedSettingService = (database, srvRef, sigRef) => {
+  return srvRef;
+};
+const Try = () => {
+  return function(target, key, descriptor) {
+    const originMethod = descriptor.value;
+    descriptor.value = async function(...args) {
+      try {
+        const result = await originMethod.apply(this, args);
+        return result;
+      } catch (e) {
+        this.logger?.warn(`${key} action error return: ${e}`);
+      }
+    };
+  };
+};
+const Cron = (cronTime, { lock = true, serverMode, enabled = true } = {}) => {
+  return function(target, key, descriptor) {
+    const originMethod = descriptor.value;
+    let isRunning = false;
+    descriptor.value = async function(...args) {
+      if (lock && isRunning)
+        return this.logger?.warn(`Cronjob-${key} is already running, skipped`);
+      try {
+        isRunning = true;
+        this.logger?.verbose(`Cron Job-${key} started`);
+        const res = await originMethod.apply(this, args);
+        this.logger?.verbose(`Cron Job-${key} finished`);
+        isRunning = false;
+        return res;
+      } catch (e) {
+        this.logger?.error(`Cron Job-${key} error return: ${e}`);
+        isRunning = false;
+      }
+    };
+    if (!enabled)
+      return;
+    if (!serverMode || process.env.SERVER_MODE === "all" || serverMode === process.env.SERVER_MODE)
+      (0, import_schedule.Cron)(cronTime)(target, key, descriptor);
+  };
+};
+const getIntervalMetaMap = (prototype) => {
+  return Reflect.getMetadata("serviceInterval", prototype) ?? /* @__PURE__ */ new Map();
+};
+const setIntervalMetaMap = (prototype, intervalMetaMap) => {
+  Reflect.defineMetadata("serviceInterval", intervalMetaMap, prototype);
+};
+const Interval = (ms, { lock = true, serverMode, enabled = true } = {}) => {
+  return function(target, key, descriptor) {
+    const intervalMetaMap = getIntervalMetaMap(target);
+    if (intervalMetaMap.has(key))
+      return descriptor;
+    intervalMetaMap.set(key, descriptor.value);
+    setIntervalMetaMap(target, intervalMetaMap);
+    const originMethod = descriptor.value;
+    let isRunning = false;
+    descriptor.value = async function(...args) {
+      if (lock && isRunning)
+        return this.logger?.warn(`Cronjob-${key} is already running, skipped`);
+      try {
+        isRunning = true;
+        this.logger?.verbose(`Interval Job-${key} started`);
+        const res = await originMethod.apply(this, args);
+        this.logger?.verbose(`Interval Job-${key} finished`);
+        isRunning = false;
+        return res;
+      } catch (e) {
+        this.logger?.error(`Cronjob-${key} error return: ${e}`);
+        isRunning = false;
+      }
+    };
+    if (!enabled)
+      return;
+    if (!serverMode || process.env.SERVER_MODE === "all" || serverMode === process.env.SERVER_MODE)
+      (0, import_schedule.Interval)(ms)(target, key, descriptor);
+  };
+};
+const 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;
+  };
+};
+const Cache = (timeout = 1e3, getCacheKey) => {
+  return function(target, key, descriptor) {
+    const originMethod = descriptor.value;
+    const cacheMap = /* @__PURE__ */ new Map();
+    const timerMap = /* @__PURE__ */ new Map();
+    descriptor.value = async function(...args) {
+      const classType = this.__model ? "doc" : this.__databaseModel ? "service" : "class";
+      const model = this.__model ?? this.__databaseModel?.__model;
+      const cache = this.__cache ?? this.__databaseModel?.__cache;
+      const getCacheKeyFn = getCacheKey ?? JSON.stringify;
+      const cacheKey = `${classType}:${model.modelName}:${key}:${getCacheKeyFn(...args)}`;
+      const getCache = async (cacheKey2) => {
+        if (classType === "class")
+          return cacheMap.get(cacheKey2);
+        const cached = await cache.get(cacheKey2);
+        if (cached)
+          return JSON.parse(cached);
+        return null;
+      };
+      const setCache = async (cacheKey2, value) => {
+        if (classType === "class") {
+          const existingTimer = timerMap.get(cacheKey2);
+          if (existingTimer)
+            clearTimeout(existingTimer);
+          cacheMap.set(cacheKey2, value);
+          const timer = setTimeout(() => {
+            cacheMap.delete(cacheKey2);
+            timerMap.delete(cacheKey2);
+          }, timeout);
+          timerMap.set(cacheKey2, timer);
+        } else
+          await cache.set(cacheKey2, JSON.stringify(value), { PX: timeout });
+      };
+      const cachedData = await getCache(cacheKey);
+      if (cachedData) {
+        this.logger?.trace(`${model.modelName} cache hit: ${cacheKey}`);
+        return cachedData;
+      }
+      const result = await originMethod.apply(this, args);
+      await setCache(cacheKey, result);
+      this.logger?.trace(`${model.modelName} cache set: ${cacheKey}`);
+      return result;
+    };
+  };
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Cache,
+  Cron,
+  Db,
+  DbService,
+  ExtendedSettingService,
+  ExtendedSummaryService,
+  ExtendedUserService,
+  Interval,
+  LogService,
+  MixSrvs,
+  Queue,
+  Service,
+  ServiceStorage,
+  Srv,
+  Transaction,
+  Try,
+  Use,
+  Websocket,
+  serviceOf
+});

package/src/types.d.ts

@@ -0,0 +1,14 @@
+import type { ReadStream } from "fs";
+import type { Readable } from "stream";
+export interface FileStream {
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    createReadStream(): ReadStream | Readable;
+}
+export interface LocalFile {
+    filename: string;
+    mimetype: string;
+    encoding: string;
+    localPath: string;
+}

package/src/types.js

@@ -0,0 +1,15 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var types_exports = {};
+module.exports = __toCommonJS(types_exports);

package/src/websocket.d.ts

@@ -0,0 +1,17 @@
+import { Type } from "@akanjs/base";
+import type { Server } from "socket.io";
+export interface Response<T> {
+    data: T;
+}
+export declare const websocketOf: (sigRef: Type, allSrvs: {
+    [key: string]: Type;
+}) => {
+    new (): {
+        __sigRef__: Type;
+    };
+};
+export declare const websocketServerOf: (sigRef: Type) => {
+    new (): {
+        server: Server;
+    };
+};

package/src/websocket.js

@@ -0,0 +1,143 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __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 websocket_exports = {};
+__export(websocket_exports, {
+  websocketOf: () => websocketOf,
+  websocketServerOf: () => websocketServerOf
+});
+module.exports = __toCommonJS(websocket_exports);
+var import_common = require("@akanjs/common");
+var import_nest = require("@akanjs/nest");
+var import_signal = require("@akanjs/signal");
+var import_common2 = require("@nestjs/common");
+var import_websockets = require("@nestjs/websockets");
+var import_operators = require("rxjs/operators");
+const internalArgMap = { Account: import_nest.Account, UserIp: import_nest.UserIp, Access: import_nest.Access, Self: import_nest.Self, Me: import_nest.Me, Ws: import_nest.Ws };
+let TransformInterceptor = class {
+  intercept(context, next) {
+    const [, gqlKey] = [context.getArgByIndex(1), context.getArgByIndex(3)];
+    return next.handle().pipe((0, import_operators.map)((data) => ({ event: gqlKey, data })));
+  }
+};
+TransformInterceptor = __decorateClass([
+  (0, import_common2.Injectable)()
+], TransformInterceptor);
+const makeRoomId = (gqlKey, argValues) => `${gqlKey}-${argValues.join("-")}`;
+const 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_operators.map)(() => ({ event: gqlKey, data: { roomId, __subscribe__ } })));
+    }
+  };
+  PubsubInterceptor = __decorateClass([
+    (0, import_common2.Injectable)()
+  ], PubsubInterceptor);
+  return PubsubInterceptor;
+};
+const websocketOf = (sigRef, allSrvs) => {
+  const sigMeta = (0, import_signal.getSigMeta)(sigRef);
+  class WsGateway {
+    __sigRef__ = sigRef;
+  }
+  Object.keys(allSrvs).forEach((srv) => {
+    (0, import_common2.Inject)(allSrvs[srv])(WsGateway.prototype, (0, import_common.lowerlize)(srv));
+  });
+  const messageGqlMetas = (0, import_signal.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] = (0, import_signal.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, ...(0, import_nest.getBodyPipes)(argMeta))(WsGateway.prototype, gqlMeta.key, argMeta.idx);
+    });
+    internalArgMetas.forEach((internalArgMeta) => {
+      const internalDecorator = internalArgMap[internalArgMeta.type];
+      internalDecorator(internalArgMeta.option ?? {})(WsGateway.prototype, gqlMeta.key, internalArgMeta.idx);
+    });
+    (0, import_common2.UseInterceptors)(TransformInterceptor)(WsGateway.prototype, gqlMeta.key, gqlMeta.descriptor);
+    (0, import_websockets.SubscribeMessage)(gqlMeta.key)(WsGateway.prototype, gqlMeta.key, descriptor);
+  }
+  const pubsubGqlMetas = (0, import_signal.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] = (0, import_signal.getArgMetas)(sigRef, gqlMeta.key);
+    argMetas.forEach((argMeta) => {
+      if (argMeta.type !== "Room")
+        throw new Error(`Argument of Message should be Msg ${sigMeta.refName}-${gqlMeta.key}-${argMeta.name}`);
+      (0, import_websockets.MessageBody)(argMeta.name, ...(0, import_nest.getBodyPipes)(argMeta))(WsGateway.prototype, gqlMeta.key, argMeta.idx);
+    });
+    internalArgMetas.forEach((internalArgMeta) => {
+      const internalDecorator = internalArgMap[internalArgMeta.type];
+      internalDecorator(internalArgMeta.option ?? {})(WsGateway.prototype, gqlMeta.key, internalArgMeta.idx);
+    });
+    (0, import_common2.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;
+};
+const websocketServerOf = (sigRef) => {
+  const pubsubGqlMetas = (0, import_signal.getGqlMetas)(sigRef).filter((gqlMeta) => gqlMeta.type === "Pubsub");
+  let Websocket = class {
+    server;
+  };
+  __decorateClass([
+    (0, import_websockets.WebSocketServer)()
+  ], Websocket.prototype, "server", 2);
+  Websocket = __decorateClass([
+    (0, import_common2.Injectable)(),
+    (0, import_websockets.WebSocketGateway)({ cors: { origin: "*" }, transports: ["websocket"] })
+  ], Websocket);
+  for (const gqlMeta of pubsubGqlMetas) {
+    const [argMetas] = (0, import_signal.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;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  websocketOf,
+  websocketServerOf
+});