@akanjs/constant 1.0.5 → 1.0.6

package/esm/src/fieldInfo.js

@@ -1,15 +1,13 @@
 import {
   arraiedModel,
   getNonArrayModel,
+  ID,
+  Int,
   isEnum,
   isGqlMap,
   isGqlScalar
 } from "@akanjs/base";
 import { constantInfo } from "./constantInfo";
-import {
-  getFieldMetaMapOnPrototype,
-  setFieldMetaMapOnPrototype
-} from "./scalar";
 class FieldInfo {
   value;
   type;
@@ -29,15 +27,81 @@ class FieldInfo {
     this.option.meta = meta;
     return this;
   }
-  applyFieldMeta(target, key) {
-    const [modelRef, arrDepth] = getNonArrayModel(this.type);
-    const [option, optArrDepth] = getNonArrayModel(this.option);
+  toField() {
+    return ConstantField.fromFieldInfo(this);
+  }
+}
+class ConstantField {
+  static getBaseModelField() {
+    return {
+      id: field(ID).toField(),
+      createdAt: field(Date).toField(),
+      updatedAt: field(Date).toField(),
+      removedAt: field(Date).optional().toField()
+    };
+  }
+  static getBaseInsightField() {
+    return {
+      count: field(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] = getNonArrayModel(fieldInfo.type);
+    const [option, optArrDepth] = getNonArrayModel(fieldInfo.option);
     const isArray = arrDepth > 0;
-    const isClass = !isGqlScalar(modelRef);
     const isMap = 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,
@@ -54,22 +118,57 @@ class FieldInfo {
       maxlength: option.maxlength,
       accumulate: option.accumulate,
       example: option.example,
+      of: option.of,
       validate: option.validate,
-      key,
-      isClass,
-      isScalar: constantInfo.isScalar(modelRef),
+      text: option.text,
       modelRef,
       arrDepth,
-      isArray,
       optArrDepth,
-      isMap,
-      of: option.of,
-      text: option.text,
       meta: option.meta ?? {}
+    });
+  }
+  get isClass() {
+    return !isGqlScalar(this.modelRef);
+  }
+  get isScalar() {
+    return constantInfo.isScalar(this.modelRef) || isGqlScalar(this.modelRef);
+  }
+  get isArray() {
+    return this.arrDepth > 0;
+  }
+  get isMap() {
+    return 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 = getFieldMetaMapOnPrototype(target.prototype);
-    metadataMap.set(key, metadata);
-    setFieldMetaMapOnPrototype(target.prototype, metadataMap);
   }
 }
 const field = (value, option = {}) => new FieldInfo(value, { ...option, fieldType: "property" });
@@ -82,6 +181,7 @@ field.hidden = (value, option = {}) => new FieldInfo(value, {
 });
 const resolve = (value, option = {}) => new FieldInfo(value, { ...option, fieldType: "resolve" });
 export {
+  ConstantField,
   field,
   resolve
 };

package/esm/src/immerify.js

@@ -1,14 +1,12 @@
 import { immerable } from "immer";
-import { getFieldMetas } from ".";
 const immerify = (modelRef, objOrArr) => {
   if (Array.isArray(objOrArr))
     return objOrArr.map((val) => immerify(modelRef, val));
-  const fieldMetas = getFieldMetas(modelRef);
   const immeredObj = Object.assign({}, objOrArr, { [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;
 };

package/esm/src/purify.js

@@ -8,7 +8,7 @@ import {
   JSON as GqlJSON
 } from "@akanjs/base";
 import { Logger } from "@akanjs/common";
-import { constantInfo, getFieldMetas } from ".";
+import { constantInfo } from ".";
 class PurifyStorage {
 }
 const scalarPurifyMap = /* @__PURE__ */ new Map([
@@ -24,65 +24,53 @@ const getPurifyFn = (modelRef) => {
   const [valueRef] = 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, applyFnToArrayObjects(val, purifyFn2)])
+      [...value.entries()].map(([key2, val]) => [key2, applyFnToArrayObjects(val, purifyFn2)])
     );
   }
-  if (metadata.isClass)
-    return makePurify(metadata.modelRef)(value, true);
-  if (metadata.modelRef === Date && dayjs(value).isBefore(dayjs(/* @__PURE__ */ new Date("0000"))))
-    throw new Error(`Invalid Date Value (Default) in ${metadata.key} for value ${value}`);
-  if ([String, 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 && dayjs(value).isBefore(dayjs(/* @__PURE__ */ new Date("0000"))))
+    throw new Error(`Invalid Date Value (Default) in ${key} for value ${value}`);
+  if ([String, 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 = constantInfo.getRefName(modelRef);
-  const purifyFn = getPredefinedPurifyFn(refName);
-  if (purifyFn && !option.overwrite)
-    return purifyFn;
-  const metadatas = getFieldMetas(modelRef);
+const makePurify = (modelRef) => {
   const fn = (self, isChild) => {
     try {
       if (isChild && !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)
@@ -91,7 +79,6 @@ const makePurify = (modelRef, option = {}) => {
       return null;
     }
   };
-  setPredefinedPurifyFn(refName, fn);
   return fn;
 };
 export {

package/esm/src/scalar.js

@@ -1,7 +1,6 @@
 import "reflect-metadata";
 import {
   Float,
-  getNonArrayModel,
   ID,
   Int,
   JSON,
@@ -24,42 +23,13 @@ const scalarExampleMap = /* @__PURE__ */ new Map([
 const getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
 const getGqlTypeStr = (ref) => scalarNameMap.get(ref) ?? `${constantInfo.isLight(ref) ? "Light" : ""}${capitalize(constantInfo.getRefName(ref))}${constantInfo.isInsight(ref) ? "Insight" : ""}`;
 const fieldPresets = ["email", "password", "url"];
-const getFieldMetas = (modelRef) => {
-  const [target] = 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] = getNonArrayModel(modelRef);
-  const metadataMap = Reflect.getMetadata("fields", target.prototype) ?? /* @__PURE__ */ new Map();
-  return metadataMap;
-};
-const setFieldMetaMap = (modelRef, metadataMap) => {
-  const [target] = 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);
-};
 export {
   fieldPresets,
-  getFieldMetaMap,
-  getFieldMetaMapOnPrototype,
-  getFieldMetas,
   getGqlTypeStr,
   getScalarExample,
   isConstantModel,
-  scalarExampleMap,
-  setFieldMetaMap,
-  setFieldMetaMapOnPrototype
+  scalarExampleMap
 };

package/esm/src/serialize.js

@@ -8,7 +8,7 @@ import {
   isGqlScalar,
   JSON as GqlJSON
 } from "@akanjs/base";
-import { constantInfo, getFieldMetas } from ".";
+import { constantInfo } from ".";
 const scalarSerializeMap = /* @__PURE__ */ new Map([
   [Date, (value) => dayjs(value).toDate()],
   [String, (value) => value],
@@ -42,9 +42,9 @@ const serializeInput = (value, inputRef, arrDepth) => {
     return value;
   else
     return Object.fromEntries(
-      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)
       ])
     );
 };
@@ -87,9 +87,9 @@ const deserializeInput = (value, inputRef, arrDepth) => {
     return value;
   else
     return Object.fromEntries(
-      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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/constant",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"

package/src/baseGql.d.ts

@@ -1,12 +1,33 @@
 import "reflect-metadata";
-import { BaseInsight, BaseObject, type MergeAllTypes, type Prettify, Type } from "@akanjs/base";
-import { type ExtractFieldInfoObject, type FieldBuilder, type FieldInfoObject, FieldResolver } from "./fieldInfo";
-import type { NonFunctionalKeys } from "./types";
+import { BaseInsight, BaseObject, type MergeAllTypes, Type } from "@akanjs/base";
+import { type ExtractFieldInfoObject, type FieldBuilder, type FieldInfoObject, FieldObject, FieldResolver } from "./fieldInfo";
+import { type PurifyFunc } from "./purify";
+import type { DefaultOf, NonFunctionalKeys } from "./types";
 type BaseFields = "id" | "createdAt" | "updatedAt" | "removedAt";
 type OmitBase<T> = Omit<T, BaseFields>;
-export declare function via<T extends BaseObject, K extends NonFunctionalKeys<OmitBase<T>>, ResolveField extends (resolve: FieldResolver) => FieldInfoObject, LightModels extends Type[]>(modelRef: Type<T>, fields: readonly K[], resolveField: ResolveField, ...lightModelRefs: LightModels): Type<Prettify<MergeAllTypes<LightModels> & Pick<T, K> & BaseObject & ExtractFieldInfoObject<ReturnType<ResolveField>>>>;
-export declare function via<BuildField extends (builder: FieldBuilder) => FieldInfoObject, Inputs extends Type[]>(buildField: BuildField, ...extendInputRefs: Inputs): Type<MergeAllTypes<Inputs> & ExtractFieldInfoObject<ReturnType<BuildField>>>;
-export declare function via<T extends BaseObject, BuildField extends (builder: FieldBuilder) => FieldInfoObject, Insights extends Type[]>(modelRef: Type<T>, buildField: BuildField, ...extendInsightRefs: Insights): Type<MergeAllTypes<Insights> & BaseInsight & ExtractFieldInfoObject<ReturnType<BuildField>>>;
-export declare function via<T, BuildField extends (builder: FieldBuilder) => FieldInfoObject, ObjectModels extends Type[]>(inputRef: Type<T>, buildField: BuildField, ...extendObjectRefs: ObjectModels): Type<Prettify<MergeAllTypes<ObjectModels> & T & BaseObject & ExtractFieldInfoObject<ReturnType<BuildField>>>>;
-export declare function via<T, Light, ResolveField extends (resolve: FieldResolver) => FieldInfoObject, FullModels extends Type[]>(objectRef: Type<T>, lightModelRef: Type<Light>, resolveField: ResolveField, ...fullModelRefs: FullModels): Type<Prettify<MergeAllTypes<FullModels> & T & Light & ExtractFieldInfoObject<ReturnType<ResolveField>>>>;
+export interface ConstantMethods<Schema = any> {
+    set: (obj: Partial<Schema>) => this;
+}
+export interface ConstantStatics<Schema = any> {
+    field: FieldObject;
+    default: DefaultOf<Schema>;
+    purify: PurifyFunc<Schema>;
+}
+export type Crystal<Schema = any> = Schema & ConstantMethods<Schema>;
+export type Cnst<Schema = any> = (new (obj?: Partial<Schema>) => Crystal<Schema>) & ConstantStatics<Schema>;
+declare global {
+    interface DateConstructor extends ConstantStatics<unknown> {
+    }
+    interface StringConstructor extends ConstantStatics<unknown> {
+    }
+    interface BooleanConstructor extends ConstantStatics<unknown> {
+    }
+    interface MapConstructor extends ConstantStatics<unknown> {
+    }
+}
+export declare function via<T extends BaseObject, K extends NonFunctionalKeys<OmitBase<T>>, ResolveField extends (resolve: FieldResolver) => FieldInfoObject, LightModels extends Type[], _Schema = MergeAllTypes<LightModels> & Pick<T, K> & BaseObject & ExtractFieldInfoObject<ReturnType<ResolveField>>>(modelRef: Type<T>, fields: readonly K[], resolveField: ResolveField, ...lightModelRefs: LightModels): Cnst<_Schema>;
+export declare function via<BuildField extends (builder: FieldBuilder) => FieldInfoObject, Inputs extends Type[], _Schema = MergeAllTypes<Inputs> & ExtractFieldInfoObject<ReturnType<BuildField>>>(buildField: BuildField, ...extendInputRefs: Inputs): Cnst<_Schema>;
+export declare function via<T extends BaseObject, BuildField extends (builder: FieldBuilder) => FieldInfoObject, Insights extends Type[], _Schema = MergeAllTypes<Insights> & BaseInsight & ExtractFieldInfoObject<ReturnType<BuildField>>>(modelRef: Type<T>, buildField: BuildField, ...extendInsightRefs: Insights): Cnst<_Schema>;
+export declare function via<T, BuildField extends (builder: FieldBuilder) => FieldInfoObject, ObjectModels extends Type[], _Schema = MergeAllTypes<ObjectModels> & T & BaseObject & ExtractFieldInfoObject<ReturnType<BuildField>>>(inputRef: Type<T>, buildField: BuildField, ...extendObjectRefs: ObjectModels): Cnst<_Schema>;
+export declare function via<T, Light, ResolveField extends (resolve: FieldResolver) => FieldInfoObject, FullModels extends Type[], _Schema = MergeAllTypes<FullModels> & T & Light & ExtractFieldInfoObject<ReturnType<ResolveField>>>(objectRef: Type<T>, lightModelRef: Type<Light>, resolveField: ResolveField, ...fullModelRefs: FullModels): Cnst<_Schema>;
 export {};

package/src/classMeta.d.ts

@@ -1,12 +1,9 @@
 import "reflect-metadata";
-import { type EnumInstance, type Type } from "@akanjs/base";
-export declare const setExtendRef: (modelRef: Type, extendRef: Type) => void;
-export declare const getExtendRef: <AllowEmpty extends boolean = false>(modelRef: Type, { allowEmpty }?: {
-    allowEmpty?: AllowEmpty;
-}) => AllowEmpty extends true ? Type | undefined : Type;
-export declare const getChildClassRefs: (target: Type) => Type[];
-export declare const getFieldEnumMetas: (modelRef: Type) => {
+import { type EnumInstance } from "@akanjs/base";
+import { Cnst } from "./baseGql";
+export declare const getChildClassRefs: (target: Cnst) => Cnst[];
+export declare const getFieldEnumMetas: (modelRef: Cnst) => {
     key: string;
     enum: EnumInstance;
 }[];
-export declare const hasTextField: (modelRef: Type) => boolean;
+export declare const hasTextField: (modelRef: Cnst) => boolean;

package/src/constantInfo.d.ts

@@ -1,10 +1,16 @@
 import "reflect-metadata";
 import { type GetStateObject, GqlScalar, type Type } from "@akanjs/base";
-import { CrystalizeFunc, PurifiedModel, PurifyFunc } from ".";
+import { Cnst, PurifiedModel } from ".";
 import type { DefaultOf, DocumentModel, QueryOf } from "./types";
 export type ModelType = "input" | "object" | "full" | "light" | "insight" | "filter" | "scalar";
 export declare const constantInfo: {
-    database: Map<string, ConstantModel<string, any, any, any, any, any, Capitalize<string>, DefaultOf<any>, DefaultOf<any>, GetStateObject<any>, GetStateObject<any>, DefaultOf<any>, any, any, any, QueryOf<any>>>;
+    database: Map<string, ConstantModel<string, any, any, any, any, any, Capitalize<string>, GetStateObject<{
+        [x: string]: any;
+    }>, GetStateObject<{
+        [x: string]: any;
+    }>, GetStateObject<any>, GetStateObject<any>, GetStateObject<{
+        [x: string]: any;
+    }>, any, any, any, QueryOf<any>>>;
     scalar: Map<string, ScalarConstantModel<any, any, any, any, any>>;
     modelRefNameMap: Map<new (...args: any[]) => any, string>;
     getRefName<AllowEmpty extends boolean = false>(modelRef: Type, { allowEmpty }?: {
@@ -23,26 +29,20 @@ export declare const constantInfo: {
     setDatabase(refName: string, cnst: ConstantModel<string, any, any, any, any, any>): void;
     getDatabase<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
         allowEmpty?: AllowEmpty;
-    }): AllowEmpty extends true ? ConstantModel<string, any, any, any, any, any> | undefined : ConstantModel<string, any, any, any, any, any>;
-    setScalar(refName: string, cnst: ScalarConstantModel<string, any, any, any, any>): void;
+    }): AllowEmpty extends true ? ConstantModel<string, unknown, unknown, unknown, unknown, unknown> | undefined : ConstantModel<string, unknown, unknown, unknown, unknown, unknown>;
+    setScalar(refName: string, cnst: ScalarConstantModel<string, unknown, unknown, unknown, unknown>): void;
     getScalar<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
         allowEmpty?: AllowEmpty;
-    }): AllowEmpty extends true ? ScalarConstantModel<string, any, any, any, any> | undefined : ScalarConstantModel<string, any, any, any, any>;
+    }): AllowEmpty extends true ? ScalarConstantModel<string, unknown, unknown, unknown, unknown> | undefined : ScalarConstantModel<string, unknown, unknown, unknown, unknown>;
     getModelRef(refName: string, modelType: "input" | "object" | "full" | "light" | "insight" | "scalar"): Type | GqlScalar;
 };
 export interface ConstantModel<T extends string, Input, Obj, Full, Light, Insight, _CapitalizedT extends string = Capitalize<T>, _Default = DefaultOf<Full>, _DefaultInput = DefaultOf<Input>, _DefaultState = GetStateObject<Full>, _DefaultStateInput = GetStateObject<Input>, _DefaultInsight = DefaultOf<Insight>, _PurifiedInput = PurifiedModel<Input>, _Doc = DocumentModel<Full>, _DocInput = DocumentModel<Input>, _QueryOfDoc = QueryOf<_Doc>> {
     refName: T;
-    input: Type<Input>;
-    object: Type<Obj>;
-    full: Type<Full>;
-    light: Type<Light>;
-    insight: Type<Insight>;
-    crystalize: CrystalizeFunc<Full>;
-    lightCrystalize: CrystalizeFunc<Light>;
-    crystalizeInsight: CrystalizeFunc<Insight>;
-    purify: PurifyFunc<Input, _DefaultInput, _PurifiedInput>;
-    getDefault: () => _Default;
-    getDefaultInsight: () => _DefaultInsight;
+    input: Cnst<Input>;
+    object: Cnst<Obj>;
+    full: Cnst<Full>;
+    light: Cnst<Light>;
+    insight: Cnst<Insight>;
     _CapitalizedT: _CapitalizedT;
     _Default: _Default;
     _DefaultInput: _DefaultInput;
@@ -54,15 +54,10 @@ export interface ConstantModel<T extends string, Input, Obj, Full, Light, Insigh
     _DocInput: _DocInput;
     _QueryOfDoc: _QueryOfDoc;
 }
-export declare const cnstOf: <T extends string, Input, Obj, Full, Light, Insight>(refName: T, inputRef: Type<Input>, objectRef: Type<Obj>, fullRef: Type<Full>, lightRef: Type<Light>, insightRef: Type<Insight>, option?: {
-    overwrite?: any;
-}) => ConstantModel<T, Input, Obj, Full, Light, Insight, Capitalize<T>, DefaultOf<Full>, DefaultOf<Input>, GetStateObject<Full>, GetStateObject<Input>, DefaultOf<Insight>, PurifiedModel<Input>, DocumentModel<Full>, DocumentModel<Input>, QueryOf<DocumentModel<Full>>>;
+export declare const cnstOf: <T extends string, Input, Obj, Full, Light, Insight>(refName: T, inputRef: Type<Input>, objectRef: Type<Obj>, fullRef: Type<Full>, lightRef: Type<Light>, insightRef: Type<Insight>) => ConstantModel<T, Input, Obj, Full, Light, Insight, Capitalize<T>, DefaultOf<Full>, DefaultOf<Input>, GetStateObject<Full>, GetStateObject<Input>, DefaultOf<Insight>, PurifiedModel<Input>, DocumentModel<Full>, DocumentModel<Input>, QueryOf<DocumentModel<Full>>>;
 export interface ScalarConstantModel<T extends string, Model, _Default = DefaultOf<Model>, _Doc = DocumentModel<Model>, _PurifiedInput = PurifiedModel<Model>> {
     refName: T;
-    model: Type<Model>;
-    crystalize: CrystalizeFunc<Model>;
-    purify: PurifyFunc<Model, _Default, _PurifiedInput>;
-    getDefault: () => _Default;
+    model: Cnst<Model>;
     _Default: _Default;
     _Doc: _Doc;
     _PurifiedInput: _PurifiedInput;

package/src/crystalize.d.ts

@@ -1,6 +1,9 @@
 import { GetStateObject, Type } from "@akanjs/base";
+import { FieldObject, FieldProps } from ".";
 export type CrystalizeFunc<Model> = (self: GetStateObject<Model>, isChild?: boolean) => Model;
-export declare const makeCrystalize: <M>(modelRef: Type<M>, option?: {
-    overwrite?: any;
+export declare const crystalize: (field: FieldProps, value: any) => any;
+export declare const makeCrystalize: <M>(modelRef: Type<M, {
+    field: FieldObject;
+}>, option?: {
     partial?: string[];
 }) => CrystalizeFunc<M>;

package/src/default.d.ts

@@ -1,6 +1,3 @@
-import { Type } from "@akanjs/base";
+import { FieldObject } from ".";
 import { DefaultOf } from "./types";
-export declare const makeDefault: <T>(modelRef: Type<T>, option?: {
-    isChild?: boolean;
-    overwrite?: any;
-}) => DefaultOf<T>;
+export declare const makeDefault: <T>(fieldObj: FieldObject) => DefaultOf<T>;