@akanjs/signal 0.9.48 → 0.9.49

package/cjs/src/gql.js

@@ -17,69 +17,18 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var gql_exports = {};
 __export(gql_exports, {
-  CrystalizeStorage: () => CrystalizeStorage,
-  DefaultStorage: () => DefaultStorage,
-  FragmentStorage: () => FragmentStorage,
   GqlStorage: () => GqlStorage,
-  PurifyStorage: () => PurifyStorage,
-  deserializeArg: () => deserializeArg,
   fetchOf: () => fetchOf,
   getGqlOnStorage: () => getGqlOnStorage,
-  getGqlStr: () => getGqlStr,
   gqlOf: () => gqlOf,
-  makeCrystalize: () => makeCrystalize,
-  makeDefault: () => makeDefault,
   makeFetch: () => makeFetch,
-  makeFragment: () => makeFragment,
-  makePurify: () => makePurify,
-  scalarUtilOf: () => scalarUtilOf,
-  serializeArg: () => serializeArg
+  mutate: () => mutate,
+  query: () => query,
+  setGqlOnStorage: () => setGqlOnStorage
 });
 module.exports = __toCommonJS(gql_exports);
-var import_base = require("@akanjs/base");
-var import_common = require("@akanjs/common");
-var import_constant = require("@akanjs/constant");
-var import__ = require(".");
-var import_signalDecorators = require("./signalDecorators");
-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;
-}
 class GqlStorage {
 }
-class FragmentStorage {
-}
-class PurifyStorage {
-}
-class DefaultStorage {
-}
-class CrystalizeStorage {
-}
-const scalarUtilOf = (cnst) => {
-  const refName = cnst.refName;
-  const [fieldName, className] = [(0, import_common.lowerlize)(refName), (0, import_common.capitalize)(refName)];
-  const graphQL = {
-    refName,
-    [className]: cnst.Model,
-    [`default${className}`]: (0, import__.immerify)(
-      cnst.Model,
-      Object.assign(new cnst.Model(), makeDefault(cnst.Model))
-    ),
-    [`purify${className}`]: makePurify(cnst.Model),
-    [`crystalize${className}`]: makeCrystalize(cnst.Model),
-    [`${fieldName}Fragment`]: makeFragment(cnst.Model)
-  };
-  return graphQL;
-};
 const getGqlOnStorage = (refName) => {
   const modelGql = Reflect.getMetadata(refName, GqlStorage.prototype);
   if (!modelGql)
@@ -89,238 +38,8 @@ const getGqlOnStorage = (refName) => {
 const setGqlOnStorage = (refName, modelGql) => {
   Reflect.defineMetadata(refName, modelGql, GqlStorage.prototype);
 };
-const gqlOf = (constant, sigRef, option = {}) => {
-  const refName = constant.refName;
-  const [fieldName, className] = [(0, import_common.lowerlize)(refName), (0, import_common.capitalize)(refName)];
-  const sigMeta = (0, import_signalDecorators.getSigMeta)(sigRef);
-  const names = {
-    refName,
-    model: fieldName,
-    Model: className,
-    _model: `_${fieldName}`,
-    lightModel: `light${className}`,
-    _lightModel: `_light${className}`,
-    purifyModel: `purify${className}`,
-    crystalizeModel: `crystalize${className}`,
-    lightCrystalizeModel: `lightCrystalize${className}`,
-    crystalizeModelInsight: `crystalize${className}Insight`,
-    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`
-  };
-  const base = {
-    refName,
-    [names.purifyModel]: makePurify(constant.Input, option),
-    [names.crystalizeModel]: makeCrystalize(constant.Full, option),
-    [names.lightCrystalizeModel]: makeCrystalize(constant.Light, option),
-    [names.crystalizeModelInsight]: makeCrystalize(constant.Insight, option),
-    [names.defaultModel]: (0, import__.immerify)(
-      constant.Full,
-      Object.assign(new constant.Full(), makeDefault(constant.Full, option))
-    ),
-    [names.defaultModelInsight]: Object.assign(
-      new constant.Insight(),
-      makeDefault(constant.Insight, option)
-    )
-  };
-  const gql = Object.assign(option.overwrite ?? { client: import__.client }, fetchOf(sigRef));
-  const util = {
-    [names.addModelFiles]: async (files, id, option2) => {
-      const fileGql = getGqlOnStorage("file");
-      const metas = Array.from(files).map((file) => ({ lastModifiedAt: new Date(file.lastModified), size: file.size }));
-      return await fileGql.addFiles(
-        files,
-        metas,
-        names.model,
-        id,
-        option2
-      );
-    },
-    [names.mergeModel]: async (modelOrId, data, option2) => {
-      const model = typeof modelOrId === "string" ? await gql[names._model](modelOrId) : modelOrId;
-      const input = base[names.purifyModel]({ ...model, ...data });
-      if (!input)
-        throw new Error("Error");
-      return await gql[names.updateModel](model.id, input, option2);
-    },
-    [names.viewModel]: async (id, option2) => {
-      const modelObj = await gql[names._model](id, option2);
-      return {
-        [names.model]: base[names.crystalizeModel](modelObj),
-        [names.modelView]: {
-          refName: names.model,
-          [names.modelObj]: modelObj,
-          [names.modelViewAt]: /* @__PURE__ */ new Date()
-        }
-      };
-    },
-    [names.getModelView]: async (id, option2) => {
-      const modelView = await gql[names._model](id, option2);
-      return {
-        refName: names.model,
-        [names.modelObj]: modelView,
-        [names.modelViewAt]: /* @__PURE__ */ new Date()
-      };
-    },
-    [names.editModel]: async (id, option2) => {
-      const modelObj = await gql[names._model](id, option2);
-      return {
-        [names.model]: base[names.crystalizeModel](modelObj),
-        [names.modelEdit]: {
-          refName: names.model,
-          [names.modelObj]: modelObj,
-          [names.modelViewAt]: /* @__PURE__ */ new Date()
-        }
-      };
-    },
-    [names.getModelEdit]: async (id, option2) => {
-      const modelEdit = await gql[names.editModel](id, option2);
-      return modelEdit[names.modelEdit];
-    }
-  };
-  const sliceUtil = Object.fromEntries(
-    sigMeta.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([
-          gql[`_${namesOfSlice.modelList}`](
-            ...queryArgs,
-            skip,
-            limit,
-            sort,
-            fetchInitOption
-          ),
-          gql[`_${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 (...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) => base[names.lightCrystalizeModel](modelObj))
-        );
-        const modelInsight = base[names.crystalizeModelInsight](modelObjInsight);
-        return {
-          [namesOfSlice.modelList]: modelList,
-          // Server Component용
-          [namesOfSlice.modelInsight]: modelInsight,
-          // Server Component용
-          [namesOfSlice.modelInit]: modelInit
-        };
-      };
-      return [...acc, [namesOfSlice.getModelInit, getInitFn], [namesOfSlice.initModel, initFn]];
-    }, [])
-  );
-  const overwriteSlices = option.overwrite ? option.overwrite.slices.filter(
-    (slice) => !sigMeta.slices.some((s) => s.sliceName === slice.sliceName)
-  ) : [];
-  const modelGql = Object.assign(option.overwrite ?? {}, {
-    ...gql,
-    ...base,
-    ...util,
-    ...sliceUtil,
-    slices: [...overwriteSlices, ...sigMeta.slices]
-  });
-  setGqlOnStorage(refName, modelGql);
-  return modelGql;
-};
-const getPredefinedDefault = (refName) => {
-  const defaultData = Reflect.getMetadata(refName, DefaultStorage.prototype);
-  return defaultData;
-};
-const setPredefinedDefault = (refName, defaultData) => {
-  Reflect.defineMetadata(refName, defaultData, DefaultStorage.prototype);
-};
-const makeDefault = (target, option = {}) => {
-  const classMeta = (0, import_constant.getClassMeta)(target);
-  const predefinedDefault = getPredefinedDefault(classMeta.refName);
-  if (predefinedDefault && !option.overwrite)
-    return predefinedDefault;
-  if (option.isChild && classMeta.type !== "scalar")
-    return null;
-  const metadatas = (0, import_constant.getFieldMetas)(target);
-  const result = {};
-  for (const metadata of metadatas) {
-    if (metadata.fieldType === "hidden")
-      result[metadata.key] = null;
-    else if (metadata.default) {
-      if (typeof metadata.default === "function")
-        result[metadata.key] = metadata.default();
-      else if (metadata.default instanceof import_base.Enum)
-        result[metadata.key] = [...metadata.default.values];
-      else
-        result[metadata.key] = metadata.default;
-    } else if (metadata.isArray)
-      result[metadata.key] = [];
-    else if (metadata.nullable)
-      result[metadata.key] = null;
-    else if (metadata.isClass)
-      result[metadata.key] = metadata.isScalar ? makeDefault(metadata.modelRef) : null;
-    else
-      result[metadata.key] = import_base.scalarDefaultMap.get(metadata.modelRef);
-  }
-  setPredefinedDefault(classMeta.refName, result);
-  return result;
+const gqlOf = (constant, filterRef, sigRef, option = {}) => {
+  return null;
 };
 const query = async (fetchClient, query2, variables = {}, option = {}) => {
   const jwt = option.url ? null : await fetchClient.getJwt();
@@ -372,483 +91,9 @@ const mutate = async (fetchClient, mutation, variables = {}, option = {}) => {
   }
   return data;
 };
-const scalarPurifyMap = /* @__PURE__ */ new Map([
-  [Date, (value) => (0, import_base.dayjs)(value).toDate()],
-  [String, (value) => value],
-  [import_base.ID, (value) => value],
-  [Boolean, (value) => value],
-  [import_base.Int, (value) => value],
-  [import_base.Float, (value) => value],
-  [import_base.JSON, (value) => value]
-]);
-const getPurifyFn = (modelRef) => {
-  const [valueRef] = (0, import_base.getNonArrayModel)(modelRef);
-  return scalarPurifyMap.get(valueRef) ?? ((value) => value);
-};
-const purify = (metadata, value, self) => {
-  if (metadata.nullable && (value === null || value === void 0 || typeof value === "number" && isNaN(value) || typeof value === "string" && !value.length))
-    return null;
-  if (metadata.isArray) {
-    if (!Array.isArray(value))
-      throw new Error(`Invalid Array Value in ${metadata.key} for value ${value}`);
-    if (metadata.minlength && value.length < metadata.minlength)
-      throw new Error(`Invalid Array Length (Min) in ${metadata.key} for value ${value}`);
-    else if (metadata.maxlength && value.length > metadata.maxlength)
-      throw new Error(`Invalid Array Length (Max) in ${metadata.key} for value ${value}`);
-    else if (metadata.optArrDepth === 0 && metadata.validate && !metadata.validate(value, self))
-      throw new Error(`Invalid Array Value (Failed to pass validation) in ${metadata.key} for value ${value}`);
-    return value.map((v) => purify({ ...metadata, isArray: false }, v, v));
-  }
-  if (metadata.isMap && metadata.of) {
-    const purifyFn2 = getPurifyFn(metadata.of);
-    return Object.fromEntries(
-      [...value.entries()].map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, purifyFn2)])
-    );
-  }
-  if (metadata.isClass)
-    return makePurify(metadata.modelRef)(value, true);
-  if (metadata.name === "Date" && (0, import_base.dayjs)(value).isBefore((0, import_base.dayjs)(/* @__PURE__ */ new Date("0000"))))
-    throw new Error(`Invalid Date Value (Default) in ${metadata.key} for value ${value}`);
-  if (["String", "ID"].includes(metadata.name) && (value === "" || !value))
-    throw new Error(`Invalid String Value (Default) in ${metadata.key} for value ${value}`);
-  if (metadata.validate && !metadata.validate(value, self))
-    throw new Error(`Invalid Value (Failed to pass validation) / ${value} in ${metadata.key}`);
-  if (!metadata.nullable && !value && value !== 0 && value !== false)
-    throw new Error(`Invalid Value (Nullable) in ${metadata.key} for value ${value}`);
-  const purifyFn = getPurifyFn(metadata.modelRef);
-  return purifyFn(value);
-};
-const getPredefinedPurifyFn = (refName) => {
-  const purify2 = Reflect.getMetadata(refName, PurifyStorage.prototype);
-  return purify2;
-};
-const setPredefinedPurifyFn = (refName, purify2) => {
-  Reflect.defineMetadata(refName, purify2, PurifyStorage.prototype);
-};
-const makePurify = (target, option = {}) => {
-  const classMeta = (0, import_constant.getClassMeta)(target);
-  const purifyFn = getPredefinedPurifyFn(classMeta.refName);
-  if (purifyFn && !option.overwrite)
-    return purifyFn;
-  const metadatas = (0, import_constant.getFieldMetas)(target);
-  const fn = (self, isChild) => {
-    try {
-      if (isChild && classMeta.type !== "scalar") {
-        const id = self.id;
-        if (!id)
-          throw new Error(`Invalid Value (No ID) for id ${classMeta.refName}`);
-        return id;
-      }
-      const result = {};
-      for (const metadata of metadatas) {
-        const value = self[metadata.key];
-        result[metadata.key] = purify(metadata, value, self);
-      }
-      return result;
-    } catch (err) {
-      if (isChild)
-        throw new Error(err);
-      import_common.Logger.debug(err);
-      return null;
-    }
-  };
-  setPredefinedPurifyFn(classMeta.refName, fn);
-  return fn;
-};
-const scalarCrystalizeMap = /* @__PURE__ */ new Map([
-  [Date, (value) => (0, import_base.dayjs)(value)],
-  [String, (value) => value],
-  [import_base.ID, (value) => value],
-  [Boolean, (value) => value],
-  [import_base.Int, (value) => value],
-  [import_base.Float, (value) => value],
-  [import_base.JSON, (value) => value]
-]);
-const crystalize = (metadata, value) => {
-  if (value === void 0 || value === null)
-    return value;
-  if (metadata.isArray && Array.isArray(value))
-    return value.map((v) => crystalize({ ...metadata, isArray: false }, v));
-  if (metadata.isMap) {
-    const [valueRef] = (0, import_base.getNonArrayModel)(metadata.of);
-    const crystalizeValue = scalarCrystalizeMap.get(valueRef) ?? ((value2) => value2);
-    return new Map(
-      Object.entries(value).map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, crystalizeValue)])
-    );
-  }
-  if (metadata.isClass)
-    return makeCrystalize(metadata.modelRef)(value, true);
-  if (metadata.name === "Date")
-    return (0, import_base.dayjs)(value);
-  return (scalarCrystalizeMap.get(metadata.modelRef) ?? ((value2) => value2))(value);
-};
-const getPredefinedCrystalizeFn = (refName) => {
-  const crystalize2 = Reflect.getMetadata(refName, CrystalizeStorage.prototype);
-  return crystalize2;
-};
-const setPredefinedCrystalizeFn = (refName, crystalize2) => {
-  Reflect.defineMetadata(refName, crystalize2, CrystalizeStorage.prototype);
-};
-const makeCrystalize = (target, option = {}) => {
-  const classMeta = (0, import_constant.getClassMeta)(target);
-  const crystalizeFn = getPredefinedCrystalizeFn(classMeta.refName);
-  if (crystalizeFn && !option.overwrite && !option.partial?.length)
-    return crystalizeFn;
-  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(target);
-  const fieldKeys = option.partial?.length ? classMeta.type === "scalar" ? option.partial : ["id", ...option.partial, "updatedAt"] : [...fieldMetaMap.keys()];
-  const metadatas = fieldKeys.map((key) => fieldMetaMap.get(key));
-  const fn = (self, isChild) => {
-    try {
-      const result = Object.assign(new target(), self);
-      for (const metadata of metadatas.filter((m) => !!self[m.key])) {
-        if (metadata.fieldType === "hidden")
-          continue;
-        result[metadata.key] = crystalize(metadata, self[metadata.key]);
-      }
-      return result;
-    } catch (err) {
-      if (isChild)
-        throw new Error(err);
-      return null;
-    }
-  };
-  if (!option.partial?.length)
-    setPredefinedCrystalizeFn(classMeta.refName, fn);
-  return fn;
-};
-const fragmentize = (target, fragMap = /* @__PURE__ */ new Map(), partial) => {
-  const classMeta = (0, import_constant.getClassMeta)(target);
-  const metadatas = (0, import_constant.getFieldMetas)(target);
-  const selectKeys = partial ? ["id", ...partial, "updatedAt"] : metadatas.map((metadata) => metadata.key);
-  const selectKeySet = new Set(selectKeys);
-  const fragment = `fragment ${(0, import_common.lowerlize)(classMeta.refName)}Fragment on ${(0, import_common.capitalize)(
-    classMeta.type === "light" ? classMeta.refName.slice(5) : classMeta.refName
-  )} {
-` + metadatas.filter((metadata) => metadata.fieldType !== "hidden" && selectKeySet.has(metadata.key)).map((metadata) => {
-    return metadata.isClass ? `  ${metadata.key} {
-    ...${(0, import_common.lowerlize)(metadata.name)}Fragment
-  }` : `  ${metadata.key}`;
-  }).join(`
-`) + `
-}`;
-  fragMap.set(classMeta.refName, fragment);
-  metadatas.filter((metadata) => metadata.fieldType !== "hidden" && selectKeySet.has(metadata.key) && metadata.isClass).forEach((metadata) => fragmentize(metadata.modelRef, fragMap));
-  return fragMap;
-};
-const getPredefinedFragment = (refName) => {
-  const fragment = Reflect.getMetadata(refName, FragmentStorage.prototype);
-  return fragment;
-};
-const setPredefinedFragment = (refName, fragment) => {
-  Reflect.defineMetadata(refName, fragment, FragmentStorage.prototype);
-};
-const makeFragment = (target, option = {}) => {
-  const classMeta = (0, import_constant.getClassMeta)(target);
-  const fragment = getPredefinedFragment(classMeta.refName);
-  if (fragment && !option.overwrite && !option.excludeSelf && !option.partial?.length)
-    return fragment;
-  const fragMap = new Map(fragmentize(target, /* @__PURE__ */ new Map(), option.partial));
-  if (option.excludeSelf)
-    fragMap.delete(classMeta.refName);
-  const gqlStr = [...fragMap.values()].join("\n");
-  if (!option.excludeSelf)
-    setPredefinedFragment(classMeta.refName, gqlStr);
-  return gqlStr;
-};
-const getGqlStr = (modelRef, gqlMeta, argMetas, returnRef, partial) => {
-  const isScalar = (0, import_base.isGqlScalar)(modelRef);
-  const argStr = makeArgStr(argMetas);
-  const argAssignStr = makeArgAssignStr(argMetas);
-  const returnStr = makeReturnStr(returnRef, partial);
-  const gqlStr = `${isScalar ? "" : makeFragment(returnRef, { excludeSelf: !!partial?.length, partial })}
-${(0, import_common.lowerlize)(gqlMeta.type) + " " + gqlMeta.key + argStr}{
-  ${gqlMeta.key}${argAssignStr}${returnStr}
-}
-`;
-  return gqlStr;
-};
-const scalarSerializeMap = /* @__PURE__ */ new Map([
-  [Date, (value) => (0, import_base.dayjs)(value).toDate()],
-  [String, (value) => value],
-  [import_base.ID, (value) => value],
-  [Boolean, (value) => value],
-  [import_base.Int, (value) => value],
-  [import_base.Float, (value) => value],
-  [import_base.JSON, (value) => value]
-]);
-const getSerializeFn = (inputRef) => {
-  const serializeFn = scalarSerializeMap.get(inputRef);
-  if (!serializeFn)
-    return (value) => value;
-  else
-    return serializeFn;
-};
-const serializeInput = (value, inputRef, arrDepth) => {
-  if (arrDepth && Array.isArray(value))
-    return value.map((v) => serializeInput(v, inputRef, arrDepth - 1));
-  else if (inputRef.prototype === Map.prototype) {
-    const [valueRef] = (0, import_base.getNonArrayModel)(inputRef);
-    const serializeFn = getSerializeFn(valueRef);
-    return Object.fromEntries(
-      [...value.entries()].map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, serializeFn)])
-    );
-  } else if ((0, import_base.isGqlScalar)(inputRef)) {
-    const serializeFn = getSerializeFn(inputRef);
-    return serializeFn(value);
-  }
-  const classMeta = (0, import_constant.getClassMeta)(inputRef);
-  if (classMeta.type !== "scalar")
-    return value;
-  else
-    return Object.fromEntries(
-      (0, import_constant.getFieldMetas)(inputRef).map((fieldMeta) => [
-        fieldMeta.key,
-        serializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
-      ])
-    );
-};
-const serializeArg = (argMeta, value) => {
-  const [returnRef, arrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
-  if (argMeta.argsOption.nullable && (value === null || value === void 0))
-    return null;
-  else if (!argMeta.argsOption.nullable && (value === null || value === void 0))
-    throw new Error(`Invalid Value (Nullable) in ${argMeta.name} for value ${value}`);
-  return serializeInput(value, returnRef, arrDepth);
-};
-const scalarDeserializeMap = /* @__PURE__ */ new Map([
-  [Date, (value) => (0, import_base.dayjs)(value)],
-  [String, (value) => value],
-  [import_base.ID, (value) => value],
-  [Boolean, (value) => value],
-  [import_base.Int, (value) => value],
-  [import_base.Float, (value) => value],
-  [import_base.JSON, (value) => value]
-]);
-const getDeserializeFn = (inputRef) => {
-  const deserializeFn = scalarDeserializeMap.get(inputRef);
-  if (!deserializeFn)
-    return (value) => value;
-  return deserializeFn;
-};
-const deserializeInput = (value, inputRef, arrDepth) => {
-  if (arrDepth && Array.isArray(value))
-    return value.map((v) => deserializeInput(v, inputRef, arrDepth - 1));
-  else if (inputRef.prototype === Map.prototype) {
-    const [valueRef] = (0, import_base.getNonArrayModel)(inputRef);
-    const deserializeFn = getDeserializeFn(valueRef);
-    return Object.fromEntries(
-      [...value.entries()].map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, deserializeFn)])
-    );
-  } else if ((0, import_base.isGqlScalar)(inputRef)) {
-    const deserializeFn = getDeserializeFn(inputRef);
-    return deserializeFn(value);
-  }
-  const classMeta = (0, import_constant.getClassMeta)(inputRef);
-  if (classMeta.type !== "scalar")
-    return value;
-  else
-    return Object.fromEntries(
-      (0, import_constant.getFieldMetas)(inputRef).map((fieldMeta) => [
-        fieldMeta.key,
-        deserializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
-      ])
-    );
-};
-const deserializeArg = (argMeta, value) => {
-  const [returnRef, arrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
-  if (argMeta.argsOption.nullable && (value === null || value === void 0))
-    return null;
-  else if (!argMeta.argsOption.nullable && (value === null || value === void 0))
-    throw new Error(`Invalid Value (Nullable) in ${argMeta.name} for value ${value}`);
-  return deserializeInput(value, returnRef, arrDepth);
-};
 const fetchOf = (sigRef) => {
-  const gqls = {};
-  const gqlMetas = (0, import_signalDecorators.getGqlMetas)(sigRef);
-  gqlMetas.filter((gqlMeta) => !gqlMeta.signalOption.default).forEach((gqlMeta) => {
-    if (gqlMeta.type === "Message") {
-      const [returnRef, arrDepth] = (0, import_base.getNonArrayModel)(gqlMeta.returns());
-      const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
-      const isScalar = (0, import_base.isGqlScalar)(returnRef);
-      const emitEvent = function(...args) {
-        const fetchPolicy = args[argMetas.length] ?? { crystalize: true };
-        if (!this.client.io && !fetchPolicy.url) {
-          import_common.Logger.warn(`${gqlMeta.key} emit suppressed - socket is not connected`);
-          return;
-        }
-        const message = Object.fromEntries(
-          argMetas.map((argMeta) => [argMeta.name, serializeArg(argMeta, args[argMeta.idx]) ?? 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: ${gqlMeta.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(gqlMeta.key, message);
-            import_common.Logger.debug(`socket emit: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
-          });
-        }
-      };
-      const listenEvent = function(handleEvent, fetchPolicy = {}) {
-        const crystalize2 = (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) => crystalize2(d));
-          else
-            return makeCrystalize(returnRef)(data);
-        };
-        const handle = (data) => {
-          import_common.Logger.debug(`socket listened: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
-          handleEvent(crystalize2(data));
-        };
-        const io = this.client.getIo(fetchPolicy.url);
-        this.client.waitUntilWebSocketConnected(fetchPolicy.url).then(() => {
-          io.removeListener(gqlMeta.key, handle);
-          io.on(gqlMeta.key, handle);
-          import_common.Logger.debug(`socket listen start: ${gqlMeta.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: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
-          io.removeListener(gqlMeta.key, handle);
-        };
-      };
-      gqls[gqlMeta.key] = emitEvent;
-      gqls[`listen${(0, import_common.capitalize)(gqlMeta.key)}`] = listenEvent;
-    } else if (gqlMeta.type === "Pubsub") {
-      const [returnRef] = (0, import_base.getNonArrayModel)(gqlMeta.returns());
-      const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
-      const isScalar = (0, import_base.isGqlScalar)(returnRef);
-      const makeRoomId = (gqlKey, argValues) => `${gqlKey}-${argValues.join("-")}`;
-      const crystalize2 = (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) => crystalize2(d));
-        else
-          return makeCrystalize(returnRef)(data);
-      };
-      const subscribeEvent = function(...args) {
-        const onData = args[argMetas.length];
-        const fetchPolicy = args[argMetas.length + 1] ?? { crystalize: true };
-        const message = Object.fromEntries(
-          argMetas.map((argMeta) => [argMeta.name, serializeArg(argMeta, args[argMeta.idx]) ?? null])
-        );
-        const handleEvent = (data) => {
-          if (data.__subscribe__)
-            return;
-          onData(crystalize2(data));
-        };
-        const roomId = makeRoomId(
-          gqlMeta.key,
-          argMetas.map((argMeta) => message[argMeta.name])
-        );
-        const io = this.client.getIo(fetchPolicy.url);
-        void this.client.waitUntilWebSocketConnected(fetchPolicy.url).then(() => {
-          import_common.Logger.debug(`socket subscribe start: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
-          io.subscribe({ key: gqlMeta.key, roomId, message, handleEvent });
-        });
-        return async () => {
-          //! 앱에서 다른 앱 넘어갈 때 언마운트 되버리면서 subscribe가 끊기는 일이 있음.
-          await this.client.waitUntilWebSocketConnected(fetchPolicy.url);
-          import_common.Logger.debug(`socket unsubscribe: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
-          io.unsubscribe(roomId, handleEvent);
-        };
-      };
-      gqls[`subscribe${(0, import_common.capitalize)(gqlMeta.key)}`] = subscribeEvent;
-    } else if (gqlMeta.type === "Query" || gqlMeta.type === "Mutation") {
-      const name = gqlMeta.signalOption.name ?? gqlMeta.key;
-      const makeReq = ({ resolve }) => async function(...args) {
-        import_common.Logger.debug(`fetch: ${gqlMeta.key} start: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
-        const now = Date.now();
-        const [argMetas] = (0, import_signalDecorators.getArgMetas)(sigRef, gqlMeta.signalOption.name ?? gqlMeta.key);
-        const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(gqlMeta.returns());
-        const isScalar = (0, import_base.isGqlScalar)(modelRef);
-        const returnRef = isScalar || !arrDepth ? modelRef : (0, import_constant.getLightModelRef)(modelRef);
-        const fetchPolicy = args[argMetas.length] ?? { crystalize: true };
-        const partial = fetchPolicy.partial ?? gqlMeta.signalOption.partial;
-        const crystalize2 = (data) => {
-          if (fetchPolicy.crystalize === false)
-            return 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) => crystalize2(d));
-          else
-            return makeCrystalize(returnRef, { partial })(data);
-        };
-        try {
-          const res = (await (gqlMeta.type === "Query" ? query : mutate)(
-            this.client,
-            graphql(getGqlStr(modelRef, gqlMeta, argMetas, returnRef, partial)),
-            Object.fromEntries(
-              argMetas.map((argMeta) => [argMeta.name, serializeArg(argMeta, args[argMeta.idx]) ?? null])
-            ),
-            fetchPolicy
-          ))[name];
-          const data = resolve ? crystalize2(res) : res;
-          import_common.Logger.debug(
-            `fetch: ${gqlMeta.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: ${gqlMeta.key} error: ${e}`);
-          throw e;
-        }
-      };
-      gqls[name] = makeReq({ resolve: true });
-      gqls[`_${name}`] = makeReq({ resolve: false });
-    }
-  });
-  return gqls;
+  return null;
 };
 const makeFetch = (...fetches) => {
-  const [f1, ...rest] = fetches;
-  return Object.assign(f1, ...rest);
-};
-const makeArgStr = (argMetas) => {
-  return argMetas.length ? `(${argMetas.map((argMeta) => {
-    const [argRef, arrDepth] = (0, import_base.getNonArrayModel)(argMeta.returns());
-    const argRefType = (0, import_base.isGqlScalar)(argRef) ? "gqlScalar" : (0, import_constant.getClassMeta)(argRef).type === "scalar" ? "scalar" : "model";
-    const gqlTypeStr = "[".repeat(arrDepth) + ((0, import_constant.getGqlTypeStr)(argRef) + (argRefType === "scalar" ? "Input" : "")) + "!]".repeat(arrDepth);
-    return `$${argMeta.name}: ` + gqlTypeStr + (argMeta.argsOption.nullable ? "" : "!");
-  }).join(", ")})` : "";
-};
-const makeArgAssignStr = (argMetas) => {
-  return argMetas.length ? `(${argMetas.map((argMeta) => `${argMeta.name}: $${argMeta.name}`).join(", ")})` : "";
-};
-const makeReturnStr = (returnRef, partial) => {
-  const isScalar = (0, import_base.isGqlScalar)(returnRef);
-  if (isScalar)
-    return "";
-  const classMeta = (0, import_constant.getClassMeta)(returnRef);
-  if (!partial?.length)
-    return ` {
-    ...${(0, import_common.lowerlize)(classMeta.refName)}Fragment
-  }`;
-  const targetKeys = classMeta.type === "scalar" ? partial : [.../* @__PURE__ */ new Set(["id", ...partial, "updatedAt"])];
-  const fieldMetaMap = (0, import_constant.getFieldMetaMap)(returnRef);
-  return ` {
-${targetKeys.map((key) => fieldMetaMap.get(key)).filter((metadata) => metadata && metadata.fieldType !== "hidden").map(
-    (fieldMeta) => fieldMeta.isClass ? `    ${fieldMeta.key} {
-      ...${(0, import_common.lowerlize)(fieldMeta.name)}Fragment
-    }` : `    ${fieldMeta.key}`
-  ).join("\n")}
-  }`;
+  return null;
 };