akanjs 2.3.5-rc.8 → 2.3.5

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,47 +220,213 @@ 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: {
     [K in keyof Schema]: K extends keyof FieldObj
-      ? FieldObj[K] extends ConstantField<infer FieldType, any, any, any, any, any>
-        ? FieldType extends "hidden"
-          ? NonNullable<Schema[K]>
-          : Schema[K]
+      ? FieldObj[K]["fieldType"] extends "hidden"
+        ? NonNullable<Schema[K]>
         : Schema[K]
       : 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> => {
@@ -236,48 +470,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,
@@ -286,17 +542,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),

package/dictionary/dictInfo.ts

@@ -1,12 +1,22 @@
 import type { GetStateObject } from "akanjs/base";
 import { capitalize } from "akanjs/common";
 import type { BaseInsight, BaseObject } from "akanjs/constant";
-import type { BaseFilterQueryKey, BaseFilterSortKey, FilterInfo, FilterInstance } from "akanjs/document";
-import type { EndpointInfo, SliceInfo } from "akanjs/signal";
+import type { BaseFilterQueryKey, BaseFilterSortKey, FilterCls, FilterInfo, FilterInstance } from "akanjs/document";
+import type { EndpInfoArgNames, EndpointInfo, SliceInfo, SliceInfoArgNames } from "akanjs/signal";
 import type { DictionaryNode, RootDictionary } from "./trans";
 
 type MutableDictionaryNode = DictionaryNode & { t?: string; desc?: DictionaryNode };
 type EnumValueKey = string | number;
+type AnyFilterShape = FilterInstance<Record<string, FilterInfo>, Record<string, unknown>>;
+type DictFilterShape<Filter> = Filter extends FilterInstance
+  ? Filter
+  : Filter extends FilterCls<infer FilterShape>
+    ? FilterShape
+    : Filter extends { query: Record<string, FilterInfo>; sort: Record<string, unknown> }
+      ? Filter
+      : AnyFilterShape;
+type DictFilterQuery<Filter> = DictFilterShape<Filter>["query"];
+type DictFilterSort<Filter> = DictFilterShape<Filter>["sort"];
 
 const ensureNode = (target: DictionaryNode, key: string): MutableDictionaryNode => {
   target[key] ??= {};
@@ -250,24 +260,27 @@ export class ModelDictInfo<
       EtcKey
     >;
   }
-  query<Filter extends FilterInstance>(
+  query<Filter>(
     translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
-      [K in Exclude<keyof Filter["query"], QueryKey>]: Filter["query"][K] extends FilterInfo<infer ArgNames, any>
+      [K in Exclude<keyof DictFilterQuery<Filter>, QueryKey>]: DictFilterQuery<Filter>[K] extends FilterInfo<
+        infer ArgNames,
+        any
+      >
         ? FunctionTranslation<Languages, ArgNames[number]>
         : never;
     },
   ) {
     Object.assign(this.queryDictionary, translate(fn), ModelDictInfo.baseQueryDictionary) as unknown as {
-      [K in keyof Filter["query"]]: FunctionTranslation<
+      [K in keyof DictFilterQuery<Filter>]: FunctionTranslation<
         Languages,
-        Filter["query"][K] extends FilterInfo<infer ArgNames, any> ? ArgNames[number] : never
+        DictFilterQuery<Filter>[K] extends FilterInfo<infer ArgNames, any> ? ArgNames[number] : never
       >;
     };
     return this as unknown as ModelDictInfo<
       Languages,
       ModelKey,
       InsightKey,
-      keyof Filter["query"] & string,
+      keyof DictFilterQuery<Filter> & string,
       SortKey,
       EnumKey,
       BaseSignalKey,
@@ -277,9 +290,9 @@ export class ModelDictInfo<
       EtcKey
     >;
   }
-  sort<Filter extends FilterInstance>(
+  sort<Filter>(
     translate: (t: (trans: Languages) => FieldTranslation<Languages>) => {
-      [K in Exclude<keyof Filter["sort"], SortKey>]: FieldTranslation<Languages>;
+      [K in Exclude<keyof DictFilterSort<Filter>, SortKey>]: FieldTranslation<Languages>;
     },
   ) {
     Object.assign(
@@ -292,7 +305,7 @@ export class ModelDictInfo<
       ModelKey,
       InsightKey,
       QueryKey,
-      keyof Filter["sort"] & string,
+      keyof DictFilterSort<Filter> & string,
       EnumKey,
       BaseSignalKey,
       SliceKey,
@@ -327,20 +340,8 @@ export class ModelDictInfo<
   }
   slice<Slice>(
     translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
-      [K in Exclude<keyof Slice, SliceKey>]: Slice[K] extends SliceInfo<
-        any,
-        any,
-        any,
-        any,
-        any,
-        any,
-        any,
-        infer ArgNames,
-        any,
-        any,
-        any
-      >
-        ? FunctionTranslation<Languages, ArgNames[number]>
+      [K in Exclude<keyof Slice, SliceKey>]: Slice[K] extends infer Info extends SliceInfo
+        ? FunctionTranslation<Languages, SliceInfoArgNames<Info>[number]>
         : never;
     },
   ) {
@@ -363,19 +364,8 @@ export class ModelDictInfo<
   }
   endpoint<Endpoint>(
     translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
-      [K in Exclude<keyof Endpoint, EndpointKey>]: Endpoint[K] extends EndpointInfo<
-        any,
-        any,
-        infer ArgNames,
-        any,
-        any,
-        any,
-        any,
-        any,
-        any,
-        any
-      >
-        ? FunctionTranslation<Languages, ArgNames[number]>
+      [K in Exclude<keyof Endpoint, EndpointKey>]: Endpoint[K] extends infer Info extends EndpointInfo
+        ? FunctionTranslation<Languages, EndpInfoArgNames<Info>[number]>
         : never;
     },
   ) {
@@ -992,7 +982,7 @@ export class ServiceDictInfo<
   }
   endpoint<Endpoint extends { [key: string]: EndpointInfo }>(
     translate: (fn: (trans: Languages) => FunctionTranslation<Languages>) => {
-      [K in keyof Endpoint]: FunctionTranslation<Languages, Endpoint[K]["argNames"][number]>;
+      [K in keyof Endpoint]: FunctionTranslation<Languages, EndpInfoArgNames<Endpoint[K]>[number]>;
     },
   ) {
     Object.assign(this.endpointDictionary, translate(fn)) as unknown as {