@akanjs/constant 1.0.5 → 1.0.6

package/cjs/src/purify.js

@@ -38,65 +38,53 @@ 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))
+const purify = (field, key, value, self) => {
+  if (field.nullable && (value === null || value === void 0 || typeof value === "number" && isNaN(value) || typeof value === "string" && !value.length))
     return null;
-  if (metadata.isArray) {
+  if (field.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));
+      throw new Error(`Invalid Array Value in ${key} for value ${value}`);
+    if (field.minlength && value.length < field.minlength)
+      throw new Error(`Invalid Array Length (Min) in ${key} for value ${value}`);
+    else if (field.maxlength && value.length > field.maxlength)
+      throw new Error(`Invalid Array Length (Max) in ${key} for value ${value}`);
+    else if (field.optArrDepth === 0 && field.validate && !field.validate(value, self))
+      throw new Error(`Invalid Array Value (Failed to pass validation) in ${key} for value ${value}`);
+    return value.map((v) => purify({ ...field, isArray: false }, key, v, v));
   }
-  if (metadata.isMap && metadata.of) {
-    const purifyFn2 = getPurifyFn(metadata.of);
+  if (field.isMap && field.of) {
+    const purifyFn2 = getPurifyFn(field.of);
     return Object.fromEntries(
-      [...value.entries()].map(([key, val]) => [key, (0, import_base.applyFnToArrayObjects)(val, purifyFn2)])
+      [...value.entries()].map(([key2, val]) => [key2, (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);
+  if (field.isClass)
+    return makePurify(field.modelRef)(value, true);
+  if (field.modelRef === Date && (0, import_base.dayjs)(value).isBefore((0, import_base.dayjs)(/* @__PURE__ */ new Date("0000"))))
+    throw new Error(`Invalid Date Value (Default) in ${key} for value ${value}`);
+  if ([String, import_base.ID].includes(field.modelRef) && (value === "" || !value))
+    throw new Error(`Invalid String Value (Default) in ${key} for value ${value}`);
+  if (field.validate && !field.validate(value, self))
+    throw new Error(`Invalid Value (Failed to pass validation) / ${value} in ${key}`);
+  if (!field.nullable && !value && value !== 0 && value !== false)
+    throw new Error(`Invalid Value (Nullable) in ${key} for value ${value}`);
+  const purifyFn = getPurifyFn(field.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 makePurify = (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}`);
+          throw new Error(`Invalid Value (No ID) for id ${modelRef}`);
         return id;
       }
       const result = {};
-      for (const metadata of metadatas) {
-        const value = self[metadata.key];
-        result[metadata.key] = purify(metadata, value, self);
-      }
+      Object.entries(modelRef.field).forEach(([key, field]) => {
+        const value = self[key];
+        result[key] = purify(field.getProps(), key, value, self);
+      });
       return result;
     } catch (err) {
       if (isChild)
@@ -105,6 +93,5 @@ const makePurify = (modelRef, option = {}) => {
       return null;
     }
   };
-  setPredefinedPurifyFn(refName, fn);
   return fn;
 };

package/cjs/src/scalar.js

@@ -18,15 +18,10 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var scalar_exports = {};
 __export(scalar_exports, {
   fieldPresets: () => fieldPresets,
-  getFieldMetaMap: () => getFieldMetaMap,
-  getFieldMetaMapOnPrototype: () => getFieldMetaMapOnPrototype,
-  getFieldMetas: () => getFieldMetas,
   getGqlTypeStr: () => getGqlTypeStr,
   getScalarExample: () => getScalarExample,
   isConstantModel: () => isConstantModel,
-  scalarExampleMap: () => scalarExampleMap,
-  setFieldMetaMap: () => setFieldMetaMap,
-  setFieldMetaMapOnPrototype: () => setFieldMetaMapOnPrototype
+  scalarExampleMap: () => scalarExampleMap
 });
 module.exports = __toCommonJS(scalar_exports);
 var import_reflect_metadata = require("reflect-metadata");
@@ -47,30 +42,6 @@ const scalarExampleMap = /* @__PURE__ */ new Map([
 const getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
 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)
-  );
-};
 const isConstantModel = (modelRef) => {
   return Reflect.getMetadata("class", modelRef.prototype) !== void 0;
 };
-const getFieldMetaMap = (modelRef) => {
-  const [target] = (0, import_base.getNonArrayModel)(modelRef);
-  const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
-  return metadataMap;
-};
-const setFieldMetaMap = (modelRef, metadataMap) => {
-  const [target] = (0, import_base.getNonArrayModel)(modelRef);
-  Reflect.defineMetadata("fields", metadataMap, target.prototype);
-};
-const getFieldMetaMapOnPrototype = (prototype) => {
-  const metadataMap = Reflect.getMetadata("fields", prototype) ?? /* @__PURE__ */ new Map();
-  return metadataMap;
-};
-const setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
-  Reflect.defineMetadata("fields", metadataMap, prototype);
-};

package/cjs/src/serialize.js

@@ -56,9 +56,9 @@ const serializeInput = (value, inputRef, arrDepth) => {
     return value;
   else
     return Object.fromEntries(
-      (0, import__.getFieldMetas)(inputRef).map((fieldMeta) => [
-        fieldMeta.key,
-        serializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
+      Object.entries(inputRef.field).map(([key, field]) => [
+        key,
+        serializeInput(value[key], field.modelRef, field.arrDepth)
       ])
     );
 };
@@ -101,9 +101,9 @@ const deserializeInput = (value, inputRef, arrDepth) => {
     return value;
   else
     return Object.fromEntries(
-      (0, import__.getFieldMetas)(inputRef).map((fieldMeta) => [
-        fieldMeta.key,
-        deserializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
+      Object.entries(inputRef.field).map(([key, field]) => [
+        key,
+        deserializeInput(value[key], field.modelRef, field.arrDepth)
       ])
     );
 };

package/esm/src/baseGql.js

@@ -1,93 +1,89 @@
 import "reflect-metadata";
-import { ID, Int } from "@akanjs/base";
 import { applyMixins } from "@akanjs/common";
-import { setExtendRef } from "./classMeta";
+import { immerable } from "immer";
+import { crystalize, makeDefault } from ".";
 import { constantInfo } from "./constantInfo";
 import {
+  ConstantField,
   field,
   resolve
 } from "./fieldInfo";
-import { getFieldMetaMap, setFieldMetaMap } from "./scalar";
-const defaultFieldMeta = {
-  fieldType: "property",
-  immutable: false,
-  select: true,
-  isClass: false,
-  isScalar: true,
-  nullable: false,
-  isArray: false,
-  arrDepth: 0,
-  optArrDepth: 0,
-  default: null,
-  isMap: false,
-  meta: {}
-};
-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 } }]
-]);
+import { makePurify } from "./purify";
 const objectModelOf = (inputRef, fieldMap) => {
-  class ObjectModel {
-  }
-  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 field2 = Object.assign(
+    ConstantField.getBaseModelField(),
+    inputRef.field,
+    Object.fromEntries(Object.entries(fieldMap).map(([key, fieldInfo]) => [key, fieldInfo.toField()]))
+  );
+  const baseObjectModelRef = getBaseConstantClass(field2);
+  applyConstantStatics(baseObjectModelRef);
+  constantInfo.setModelType(baseObjectModelRef, "object");
+  return baseObjectModelRef;
 };
 const lightModelOf = (objectRef, fields, fieldMap, ...libLightModelRefs) => {
-  const objectFieldMetaMap = getFieldMetaMap(objectRef);
-  const baseLightModelRef = libLightModelRefs.at(0);
-  const fieldMetaMap = baseLightModelRef ? getFieldMetaMap(baseLightModelRef) : new Map([...baseFieldMetaMap]);
-  class BaseLightModel {
-  }
-  for (const field2 of fields) {
-    const fieldMeta = objectFieldMetaMap.get(field2);
-    if (!fieldMeta)
-      throw new Error(`Field ${field2} not found in objectRef`);
-    fieldMetaMap.set(field2, fieldMeta);
-  }
-  applyMixins(BaseLightModel, libLightModelRefs);
-  setFieldMetaMap(BaseLightModel, fieldMetaMap);
-  setExtendRef(BaseLightModel, objectRef);
-  constantInfo.setModelType(BaseLightModel, "light");
-  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
-    fieldInfo.applyFieldMeta(BaseLightModel, key);
-  });
-  return BaseLightModel;
+  const libLightModelRef = libLightModelRefs.at(0);
+  const field2 = Object.assign(
+    libLightModelRef?.field ?? ConstantField.getBaseModelField(),
+    Object.fromEntries(Object.entries(fieldMap).map(([key, field3]) => [key, field3.toField()])),
+    Object.fromEntries(fields.map((field3) => [field3, objectRef.field[field3]]))
+  );
+  const baseLightModelRef = getBaseConstantClass(field2);
+  applyConstantStatics(baseLightModelRef);
+  applyMixins(baseLightModelRef, libLightModelRefs);
+  constantInfo.setModelType(baseLightModelRef, "light");
+  return baseLightModelRef;
 };
 const fullModelOf = (objectRef, lightRef, fieldMap, ...libFullModelRefs) => {
-  const fullRef = libFullModelRefs.at(0) ?? class FullModel {
-  };
-  const fieldMetaMap = new Map([...getFieldMetaMap(objectRef), ...getFieldMetaMap(lightRef)]);
+  const fullRef = libFullModelRefs.at(0) ?? getBaseConstantClass(ConstantField.getBaseModelField());
+  Object.assign(
+    fullRef.field,
+    objectRef.field,
+    lightRef.field,
+    Object.fromEntries(Object.entries(fieldMap).map(([key, field2]) => [key, field2.toField()]))
+  );
   applyMixins(fullRef, [objectRef, lightRef, ...libFullModelRefs]);
   libFullModelRefs.forEach((libFullModelRef) => {
     applyMixins(libFullModelRef, [objectRef, lightRef]);
   });
-  setFieldMetaMap(fullRef, fieldMetaMap);
-  setExtendRef(fullRef, objectRef);
+  applyConstantStatics(fullRef);
   constantInfo.setModelType(fullRef, "full");
-  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
-    fieldInfo.applyFieldMeta(fullRef, key);
-  });
   return fullRef;
 };
-const makeBaseScalar = (fieldMap) => {
-  class BaseScalar {
+const getBaseConstantClass = (field2) => {
+  class BaseConstant {
+    static field = field2;
+    [immerable] = true;
+    constructor(obj) {
+      Object.assign(this, this.constructor.default);
+      if (obj)
+        this.set(obj);
+    }
+    set(obj) {
+      Object.entries(obj).forEach(([key, value]) => {
+        if (!this.constructor.field[key])
+          return;
+        const fieldProp = this.constructor.field[key].getProps();
+        this[key] = crystalize(fieldProp, value);
+      });
+      return this;
+    }
   }
-  constantInfo.setModelType(BaseScalar, "scalar");
-  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
-    fieldInfo.applyFieldMeta(BaseScalar, key);
+  return BaseConstant;
+};
+const makeBaseScalar = (fieldMap) => {
+  const fieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field2]) => [key, field2.toField()]));
+  const baseScalarRef = getBaseConstantClass(fieldObject);
+  applyConstantStatics(baseScalarRef);
+  constantInfo.setModelType(baseScalarRef, "scalar");
+  return baseScalarRef;
+};
+const applyConstantStatics = (model) => {
+  Object.assign(model, {
+    purify: makePurify(model),
+    default: makeDefault(model.field)
+    // getDefault: () => immerify(model, Object.assign(new model() as object, defaultFn)),
   });
-  return BaseScalar;
+  return model;
 };
 function via(firstRefOrBuildField, secondRefOrFieldsOrBuildField, thirdRefOrResolveField, ...extendRefs) {
   if (!firstRefOrBuildField.prototype || !constantInfo.getModelType(firstRefOrBuildField, { allowEmpty: true })) {
@@ -147,41 +143,37 @@ function via(firstRefOrBuildField, secondRefOrFieldsOrBuildField, thirdRefOrReso
 }
 const extendModelInputs = (fieldMap, ...libInputModelRefs) => {
   const baseInputModelRef = libInputModelRefs.at(0);
-  const fieldMetaMap = baseInputModelRef ? getFieldMetaMap(baseInputModelRef) : /* @__PURE__ */ new Map();
-  class BaseInput {
-  }
-  setFieldMetaMap(BaseInput, fieldMetaMap);
-  constantInfo.setModelType(BaseInput, "scalar");
-  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
-    fieldInfo.applyFieldMeta(BaseInput, key);
-  });
-  return BaseInput;
+  const fieldObject = Object.assign(
+    baseInputModelRef?.field ?? {},
+    Object.fromEntries(Object.entries(fieldMap).map(([key, field2]) => [key, field2.toField()]))
+  );
+  const baseInputRef = getBaseConstantClass(fieldObject);
+  applyConstantStatics(baseInputRef);
+  constantInfo.setModelType(baseInputRef, "scalar");
+  return baseInputRef;
 };
 const extendModelObjects = (inputRef, fieldMap, ...libObjectModelRefs) => {
   const baseObjectModelRef = libObjectModelRefs.at(0);
-  const inputFieldMetaMap = getFieldMetaMap(inputRef);
-  const fieldMetaMap = baseObjectModelRef ? getFieldMetaMap(baseObjectModelRef) : /* @__PURE__ */ new Map();
-  class BaseInput {
-  }
-  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 field2 = Object.assign(
+    baseObjectModelRef?.field ?? {},
+    inputRef.field,
+    Object.fromEntries(Object.entries(fieldMap).map(([key, fieldInfo]) => [key, fieldInfo.toField()]))
+  );
+  const baseInputRef = getBaseConstantClass(field2);
+  applyConstantStatics(baseInputRef);
+  constantInfo.setModelType(baseInputRef, "object");
+  return baseInputRef;
 };
 const extendModelInsights = (fieldMap, ...insightModelRefs) => {
   const baseInsightModelRef = insightModelRefs.at(0);
-  const insightFieldMetaMap = baseInsightModelRef ? getFieldMetaMap(baseInsightModelRef) : new Map([...baseInsightFieldMetaMap]);
-  class BaseInsight2 {
-  }
-  setFieldMetaMap(BaseInsight2, insightFieldMetaMap);
-  constantInfo.setModelType(BaseInsight2, "insight");
-  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
-    fieldInfo.applyFieldMeta(BaseInsight2, key);
-  });
-  return BaseInsight2;
+  const field2 = Object.assign(
+    baseInsightModelRef?.field ?? ConstantField.getBaseInsightField(),
+    Object.fromEntries(Object.entries(fieldMap).map(([key, fieldInfo]) => [key, fieldInfo.toField()]))
+  );
+  const baseInsightRef = getBaseConstantClass(field2);
+  applyConstantStatics(baseInsightRef);
+  constantInfo.setModelType(baseInsightRef, "insight");
+  return baseInsightRef;
 };
 export {
   via

package/esm/src/classMeta.js

@@ -1,38 +1,23 @@
 import "reflect-metadata";
 import { constantInfo } from "./constantInfo";
-import { getFieldMetas } from "./scalar";
-const setExtendRef = (modelRef, extendRef) => {
-  Reflect.defineMetadata("akan:extend", extendRef, modelRef.prototype);
-};
-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);
   const refMap = /* @__PURE__ */ new Map();
-  const childRefs = metadatas.filter((metadata) => metadata.isClass).reduce((acc, metadata) => {
-    return [...acc, metadata.modelRef, ...getChildClassRefs(metadata.modelRef)];
+  const childRefs = Object.entries(target.field).filter(([_, field]) => field.isClass).reduce((acc, [key, field]) => {
+    return [...acc, field.modelRef, ...getChildClassRefs(field.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) => {
-  const fieldMetas = getFieldMetas(modelRef);
-  return fieldMetas.filter((fieldMeta) => !!fieldMeta.enum).map((fieldMeta) => ({ key: fieldMeta.key, enum: fieldMeta.enum }));
+  return Object.entries(modelRef.field).filter(([_, field]) => !!field.enum).map(([key, field]) => ({ key, enum: field.enum }));
 };
 const hasTextField = (modelRef) => {
-  const fieldMetas = getFieldMetas(modelRef);
-  return fieldMetas.some(
-    (fieldMeta) => !!fieldMeta.text || fieldMeta.isScalar && fieldMeta.isClass && fieldMeta.select && hasTextField(fieldMeta.modelRef)
+  return Object.entries(modelRef.field).some(
+    ([_, field]) => !!field.text || field.isScalar && field.isClass && field.select && hasTextField(field.modelRef)
   );
 };
 export {
   getChildClassRefs,
-  getExtendRef,
   getFieldEnumMetas,
-  hasTextField,
-  setExtendRef
+  hasTextField
 };

package/esm/src/constantInfo.js

@@ -1,7 +1,5 @@
 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(),
@@ -69,7 +67,7 @@ const constantInfo = {
       return constantInfo.getDatabase(refName)[modelType];
   }
 };
-const cnstOf = (refName, inputRef, objectRef, fullRef, lightRef, insightRef, option = {}) => {
+const cnstOf = (refName, inputRef, objectRef, fullRef, lightRef, insightRef) => {
   [inputRef, objectRef, fullRef, lightRef, insightRef].forEach((modelRef) => {
     constantInfo.modelRefNameMap.set(modelRef, refName);
   });
@@ -85,12 +83,6 @@ const cnstOf = (refName, inputRef, objectRef, fullRef, lightRef, insightRef, opt
     full: fullRef,
     light: lightRef,
     insight: insightRef,
-    crystalize: makeCrystalize(fullRef, option),
-    lightCrystalize: makeCrystalize(lightRef, option),
-    crystalizeInsight: makeCrystalize(insightRef, option),
-    purify: makePurify(inputRef, option),
-    getDefault: () => immerify(fullRef, Object.assign(new fullRef(), makeDefault(fullRef, option))),
-    getDefaultInsight: () => immerify(insightRef, Object.assign(new insightRef(), makeDefault(insightRef, option))),
     _CapitalizedT: null,
     _Default: null,
     _DefaultInput: null,
@@ -111,9 +103,6 @@ const scalarCnstOf = (refName, Model) => {
   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

package/esm/src/crystalize.js

@@ -7,10 +7,7 @@ import {
   Int,
   JSON as GqlJSON
 } from "@akanjs/base";
-import { capitalize } from "@akanjs/common";
-import { constantInfo, getFieldMetaMap } from ".";
-class CrystalizeStorage {
-}
+import { constantInfo } from ".";
 const scalarCrystalizeMap = /* @__PURE__ */ new Map([
   [Date, (value) => dayjs(value)],
   [String, (value) => value],
@@ -20,13 +17,13 @@ const scalarCrystalizeMap = /* @__PURE__ */ new Map([
   [Float, (value) => value],
   [GqlJSON, (value) => value]
 ]);
-const crystalize = (metadata, value) => {
+const crystalize = (field, 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);
+  if (field.isArray && Array.isArray(value))
+    return value.map((v) => crystalize({ ...field, isArray: false }, v));
+  if (field.isMap) {
+    const [valueRef] = getNonArrayModel(field.of);
     const crystalizeValue = scalarCrystalizeMap.get(valueRef) ?? ((value2) => value2);
     return new Map(
       Object.entries(value).map(([key, val]) => [
@@ -35,36 +32,23 @@ const crystalize = (metadata, value) => {
       ])
     );
   }
-  if (metadata.isClass)
-    return makeCrystalize(metadata.modelRef)(value, true);
-  if (metadata.modelRef === Date)
+  if (field.isClass)
+    return new field.modelRef().set(value);
+  if (field.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);
+  return (scalarCrystalizeMap.get(field.modelRef) ?? ((value2) => value2))(value);
 };
 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 fieldKeys = option.partial?.length ? constantInfo.isScalar(modelRef) ? option.partial : ["id", ...option.partial, "updatedAt"] : Object.keys(modelRef.field);
   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]);
-      }
+      const result = new modelRef().set(self);
+      fieldKeys.forEach((key) => {
+        const field = modelRef.field[key];
+        if (field.fieldType === "hidden")
+          return;
+        result[key] = crystalize(field.getProps(), self[key]);
+      });
       return result;
     } catch (err) {
       if (isChild)
@@ -72,10 +56,9 @@ const makeCrystalize = (modelRef, option = {}) => {
       return null;
     }
   };
-  if (!option.partial?.length)
-    setPredefinedCrystalizeFn(crystalName, fn);
   return fn;
 };
 export {
+  crystalize,
   makeCrystalize
 };

package/esm/src/default.js

@@ -1,44 +1,23 @@
 import { scalarDefaultMap } from "@akanjs/base";
-import { capitalize } from "@akanjs/common";
-import { constantInfo } from "./constantInfo";
-import { getFieldMetas } from "./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 = constantInfo.getRefName(modelRef);
-  const defaultName = `${capitalize(refName)}${constantInfo.isInsight(modelRef) ? "Insight" : ""}`;
-  const predefinedDefault = getPredefinedDefault(defaultName);
-  if (predefinedDefault && !option.overwrite)
-    return predefinedDefault;
-  if (option.isChild && constantInfo.isScalar(modelRef))
-    return null;
-  const metadatas = getFieldMetas(modelRef);
+const makeDefault = (fieldObj) => {
   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();
+  for (const [key, field] of Object.entries(fieldObj)) {
+    if (field.fieldType === "hidden")
+      result[key] = null;
+    else if (field.default) {
+      if (typeof field.default === "function")
+        result[key] = field.default();
       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;
+        result[key] = field.default;
+    } else if (field.isArray)
+      result[key] = [];
+    else if (field.nullable)
+      result[key] = null;
+    else if (field.isClass)
+      result[key] = field.isScalar ? makeDefault(field.modelRef.field) : null;
     else
-      result[metadata.key] = scalarDefaultMap.get(metadata.modelRef);
+      result[key] = scalarDefaultMap.get(field.modelRef);
   }
-  setPredefinedDefault(defaultName, result);
   return result;
 };
 export {