@akanjs/constant 1.0.5 → 1.0.6

package/cjs/src/baseGql.js

@@ -21,92 +21,87 @@ __export(baseGql_exports, {
 });
 module.exports = __toCommonJS(baseGql_exports);
 var import_reflect_metadata = require("reflect-metadata");
-var import_base = require("@akanjs/base");
 var import_common = require("@akanjs/common");
-var import_classMeta = require("./classMeta");
+var import_immer = require("immer");
+var import__ = require(".");
 var import_constantInfo = require("./constantInfo");
 var import_fieldInfo = require("./fieldInfo");
-var import_scalar = require("./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: import_base.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: import_base.Int, default: 0, accumulate: { $sum: 1 } }]
-]);
+var import_purify = require("./purify");
 const objectModelOf = (inputRef, fieldMap) => {
-  class ObjectModel {
-  }
-  const metadataMap = new Map([...baseFieldMetaMap, ...(0, import_scalar.getFieldMetaMap)(inputRef)]);
-  (0, import_scalar.setFieldMetaMap)(ObjectModel, metadataMap);
-  (0, import_classMeta.setExtendRef)(ObjectModel, inputRef);
-  import_constantInfo.constantInfo.setModelType(ObjectModel, "object");
-  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
-    fieldInfo.applyFieldMeta(ObjectModel, key);
-  });
-  return ObjectModel;
+  const field2 = Object.assign(
+    import_fieldInfo.ConstantField.getBaseModelField(),
+    inputRef.field,
+    Object.fromEntries(Object.entries(fieldMap).map(([key, fieldInfo]) => [key, fieldInfo.toField()]))
+  );
+  const baseObjectModelRef = getBaseConstantClass(field2);
+  applyConstantStatics(baseObjectModelRef);
+  import_constantInfo.constantInfo.setModelType(baseObjectModelRef, "object");
+  return baseObjectModelRef;
 };
 const lightModelOf = (objectRef, fields, fieldMap, ...libLightModelRefs) => {
-  const objectFieldMetaMap = (0, import_scalar.getFieldMetaMap)(objectRef);
-  const baseLightModelRef = libLightModelRefs.at(0);
-  const fieldMetaMap = baseLightModelRef ? (0, import_scalar.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);
-  }
-  (0, import_common.applyMixins)(BaseLightModel, libLightModelRefs);
-  (0, import_scalar.setFieldMetaMap)(BaseLightModel, fieldMetaMap);
-  (0, import_classMeta.setExtendRef)(BaseLightModel, objectRef);
-  import_constantInfo.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 ?? import_fieldInfo.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);
+  (0, import_common.applyMixins)(baseLightModelRef, libLightModelRefs);
+  import_constantInfo.constantInfo.setModelType(baseLightModelRef, "light");
+  return baseLightModelRef;
 };
 const fullModelOf = (objectRef, lightRef, fieldMap, ...libFullModelRefs) => {
-  const fullRef = libFullModelRefs.at(0) ?? class FullModel {
-  };
-  const fieldMetaMap = new Map([...(0, import_scalar.getFieldMetaMap)(objectRef), ...(0, import_scalar.getFieldMetaMap)(lightRef)]);
+  const fullRef = libFullModelRefs.at(0) ?? getBaseConstantClass(import_fieldInfo.ConstantField.getBaseModelField());
+  Object.assign(
+    fullRef.field,
+    objectRef.field,
+    lightRef.field,
+    Object.fromEntries(Object.entries(fieldMap).map(([key, field2]) => [key, field2.toField()]))
+  );
   (0, import_common.applyMixins)(fullRef, [objectRef, lightRef, ...libFullModelRefs]);
   libFullModelRefs.forEach((libFullModelRef) => {
     (0, import_common.applyMixins)(libFullModelRef, [objectRef, lightRef]);
   });
-  (0, import_scalar.setFieldMetaMap)(fullRef, fieldMetaMap);
-  (0, import_classMeta.setExtendRef)(fullRef, objectRef);
+  applyConstantStatics(fullRef);
   import_constantInfo.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;
+    [import_immer.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] = (0, import__.crystalize)(fieldProp, value);
+      });
+      return this;
+    }
   }
-  import_constantInfo.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);
+  import_constantInfo.constantInfo.setModelType(baseScalarRef, "scalar");
+  return baseScalarRef;
+};
+const applyConstantStatics = (model) => {
+  Object.assign(model, {
+    purify: (0, import_purify.makePurify)(model),
+    default: (0, import__.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 || !import_constantInfo.constantInfo.getModelType(firstRefOrBuildField, { allowEmpty: true })) {
@@ -166,39 +161,35 @@ function via(firstRefOrBuildField, secondRefOrFieldsOrBuildField, thirdRefOrReso
 }
 const extendModelInputs = (fieldMap, ...libInputModelRefs) => {
   const baseInputModelRef = libInputModelRefs.at(0);
-  const fieldMetaMap = baseInputModelRef ? (0, import_scalar.getFieldMetaMap)(baseInputModelRef) : /* @__PURE__ */ new Map();
-  class BaseInput {
-  }
-  (0, import_scalar.setFieldMetaMap)(BaseInput, fieldMetaMap);
-  import_constantInfo.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);
+  import_constantInfo.constantInfo.setModelType(baseInputRef, "scalar");
+  return baseInputRef;
 };
 const extendModelObjects = (inputRef, fieldMap, ...libObjectModelRefs) => {
   const baseObjectModelRef = libObjectModelRefs.at(0);
-  const inputFieldMetaMap = (0, import_scalar.getFieldMetaMap)(inputRef);
-  const fieldMetaMap = baseObjectModelRef ? (0, import_scalar.getFieldMetaMap)(baseObjectModelRef) : /* @__PURE__ */ new Map();
-  class BaseInput {
-  }
-  inputFieldMetaMap.forEach((value, key) => fieldMetaMap.set(key, value));
-  (0, import_scalar.setFieldMetaMap)(BaseInput, fieldMetaMap);
-  import_constantInfo.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);
+  import_constantInfo.constantInfo.setModelType(baseInputRef, "object");
+  return baseInputRef;
 };
 const extendModelInsights = (fieldMap, ...insightModelRefs) => {
   const baseInsightModelRef = insightModelRefs.at(0);
-  const insightFieldMetaMap = baseInsightModelRef ? (0, import_scalar.getFieldMetaMap)(baseInsightModelRef) : new Map([...baseInsightFieldMetaMap]);
-  class BaseInsight2 {
-  }
-  (0, import_scalar.setFieldMetaMap)(BaseInsight2, insightFieldMetaMap);
-  import_constantInfo.constantInfo.setModelType(BaseInsight2, "insight");
-  Object.entries(fieldMap).forEach(([key, fieldInfo]) => {
-    fieldInfo.applyFieldMeta(BaseInsight2, key);
-  });
-  return BaseInsight2;
+  const field2 = Object.assign(
+    baseInsightModelRef?.field ?? import_fieldInfo.ConstantField.getBaseInsightField(),
+    Object.fromEntries(Object.entries(fieldMap).map(([key, fieldInfo]) => [key, fieldInfo.toField()]))
+  );
+  const baseInsightRef = getBaseConstantClass(field2);
+  applyConstantStatics(baseInsightRef);
+  import_constantInfo.constantInfo.setModelType(baseInsightRef, "insight");
+  return baseInsightRef;
 };

package/cjs/src/classMeta.js

@@ -18,40 +18,25 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var classMeta_exports = {};
 __export(classMeta_exports, {
   getChildClassRefs: () => getChildClassRefs,
-  getExtendRef: () => getExtendRef,
   getFieldEnumMetas: () => getFieldEnumMetas,
-  hasTextField: () => hasTextField,
-  setExtendRef: () => setExtendRef
+  hasTextField: () => hasTextField
 });
 module.exports = __toCommonJS(classMeta_exports);
 var import_reflect_metadata = require("reflect-metadata");
 var import_constantInfo = require("./constantInfo");
-var import_scalar = require("./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 = (0, import_scalar.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(import_constantInfo.constantInfo.getRefName(modelRef), modelRef));
   return [...refMap.values()];
 };
 const getFieldEnumMetas = (modelRef) => {
-  const fieldMetas = (0, import_scalar.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 = (0, import_scalar.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)
   );
 };

package/cjs/src/constantInfo.js

@@ -24,8 +24,6 @@ __export(constantInfo_exports, {
 module.exports = __toCommonJS(constantInfo_exports);
 var import_reflect_metadata = require("reflect-metadata");
 var import_base = require("@akanjs/base");
-var import__ = require(".");
-var import_immerify = require("./immerify");
 const constantInfo = {
   database: /* @__PURE__ */ new Map(),
   scalar: /* @__PURE__ */ new Map(),
@@ -93,7 +91,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);
   });
@@ -109,12 +107,6 @@ const cnstOf = (refName, inputRef, objectRef, fullRef, lightRef, insightRef, opt
     full: fullRef,
     light: lightRef,
     insight: insightRef,
-    crystalize: (0, import__.makeCrystalize)(fullRef, option),
-    lightCrystalize: (0, import__.makeCrystalize)(lightRef, option),
-    crystalizeInsight: (0, import__.makeCrystalize)(insightRef, option),
-    purify: (0, import__.makePurify)(inputRef, option),
-    getDefault: () => (0, import_immerify.immerify)(fullRef, Object.assign(new fullRef(), (0, import__.makeDefault)(fullRef, option))),
-    getDefaultInsight: () => (0, import_immerify.immerify)(insightRef, Object.assign(new insightRef(), (0, import__.makeDefault)(insightRef, option))),
     _CapitalizedT: null,
     _Default: null,
     _DefaultInput: null,
@@ -135,9 +127,6 @@ const scalarCnstOf = (refName, Model) => {
   const cnst = {
     refName,
     model: Model,
-    crystalize: (0, import__.makeCrystalize)(Model),
-    purify: (0, import__.makePurify)(Model),
-    getDefault: () => (0, import_immerify.immerify)(Model, Object.assign(new Model(), (0, import__.makeDefault)(Model))),
     _Default: null,
     _Doc: null,
     _PurifiedInput: null

package/cjs/src/crystalize.js

@@ -17,14 +17,12 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var crystalize_exports = {};
 __export(crystalize_exports, {
+  crystalize: () => crystalize,
   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],
@@ -34,13 +32,13 @@ const scalarCrystalizeMap = /* @__PURE__ */ new Map([
   [import_base.Float, (value) => value],
   [import_base.JSON, (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] = (0, import_base.getNonArrayModel)(metadata.of);
+  if (field.isArray && Array.isArray(value))
+    return value.map((v) => crystalize({ ...field, isArray: false }, v));
+  if (field.isMap) {
+    const [valueRef] = (0, import_base.getNonArrayModel)(field.of);
     const crystalizeValue = scalarCrystalizeMap.get(valueRef) ?? ((value2) => value2);
     return new Map(
       Object.entries(value).map(([key, val]) => [
@@ -49,36 +47,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 (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);
+  return (scalarCrystalizeMap.get(field.modelRef) ?? ((value2) => value2))(value);
 };
 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 fieldKeys = option.partial?.length ? import__.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)
@@ -86,7 +71,5 @@ const makeCrystalize = (modelRef, option = {}) => {
       return null;
     }
   };
-  if (!option.partial?.length)
-    setPredefinedCrystalizeFn(crystalName, fn);
   return fn;
 };

package/cjs/src/default.js

@@ -21,45 +21,24 @@ __export(default_exports, {
 });
 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 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] = import_base.scalarDefaultMap.get(metadata.modelRef);
+      result[key] = import_base.scalarDefaultMap.get(field.modelRef);
   }
-  setPredefinedDefault(defaultName, result);
   return result;
 };

package/cjs/src/fieldInfo.js

@@ -17,13 +17,13 @@ var __copyProps = (to, from, except, desc) => {
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var fieldInfo_exports = {};
 __export(fieldInfo_exports, {
+  ConstantField: () => ConstantField,
   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;
@@ -43,15 +43,81 @@ class FieldInfo {
     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);
+  toField() {
+    return ConstantField.fromFieldInfo(this);
+  }
+}
+class ConstantField {
+  static getBaseModelField() {
+    return {
+      id: field(import_base.ID).toField(),
+      createdAt: field(Date).toField(),
+      updatedAt: field(Date).toField(),
+      removedAt: field(Date).optional().toField()
+    };
+  }
+  static getBaseInsightField() {
+    return {
+      count: field(import_base.Int, { default: 0, accumulate: { $sum: 1 } }).toField()
+    };
+  }
+  nullable;
+  ref;
+  refPath;
+  refType;
+  default;
+  type;
+  fieldType;
+  immutable;
+  min;
+  max;
+  enum;
+  select;
+  minlength;
+  maxlength;
+  accumulate;
+  example;
+  of;
+  // for Map type fields
+  validate;
+  text;
+  modelRef;
+  arrDepth;
+  optArrDepth;
+  meta;
+  constructor(props) {
+    this.nullable = props.nullable;
+    this.ref = props.ref;
+    this.refPath = props.refPath;
+    this.refType = props.refType;
+    this.default = props.default;
+    this.type = props.type;
+    this.fieldType = props.fieldType;
+    this.immutable = props.immutable;
+    this.min = props.min;
+    this.max = props.max;
+    this.enum = props.enum;
+    this.select = props.select;
+    this.minlength = props.minlength;
+    this.maxlength = props.maxlength;
+    this.accumulate = props.accumulate;
+    this.example = props.example;
+    this.of = props.of;
+    this.validate = props.validate;
+    this.text = props.text;
+    this.modelRef = props.modelRef;
+    this.arrDepth = props.arrDepth;
+    this.optArrDepth = props.optArrDepth;
+    this.meta = props.meta;
+  }
+  static fromFieldInfo(fieldInfo) {
+    const [modelRef, arrDepth] = (0, import_base.getNonArrayModel)(fieldInfo.type);
+    const [option, optArrDepth] = (0, import_base.getNonArrayModel)(fieldInfo.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 = {
+    return new ConstantField({
       nullable: option.nullable ?? (option.default === "" ? true : false),
       ref: option.ref,
       refPath: option.refPath,
@@ -68,22 +134,57 @@ class FieldInfo {
       maxlength: option.maxlength,
       accumulate: option.accumulate,
       example: option.example,
+      of: option.of,
       validate: option.validate,
-      key,
-      isClass,
-      isScalar: import_constantInfo.constantInfo.isScalar(modelRef),
+      text: option.text,
       modelRef,
       arrDepth,
-      isArray,
       optArrDepth,
-      isMap,
-      of: option.of,
-      text: option.text,
       meta: option.meta ?? {}
+    });
+  }
+  get isClass() {
+    return !(0, import_base.isGqlScalar)(this.modelRef);
+  }
+  get isScalar() {
+    return import_constantInfo.constantInfo.isScalar(this.modelRef) || (0, import_base.isGqlScalar)(this.modelRef);
+  }
+  get isArray() {
+    return this.arrDepth > 0;
+  }
+  get isMap() {
+    return (0, import_base.isGqlMap)(this.modelRef);
+  }
+  getProps() {
+    return {
+      nullable: this.nullable,
+      ref: this.ref,
+      refPath: this.refPath,
+      refType: this.refType,
+      default: this.default,
+      type: this.type,
+      fieldType: this.fieldType,
+      immutable: this.immutable,
+      min: this.min,
+      max: this.max,
+      enum: this.enum,
+      select: this.select,
+      minlength: this.minlength,
+      maxlength: this.maxlength,
+      accumulate: this.accumulate,
+      example: this.example,
+      of: this.of,
+      validate: this.validate,
+      text: this.text,
+      modelRef: this.modelRef,
+      arrDepth: this.arrDepth,
+      optArrDepth: this.optArrDepth,
+      meta: this.meta,
+      isClass: this.isClass,
+      isScalar: this.isScalar,
+      isArray: this.isArray,
+      isMap: this.isMap
     };
-    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" });

package/cjs/src/immerify.js

@@ -21,16 +21,14 @@ __export(immerify_exports, {
 });
 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 });
   const objRecord = objOrArr;
-  fieldMetas.forEach((fieldMeta) => {
-    if (fieldMeta.isScalar && fieldMeta.isClass && !!objRecord[fieldMeta.key])
-      immeredObj[fieldMeta.key] = immerify(fieldMeta.modelRef, objRecord[fieldMeta.key]);
+  Object.entries(modelRef.field).forEach(([key, field]) => {
+    if (field.isScalar && field.isClass && !!objRecord[key])
+      immeredObj[key] = immerify(field.modelRef, objRecord[key]);
   });
   return immeredObj;
 };