@akanjs/signal 0.0.40 → 0.0.42

package/src/signalDecorators.js

@@ -1,788 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var signalDecorators_exports = {};
-__export(signalDecorators_exports, {
-  Access: () => Access,
-  Account: () => Account,
-  Arg: () => Arg,
-  DbSignal: () => DbSignal,
-  Job: () => Job,
-  LogSignal: () => LogSignal,
-  Me: () => Me,
-  Message: () => Message,
-  Mutation: () => Mutation,
-  Parent: () => Parent,
-  Process: () => Process,
-  Pubsub: () => Pubsub,
-  Query: () => Query1,
-  Req: () => Req,
-  Res: () => Res,
-  ResolveField: () => ResolveField,
-  Self: () => Self,
-  Signal: () => Signal,
-  SignalStorage: () => SignalStorage,
-  UserIp: () => UserIp,
-  Ws: () => Ws,
-  argTypes: () => argTypes,
-  copySignal: () => copySignal,
-  createArgMetaDecorator: () => createArgMetaDecorator,
-  defaultAccount: () => defaultAccount,
-  done: () => done,
-  emit: () => emit,
-  endpointTypes: () => endpointTypes,
-  getAllSignalRefs: () => getAllSignalRefs,
-  getArgMetas: () => getArgMetas,
-  getControllerPath: () => getControllerPath,
-  getControllerPrefix: () => getControllerPrefix,
-  getGqlMeta: () => getGqlMeta,
-  getGqlMetaMapOnPrototype: () => getGqlMetaMapOnPrototype,
-  getGqlMetas: () => getGqlMetas,
-  getResolveFieldMetas: () => getResolveFieldMetas,
-  getSigMeta: () => getSigMeta,
-  getSignalRefsOnStorage: () => getSignalRefsOnStorage,
-  guardTypes: () => guardTypes,
-  internalArgTypes: () => internalArgTypes,
-  resolve: () => resolve,
-  roleTypes: () => roleTypes,
-  setArgMetas: () => setArgMetas,
-  setGqlMetaMapOnPrototype: () => setGqlMetaMapOnPrototype,
-  signalTypes: () => signalTypes,
-  ssoTypes: () => ssoTypes,
-  subscribe: () => subscribe
-});
-module.exports = __toCommonJS(signalDecorators_exports);
-var import_reflect_metadata = require("reflect-metadata");
-var import_base = require("@akanjs/base");
-var import_common = require("@akanjs/common");
-var import_constant = require("@akanjs/constant");
-var import_gql = require("./gql");
-function _ts_decorate(decorators, target, key, desc) {
-  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-  if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-  else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-  return c > 3 && r && Object.defineProperty(target, key, r), r;
-}
-__name(_ts_decorate, "_ts_decorate");
-function _ts_metadata(k, v) {
-  if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-}
-__name(_ts_metadata, "_ts_metadata");
-function _ts_param(paramIndex, decorator) {
-  return function(target, key) {
-    decorator(target, key, paramIndex);
-  };
-}
-__name(_ts_param, "_ts_param");
-const ssoTypes = [
-  "github",
-  "google",
-  "facebook",
-  "apple",
-  "naver",
-  "kakao"
-];
-class SignalStorage {
-  static {
-    __name(this, "SignalStorage");
-  }
-}
-const getAllSignalRefs = /* @__PURE__ */ __name(() => {
-  const signalNames = Reflect.getOwnMetadataKeys(SignalStorage.prototype);
-  const sigRefs = signalNames?.reduce((acc, signalName) => [
-    ...acc,
-    ...getSignalRefsOnStorage(signalName)
-  ], []) ?? [];
-  return sigRefs;
-}, "getAllSignalRefs");
-const getSignalRefsOnStorage = /* @__PURE__ */ __name((refName) => {
-  const sigRefs = Reflect.getMetadata(refName, SignalStorage.prototype);
-  return sigRefs ?? [];
-}, "getSignalRefsOnStorage");
-const setSignalRefOnStorage = /* @__PURE__ */ __name((refName, signalRef) => {
-  Reflect.defineMetadata(refName, [
-    ...getSignalRefsOnStorage(refName),
-    signalRef
-  ], SignalStorage.prototype);
-}, "setSignalRefOnStorage");
-const resolve = /* @__PURE__ */ __name((data) => data, "resolve");
-const emit = /* @__PURE__ */ __name((data) => data, "emit");
-const done = /* @__PURE__ */ __name((data) => data, "done");
-const subscribe = /* @__PURE__ */ __name(() => void 0, "subscribe");
-const signalTypes = [
-  "graphql",
-  "restapi"
-];
-const endpointTypes = [
-  "Query",
-  "Mutation",
-  "Message",
-  "Pubsub",
-  "Process"
-];
-const guardTypes = [
-  "Public",
-  "None",
-  "User",
-  "Admin",
-  "SuperAdmin",
-  "Every",
-  "Owner"
-];
-const roleTypes = [
-  "Public",
-  "User",
-  "Admin",
-  "SuperAdmin"
-];
-const argTypes = [
-  "Body",
-  "Param",
-  "Query",
-  "Upload",
-  "Msg",
-  "Room"
-];
-const internalArgTypes = [
-  "Account",
-  "Me",
-  "Self",
-  "UserIp",
-  "Access",
-  "Parent",
-  "Req",
-  "Res",
-  "Ws",
-  "Job"
-];
-const getDefaultArg = /* @__PURE__ */ __name((argRef) => {
-  const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(argRef);
-  if (arrDepth) return [];
-  const scalarArg = import_base.scalarArgMap.get(modelRef);
-  if (scalarArg) return scalarArg;
-  else return {};
-}, "getDefaultArg");
-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 = (0, import_constant.getClassMeta)(modelRef);
-      const gqlMetas = getGqlMetas(target);
-      const modelName = (0, import_common.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] = (0, import_base.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" ? (0, import_common.lowerlize)(returnsOrObj.name) : void 0;
-      if (!refName) throw new Error("Signal name is required");
-      setSigMeta(target, {
-        returns,
-        prefix,
-        slices: [],
-        refName
-      });
-      setSignalRefOnStorage(refName, target);
-    }
-  };
-}
-__name(Signal, "Signal");
-const createArgMetaDecorator = /* @__PURE__ */ __name((type) => {
-  return function(option = {}) {
-    return function(prototype, key, idx) {
-      const argMetas = getArgMetasOnPrototype(prototype, key);
-      argMetas[idx] = {
-        key,
-        idx,
-        type,
-        option
-      };
-      setArgMetasOnPrototype(prototype, key, argMetas);
-    };
-  };
-}, "createArgMetaDecorator");
-const Account = createArgMetaDecorator("Account");
-const defaultAccount = {
-  __InternalArg__: "Account",
-  appName: import_base.baseEnv.appName,
-  environment: import_base.baseEnv.environment
-};
-const Self = createArgMetaDecorator("Self");
-const Me = createArgMetaDecorator("Me");
-const UserIp = createArgMetaDecorator("UserIp");
-const Access = createArgMetaDecorator("Access");
-const Req = createArgMetaDecorator("Req");
-const Res = createArgMetaDecorator("Res");
-const Ws = createArgMetaDecorator("Ws");
-const Job = createArgMetaDecorator("Job");
-const getQuery = /* @__PURE__ */ __name((allow) => function(returns, signalOption = {}, guards = []) {
-  return (prototype, key, descriptor) => {
-    const metadataMap = getGqlMetaMapOnPrototype(prototype);
-    metadataMap.set(key, {
-      returns,
-      signalOption,
-      key,
-      descriptor,
-      guards: [
-        allow,
-        ...guards
-      ],
-      type: "Query"
-    });
-    setGqlMetaMapOnPrototype(prototype, metadataMap);
-  };
-}, "getQuery");
-const getMutation = /* @__PURE__ */ __name((allow) => function(returns, signalOption = {}, guards = []) {
-  return (prototype, key, descriptor) => {
-    const metadataMap = getGqlMetaMapOnPrototype(prototype);
-    metadataMap.set(key, {
-      returns,
-      signalOption,
-      key,
-      descriptor,
-      guards: [
-        allow,
-        ...guards
-      ],
-      type: "Mutation"
-    });
-    setGqlMetaMapOnPrototype(prototype, metadataMap);
-  };
-}, "getMutation");
-const getMessage = /* @__PURE__ */ __name((allow) => function(returns, signalOption = {}, guards = []) {
-  return (prototype, key, descriptor) => {
-    const metadataMap = getGqlMetaMapOnPrototype(prototype);
-    metadataMap.set(key, {
-      returns,
-      signalOption,
-      key,
-      descriptor,
-      guards: [
-        allow,
-        ...guards
-      ],
-      type: "Message"
-    });
-    setGqlMetaMapOnPrototype(prototype, metadataMap);
-  };
-}, "getMessage");
-const getPubsub = /* @__PURE__ */ __name((allow) => function(returns, signalOption = {}, guards = []) {
-  return (prototype, key, descriptor) => {
-    const metadataMap = getGqlMetaMapOnPrototype(prototype);
-    metadataMap.set(key, {
-      returns,
-      signalOption,
-      key,
-      descriptor,
-      guards: [
-        allow,
-        ...guards
-      ],
-      type: "Pubsub"
-    });
-    setGqlMetaMapOnPrototype(prototype, metadataMap);
-  };
-}, "getPubsub");
-const getProcess = /* @__PURE__ */ __name((serverType) => function(returns, signalOption = {}) {
-  return (prototype, key, descriptor) => {
-    const metadataMap = getGqlMetaMapOnPrototype(prototype);
-    metadataMap.set(key, {
-      returns,
-      signalOption: {
-        ...signalOption,
-        serverType: (0, import_common.lowerlize)(serverType)
-      },
-      key,
-      descriptor,
-      guards: [
-        "None"
-      ],
-      type: "Process"
-    });
-    setGqlMetaMapOnPrototype(prototype, metadataMap);
-  };
-}, "getProcess");
-const Query1 = {
-  Public: getQuery("Public"),
-  Every: getQuery("Every"),
-  Admin: getQuery("Admin"),
-  User: getQuery("User"),
-  SuperAdmin: getQuery("SuperAdmin"),
-  None: getQuery("None"),
-  Owner: getQuery("Owner")
-};
-const Mutation = {
-  Public: getMutation("Public"),
-  Every: getMutation("Every"),
-  Admin: getMutation("Admin"),
-  User: getMutation("User"),
-  SuperAdmin: getMutation("SuperAdmin"),
-  None: getMutation("None"),
-  Owner: getMutation("Owner")
-};
-const Message = {
-  Public: getMessage("Public"),
-  Every: getMessage("Every"),
-  Admin: getMessage("Admin"),
-  User: getMessage("User"),
-  SuperAdmin: getMessage("SuperAdmin"),
-  None: getMessage("None"),
-  Owner: getMessage("Owner")
-};
-const Pubsub = {
-  Public: getPubsub("Public"),
-  Every: getPubsub("Every"),
-  Admin: getPubsub("Admin"),
-  User: getPubsub("User"),
-  SuperAdmin: getPubsub("SuperAdmin"),
-  None: getPubsub("None"),
-  Owner: getPubsub("Owner")
-};
-const Process = {
-  Federation: getProcess("Federation"),
-  Batch: getProcess("Batch"),
-  All: getProcess("All")
-};
-function ResolveField(returns, argsOption = {}) {
-  return function(target, key, descriptor) {
-    const metadataMap = getResolveFieldMetaMapOnPrototype(target);
-    metadataMap.set(key, {
-      returns,
-      argsOption,
-      key,
-      descriptor
-    });
-    Reflect.defineMetadata("resolveField", metadataMap, target);
-  };
-}
-__name(ResolveField, "ResolveField");
-const getArg = /* @__PURE__ */ __name((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);
-  };
-}, "getArg");
-const Arg = {
-  Body: getArg("Body"),
-  Param: getArg("Param"),
-  Query: getArg("Query"),
-  Upload: getArg("Upload"),
-  Msg: getArg("Msg"),
-  Room: getArg("Room")
-};
-function Parent() {
-  return function(prototype, key, idx) {
-    const argMetas = getArgMetasOnPrototype(prototype, key);
-    argMetas[idx] = {
-      key,
-      idx,
-      type: "Parent"
-    };
-    setArgMetasOnPrototype(prototype, key, argMetas);
-  };
-}
-__name(Parent, "Parent");
-function LogSignal(srv) {
-  let BaseSignal = class BaseSignal {
-    static {
-      __name(this, "BaseSignal");
-    }
-  };
-  return BaseSignal;
-}
-__name(LogSignal, "LogSignal");
-function DbSignal(constant, srv, option) {
-  const meta = (0, import_constant.getClassMeta)(constant.Full);
-  const serviceName = `${(0, import_common.lowerlize)(meta.refName)}Service`;
-  const [modelName, className] = [
-    (0, import_common.lowerlize)(meta.refName),
-    (0, import_common.capitalize)(meta.refName)
-  ];
-  const names = {
-    modelId: `${modelName}Id`,
-    model: modelName,
-    lightModel: `light${className}`,
-    modelList: `${modelName}List`,
-    modelInsight: `${modelName}Insight`,
-    modelExists: `${modelName}Exists`,
-    getModel: `get${className}`,
-    createModel: `create${className}`,
-    updateModel: `update${className}`,
-    removeModel: `remove${className}`
-  };
-  var _key, _key1, _key2, _key3, _key4, _key5, _key6, _key7;
-  _key = names.lightModel;
-  _key1 = names.model;
-  _key2 = names.modelList;
-  _key3 = names.modelInsight;
-  _key4 = names.modelExists;
-  _key5 = names.createModel;
-  _key6 = names.updateModel;
-  _key7 = names.removeModel;
-  let BaseSignal = class BaseSignal {
-    static {
-      __name(this, "BaseSignal");
-    }
-    async [_key](id) {
-      const service = this[serviceName];
-      const model = await service[names.getModel](id);
-      return resolve(model);
-    }
-    async [_key1](id) {
-      const service = this[serviceName];
-      const model = await service[names.getModel](id);
-      return resolve(model);
-    }
-    async [_key2](query, skip, limit, sort) {
-      const service = this[serviceName];
-      const models = query?.$search ? await service.__searchDocs(query.$search, {
-        skip,
-        limit,
-        sort
-      }) : await service.__list(query, {
-        skip,
-        limit,
-        sort
-      });
-      return resolve(models);
-    }
-    async [_key3](query) {
-      const service = this[serviceName];
-      const insight = query.$search ? {
-        ...(0, import_gql.makeDefault)(constant.Insight),
-        count: await service.__searchCount(query.$search)
-      } : await service.__insight(query);
-      return resolve(insight);
-    }
-    async [_key4](query) {
-      const service = this[serviceName];
-      const exists = await service.__exists(query);
-      return resolve(exists);
-    }
-    async [_key5](data) {
-      const service = this[serviceName];
-      const model = await service[names.createModel](data);
-      return resolve(model);
-    }
-    async [_key6](id, data) {
-      const service = this[serviceName];
-      const model = await service[names.updateModel](id, data);
-      return resolve(model);
-    }
-    async [_key7](id) {
-      const service = this[serviceName];
-      const model = await service[names.removeModel](id);
-      return resolve(model);
-    }
-  };
-  _ts_decorate([
-    option.guards.get(() => constant.Light),
-    _ts_param(0, Arg.Param(names.modelId, () => import_base.ID)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-  ], BaseSignal.prototype, _key, null);
-  _ts_decorate([
-    option.guards.get(() => constant.Full),
-    _ts_param(0, Arg.Param(names.modelId, () => import_base.ID)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-  ], BaseSignal.prototype, _key1, null);
-  _ts_decorate([
-    Query1.Admin(() => [
-      constant.Full
-    ]),
-    _ts_param(0, Arg.Query("query", () => import_base.JSON)),
-    _ts_param(1, Arg.Query("skip", () => import_base.Int, {
-      nullable: true,
-      example: 0
-    })),
-    _ts_param(2, Arg.Query("limit", () => import_base.Int, {
-      nullable: true,
-      example: 20
-    })),
-    _ts_param(3, Arg.Query("sort", () => String, {
-      nullable: true,
-      example: "latest"
-    })),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      Object,
-      Object,
-      Object,
-      Object
-    ]),
-    _ts_metadata("design:returntype", Promise)
-  ], BaseSignal.prototype, _key2, null);
-  _ts_decorate([
-    Query1.Admin(() => constant.Insight),
-    _ts_param(0, Arg.Query("query", () => import_base.JSON)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      typeof Query === "undefined" ? Object : Query
-    ]),
-    _ts_metadata("design:returntype", Promise)
-  ], BaseSignal.prototype, _key3, null);
-  _ts_decorate([
-    Query1.Admin(() => Boolean),
-    _ts_param(0, Arg.Query("query", () => import_base.JSON)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      typeof Query === "undefined" ? Object : Query
-    ]),
-    _ts_metadata("design:returntype", Promise)
-  ], BaseSignal.prototype, _key4, null);
-  _ts_decorate([
-    option.guards.cru(() => constant.Full),
-    _ts_param(0, Arg.Body(`data`, () => constant.Input)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      typeof Query === "undefined" ? Object : Query
-    ]),
-    _ts_metadata("design:returntype", Promise)
-  ], BaseSignal.prototype, _key5, null);
-  _ts_decorate([
-    option.guards.cru(() => constant.Full),
-    _ts_param(0, Arg.Param(names.modelId, () => import_base.ID)),
-    _ts_param(1, Arg.Body("data", () => constant.Input)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      String,
-      typeof Input === "undefined" ? Object : Input
-    ]),
-    _ts_metadata("design:returntype", Promise)
-  ], BaseSignal.prototype, _key6, null);
-  _ts_decorate([
-    option.guards.cru(() => constant.Full, {
-      partial: [
-        "status",
-        "removedAt"
-      ]
-    }),
-    _ts_param(0, Arg.Param(names.modelId, () => import_base.ID)),
-    _ts_metadata("design:type", Function),
-    _ts_metadata("design:paramtypes", [
-      String
-    ]),
-    _ts_metadata("design:returntype", Promise)
-  ], BaseSignal.prototype, _key7, null);
-  return BaseSignal;
-}
-__name(DbSignal, "DbSignal");
-const getSigMeta = /* @__PURE__ */ __name((sigRef) => {
-  const sigMeta = Reflect.getMetadata("signal", sigRef.prototype);
-  if (!sigMeta) throw new Error(`No SignalMeta found for ${sigRef.name}`);
-  return sigMeta;
-}, "getSigMeta");
-const setSigMeta = /* @__PURE__ */ __name((sigRef, sigMeta) => {
-  Reflect.defineMetadata("signal", sigMeta, sigRef.prototype);
-}, "setSigMeta");
-const getGqlMeta = /* @__PURE__ */ __name((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;
-}, "getGqlMeta");
-const getGqlMetaMapOnPrototype = /* @__PURE__ */ __name((prototype) => {
-  const gqlMetaMap = Reflect.getMetadata("gql", prototype);
-  return gqlMetaMap ?? /* @__PURE__ */ new Map();
-}, "getGqlMetaMapOnPrototype");
-const getGqlMetas = /* @__PURE__ */ __name((sigRef) => {
-  const gqlMetaMap = Reflect.getMetadata("gql", sigRef.prototype);
-  return gqlMetaMap ? [
-    ...gqlMetaMap.values()
-  ] : [];
-}, "getGqlMetas");
-const setGqlMetaMapOnPrototype = /* @__PURE__ */ __name((prototype, gqlMetaMap) => {
-  Reflect.defineMetadata("gql", gqlMetaMap, prototype);
-}, "setGqlMetaMapOnPrototype");
-const getArgMetas = /* @__PURE__ */ __name((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
-  ];
-}, "getArgMetas");
-const getArgMetasOnPrototype = /* @__PURE__ */ __name((prototype, key) => {
-  return Reflect.getMetadata("args", prototype, key) ?? [];
-}, "getArgMetasOnPrototype");
-const setArgMetas = /* @__PURE__ */ __name((sigRef, key, argMetas, internalArgMetas) => {
-  Reflect.defineMetadata("args", [
-    ...argMetas,
-    ...internalArgMetas
-  ], sigRef.prototype, key);
-}, "setArgMetas");
-const setArgMetasOnPrototype = /* @__PURE__ */ __name((prototype, key, argMetas) => {
-  Reflect.defineMetadata("args", argMetas, prototype, key);
-}, "setArgMetasOnPrototype");
-const getResolveFieldMetaMapOnPrototype = /* @__PURE__ */ __name((prototype) => {
-  const resolveFieldMetaMap = Reflect.getMetadata("resolveField", prototype);
-  return resolveFieldMetaMap ?? /* @__PURE__ */ new Map();
-}, "getResolveFieldMetaMapOnPrototype");
-const getResolveFieldMetas = /* @__PURE__ */ __name((sigRef) => {
-  const resolveFieldMetaMap = Reflect.getMetadata("resolveField", sigRef.prototype);
-  return resolveFieldMetaMap ? [
-    ...resolveFieldMetaMap.values()
-  ] : [];
-}, "getResolveFieldMetas");
-const setResolveFieldMetaMapOnPrototype = /* @__PURE__ */ __name((prototype, resolveFieldMetaMap) => {
-  Reflect.defineMetadata("resolveField", resolveFieldMetaMap, prototype);
-}, "setResolveFieldMetaMapOnPrototype");
-const getControllerPrefix = /* @__PURE__ */ __name((sigMeta) => {
-  return sigMeta.returns ? (0, import_common.lowerlize)((0, import_constant.getClassMeta)(sigMeta.returns()).refName) : sigMeta.prefix;
-}, "getControllerPrefix");
-const getControllerPath = /* @__PURE__ */ __name((gqlMeta, paramArgMetas) => {
-  return gqlMeta.signalOption.path ?? [
-    gqlMeta.signalOption.name ?? gqlMeta.key,
-    ...paramArgMetas.map((argMeta) => `:${argMeta.name}`)
-  ].join("/");
-}, "getControllerPath");
-const copySignal = /* @__PURE__ */ __name((sigRef) => {
-  let CopiedSignal = class CopiedSignal {
-    static {
-      __name(this, "CopiedSignal");
-    }
-  };
-  (0, import_common.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;
-}, "copySignal");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  Access,
-  Account,
-  Arg,
-  DbSignal,
-  Job,
-  LogSignal,
-  Me,
-  Message,
-  Mutation,
-  Parent,
-  Process,
-  Pubsub,
-  Query,
-  Req,
-  Res,
-  ResolveField,
-  Self,
-  Signal,
-  SignalStorage,
-  UserIp,
-  Ws,
-  argTypes,
-  copySignal,
-  createArgMetaDecorator,
-  defaultAccount,
-  done,
-  emit,
-  endpointTypes,
-  getAllSignalRefs,
-  getArgMetas,
-  getControllerPath,
-  getControllerPrefix,
-  getGqlMeta,
-  getGqlMetaMapOnPrototype,
-  getGqlMetas,
-  getResolveFieldMetas,
-  getSigMeta,
-  getSignalRefsOnStorage,
-  guardTypes,
-  internalArgTypes,
-  resolve,
-  roleTypes,
-  setArgMetas,
-  setGqlMetaMapOnPrototype,
-  signalTypes,
-  ssoTypes,
-  subscribe
-});