@akanjs/signal 0.0.40 → 0.0.42

package/src/gql.js

@@ -1,958 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-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 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
-});
-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;
-}
-__name(graphql, "graphql");
-class GqlStorage {
-  static {
-    __name(this, "GqlStorage");
-  }
-}
-class FragmentStorage {
-  static {
-    __name(this, "FragmentStorage");
-  }
-}
-class PurifyStorage {
-  static {
-    __name(this, "PurifyStorage");
-  }
-}
-class DefaultStorage {
-  static {
-    __name(this, "DefaultStorage");
-  }
-}
-class CrystalizeStorage {
-  static {
-    __name(this, "CrystalizeStorage");
-  }
-}
-const scalarUtilOf = /* @__PURE__ */ __name((name, target) => {
-  const refName = (0, import_constant.getClassMeta)(target).refName;
-  const [fieldName, className] = [
-    (0, import_common.lowerlize)(refName),
-    (0, import_common.capitalize)(refName)
-  ];
-  const graphQL = {
-    refName,
-    [className]: target,
-    [`default${className}`]: (0, import__.immerify)(target, Object.assign(new target(), makeDefault(target))),
-    [`purify${className}`]: makePurify(target),
-    [`crystalize${className}`]: makeCrystalize(target),
-    [`${fieldName}Fragment`]: makeFragment(target)
-  };
-  return graphQL;
-}, "scalarUtilOf");
-const getGqlOnStorage = /* @__PURE__ */ __name((refName) => {
-  const modelGql = Reflect.getMetadata(refName, GqlStorage.prototype);
-  if (!modelGql) throw new Error("Gql is not defined");
-  return modelGql;
-}, "getGqlOnStorage");
-const setGqlOnStorage = /* @__PURE__ */ __name((refName, modelGql) => {
-  Reflect.defineMetadata(refName, modelGql, GqlStorage.prototype);
-}, "setGqlOnStorage");
-const gqlOf = /* @__PURE__ */ __name((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),
-      modelInsight: sliceName.replace(names.model, names.modelInsight),
-      modelInit: sliceName.replace(names.model, names.modelInit),
-      initModel: sliceName.replace(names.model, names.initModel),
-      getModelInit: sliceName.replace(names.model, names.getModelInit)
-    };
-    const getInitFn = /* @__PURE__ */ __name(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()
-      };
-    }, "getInitFn");
-    const initFn = /* @__PURE__ */ __name(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,
-        [namesOfSlice.modelInsight]: modelInsight,
-        [namesOfSlice.modelInit]: modelInit
-      };
-    }, "initFn");
-    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;
-}, "gqlOf");
-const getPredefinedDefault = /* @__PURE__ */ __name((refName) => {
-  const defaultData = Reflect.getMetadata(refName, DefaultStorage.prototype);
-  return defaultData;
-}, "getPredefinedDefault");
-const setPredefinedDefault = /* @__PURE__ */ __name((refName, defaultData) => {
-  Reflect.defineMetadata(refName, defaultData, DefaultStorage.prototype);
-}, "setPredefinedDefault");
-const makeDefault = /* @__PURE__ */ __name((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;
-}, "makeDefault");
-const query = /* @__PURE__ */ __name(async (fetchClient, query2, variables = {}, option = {}) => {
-  const jwt = option.url ? null : await fetchClient.getJwt();
-  const { data, error } = await fetchClient.gql.query(query2, variables, {
-    fetch,
-    url: option.url ?? fetchClient.uri,
-    requestPolicy: typeof option.cache === "string" ? option.cache : option.cache === true ? "cache-first" : "network-only",
-    fetchOptions: {
-      ...typeof option.cache === "number" ? {
-        next: {
-          revalidate: option.cache
-        }
-      } : option.cache === true ? {
-        cache: "force-cache"
-      } : {
-        cache: "no-store"
-      },
-      headers: {
-        "apollo-require-preflight": "true",
-        ...jwt ? {
-          authorization: `Bearer ${jwt}`
-        } : {},
-        ...option.token ? {
-          authorization: `Bearer ${option.token}`
-        } : {}
-      }
-    }
-  }).toPromise();
-  if (!data) {
-    const content = error?.graphQLErrors[0]?.message ?? "Unknown Error";
-    if (option.onError) {
-      option.onError(content);
-      return;
-    } else throw new Error(content);
-  }
-  return data;
-}, "query");
-const mutate = /* @__PURE__ */ __name(async (fetchClient, mutation, variables = {}, option = {}) => {
-  const jwt = option.url ? null : await fetchClient.getJwt();
-  const { data, error } = await fetchClient.gql.mutation(mutation, variables, {
-    fetch,
-    url: option.url ?? fetchClient.uri,
-    requestPolicy: "network-only",
-    fetchOptions: {
-      cache: "no-store",
-      headers: {
-        "apollo-require-preflight": "true",
-        ...jwt ? {
-          authorization: `Bearer ${jwt}`
-        } : {},
-        ...option.token ? {
-          authorization: `Bearer ${option.token}`
-        } : {}
-      }
-    }
-  }).toPromise();
-  if (!data) {
-    const content = error?.graphQLErrors[0]?.message ?? "Unknown Error";
-    if (option.onError) {
-      option.onError(content);
-      return;
-    } else throw new Error(content);
-  }
-  return data;
-}, "mutate");
-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 = /* @__PURE__ */ __name((modelRef) => {
-  const [valueRef] = (0, import_base.getNonArrayModel)(modelRef);
-  return scalarPurifyMap.get(valueRef) ?? ((value) => value);
-}, "getPurifyFn");
-const purify = /* @__PURE__ */ __name((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);
-}, "purify");
-const getPredefinedPurifyFn = /* @__PURE__ */ __name((refName) => {
-  const purify2 = Reflect.getMetadata(refName, PurifyStorage.prototype);
-  return purify2;
-}, "getPredefinedPurifyFn");
-const setPredefinedPurifyFn = /* @__PURE__ */ __name((refName, purify2) => {
-  Reflect.defineMetadata(refName, purify2, PurifyStorage.prototype);
-}, "setPredefinedPurifyFn");
-const makePurify = /* @__PURE__ */ __name((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 = /* @__PURE__ */ __name((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;
-    }
-  }, "fn");
-  setPredefinedPurifyFn(classMeta.refName, fn);
-  return fn;
-}, "makePurify");
-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 = /* @__PURE__ */ __name((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);
-}, "crystalize");
-const getPredefinedCrystalizeFn = /* @__PURE__ */ __name((refName) => {
-  const crystalize2 = Reflect.getMetadata(refName, CrystalizeStorage.prototype);
-  return crystalize2;
-}, "getPredefinedCrystalizeFn");
-const setPredefinedCrystalizeFn = /* @__PURE__ */ __name((refName, crystalize2) => {
-  Reflect.defineMetadata(refName, crystalize2, CrystalizeStorage.prototype);
-}, "setPredefinedCrystalizeFn");
-const makeCrystalize = /* @__PURE__ */ __name((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 = /* @__PURE__ */ __name((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;
-    }
-  }, "fn");
-  if (!option.partial?.length) setPredefinedCrystalizeFn(classMeta.refName, fn);
-  return fn;
-}, "makeCrystalize");
-const fragmentize = /* @__PURE__ */ __name((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;
-}, "fragmentize");
-const getPredefinedFragment = /* @__PURE__ */ __name((refName) => {
-  const fragment = Reflect.getMetadata(refName, FragmentStorage.prototype);
-  return fragment;
-}, "getPredefinedFragment");
-const setPredefinedFragment = /* @__PURE__ */ __name((refName, fragment) => {
-  Reflect.defineMetadata(refName, fragment, FragmentStorage.prototype);
-}, "setPredefinedFragment");
-const makeFragment = /* @__PURE__ */ __name((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;
-}, "makeFragment");
-const getGqlStr = /* @__PURE__ */ __name((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;
-}, "getGqlStr");
-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 = /* @__PURE__ */ __name((inputRef) => {
-  const serializeFn = scalarSerializeMap.get(inputRef);
-  if (!serializeFn) return (value) => value;
-  else return serializeFn;
-}, "getSerializeFn");
-const serializeInput = /* @__PURE__ */ __name((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)
-  ]));
-}, "serializeInput");
-const serializeArg = /* @__PURE__ */ __name((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);
-}, "serializeArg");
-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 = /* @__PURE__ */ __name((inputRef) => {
-  const deserializeFn = scalarDeserializeMap.get(inputRef);
-  if (!deserializeFn) return (value) => value;
-  return deserializeFn;
-}, "getDeserializeFn");
-const deserializeInput = /* @__PURE__ */ __name((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)
-  ]));
-}, "deserializeInput");
-const deserializeArg = /* @__PURE__ */ __name((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);
-}, "deserializeArg");
-const fetchOf = /* @__PURE__ */ __name((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 = /* @__PURE__ */ __name(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")}`);
-          });
-        }
-      }, "emitEvent");
-      const listenEvent = /* @__PURE__ */ __name(function(handleEvent, fetchPolicy = {}) {
-        const crystalize2 = /* @__PURE__ */ __name((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);
-        }, "crystalize");
-        const handle = /* @__PURE__ */ __name((data) => {
-          import_common.Logger.debug(`socket listened: ${gqlMeta.key}: ${(0, import_base.dayjs)().format("YYYY-MM-DD HH:mm:ss.SSS")}`);
-          handleEvent(crystalize2(data));
-        }, "handle");
-        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);
-        };
-      }, "listenEvent");
-      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 = /* @__PURE__ */ __name((gqlKey, argValues) => `${gqlKey}-${argValues.join("-")}`, "makeRoomId");
-      const crystalize2 = /* @__PURE__ */ __name((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);
-      }, "crystalize");
-      const subscribeEvent = /* @__PURE__ */ __name(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 = /* @__PURE__ */ __name((data) => {
-          if (data.__subscribe__) return;
-          onData(crystalize2(data));
-        }, "handleEvent");
-        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);
-        };
-      }, "subscribeEvent");
-      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 = /* @__PURE__ */ __name(({ 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 = /* @__PURE__ */ __name((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);
-        }, "crystalize");
-        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;
-        }
-      }, "makeReq");
-      gqls[name] = makeReq({
-        resolve: true
-      });
-      gqls[`_${name}`] = makeReq({
-        resolve: false
-      });
-    }
-  });
-  return gqls;
-}, "fetchOf");
-const makeFetch = /* @__PURE__ */ __name((fetch1, fetch2, fetch3, fetch4, fetch5, fetch6, fetch7, fetch8, fetch9, fetch10) => {
-  return Object.assign(fetch1, fetch2, fetch3, fetch4, fetch5, fetch6, fetch7, fetch8, fetch9, fetch10);
-}, "makeFetch");
-const makeArgStr = /* @__PURE__ */ __name((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(", ")})` : "";
-}, "makeArgStr");
-const makeArgAssignStr = /* @__PURE__ */ __name((argMetas) => {
-  return argMetas.length ? `(${argMetas.map((argMeta) => `${argMeta.name}: $${argMeta.name}`).join(", ")})` : "";
-}, "makeArgAssignStr");
-const makeReturnStr = /* @__PURE__ */ __name((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")}
-  }`;
-}, "makeReturnStr");
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  CrystalizeStorage,
-  DefaultStorage,
-  FragmentStorage,
-  GqlStorage,
-  PurifyStorage,
-  deserializeArg,
-  fetchOf,
-  getGqlOnStorage,
-  getGqlStr,
-  gqlOf,
-  makeCrystalize,
-  makeDefault,
-  makeFetch,
-  makeFragment,
-  makePurify,
-  scalarUtilOf,
-  serializeArg
-});