akanjs 0.0.1 → 2.0.0-beta.1

package/constant/fieldInfo.ts

@@ -0,0 +1,415 @@
+import {
+  type Any,
+  arraiedModel,
+  type Cls,
+  type Dayjs,
+  type EnumInstance,
+  type Float,
+  getNonArrayModel,
+  ID,
+  Int,
+  isEnum,
+  PRIMITIVE_CLIENT_VALUE,
+  PRIMITIVE_SERVER_VALUE,
+  PrimitiveRegistry,
+  type PrimitiveScalar,
+  type SingleValue,
+  type UnCls,
+} from "akanjs/base";
+import { ConstantRegistry } from "./constantRegistry";
+import type { ConstantCls } from "./via";
+
+export type ParamFieldType =
+  | (typeof PrimitiveScalar & {
+      [PRIMITIVE_CLIENT_VALUE]: string | number | boolean | Dayjs;
+    })
+  | EnumInstance<string, any>;
+
+export type ConstantFieldType = typeof PrimitiveScalar | Cls | MapConstructor | EnumInstance<string, 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 { [PRIMITIVE_SERVER_VALUE]: infer V }
+        ? V
+        : Field extends EnumInstance<string, infer V>
+          ? V
+          : Field extends Cls
+            ? UnCls<Field>
+            : never;
+export interface FieldInfoObject {
+  [key: string]: FieldInfo<any, ConstantFieldTypeInput | null, any>;
+}
+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;
+};
+
+export interface ConstantFieldProps<
+  FieldType extends "property" | "hidden" | "resolve" = "property" | "hidden" | "resolve",
+  FieldValue = any,
+  MapValue = any,
+  Metadata = { [key: string]: any },
+> {
+  nullable?: boolean;
+  ref?: string;
+  refPath?: string;
+  refType?: "child" | "parent" | "relation";
+  default?: FieldValue | ((doc: { id: string }) => FieldValue);
+  type?: FieldPreset;
+  fieldType?: FieldType;
+  immutable?: boolean;
+  min?: number;
+  max?: number;
+  enum?: EnumInstance;
+  select?: boolean;
+  minlength?: number;
+  maxlength?: number;
+  accumulate?: any;
+  example?: FieldValue;
+  of?: MapValue; 
+  validate?: (value: FieldValue, model: any) => boolean;
+  text?: "search" | "filter";
+  meta?: Metadata;
+}
+export const fieldPresets = ["email", "password", "url"] as const;
+export type FieldPreset = (typeof fieldPresets)[number];
+
+class FieldInfo<
+  FieldType extends "property" | "hidden" | "resolve" = any,
+  Value extends ConstantFieldTypeInput | null = null,
+  ExplicitType = unknown,
+  MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never,
+> {
+  readonly value: Value;
+  readonly type: ConstantFieldTypeInput;
+  readonly option: ConstantFieldProps;
+  declare explicitType: ExplicitType;
+  constructor(value: Value, option: ConstantFieldProps<FieldType, any, MapValue>) {
+    this.value = value;
+    const [singleValue, arrDepth] = getNonArrayModel(value as Cls);
+    const isEnumValue = isEnum(singleValue);
+    const valueType = isEnumValue ? arraiedModel((singleValue as EnumInstance).type, arrDepth) : value;
+    this.type = valueType as ConstantFieldTypeInput;
+    this.option = {
+      ...option,
+      ...(isEnumValue ? { enum: singleValue } : {}),
+    } as any;
+  }
+  optional() {
+    this.option.nullable = true;
+    return this as FieldInfo<FieldType, Value | null, ExplicitType | null, MapValue>;
+  }
+  meta(meta: ConstantFieldProps["meta"]) {
+    this.option.meta = meta;
+    return this;
+  }
+  toField() {
+    return ConstantField.fromFieldInfo(this);
+  }
+}
+
+interface ConstantFieldBuildProps<
+  FieldType extends "property" | "hidden" | "resolve" = any,
+  FieldValue = any,
+  MapValue = any,
+  Metadata = any,
+  Nullable extends boolean = boolean,
+> {
+  nullable: Nullable;
+  ref?: string;
+  refPath?: string;
+  refType?: "child" | "parent" | "relation";
+  default: FieldValue | ((doc: { id: string }) => FieldValue);
+  type?: FieldPreset;
+  fieldType: FieldType;
+  immutable: boolean;
+  min?: number;
+  max?: number;
+  enum?: EnumInstance;
+  select: boolean;
+  minlength?: number;
+  maxlength?: number;
+  accumulate?: any;
+  example?: FieldValue;
+  of?: MapValue; 
+  validate?: (value: FieldValue, model: any) => boolean;
+  text?: "search" | "filter";
+  modelRef: ConstantCls;
+  arrDepth: number;
+  optArrDepth: number;
+  meta: Metadata;
+}
+
+export interface FieldProps extends ConstantFieldBuildProps {
+  isClass: boolean;
+  isScalar: boolean;
+  isArray: boolean;
+  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<
+        FieldType,
+        Value,
+        unknown extends ExplicitType ? FieldToValue<Value, MapValue> : ExplicitType,
+        MapValue
+      >
+    : never;
+};
+
+/** Runtime metadata for a single Akan constant field. */
+export class ConstantField<
+  FieldType extends "property" | "hidden" | "resolve" = "property" | "hidden" | "resolve",
+  Value extends ConstantFieldTypeInput | null = any,
+  FieldValue = any,
+  MapValue = any,
+  Nullable extends boolean = false,
+  Metadata = { [key: string]: any },
+> implements ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata>
+{
+  static getBaseModelField(): FieldObject {
+    return {
+      id: field(ID).toField(),
+      createdAt: field(Date).toField(),
+      updatedAt: field(Date).toField(),
+      removedAt: field(Date).optional().toField(),
+    };
+  }
+  static getBaseInsightField(): FieldObject {
+    return {
+      count: field(Int, { default: 0, accumulate: { $sum: 1 } }).toField(),
+    };
+  }
+  readonly nullable: Nullable;
+  readonly ref?: string;
+  readonly refPath?: string;
+  readonly refType?: "child" | "parent" | "relation";
+  readonly default: FieldValue | ((doc: { id: string }) => FieldValue);
+  readonly type?: FieldPreset;
+  readonly fieldType: FieldType;
+  readonly immutable: boolean;
+  readonly min?: number;
+  readonly max?: number;
+  readonly enum?: EnumInstance;
+  readonly select: boolean;
+  readonly minlength?: number;
+  readonly maxlength?: number;
+  readonly accumulate?: any;
+  readonly example?: FieldValue;
+  readonly of?: MapValue; 
+  readonly validate?: (value: FieldValue, model: any) => boolean;
+  readonly text?: "search" | "filter";
+  readonly modelRef: ConstantCls;
+  readonly arrDepth: number;
+  readonly optArrDepth: number;
+  readonly meta: Metadata;
+
+  constructor(props: ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata>) {
+    this.nullable = props.nullable as unknown as Nullable;
+    this.ref = props.ref;
+    this.refPath = props.refPath;
+    this.refType = props.refType;
+    this.default = props.default;
+    this.type = props.type;
+    this.fieldType = props.fieldType;
+    this.immutable = props.immutable;
+    this.min = props.min;
+    this.max = props.max;
+    this.enum = props.enum;
+    this.select = props.select;
+    this.minlength = props.minlength;
+    this.maxlength = props.maxlength;
+    this.accumulate = props.accumulate;
+    this.example = props.example;
+    this.of = props.of;
+    this.validate = props.validate;
+    this.text = props.text;
+    this.modelRef = props.modelRef;
+    this.arrDepth = props.arrDepth;
+    this.optArrDepth = props.optArrDepth;
+    this.meta = props.meta;
+  }
+
+  static fromFieldInfo<
+    FieldType extends "property" | "hidden" | "resolve" = any,
+    Value extends ConstantFieldTypeInput | null = null,
+    FieldValue = any,
+    MapValue = any,
+    Nullable extends boolean = false,
+    Metadata = { [key: string]: any },
+  >(
+    fieldInfo: FieldInfo<FieldType, Value, FieldValue, MapValue>,
+  ): ConstantField<FieldType, Value, FieldValue, MapValue, Nullable, Metadata> {
+    const [modelRef, arrDepth] = getNonArrayModel(fieldInfo.type as Cls);
+    const [option, optArrDepth] = getNonArrayModel(fieldInfo.option);
+
+    const isArray = arrDepth > 0;
+    const isMap = modelRef === Map;
+    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),
+      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,
+      of: option.of,
+      validate: option.validate,
+      text: option.text,
+      modelRef,
+      arrDepth: arrDepth,
+      optArrDepth: optArrDepth,
+      meta: (option.meta ?? {}) as Metadata,
+    } as ConstantFieldBuildProps<FieldType, FieldValue, MapValue, Metadata, Nullable>);
+  }
+  get isClass() {
+    return !PrimitiveRegistry.has(this.modelRef) && !this.isMap;
+  }
+  get isScalar() {
+    return ConstantRegistry.isScalar(this.modelRef) || PrimitiveRegistry.has(this.modelRef);
+  }
+  get isArray() {
+    return this.arrDepth > 0;
+  }
+  get isMap() {
+    return this.modelRef === Map;
+  }
+  getProps(): FieldProps {
+    return {
+      nullable: this.nullable as unknown as boolean,
+      ref: this.ref,
+      refPath: this.refPath,
+      refType: this.refType,
+      default: this.default,
+      type: this.type,
+      fieldType: this.fieldType,
+      immutable: this.immutable,
+      min: this.min,
+      max: this.max,
+      enum: this.enum,
+      select: this.select,
+      minlength: this.minlength,
+      maxlength: this.maxlength,
+      accumulate: this.accumulate,
+      example: this.example,
+      of: this.of,
+      validate: this.validate,
+      text: this.text,
+      modelRef: this.modelRef,
+      arrDepth: this.arrDepth,
+      optArrDepth: this.optArrDepth,
+      meta: this.meta,
+      isClass: this.isClass,
+      isScalar: this.isScalar,
+      isArray: this.isArray,
+      isMap: this.isMap,
+    };
+  }
+}
+export interface FieldObject {
+  [key: string]: ConstantField;
+}
+
+type FieldOption<
+  Value extends ConstantFieldTypeInput,
+  MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never,
+  Metadata extends { [key: string]: any } = { [key: string]: any },
+  _FieldToValue = FieldToValue<Value, MapValue> | null | undefined,
+> =
+  | Omit<
+      ConstantFieldProps<"property" | "hidden" | "resolve", _FieldToValue, MapValue, Metadata>,
+      "enum" | "meta" | "nullable" | "fieldType" | "select"
+    >
+  | Omit<
+      ConstantFieldProps<"property" | "hidden" | "resolve", SingleValue<_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 Any;
+
+/** Builds a stored property field with optional validation, default, ref, text, and metadata options. */
+export const field = <
+  ExplicitType,
+  Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+  MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never,
+>(
+  value: Value,
+  option: FieldOption<Value, MapValue> = {},
+) =>
+  new FieldInfo<"property", Value, ExplicitType, MapValue>(value, {
+    ...option,
+    fieldType: "property",
+  });
+
+field.hidden = <
+  ExplicitType,
+  Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+  MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never,
+>(
+  value: Value,
+  option: FieldOption<Value, MapValue> = {},
+) =>
+  new FieldInfo<"hidden", Value | null, ExplicitType | null, MapValue>(value, {
+    ...option,
+    fieldType: "hidden",
+    nullable: true,
+  });
+field.secret = <
+  ExplicitType,
+  Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+  MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never,
+>(
+  value: Value,
+  option: FieldOption<Value, MapValue> = {},
+) =>
+  new FieldInfo<"hidden", Value | null, ExplicitType | null, MapValue>(value, {
+    ...option,
+    fieldType: "hidden",
+    select: false,
+    nullable: true,
+  });
+/** Builds a resolved field that is derived rather than treated as a stored property. */
+export const resolve = <
+  ExplicitType,
+  Value extends ConstantFieldTypeInput = PlainTypeToFieldType<ExplicitType>,
+  MapValue = Value extends MapConstructor ? typeof PrimitiveScalar : never,
+>(
+  value: Value,
+  option: FieldOption<Value, MapValue> = {},
+) =>
+  new FieldInfo<"resolve", Value, ExplicitType, MapValue>(value, {
+    ...option,
+    fieldType: "resolve",
+  });
+export type FieldBuilder = typeof field;
+export type FieldResolver = typeof resolve;

package/constant/getDefault.ts

@@ -0,0 +1,18 @@
+import { FIELD_META, PRIMITIVE_DEFAULT_VALUE, type PrimitiveScalar } from "akanjs/base";
+import type { FieldObject } from ".";
+import type { DefaultOf } from "./types";
+
+export const getDefault = <T>(fieldObj: FieldObject): DefaultOf<T> => {
+  const result: Record<string, unknown> = {};
+  for (const [key, field] of Object.entries(fieldObj)) {
+    if (field.fieldType === "hidden") result[key] = null;
+    else if (field.default) {
+      if (typeof field.default === "function") result[key] = (field.default as () => object)();
+      else result[key] = field.default as object;
+    } 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];
+  }
+  return result as DefaultOf<T>;
+};

package/constant/immerify.ts

@@ -0,0 +1,16 @@
+import { FIELD_META } from "akanjs/base";
+import { immerable } from "immer";
+import type { ConstantCls } from ".";
+
+export const immerify = <T extends object>(modelRef: ConstantCls, 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,
+  }) as Record<string, unknown>;
+  const objRecord = objOrArr as Record<string, unknown>;
+  Object.entries(modelRef[FIELD_META]).forEach(([key, field]) => {
+    if (field.isScalar && field.isClass && !!objRecord[key])
+      immeredObj[key] = immerify(field.modelRef, objRecord[key] as object);
+  });
+  return immeredObj as T;
+};

package/constant/index.ts

@@ -0,0 +1,10 @@
+export * from "./constantRegistry";
+export * from "./crystalize";
+export * from "./deserialize";
+export * from "./fieldInfo";
+export * from "./getDefault";
+export * from "./immerify";
+export * from "./purify";
+export * from "./serialize";
+export * from "./types";
+export * from "./via";

package/constant/purify.ts

@@ -0,0 +1,118 @@
+import {
+  applyFnToArrayObjects,
+  type Cls,
+  type Dayjs,
+  dayjs,
+  FIELD_META,
+  type GetStateObject,
+  getNonArrayModel,
+  ID,
+  PrimitiveRegistry,
+  type PrimitiveScalar,
+  type Upload,
+} from "akanjs/base";
+import { Logger } from "akanjs/common";
+
+import { type BaseObject, type ConstantCls, ConstantRegistry, type DefaultOf, type FieldProps } from ".";
+
+type Purified<O> = O extends BaseObject
+  ? string
+  : O extends BaseObject[]
+    ? string[]
+    : O extends Dayjs
+      ? Dayjs
+      : O extends object
+        ? PurifiedModel<O>
+        : O;
+type PurifiedWithObjectToId<T, StateKeys extends keyof GetStateObject<T> = keyof GetStateObject<T>> = {
+  [K in StateKeys as null extends T[K] ? never : K]: Purified<T[K]>;
+} & {
+  [K in StateKeys as null extends T[K] ? K : never]?: Purified<T[K]> | undefined;
+};
+export type PurifiedModel<T> = T extends Upload[]
+  ? FileList
+  : T extends (infer S)[]
+    ? PurifiedModel<S>[]
+    : T extends string | number | boolean | Dayjs
+      ? 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;
+
+const getPurifyFn = (modelRef: Cls): ((value: unknown) => unknown) => {
+  const [valueRef] = getNonArrayModel(modelRef);
+  const purifyFn = PrimitiveRegistry.has(valueRef)
+    ? (value: unknown) => (valueRef as unknown as typeof PrimitiveScalar)._serialize(value as never)
+    : (value: unknown) => value as object;
+  return purifyFn;
+};
+
+const purify = (field: FieldProps, key: string, value: unknown, self: Record<string, unknown>): unknown => {
+  
+  if (
+    field.nullable &&
+    (value === null ||
+      value === undefined ||
+      (typeof value === "number" && Number.isNaN(value)) ||
+      (typeof value === "string" && !value.length))
+  )
+    return null;
+  if (field.isArray) {
+    if (!Array.isArray(value)) throw new Error(`Invalid Array Value in ${key} for value ${value}`);
+    if (field.minlength && value.length < field.minlength)
+      throw new Error(`Invalid Array Length (Min) in ${key} for value ${value}`);
+    else if (field.maxlength && value.length > field.maxlength)
+      throw new Error(`Invalid Array Length (Max) in ${key} for value ${value}`);
+    else if (field.optArrDepth === 0 && field.validate && !field.validate(value, self))
+      throw new Error(`Invalid Array Value (Failed to pass validation) in ${key} for value ${value}`);
+    return value.map((v) => purify({ ...field, isArray: field.arrDepth > 1, arrDepth: field.arrDepth - 1 }, key, v, v));
+  }
+  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);
+    return Object.fromEntries(
+      [...(value as Map<string, unknown>).entries()].map(([key, val]) => [key, applyFnToArrayObjects(val, purifyFn)]),
+    );
+  }
+  if (field.isClass) return makePurify(field.modelRef)(value as object, true) as object;
+  if (field.modelRef === Date && dayjs(value as Date).isBefore(dayjs(new Date("0000"))))
+    throw new Error(`Invalid Date Value (Default) in ${key} for value ${value}`);
+  if ([String, ID].includes(field.modelRef as unknown as StringConstructor | typeof ID) && (value === "" || !value))
+    throw new Error(`Invalid String Value (Default) in ${key} for value ${value}`);
+  if (field.validate && !field.validate(value, self))
+    throw new Error(`Invalid Value (Failed to pass validation) / ${value} in ${key}`);
+  if (!field.nullable && !value && value !== 0 && value !== false)
+    throw new Error(`Invalid Value (Nullable) in ${key} for value ${value}`);
+
+  const purifyFn = getPurifyFn(field.modelRef);
+  return purifyFn(value);
+};
+
+export const makePurify = <I>(modelRef: ConstantCls<I>): PurifyFunc<I> => {
+  const fn = ((self: Record<string, unknown>, isChild?: boolean): unknown => {
+    try {
+      if (isChild && !ConstantRegistry.isScalar(modelRef)) {
+        const id = self.id as string;
+        if (!id) throw new Error(`Invalid Value (No ID) for id ${modelRef}`);
+        return id;
+      }
+      const result: Record<string, unknown> = {};
+      Object.entries(modelRef[FIELD_META]).forEach(([key, field]) => {
+        const value = self[key] as object;
+        result[key] = purify(field.getProps(), key, value, self) as object;
+      });
+      return result;
+    } catch (err) {
+      if (isChild) throw new Error(err as string);
+      Logger.debug(err as string);
+      return null;
+    }
+  }) as PurifyFunc<I>;
+  return fn;
+};

package/constant/serialize.ts

@@ -0,0 +1,87 @@
+import {
+  applyFnToArrayObjects,
+  type Cls,
+  type Dayjs,
+  FIELD_META,
+  getNonArrayModel,
+  ID,
+  PrimitiveRegistry,
+  type PrimitiveScalar,
+} from "akanjs/base";
+
+import type { ConstantCls } from ".";
+
+export type Serialized<O> = O extends (infer V)[]
+  ? Serialized<V>[]
+  : O extends Dayjs
+    ? Date
+    : O extends Map<infer K, infer V>
+      ? { [key in K & string]: Serialized<V> }
+      : O extends object
+        ? { [K in keyof O]: Serialized<O[K]> }
+        : O;
+
+const getSerializeFn = (inputRef: Cls, { optional = false }: { optional?: boolean } = {}) => {
+  const serializeFn = PrimitiveRegistry.has(inputRef)
+    ? (value: unknown) => (inputRef as typeof PrimitiveScalar)._serialize(value as never, { optional })
+    : (value: unknown) => value as object;
+  return serializeFn;
+};
+const serializeInput = <Input = unknown>(
+  value: Input | Input[],
+  inputRef: ConstantCls<Input> | PrimitiveScalar,
+  arrDepth: number,
+  serializeType: "input" | "object" = "object",
+  { optional = false }: { optional?: boolean } = {},
+): Input | Input[] => {
+  if (arrDepth && Array.isArray(value))
+    return value.map((v) => serializeInput(v, inputRef, arrDepth - 1) as Input) as unknown as Input[];
+  else if ((inputRef as MapConstructor).prototype === Map.prototype) {
+    const [valueRef] = getNonArrayModel(inputRef as Cls);
+    const serializeFn = getSerializeFn(valueRef, { optional });
+    return Object.fromEntries(
+      [...(value as Map<string, unknown>).entries()].map(([key, val]) => [
+        key,
+        applyFnToArrayObjects(val, serializeFn),
+      ]),
+    ) as unknown as Input;
+  } else if (PrimitiveRegistry.has(inputRef as Cls)) {
+    const serializeFn = getSerializeFn(inputRef as Cls, { optional });
+    return serializeFn(value) as Input;
+  } else {
+    const modelRef = inputRef as ConstantCls;
+    return Object.fromEntries(
+      Object.entries(modelRef[FIELD_META]).map(([key, field]) => [
+        key,
+        field.isClass && !field.isScalar
+          ? serialize(ID, field.arrDepth, getRelationId((value as Record<string, unknown>)?.[key]), serializeType, {
+              nullable: field.nullable,
+              key,
+            })
+          : serialize(field.modelRef, field.arrDepth, (value as Record<string, unknown>)?.[key], serializeType, {
+              nullable: field.nullable,
+              key,
+            }),
+      ]),
+    ) as unknown as Input;
+  }
+};
+
+const getRelationId = (value: unknown): unknown => {
+  if (Array.isArray(value)) return value.map((item) => getRelationId(item));
+  if (value && typeof value === "object" && "id" in value) return (value as { id: unknown }).id;
+  return value;
+};
+
+export const serialize = (
+  argRef: ConstantCls | 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))
+    throw new Error(`Invalid Value (Nullable) in ${argRef} for value ${value}${key ? ` in ${key}` : ""}`);
+  return serializeInput(value, argRef, arrDepth, serializeType, { optional: nullable }) as object[];
+};