@akanjs/constant 0.9.47 → 0.9.49

package/cjs/src/crystalize.js

@@ -0,0 +1,89 @@
+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 crystalize_exports = {};
+__export(crystalize_exports, {
+  makeCrystalize: () => makeCrystalize
+});
+module.exports = __toCommonJS(crystalize_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import__ = require(".");
+class CrystalizeStorage {
+}
+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.modelRef === 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 = (modelRef, option = {}) => {
+  const refName = import__.constantInfo.getRefName(modelRef);
+  const crystalName = `${import__.constantInfo.isLight(modelRef) ? "Light" : ""}${(0, import_common.capitalize)(refName)}${import__.constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
+  const crystalizeFn = getPredefinedCrystalizeFn(crystalName);
+  if (crystalizeFn && !option.overwrite && !option.partial?.length)
+    return crystalizeFn;
+  const fieldMetaMap = (0, import__.getFieldMetaMap)(modelRef);
+  const fieldKeys = option.partial?.length ? import__.constantInfo.isScalar(modelRef) ? 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 modelRef(), 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(crystalName, fn);
+  return fn;
+};

package/cjs/src/default.js

@@ -0,0 +1,67 @@
+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 default_exports = {};
+__export(default_exports, {
+  makeDefault: () => makeDefault
+});
+module.exports = __toCommonJS(default_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constantInfo = require("./constantInfo");
+var import_scalar = require("./scalar");
+class DefaultStorage {
+}
+const getPredefinedDefault = (refName) => {
+  const defaultData = Reflect.getMetadata(refName, DefaultStorage.prototype);
+  return defaultData;
+};
+const setPredefinedDefault = (refName, defaultData) => {
+  Reflect.defineMetadata(refName, defaultData, DefaultStorage.prototype);
+};
+const makeDefault = (modelRef, option = {}) => {
+  const refName = import_constantInfo.constantInfo.getRefName(modelRef);
+  const defaultName = `${(0, import_common.capitalize)(refName)}${import_constantInfo.constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
+  const predefinedDefault = getPredefinedDefault(defaultName);
+  if (predefinedDefault && !option.overwrite)
+    return predefinedDefault;
+  if (option.isChild && import_constantInfo.constantInfo.isScalar(modelRef))
+    return null;
+  const metadatas = (0, import_scalar.getFieldMetas)(modelRef);
+  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(defaultName, result);
+  return result;
+};

package/cjs/src/fieldInfo.js

@@ -0,0 +1,98 @@
+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 fieldInfo_exports = {};
+__export(fieldInfo_exports, {
+  field: () => field,
+  resolve: () => resolve
+});
+module.exports = __toCommonJS(fieldInfo_exports);
+var import_base = require("@akanjs/base");
+var import_constantInfo = require("./constantInfo");
+var import_scalar = require("./scalar");
+class FieldInfo {
+  value;
+  type;
+  option;
+  explicitType;
+  constructor(value, option) {
+    this.value = value;
+    const [singleValue, arrDepth] = (0, import_base.getNonArrayModel)(value);
+    const isEnum = singleValue instanceof import_base.Enum;
+    const valueType = isEnum ? (0, import_base.arraiedModel)(singleValue.type, arrDepth) : value;
+    this.type = valueType;
+    this.option = { ...option, ...isEnum ? { enum: singleValue } : {} };
+  }
+  optional() {
+    return new FieldInfo(this.value, { ...this.option, nullable: true });
+  }
+  meta(meta) {
+    this.option.meta = meta;
+    return this;
+  }
+  applyFieldMeta(target, key) {
+    const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(this.type);
+    const [option, optArrDepth] = (0, import_base.getNonArrayModel)(this.option);
+    const isArray = arrDepth > 0;
+    const isClass = !(0, import_base.isGqlScalar)(modelRef);
+    const isMap = (0, import_base.isGqlMap)(modelRef);
+    if (isMap && !option.of)
+      throw new Error("Map type must have 'of' option");
+    const metadata = {
+      nullable: option.nullable ?? (option.default === "" ? true : false),
+      ref: option.ref,
+      refPath: option.refPath,
+      refType: option.refType,
+      default: option.default ?? (isArray ? [] : null),
+      type: option.type,
+      fieldType: option.fieldType ?? "property",
+      immutable: option.immutable ?? false,
+      min: option.min,
+      max: option.max,
+      enum: option.enum,
+      select: option.select ?? true,
+      minlength: option.minlength,
+      maxlength: option.maxlength,
+      accumulate: option.accumulate,
+      example: option.example,
+      validate: option.validate,
+      key,
+      isClass,
+      isScalar: import_constantInfo.constantInfo.isScalar(modelRef),
+      modelRef,
+      arrDepth,
+      isArray,
+      optArrDepth,
+      isMap,
+      of: option.of,
+      text: option.text,
+      meta: option.meta ?? {}
+    };
+    const metadataMap = (0, import_scalar.getFieldMetaMapOnPrototype)(target.prototype);
+    metadataMap.set(key, metadata);
+    (0, import_scalar.setFieldMetaMapOnPrototype)(target.prototype, metadataMap);
+  }
+}
+const field = (value, option = {}) => new FieldInfo(value, { ...option, fieldType: "property" });
+field.secret = (value, option = {}) => new FieldInfo(value, { ...option, fieldType: "hidden", nullable: true });
+field.hidden = (value, option = {}) => new FieldInfo(value, {
+  ...option,
+  fieldType: "hidden",
+  select: false,
+  nullable: true
+});
+const resolve = (value, option = {}) => new FieldInfo(value, { ...option, fieldType: "resolve" });

package/cjs/src/immerify.js

@@ -0,0 +1,35 @@
+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 immerify_exports = {};
+__export(immerify_exports, {
+  immerify: () => immerify
+});
+module.exports = __toCommonJS(immerify_exports);
+var import_immer = require("immer");
+var import__ = require(".");
+const immerify = (modelRef, objOrArr) => {
+  if (Array.isArray(objOrArr))
+    return objOrArr.map((val) => immerify(modelRef, val));
+  const fieldMetas = (0, import__.getFieldMetas)(modelRef);
+  const immeredObj = Object.assign({}, objOrArr, { [import_immer.immerable]: true });
+  fieldMetas.forEach((fieldMeta) => {
+    if (fieldMeta.isScalar && fieldMeta.isClass && !!objOrArr[fieldMeta.key])
+      immeredObj[fieldMeta.key] = immerify(fieldMeta.modelRef, objOrArr[fieldMeta.key]);
+  });
+  return immeredObj;
+};

package/cjs/src/index.js

@@ -2,10 +2,6 @@ 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))
@@ -17,15 +13,14 @@ var __copyProps = (to, from, except, desc) => {
 var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var src_exports = {};
-__export(src_exports, {
-  Srvs: () => Srvs
-});
 module.exports = __toCommonJS(src_exports);
 __reExport(src_exports, require("./types"), module.exports);
-__reExport(src_exports, require("./fieldMeta"), module.exports);
+__reExport(src_exports, require("./fieldInfo"), module.exports);
 __reExport(src_exports, require("./scalar"), module.exports);
-__reExport(src_exports, require("./constantDecorator"), module.exports);
-__reExport(src_exports, require("./filterMeta"), module.exports);
+__reExport(src_exports, require("./constantInfo"), module.exports);
 __reExport(src_exports, require("./baseGql"), module.exports);
 __reExport(src_exports, require("./classMeta"), module.exports);
-const Srvs = {};
+__reExport(src_exports, require("./default"), module.exports);
+__reExport(src_exports, require("./crystalize"), module.exports);
+__reExport(src_exports, require("./purify"), module.exports);
+__reExport(src_exports, require("./serialize"), module.exports);

package/cjs/src/purify.js

@@ -0,0 +1,110 @@
+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 purify_exports = {};
+__export(purify_exports, {
+  makePurify: () => makePurify
+});
+module.exports = __toCommonJS(purify_exports);
+var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import__ = require(".");
+class PurifyStorage {
+}
+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.modelRef === 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, import_base.ID].includes(metadata.modelRef) && (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 = (modelRef, option = {}) => {
+  const refName = import__.constantInfo.getRefName(modelRef);
+  const purifyFn = getPredefinedPurifyFn(refName);
+  if (purifyFn && !option.overwrite)
+    return purifyFn;
+  const metadatas = (0, import__.getFieldMetas)(modelRef);
+  const fn = (self, isChild) => {
+    try {
+      if (isChild && !import__.constantInfo.isScalar(modelRef)) {
+        const id = self.id;
+        if (!id)
+          throw new Error(`Invalid Value (No ID) for id ${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(refName, fn);
+  return fn;
+};

package/cjs/src/scalar.js

@@ -17,8 +17,7 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var scalar_exports = {};
 __export(scalar_exports, {
-  fieldTypes: () => fieldTypes,
-  getClassMeta: () => getClassMeta,
+  fieldPresets: () => fieldPresets,
   getFieldMetaMap: () => getFieldMetaMap,
   getFieldMetaMapOnPrototype: () => getFieldMetaMapOnPrototype,
   getFieldMetas: () => getFieldMetas,
@@ -32,6 +31,8 @@ __export(scalar_exports, {
 module.exports = __toCommonJS(scalar_exports);
 var import_reflect_metadata = require("reflect-metadata");
 var import_base = require("@akanjs/base");
+var import_common = require("@akanjs/common");
+var import_constantInfo = require("./constantInfo");
 const scalarExampleMap = /* @__PURE__ */ new Map([
   [import_base.ID, "1234567890abcdef12345678"],
   [import_base.Int, 0],
@@ -44,20 +45,15 @@ const scalarExampleMap = /* @__PURE__ */ new Map([
   [Map, {}]
 ]);
 const getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
-const getGqlTypeStr = (ref) => import_base.scalarNameMap.get(ref) ?? getClassMeta(ref).refName;
-const fieldTypes = ["email", "password", "url"];
-const getClassMeta = (modelRef) => {
-  const [target] = (0, import_base.getNonArrayModel)(modelRef);
-  const classMeta = Reflect.getMetadata("class", target.prototype);
-  if (!classMeta)
-    throw new Error(`No ClassMeta for this target ${target.name}`);
-  return classMeta;
-};
+const getGqlTypeStr = (ref) => import_base.scalarNameMap.get(ref) ?? `${import_constantInfo.constantInfo.isLight(ref) ? "Light" : ""}${(0, import_common.capitalize)(import_constantInfo.constantInfo.getRefName(ref))}${import_constantInfo.constantInfo.isInsight(ref) ? "Insight" : ""}`;
+const fieldPresets = ["email", "password", "url"];
 const getFieldMetas = (modelRef) => {
   const [target] = (0, import_base.getNonArrayModel)(modelRef);
   const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
   const keySortMap = { id: -1, createdAt: 1, updatedAt: 2, removedAt: 3 };
-  return [...metadataMap.values()].sort((a, b) => (keySortMap[a.key] ?? 0) - (keySortMap[b.key] ?? 0));
+  return [...metadataMap.values()].sort(
+    (a, b) => (keySortMap[a.key] ?? 0) - (keySortMap[b.key] ?? 0)
+  );
 };
 const isConstantModel = (modelRef) => {
   return Reflect.getMetadata("class", modelRef.prototype) !== void 0;

package/cjs/src/serialize.js

@@ -0,0 +1,116 @@
+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 serialize_exports = {};
+__export(serialize_exports, {
+  deserializeArg: () => deserializeArg,
+  serializeArg: () => serializeArg
+});
+module.exports = __toCommonJS(serialize_exports);
+var import_base = require("@akanjs/base");
+var import__ = require(".");
+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);
+  }
+  if (!import__.constantInfo.isScalar(inputRef))
+    return value;
+  else
+    return Object.fromEntries(
+      (0, import__.getFieldMetas)(inputRef).map((fieldMeta) => [
+        fieldMeta.key,
+        serializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
+      ])
+    );
+};
+const serializeArg = (argRef, arrDepth, value, { nullable = false }) => {
+  if (nullable && (value === null || value === void 0))
+    return null;
+  else if (!nullable && (value === null || value === void 0))
+    throw new Error(`Invalid Value (Nullable) in ${argRef} for value ${value}`);
+  return serializeInput(value, argRef, 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);
+  }
+  if (!import__.constantInfo.isScalar(inputRef))
+    return value;
+  else
+    return Object.fromEntries(
+      (0, import__.getFieldMetas)(inputRef).map((fieldMeta) => [
+        fieldMeta.key,
+        deserializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
+      ])
+    );
+};
+const deserializeArg = (argRef, arrDepth, value, { nullable = false }) => {
+  if (nullable && (value === null || value === void 0))
+    return null;
+  else if (!nullable && (value === null || value === void 0))
+    throw new Error(`Invalid Value (Nullable) in ${argRef} for value ${value}`);
+  return deserializeInput(value, argRef, arrDepth);
+};