@akanjs/signal 0.9.48 → 0.9.49

package/esm/src/graphql.js

@@ -0,0 +1,106 @@
+import { isGqlScalar } from "@akanjs/base";
+import { capitalize, lowerlize } from "@akanjs/common";
+import { constantInfo, getFieldMetaMap, getFieldMetas, getGqlTypeStr } from "@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 = constantInfo.getModelRef(arg.refName, arg.modelType);
+    const argRefType = isGqlScalar(argRef) ? "gqlScalar" : "class";
+    const gqlTypeStr = "[".repeat(arg.arrDepth) + `${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 = isGqlScalar(returnRef);
+  if (isScalar)
+    return "";
+  const refName = constantInfo.getRefName(returnRef);
+  const fragmentName = `${constantInfo.isLight(returnRef) ? "Light" : ""}${capitalize(refName)}${constantInfo.isInsight(returnRef) ? "Insight" : ""}`;
+  if (!partial?.length)
+    return ` {
+        ...${lowerlize(fragmentName)}Fragment
+      }`;
+  const targetKeys = constantInfo.isScalar(returnRef) ? partial : [.../* @__PURE__ */ new Set(["id", ...partial, "updatedAt"])];
+  const fieldMetaMap = getFieldMetaMap(returnRef);
+  return ` {
+    ${targetKeys.map((key) => fieldMetaMap.get(key)).filter((metadata) => metadata && metadata.fieldType !== "hidden").map(
+    (fieldMeta) => fieldMeta.isClass ? `    ${fieldMeta.key} {
+          ...${lowerlize(getGqlTypeStr(fieldMeta.modelRef))}Fragment
+        }` : `    ${fieldMeta.key}`
+  ).join("\n")}
+      }`;
+};
+const fragmentize = (modelRef, fragMap = /* @__PURE__ */ new Map(), partial) => {
+  const refName = constantInfo.getRefName(modelRef);
+  const fragmentName = `${constantInfo.isLight(modelRef) ? "Light" : ""}${capitalize(refName)}${constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
+  const gqlName = `${capitalize(refName)}${constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
+  const metadatas = getFieldMetas(modelRef);
+  const selectKeys = partial ? ["id", ...partial, "updatedAt"] : metadatas.map((metadata) => metadata.key);
+  const selectKeySet = new Set(selectKeys);
+  const fragment = `fragment ${lowerlize(fragmentName)}Fragment on ${gqlName} {
+` + metadatas.filter((metadata) => metadata.fieldType !== "hidden" && selectKeySet.has(metadata.key)).map((metadata) => {
+    return metadata.isClass ? `  ${metadata.key} {
+    ...${lowerlize(`${constantInfo.isLight(metadata.modelRef) ? "Light" : ""}${capitalize(constantInfo.getRefName(metadata.modelRef))}${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 = constantInfo.getRefName(modelRef);
+  const fragmentName = `${constantInfo.isLight(modelRef) ? "Light" : ""}${capitalize(refName)}${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 = 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;
+}
+export {
+  getGqlStr,
+  graphql,
+  makeFragment
+};

package/esm/src/index.js

@@ -6,6 +6,11 @@ export * from "./doc";
 export * from "./baseFetch";
 export * from "./base.signal";
 export * from "./fetch";
+export * from "./signalInfo";
+export * from "./apiInfo";
+export * from "./sliceInfo";
+export * from "./fetchInfo";
+export * from "./graphql";
 export {
   client,
   immerify

package/esm/src/internalApiInfo.js

@@ -0,0 +1,137 @@
+import { Enum, JSON } from "@akanjs/base";
+import {
+  getGqlMetaMapOnPrototype,
+  getResolveFieldMetaMapOnPrototype,
+  setArgMetas,
+  setGqlMetaMapOnPrototype
+} from "./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 = 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 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 = getGqlMetaMapOnPrototype(sigRef.prototype);
+    metadataMap.set(key, internalApiMeta);
+    setGqlMetaMapOnPrototype(sigRef.prototype, metadataMap);
+    const argMetas = this.args.map((arg, idx) => ({
+      name: arg.name,
+      returns: () => arg.argRef,
+      argsOption: { ...arg.option, enum: arg.argRef instanceof 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
+    }));
+    setArgMetas(sigRef, key, argMetas, internalArgMetas);
+  }
+}
+const makeInternalApiBuilder = () => ({
+  resolveField: (returnRef, signalOption) => new InternalApiInfo(
+    "resolveField",
+    returnRef,
+    signalOption
+  ),
+  interval: (scheduleTime, signalOption) => new InternalApiInfo("interval", JSON, {
+    enabled: true,
+    lock: true,
+    scheduleType: "interval",
+    scheduleTime,
+    ...signalOption
+  }),
+  cron: (scheduleCron, signalOption) => new InternalApiInfo("cron", JSON, {
+    enabled: true,
+    lock: true,
+    scheduleType: "cron",
+    scheduleCron,
+    ...signalOption
+  }),
+  timeout: (timeout, signalOption) => new InternalApiInfo("timeout", JSON, {
+    enabled: true,
+    lock: true,
+    scheduleType: "timeout",
+    scheduleTime: timeout,
+    ...signalOption
+  }),
+  initialize: (signalOption) => new InternalApiInfo("init", JSON, {
+    enabled: true,
+    scheduleType: "init",
+    ...signalOption
+  }),
+  destroy: (signalOption) => new InternalApiInfo("destroy", JSON, {
+    enabled: true,
+    lock: true,
+    scheduleType: "destroy",
+    ...signalOption
+  }),
+  process: (returnRef, signalOption) => new InternalApiInfo("process", returnRef, {
+    serverMode: "all",
+    ...signalOption
+  })
+});
+export {
+  InternalApiInfo,
+  makeInternalApiBuilder
+};

package/esm/src/signalDecorators.js

@@ -1,27 +1,17 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-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);
 import "reflect-metadata";
 import {
   baseEnv,
   getNonArrayModel,
   ID,
-  Int,
   JSON,
   scalarArgMap
 } from "@akanjs/base";
 import { applyMixins, capitalize, lowerlize } from "@akanjs/common";
-import { getClassMeta } from "@akanjs/constant";
-import { makeDefault } from "./gql";
+import { constantInfo } from "@akanjs/constant";
+import { sliceInit } from ".";
+import { makeApiBuilder } from "./apiInfo";
+import { makeInternalApiBuilder } from "./internalApiInfo";
+import { signalInfo } from "./signalInfo";
 const ssoTypes = ["github", "google", "facebook", "apple", "naver", "kakao"];
 class SignalStorage {
 }
@@ -42,7 +32,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"];
@@ -68,50 +58,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 = 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);
-    }
-  };
-}
 const createArgMetaDecorator = (type) => {
   return function(option = {}) {
     return function(prototype, key, idx) {
@@ -338,106 +284,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 {
+  };
+  signalInfo.setRefNameTemp(sigRef, srv.refName);
+  const buildInternal = internalBuilder(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 = getClassMeta(constant.Full);
-  const serviceName = `${lowerlize(meta.refName)}Service`;
-  const [modelName, className] = [lowerlize(meta.refName), 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 {
+  };
+  signalInfo.setRefNameTemp(sigRef, srv.refName);
+  const [modelName, className] = [srv.cnst.refName, 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 = sliceInit(srv.cnst.full, srv.cnst.light, srv.cnst.insight);
+  const { query, mutation } = makeApiBuilder();
+  const buildSlice = {
+    [""]: init("Admin").search("query", JSON).exec(function(query2) {
+      return query2 ?? {};
+    }),
+    ...sliceBuilder(init)
+  };
+  const buildEndpoint = {
+    [names.model]: query(srv.cnst.full, getGuard).param(names.modelId, 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, 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, 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, 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 {
+  };
+  signalInfo.setRefNameTemp(sigRef, srv.refName);
+  const apiInfoMap = builder(makeApiBuilder());
+  Object.entries(apiInfoMap).forEach(([key, apiInfo]) => {
+    apiInfo.applyApiMeta(sigRef, key);
+  });
+  return sigRef;
+}
+const mergeSignals = (signalRef, internalRef, sliceRef) => {
+  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 ? { ...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, () => ID))
-  ], BaseSignal.prototype, _a, 1);
-  __decorateClass([
-    option.guards.get(() => constant.Full),
-    __decorateParam(0, Arg.Param(names.modelId, () => ID))
-  ], BaseSignal.prototype, _b, 1);
-  __decorateClass([
-    Query.Admin(() => [constant.Full]),
-    __decorateParam(0, Arg.Query("query", () => JSON)),
-    __decorateParam(1, Arg.Query("skip", () => Int, { nullable: true, example: 0 })),
-    __decorateParam(2, Arg.Query("limit", () => 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", () => JSON))
-  ], BaseSignal.prototype, _d, 1);
-  __decorateClass([
-    Query.Admin(() => Boolean),
-    __decorateParam(0, Arg.Query("query", () => 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, () => 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, () => ID))
-  ], BaseSignal.prototype, _h, 1);
+  signalInfo.setRefNameTemp(BaseSignal, refName);
+  signalInfo.setPrefixTemp(BaseSignal, option?.prefix ?? "");
   return BaseSignal;
 }
 const getSigMeta = (sigRef) => {
@@ -496,7 +454,7 @@ const setResolveFieldMetaMapOnPrototype = (prototype, resolveFieldMetaMap) => {
   Reflect.defineMetadata("resolveField", resolveFieldMetaMap, prototype);
 };
 const getControllerPrefix = (sigMeta) => {
-  return sigMeta.returns ? lowerlize(getClassMeta(sigMeta.returns()).refName) : sigMeta.prefix;
+  return sigMeta.returns ? 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("/");
@@ -526,9 +484,7 @@ export {
   Access,
   Account,
   Arg,
-  DbSignal,
   Job,
-  LogSignal,
   Me,
   Message,
   Mutation,
@@ -541,7 +497,6 @@ export {
   ResolveField,
   Schedule,
   Self,
-  Signal,
   SignalStorage,
   UserIp,
   Ws,
@@ -551,24 +506,32 @@ export {
   defaultAccount,
   done,
   emit,
+  endpoint,
   endpointTypes,
   getAllSignalRefs,
   getArgMetas,
   getControllerPath,
   getControllerPrefix,
+  getDefaultArg,
   getGqlMeta,
   getGqlMetaMapOnPrototype,
   getGqlMetas,
+  getResolveFieldMetaMapOnPrototype,
   getResolveFieldMetas,
   getSigMeta,
   getSignalRefsOnStorage,
   guardTypes,
+  internal,
   internalArgTypes,
+  mergeSignals,
   resolve,
   roleTypes,
   setArgMetas,
   setGqlMetaMapOnPrototype,
+  setSigMeta,
+  setSignalRefOnStorage,
   signalTypes,
+  slice,
   ssoTypes,
   subscribe
 };