@akanjs/constant 0.9.48 → 0.9.49

package/esm/src/baseGql.js

@@ -1,17 +1,13 @@
 import "reflect-metadata";
-import { ID } from "@akanjs/base";
+import { ID, Int } from "@akanjs/base";
 import { applyMixins } from "@akanjs/common";
-import { getFullModelRefs } from "./classMeta";
+import { setExtendRef } from "./classMeta";
+import { constantInfo } from "./constantInfo";
 import {
-  getFilterArgMetas,
-  getFilterMeta,
-  getFilterQueryMap,
-  getFilterSortMap,
-  setFilterArgMetasOnPrototype,
-  setFilterKeyMetaMapOnPrototype,
-  setFilterMeta
-} from "./filterMeta";
-import { getClassMeta, getFieldMetaMap, setFieldMetaMap } from "./scalar";
+  field,
+  resolve
+} from "./fieldInfo";
+import { getFieldMetaMap, setFieldMetaMap } from "./scalar";
 const defaultFieldMeta = {
   fieldType: "property",
   immutable: false,
@@ -26,166 +22,167 @@ const defaultFieldMeta = {
   isMap: false,
   meta: {}
 };
-const idFieldMeta = { ...defaultFieldMeta, key: "id", name: "ID", modelRef: ID };
-const createdAtFieldMeta = { ...defaultFieldMeta, key: "createdAt", name: "Date", modelRef: Date };
-const updatedAtFieldMeta = { ...defaultFieldMeta, key: "updatedAt", name: "Date", modelRef: Date };
-const removedAtFieldMeta = {
-  ...defaultFieldMeta,
-  key: "removedAt",
-  name: "Date",
-  modelRef: Date,
-  nullable: true,
-  default: null
-};
-const extendModel = (modelRef) => {
-  class BaseModel {
-  }
-  const metadataMap = getFieldMetaMap(modelRef);
-  setFieldMetaMap(BaseModel, metadataMap);
-  return BaseModel;
-};
-const as = extendModel;
-const baseModelOf = (modelRef) => {
-  class BaseModel {
-    __ModelType__ = "full";
+const baseFieldMetaMap = /* @__PURE__ */ new Map([
+  ["id", { ...defaultFieldMeta, key: "id", modelRef: ID }],
+  ["createdAt", { ...defaultFieldMeta, key: "createdAt", modelRef: Date }],
+  ["updatedAt", { ...defaultFieldMeta, key: "updatedAt", modelRef: Date }],
+  ["removedAt", { ...defaultFieldMeta, key: "removedAt", modelRef: Date, nullable: true, default: null }]
+]);
+const baseInsightFieldMetaMap = /* @__PURE__ */ new Map([
+  ["count", { ...defaultFieldMeta, key: "count", modelRef: Int, default: 0, accumulate: { $sum: 1 } }]
+]);
+const objectModelOf = (inputRef, fieldMap) => {
+  class ObjectModel {
   }
-  const metadataMap = new Map(getFieldMetaMap(modelRef));
-  metadataMap.set("id", idFieldMeta);
-  metadataMap.set("createdAt", createdAtFieldMeta);
-  metadataMap.set("updatedAt", updatedAtFieldMeta);
-  metadataMap.set("removedAt", removedAtFieldMeta);
-  Reflect.defineMetadata("fields", metadataMap, BaseModel.prototype);
-  return BaseModel;
+  const metadataMap = new Map([...baseFieldMetaMap, ...getFieldMetaMap(inputRef)]);
+  setFieldMetaMap(ObjectModel, metadataMap);
+  setExtendRef(ObjectModel, inputRef);
+  constantInfo.setModelType(ObjectModel, "object");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(ObjectModel, key);
+  });
+  return ObjectModel;
 };
-const lightModelOf = (objectRef, fields, ...libLightModelRefs) => {
+const lightModelOf = (objectRef, fields, fieldMap, ...libLightModelRefs) => {
   const objectFieldMetaMap = getFieldMetaMap(objectRef);
   const baseLightModelRef = libLightModelRefs.at(0);
-  const fieldMetaMap = baseLightModelRef ? getFieldMetaMap(baseLightModelRef) : /* @__PURE__ */ new Map();
+  const fieldMetaMap = baseLightModelRef ? getFieldMetaMap(baseLightModelRef) : new Map([...baseFieldMetaMap]);
   class BaseLightModel {
-    __ModelType__ = "light";
   }
-  fieldMetaMap.set("id", idFieldMeta);
-  fieldMetaMap.set("createdAt", createdAtFieldMeta);
-  fieldMetaMap.set("updatedAt", updatedAtFieldMeta);
-  fieldMetaMap.set("removedAt", removedAtFieldMeta);
-  for (const field of fields) {
-    const fieldMeta = objectFieldMetaMap.get(field);
+  for (const field2 of fields) {
+    const fieldMeta = objectFieldMetaMap.get(field2);
     if (!fieldMeta)
-      throw new Error(`Field ${field} not found in objectRef`);
-    fieldMetaMap.set(field, fieldMeta);
+      throw new Error(`Field ${field2} not found in objectRef`);
+    fieldMetaMap.set(field2, fieldMeta);
   }
   applyMixins(BaseLightModel, libLightModelRefs);
-  Reflect.defineMetadata("fields", fieldMetaMap, BaseLightModel.prototype);
+  setFieldMetaMap(BaseLightModel, fieldMetaMap);
+  setExtendRef(BaseLightModel, objectRef);
+  constantInfo.setModelType(BaseLightModel, "light");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseLightModel, key);
+  });
   return BaseLightModel;
 };
-const fullModelOf = (modelRef, lightRef, ...libFullModelRefs) => {
-  const modelFieldMetaMap = getFieldMetaMap(modelRef);
-  const lightFieldMetaMap = getFieldMetaMap(lightRef);
-  applyMixins(modelRef, [...libFullModelRefs, lightRef]);
+const fullModelOf = (objectRef, lightRef, fieldMap, ...libFullModelRefs) => {
+  const fullRef = libFullModelRefs.at(0) ?? class FullModel {
+  };
+  const fieldMetaMap = new Map([...getFieldMetaMap(objectRef), ...getFieldMetaMap(lightRef)]);
+  applyMixins(fullRef, [objectRef, lightRef, ...libFullModelRefs]);
   libFullModelRefs.forEach((libFullModelRef) => {
-    applyMixins(libFullModelRef, [lightRef, modelRef]);
+    applyMixins(libFullModelRef, [objectRef, lightRef]);
+  });
+  setFieldMetaMap(fullRef, fieldMetaMap);
+  setExtendRef(fullRef, objectRef);
+  constantInfo.setModelType(fullRef, "full");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(fullRef, key);
   });
-  lightFieldMetaMap.forEach((value, key) => modelFieldMetaMap.set(key, value));
-  return modelRef;
+  return fullRef;
 };
-function via(modelRef, fieldsOrLightModelRef, ...fullOrLightModelRefs) {
-  const classMeta = getClassMeta(modelRef);
-  if (!fieldsOrLightModelRef) {
-    if (classMeta.type === "input") {
-      const objectRefName = classMeta.refName.slice(0, -5) + "Object";
-      const isFullModelRefDefined = getFullModelRefs(objectRefName).length > 0;
-      if (isFullModelRefDefined)
-        return extendModelInputs(modelRef);
-      else
-        return baseModelOf(modelRef);
-    } else if (classMeta.modelType === "insight")
-      return extendModelInsights(modelRef);
-    else
-      throw new Error("Invalid modelRef args");
+const makeBaseScalar = (fieldMap) => {
+  class BaseScalar {
   }
-  if (Array.isArray(fieldsOrLightModelRef))
-    return lightModelOf(modelRef, fieldsOrLightModelRef, ...fullOrLightModelRefs);
-  const secondArgModelRef = fieldsOrLightModelRef;
-  const secondArgClassMeta = getClassMeta(secondArgModelRef);
-  if (classMeta.type === "input") {
-    if (secondArgClassMeta.type === "input")
-      return extendModelInputs(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
-    else if (secondArgClassMeta.type === "full")
-      return extendModelObjects(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
-    else
-      throw new Error("Invalid modelRef args");
-  } else if (classMeta.type === "full") {
-    if (secondArgClassMeta.type === "light")
-      return fullModelOf(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
+  constantInfo.setModelType(BaseScalar, "scalar");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseScalar, key);
+  });
+  return BaseScalar;
+};
+function via(firstRefOrBuildField, secondRefOrFieldsOrBuildField, thirdRefOrResolveField, ...extendRefs) {
+  if (!firstRefOrBuildField.prototype || !constantInfo.getModelType(firstRefOrBuildField, { allowEmpty: true })) {
+    const buildField = firstRefOrBuildField;
+    const fieldMap = buildField(field);
+    const extendInputRefs = [
+      ...secondRefOrFieldsOrBuildField ? [secondRefOrFieldsOrBuildField] : [],
+      ...thirdRefOrResolveField ? [thirdRefOrResolveField] : [],
+      ...extendRefs
+    ];
+    if (!secondRefOrFieldsOrBuildField)
+      return makeBaseScalar(fieldMap);
     else
-      throw new Error("Invalid modelRef args");
-  } else if (classMeta.modelType === "insight")
-    return extendModelInsights(modelRef, secondArgModelRef, ...fullOrLightModelRefs);
-  else
-    throw new Error("Invalid modelRef");
+      return extendModelInputs(fieldMap, ...extendInputRefs);
+  }
+  if (Array.isArray(secondRefOrFieldsOrBuildField)) {
+    const resolveField = thirdRefOrResolveField;
+    const fieldMap = resolveField(resolve);
+    return lightModelOf(
+      firstRefOrBuildField,
+      secondRefOrFieldsOrBuildField,
+      fieldMap,
+      ...extendRefs
+    );
+  }
+  if (!secondRefOrFieldsOrBuildField.prototype || !constantInfo.getModelType(secondRefOrFieldsOrBuildField, { allowEmpty: true })) {
+    const buildField = secondRefOrFieldsOrBuildField;
+    const fieldMap = buildField(field);
+    if (constantInfo.isScalar(firstRefOrBuildField)) {
+      if (!thirdRefOrResolveField)
+        return objectModelOf(firstRefOrBuildField, fieldMap);
+      else
+        return extendModelObjects(
+          firstRefOrBuildField,
+          fieldMap,
+          thirdRefOrResolveField,
+          ...extendRefs
+        );
+    }
+    if (constantInfo.isFull(firstRefOrBuildField)) {
+      const extendInsightRefs = [
+        ...thirdRefOrResolveField ? [thirdRefOrResolveField] : [],
+        ...extendRefs
+      ];
+      return extendModelInsights(fieldMap, ...extendInsightRefs);
+    }
+  } else {
+    const objectRef = firstRefOrBuildField;
+    const lightRef = secondRefOrFieldsOrBuildField;
+    const resolveField = thirdRefOrResolveField;
+    const fieldMap = resolveField(resolve);
+    return fullModelOf(objectRef, lightRef, fieldMap, ...extendRefs);
+  }
+  throw new Error(
+    `Invalid modelRef args ${firstRefOrBuildField} ${secondRefOrFieldsOrBuildField} ${extendRefs.join(", ")}`
+  );
 }
-const extendModelInputs = (...libInputModelRefs) => {
+const extendModelInputs = (fieldMap, ...libInputModelRefs) => {
   const baseInputModelRef = libInputModelRefs.at(0);
   const fieldMetaMap = baseInputModelRef ? getFieldMetaMap(baseInputModelRef) : /* @__PURE__ */ new Map();
   class BaseInput {
-    __ModelType__ = "input";
   }
   setFieldMetaMap(BaseInput, fieldMetaMap);
+  constantInfo.setModelType(BaseInput, "scalar");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseInput, key);
+  });
   return BaseInput;
 };
-const extendModelObjects = (inputRef, ...libObjectModelRefs) => {
+const extendModelObjects = (inputRef, fieldMap, ...libObjectModelRefs) => {
   const baseObjectModelRef = libObjectModelRefs.at(0);
   const inputFieldMetaMap = getFieldMetaMap(inputRef);
   const fieldMetaMap = baseObjectModelRef ? getFieldMetaMap(baseObjectModelRef) : /* @__PURE__ */ new Map();
   class BaseInput {
-    __ModelType__ = "object";
   }
   inputFieldMetaMap.forEach((value, key) => fieldMetaMap.set(key, value));
   setFieldMetaMap(BaseInput, fieldMetaMap);
+  constantInfo.setModelType(BaseInput, "object");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseInput, key);
+  });
   return BaseInput;
 };
-const extendModelInsights = (...insightModelRefs) => {
+const extendModelInsights = (fieldMap, ...insightModelRefs) => {
   const baseInsightModelRef = insightModelRefs.at(0);
-  const insightFieldMetaMap = baseInsightModelRef ? getFieldMetaMap(baseInsightModelRef) : /* @__PURE__ */ new Map();
+  const insightFieldMetaMap = baseInsightModelRef ? getFieldMetaMap(baseInsightModelRef) : new Map([...baseInsightFieldMetaMap]);
   class BaseInsight {
-    __ModelType__ = "insight";
   }
   setFieldMetaMap(BaseInsight, insightFieldMetaMap);
+  constantInfo.setModelType(BaseInsight, "insight");
+  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
+    fieldInfo.applyFieldMeta(BaseInsight, key);
+  });
   return BaseInsight;
 };
-const addModelOf = (modelRef, ...types) => {
-  const modelMetadataMap = getFieldMetaMap(modelRef);
-  const metadataMap = types.reduce((acc, writeRef) => {
-    const writeMetadataMap = getFieldMetaMap(writeRef);
-    applyMixins(modelRef, [writeRef]);
-    return new Map([...acc, ...writeMetadataMap]);
-  }, modelMetadataMap);
-  setFieldMetaMap(modelRef, metadataMap);
-  return modelRef;
-};
-const addFilterOf = (filterRef, ...types) => {
-  const filterMeta = getFilterMeta(filterRef);
-  const filterQueryMap = getFilterQueryMap(filterRef);
-  const metadataMap = new Map(
-    types.reduce((acc, writeRef) => {
-      const writeMetadataMap = getFilterQueryMap(writeRef);
-      applyMixins(filterRef, [writeRef]);
-      writeMetadataMap.forEach((value, key) => {
-        const filterArgMetas = getFilterArgMetas(writeRef, key);
-        setFilterArgMetasOnPrototype(filterRef.prototype, key, filterArgMetas);
-      });
-      return new Map([...acc, ...writeMetadataMap]);
-    }, filterQueryMap)
-  );
-  const filterSort = types.filter(Boolean).map((t) => getFilterSortMap(t)).reduce((acc, sort) => {
-    Object.assign(acc, sort);
-    return acc;
-  }, filterMeta.sort);
-  setFilterKeyMetaMapOnPrototype(filterRef.prototype, metadataMap);
-  setFilterMeta(filterRef, { ...filterMeta, sort: filterSort });
-  return filterRef;
-};
 export {
-  as,
   via
 };

package/esm/src/classMeta.js

@@ -1,49 +1,14 @@
 import "reflect-metadata";
-import { capitalize } from "@akanjs/common";
-import { setFilterMeta } from "./filterMeta";
-import { getClassMeta, getFieldMetas } from "./scalar";
-class InputModelStorage {
-}
-class LightModelStorage {
-}
-class FullModelStorage {
-}
-class ScalarModelStorage {
-}
-class FilterModelStorage {
-}
-const getFullModelRef = (refName) => {
-  const modelRefs = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
-  const modelRef = modelRefs?.[0];
-  if (!modelRef)
-    throw new Error(`FullModel not found - ${refName}`);
-  return modelRef;
+import { constantInfo } from "./constantInfo";
+import { getFieldMetas } from "./scalar";
+const setExtendRef = (modelRef, extendRef) => {
+  Reflect.defineMetadata("akan:extend", extendRef, modelRef.prototype);
 };
-const getFullModelRefs = (refName) => {
-  const modelRefs = Reflect.getMetadata(capitalize(refName), FullModelStorage.prototype);
-  return modelRefs ?? [];
-};
-const getInputModelRef = (refName) => {
-  const modelRefs = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
-  const modelRef = modelRefs?.[0];
-  if (!modelRef)
-    throw new Error(`InputModel not found - ${refName}`);
-  return modelRef;
-};
-const getInputModelRefs = (refName) => {
-  const modelRefs = Reflect.getMetadata(capitalize(refName), InputModelStorage.prototype);
-  return modelRefs ?? [];
-};
-const getScalarModelRef = (refName) => {
-  const modelRefs = Reflect.getMetadata(capitalize(refName), ScalarModelStorage.prototype);
-  const modelRef = modelRefs?.[0];
-  if (!modelRef)
-    throw new Error(`ScalarModel not found - ${refName}`);
-  return modelRef;
-};
-const getScalarModelRefs = (refName) => {
-  const modelRefs = Reflect.getMetadata(capitalize(refName), ScalarModelStorage.prototype);
-  return modelRefs ?? [];
+const getExtendRef = (modelRef, { allowEmpty } = {}) => {
+  const extendRef = Reflect.getMetadata("akan:extend", modelRef.prototype);
+  if (!extendRef && !allowEmpty)
+    throw new Error(`ExtendRef not found - ${modelRef.name}`);
+  return extendRef;
 };
 const getChildClassRefs = (target) => {
   const metadatas = getFieldMetas(target);
@@ -51,7 +16,7 @@ const getChildClassRefs = (target) => {
   const childRefs = metadatas.filter((metadata) => metadata.isClass).reduce((acc, metadata) => {
     return [...acc, metadata.modelRef, ...getChildClassRefs(metadata.modelRef)];
   }, []);
-  childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set(getClassMeta(modelRef).refName, modelRef));
+  childRefs.filter((modelRef, idx) => childRefs.findIndex((ref) => ref.prototype === modelRef.prototype) === idx).map((modelRef) => refMap.set(constantInfo.getRefName(modelRef), modelRef));
   return [...refMap.values()];
 };
 const getFieldEnumMetas = (modelRef) => {
@@ -64,80 +29,10 @@ const hasTextField = (modelRef) => {
     (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
   );
 };
-const applyClassMeta = (type, modelType, storage) => {
-  return function(refName) {
-    return function(target) {
-      const modelRef = target;
-      const classMeta = { refName, type, modelType, modelRef, hasTextField: hasTextField(modelRef) };
-      Reflect.defineMetadata("class", classMeta, modelRef.prototype);
-      const modelRefs = Reflect.getMetadata(capitalize(refName), storage.prototype);
-      if (modelRefs)
-        modelRefs.push(modelRef);
-      else
-        Reflect.defineMetadata(refName, [modelRef], storage.prototype);
-    };
-  };
-};
-const applyFilterMeta = (storage) => {
-  return function(refName) {
-    return function(target) {
-      const modelRef = target;
-      setFilterMeta(modelRef, { refName, sort: {} });
-      const modelRefs = Reflect.getMetadata(capitalize(refName), storage.prototype);
-      if (modelRefs)
-        modelRefs.push(modelRef);
-      else
-        Reflect.defineMetadata(refName, [modelRef], storage.prototype);
-    };
-  };
-};
-const Model = {
-  Light: applyClassMeta("light", "data", LightModelStorage),
-  Object: applyClassMeta("full", "ephemeral", FullModelStorage),
-  Full: applyClassMeta("full", "data", FullModelStorage),
-  Input: applyClassMeta("input", "data", InputModelStorage),
-  Scalar: applyClassMeta("scalar", "data", ScalarModelStorage),
-  Insight: applyClassMeta("scalar", "insight", ScalarModelStorage),
-  Filter: applyFilterMeta(FilterModelStorage)
-};
-const getLightModelRef = (modelRef) => {
-  const classMeta = getClassMeta(modelRef);
-  if (classMeta.type !== "full")
-    return modelRef;
-  const lightModelRefs = Reflect.getMetadata(`Light${classMeta.refName}`, LightModelStorage.prototype);
-  const lightModelRef = lightModelRefs?.at(-1);
-  if (!lightModelRef)
-    throw new Error(`LightModel not found - ${classMeta.refName}`);
-  return lightModelRef;
-};
-const getAllFullModelRefs = () => {
-  const modelNames = Reflect.getMetadataKeys(FullModelStorage.prototype);
-  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, FullModelStorage.prototype)).flat();
-  return modelRefs;
-};
-const getAllScalarModelRefs = () => {
-  const modelNames = Reflect.getMetadataKeys(ScalarModelStorage.prototype);
-  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, ScalarModelStorage.prototype)).flat();
-  return modelRefs;
-};
-const getAllFilterModelRefs = () => {
-  const modelNames = Reflect.getMetadataKeys(FilterModelStorage.prototype);
-  const modelRefs = modelNames.map((modelName) => Reflect.getMetadata(modelName, FilterModelStorage.prototype)).flat();
-  return modelRefs;
-};
 export {
-  Model,
-  getAllFilterModelRefs,
-  getAllFullModelRefs,
-  getAllScalarModelRefs,
   getChildClassRefs,
+  getExtendRef,
   getFieldEnumMetas,
-  getFullModelRef,
-  getFullModelRefs,
-  getInputModelRef,
-  getInputModelRefs,
-  getLightModelRef,
-  getScalarModelRef,
-  getScalarModelRefs,
-  hasTextField
+  hasTextField,
+  setExtendRef
 };

package/esm/src/constantInfo.js

@@ -0,0 +1,126 @@
+import "reflect-metadata";
+import { gqlScalarMap } from "@akanjs/base";
+import { makeCrystalize, makeDefault, makePurify } from ".";
+import { immerify } from "./immerify";
+const constantInfo = {
+  database: /* @__PURE__ */ new Map(),
+  scalar: /* @__PURE__ */ new Map(),
+  modelRefNameMap: /* @__PURE__ */ new Map(),
+  getRefName(modelRef, { allowEmpty } = {}) {
+    const refName = constantInfo.modelRefNameMap.get(modelRef);
+    if (!refName && !allowEmpty)
+      throw new Error(`No ref name for modelRef: ${modelRef}`);
+    return refName;
+  },
+  getModelType(modelRef, { allowEmpty } = {}) {
+    const modelType = Reflect.getMetadata("akan:modeltype", modelRef.prototype);
+    if (!modelType && !allowEmpty)
+      throw new Error(`No model type for modelRef: ${modelRef}`);
+    return modelType;
+  },
+  setModelType(modelRef, modelType) {
+    Reflect.defineMetadata("akan:modeltype", modelType, modelRef.prototype);
+  },
+  isObject(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "object";
+  },
+  isFull(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "full";
+  },
+  isLight(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "light";
+  },
+  isInsight(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "insight";
+  },
+  isFilter(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "filter";
+  },
+  isScalar(modelRef) {
+    return constantInfo.getModelType(modelRef, { allowEmpty: true }) === "scalar";
+  },
+  setDatabase(refName, cnst) {
+    constantInfo.database.set(refName, cnst);
+  },
+  getDatabase(refName, { allowEmpty } = {}) {
+    const info = constantInfo.database.get(refName);
+    if (!info && !allowEmpty)
+      throw new Error(`No database constant model info for ${refName}`);
+    return info;
+  },
+  setScalar(refName, cnst) {
+    if (constantInfo.scalar.has(refName))
+      return;
+    constantInfo.scalar.set(refName, cnst);
+  },
+  getScalar(refName, { allowEmpty } = {}) {
+    const model = constantInfo.scalar.get(refName);
+    if (!model && !allowEmpty)
+      throw new Error(`No scalar constant model for ${refName}`);
+    return model;
+  },
+  getModelRef(refName, modelType) {
+    if (modelType === "scalar") {
+      if (gqlScalarMap.has(refName))
+        return gqlScalarMap.get(refName);
+      else
+        return constantInfo.getScalar(refName).model;
+    } else
+      return constantInfo.getDatabase(refName)[modelType];
+  }
+};
+const cnstOf = (refName, Input, Full, Light, Insight, option = {}) => {
+  [Input, Full, Light, Insight].forEach((modelRef) => {
+    constantInfo.modelRefNameMap.set(modelRef, refName);
+  });
+  constantInfo.setModelType(Input, "input");
+  constantInfo.setModelType(Full, "full");
+  constantInfo.setModelType(Light, "light");
+  constantInfo.setModelType(Insight, "insight");
+  const cnst = {
+    refName,
+    input: Input,
+    full: Full,
+    light: Light,
+    insight: Insight,
+    crystalize: makeCrystalize(Full, option),
+    lightCrystalize: makeCrystalize(Light, option),
+    crystalizeInsight: makeCrystalize(Insight, option),
+    purify: makePurify(Input, option),
+    getDefault: () => immerify(Full, Object.assign(new Full(), makeDefault(Full, option))),
+    getDefaultInsight: () => immerify(Insight, Object.assign(new Insight(), makeDefault(Insight, option))),
+    _CapitalizedT: null,
+    _Default: null,
+    _DefaultInput: null,
+    _DefaultState: null,
+    _DefaultStateInput: null,
+    _DefaultInsight: null,
+    _PurifiedInput: null,
+    _Doc: null,
+    _DocInput: null,
+    _QueryOfDoc: null
+  };
+  constantInfo.setDatabase(refName, cnst);
+  return cnst;
+};
+const scalarCnstOf = (refName, Model) => {
+  constantInfo.setModelType(Model, "scalar");
+  constantInfo.modelRefNameMap.set(Model, refName);
+  const cnst = {
+    refName,
+    model: Model,
+    crystalize: makeCrystalize(Model),
+    purify: makePurify(Model),
+    getDefault: () => immerify(Model, Object.assign(new Model(), makeDefault(Model))),
+    _Default: null,
+    _Doc: null,
+    _PurifiedInput: null
+  };
+  constantInfo.setScalar(refName, cnst);
+  return cnst;
+};
+export {
+  cnstOf,
+  constantInfo,
+  scalarCnstOf
+};

package/esm/src/crystalize.js

@@ -0,0 +1,78 @@
+import {
+  applyFnToArrayObjects,
+  dayjs,
+  Float,
+  getNonArrayModel,
+  ID,
+  Int,
+  JSON as GqlJSON
+} from "@akanjs/base";
+import { capitalize } from "@akanjs/common";
+import { constantInfo, getFieldMetaMap } from ".";
+class CrystalizeStorage {
+}
+const scalarCrystalizeMap = /* @__PURE__ */ new Map([
+  [Date, (value) => dayjs(value)],
+  [String, (value) => value],
+  [ID, (value) => value],
+  [Boolean, (value) => value],
+  [Int, (value) => value],
+  [Float, (value) => value],
+  [GqlJSON, (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] = getNonArrayModel(metadata.of);
+    const crystalizeValue = scalarCrystalizeMap.get(valueRef) ?? ((value2) => value2);
+    return new Map(
+      Object.entries(value).map(([key, val]) => [key, applyFnToArrayObjects(val, crystalizeValue)])
+    );
+  }
+  if (metadata.isClass)
+    return makeCrystalize(metadata.modelRef)(value, true);
+  if (metadata.modelRef === Date)
+    return 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 = constantInfo.getRefName(modelRef);
+  const crystalName = `${constantInfo.isLight(modelRef) ? "Light" : ""}${capitalize(refName)}${constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
+  const crystalizeFn = getPredefinedCrystalizeFn(crystalName);
+  if (crystalizeFn && !option.overwrite && !option.partial?.length)
+    return crystalizeFn;
+  const fieldMetaMap = getFieldMetaMap(modelRef);
+  const fieldKeys = option.partial?.length ? 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;
+};
+export {
+  makeCrystalize
+};