akanjs 2.3.5-rc.9 → 2.3.5

package/base/base.ts

@@ -1,4 +1,4 @@
-import type { Cls } from ".";
+import type { CLIENT_VALUE, Cls, DEFAULT_VALUE, PURIFIED_VALUE, SERVER_VALUE } from ".";
 import { Float, Int } from "./primitiveRegistry";
 
 class EnumPrototype {}
@@ -6,6 +6,10 @@ export type EnumInstance<RefName extends string = string, T = string | number> =
   { refName: RefName; value: T },
   {
     refName: RefName;
+    [SERVER_VALUE]: T;
+    [CLIENT_VALUE]: T;
+    [DEFAULT_VALUE]: T;
+    [PURIFIED_VALUE]: T;
     type: StringConstructor | typeof Int | typeof Float;
     values: readonly T[];
     valueMap: Map<T, number>;
@@ -71,7 +75,7 @@ export const enumOf = <RefName extends string, T = string | number>(
     readonly refName = refName;
     declare readonly value: T;
   }
-  return Enum;
+  return Enum as unknown as EnumInstance<RefName, T>;
 };
 
 /** Id-keyed list helper used for light model collections and immutable-style list updates. */

package/base/primitiveRegistry.ts

@@ -1,5 +1,5 @@
 import dayjsLib, { type Dayjs } from "dayjs";
-
+import { CLIENT_VALUE, DEFAULT_VALUE, EXAMPLE_VALUE, PURIFIED_VALUE, SERVER_VALUE } from "./symbols";
 import type { Cls } from "./types";
 
 export type { Dayjs };
@@ -44,17 +44,14 @@ export class PrimitiveRegistry {
   }
 }
 
-export const PRIMITIVE_SERVER_VALUE = Symbol.for("PRIMITIVE_SERVER_VALUE");
-export const PRIMITIVE_CLIENT_VALUE = Symbol.for("PRIMITIVE_CLIENT_VALUE");
-export const PRIMITIVE_DEFAULT_VALUE = Symbol.for("PRIMITIVE_DEFAULT_VALUE");
-export const PRIMITIVE_EXAMPLE_VALUE = Symbol.for("PRIMITIVE_EXAMPLE_VALUE");
 export type PrimitiveValue = string | number | boolean | Dayjs | Date | null | undefined;
 export class PrimitiveScalar {
   static refName: string;
-  static [PRIMITIVE_SERVER_VALUE]: unknown;
-  static [PRIMITIVE_CLIENT_VALUE]: unknown;
-  static [PRIMITIVE_DEFAULT_VALUE]: unknown = null;
-  static [PRIMITIVE_EXAMPLE_VALUE]: unknown = null;
+  static [SERVER_VALUE]: unknown;
+  static [CLIENT_VALUE]: unknown;
+  static [DEFAULT_VALUE]: unknown = null;
+  static [PURIFIED_VALUE]: unknown = null;
+  static [EXAMPLE_VALUE]: unknown = null;
 
   static validate(value: PrimitiveValue): boolean {
     return true;
@@ -105,10 +102,11 @@ export class PrimitiveScalar {
 /** Integer primitive scalar. Accepts safe integer numbers after parsing. */
 export class Int extends PrimitiveScalar {
   static override refName: "Int" = "Int";
-  static override [PRIMITIVE_SERVER_VALUE]: number;
-  static override [PRIMITIVE_CLIENT_VALUE]: number;
-  static override [PRIMITIVE_DEFAULT_VALUE]: number = 0;
-  static override [PRIMITIVE_EXAMPLE_VALUE]: number = 0;
+  static override [SERVER_VALUE]: number;
+  static override [CLIENT_VALUE]: number;
+  static override [DEFAULT_VALUE]: number = 0;
+  static override [PURIFIED_VALUE]: number = 0;
+  static override [EXAMPLE_VALUE]: number = 0;
 
   static override validate(value: string | number): boolean {
     return typeof value === "number" && Number.isSafeInteger(value);
@@ -125,10 +123,11 @@ PrimitiveRegistry.register(Int);
 /** Floating point primitive scalar. Accepts finite numbers after parsing. */
 export class Float extends PrimitiveScalar {
   static override refName: "Float" = "Float";
-  static override [PRIMITIVE_SERVER_VALUE]: number;
-  static override [PRIMITIVE_CLIENT_VALUE]: number;
-  static override [PRIMITIVE_DEFAULT_VALUE]: number = 0;
-  static override [PRIMITIVE_EXAMPLE_VALUE]: number = 0;
+  static override [SERVER_VALUE]: number;
+  static override [CLIENT_VALUE]: number;
+  static override [DEFAULT_VALUE]: number = 0;
+  static override [PURIFIED_VALUE]: number = 0;
+  static override [EXAMPLE_VALUE]: number = 0;
 
   static override validate(value: string | number): boolean {
     return typeof value === "number" && Number.isFinite(value);
@@ -145,10 +144,11 @@ PrimitiveRegistry.register(Float);
 /** 24-character hexadecimal id primitive used by Akan document and signal models. */
 export class ID extends PrimitiveScalar {
   static override refName: "ID" = "ID";
-  static override [PRIMITIVE_SERVER_VALUE]: string;
-  static override [PRIMITIVE_CLIENT_VALUE]: string;
-  static override [PRIMITIVE_DEFAULT_VALUE]: string = "";
-  static override [PRIMITIVE_EXAMPLE_VALUE]: string = "1234567890abcdef12345678";
+  static override [SERVER_VALUE]: string;
+  static override [CLIENT_VALUE]: string;
+  static override [DEFAULT_VALUE]: string = "";
+  static override [PURIFIED_VALUE]: string = "";
+  static override [EXAMPLE_VALUE]: string = "1234567890abcdef12345678";
 
   static override validate(value: string): boolean {
     if (typeof value !== "string") return false;
@@ -161,7 +161,7 @@ export class ID extends PrimitiveScalar {
     return String(value);
   }
   static override _checkValue(value: PrimitiveValue, options: { optional?: boolean } = {}): void {
-    if (value === ID[PRIMITIVE_DEFAULT_VALUE]) return;
+    if (value === ID[DEFAULT_VALUE]) return;
     
     super._checkValue(value, options);
   }
@@ -171,17 +171,18 @@ PrimitiveRegistry.register(ID);
 /** Open object primitive for intentionally flexible payloads or metadata blobs. */
 export class Any extends PrimitiveScalar {
   static override refName: "Any" = "Any";
-  static override [PRIMITIVE_DEFAULT_VALUE]: object | null = null;
-  static override [PRIMITIVE_EXAMPLE_VALUE]: object = {};
+  static override [DEFAULT_VALUE]: object | null = null;
+  static override [EXAMPLE_VALUE]: object = {};
 }
 PrimitiveRegistry.register(Any);
 
 export class Upload extends PrimitiveScalar {
   static override refName: "Upload" = "Upload";
-  static override [PRIMITIVE_SERVER_VALUE]: File;
-  static override [PRIMITIVE_CLIENT_VALUE]: File;
-  static override [PRIMITIVE_DEFAULT_VALUE]: File | null = null;
-  static override [PRIMITIVE_EXAMPLE_VALUE] = "FileUpload";
+  static override [SERVER_VALUE]: File;
+  static override [CLIENT_VALUE]: File;
+  static override [DEFAULT_VALUE]: File | null = null;
+  static override [PURIFIED_VALUE]: File;
+  static override [EXAMPLE_VALUE] = "FileUpload";
   __TEMP_TYPE__: "Upload" = "Upload";
 }
 PrimitiveRegistry.register(Upload);
@@ -189,10 +190,11 @@ PrimitiveRegistry.register(Upload);
 declare global {
   interface StringConstructor {
     refName: "String";
-    [PRIMITIVE_SERVER_VALUE]: string;
-    [PRIMITIVE_CLIENT_VALUE]: string;
-    [PRIMITIVE_DEFAULT_VALUE]: string;
-    [PRIMITIVE_EXAMPLE_VALUE]: string;
+    [SERVER_VALUE]: string;
+    [CLIENT_VALUE]: string;
+    [DEFAULT_VALUE]: string;
+    [PURIFIED_VALUE]: string;
+    [EXAMPLE_VALUE]: string;
     validate(value: string): boolean;
     parseValue(input: string): string;
     serializeValue(value: string): string;
@@ -202,10 +204,11 @@ declare global {
   }
   interface BooleanConstructor {
     refName: "Boolean";
-    [PRIMITIVE_SERVER_VALUE]: boolean;
-    [PRIMITIVE_CLIENT_VALUE]: boolean;
-    [PRIMITIVE_DEFAULT_VALUE]: boolean;
-    [PRIMITIVE_EXAMPLE_VALUE]: boolean;
+    [SERVER_VALUE]: boolean;
+    [CLIENT_VALUE]: boolean;
+    [DEFAULT_VALUE]: boolean;
+    [PURIFIED_VALUE]: boolean;
+    [EXAMPLE_VALUE]: boolean;
     validate(value: boolean | number): boolean;
     parseValue(input: boolean | number): boolean | number;
     serializeValue(value: boolean | number): boolean | number;
@@ -215,10 +218,11 @@ declare global {
   }
   interface DateConstructor {
     refName: "Date";
-    [PRIMITIVE_SERVER_VALUE]: Dayjs;
-    [PRIMITIVE_CLIENT_VALUE]: Dayjs;
-    [PRIMITIVE_DEFAULT_VALUE]: Dayjs;
-    [PRIMITIVE_EXAMPLE_VALUE]: string;
+    [SERVER_VALUE]: Dayjs;
+    [CLIENT_VALUE]: Dayjs;
+    [DEFAULT_VALUE]: Dayjs;
+    [PURIFIED_VALUE]: Dayjs;
+    [EXAMPLE_VALUE]: string;
     validate(value: Date): boolean;
     parseValue(input: Date): Dayjs;
     serializeValue(value: Dayjs | Date): Date;
@@ -287,8 +291,8 @@ const scalarPrimitiveStatics = {
 
 Object.assign(String, scalarPrimitiveStatics, {
   refName: "String",
-  [PRIMITIVE_DEFAULT_VALUE]: "",
-  [PRIMITIVE_EXAMPLE_VALUE]: "String",
+  [DEFAULT_VALUE]: "",
+  [EXAMPLE_VALUE]: "String",
   validate(value: string) {
     return typeof value === "string";
   },
@@ -311,8 +315,8 @@ const normalizeBooleanPrimitiveValue = (value: boolean | number): boolean | null
 Object.assign(Boolean, {
   ...scalarPrimitiveStatics,
   refName: "Boolean",
-  [PRIMITIVE_DEFAULT_VALUE]: false,
-  [PRIMITIVE_EXAMPLE_VALUE]: true,
+  [DEFAULT_VALUE]: false,
+  [EXAMPLE_VALUE]: true,
   validate(value: boolean | number) {
     return normalizeBooleanPrimitiveValue(value) !== null;
   },
@@ -328,8 +332,8 @@ PrimitiveRegistry.register(Boolean);
 Object.assign(Date, {
   ...scalarPrimitiveStatics,
   refName: "Date",
-  [PRIMITIVE_DEFAULT_VALUE]: dayjs(new Date(-1)),
-  [PRIMITIVE_EXAMPLE_VALUE]: dayjs(new Date().toISOString()),
+  [DEFAULT_VALUE]: dayjs(new Date(-1)),
+  [EXAMPLE_VALUE]: dayjs(new Date().toISOString()),
   validate(value: Date | string | number) {
     const date = new Date(value);
     if (Number.isNaN(date.getTime())) return false;

package/base/symbols.ts

@@ -1,11 +1,16 @@
-export const FIELD_META = Symbol.for("akanjs.field");
-export const SLICE_META = Symbol.for("akanjs.slice");
-export const FILTER_META = Symbol.for("akanjs.filter");
-export const LOADER_META = Symbol.for("akanjs.loader");
-export const INJECT_META = Symbol.for("akanjs.inject");
-export const ENDPOINT_META = Symbol.for("akanjs.endpoint");
-export const INTERNAL_META = Symbol.for("akanjs.internal");
-export const STATE_META = Symbol.for("akanjs.state");
-export const STATE_INIT_META = Symbol.for("akanjs.state.init");
-export const STATE_DERIVED_META = Symbol.for("akanjs.state.derived");
-export const ACTION_META = Symbol.for("akanjs.action");
+export const FIELD_META = Symbol.for("akan.field");
+export const SLICE_META = Symbol.for("akan.slice");
+export const FILTER_META = Symbol.for("akan.filter");
+export const LOADER_META = Symbol.for("akan.loader");
+export const INJECT_META = Symbol.for("akan.inject");
+export const ENDPOINT_META = Symbol.for("akan.endpoint");
+export const INTERNAL_META = Symbol.for("akan.internal");
+export const STATE_META = Symbol.for("akan.state");
+export const STATE_INIT_META = Symbol.for("akan.state.init");
+export const STATE_DERIVED_META = Symbol.for("akan.state.derived");
+export const ACTION_META = Symbol.for("akan.action");
+export const SERVER_VALUE = Symbol.for("akan.value.server");
+export const CLIENT_VALUE = Symbol.for("akan.value.client");
+export const DEFAULT_VALUE = Symbol.for("akan.value.default");
+export const EXAMPLE_VALUE = Symbol.for("akan.value.example");
+export const PURIFIED_VALUE = Symbol.for("akan.value.purified");

package/base/types.ts

@@ -48,6 +48,18 @@ export type ObjectAssign<Objects extends object[], Acc = unknown> = Objects exte
   ? ObjectAssign<Rest, Assign<Acc, First>>
   : Acc;
 
+export type ObjectAssignKeyOfObjects<
+  T extends object[],
+  Key extends PropertyKey,
+  Acc = Record<never, never>,
+> = T extends [infer First extends object, ...infer Rest extends object[]]
+  ? Key extends keyof First
+    ? First[Key] extends object
+      ? ObjectAssignKeyOfObjects<Rest, Key, Assign<Acc, First[Key]>>
+      : ObjectAssignKeyOfObjects<Rest, Key, Acc>
+    : ObjectAssignKeyOfObjects<Rest, Key, Acc>
+  : Acc;
+
 export type MergeAll<T extends object[], Acc = unknown> = T extends [
   infer First extends object,
   ...infer Rest extends object[],

package/constant/constantRegistry.ts

@@ -1,7 +1,6 @@
 import {
   type Cls,
   type EnumInstance,
-  FIELD_META,
   type GetStateObject,
   isEnum,
   PrimitiveRegistry,
@@ -9,14 +8,16 @@ import {
   type PrimitiveValue,
 } from "akanjs/base";
 import { capitalize, lowerlize } from "akanjs/common";
-import { type ConstantCls, deserialize, type FieldObject, type PurifiedModel, serialize } from ".";
+import {
+  type ConstantCls,
+  type ConstantModelRef,
+  deserialize,
+  type FieldObject,
+  type PurifiedModel,
+  serialize,
+} from ".";
 import type { ConstantType, DefaultOf, DocumentModel, QueryOf } from "./types";
 
-type ConstantModelRef<FieldObj extends FieldObject = FieldObject> = Cls<
-  unknown,
-  { [FIELD_META]: FieldObj; modelType: ConstantType }
->;
-
 /** Runtime registry for Akan constant model metadata, refs, enums, and generated model contracts. */
 export class ConstantRegistry {
   static database = new Map<string, ConstantModel>();
@@ -107,7 +108,7 @@ export class ConstantRegistry {
     InputRef extends ConstantModelRef,
     ObjectRef extends ConstantModelRef,
     FullFieldObj extends FieldObject,
-    FullRef extends ConstantModelRef<FullFieldObj>,
+    FullRef extends ConstantModelRef<any, FullFieldObj>,
     LightRef extends ConstantModelRef,
     InsightRef extends ConstantModelRef,
     Input = InstanceType<InputRef>,
@@ -200,7 +201,7 @@ export class ConstantRegistry {
       _StateLight: null as unknown as GetStateObject<Light>,
       _StateInsight: null as unknown as GetStateObject<Insight>,
     };
-    ConstantRegistry.setDatabase(refName, cnst as ConstantModel);
+    ConstantRegistry.setDatabase(refName, cnst as unknown as ConstantModel);
     Object.entries(constExports).forEach(([key, value]) => {
       if ((modelRefSet as Set<unknown>).has(value)) return;
       else if (typeof value === "function" && isEnum(value as Cls))

package/constant/deserialize.ts

@@ -1,8 +1,8 @@
-import { applyFnToArrayObjects, type Cls, FIELD_META, PrimitiveRegistry, type PrimitiveScalar } from "akanjs/base";
+import { Any, applyFnToArrayObjects, type Cls, FIELD_META, PrimitiveRegistry, type PrimitiveScalar } from "akanjs/base";
 
-import { type ConstantCls, ConstantRegistry, type FieldProps } from ".";
+import { type ConstantCls, type ConstantModelRef, ConstantRegistry, type FieldProps } from ".";
 
-const getDeserializeFn = (inputRef: ConstantCls | PrimitiveScalar) => {
+const getDeserializeFn = (inputRef: ConstantModelRef | PrimitiveScalar) => {
   const deserializeFn = PrimitiveRegistry.has(inputRef as Cls)
     ? (value: unknown) => (inputRef as unknown as typeof PrimitiveScalar)._parse(value as never)
     : (value: unknown) => value as object;
@@ -13,14 +13,14 @@ const deserializeMap = (value: unknown, field: Pick<FieldProps, "of">) => {
   return Object.fromEntries(
     Object.entries(value as Record<string, unknown>).map(([key, val]) => [
       key,
-      applyFnToArrayObjects(val, (v: never) => deserializeInput(v, field.of as ConstantCls, 0)),
+      applyFnToArrayObjects(val, (v: never) => deserializeInput(v, field.of as ConstantModelRef, 0)),
     ]),
   );
 };
 
 const deserializeInput = <Input = unknown>(
   value: Input | Input[],
-  inputRef: ConstantCls<Input> | PrimitiveScalar,
+  inputRef: ConstantModelRef<Input> | PrimitiveScalar,
   arrDepth: number,
   convertFn: (value: unknown) => unknown = (value: unknown) => value,
 ): Input | Input[] => {
@@ -58,13 +58,13 @@ const deserializeInput = <Input = unknown>(
 };
 
 export const deserialize = (
-  argRef: ConstantCls | PrimitiveScalar,
+  argRef: ConstantModelRef | PrimitiveScalar,
   arrDepth: number,
   value: unknown,
   { key, nullable = false, convertFn }: { key?: string; nullable?: boolean; convertFn?: (value: unknown) => unknown },
 ) => {
   if (nullable && (value === null || value === undefined)) return null;
-  else if (!nullable && (value === null || value === undefined))
+  else if (!nullable && (value === null || value === undefined) && argRef !== Any)
     throw new Error(`Invalid Value (Nullable) in ${key} ${argRef} for value ${value}`);
   return deserializeInput(value, argRef, arrDepth, convertFn) as object[];
 };

package/constant/fieldInfo.ts

@@ -1,6 +1,7 @@
 import {
   type Any,
   arraiedModel,
+  CLIENT_VALUE,
   type Cls,
   type Dayjs,
   type EnumInstance,
@@ -9,19 +10,19 @@ import {
   ID,
   Int,
   isEnum,
-  PRIMITIVE_CLIENT_VALUE,
-  PRIMITIVE_SERVER_VALUE,
   PrimitiveRegistry,
   type PrimitiveScalar,
+  SERVER_VALUE,
   type SingleValue,
   type UnCls,
 } from "akanjs/base";
 import { ConstantRegistry } from "./constantRegistry";
-import type { ConstantCls } from "./via";
+import type { BaseObject } from "./types";
+import type { ConstantModelRef } from "./via";
 
 export type ParamFieldType =
   | (typeof PrimitiveScalar & {
-      [PRIMITIVE_CLIENT_VALUE]: string | number | boolean | Dayjs;
+      [CLIENT_VALUE]: string | number | boolean | Dayjs;
     })
   | EnumInstance<string, any>;
 
@@ -38,23 +39,41 @@ export type FieldToValue<Field, MapValue = any> = Field extends null
     ? Map<string, FieldToValue<MapValue>>
     : Field extends (infer F)[]
       ? FieldToValue<F>[]
-      : Field extends { [PRIMITIVE_SERVER_VALUE]: infer V }
-        ? V
-        : Field extends EnumInstance<string, infer V>
-          ? V
-          : Field extends Cls
-            ? UnCls<Field>
-            : never;
+      : Field extends typeof PrimitiveScalar | StringConstructor | BooleanConstructor | DateConstructor
+        ? Field[typeof SERVER_VALUE]
+        : Field extends ConstantModelRef
+          ? UnCls<Field>
+          : Field extends { [SERVER_VALUE]: infer V }
+            ? V
+            : Field extends Cls
+              ? UnCls<Field>
+              : never;
 export interface FieldInfoObject {
-  [key: string]: FieldInfo<any, ConstantFieldTypeInput | null, any>;
+  [key: string]: FieldInfo<
+    any,
+    ConstantFieldTypeInput | null,
+    any,
+    any,
+    any,
+    boolean,
+    boolean,
+    boolean,
+    boolean,
+    boolean,
+    boolean,
+    boolean
+  >;
 }
 export type ExtractFieldInfoObject<Obj extends FieldInfoObject> = {
-  [K in keyof Obj]: Obj[K] extends FieldInfo<any, infer FieldValue, infer ExplicitType, infer MapValue>
-    ? unknown extends ExplicitType
-      ? FieldToValue<FieldValue, MapValue>
-      : ExplicitType
-    : never;
+  [K in keyof Obj]: unknown extends Obj[K]["explicitType"]
+    ? FieldToValue<Obj[K]["value"], Obj[K]["mapValue"]>
+    : Obj[K]["explicitType"];
 };
+type FieldKindSource<Value> = NonNullable<SingleValue<Value>>;
+type IsNullableValue<Value> = null extends Value ? true : false;
+type FieldInfoValue<Value, ExplicitType, MapValue> = unknown extends ExplicitType
+  ? FieldToValue<Value, MapValue>
+  : ExplicitType;
 
 export type ConstantFieldKind = "property" | "hidden" | "secret" | "resolve";
 
@@ -93,11 +112,36 @@ class FieldInfo<
   Value extends ConstantFieldTypeInput | null = null,
   ExplicitType = unknown,
   MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never,
+  KindSource = FieldKindSource<Value>,
+  IsRelation extends boolean = UnCls<KindSource> extends BaseObject ? true : false,
+  IsEnum extends boolean = KindSource extends EnumInstance<string, any> ? true : false,
+  IsPrimitive extends boolean = KindSource extends typeof PrimitiveScalar ? true : false,
+  IsMap extends boolean = KindSource extends MapConstructor ? true : false,
+  IsScalar extends boolean = IsRelation extends true
+    ? false
+    : IsEnum extends true
+      ? false
+      : IsPrimitive extends true
+        ? false
+        : IsMap extends true
+          ? false
+          : true,
+  IsHidden extends boolean = FieldType extends "hidden" ? true : false,
+  IsSecret extends boolean = FieldType extends "secret" ? true : false,
 > {
   readonly value: Value;
   readonly type: ConstantFieldTypeInput;
   readonly option: ConstantFieldProps;
   declare explicitType: ExplicitType;
+  declare mapValue: MapValue;
+  declare _isEnum: IsEnum;
+  declare _isPrimitive: IsPrimitive;
+  declare _isScalar: IsScalar;
+  declare _isRelation: IsRelation;
+  declare _isHidden: IsHidden;
+  declare _isSecret: IsSecret;
+  declare _isMap: IsMap;
+
   constructor(value: Value, option: ConstantFieldProps<FieldType, any, MapValue>) {
     this.value = value;
     const [singleValue, arrDepth] = getNonArrayModel(value as Cls);
@@ -148,7 +192,7 @@ interface ConstantFieldBuildProps<
   of?: MapValue; 
   validate?: (value: FieldValue, model: any) => boolean;
   text?: "search" | "filter";
-  modelRef: ConstantCls;
+  modelRef: ConstantModelRef;
   arrDepth: number;
   optArrDepth: number;
   meta: Metadata;
@@ -161,15 +205,65 @@ export interface FieldProps extends ConstantFieldBuildProps {
   isMap: boolean;
 }
 
-export type FieldInfoObjectToFieldObject<Obj extends FieldInfoObject> = {
-  [K in keyof Obj]: Obj[K] extends FieldInfo<infer FieldType, infer Value, infer ExplicitType, infer MapValue>
-    ? ConstantField<
+type ConstantFieldFromInfoParts<
+  FieldType extends ConstantFieldKind,
+  Value extends ConstantFieldTypeInput | null,
+  ExplicitType,
+  MapValue,
+  IsRelation extends boolean,
+  IsEnum extends boolean,
+  IsPrimitive extends boolean,
+  IsMap extends boolean,
+  IsScalar extends boolean,
+  IsHidden extends boolean,
+  IsSecret extends boolean,
+  _FieldValue = FieldInfoValue<Value, ExplicitType, MapValue>,
+> = ConstantField<
+  FieldType,
+  Value,
+  _FieldValue,
+  MapValue,
+  IsNullableValue<_FieldValue>,
+  IsRelation,
+  IsEnum,
+  IsPrimitive,
+  IsScalar,
+  IsHidden,
+  IsSecret,
+  IsMap
+>;
+type ConstantFieldFromInfo<Info> =
+  Info extends FieldInfo<
+    infer FieldType,
+    infer Value,
+    infer ExplicitType,
+    infer MapValue,
+    infer _KindSource,
+    infer IsRelation,
+    infer IsEnum,
+    infer IsPrimitive,
+    infer IsMap,
+    infer IsScalar,
+    infer IsHidden,
+    infer IsSecret
+  >
+    ? ConstantFieldFromInfoParts<
         FieldType,
         Value,
-        unknown extends ExplicitType ? FieldToValue<Value, MapValue> : ExplicitType,
-        MapValue
+        ExplicitType,
+        MapValue,
+        IsRelation,
+        IsEnum,
+        IsPrimitive,
+        IsMap,
+        IsScalar,
+        IsHidden,
+        IsSecret
       >
     : never;
+
+export type FieldInfoObjectToFieldObject<Obj extends FieldInfoObject> = {
+  [K in keyof Obj]: ConstantFieldFromInfo<Obj[K]>;
 };
 
 /** Runtime metadata for a single Akan constant field. */
@@ -178,7 +272,14 @@ export class ConstantField<
   Value extends ConstantFieldTypeInput | null = any,
   FieldValue = any,
   MapValue = any,
-  Nullable extends boolean = false,
+  Nullable extends boolean = boolean,
+  IsRelation extends boolean = boolean,
+  IsEnum extends boolean = boolean,
+  IsPrimitive extends boolean = boolean,
+  IsScalar extends boolean = boolean,
+  IsHidden extends boolean = boolean,
+  IsSecret extends boolean = boolean,
+  IsMap extends boolean = boolean,
   Metadata = { [key: string]: any },
 > implements ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata>
 {
@@ -214,11 +315,17 @@ export class ConstantField<
   readonly of?: MapValue; 
   readonly validate?: (value: FieldValue, model: any) => boolean;
   readonly text?: "search" | "filter";
-  readonly modelRef: ConstantCls;
+  readonly modelRef: ConstantModelRef;
   readonly arrDepth: number;
   readonly optArrDepth: number;
   readonly meta: Metadata;
-
+  declare _isScalar: IsScalar;
+  declare _isRelation: IsRelation;
+  declare _isEnum: IsEnum;
+  declare _isPrimitive: IsPrimitive;
+  declare _isHidden: IsHidden;
+  declare _isSecret: IsSecret;
+  declare _isMap: IsMap;
   constructor(props: ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata>) {
     this.nullable = props.nullable as unknown as Nullable;
     this.ref = props.ref;
@@ -250,11 +357,46 @@ export class ConstantField<
     Value extends ConstantFieldTypeInput | null = null,
     FieldValue = any,
     MapValue = any,
-    Nullable extends boolean = false,
+    Nullable extends boolean = IsNullableValue<FieldInfoValue<Value, FieldValue, MapValue>>,
+    KindSource = FieldKindSource<Value>,
+    IsRelation extends boolean = false,
+    IsEnum extends boolean = false,
+    IsPrimitive extends boolean = false,
+    IsMap extends boolean = false,
+    IsScalar extends boolean = false,
+    IsHidden extends boolean = false,
+    IsSecret extends boolean = false,
     Metadata = { [key: string]: any },
   >(
-    fieldInfo: FieldInfo<FieldType, Value, FieldValue, MapValue>,
-  ): ConstantField<FieldType, Value, FieldValue, MapValue, Nullable, Metadata> {
+    fieldInfo: FieldInfo<
+      FieldType,
+      Value,
+      FieldValue,
+      MapValue,
+      KindSource,
+      IsRelation,
+      IsEnum,
+      IsPrimitive,
+      IsMap,
+      IsScalar,
+      IsHidden,
+      IsSecret
+    >,
+  ): ConstantField<
+    FieldType,
+    Value,
+    FieldValue,
+    MapValue,
+    Nullable,
+    IsRelation,
+    IsEnum,
+    IsPrimitive,
+    IsScalar,
+    IsHidden,
+    IsSecret,
+    IsMap,
+    Metadata
+  > {
     const [modelRef, arrDepth] = getNonArrayModel(fieldInfo.type as Cls);
     const [option, optArrDepth] = getNonArrayModel(fieldInfo.option);
 
@@ -263,7 +405,7 @@ export class ConstantField<
     if (isMap && !option.of) throw new Error("Map type must have 'of' option");
 
     return new ConstantField({
-      nullable: option.nullable ?? ((option.default === "" ? true : false) as unknown as Nullable),
+      nullable: option.nullable ?? ((option.default === "") as unknown as Nullable),
       ref: option.ref,
       refPath: option.refPath,
       refType: option.refType,
@@ -298,7 +440,7 @@ export class ConstantField<
     return this.arrDepth > 0;
   }
   get isMap() {
-    return this.modelRef === Map;
+    return (this.modelRef as Cls) === Map;
   }
   getProps(): FieldProps {
     return {

package/constant/getDefault.ts

@@ -1,4 +1,4 @@
-import { FIELD_META, PRIMITIVE_DEFAULT_VALUE, type PrimitiveScalar } from "akanjs/base";
+import { DEFAULT_VALUE, FIELD_META, type PrimitiveScalar } from "akanjs/base";
 import type { FieldObject } from ".";
 import type { DefaultOf } from "./types";
 
@@ -12,7 +12,7 @@ export const getDefault = <T>(fieldObj: FieldObject): DefaultOf<T> => {
     } else if (field.isArray) result[key] = [];
     else if (field.nullable) result[key] = null;
     else if (field.isClass) result[key] = field.isScalar ? getDefault(field.modelRef[FIELD_META]) : null;
-    else result[key] = (field.modelRef as unknown as typeof PrimitiveScalar)[PRIMITIVE_DEFAULT_VALUE];
+    else result[key] = (field.modelRef as unknown as typeof PrimitiveScalar)[DEFAULT_VALUE];
   }
   return result as DefaultOf<T>;
 };