@akanjs/signal 0.9.48 → 0.9.49

package/cjs/src/graphql.js

@@ -0,0 +1,125 @@
+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 graphql_exports = {};
+__export(graphql_exports, {
+  getGqlStr: () => getGqlStr,
+  graphql: () => graphql,
+  makeFragment: () => makeFragment
+});
+module.exports = __toCommonJS(graphql_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+class FragmentStorage {
+}
+const getPredefinedFragment = (refName) => {
+  const fragment = Reflect.getMetadata(refName, FragmentStorage.prototype);
+  return fragment;
+};
+const setPredefinedFragment = (refName, fragment) => {
+  Reflect.defineMetadata(refName, fragment, FragmentStorage.prototype);
+};
+const makeArgStr = (args) => {
+  return args.length ? `(${args.map((arg) => {
+    const argRef = import_constant.constantInfo.getModelRef(arg.refName, arg.modelType);
+    const argRefType = (0, import_base.isGqlScalar)(argRef) ? "gqlScalar" : "class";
+    const gqlTypeStr = "[".repeat(arg.arrDepth) + `${(0, import_constant.getGqlTypeStr)(argRef)}${argRefType === "class" ? "Input" : ""}` + "!]".repeat(arg.arrDepth);
+    return `$${arg.name}: ` + gqlTypeStr + (arg.argsOption.nullable ? "" : "!");
+  }).join(", ")})` : "";
+};
+const makeArgAssignStr = (args) => {
+  return args.length ? `(${args.map((arg) => `${arg.name}: $${arg.name}`).join(", ")})` : "";
+};
+const makeReturnStr = (returnRef, partial) => {
+  const isScalar = (0, import_base.isGqlScalar)(returnRef);
+  if (isScalar)
+    return "";
+  const refName = import_constant.constantInfo.getRefName(returnRef);
+  const fragmentName = `${import_constant.constantInfo.isLight(returnRef) ? "Light" : ""}${(0, import_common.capitalize)(refName)}${import_constant.constantInfo.isInsight(returnRef) ? "Insight" : ""}`;
+  if (!partial?.length)
+    return ` {
+        ...${(0, import_common.lowerlize)(fragmentName)}Fragment
+      }`;
+  const targetKeys = import_constant.constantInfo.isScalar(returnRef) ? partial : [.../* @__PURE__ */ new Set(["id", ...partial, "updatedAt"])];
+  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(returnRef);
+  return ` {
+    ${targetKeys.map((key) => fieldMetaMap.get(key)).filter((metadata) => metadata && metadata.fieldType !== "hidden").map(
+    (fieldMeta) => fieldMeta.isClass ? `    ${fieldMeta.key} {
+          ...${(0, import_common.lowerlize)((0, import_constant.getGqlTypeStr)(fieldMeta.modelRef))}Fragment
+        }` : `    ${fieldMeta.key}`
+  ).join("\n")}
+      }`;
+};
+const fragmentize = (modelRef, fragMap = /* @__PURE__ */ new Map(), partial) => {
+  const refName = import_constant.constantInfo.getRefName(modelRef);
+  const fragmentName = `${import_constant.constantInfo.isLight(modelRef) ? "Light" : ""}${(0, import_common.capitalize)(refName)}${import_constant.constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
+  const gqlName = `${(0, import_common.capitalize)(refName)}${import_constant.constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
+  const metadatas = (0, import_constant.getFieldMetas)(modelRef);
+  const selectKeys = partial ? ["id", ...partial, "updatedAt"] : metadatas.map((metadata) => metadata.key);
+  const selectKeySet = new Set(selectKeys);
+  const fragment = `fragment ${(0, import_common.lowerlize)(fragmentName)}Fragment on ${gqlName} {
+` + metadatas.filter((metadata) => metadata.fieldType !== "hidden" && selectKeySet.has(metadata.key)).map((metadata) => {
+    return metadata.isClass ? `  ${metadata.key} {
+    ...${(0, import_common.lowerlize)(`${import_constant.constantInfo.isLight(metadata.modelRef) ? "Light" : ""}${(0, import_common.capitalize)(import_constant.constantInfo.getRefName(metadata.modelRef))}${import_constant.constantInfo.isInsight(metadata.modelRef) ? "Insight" : ""}`)}Fragment
+  }` : `  ${metadata.key}`;
+  }).join(`
+`) + `
+}`;
+  fragMap.set(fragmentName, fragment);
+  metadatas.filter((metadata) => metadata.fieldType !== "hidden" && selectKeySet.has(metadata.key) && metadata.isClass).forEach((metadata) => fragmentize(metadata.modelRef, fragMap));
+  return fragMap;
+};
+const makeFragment = (modelRef, option = {}) => {
+  const refName = import_constant.constantInfo.getRefName(modelRef);
+  const fragmentName = `${import_constant.constantInfo.isLight(modelRef) ? "Light" : ""}${(0, import_common.capitalize)(refName)}${import_constant.constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
+  const fragment = getPredefinedFragment(fragmentName);
+  if (fragment && !option.overwrite && !option.excludeSelf && !option.partial?.length)
+    return fragment;
+  const fragMap = new Map(fragmentize(modelRef, /* @__PURE__ */ new Map(), option.partial));
+  if (option.excludeSelf)
+    fragMap.delete(fragmentName);
+  const gqlStr = [...fragMap.values()].join("\n");
+  if (!option.excludeSelf)
+    setPredefinedFragment(fragmentName, gqlStr);
+  return gqlStr;
+};
+const getGqlStr = (modelRef, key, endpoint, returnRef, partial) => {
+  const isScalar = (0, import_base.isGqlScalar)(modelRef);
+  const argStr = makeArgStr(endpoint.args);
+  const argAssignStr = makeArgAssignStr(endpoint.args);
+  const returnStr = makeReturnStr(returnRef, partial);
+  const gqlStr = `${isScalar ? "" : makeFragment(returnRef, { excludeSelf: !!partial?.length, partial })}
+    ${endpoint.type + " " + key + argStr}{
+      ${key}${argAssignStr}${returnStr}
+    }
+    `;
+  return gqlStr;
+};
+function graphql(literals, ...args) {
+  if (typeof literals === "string")
+    literals = [literals];
+  let result = literals[0];
+  args.forEach((arg, i) => {
+    if (arg && arg.kind === "Document")
+      result += arg.loc.source.body;
+    else
+      result += arg;
+    result += literals[i + 1];
+  });
+  return result;
+}

package/cjs/src/index.js

@@ -30,3 +30,8 @@ __reExport(src_exports, require("./doc"), module.exports);
 __reExport(src_exports, require("./baseFetch"), module.exports);
 __reExport(src_exports, require("./base.signal"), module.exports);
 __reExport(src_exports, require("./fetch"), module.exports);
+__reExport(src_exports, require("./signalInfo"), module.exports);
+__reExport(src_exports, require("./apiInfo"), module.exports);
+__reExport(src_exports, require("./sliceInfo"), module.exports);
+__reExport(src_exports, require("./fetchInfo"), module.exports);
+__reExport(src_exports, require("./graphql"), module.exports);

package/cjs/src/internalApiInfo.js

@@ -0,0 +1,151 @@
+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 internalApiInfo_exports = {};
+__export(internalApiInfo_exports, {
+  InternalApiInfo: () => InternalApiInfo,
+  makeInternalApiBuilder: () => makeInternalApiBuilder
+});
+module.exports = __toCommonJS(internalApiInfo_exports);
+var import_base = require("@akanjs/base");
+var import_signalDecorators = require("./signalDecorators");
+class InternalApiInfo {
+  type;
+  args = [];
+  internalArgs = [];
+  returnRef;
+  signalOption;
+  execFn = null;
+  constructor(type, returnRef, signalOption = {}) {
+    this.type = type;
+    this.returnRef = returnRef;
+    this.signalOption = signalOption;
+  }
+  msg(name, argRef, option) {
+    if (this.execFn)
+      throw new Error("Query function is already set");
+    else if (this.args.at(-1)?.option?.nullable)
+      throw new Error("Last argument is nullable");
+    this.args.push({ type: "Msg", name, argRef, option });
+    return this;
+  }
+  with(argType, option) {
+    if (this.execFn)
+      throw new Error("Query function is already set");
+    this.internalArgs.push({ type: argType, option });
+    return this;
+  }
+  exec(query) {
+    if (this.execFn)
+      throw new Error("Query function is already set");
+    this.execFn = query;
+    return this;
+  }
+  static #typeTempMap = {
+    resolveField: "ResolveField",
+    interval: "Schedule",
+    cron: "Schedule",
+    timeout: "Schedule",
+    init: "Schedule",
+    destroy: "Schedule",
+    process: "Process"
+  };
+  applyApiMeta(sigRef, key) {
+    if (this.type === "resolveField") {
+      const metadataMap2 = (0, import_signalDecorators.getResolveFieldMetaMapOnPrototype)(sigRef.prototype);
+      metadataMap2.set(key, {
+        returns: () => this.returnRef,
+        argsOption: this.signalOption,
+        key,
+        descriptor: { value: this.execFn, writable: true, enumerable: false, configurable: true }
+      });
+      sigRef.prototype[key] = this.execFn;
+      Reflect.defineMetadata("resolveField", metadataMap2, sigRef.prototype);
+      return;
+    }
+    const internalApiMeta = {
+      returns: () => this.returnRef instanceof import_base.Enum ? this.returnRef.type : this.returnRef,
+      signalOption: this.signalOption,
+      key,
+      descriptor: { value: this.execFn, writable: true, enumerable: false, configurable: true },
+      guards: ["None"],
+      type: InternalApiInfo.#typeTempMap[this.type]
+    };
+    sigRef.prototype[key] = this.execFn;
+    const metadataMap = (0, import_signalDecorators.getGqlMetaMapOnPrototype)(sigRef.prototype);
+    metadataMap.set(key, internalApiMeta);
+    (0, import_signalDecorators.setGqlMetaMapOnPrototype)(sigRef.prototype, metadataMap);
+    const argMetas = this.args.map((arg, idx) => ({
+      name: arg.name,
+      returns: () => arg.argRef,
+      argsOption: { ...arg.option, enum: arg.argRef instanceof import_base.Enum ? arg.argRef : void 0 },
+      key,
+      idx,
+      type: arg.type
+    }));
+    const internalArgMetas = this.internalArgs.map((arg, idx) => ({
+      type: arg.type,
+      key,
+      idx,
+      option: arg.option
+    }));
+    (0, import_signalDecorators.setArgMetas)(sigRef, key, argMetas, internalArgMetas);
+  }
+}
+const makeInternalApiBuilder = () => ({
+  resolveField: (returnRef, signalOption) => new InternalApiInfo(
+    "resolveField",
+    returnRef,
+    signalOption
+  ),
+  interval: (scheduleTime, signalOption) => new InternalApiInfo("interval", import_base.JSON, {
+    enabled: true,
+    lock: true,
+    scheduleType: "interval",
+    scheduleTime,
+    ...signalOption
+  }),
+  cron: (scheduleCron, signalOption) => new InternalApiInfo("cron", import_base.JSON, {
+    enabled: true,
+    lock: true,
+    scheduleType: "cron",
+    scheduleCron,
+    ...signalOption
+  }),
+  timeout: (timeout, signalOption) => new InternalApiInfo("timeout", import_base.JSON, {
+    enabled: true,
+    lock: true,
+    scheduleType: "timeout",
+    scheduleTime: timeout,
+    ...signalOption
+  }),
+  initialize: (signalOption) => new InternalApiInfo("init", import_base.JSON, {
+    enabled: true,
+    scheduleType: "init",
+    ...signalOption
+  }),
+  destroy: (signalOption) => new InternalApiInfo("destroy", import_base.JSON, {
+    enabled: true,
+    lock: true,
+    scheduleType: "destroy",
+    ...signalOption
+  }),
+  process: (returnRef, signalOption) => new InternalApiInfo("process", returnRef, {
+    serverMode: "all",
+    ...signalOption
+  })
+});

package/cjs/src/signalDecorators.js

@@ -15,24 +15,12 @@ var __copyProps = (to, from, except, desc) => {
   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 __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
 var signalDecorators_exports = {};
 __export(signalDecorators_exports, {
   Access: () => Access,
   Account: () => Account,
   Arg: () => Arg,
-  DbSignal: () => DbSignal,
   Job: () => Job,
-  LogSignal: () => LogSignal,
   Me: () => Me,
   Message: () => Message,
   Mutation: () => Mutation,
@@ -45,7 +33,6 @@ __export(signalDecorators_exports, {
   ResolveField: () => ResolveField,
   Schedule: () => Schedule,
   Self: () => Self,
-  Signal: () => Signal,
   SignalStorage: () => SignalStorage,
   UserIp: () => UserIp,
   Ws: () => Ws,
@@ -55,24 +42,32 @@ __export(signalDecorators_exports, {
   defaultAccount: () => defaultAccount,
   done: () => done,
   emit: () => emit,
+  endpoint: () => endpoint,
   endpointTypes: () => endpointTypes,
   getAllSignalRefs: () => getAllSignalRefs,
   getArgMetas: () => getArgMetas,
   getControllerPath: () => getControllerPath,
   getControllerPrefix: () => getControllerPrefix,
+  getDefaultArg: () => getDefaultArg,
   getGqlMeta: () => getGqlMeta,
   getGqlMetaMapOnPrototype: () => getGqlMetaMapOnPrototype,
   getGqlMetas: () => getGqlMetas,
+  getResolveFieldMetaMapOnPrototype: () => getResolveFieldMetaMapOnPrototype,
   getResolveFieldMetas: () => getResolveFieldMetas,
   getSigMeta: () => getSigMeta,
   getSignalRefsOnStorage: () => getSignalRefsOnStorage,
   guardTypes: () => guardTypes,
+  internal: () => internal,
   internalArgTypes: () => internalArgTypes,
+  mergeSignals: () => mergeSignals,
   resolve: () => resolve,
   roleTypes: () => roleTypes,
   setArgMetas: () => setArgMetas,
   setGqlMetaMapOnPrototype: () => setGqlMetaMapOnPrototype,
+  setSigMeta: () => setSigMeta,
+  setSignalRefOnStorage: () => setSignalRefOnStorage,
   signalTypes: () => signalTypes,
+  slice: () => slice,
   ssoTypes: () => ssoTypes,
   subscribe: () => subscribe
 });
@@ -81,7 +76,10 @@ 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");
+var import__ = require(".");
+var import_apiInfo = require("./apiInfo");
+var import_internalApiInfo = require("./internalApiInfo");
+var import_signalInfo = require("./signalInfo");
 const ssoTypes = ["github", "google", "facebook", "apple", "naver", "kakao"];
 class SignalStorage {
 }
@@ -102,7 +100,7 @@ const emit = (data) => data;
 const done = (data) => data;
 const subscribe = () => void 0;
 const signalTypes = ["graphql", "restapi"];
-const endpointTypes = ["Query", "Mutation", "Message", "Pubsub", "Process", "Schedule"];
+const endpointTypes = ["Query", "Mutation", "Message", "Pubsub", "Process", "Schedule", "ResolveField"];
 const guardTypes = ["Public", "None", "User", "Admin", "SuperAdmin", "Every", "Owner"];
 const roleTypes = ["Public", "User", "Admin", "SuperAdmin"];
 const argTypes = ["Body", "Param", "Query", "Upload", "Msg", "Room"];
@@ -128,50 +126,6 @@ const getDefaultArg = (argRef) => {
   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 = (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);
-    }
-  };
-}
 const createArgMetaDecorator = (type) => {
   return function(option = {}) {
     return function(prototype, key, idx) {
@@ -398,106 +352,118 @@ function Parent() {
     setArgMetasOnPrototype(prototype, key, argMetas);
   };
 }
-function LogSignal(srv) {
-  class BaseSignal {
-  }
-  return BaseSignal;
+function internal(srv, internalBuilder, ...libInternals) {
+  const sigRef = libInternals.at(0) ?? class Internal {
+  };
+  import_signalInfo.signalInfo.setRefNameTemp(sigRef, srv.refName);
+  const buildInternal = internalBuilder((0, import_internalApiInfo.makeInternalApiBuilder)());
+  Object.entries(buildInternal).forEach(([key, internal2]) => {
+    internal2.applyApiMeta(sigRef, key);
+  });
+  return sigRef;
 }
-function DbSignal(constant, srv, option) {
-  var _a, _b, _c, _d, _e, _f, _g, _h;
-  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)];
+function slice(srv, option, sliceBuilder, ...libSlices) {
+  if (!srv.cnst)
+    throw new Error("cnst is required");
+  const sigRef = libSlices.at(0) ?? class Slice {
+  };
+  import_signalInfo.signalInfo.setRefNameTemp(sigRef, srv.refName);
+  const [modelName, className] = [srv.cnst.refName, (0, import_common.capitalize)(srv.cnst.refName)];
   const names = {
     modelId: `${modelName}Id`,
     model: modelName,
     lightModel: `light${className}`,
-    modelList: `${modelName}List`,
-    modelInsight: `${modelName}Insight`,
-    modelExists: `${modelName}Exists`,
+    modelService: `${modelName}Service`,
     getModel: `get${className}`,
     createModel: `create${className}`,
     updateModel: `update${className}`,
     removeModel: `remove${className}`
   };
+  const getGuard = option.guards?.get ?? "Public";
+  const cruGuard = option.guards?.cru ?? "Public";
+  const init = (0, import__.sliceInit)(srv.cnst.full, srv.cnst.light, srv.cnst.insight);
+  const { query, mutation } = (0, import_apiInfo.makeApiBuilder)();
+  const buildSlice = {
+    [""]: init("Admin").search("query", import_base.JSON).exec(function(query2) {
+      return query2 ?? {};
+    }),
+    ...sliceBuilder(init)
+  };
+  const buildEndpoint = {
+    [names.model]: query(srv.cnst.full, getGuard).param(names.modelId, import_base.ID).exec(async function(modelId) {
+      const service = this[names.modelService];
+      return await service[names.getModel](modelId);
+    }),
+    [names.lightModel]: query(srv.cnst.light, getGuard).param(names.modelId, import_base.ID).exec(async function(modelId) {
+      const service = this[names.modelService];
+      return await service[names.getModel](modelId);
+    }),
+    [names.createModel]: mutation(srv.cnst.full, cruGuard).body("data", srv.cnst.input).exec(async function(data) {
+      const service = this[names.modelService];
+      return await service[names.createModel](data);
+    }),
+    [names.updateModel]: mutation(srv.cnst.full, cruGuard).param(names.modelId, import_base.ID).body("data", srv.cnst.input).exec(async function(modelId, data) {
+      const service = this[names.modelService];
+      return await service[names.updateModel](modelId, data);
+    }),
+    [names.removeModel]: mutation(srv.cnst.full, { partial: ["removedAt"] }, cruGuard).param(names.modelId, import_base.ID).exec(async function(modelId) {
+      const service = this[names.modelService];
+      return await service[names.removeModel](modelId);
+    })
+  };
+  Object.entries(buildSlice).forEach(([key, slice2]) => {
+    if (!srv.cnst)
+      return;
+    slice2.applySliceMeta(srv.cnst.refName, sigRef, key);
+  });
+  Object.entries(buildEndpoint).forEach(([key, endpoint2]) => {
+    endpoint2.applyApiMeta(sigRef, key);
+  });
+  return sigRef;
+}
+function endpoint(srv, builder, ...libSignals) {
+  const sigRef = libSignals.at(0) ?? class Signal {
+  };
+  import_signalInfo.signalInfo.setRefNameTemp(sigRef, srv.refName);
+  const apiInfoMap = builder((0, import_apiInfo.makeApiBuilder)());
+  Object.entries(apiInfoMap).forEach(([key, apiInfo]) => {
+    apiInfo.applyApiMeta(sigRef, key);
+  });
+  return sigRef;
+}
+const mergeSignals = (signalRef, internalRef, sliceRef) => {
+  (0, import_common.applyMixins)(signalRef, [internalRef, ...sliceRef ? [sliceRef] : []]);
+  const gqlMetaMap = getGqlMetaMapOnPrototype(signalRef.prototype);
+  const resolveFieldMetaMap = getResolveFieldMetaMapOnPrototype(signalRef.prototype);
+  setResolveFieldMetaMapOnPrototype(signalRef.prototype, resolveFieldMetaMap);
+  const internalGqlMetaMap = getGqlMetaMapOnPrototype(internalRef.prototype);
+  const internalResolveFieldMetaMap = getResolveFieldMetaMapOnPrototype(internalRef.prototype);
+  internalGqlMetaMap.forEach((value, key) => {
+    gqlMetaMap.set(key, value);
+    const [argMetas, internalArgMetas] = getArgMetas(internalRef, key);
+    setArgMetas(signalRef, key, argMetas, internalArgMetas);
+  });
+  internalResolveFieldMetaMap.forEach((value, key) => {
+    resolveFieldMetaMap.set(key, value);
+  });
+  if (sliceRef) {
+    const sliceGqlMetaMap = getGqlMetaMapOnPrototype(sliceRef.prototype);
+    sliceGqlMetaMap.forEach((value, key) => {
+      if (gqlMetaMap.has(key))
+        return;
+      gqlMetaMap.set(key, value);
+      const [argMetas, internalArgMetas] = getArgMetas(sliceRef, key);
+      setArgMetas(signalRef, key, argMetas, internalArgMetas);
+    });
+  }
+  setGqlMetaMapOnPrototype(signalRef.prototype, gqlMetaMap);
+  return signalRef;
+};
+function LogSignal(refName, srv, option) {
   class BaseSignal {
-    async [_a = names.lightModel](id) {
-      const service = this[serviceName];
-      const model = await service[names.getModel](id);
-      return resolve(model);
-    }
-    async [_b = names.model](id) {
-      const service = this[serviceName];
-      const model = await service[names.getModel](id);
-      return resolve(model);
-    }
-    async [_c = names.modelList](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 [_d = names.modelInsight](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 [_e = names.modelExists](query) {
-      const service = this[serviceName];
-      const exists = await service.__exists(query);
-      return resolve(exists);
-    }
-    async [_f = names.createModel](data) {
-      const service = this[serviceName];
-      const model = await service[names.createModel](data);
-      return resolve(model);
-    }
-    async [_g = names.updateModel](id, data) {
-      const service = this[serviceName];
-      const model = await service[names.updateModel](id, data);
-      return resolve(model);
-    }
-    async [_h = names.removeModel](id) {
-      const service = this[serviceName];
-      const model = await service[names.removeModel](id);
-      return resolve(model);
-    }
   }
-  __decorateClass([
-    option.guards.get(() => constant.Light),
-    __decorateParam(0, Arg.Param(names.modelId, () => import_base.ID))
-  ], BaseSignal.prototype, _a, 1);
-  __decorateClass([
-    option.guards.get(() => constant.Full),
-    __decorateParam(0, Arg.Param(names.modelId, () => import_base.ID))
-  ], BaseSignal.prototype, _b, 1);
-  __decorateClass([
-    Query.Admin(() => [constant.Full]),
-    __decorateParam(0, Arg.Query("query", () => import_base.JSON)),
-    __decorateParam(1, Arg.Query("skip", () => import_base.Int, { nullable: true, example: 0 })),
-    __decorateParam(2, Arg.Query("limit", () => import_base.Int, { nullable: true, example: 20 })),
-    __decorateParam(3, Arg.Query("sort", () => String, { nullable: true, example: "latest" }))
-  ], BaseSignal.prototype, _c, 1);
-  __decorateClass([
-    Query.Admin(() => constant.Insight),
-    __decorateParam(0, Arg.Query("query", () => import_base.JSON))
-  ], BaseSignal.prototype, _d, 1);
-  __decorateClass([
-    Query.Admin(() => Boolean),
-    __decorateParam(0, Arg.Query("query", () => import_base.JSON))
-  ], BaseSignal.prototype, _e, 1);
-  __decorateClass([
-    option.guards.cru(() => constant.Full),
-    __decorateParam(0, Arg.Body(`data`, () => constant.Input))
-  ], BaseSignal.prototype, _f, 1);
-  __decorateClass([
-    option.guards.cru(() => constant.Full),
-    __decorateParam(0, Arg.Param(names.modelId, () => import_base.ID)),
-    __decorateParam(1, Arg.Body("data", () => constant.Input))
-  ], BaseSignal.prototype, _g, 1);
-  __decorateClass([
-    option.guards.cru(() => constant.Full, { partial: ["status", "removedAt"] }),
-    __decorateParam(0, Arg.Param(names.modelId, () => import_base.ID))
-  ], BaseSignal.prototype, _h, 1);
+  import_signalInfo.signalInfo.setRefNameTemp(BaseSignal, refName);
+  import_signalInfo.signalInfo.setPrefixTemp(BaseSignal, option?.prefix ?? "");
   return BaseSignal;
 }
 const getSigMeta = (sigRef) => {
@@ -556,7 +522,7 @@ const setResolveFieldMetaMapOnPrototype = (prototype, resolveFieldMetaMap) => {
   Reflect.defineMetadata("resolveField", resolveFieldMetaMap, prototype);
 };
 const getControllerPrefix = (sigMeta) => {
-  return sigMeta.returns ? (0, import_common.lowerlize)((0, import_constant.getClassMeta)(sigMeta.returns()).refName) : sigMeta.prefix;
+  return sigMeta.returns ? import_constant.constantInfo.getRefName(sigMeta.returns()) : sigMeta.prefix;
 };
 const getControllerPath = (gqlMeta, paramArgMetas) => {
   return gqlMeta.signalOption.path ?? [gqlMeta.signalOption.name ?? gqlMeta.key, ...paramArgMetas.map((argMeta) => `:${argMeta.name}`)].join("/");