akanjs 2.3.5-rc.9 → 2.3.5

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,13 +30,13 @@ 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 } = {},
 ): Input | Input[] => {
   if (arrDepth && Array.isArray(value))
-    return value.map((v) => serializeInput(v, inputRef, arrDepth - 1) as Input) as unknown as Input[];
+    return value.map((v) => serializeInput(v, inputRef, arrDepth - 1, serializeType) 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 });
@@ -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;