@akanjs/signal 0.9.47 → 0.9.49

package/esm/src/base.signal.js

@@ -1,116 +1,64 @@
-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 { JSON } from "@akanjs/base";
-import { Srvs } from "@akanjs/constant";
-import {
-  Arg,
-  emit,
-  LogSignal,
-  Message,
-  Mutation,
-  Pubsub,
-  Query,
-  resolve,
-  Schedule,
-  Signal,
-  subscribe
-} from "./signalDecorators";
-let BaseSignal = class extends LogSignal(Srvs) {
-  publishPing() {
+import { getAllDictionary, getDictionary } from "@akanjs/dictionary";
+import { endpoint, internal, mergeSignals } from "./signalDecorators";
+import { signalInfo } from "./signalInfo";
+const srvBase = { refName: "base" };
+class BaseInternal extends internal(srvBase, ({ interval }) => ({
+  publishPing: interval(3e3).exec(function() {
     this.baseService.publishPing();
-  }
-  ping() {
-    return resolve("ping");
-  }
-  pingBody(data) {
-    return resolve(global.JSON.stringify(data));
-  }
-  pingParam(id) {
-    return resolve(id);
-  }
-  pingQuery(id) {
-    return resolve(id);
-  }
-  pingEvery() {
-    return resolve("pingEvery");
-  }
-  pingUser() {
-    return resolve("pingUser");
-  }
-  pingAdmin() {
-    return resolve("pingAdmin");
-  }
-  async cleanup() {
+  })
+})) {
+}
+class BaseEndpoint extends 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(JSON).param("lang", String).exec(function(lang) {
+    const dictionary = getDictionary(lang);
+    return dictionary;
+  }),
+  getAllDictionary: query(JSON).exec(function() {
+    const 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 resolve(true);
-  }
-  wsPing(data) {
-    return emit(data);
-  }
-  pubsubPing() {
-    return subscribe();
-  }
-  getDictionary(lang) {
-    const dictionary = this.baseService.getDictionary(lang);
-    return resolve(dictionary);
-  }
-};
-__decorateClass([
-  Schedule.Interval(3e3)
-], BaseSignal.prototype, "publishPing", 1);
-__decorateClass([
-  Query.Public(() => String, { cache: 3e3 })
-], BaseSignal.prototype, "ping", 1);
-__decorateClass([
-  Query.Public(() => String, { cache: 1e4 }),
-  __decorateParam(0, Arg.Body("data", () => JSON))
-], BaseSignal.prototype, "pingBody", 1);
-__decorateClass([
-  Query.Public(() => String, { cache: 1e4 }),
-  __decorateParam(0, Arg.Param("id", () => String))
-], BaseSignal.prototype, "pingParam", 1);
-__decorateClass([
-  Query.Public(() => String),
-  __decorateParam(0, Arg.Query("id", () => String))
-], BaseSignal.prototype, "pingQuery", 1);
-__decorateClass([
-  Query.Every(() => String)
-], BaseSignal.prototype, "pingEvery", 1);
-__decorateClass([
-  Query.User(() => String)
-], BaseSignal.prototype, "pingUser", 1);
-__decorateClass([
-  Query.Admin(() => String)
-], BaseSignal.prototype, "pingAdmin", 1);
-__decorateClass([
-  Mutation.Public(() => Boolean)
-], BaseSignal.prototype, "cleanup", 1);
-__decorateClass([
-  Message.Public(() => String),
-  __decorateParam(0, Arg.Msg("data", () => String))
-], BaseSignal.prototype, "wsPing", 1);
-__decorateClass([
-  Pubsub.Public(() => String)
-], BaseSignal.prototype, "pubsubPing", 1);
-__decorateClass([
-  Query.Public(() => JSON),
-  __decorateParam(0, Arg.Param("lang", () => String))
-], BaseSignal.prototype, "getDictionary", 1);
-BaseSignal = __decorateClass([
-  Signal({ name: "Base" })
-], BaseSignal);
+    return true;
+  }),
+  wsPing: message(String).exec(function() {
+    return "wsPing";
+  }),
+  pubsubPing: pubsub(String).exec(function() {
+  }),
+  getSignals: query(JSON).exec(function() {
+    return signalInfo.serializedSignals;
+  })
+})) {
+}
+class BaseSignal extends mergeSignals(BaseEndpoint, BaseInternal) {
+}
 export {
+  BaseEndpoint,
+  BaseInternal,
   BaseSignal
 };

package/esm/src/baseFetch.js

@@ -1,6 +1,5 @@
 import { client } from "./client";
-const nativeFetch = fetch;
-const baseFetch = Object.assign(nativeFetch, {
+const baseFetch = Object.assign(global.fetch, {
   client,
   clone: function(option = {}) {
     return {

package/esm/src/fetch.js

@@ -1,6 +1,8 @@
 import { BaseSignal } from "./base.signal";
 import { baseFetch } from "./baseFetch";
 import { fetchOf, makeFetch } from "./gql";
+import { signalInfo } from "./signalInfo";
+signalInfo.registerSignals(BaseSignal);
 const fetch = makeFetch(baseFetch, {
   ...fetchOf(BaseSignal)
 });

package/esm/src/fetchInfo.js

@@ -0,0 +1,345 @@
+import { DataList, dayjs, isGqlScalar } from "@akanjs/base";
+import { capitalize, Logger, lowerlize } from "@akanjs/common";
+import { constantInfo, makeCrystalize, serializeArg } from "@akanjs/constant";
+import { mutate, query, setGqlOnStorage } from "./gql";
+import { getGqlStr, graphql } from "./graphql";
+const serviceFetchOf = (signal) => {
+  const fetch = {};
+  Object.entries(signal.endpoint).forEach(([key, endpoint]) => {
+    const returnRef = constantInfo.getModelRef(endpoint.returns.refName, endpoint.returns.modelType);
+    const isScalar = isGqlScalar(returnRef);
+    if (endpoint.type === "message") {
+      const emitEvent = function(...args) {
+        const fetchPolicy = args[endpoint.args.length] ?? { crystalize: true };
+        if (!this.client.io && !fetchPolicy.url) {
+          Logger.warn(`${key} emit suppressed - socket is not connected`);
+          return;
+        }
+        const message = Object.fromEntries(
+          endpoint.args.map((arg, idx) => {
+            const argRef = constantInfo.getModelRef(arg.refName, arg.modelType);
+            return [arg.name, serializeArg(argRef, arg.arrDepth, args[idx], arg.argsOption) ?? null];
+          })
+        );
+        if (fetchPolicy.transport === "udp") {
+          if (!this.client.udp)
+            throw new Error("UDP is not set");
+          const uri = fetchPolicy.url ?? "udpout:localhost:4000";
+          const [host, port] = uri.split(":").slice(1);
+          this.client.udp.send(JSON.stringify(message), parseInt(port), host);
+          Logger.debug(`udp emit: ${key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          return;
+        } else {
+          const io = this.client.getIo(fetchPolicy.url);
+          void this.client.waitUntilWebSocketConnected(fetchPolicy.url).then(() => {
+            io.emit(key, message);
+            Logger.debug(`socket emit: ${key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          });
+        }
+      };
+      const listenEvent = function(handleEvent, fetchPolicy = {}) {
+        const crystalize = (data) => {
+          if (isScalar) {
+            if (returnRef.prototype === Date.prototype)
+              return dayjs(data);
+            else
+              return data;
+          } else if (Array.isArray(data))
+            return data.map((d) => crystalize(d));
+          else
+            return makeCrystalize(returnRef)(data);
+        };
+        const handle = (data) => {
+          Logger.debug(`socket listened: ${key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          handleEvent(crystalize(data));
+        };
+        const io = this.client.getIo(fetchPolicy.url);
+        this.client.waitUntilWebSocketConnected(fetchPolicy.url).then(() => {
+          io.removeListener(key, handle);
+          io.on(key, handle);
+          Logger.debug(`socket listen start: ${key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+        });
+        return async () => {
+          await this.client.waitUntilWebSocketConnected(fetchPolicy.url);
+          Logger.debug(`socket listen end: ${key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          io.removeListener(key, handle);
+        };
+      };
+      fetch[key] = emitEvent;
+      fetch[`listen${capitalize(key)}`] = listenEvent;
+    } else if (endpoint.type === "pubsub") {
+      const makeRoomId = (gqlKey, argValues) => `${gqlKey}-${argValues.join("-")}`;
+      const crystalize = (data) => {
+        if (isScalar) {
+          if (returnRef.prototype === Date.prototype)
+            return dayjs(data);
+          else
+            return data;
+        } else if (Array.isArray(data))
+          return data.map((d) => crystalize(d));
+        else
+          return makeCrystalize(returnRef)(data);
+      };
+      const subscribeEvent = function(...args) {
+        const onData = args[endpoint.args.length];
+        const fetchPolicy = args[endpoint.args.length + 1] ?? { crystalize: true };
+        const message = Object.fromEntries(
+          endpoint.args.map((arg, idx) => {
+            const argRef = constantInfo.getModelRef(arg.refName, arg.modelType);
+            return [arg.name, serializeArg(argRef, arg.arrDepth, args[idx], arg.argsOption) ?? null];
+          })
+        );
+        const handleEvent = (data) => {
+          if (data.__subscribe__)
+            return;
+          onData(crystalize(data));
+        };
+        const roomId = makeRoomId(
+          key,
+          endpoint.args.map((arg) => message[arg.name])
+        );
+        const io = this.client.getIo(fetchPolicy.url);
+        void this.client.waitUntilWebSocketConnected(fetchPolicy.url).then(() => {
+          Logger.debug(`socket subscribe start: ${key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          io.subscribe({ key, roomId, message, handleEvent });
+        });
+        return async () => {
+          //! 앱에서 다른 앱 넘어갈 때 언마운트 되버리면서 subscribe가 끊기는 일이 있음.
+          await this.client.waitUntilWebSocketConnected(fetchPolicy.url);
+          Logger.debug(`socket unsubscribe: ${key}: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          io.unsubscribe(roomId, handleEvent);
+        };
+      };
+      fetch[`subscribe${capitalize(key)}`] = subscribeEvent;
+    } else if (["query", "mutation"].includes(endpoint.type)) {
+      const name = endpoint.signalOption?.name ?? key;
+      const makeReq = ({ resolve }) => async function(...args) {
+        Logger.debug(`fetch: ${key} start: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+        const now = Date.now();
+        const lightenedReturnRef = isScalar || endpoint.returns.arrDepth === 0 ? returnRef : endpoint.returns.modelType === "full" ? constantInfo.getDatabase(endpoint.returns.refName).light : returnRef;
+        const fetchPolicy = args[endpoint.args.length] ?? { crystalize: true };
+        const partial = fetchPolicy.partial ?? endpoint.signalOption?.partial;
+        const crystalize = (data) => {
+          if (fetchPolicy.crystalize === false)
+            return data;
+          if (isScalar) {
+            if (lightenedReturnRef.prototype === Date.prototype)
+              return dayjs(data);
+            else
+              return data;
+          } else if (Array.isArray(data))
+            return data.map((d) => crystalize(d));
+          else
+            return makeCrystalize(lightenedReturnRef, { partial })(data);
+        };
+        try {
+          const res = (await (endpoint.type === "query" ? query : mutate)(
+            this.client,
+            graphql(getGqlStr(returnRef, key, endpoint, lightenedReturnRef, partial)),
+            Object.fromEntries(
+              endpoint.args.map((arg, idx) => {
+                const argRef = constantInfo.getModelRef(arg.refName, arg.modelType);
+                return [arg.name, serializeArg(argRef, arg.arrDepth, args[idx], arg.argsOption) ?? null];
+              })
+            ),
+            fetchPolicy
+          ))[name];
+          const data = resolve ? crystalize(res) : res;
+          Logger.debug(`fetch: ${key} end: ${dayjs().format("YYYY-MM-DD HH:mm:ss.SSS")} ${Date.now() - now}ms`);
+          return data;
+        } catch (e) {
+          Logger.error(`fetch: ${key} error: ${e}`);
+          throw e;
+        }
+      };
+      const reqFn = makeReq({ resolve: true });
+      const reqFnWithoutResolve = makeReq({ resolve: false });
+      fetch[name] = async function(...args) {
+        return await reqFn.apply(this, args);
+      };
+      fetch[`_${name}`] = async function(...args) {
+        return await reqFnWithoutResolve.apply(this, args);
+      };
+    } else
+      throw new Error(`Invalid endpoint type: ${endpoint.type}`);
+  });
+  return fetch;
+};
+const databaseFetchOf = (signal, option = {}) => {
+  const cnst = constantInfo.getDatabase(signal.refName);
+  const [fieldName, className] = [lowerlize(signal.refName), capitalize(signal.refName)];
+  const names = {
+    refName: signal.refName,
+    model: fieldName,
+    Model: className,
+    _model: `_${fieldName}`,
+    lightModel: `light${className}`,
+    _lightModel: `_light${className}`,
+    defaultModel: `default${className}`,
+    defaultModelInsight: `default${className}Insight`,
+    mergeModel: `merge${className}`,
+    viewModel: `view${className}`,
+    getModelView: `get${className}View`,
+    modelView: `${fieldName}View`,
+    modelViewAt: `${fieldName}ViewAt`,
+    editModel: `edit${className}`,
+    getModelEdit: `get${className}Edit`,
+    modelEdit: `${fieldName}Edit`,
+    listModel: `list${className}`,
+    modelList: `${fieldName}List`,
+    modelObjList: `${fieldName}ObjList`,
+    modelInsight: `${fieldName}Insight`,
+    modelObjInsight: `${fieldName}ObjInsight`,
+    updateModel: `update${className}`,
+    modelObj: `${fieldName}Obj`,
+    _modelList: `_${fieldName}List`,
+    modelInit: `${fieldName}Init`,
+    pageOfModel: `pageOf${className}`,
+    lastPageOfModel: `lastPageOf${className}`,
+    limitOfModel: `limitOf${className}`,
+    queryArgsOfModel: `queryArgsOf${className}`,
+    sortOfModel: `sortOf${className}`,
+    modelInitAt: `${fieldName}InitAt`,
+    initModel: `init${className}`,
+    getModelInit: `get${className}Init`,
+    addModelFiles: `add${className}Files`,
+    addFiles: `addFiles`
+  };
+  const fetch = serviceFetchOf(signal);
+  const util = {
+    [names.addModelFiles]: async (files, id, option2) => {
+      const metas = Array.from(files).map((file) => ({ lastModifiedAt: new Date(file.lastModified), size: file.size }));
+      //! will not work properly
+      return await global.builtFetch[names.addFiles](
+        files,
+        metas,
+        names.model,
+        id,
+        option2
+      );
+    },
+    [names.mergeModel]: async (modelOrId, data, option2) => {
+      const model = typeof modelOrId === "string" ? await global.builtFetch[names._model](modelOrId) : modelOrId;
+      const input = cnst.purify({ ...model, ...data });
+      if (!input)
+        throw new Error("Error");
+      return await global.builtFetch[names.updateModel](model.id, input, option2);
+    },
+    [names.viewModel]: async (id, option2) => {
+      const modelObj = await global.builtFetch[names._model](id, option2);
+      return {
+        [names.model]: cnst.crystalize(modelObj),
+        [names.modelView]: {
+          refName: names.model,
+          [names.modelObj]: modelObj,
+          [names.modelViewAt]: /* @__PURE__ */ new Date()
+        }
+      };
+    },
+    [names.getModelView]: async (id, option2) => {
+      const modelView = await global.builtFetch[names._model](id, option2);
+      return {
+        refName: names.model,
+        [names.modelObj]: modelView,
+        [names.modelViewAt]: /* @__PURE__ */ new Date()
+      };
+    },
+    [names.editModel]: async (id, option2) => {
+      const modelObj = await global.builtFetch[names._model](id, option2);
+      return {
+        [names.model]: cnst.crystalize(modelObj),
+        [names.modelEdit]: {
+          refName: names.model,
+          [names.modelObj]: modelObj,
+          [names.modelViewAt]: /* @__PURE__ */ new Date()
+        }
+      };
+    },
+    [names.getModelEdit]: async (id, option2) => {
+      const modelEdit = await global.builtFetch[names.editModel](id, option2);
+      return modelEdit[names.modelEdit];
+    }
+  };
+  const sliceUtil = Object.fromEntries(
+    signal.slices.reduce((acc, { sliceName, argLength, defaultArgs }) => {
+      const namesOfSlice = {
+        modelList: sliceName.replace(names.model, names.modelList),
+        // modelListInSelf
+        modelInsight: sliceName.replace(names.model, names.modelInsight),
+        // modelInsightInSelf
+        modelInit: sliceName.replace(names.model, names.modelInit),
+        // modelInitInSelf
+        initModel: sliceName.replace(names.model, names.initModel),
+        // initModelInSelf
+        getModelInit: sliceName.replace(names.model, names.getModelInit)
+        // getModelInitInSelf
+      };
+      const getInitFn = async (...args) => {
+        const queryArgLength = Math.min(args.length, argLength);
+        const queryArgs = [
+          ...new Array(queryArgLength).fill(null).map((_, i) => args[i]),
+          ...queryArgLength < argLength ? new Array(argLength - queryArgLength).fill(null).map((_, i) => defaultArgs[i + queryArgLength] ?? null) : []
+        ];
+        const fetchInitOption = args[argLength] ?? {};
+        const { page = 1, limit = 20, sort = "latest", insight } = fetchInitOption;
+        const skip = (page - 1) * limit;
+        const [modelObjList, modelObjInsight] = await Promise.all([
+          global.builtFetch[`_${namesOfSlice.modelList}`](
+            ...queryArgs,
+            skip,
+            limit,
+            sort,
+            fetchInitOption
+          ),
+          global.builtFetch[`_${namesOfSlice.modelInsight}`](
+            ...queryArgs,
+            fetchInitOption
+          )
+        ]);
+        const count = modelObjInsight.count;
+        return {
+          // Client Component용
+          refName: names.model,
+          sliceName,
+          argLength,
+          [names.modelObjList]: modelObjList,
+          [names.modelObjInsight]: modelObjInsight,
+          [names.pageOfModel]: page,
+          [names.lastPageOfModel]: Math.max(Math.floor((count - 1) / limit) + 1, 1),
+          [names.limitOfModel]: limit,
+          [names.queryArgsOfModel]: JSON.parse(JSON.stringify(queryArgs)),
+          [names.sortOfModel]: sort,
+          [names.modelInitAt]: /* @__PURE__ */ new Date()
+        };
+      };
+      const initFn = async function(...args) {
+        const modelInit = await getInitFn(...args);
+        const modelObjList = modelInit[names.modelObjList];
+        const modelObjInsight = modelInit[names.modelObjInsight];
+        const modelList = new DataList(
+          modelObjList.map((modelObj) => cnst.lightCrystalize(modelObj))
+        );
+        const modelInsight = cnst.crystalizeInsight(modelObjInsight);
+        return {
+          [namesOfSlice.modelList]: modelList,
+          // Server Component용
+          [namesOfSlice.modelInsight]: modelInsight,
+          // Server Component용
+          [namesOfSlice.modelInit]: modelInit
+        };
+      };
+      return [...acc, [namesOfSlice.getModelInit, getInitFn], [namesOfSlice.initModel, initFn]];
+    }, [])
+  );
+  const modelGql = Object.assign(fetch, {
+    ...util,
+    ...sliceUtil
+    // slices: [...overwriteSlices, ...sigMeta.slices],
+  });
+  setGqlOnStorage(signal.refName, modelGql);
+  return modelGql;
+};
+export {
+  databaseFetchOf,
+  serviceFetchOf
+};