akanjs 2.3.5-rc.11 → 2.3.5-rc.13

package/constant/immerify.ts

@@ -1,8 +1,8 @@
 import { FIELD_META } from "akanjs/base";
 import { immerable } from "immer";
-import type { ConstantCls } from ".";
+import type { ConstantModelRef } from ".";
 
-export const immerify = <T extends object>(modelRef: ConstantCls, objOrArr: T): T => {
+export const immerify = <T extends object>(modelRef: ConstantModelRef, objOrArr: T): T => {
   if (Array.isArray(objOrArr)) return objOrArr.map((val) => immerify(modelRef, val as object)) as T;
   const immeredObj = Object.assign({}, objOrArr, {
     [immerable]: true,

package/constant/purify.ts

@@ -1,4 +1,5 @@
 import {
+  Any,
   applyFnToArrayObjects,
   type Cls,
   type Dayjs,
@@ -13,7 +14,14 @@ import {
 } from "akanjs/base";
 import { Logger } from "akanjs/common";
 
-import { type BaseObject, type ConstantCls, ConstantRegistry, type DefaultOf, type FieldProps } from ".";
+import {
+  type BaseObject,
+  type ConstantModelRef,
+  ConstantRegistry,
+  type DefaultOf,
+  type DefaultOfSchema,
+  type FieldProps,
+} from ".";
 
 type Purified<O> = O extends BaseObject
   ? string
@@ -44,6 +52,13 @@ export type PurifyFunc<Input, _DefaultInput = DefaultOf<Input>, _PurifiedInput =
   isChild?: boolean,
 ) => _PurifiedInput | null;
 
+export type PurifyFuncV2<
+  Input,
+  RelationKey extends string = never,
+  _DefaultInput = DefaultOfSchema<Input, RelationKey>,
+  _PurifiedInput = PurifiedModel<Input>,
+> = (self: _DefaultInput, isChild?: boolean) => _PurifiedInput | null;
+
 const getPurifyFn = (modelRef: Cls): ((value: unknown) => unknown) => {
   const [valueRef] = getNonArrayModel(modelRef);
   const purifyFn = PrimitiveRegistry.has(valueRef)
@@ -75,7 +90,7 @@ const purify = (field: FieldProps, key: string, value: unknown, self: Record<str
   if (field.isMap && field.of) {
     const purifyFn = PrimitiveRegistry.has(field.of as Cls)
       ? getPurifyFn(field.of as Cls)
-      : (value: unknown) => makePurify(field.of as ConstantCls)(value as object);
+      : (value: unknown) => makePurify(field.of as ConstantModelRef)(value as object);
     return Object.fromEntries(
       [...(value as Map<string, unknown>).entries()].map(([key, val]) => [key, applyFnToArrayObjects(val, purifyFn)]),
     );
@@ -87,14 +102,14 @@ const purify = (field: FieldProps, key: string, value: unknown, self: Record<str
     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)
+  if (!field.nullable && !value && value !== 0 && value !== false && (field.modelRef as Cls) !== Any)
     throw new Error(`Invalid Value (Nullable) in ${key} for value ${value}`);
 
   const purifyFn = getPurifyFn(field.modelRef);
   return purifyFn(value);
 };
 
-export const makePurify = <I>(modelRef: ConstantCls<I>): PurifyFunc<I> => {
+export const makePurify = <I>(modelRef: ConstantModelRef<I>): PurifyFunc<I> => {
   const fn = ((self: Record<string, unknown>, isChild?: boolean): unknown => {
     try {
       if (isChild && !ConstantRegistry.isScalar(modelRef)) {

package/constant/serialize.ts

@@ -1,4 +1,5 @@
 import {
+  Any,
   applyFnToArrayObjects,
   type Cls,
   type Dayjs,
@@ -9,7 +10,7 @@ import {
   type PrimitiveScalar,
 } from "akanjs/base";
 
-import type { ConstantCls } from ".";
+import type { ConstantCls, ConstantModelRef } from ".";
 
 export type Serialized<O> = O extends (infer V)[]
   ? Serialized<V>[]
@@ -29,7 +30,7 @@ const getSerializeFn = (inputRef: Cls, { optional = false }: { optional?: boolea
 };
 const serializeInput = <Input = unknown>(
   value: Input | Input[],
-  inputRef: ConstantCls<Input> | PrimitiveScalar,
+  inputRef: ConstantModelRef<Input> | PrimitiveScalar,
   arrDepth: number,
   serializeType: "input" | "object" = "object",
   { optional = false }: { optional?: boolean } = {},
@@ -74,14 +75,14 @@ const getRelationId = (value: unknown): unknown => {
 };
 
 export const serialize = (
-  argRef: ConstantCls | PrimitiveScalar,
+  argRef: ConstantModelRef | PrimitiveScalar,
   arrDepth: number,
   value: unknown,
   serializeType: "input" | "object" = "object",
   { nullable = false, key }: { nullable?: boolean; key?: string },
 ) => {
   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 ${argRef} for value ${value}${key ? ` in ${key}` : ""}`);
   return serializeInput(value, argRef, arrDepth, serializeType, { optional: nullable }) as object[];
 };

package/constant/types.ts

@@ -30,6 +30,12 @@ export type DocumentModel<T> = T extends (infer S)[]
 export type FieldState<T> = T extends { id: string } ? T | null : T;
 export type DefaultOf<S> = GetStateObject<{ [K in keyof S]: FieldState<S[K]> }>;
 
+export type DefaultOfSchema<Schema, RelationKey = never> = [RelationKey] extends [never]
+  ? Schema
+  : {
+      [K in keyof Schema]: Schema[K] | (K extends RelationKey ? null : never);
+    };
+
 export type GetPlainObject<T, O extends string> = Omit<
   {
     [K in keyof T as T[K] extends (...args: never[]) => unknown
@@ -96,7 +102,9 @@ export interface TextDoc {
   [key: string]: string | TextDoc;
 }
 
-export type NonFunctionalKeys<T> = keyof T extends (...args: never[]) => unknown ? never : keyof T;
+export type NonFunctionalKeys<T> = {
+  [K in keyof T]: T[K] extends (...args: never[]) => unknown ? never : K;
+}[keyof T];
 
 export const unsetDate = dayjs(new Date("0000"));
 export const MAX_INT = 2147483647;

package/constant/via.ts

@@ -1,4 +1,14 @@
-import { type Cls, type EnumInstance, FIELD_META, type MergeAllKeyOfObjects, type MergeAllTypes } from "akanjs/base";
+import {
+  CLIENT_VALUE,
+  type Cls,
+  DEFAULT_VALUE,
+  type EnumInstance,
+  FIELD_META,
+  type ObjectAssign,
+  type ObjectAssignKeyOfObjects,
+  PURIFIED_VALUE,
+  SERVER_VALUE,
+} from "akanjs/base";
 import { applyMixins } from "akanjs/common";
 import { immerable } from "immer";
 
@@ -15,22 +25,44 @@ import {
   field,
   resolve,
 } from "./fieldInfo";
-import { makePurify, type PurifyFunc } from "./purify";
-import type { BaseInsight, BaseObject, ConstantType, DefaultOf, NonFunctionalKeys } from "./types";
+import { makePurify, type PurifiedModel, type PurifyFunc } from "./purify";
+import type { BaseInsight, BaseObject, ConstantType, DefaultOf, DefaultOfSchema, NonFunctionalKeys } from "./types";
 
 type BaseFields = "id" | "createdAt" | "updatedAt" | "removedAt";
 type WithBase<T> = T & BaseObject;
 type OmitBase<T> = Omit<T, BaseFields>;
 type Merge<A, B> = B & Omit<A, keyof B>;
+type MergeOwnSchemas<Models extends object[]> = ObjectAssignKeyOfObjects<Models, "_OwnSchema">;
+type MergeOwnFieldObjects<Models extends object[]> = ObjectAssignKeyOfObjects<Models, "_OwnFieldObj">;
+type MergeWithOwnSchemas<Models extends object[], OwnSchema extends object> = ObjectAssign<
+  [MergeOwnSchemas<Models>, OwnSchema]
+>;
+type MergeWithOwnFieldObjects<Models extends object[], OwnFieldObj extends object> = ObjectAssign<
+  [MergeOwnFieldObjects<Models>, OwnFieldObj]
+>;
+type BuiltSchema<BuildField extends (builder: FieldBuilder) => FieldInfoObject> = ExtractFieldInfoObject<
+  ReturnType<BuildField>
+>;
+type BuiltFieldObject<BuildField extends (builder: FieldBuilder) => FieldInfoObject> = FieldInfoObjectToFieldObject<
+  ReturnType<BuildField>
+>;
+type ResolvedSchema<ResolveField extends (resolve: FieldResolver) => FieldInfoObject> = ExtractFieldInfoObject<
+  ReturnType<ResolveField>
+>;
+type ResolvedFieldObject<ResolveField extends (resolve: FieldResolver) => FieldInfoObject> =
+  FieldInfoObjectToFieldObject<ReturnType<ResolveField>>;
 
-const objectModelOf = <T>(inputRef: ConstantCls<T>, fieldMap: FieldInfoObject): Cls<WithBase<T>> => {
+const objectModelOf = <T>(
+  inputRef: ConstantCls<T>,
+  fieldMap: FieldInfoObject,
+): ConstantCls<WithBase<T>, FieldObject, WithBase<T>, FieldObject, "object"> => {
   const fieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
   const applyFieldObject = { ...inputRef[FIELD_META], ...fieldObject };
   const field = Object.assign(ConstantField.getBaseModelField(), applyFieldObject);
   const baseObjectModelRef = getBaseConstantClass(field);
   applyConstantStatics(baseObjectModelRef, applyFieldObject);
   baseObjectModelRef.modelType = "object";
-  return baseObjectModelRef as unknown as Cls<WithBase<T>>;
+  return baseObjectModelRef as unknown as ConstantCls<WithBase<T>, FieldObject, WithBase<T>, FieldObject, "object">;
 };
 
 const lightModelOf = <T, F extends keyof OmitBase<T>>(
@@ -38,7 +70,13 @@ const lightModelOf = <T, F extends keyof OmitBase<T>>(
   fields: readonly F[],
   fieldMap: FieldInfoObject,
   ...libLightModelRefs: ConstantCls[]
-): Cls<Pick<OmitBase<T>, F> & BaseObject> => {
+): ConstantCls<
+  Pick<OmitBase<T>, F> & BaseObject,
+  FieldObject,
+  Pick<OmitBase<T>, F> & BaseObject,
+  FieldObject,
+  "light"
+> => {
   const libLightModelRef = libLightModelRefs.at(0);
   const applyFieldObject = {
     ...Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()])),
@@ -49,7 +87,13 @@ const lightModelOf = <T, F extends keyof OmitBase<T>>(
   applyConstantStatics(baseLightModelRef, applyFieldObject);
   applyMixins(baseLightModelRef, libLightModelRefs);
   baseLightModelRef.modelType = "light";
-  return baseLightModelRef as unknown as Cls<Pick<OmitBase<T>, F> & BaseObject>;
+  return baseLightModelRef as unknown as ConstantCls<
+    Pick<OmitBase<T>, F> & BaseObject,
+    FieldObject,
+    Pick<OmitBase<T>, F> & BaseObject,
+    FieldObject,
+    "light"
+  >;
 };
 
 const fullModelOf = <A, B = undefined>(
@@ -57,7 +101,7 @@ const fullModelOf = <A, B = undefined>(
   lightRef: ConstantCls<B>,
   fieldMap: FieldInfoObject,
   ...libFullModelRefs: ConstantCls[]
-): Cls<Merge<A, B>> => {
+): ConstantCls<Merge<A, B>, FieldObject, Merge<A, B>, FieldObject, "full"> => {
   const fullRef = libFullModelRefs.at(0) ?? getBaseConstantClass(ConstantField.getBaseModelField());
   const applyFieldObject = {
     ...objectRef[FIELD_META],
@@ -72,26 +116,38 @@ const fullModelOf = <A, B = undefined>(
 
   applyConstantStatics(fullRef, applyFieldObject);
   fullRef.modelType = "full";
-  return fullRef as unknown as Cls<Omit<A, keyof B> & B>;
+  return fullRef as unknown as ConstantCls<Merge<A, B>, FieldObject, Merge<A, B>, FieldObject, "full">;
 };
 
 const extendModelInputs = <T extends ConstantCls[]>(
   fieldMap: FieldInfoObject,
   ...libInputModelRefs: T
-): Cls<MergeAllTypes<T>> => {
+): ConstantCls<MergeOwnSchemas<T>, FieldObject, MergeOwnSchemas<T>, FieldObject, "input"> => {
   const baseInputModelRef = libInputModelRefs.at(0);
   const applyFieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
   const fieldObject = Object.assign(baseInputModelRef?.[FIELD_META] ?? {}, applyFieldObject);
   const baseInputRef = getBaseConstantClass(fieldObject);
   applyConstantStatics(baseInputRef, applyFieldObject);
-  return baseInputRef as unknown as Cls<MergeAllTypes<T>>;
+  return baseInputRef as unknown as ConstantCls<
+    MergeOwnSchemas<T>,
+    FieldObject,
+    MergeOwnSchemas<T>,
+    FieldObject,
+    "input"
+  >;
 };
 
 const extendModelObjects = <Input, ObjectModels extends ConstantCls[]>(
   inputRef: ConstantCls<Input>,
   fieldMap: FieldInfoObject,
   ...libObjectModelRefs: ObjectModels
-): Cls<MergeAllTypes<ObjectModels> & Input> => {
+): ConstantCls<
+  MergeWithOwnSchemas<ObjectModels, Input & object>,
+  FieldObject,
+  MergeWithOwnSchemas<ObjectModels, Input & object>,
+  FieldObject,
+  "object"
+> => {
   const baseObjectModelRef = libObjectModelRefs.at(0);
   const applyFieldObject = {
     ...inputRef[FIELD_META],
@@ -100,13 +156,19 @@ const extendModelObjects = <Input, ObjectModels extends ConstantCls[]>(
   const field = Object.assign(baseObjectModelRef?.[FIELD_META] ?? {}, applyFieldObject);
   const baseInputRef = getBaseConstantClass(field, "object");
   applyConstantStatics(baseInputRef, applyFieldObject);
-  return baseInputRef as unknown as Cls<MergeAllTypes<ObjectModels> & Input>;
+  return baseInputRef as unknown as ConstantCls<
+    MergeWithOwnSchemas<ObjectModels, Input & object>,
+    FieldObject,
+    MergeWithOwnSchemas<ObjectModels, Input & object>,
+    FieldObject,
+    "object"
+  >;
 };
 
 const extendModelInsights = <InsightModels extends ConstantCls[]>(
   fieldMap: FieldInfoObject,
   ...insightModelRefs: InsightModels
-): Cls<MergeAllTypes<InsightModels>> => {
+): ConstantCls<MergeOwnSchemas<InsightModels>, FieldObject, MergeOwnSchemas<InsightModels>, FieldObject, "insight"> => {
   const baseInsightModelRef = insightModelRefs.at(0);
   const applyFieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
   const field = Object.assign(
@@ -116,7 +178,13 @@ const extendModelInsights = <InsightModels extends ConstantCls[]>(
   const baseInsightRef = getBaseConstantClass(field, "insight");
 
   applyConstantStatics(baseInsightRef, applyFieldObject);
-  return baseInsightRef as unknown as Cls<MergeAllTypes<InsightModels>>;
+  return baseInsightRef as unknown as ConstantCls<
+    MergeOwnSchemas<InsightModels>,
+    FieldObject,
+    MergeOwnSchemas<InsightModels>,
+    FieldObject,
+    "insight"
+  >;
 };
 
 const getBaseConstantClass = (field: FieldObject, modelType: ConstantType = "scalar") => {
@@ -125,8 +193,8 @@ const getBaseConstantClass = (field: FieldObject, modelType: ConstantType = "sca
     static modelType: ConstantType = modelType;
     static text: { search: Set<string>; filter: Set<string>; children: { search: Set<string>; filter: Set<string> } } =
       { search: new Set(), filter: new Set(), children: { search: new Set(), filter: new Set() } };
-    static children: Set<ConstantCls> = new Set();
-    static relations: Set<ConstantCls> = new Set();
+    static children: Set<ConstantModelRef> = new Set();
+    static relations: Set<ConstantModelRef> = new Set();
     static enums: Set<EnumInstance> = new Set();
     [immerable] = true;
     constructor(obj?: Partial<unknown>) {
@@ -152,24 +220,85 @@ const getBaseConstantClass = (field: FieldObject, modelType: ConstantType = "sca
 
 const makeBaseScalar = <FieldMap extends FieldInfoObject>(
   fieldMap: FieldMap,
-): Cls<ExtractFieldInfoObject<FieldMap>> => {
+): ConstantCls<
+  ExtractFieldInfoObject<FieldMap>,
+  FieldObject,
+  ExtractFieldInfoObject<FieldMap>,
+  FieldObject,
+  "scalar"
+> => {
   const fieldObject = Object.fromEntries(Object.entries(fieldMap).map(([key, field]) => [key, field.toField()]));
   const baseScalarRef = getBaseConstantClass(fieldObject, "scalar");
   applyConstantStatics(baseScalarRef, fieldObject);
-  return baseScalarRef as unknown as Cls<ExtractFieldInfoObject<FieldMap>>;
+  return baseScalarRef as unknown as ConstantCls<
+    ExtractFieldInfoObject<FieldMap>,
+    FieldObject,
+    ExtractFieldInfoObject<FieldMap>,
+    FieldObject,
+    "scalar"
+  >;
 };
 
+type ConstantSetReturn<Self, Schema> = Self extends Schema & ConstantMethods<Schema> & infer Model
+  ? unknown extends Model
+    ? Self
+    : Model
+  : Self;
 export interface ConstantMethods<Schema = any> {
-  set: (obj: Partial<Schema>) => this;
+  set<Self extends Schema & ConstantMethods<Schema>>(this: Self, obj: Partial<Schema>): ConstantSetReturn<Self, Schema>;
 }
 
-export interface ConstantStatics<Schema = any, FieldObj extends FieldObject = FieldObject> {
+type DatabaseSchemaOf<Schema, HiddenKey> = {
+  [K in keyof Schema]: K extends HiddenKey ? NonNullable<Schema[K]> : Schema[K];
+};
+
+export interface ConstantStatics<
+  Schema = any,
+  OwnSchema = Schema,
+  OwnFieldObj extends FieldObject = FieldObject,
+  OptionalKey = never,
+  RelationKey = never,
+  PrimitiveKey = never,
+  ScalarKey = never,
+  EnumKey = never,
+  MapKey = never,
+  HiddenKey = never,
+  SecretKey = never,
+  ModelType extends ConstantType = ConstantType,
+> {
+  [FIELD_META]: FieldObject;
+  getDefault: () => DefaultOfSchema<Schema, RelationKey>;
+  purify: PurifyFunc<Schema>;
+  modelType: ConstantType;
+  children: Set<ConstantModelRef>;
+  relations: Set<ConstantModelRef>;
+  enums: Set<EnumInstance>;
+  text: { search: Set<string>; filter: Set<string>; children: { search: Set<string>; filter: Set<string> } };
+  _OptionalKey: OptionalKey;
+  _RelationKey: RelationKey;
+  _PrimitiveKey: PrimitiveKey;
+  _ScalarKey: ScalarKey;
+  _EnumKey: EnumKey;
+  _MapKey: MapKey;
+  _HiddenKey: HiddenKey;
+  _SecretKey: SecretKey;
+  _OwnSchema: OwnSchema;
+  _OwnFieldObj: OwnFieldObj;
+  _DatabaseSchema: DatabaseSchemaOf<Schema, HiddenKey>;
+  _ModelType: ModelType;
+  [SERVER_VALUE]: Schema;
+  [CLIENT_VALUE]: Schema;
+  [DEFAULT_VALUE]: DefaultOfSchema<Schema, RelationKey>;
+  [PURIFIED_VALUE]: PurifiedModel<Schema>;
+}
+
+export interface DatabaseConstantStatics<Schema = any, FieldObj extends FieldObject = FieldObject> {
   [FIELD_META]: FieldObj;
   getDefault: () => DefaultOf<Schema>;
   purify: PurifyFunc<Schema>;
   modelType: ConstantType;
-  children: Set<ConstantCls>;
-  relations: Set<ConstantCls>;
+  children: Set<ConstantModelRef>;
+  relations: Set<ConstantModelRef>;
   enums: Set<EnumInstance>;
   text: { search: Set<string>; filter: Set<string>; children: { search: Set<string>; filter: Set<string> } };
   _DatabaseSchema: {
@@ -180,17 +309,116 @@ export interface ConstantStatics<Schema = any, FieldObj extends FieldObject = Fi
       : Schema[K];
   };
 }
-export type ConstantCls<Schema = any, FieldObj extends FieldObject = FieldObject> = (new (
+
+export type ConstantModelRef<
+  Schema = any,
+  FieldObj extends FieldObject = FieldObject,
+  ModelType extends ConstantType = ConstantType,
+> = Cls<
+  Schema,
+  {
+    [FIELD_META]: FieldObj;
+    modelType: ModelType;
+    children: Set<ConstantModelRef>;
+    relations: Set<ConstantModelRef>;
+    enums: Set<EnumInstance>;
+    text: { search: Set<string>; filter: Set<string>; children: { search: Set<string>; filter: Set<string> } };
+  }
+>;
+
+export type DocumentConstantModelRef<
+  Schema = any,
+  FieldObj extends FieldObject = FieldObject,
+  ModelType extends ConstantType = ConstantType,
+  DatabaseSchema = DatabaseSchemaOf<Schema, never>,
+> = Cls<
+  Schema,
+  {
+    [FIELD_META]: FieldObj;
+    modelType: ModelType;
+    _DatabaseSchema: DatabaseSchema;
+    _ModelType: ModelType;
+  }
+>;
+
+type FieldFlag = "nullable" | "_isRelation" | "_isPrimitive" | "_isScalar" | "_isEnum" | "_isHidden" | "_isSecret" | "_isMap";
+type TrueFieldFlag<Flag extends FieldFlag> = { readonly [K in Flag]: true };
+type KeysByFlag<FieldObj extends FieldObject, Flag extends FieldFlag> = {
+  [K in keyof FieldObj]: FieldObj[K] extends TrueFieldFlag<Flag> ? K : never;
+}[keyof FieldObj];
+type OptionalKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "nullable">;
+type RelationKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isRelation">;
+type PrimitiveKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isPrimitive">;
+type ScalarKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isScalar">;
+type EnumKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isEnum">;
+type HiddenKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isHidden">;
+type SecretKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isSecret">;
+type MapKeys<FieldObj extends FieldObject> = KeysByFlag<FieldObj, "_isMap">;
+type ConstantKeyChannelMap = {
+  optional: unknown;
+  relation: unknown;
+  primitive: unknown;
+  scalar: unknown;
+  enum: unknown;
+  map: unknown;
+  hidden: unknown;
+  secret: unknown;
+};
+type IsBroadFieldObject<FieldObj extends FieldObject> = string extends keyof FieldObj ? true : false;
+type ConstantKeyChannels<FieldObj extends FieldObject> =
+  IsBroadFieldObject<FieldObj> extends true
+    ? {
+        optional: never;
+        relation: never;
+        primitive: never;
+        scalar: never;
+        enum: never;
+        map: never;
+        hidden: never;
+        secret: never;
+      }
+    : {
+        optional: OptionalKeys<FieldObj>;
+        relation: RelationKeys<FieldObj>;
+        primitive: PrimitiveKeys<FieldObj>;
+        scalar: ScalarKeys<FieldObj>;
+        enum: EnumKeys<FieldObj>;
+        map: MapKeys<FieldObj>;
+        hidden: HiddenKeys<FieldObj>;
+        secret: SecretKeys<FieldObj>;
+      };
+
+export type ConstantCls<
+  Schema = any,
+  FieldObj extends FieldObject = FieldObject,
+  OwnSchema = Schema,
+  OwnFieldObj extends FieldObject = FieldObj,
+  ModelType extends ConstantType = ConstantType,
+  _Channels extends ConstantKeyChannelMap = ConstantKeyChannels<FieldObj>,
+> = (new (
   obj?: Partial<Schema>,
 ) => Schema & ConstantMethods<Schema>) &
-  ConstantStatics<Schema, FieldObj>;
+  ConstantStatics<
+    Schema,
+    OwnSchema,
+    OwnFieldObj,
+    _Channels["optional"],
+    _Channels["relation"],
+    _Channels["primitive"],
+    _Channels["scalar"],
+    _Channels["enum"],
+    _Channels["map"],
+    _Channels["hidden"],
+    _Channels["secret"],
+    ModelType
+  >;
 
 declare global {
   
-  interface DateConstructor extends ConstantStatics<unknown> {}
-  interface StringConstructor extends ConstantStatics<unknown> {}
-  interface BooleanConstructor extends ConstantStatics<unknown> {}
-  interface MapConstructor extends ConstantStatics<unknown> {}
+  interface DateConstructor extends DatabaseConstantStatics<unknown> {}
+  interface StringConstructor extends DatabaseConstantStatics<unknown> {}
+  interface BooleanConstructor extends DatabaseConstantStatics<unknown> {}
+  interface MapConstructor extends DatabaseConstantStatics<unknown> {}
 }
 
 const applyConstantStatics = <Model>(model: ConstantCls<Model>, fieldMap: FieldObject): ConstantCls<Model> => {
@@ -234,48 +462,70 @@ export function via<
   K extends NonFunctionalKeys<OmitBase<Obj>>,
   ResolveField extends (resolve: FieldResolver) => FieldInfoObject,
   LightModels extends Cls[],
-  _Schema = MergeAllTypes<LightModels> & Pick<Obj, K> & BaseObject & ExtractFieldInfoObject<ReturnType<ResolveField>>,
-  _FieldObj extends FieldObject = MergeAllKeyOfObjects<LightModels, typeof FIELD_META> &
-    Pick<ObjFieldObj, K & keyof ObjFieldObj> &
-    FieldInfoObjectToFieldObject<ReturnType<ResolveField>>,
+  _DirectSchema extends object = ObjectAssign<[Pick<Obj, K> & BaseObject, ResolvedSchema<ResolveField>]>,
+  _Schema extends object = MergeWithOwnSchemas<LightModels, _DirectSchema>,
+  _DirectFieldObj extends FieldObject = ObjectAssign<
+    [Pick<ObjFieldObj, K & keyof ObjFieldObj>, ResolvedFieldObject<ResolveField>]
+  >,
+  _FieldObj extends FieldObject = MergeWithOwnFieldObjects<LightModels, _DirectFieldObj> & FieldObject,
 >(
   modelRef: Cls<Obj, { [FIELD_META]: ObjFieldObj }>,
   fields: readonly K[],
   resolveField: ResolveField,
   ...lightModelRefs: LightModels
-): ConstantCls<_Schema, _FieldObj>;
+): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "light">;
 
 export function via<
   BuildField extends (builder: FieldBuilder) => FieldInfoObject,
+  _DirectSchema extends object = BuiltSchema<BuildField>,
+  _DirectFieldObj extends FieldObject = BuiltFieldObject<BuildField>,
+>(
+  buildField: BuildField,
+): ConstantCls<_DirectSchema, _DirectFieldObj, _DirectSchema, _DirectFieldObj, "input" | "scalar">;
+
+export function via<
+  BuildField extends (builder: FieldBuilder) => FieldInfoObject,
+  FirstInput extends Cls,
   Inputs extends Cls[],
-  _Schema = MergeAllTypes<Inputs> & ExtractFieldInfoObject<ReturnType<BuildField>>,
-  _FieldObj extends FieldObject = MergeAllKeyOfObjects<Inputs, typeof FIELD_META> &
-    FieldInfoObjectToFieldObject<ReturnType<BuildField>>,
->(buildField: BuildField, ...extendInputRefs: Inputs): ConstantCls<_Schema, _FieldObj>;
+  _DirectSchema extends object = BuiltSchema<BuildField>,
+  _InputRefs extends Cls[] = [FirstInput, ...Inputs],
+  _Schema extends object = MergeWithOwnSchemas<_InputRefs, _DirectSchema>,
+  _DirectFieldObj extends FieldObject = BuiltFieldObject<BuildField>,
+  _FieldObj extends FieldObject = MergeWithOwnFieldObjects<_InputRefs, _DirectFieldObj> & FieldObject,
+>(
+  buildField: BuildField,
+  firstExtendInputRef: FirstInput,
+  ...extendInputRefs: Inputs
+): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "input">;
 
 export function via<
   Full extends BaseObject,
   BuildField extends (builder: FieldBuilder) => FieldInfoObject,
   Insights extends Cls[],
-  _Schema = MergeAllTypes<Insights> & BaseInsight & ExtractFieldInfoObject<ReturnType<BuildField>>,
-  _FieldObj extends FieldObject = MergeAllKeyOfObjects<Insights, typeof FIELD_META> &
-    FieldInfoObjectToFieldObject<ReturnType<BuildField>>,
->(modelRef: Cls<Full>, buildField: BuildField, ...extendInsightRefs: Insights): ConstantCls<_Schema, _FieldObj>;
+  _DirectSchema extends object = ObjectAssign<[BaseInsight, BuiltSchema<BuildField>]>,
+  _Schema extends object = MergeWithOwnSchemas<Insights, _DirectSchema>,
+  _DirectFieldObj extends FieldObject = BuiltFieldObject<BuildField>,
+  _FieldObj extends FieldObject = MergeWithOwnFieldObjects<Insights, _DirectFieldObj> & FieldObject,
+>(
+  modelRef: Cls<Full>,
+  buildField: BuildField,
+  ...extendInsightRefs: Insights
+): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "insight">;
 
 export function via<
   Input,
   InputFieldObj extends FieldObject,
   BuildField extends (builder: FieldBuilder) => FieldInfoObject,
   ObjectModels extends Cls[],
-  _Schema = MergeAllTypes<ObjectModels> & Input & BaseObject & ExtractFieldInfoObject<ReturnType<BuildField>>,
-  _FieldObj extends FieldObject = MergeAllKeyOfObjects<ObjectModels, typeof FIELD_META> &
-    InputFieldObj &
-    FieldInfoObjectToFieldObject<ReturnType<BuildField>>,
+  _DirectSchema extends object = ObjectAssign<[Input & object, BaseObject, BuiltSchema<BuildField>]>,
+  _Schema extends object = MergeWithOwnSchemas<ObjectModels, _DirectSchema>,
+  _DirectFieldObj extends FieldObject = ObjectAssign<[InputFieldObj, BuiltFieldObject<BuildField>]>,
+  _FieldObj extends FieldObject = MergeWithOwnFieldObjects<ObjectModels, _DirectFieldObj> & FieldObject,
 >(
   inputRef: Cls<Input, { [FIELD_META]: InputFieldObj }>,
   buildField: BuildField,
   ...extendObjectRefs: ObjectModels
-): ConstantCls<_Schema, _FieldObj>;
+): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "object">;
 
 export function via<
   Obj,
@@ -284,17 +534,16 @@ export function via<
   LightFieldObj extends FieldObject,
   ResolveField extends (resolve: FieldResolver) => FieldInfoObject,
   FullModels extends Cls[],
-  _Schema = MergeAllTypes<FullModels> & Obj & Light & ExtractFieldInfoObject<ReturnType<ResolveField>>,
-  _FieldObj extends FieldObject = MergeAllKeyOfObjects<FullModels, typeof FIELD_META> &
-    ObjFieldObj &
-    LightFieldObj &
-    FieldInfoObjectToFieldObject<ReturnType<ResolveField>>,
+  _DirectSchema extends object = ObjectAssign<[Obj & object, Light & object, ResolvedSchema<ResolveField>]>,
+  _Schema extends object = MergeWithOwnSchemas<FullModels, _DirectSchema>,
+  _DirectFieldObj extends FieldObject = ObjectAssign<[ObjFieldObj, LightFieldObj, ResolvedFieldObject<ResolveField>]>,
+  _FieldObj extends FieldObject = MergeWithOwnFieldObjects<FullModels, _DirectFieldObj> & FieldObject,
 >(
   objectRef: Cls<Obj, { [FIELD_META]: ObjFieldObj }>,
   lightModelRef: Cls<Light, { [FIELD_META]: LightFieldObj }>,
   resolveField: ResolveField,
   ...fullModelRefs: FullModels
-): ConstantCls<_Schema, _FieldObj>;
+): ConstantCls<_Schema, _FieldObj, _Schema, _FieldObj, "full">;
 
 export function via(
   firstRefOrBuildField: Cls | ((builder: FieldBuilder) => FieldInfoObject),