@akanjs/signal 0.9.48 → 0.9.49

package/cjs/src/apiInfo.js

@@ -0,0 +1,167 @@
+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 apiInfo_exports = {};
+__export(apiInfo_exports, {
+  ApiInfo: () => ApiInfo,
+  makeApiBuilder: () => makeApiBuilder
+});
+module.exports = __toCommonJS(apiInfo_exports);
+var import_base = require("@akanjs/base");
+var import_signalDecorators = require("./signalDecorators");
+var import_signalInfo = require("./signalInfo");
+class ApiInfo {
+  type;
+  args = [];
+  internalArgs = [];
+  returnRef;
+  signalOption;
+  guards;
+  execFn = null;
+  constructor(type, returnRef, signalOptionOrGuard, ...guards) {
+    this.type = type;
+    this.returnRef = returnRef;
+    this.signalOption = typeof signalOptionOrGuard === "string" ? {} : signalOptionOrGuard ?? {};
+    this.guards = [
+      .../* @__PURE__ */ new Set([
+        ...guards,
+        ...typeof signalOptionOrGuard === "string" ? [signalOptionOrGuard] : ["Public"]
+      ])
+    ];
+  }
+  param(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: "Param", name, argRef, option });
+    return this;
+  }
+  body(name, argRef, option) {
+    if (this.execFn)
+      throw new Error("Query function is already set");
+    this.args.push({ type: "Body", name, argRef, option });
+    return this;
+  }
+  room(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: "Room", name, argRef, option });
+    return this;
+  }
+  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;
+  }
+  search(name, argRef, option) {
+    if (this.execFn)
+      throw new Error("Query function is already set");
+    this.args.push({ type: "Query", name, argRef, option: { ...option, nullable: true } });
+    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(execFn) {
+    if (this.execFn)
+      throw new Error("Query function is already set");
+    this.execFn = execFn;
+    return this;
+  }
+  static #typeTempMap = {
+    query: "Query",
+    mutation: "Mutation",
+    pubsub: "Pubsub",
+    message: "Message"
+  };
+  applyApiMeta(sigRef, key) {
+    const execFn = this.execFn;
+    if (!execFn)
+      throw new Error("Exec function is not set");
+    import_signalInfo.signalInfo.setHandlerKey(execFn, key);
+    const [singleReturnRef, returnArrDepth] = (0, import_base.getNonArrayModel)(this.returnRef);
+    const apiMeta = {
+      returns: () => (0, import_base.arraiedModel)(
+        singleReturnRef instanceof import_base.Enum ? singleReturnRef.type : singleReturnRef,
+        returnArrDepth
+      ),
+      signalOption: this.signalOption,
+      key,
+      descriptor: { value: this.execFn, writable: true, enumerable: false, configurable: true },
+      guards: this.guards,
+      type: ApiInfo.#typeTempMap[this.type]
+    };
+    sigRef.prototype[key] = this.execFn;
+    const metadataMap = (0, import_signalDecorators.getGqlMetaMapOnPrototype)(sigRef.prototype);
+    metadataMap.set(key, apiMeta);
+    (0, import_signalDecorators.setGqlMetaMapOnPrototype)(sigRef.prototype, metadataMap);
+    const argMetas = this.args.map((arg, idx) => {
+      const [singleArgRef, argArrDepth] = (0, import_base.getNonArrayModel)(arg.argRef);
+      const returnRef = (0, import_base.arraiedModel)(singleArgRef instanceof import_base.Enum ? singleArgRef.type : singleArgRef, argArrDepth);
+      return {
+        name: arg.name,
+        returns: () => returnRef,
+        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: this.args.length + idx,
+      option: arg.option
+    }));
+    (0, import_signalDecorators.setArgMetas)(sigRef, key, argMetas, internalArgMetas);
+  }
+}
+const makeApiBuilder = () => ({
+  query: (returnRef, signalOptionOrGuard, ...guards) => new ApiInfo(
+    "query",
+    returnRef,
+    signalOptionOrGuard,
+    ...guards
+  ),
+  mutation: (returnRef, signalOptionOrGuard, ...guards) => new ApiInfo(
+    "mutation",
+    returnRef,
+    signalOptionOrGuard,
+    ...guards
+  ),
+  pubsub: (returnRef, signalOptionOrGuard, ...guards) => new ApiInfo(
+    "pubsub",
+    returnRef,
+    signalOptionOrGuard,
+    ...guards
+  ),
+  message: (returnRef, signalOptionOrGuard, ...guards) => new ApiInfo(
+    "message",
+    returnRef,
+    signalOptionOrGuard,
+    ...guards
+  )
+});

package/cjs/src/base.signal.js

@@ -15,107 +15,69 @@ 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 base_signal_exports = {};
 __export(base_signal_exports, {
+  BaseEndpoint: () => BaseEndpoint,
+  BaseInternal: () => BaseInternal,
   BaseSignal: () => BaseSignal
 });
 module.exports = __toCommonJS(base_signal_exports);
 var import_base = require("@akanjs/base");
-var import_constant = require("@akanjs/constant");
+var import_dictionary = require("@akanjs/dictionary");
 var import_signalDecorators = require("./signalDecorators");
-let BaseSignal = class extends (0, import_signalDecorators.LogSignal)(import_constant.Srvs) {
-  publishPing() {
+var import_signalInfo = require("./signalInfo");
+const srvBase = { refName: "base" };
+class BaseInternal extends (0, import_signalDecorators.internal)(srvBase, ({ interval }) => ({
+  publishPing: interval(3e3).exec(function() {
     this.baseService.publishPing();
-  }
-  ping() {
-    return (0, import_signalDecorators.resolve)("ping");
-  }
-  pingBody(data) {
-    return (0, import_signalDecorators.resolve)(global.JSON.stringify(data));
-  }
-  pingParam(id) {
-    return (0, import_signalDecorators.resolve)(id);
-  }
-  pingQuery(id) {
-    return (0, import_signalDecorators.resolve)(id);
-  }
-  pingEvery() {
-    return (0, import_signalDecorators.resolve)("pingEvery");
-  }
-  pingUser() {
-    return (0, import_signalDecorators.resolve)("pingUser");
-  }
-  pingAdmin() {
-    return (0, import_signalDecorators.resolve)("pingAdmin");
-  }
-  async cleanup() {
+  })
+})) {
+}
+class BaseEndpoint extends (0, import_signalDecorators.endpoint)(srvBase, ({ query, mutation, message, pubsub }) => ({
+  ping: query(String, { cache: 3e3 }).exec(function() {
+    return "ping";
+  }),
+  pingBody: query(String, { cache: 1e4 }).body("data", String).exec(function() {
+    return "pingBody";
+  }),
+  pingParam: query(String, { cache: 1e4 }).param("id", String).exec(function() {
+    return "pingParam";
+  }),
+  pingQuery: query(String, { nullable: true }).search("id", String).exec(function(id) {
+    return id;
+  }),
+  pingEvery: query(String).exec(function() {
+    return "pingEvery";
+  }),
+  pingUser: query(String).exec(function() {
+    return "pingUser";
+  }),
+  pingAdmin: query(String).exec(function() {
+    return "pingAdmin";
+  }),
+  getDictionary: query(import_base.JSON).param("lang", String).exec(function(lang) {
+    const dictionary = (0, import_dictionary.getDictionary)(lang);
+    return dictionary;
+  }),
+  getAllDictionary: query(import_base.JSON).exec(function() {
+    const dictionary = (0, import_dictionary.getAllDictionary)();
+    return dictionary;
+  }),
+  cleanup: mutation(Boolean).exec(async function() {
     if (process.env.NODE_ENV !== "test")
       throw new Error("cleanup is only available in test environment");
     await this.baseService.cleanup();
-    return (0, import_signalDecorators.resolve)(true);
-  }
-  wsPing(data) {
-    return (0, import_signalDecorators.emit)(data);
-  }
-  pubsubPing() {
-    return (0, import_signalDecorators.subscribe)();
-  }
-  getDictionary(lang) {
-    const dictionary = this.baseService.getDictionary(lang);
-    return (0, import_signalDecorators.resolve)(dictionary);
-  }
-};
-__decorateClass([
-  import_signalDecorators.Schedule.Interval(3e3)
-], BaseSignal.prototype, "publishPing", 1);
-__decorateClass([
-  import_signalDecorators.Query.Public(() => String, { cache: 3e3 })
-], BaseSignal.prototype, "ping", 1);
-__decorateClass([
-  import_signalDecorators.Query.Public(() => String, { cache: 1e4 }),
-  __decorateParam(0, import_signalDecorators.Arg.Body("data", () => import_base.JSON))
-], BaseSignal.prototype, "pingBody", 1);
-__decorateClass([
-  import_signalDecorators.Query.Public(() => String, { cache: 1e4 }),
-  __decorateParam(0, import_signalDecorators.Arg.Param("id", () => String))
-], BaseSignal.prototype, "pingParam", 1);
-__decorateClass([
-  import_signalDecorators.Query.Public(() => String),
-  __decorateParam(0, import_signalDecorators.Arg.Query("id", () => String))
-], BaseSignal.prototype, "pingQuery", 1);
-__decorateClass([
-  import_signalDecorators.Query.Every(() => String)
-], BaseSignal.prototype, "pingEvery", 1);
-__decorateClass([
-  import_signalDecorators.Query.User(() => String)
-], BaseSignal.prototype, "pingUser", 1);
-__decorateClass([
-  import_signalDecorators.Query.Admin(() => String)
-], BaseSignal.prototype, "pingAdmin", 1);
-__decorateClass([
-  import_signalDecorators.Mutation.Public(() => Boolean)
-], BaseSignal.prototype, "cleanup", 1);
-__decorateClass([
-  import_signalDecorators.Message.Public(() => String),
-  __decorateParam(0, import_signalDecorators.Arg.Msg("data", () => String))
-], BaseSignal.prototype, "wsPing", 1);
-__decorateClass([
-  import_signalDecorators.Pubsub.Public(() => String)
-], BaseSignal.prototype, "pubsubPing", 1);
-__decorateClass([
-  import_signalDecorators.Query.Public(() => import_base.JSON),
-  __decorateParam(0, import_signalDecorators.Arg.Param("lang", () => String))
-], BaseSignal.prototype, "getDictionary", 1);
-BaseSignal = __decorateClass([
-  (0, import_signalDecorators.Signal)({ name: "Base" })
-], BaseSignal);
+    return true;
+  }),
+  wsPing: message(String).exec(function() {
+    return "wsPing";
+  }),
+  pubsubPing: pubsub(String).exec(function() {
+  }),
+  getSignals: query(import_base.JSON).exec(function() {
+    return import_signalInfo.signalInfo.serializedSignals;
+  })
+})) {
+}
+class BaseSignal extends (0, import_signalDecorators.mergeSignals)(BaseEndpoint, BaseInternal) {
+}

package/cjs/src/baseFetch.js

@@ -21,8 +21,7 @@ __export(baseFetch_exports, {
 });
 module.exports = __toCommonJS(baseFetch_exports);
 var import_client = require("./client");
-const nativeFetch = fetch;
-const baseFetch = Object.assign(nativeFetch, {
+const baseFetch = Object.assign(global.fetch, {
   client: import_client.client,
   clone: function(option = {}) {
     return {

package/cjs/src/fetch.js

@@ -23,6 +23,8 @@ module.exports = __toCommonJS(fetch_exports);
 var import_base = require("./base.signal");
 var import_baseFetch = require("./baseFetch");
 var import_gql = require("./gql");
+var import_signalInfo = require("./signalInfo");
+import_signalInfo.signalInfo.registerSignals(import_base.BaseSignal);
 const fetch = (0, import_gql.makeFetch)(import_baseFetch.baseFetch, {
   ...(0, import_gql.fetchOf)(import_base.BaseSignal)
 });