@akanjs/signal 0.0.4

package/src/gql.js

@@ -0,0 +1,860 @@
+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 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;
+}
+class GqlStorage {
+}
+class FragmentStorage {
+}
+class PurifyStorage {
+}
+class DefaultStorage {
+}
+class CrystalizeStorage {
+}
+const scalarUtilOf = (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;
+};
+const getGqlOnStorage = (refName) => {
+  const modelGql = Reflect.getMetadata(refName, GqlStorage.prototype);
+  if (!modelGql)
+    throw new Error("Gql is not defined");
+  return modelGql;
+};
+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 query = 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;
+};
+const mutate = 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;
+};
+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])
+        );
+        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;
+};
+const makeFetch = (fetch1, fetch2, fetch3, fetch4, fetch5, fetch6, fetch7, fetch8, fetch9, fetch10) => {
+  return Object.assign(fetch1, fetch2, fetch3, fetch4, fetch5, fetch6, fetch7, fetch8, fetch9, fetch10);
+};
+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")}
+  }`;
+};
+// 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
+});