@akanjs/signal 0.9.47 → 0.9.49

package/cjs/src/fetchInfo.js

@@ -0,0 +1,364 @@
+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 fetchInfo_exports = {};
+__export(fetchInfo_exports, {
+  databaseFetchOf: () => databaseFetchOf,
+  serviceFetchOf: () => serviceFetchOf
+});
+module.exports = __toCommonJS(fetchInfo_exports);
+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_graphql = require("./graphql");
+const serviceFetchOf = (signal) => {
+  const fetch = {};
+  Object.entries(signal.endpoint).forEach(([key, endpoint]) => {
+    const returnRef = import_constant.constantInfo.getModelRef(endpoint.returns.refName, endpoint.returns.modelType);
+    const isScalar = (0, import_base.isGqlScalar)(returnRef);
+    if (endpoint.type === "message") {
+      const emitEvent = function(...args) {
+        const fetchPolicy = args[endpoint.args.length] ?? { crystalize: true };
+        if (!this.client.io && !fetchPolicy.url) {
+          import_common.Logger.warn(`${key} emit suppressed - socket is not connected`);
+          return;
+        }
+        const message = Object.fromEntries(
+          endpoint.args.map((arg, idx) => {
+            const argRef = import_constant.constantInfo.getModelRef(arg.refName, arg.modelType);
+            return [arg.name, (0, import_constant.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);
+          import_common.Logger.debug(`udp emit: ${key}: ${(0, import_base.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);
+            import_common.Logger.debug(`socket emit: ${key}: ${(0, import_base.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 (0, import_base.dayjs)(data);
+            else
+              return data;
+          } else if (Array.isArray(data))
+            return data.map((d) => crystalize(d));
+          else
+            return (0, import_constant.makeCrystalize)(returnRef)(data);
+        };
+        const handle = (data) => {
+          import_common.Logger.debug(`socket listened: ${key}: ${(0, import_base.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);
+          import_common.Logger.debug(`socket listen start: ${key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+        });
+        return async () => {
+          await this.client.waitUntilWebSocketConnected(fetchPolicy.url);
+          import_common.Logger.debug(`socket listen end: ${key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          io.removeListener(key, handle);
+        };
+      };
+      fetch[key] = emitEvent;
+      fetch[`listen${(0, import_common.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 (0, import_base.dayjs)(data);
+          else
+            return data;
+        } else if (Array.isArray(data))
+          return data.map((d) => crystalize(d));
+        else
+          return (0, import_constant.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 = import_constant.constantInfo.getModelRef(arg.refName, arg.modelType);
+            return [arg.name, (0, import_constant.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(() => {
+          import_common.Logger.debug(`socket subscribe start: ${key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          io.subscribe({ key, roomId, message, handleEvent });
+        });
+        return async () => {
+          //! 앱에서 다른 앱 넘어갈 때 언마운트 되버리면서 subscribe가 끊기는 일이 있음.
+          await this.client.waitUntilWebSocketConnected(fetchPolicy.url);
+          import_common.Logger.debug(`socket unsubscribe: ${key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
+          io.unsubscribe(roomId, handleEvent);
+        };
+      };
+      fetch[`subscribe${(0, import_common.capitalize)(key)}`] = subscribeEvent;
+    } else if (["query", "mutation"].includes(endpoint.type)) {
+      const name = endpoint.signalOption?.name ?? key;
+      const makeReq = ({ resolve }) => async function(...args) {
+        import_common.Logger.debug(`fetch: ${key} start: ${(0, import_base.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" ? import_constant.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 (0, import_base.dayjs)(data);
+            else
+              return data;
+          } else if (Array.isArray(data))
+            return data.map((d) => crystalize(d));
+          else
+            return (0, import_constant.makeCrystalize)(lightenedReturnRef, { partial })(data);
+        };
+        try {
+          const res = (await (endpoint.type === "query" ? import_gql.query : import_gql.mutate)(
+            this.client,
+            (0, import_graphql.graphql)((0, import_graphql.getGqlStr)(returnRef, key, endpoint, lightenedReturnRef, partial)),
+            Object.fromEntries(
+              endpoint.args.map((arg, idx) => {
+                const argRef = import_constant.constantInfo.getModelRef(arg.refName, arg.modelType);
+                return [arg.name, (0, import_constant.serializeArg)(argRef, arg.arrDepth, args[idx], arg.argsOption) ?? null];
+              })
+            ),
+            fetchPolicy
+          ))[name];
+          const data = resolve ? crystalize(res) : res;
+          import_common.Logger.debug(`fetch: ${key} end: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")} ${Date.now() - now}ms`);
+          return data;
+        } catch (e) {
+          import_common.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 = import_constant.constantInfo.getDatabase(signal.refName);
+  const [fieldName, className] = [(0, import_common.lowerlize)(signal.refName), (0, import_common.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 import_base.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],
+  });
+  (0, import_gql.setGqlOnStorage)(signal.refName, modelGql);
+  return modelGql;
+};