@akanjs/constant 0.9.47 → 0.9.49

package/esm/src/default.js

@@ -0,0 +1,48 @@
+import { Enum, 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 result = {};
+  for (const metadata of metadatas) {
+    if (metadata.fieldType === "hidden")
+      result[metadata.key] = null;
+    else if (metadata.default) {
+      if (typeof metadata.default === "function")
+        result[metadata.key] = metadata.default();
+      else if (metadata.default instanceof Enum)
+        result[metadata.key] = [...metadata.default.values];
+      else
+        result[metadata.key] = metadata.default;
+    } else if (metadata.isArray)
+      result[metadata.key] = [];
+    else if (metadata.nullable)
+      result[metadata.key] = null;
+    else if (metadata.isClass)
+      result[metadata.key] = metadata.isScalar ? makeDefault(metadata.modelRef) : null;
+    else
+      result[metadata.key] = scalarDefaultMap.get(metadata.modelRef);
+  }
+  setPredefinedDefault(defaultName, result);
+  return result;
+};
+export {
+  makeDefault
+};

package/esm/src/fieldInfo.js

@@ -0,0 +1,88 @@
+import {
+  arraiedModel,
+  Enum,
+  getNonArrayModel,
+  isGqlMap,
+  isGqlScalar
+} from "@akanjs/base";
+import { constantInfo } from "./constantInfo";
+import {
+  getFieldMetaMapOnPrototype,
+  setFieldMetaMapOnPrototype
+} from "./scalar";
+class FieldInfo {
+  value;
+  type;
+  option;
+  explicitType;
+  constructor(value, option) {
+    this.value = value;
+    const [singleValue, arrDepth] = getNonArrayModel(value);
+    const isEnum = singleValue instanceof Enum;
+    const valueType = isEnum ? arraiedModel(singleValue.type, arrDepth) : value;
+    this.type = valueType;
+    this.option = { ...option, ...isEnum ? { enum: singleValue } : {} };
+  }
+  optional() {
+    return new FieldInfo(this.value, { ...this.option, nullable: true });
+  }
+  meta(meta) {
+    this.option.meta = meta;
+    return this;
+  }
+  applyFieldMeta(target, key) {
+    const [modelRef, arrDepth] = getNonArrayModel(this.type);
+    const [option, optArrDepth] = getNonArrayModel(this.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 = {
+      nullable: option.nullable ?? (option.default === "" ? true : false),
+      ref: option.ref,
+      refPath: option.refPath,
+      refType: option.refType,
+      default: option.default ?? (isArray ? [] : null),
+      type: option.type,
+      fieldType: option.fieldType ?? "property",
+      immutable: option.immutable ?? false,
+      min: option.min,
+      max: option.max,
+      enum: option.enum,
+      select: option.select ?? true,
+      minlength: option.minlength,
+      maxlength: option.maxlength,
+      accumulate: option.accumulate,
+      example: option.example,
+      validate: option.validate,
+      key,
+      isClass,
+      isScalar: constantInfo.isScalar(modelRef),
+      modelRef,
+      arrDepth,
+      isArray,
+      optArrDepth,
+      isMap,
+      of: option.of,
+      text: option.text,
+      meta: option.meta ?? {}
+    };
+    const metadataMap = getFieldMetaMapOnPrototype(target.prototype);
+    metadataMap.set(key, metadata);
+    setFieldMetaMapOnPrototype(target.prototype, metadataMap);
+  }
+}
+const field = (value, option = {}) => new FieldInfo(value, { ...option, fieldType: "property" });
+field.secret = (value, option = {}) => new FieldInfo(value, { ...option, fieldType: "hidden", nullable: true });
+field.hidden = (value, option = {}) => new FieldInfo(value, {
+  ...option,
+  fieldType: "hidden",
+  select: false,
+  nullable: true
+});
+const resolve = (value, option = {}) => new FieldInfo(value, { ...option, fieldType: "resolve" });
+export {
+  field,
+  resolve
+};

package/esm/src/immerify.js

@@ -0,0 +1,16 @@
+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 });
+  fieldMetas.forEach((fieldMeta) => {
+    if (fieldMeta.isScalar && fieldMeta.isClass && !!objOrArr[fieldMeta.key])
+      immeredObj[fieldMeta.key] = immerify(fieldMeta.modelRef, objOrArr[fieldMeta.key]);
+  });
+  return immeredObj;
+};
+export {
+  immerify
+};

package/esm/src/index.js

@@ -1,11 +1,10 @@
-const Srvs = {};
 export * from "./types";
-export * from "./fieldMeta";
+export * from "./fieldInfo";
 export * from "./scalar";
-export * from "./constantDecorator";
-export * from "./filterMeta";
+export * from "./constantInfo";
 export * from "./baseGql";
 export * from "./classMeta";
-export {
-  Srvs
-};
+export * from "./default";
+export * from "./crystalize";
+export * from "./purify";
+export * from "./serialize";

package/esm/src/purify.js

@@ -0,0 +1,99 @@
+import {
+  applyFnToArrayObjects,
+  dayjs,
+  Float,
+  getNonArrayModel,
+  ID,
+  Int,
+  JSON as GqlJSON
+} from "@akanjs/base";
+import { Logger } from "@akanjs/common";
+import { constantInfo, getFieldMetas } from ".";
+class PurifyStorage {
+}
+const scalarPurifyMap = /* @__PURE__ */ new Map([
+  [Date, (value) => dayjs(value).toDate()],
+  [String, (value) => value],
+  [ID, (value) => value],
+  [Boolean, (value) => value],
+  [Int, (value) => value],
+  [Float, (value) => value],
+  [GqlJSON, (value) => value]
+]);
+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))
+    return null;
+  if (metadata.isArray) {
+    if (!Array.isArray(value))
+      throw new Error(`Invalid Array Value in ${metadata.key} for value ${value}`);
+    if (metadata.minlength && value.length < metadata.minlength)
+      throw new Error(`Invalid Array Length (Min) in ${metadata.key} for value ${value}`);
+    else if (metadata.maxlength && value.length > metadata.maxlength)
+      throw new Error(`Invalid Array Length (Max) in ${metadata.key} for value ${value}`);
+    else if (metadata.optArrDepth === 0 && metadata.validate && !metadata.validate(value, self))
+      throw new Error(`Invalid Array Value (Failed to pass validation) in ${metadata.key} for value ${value}`);
+    return value.map((v) => purify({ ...metadata, isArray: false }, v, v));
+  }
+  if (metadata.isMap && metadata.of) {
+    const purifyFn2 = getPurifyFn(metadata.of);
+    return Object.fromEntries(
+      [...value.entries()].map(([key, val]) => [key, 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);
+  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 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}`);
+        return id;
+      }
+      const result = {};
+      for (const metadata of metadatas) {
+        const value = self[metadata.key];
+        result[metadata.key] = purify(metadata, value, self);
+      }
+      return result;
+    } catch (err) {
+      if (isChild)
+        throw new Error(err);
+      Logger.debug(err);
+      return null;
+    }
+  };
+  setPredefinedPurifyFn(refName, fn);
+  return fn;
+};
+export {
+  makePurify
+};

package/esm/src/scalar.js

@@ -8,6 +8,8 @@ import {
   scalarNameMap,
   Upload
 } from "@akanjs/base";
+import { capitalize } from "@akanjs/common";
+import { constantInfo } from "./constantInfo";
 const scalarExampleMap = /* @__PURE__ */ new Map([
   [ID, "1234567890abcdef12345678"],
   [Int, 0],
@@ -20,20 +22,15 @@ const scalarExampleMap = /* @__PURE__ */ new Map([
   [Map, {}]
 ]);
 const getScalarExample = (ref) => scalarExampleMap.get(ref) ?? null;
-const getGqlTypeStr = (ref) => scalarNameMap.get(ref) ?? getClassMeta(ref).refName;
-const fieldTypes = ["email", "password", "url"];
-const getClassMeta = (modelRef) => {
-  const [target] = getNonArrayModel(modelRef);
-  const classMeta = Reflect.getMetadata("class", target.prototype);
-  if (!classMeta)
-    throw new Error(`No ClassMeta for this target ${target.name}`);
-  return classMeta;
-};
+const getGqlTypeStr = (ref) => 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));
+  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;
@@ -55,8 +52,7 @@ const setFieldMetaMapOnPrototype = (prototype, metadataMap) => {
   Reflect.defineMetadata("fields", metadataMap, prototype);
 };
 export {
-  fieldTypes,
-  getClassMeta,
+  fieldPresets,
   getFieldMetaMap,
   getFieldMetaMapOnPrototype,
   getFieldMetas,

package/esm/src/serialize.js

@@ -0,0 +1,106 @@
+import {
+  applyFnToArrayObjects,
+  dayjs,
+  Float,
+  getNonArrayModel,
+  ID,
+  Int,
+  isGqlScalar,
+  JSON as GqlJSON
+} from "@akanjs/base";
+import { constantInfo, getFieldMetas } from ".";
+const scalarSerializeMap = /* @__PURE__ */ new Map([
+  [Date, (value) => dayjs(value).toDate()],
+  [String, (value) => value],
+  [ID, (value) => value],
+  [Boolean, (value) => value],
+  [Int, (value) => value],
+  [Float, (value) => value],
+  [GqlJSON, (value) => value]
+]);
+const getSerializeFn = (inputRef) => {
+  const serializeFn = scalarSerializeMap.get(inputRef);
+  if (!serializeFn)
+    return (value) => value;
+  else
+    return serializeFn;
+};
+const serializeInput = (value, inputRef, arrDepth) => {
+  if (arrDepth && Array.isArray(value))
+    return value.map((v) => serializeInput(v, inputRef, arrDepth - 1));
+  else if (inputRef.prototype === Map.prototype) {
+    const [valueRef] = getNonArrayModel(inputRef);
+    const serializeFn = getSerializeFn(valueRef);
+    return Object.fromEntries(
+      [...value.entries()].map(([key, val]) => [key, applyFnToArrayObjects(val, serializeFn)])
+    );
+  } else if (isGqlScalar(inputRef)) {
+    const serializeFn = getSerializeFn(inputRef);
+    return serializeFn(value);
+  }
+  if (!constantInfo.isScalar(inputRef))
+    return value;
+  else
+    return Object.fromEntries(
+      getFieldMetas(inputRef).map((fieldMeta) => [
+        fieldMeta.key,
+        serializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
+      ])
+    );
+};
+const serializeArg = (argRef, arrDepth, value, { nullable = false }) => {
+  if (nullable && (value === null || value === void 0))
+    return null;
+  else if (!nullable && (value === null || value === void 0))
+    throw new Error(`Invalid Value (Nullable) in ${argRef} for value ${value}`);
+  return serializeInput(value, argRef, arrDepth);
+};
+const scalarDeserializeMap = /* @__PURE__ */ new Map([
+  [Date, (value) => dayjs(value)],
+  [String, (value) => value],
+  [ID, (value) => value],
+  [Boolean, (value) => value],
+  [Int, (value) => value],
+  [Float, (value) => value],
+  [GqlJSON, (value) => value]
+]);
+const getDeserializeFn = (inputRef) => {
+  const deserializeFn = scalarDeserializeMap.get(inputRef);
+  if (!deserializeFn)
+    return (value) => value;
+  return deserializeFn;
+};
+const deserializeInput = (value, inputRef, arrDepth) => {
+  if (arrDepth && Array.isArray(value))
+    return value.map((v) => deserializeInput(v, inputRef, arrDepth - 1));
+  else if (inputRef.prototype === Map.prototype) {
+    const [valueRef] = getNonArrayModel(inputRef);
+    const deserializeFn = getDeserializeFn(valueRef);
+    return Object.fromEntries(
+      [...value.entries()].map(([key, val]) => [key, applyFnToArrayObjects(val, deserializeFn)])
+    );
+  } else if (isGqlScalar(inputRef)) {
+    const deserializeFn = getDeserializeFn(inputRef);
+    return deserializeFn(value);
+  }
+  if (!constantInfo.isScalar(inputRef))
+    return value;
+  else
+    return Object.fromEntries(
+      getFieldMetas(inputRef).map((fieldMeta) => [
+        fieldMeta.key,
+        deserializeInput(value[fieldMeta.key], fieldMeta.modelRef, fieldMeta.arrDepth)
+      ])
+    );
+};
+const deserializeArg = (argRef, arrDepth, value, { nullable = false }) => {
+  if (nullable && (value === null || value === void 0))
+    return null;
+  else if (!nullable && (value === null || value === void 0))
+    throw new Error(`Invalid Value (Nullable) in ${argRef} for value ${value}`);
+  return deserializeInput(value, argRef, arrDepth);
+};
+export {
+  deserializeArg,
+  serializeArg
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@akanjs/constant",
-  "version": "0.9.47",
+  "version": "0.9.49",
   "sourceType": "module",
   "publishConfig": {
     "access": "public"
@@ -15,6 +15,7 @@
     "node": ">=20"
   },
   "dependencies": {
+    "immer": "^10.1.1",
     "reflect-metadata": "^0.2.2"
   },
   "exports": {

package/src/baseGql.d.ts

@@ -1,10 +1,14 @@
 import "reflect-metadata";
 import { BaseObject, type MergeAllTypes, type Prettify, Type } from "@akanjs/base";
+import { type ExtractFieldInfoObject, type FieldBuilder, type FieldInfoObject, FieldResolver } from "./fieldInfo";
 import type { NonFunctionalKeys } from "./types";
-export declare const as: <T>(modelRef: Type<T>) => Type<T>;
 type BaseFields = "id" | "createdAt" | "updatedAt" | "removedAt";
 type OmitBase<T> = Omit<T, BaseFields>;
-export declare function via<T>(modelRef: Type<T>): Type<Prettify<T & BaseObject>>;
-export declare function via<T, Light, FullModels extends Type[]>(modelRef: Type<T>, lightModelRef: Type<Light>, ...fullModelRefs: FullModels): Type<Prettify<MergeAllTypes<FullModels> & T & Light & BaseObject>>;
-export declare function via<T, K extends NonFunctionalKeys<OmitBase<T>>, LightModels extends Type[]>(modelRef: Type<T>, fields: readonly K[], ...lightModelRefs: LightModels): Type<Prettify<MergeAllTypes<LightModels> & Pick<T, K> & BaseObject>>;
+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> & T & {
+    count: number;
+} & 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 {};

package/src/classMeta.d.ts

@@ -1,28 +1,12 @@
 import "reflect-metadata";
 import { type Enum, type Type } from "@akanjs/base";
-export declare const getFullModelRef: (refName: string) => Type;
-export declare const getFullModelRefs: (refName: string) => Type[];
-export declare const getInputModelRef: (refName: string) => Type;
-export declare const getInputModelRefs: (refName: string) => Type[];
-export declare const getScalarModelRef: (refName: string) => Type;
-export declare const getScalarModelRefs: (refName: string) => Type[];
+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) => {
     key: string;
-    enum: Enum<string | number>;
+    enum: Enum;
 }[];
 export declare const hasTextField: (modelRef: Type) => boolean;
-export type ClassType = "light" | "full" | "input" | "scalar";
-export declare const Model: {
-    Light: (refName: string) => (target: Type) => void;
-    Object: (refName: string) => (target: Type) => void;
-    Full: (refName: string) => (target: Type) => void;
-    Input: (refName: string) => (target: Type) => void;
-    Scalar: (refName: string) => (target: Type) => void;
-    Insight: (refName: string) => (target: Type) => void;
-    Filter: (refName: string) => (target: Type) => void;
-};
-export declare const getLightModelRef: (modelRef: Type) => Type;
-export declare const getAllFullModelRefs: () => Type[];
-export declare const getAllScalarModelRefs: () => Type[];
-export declare const getAllFilterModelRefs: () => Type[];

package/src/constantInfo.d.ts

@@ -0,0 +1,69 @@
+import "reflect-metadata";
+import { type GetStateObject, GqlScalar, type Type } from "@akanjs/base";
+import { CrystalizeFunc, PurifiedModel, PurifyFunc } 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<any, any, any, any, any, any, DefaultOf<any>, DefaultOf<any>, GetStateObject<any>, GetStateObject<any>, DefaultOf<any>, any, any, any, QueryOf<any>>>;
+    scalar: Map<string, ScalarConstantModel<any, any, any, any, any>>;
+    modelRefNameMap: Map<Type, string>;
+    getRefName<AllowEmpty extends boolean = false>(modelRef: Type, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? string | undefined : string;
+    getModelType<AllowEmpty extends boolean = false>(modelRef: Type, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? ModelType | undefined : ModelType;
+    setModelType(modelRef: Type, modelType: ModelType): void;
+    isObject(modelRef: Type): boolean;
+    isFull(modelRef: Type): boolean;
+    isLight(modelRef: Type): boolean;
+    isInsight(modelRef: Type): boolean;
+    isFilter(modelRef: Type): boolean;
+    isScalar(modelRef: Type): boolean;
+    setDatabase(refName: string, cnst: ConstantModel<any, any, any, any, any, any>): void;
+    getDatabase<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? ConstantModel<any, any, any, any, any, any> | undefined : ConstantModel<any, any, any, any, any, any>;
+    setScalar(refName: string, cnst: ScalarConstantModel<any, any, any, any, any>): void;
+    getScalar<AllowEmpty extends boolean = false>(refName: string, { allowEmpty }?: {
+        allowEmpty?: AllowEmpty;
+    }): AllowEmpty extends true ? ScalarConstantModel<any, any, any, any, any> | undefined : ScalarConstantModel<any, any, any, any, any>;
+    getModelRef(refName: string, modelType: "input" | "full" | "light" | "insight" | "scalar"): Type | GqlScalar;
+};
+export interface ConstantModel<T extends string, Input, 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>;
+    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;
+    _CapitalizedT: _CapitalizedT;
+    _Default: _Default;
+    _DefaultInput: _DefaultInput;
+    _DefaultState: _DefaultState;
+    _DefaultStateInput: _DefaultStateInput;
+    _DefaultInsight: _DefaultInsight;
+    _PurifiedInput: _PurifiedInput;
+    _Doc: _Doc;
+    _DocInput: _DocInput;
+    _QueryOfDoc: _QueryOfDoc;
+}
+export declare const cnstOf: <T extends string, Input, Full, Light, Insight>(refName: T, Input: Type<Input>, Full: Type<Full>, Light: Type<Light>, Insight: Type<Insight>, option?: {
+    overwrite?: any;
+}) => ConstantModel<T, Input, 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;
+    _Default: _Default;
+    _Doc: _Doc;
+    _PurifiedInput: _PurifiedInput;
+}
+export declare const scalarCnstOf: <T extends string, Model>(refName: T, Model: Type<Model>) => ScalarConstantModel<T, Model>;

package/src/crystalize.d.ts

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

package/src/default.d.ts

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

package/src/fieldInfo.d.ts

@@ -0,0 +1,37 @@
+import { type Dayjs, Enum, Float, type GqlScalar, ID, Int, JSON, type Type, type UnType } from "@akanjs/base";
+import { ConstantFieldProps } from "./scalar";
+export type ParamFieldType = typeof ID | typeof Int | StringConstructor | typeof Date | BooleanConstructor | Enum<string>;
+export type ConstantFieldType = ParamFieldType | DateConstructor | typeof Float | typeof JSON | Type | MapConstructor | Enum<number>;
+export type ConstantFieldTypeInput = ConstantFieldType | ConstantFieldType[] | ConstantFieldType[][] | ConstantFieldType[][][];
+export type FieldToValue<Field, MapValue = any> = Field extends null ? FieldToValue<Exclude<Field, null>> | null : Field extends MapConstructor ? Map<string, FieldToValue<MapValue>> : Field extends (infer F)[] ? FieldToValue<F>[] : Field extends typeof ID ? string : Field extends DateConstructor ? Dayjs : Field extends StringConstructor ? string : Field extends BooleanConstructor ? boolean : Field extends typeof Int ? number : Field extends typeof Float ? number : Field extends typeof JSON ? any : Field extends Type ? UnType<Field> : Field extends Enum<infer V> ? V : never;
+export interface FieldInfoObject {
+    [key: string]: FieldInfo<ConstantFieldTypeInput | null, any>;
+}
+export type ExtractFieldInfoObject<Obj extends FieldInfoObject> = {
+    [K in keyof Obj]: Obj[K] extends FieldInfo<infer F, infer E, infer M> ? unknown extends E ? FieldToValue<F, M> : E : never;
+};
+declare class FieldInfo<Value extends ConstantFieldTypeInput | null = null, ExplicitType = unknown, MapValue = Value extends MapConstructor ? GqlScalar : never> {
+    private readonly value;
+    private readonly type;
+    private readonly option;
+    explicitType: ExplicitType;
+    constructor(value: Value, option: ConstantFieldProps<any, MapValue>);
+    optional(): FieldInfo<Value | null, unknown, any>;
+    meta(meta: ConstantFieldProps["meta"]): this;
+    applyFieldMeta(target: Type, key: string): void;
+}
+type FieldOption<Value extends ConstantFieldTypeInput, MapValue = Value extends MapConstructor ? GqlScalar : never, Metadata extends {
+    [key: string]: any;
+} = {
+    [key: string]: any;
+}, _FieldToValue = FieldToValue<Value> | null | undefined> = Omit<ConstantFieldProps<_FieldToValue, MapValue, Metadata>, "enum" | "meta" | "nullable" | "fieldType" | "select"> | Omit<ConstantFieldProps<_FieldToValue, MapValue, Metadata>, "enum" | "meta" | "nullable" | "fieldType" | "select">[];
+export type PlainTypeToFieldType<PlainType> = PlainType extends [infer First, ...infer Rest] ? PlainTypeToFieldType<First>[] : PlainType extends number ? typeof Int | typeof Float : PlainType extends string ? StringConstructor : typeof JSON;
+export declare const field: {
+    <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof Int | typeof import("@akanjs/base").Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor | MapConstructor : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<Value, ExplicitType, MapValue>;
+    secret<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof Int | typeof import("@akanjs/base").Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor | MapConstructor : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<Value | null, ExplicitType, MapValue>;
+    hidden<ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? typeof Int | typeof import("@akanjs/base").Upload | typeof Float | typeof ID | typeof JSON | StringConstructor | BooleanConstructor | DateConstructor | MapConstructor : never>(value: Value, option?: FieldOption<Value, MapValue>): FieldInfo<Value | null, ExplicitType, MapValue>;
+};
+export declare const resolve: <ExplicitType, Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>, MapValue = Value extends MapConstructor ? GqlScalar : never>(value: Value, option?: FieldOption<Value, MapValue>) => FieldInfo<Value, ExplicitType, MapValue>;
+export type FieldBuilder = typeof field;
+export type FieldResolver = typeof resolve;
+export {};

package/src/immerify.d.ts

@@ -0,0 +1,2 @@
+import { type Type } from "@akanjs/base";
+export declare const immerify: <T extends object | object[]>(modelRef: Type, objOrArr: T) => T;

package/src/index.d.ts

@@ -1,9 +1,10 @@
-import type { AllSrvs } from "@akanjs/service";
-export declare const Srvs: AllSrvs;
 export * from "./types";
-export * from "./fieldMeta";
+export * from "./fieldInfo";
 export * from "./scalar";
-export * from "./constantDecorator";
-export * from "./filterMeta";
+export * from "./constantInfo";
 export * from "./baseGql";
 export * from "./classMeta";
+export * from "./default";
+export * from "./crystalize";
+export * from "./purify";
+export * from "./serialize";

package/src/purify.d.ts

@@ -0,0 +1,14 @@
+import { BaseObject, Dayjs, GetStateObject, Type, Upload } from "@akanjs/base";
+import { DefaultOf } from ".";
+type Purified<O> = O extends BaseObject ? string : O extends BaseObject[] ? string[] : O extends Dayjs ? Dayjs : O extends {
+    [key: string]: any;
+} ? PurifiedModel<O> : O;
+type PurifiedWithObjectToId<T, StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> = {
+    [K in StateKeys]: Purified<T[K]>;
+};
+export type PurifiedModel<T> = T extends (infer S)[] ? PurifiedModel<S>[] : T extends string | number | boolean | Dayjs | Upload ? T : T extends Map<infer K, infer V> ? Map<K, PurifiedModel<V>> : PurifiedWithObjectToId<T>;
+export type PurifyFunc<Input, _DefaultInput = DefaultOf<Input>, _PurifiedInput = PurifiedModel<Input>> = (self: _DefaultInput, isChild?: boolean) => _PurifiedInput | null;
+export declare const makePurify: <I>(modelRef: Type<I>, option?: {
+    overwrite?: any;
+}) => PurifyFunc<I>;
+export {};