@akanjs/signal 0.9.47 → 0.9.49

package/cjs/src/signalInfo.js

@@ -0,0 +1,185 @@
+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 signalInfo_exports = {};
+__export(signalInfo_exports, {
+  signalInfo: () => signalInfo
+});
+module.exports = __toCommonJS(signalInfo_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constant = require("@akanjs/constant");
+var import_client = require("./client");
+var import_fetchInfo = require("./fetchInfo");
+var import_signalDecorators = require("./signalDecorators");
+const signalInfo = {
+  database: /* @__PURE__ */ new Map(),
+  service: /* @__PURE__ */ new Map(),
+  serializedSignals: [],
+  setDatabase(refName, signal) {
+    signalInfo.database.set(refName, signal);
+  },
+  getDatabase(refName) {
+    return signalInfo.database.get(refName);
+  },
+  setRefNameTemp(sigRef, refName) {
+    Reflect.defineMetadata("signal:refName", refName, sigRef.prototype);
+  },
+  getRefNameTemp(sigRef) {
+    const refName = Reflect.getMetadata("signal:refName", sigRef.prototype);
+    if (!refName)
+      throw new Error("RefName Not Found");
+    return refName;
+  },
+  setPrefixTemp(sigRef, prefix) {
+    Reflect.defineMetadata("signal:prefix", prefix, sigRef.prototype);
+  },
+  getPrefixTemp(sigRef) {
+    const prefix = Reflect.getMetadata("signal:prefix", sigRef.prototype);
+    return prefix;
+  },
+  setHandlerKey(execFn, key) {
+    Reflect.defineMetadata("signal:key", key, execFn);
+  },
+  getHandlerKey(execFn) {
+    const key = Reflect.getMetadata("signal:key", execFn);
+    if (!key)
+      throw new Error("Handler key not found");
+    return key;
+  },
+  setService(refName, signal) {
+    signalInfo.service.set(refName, signal);
+  },
+  getService(refName) {
+    return signalInfo.service.get(refName);
+  },
+  registerSignals(...signals) {
+    signals.forEach((sigRef) => {
+      const refName = signalInfo.getRefNameTemp(sigRef);
+      const signalType = import_constant.constantInfo.database.has(refName) ? "database" : "service";
+      if (signalType === "database")
+        signalInfo.setDatabase(refName, sigRef);
+      else
+        signalInfo.setService(refName, sigRef);
+    });
+    signals.forEach((sigRef) => {
+      const refName = signalInfo.getRefNameTemp(sigRef);
+      const prefix = signalInfo.getPrefixTemp(sigRef);
+      const databaseCnst = import_constant.constantInfo.getDatabase(refName, { allowEmpty: true });
+      const scalarCnst = import_constant.constantInfo.getScalar(refName, { allowEmpty: true });
+      if (databaseCnst) {
+        const gqlMetas = (0, import_signalDecorators.getGqlMetas)(sigRef);
+        const modelName = 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 import_constant.constantInfo.getRefName(retRef) === refName && arrDepth === 1;
+          }).map((gqlMeta) => {
+            const name = gqlMeta.signalOption.name ?? gqlMeta.key;
+            const sliceName = name.replace(listName, `${modelName}In`);
+            const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, 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 : (0, import_signalDecorators.getDefaultArg)(queryArgRef)
+            );
+            return { refName: modelName, sliceName, argLength, defaultArgs };
+          })
+        ];
+        (0, import_signalDecorators.setSigMeta)(sigRef, { returns: () => databaseCnst.full, prefix, slices, refName: modelName, enabled: true });
+        (0, import_signalDecorators.setSignalRefOnStorage)(modelName, sigRef);
+      } else if (scalarCnst) {
+        (0, import_signalDecorators.setSigMeta)(sigRef, { returns: () => scalarCnst.model, prefix, slices: [], refName, enabled: true });
+        (0, import_signalDecorators.setSignalRefOnStorage)(refName, sigRef);
+      } else {
+        (0, import_signalDecorators.setSigMeta)(sigRef, { returns: void 0, prefix, slices: [], refName, enabled: true });
+        (0, import_signalDecorators.setSignalRefOnStorage)(refName, sigRef);
+      }
+    });
+    return signals;
+  },
+  serialize(sigRef) {
+    const refName = signalInfo.getRefNameTemp(sigRef);
+    const { slices, prefix } = (0, import_signalDecorators.getSigMeta)(sigRef);
+    const gqlMetaMap = (0, import_signalDecorators.getGqlMetaMapOnPrototype)(sigRef.prototype);
+    const serializedSignal = { refName, slices, prefix, endpoint: {} };
+    gqlMetaMap.forEach((gqlMeta, key) => {
+      if (!["Query", "Mutation", "Pubsub", "Message"].includes(gqlMeta.type))
+        return;
+      const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, key);
+      const [returnRef, arrDepth] = (0, import_base.getNonArrayModel)(gqlMeta.returns());
+      const isGqlScalar = import_base.scalarNameMap.has(returnRef);
+      const modelType = isGqlScalar ? "scalar" : import_constant.constantInfo.getModelType(returnRef);
+      if (!["input", "full", "light", "insight", "scalar"].includes(modelType))
+        throw new Error(`Invalid model type: ${modelType}`);
+      const refName2 = isGqlScalar ? import_base.scalarNameMap.get(returnRef) : import_constant.constantInfo.getRefName(returnRef);
+      serializedSignal.endpoint[key] = {
+        type: (0, import_common.lowerlize)(gqlMeta.type),
+        signalOption: gqlMeta.signalOption,
+        returns: { refName: refName2, modelType, arrDepth },
+        args: argMetas.map((argMeta) => {
+          const [argRef, arrDepth2] = (0, import_base.getNonArrayModel)(argMeta.returns());
+          const isGqlScalar2 = import_base.scalarNameMap.has(argRef);
+          const modelType2 = isGqlScalar2 ? "scalar" : import_constant.constantInfo.getModelType(argRef);
+          if (!["input", "insight", "scalar"].includes(modelType2))
+            throw new Error(`Invalid model type: ${modelType2}`);
+          const refName3 = isGqlScalar2 ? import_base.scalarNameMap.get(argRef) : import_constant.constantInfo.getRefName(argRef);
+          return {
+            type: argMeta.type,
+            refName: refName3,
+            modelType: modelType2,
+            name: argMeta.name,
+            argsOption: argMeta.argsOption,
+            arrDepth: arrDepth2
+          };
+        })
+      };
+    });
+    return serializedSignal;
+  },
+  initialize() {
+    const databaseSignals = [...signalInfo.database.values()].map((sigRef) => signalInfo.serialize(sigRef));
+    const serviceSignals = [...signalInfo.service.values()].map((sigRef) => signalInfo.serialize(sigRef));
+    signalInfo.serializedSignals = [...databaseSignals, ...serviceSignals];
+    return signalInfo.buildFetch(signalInfo.serializedSignals);
+  },
+  buildFetch(signals = [], cnstInfo = import_constant.constantInfo) {
+    const databaseSignals = signals.filter((signal) => cnstInfo.database.has(signal.refName));
+    const serviceSignals = signals.filter((signal) => !cnstInfo.database.has(signal.refName));
+    const fetchComponent = Object.assign(
+      { client: import_client.client },
+      ...databaseSignals.map((signal) => (0, import_fetchInfo.databaseFetchOf)(signal)),
+      ...serviceSignals.map((signal) => (0, import_fetchInfo.serviceFetchOf)(signal))
+    );
+    return Object.assign(global.fetch, fetchComponent);
+  },
+  registerClient: async (cnst) => {
+    const [signals] = await Promise.all([
+      (async () => await (await global.fetch(`${import_base.baseClientEnv.serverHttpUri}/getSignals`)).json())()
+    ]);
+    signalInfo.buildFetch(signals);
+    return { fetch, signals };
+  }
+};

package/cjs/src/sliceInfo.js

@@ -0,0 +1,193 @@
+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 sliceInfo_exports = {};
+__export(sliceInfo_exports, {
+  SliceInfo: () => SliceInfo,
+  sliceInit: () => sliceInit
+});
+module.exports = __toCommonJS(sliceInfo_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_signalDecorators = require("./signalDecorators");
+var import_signalInfo = require("./signalInfo");
+class SliceInfo {
+  full;
+  light;
+  insight;
+  args = [];
+  internalArgs = [];
+  signalOption;
+  guards;
+  execFn = null;
+  constructor(full, light, insight, signalOptionOrGuard, ...guards) {
+    this.full = full;
+    this.light = light;
+    this.insight = insight;
+    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");
+    else if (this.args.at(-1)?.option?.nullable)
+      throw new Error("Last argument is nullable");
+    this.args.push({ type: "Body", 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(query) {
+    if (this.execFn)
+      throw new Error("Query function is already set");
+    this.execFn = query;
+    return this;
+  }
+  applySliceMeta(refName, sigRef, key) {
+    if (!this.execFn)
+      throw new Error("Query function is not set");
+    const execFn = this.execFn;
+    const serviceName = `${refName}Service`;
+    const argLength = this.args.length;
+    const gqlMetaMap = (0, import_signalDecorators.getGqlMetaMapOnPrototype)(sigRef.prototype);
+    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 skipLimitSortArgMetas = [
+      {
+        name: "skip",
+        returns: () => import_base.Int,
+        argsOption: { nullable: true, example: 0 },
+        key,
+        idx: argLength,
+        type: "Query"
+      },
+      {
+        name: "limit",
+        returns: () => import_base.Int,
+        argsOption: { nullable: true, example: 20 },
+        key,
+        idx: argLength + 1,
+        type: "Query"
+      },
+      {
+        name: "sort",
+        returns: () => String,
+        argsOption: { nullable: true, example: "latest" },
+        key,
+        idx: argLength + 2,
+        type: "Query"
+      }
+    ];
+    const internalArgMetas = this.internalArgs.map((arg, idx) => ({
+      type: arg.type,
+      key,
+      idx,
+      option: arg.option
+    }));
+    const listKey = `${refName}List${(0, import_common.capitalize)(key)}`;
+    const listFn = async function(...requestArgs) {
+      const args = requestArgs.slice(0, argLength);
+      const skipLimitSort = requestArgs.slice(argLength, argLength + 3);
+      const [skip = 0, limit = 20, sort = "latest"] = skipLimitSort;
+      const internalArgs = requestArgs.slice(argLength + 3);
+      const query = execFn.apply(this, [...args, ...internalArgs]);
+      return await this[serviceName].__list(query, {
+        skip,
+        limit,
+        sort
+      });
+    };
+    import_signalInfo.signalInfo.setHandlerKey(listFn, listKey);
+    sigRef.prototype[listKey] = listFn;
+    const listApiMeta = {
+      returns: () => [this.full],
+      signalOption: this.signalOption,
+      key: listKey,
+      descriptor: { value: listFn, writable: true, enumerable: false, configurable: true },
+      guards: this.guards,
+      type: "Query"
+    };
+    gqlMetaMap.set(listKey, listApiMeta);
+    (0, import_signalDecorators.setArgMetas)(
+      sigRef,
+      listKey,
+      [...argMetas, ...skipLimitSortArgMetas],
+      internalArgMetas.map((argMeta, idx) => ({ ...argMeta, idx: argLength + 3 + idx }))
+    );
+    const insightKey = `${refName}Insight${(0, import_common.capitalize)(key)}`;
+    const insightFn = async function(...requestArgs) {
+      const args = requestArgs.slice(0, argLength);
+      const internalArgs = requestArgs.slice(argLength);
+      const query = execFn.apply(this, [...args, ...internalArgs]);
+      return await this[serviceName].__insight(
+        query
+      );
+    };
+    import_signalInfo.signalInfo.setHandlerKey(insightFn, insightKey);
+    sigRef.prototype[insightKey] = insightFn;
+    const insightApiMeta = {
+      returns: () => this.insight,
+      signalOption: this.signalOption,
+      key: insightKey,
+      descriptor: { value: insightFn, writable: true, enumerable: false, configurable: true },
+      guards: this.guards,
+      type: "Query"
+    };
+    gqlMetaMap.set(insightKey, insightApiMeta);
+    (0, import_signalDecorators.setArgMetas)(
+      sigRef,
+      insightKey,
+      argMetas,
+      internalArgMetas.map((argMeta, idx) => ({ ...argMeta, idx: argLength + idx }))
+    );
+    (0, import_signalDecorators.setGqlMetaMapOnPrototype)(sigRef.prototype, gqlMetaMap);
+  }
+}
+const sliceInit = (full, light, insight) => (signalOptionOrGuard, ...guards) => new SliceInfo(full, light, insight, signalOptionOrGuard, ...guards);

package/esm/src/apiInfo.js

@@ -0,0 +1,152 @@
+import { arraiedModel, Enum, getNonArrayModel } from "@akanjs/base";
+import {
+  getGqlMetaMapOnPrototype,
+  setArgMetas,
+  setGqlMetaMapOnPrototype
+} from "./signalDecorators";
+import { signalInfo } from "./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");
+    signalInfo.setHandlerKey(execFn, key);
+    const [singleReturnRef, returnArrDepth] = getNonArrayModel(this.returnRef);
+    const apiMeta = {
+      returns: () => arraiedModel(
+        singleReturnRef instanceof 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 = getGqlMetaMapOnPrototype(sigRef.prototype);
+    metadataMap.set(key, apiMeta);
+    setGqlMetaMapOnPrototype(sigRef.prototype, metadataMap);
+    const argMetas = this.args.map((arg, idx) => {
+      const [singleArgRef, argArrDepth] = getNonArrayModel(arg.argRef);
+      const returnRef = arraiedModel(singleArgRef instanceof Enum ? singleArgRef.type : singleArgRef, argArrDepth);
+      return {
+        name: arg.name,
+        returns: () => returnRef,
+        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: this.args.length + idx,
+      option: arg.option
+    }));
+    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
+  )
+});
+export {
+  ApiInfo,
+  makeApiBuilder
+};