nest now better at inference

Author: cblanquera

docs/Types.md

@@ -717,6 +717,10 @@ Session change tracking entry for audit and rollback capabilities.
 ```typescript
 const revision: Revision = {
   action: 'set',
+  options: {
+    httpOnly: true,
+    sameSite: 'lax'
+  },
   value: 'newValue'
 };
 
@@ -730,6 +734,7 @@ const removeRevision: Revision = {
 | Property | Type | Description |
 |----------|------|-------------|
 | `action` | `'set'|'remove'` | Type of change performed |
+| `options` | `CookieOptions` | Cookie settings stored for this specific key |
 | `value` | `string|string[]` | New value (for set operations) |
 
 **Usage**

src/data/Nest.ts

@@ -1,26 +1,32 @@
-//common
-import type { 
-  Key, 
+//client
+import type {
+  CallableNest,
+  Key,
+  NestedObject,
+  SetInputResult,
   TypeOf,
-  NestedObject, 
-  UnknownNest, 
-  CallableNest 
+  UnknownNest
 } from '../types.js';
 import Exception from '../Exception.js';
-//processors
 import ArgString from './processors/ArgString.js';
+import FormData from './processors/FormData.js';
 import PathString from './processors/PathString.js';
 import QueryString from './processors/QueryString.js';
-import FormData from './processors/FormData.js';
-//local
 import ReadonlyNest from './ReadonlyNest.js';
 
 /**
  * Nest easily manipulates object data
  */
-export default class Nest<M extends UnknownNest = UnknownNest> 
+export default class Nest<M extends object = {}> 
   extends ReadonlyNest<M>
 {
+  /**
+   * Starts a new typed builder chain
+   */
+  public static load<M extends object = {}>(data?: M) {
+    return new Nest<M>(data);
+  }
+
   /**
    * Parser for terminal args
    */
@@ -75,7 +81,7 @@ export default class Nest<M extends UnknownNest = UnknownNest>
    */
   public clear() {
     this._data = {} as M;
-    return this;
+    return this as unknown as Nest<{}>;
   }
 
   /**
@@ -105,6 +111,9 @@ export default class Nest<M extends UnknownNest = UnknownNest>
   /**
    * Sets the data of a specified path
    */
+  public set<const I extends Array<any>>(
+    ...input: I
+  ): Nest<SetInputResult<M, I>>;
   public set(...path: any[]) {
     if (path.length < 1) {
       return this;
@@ -140,7 +149,7 @@ export default class Nest<M extends UnknownNest = UnknownNest>
     pointer[last] = value;
 
     //loop through the steps one more time fixing the objects
-    pointer = this._data;
+    pointer = this._data as UnknownNest;
     path.forEach((step) => {
       const next = pointer[step] as UnknownNest;
       //if next is not an array and next should be an array
@@ -281,20 +290,24 @@ export function shouldBeAnArray(object: NestedObject<unknown> | null | undefined
   return true;
 }
 
-export function nest<M extends UnknownNest = UnknownNest>(data?: M): CallableNest<M> {
+export function nest<M extends object = {}>(data?: M): CallableNest<M> {
   const store = new Nest<M>(data);
-  const callable = Object.assign(
-    <T = any>(...path: Key[]) => store.get<T>(...path),
+  let callable: CallableNest<M>;
+
+  callable = Object.assign(
+    (...path: Key[]) => store.get(...path),
     {
       withArgs: store.withArgs,
       withFormData: store.withFormData,
       withPath: store.withPath,
       withQuery: store.withQuery,
       clear() {
-        return store.clear();
+        store.clear();
+        return callable as CallableNest<{}>;
       },
       delete(...path: Key[]) {
-        return store.delete(...path);
+        store.delete(...path);
+        return callable as CallableNest<M>;
       },
       entries() {
         return store.entries();
@@ -315,18 +328,19 @@ export function nest<M extends UnknownNest = UnknownNest>(data?: M): CallableNes
         return store.path<T>(path, defaults);
       },
       set(...path: any[]) {
-        return store.set(...path);
+        store.set(...path);
+        return callable;
       },
       toString() {
         return store.toString();
       },
       values() {
         return store.values();
       }
-    } as Nest<M>
+    } as CallableNest<M>
   );
   //magic size/data property
   Object.defineProperty(callable, 'size', { get: () => store.size });
   Object.defineProperty(callable, 'data', { get: () => store.data });
   return callable;
-};
+};

src/data/ReadonlyNest.ts

@@ -1,12 +1,18 @@
-//common
-import type { Key, UnknownNest, TypeOf } from '../types.js';
-//local
+//client
+import type {
+  Infer,
+  Key,
+  KeyPath,
+  PathValue,
+  TypeOf,
+  UnknownNest
+} from '../types.js';
 import Path from './ReadonlyPath.js';
 
 /**
  * Nest easily manipulates object data
  */
-export default class ReadonlyNest<M extends UnknownNest = UnknownNest>  {
+export default class ReadonlyNest<M extends object = {}>  {
   /**
    * Parser for path notations
    */
@@ -51,7 +57,7 @@ export default class ReadonlyNest<M extends UnknownNest = UnknownNest>  {
    */
   async forEach(...path: any[]): Promise<boolean> {
     const callback = path.pop() as Function;
-    let list = this.get(...path);
+    let list: any = this.get(...path);
 
     if (!list
       || Array.isArray(list) && !list.length
@@ -73,15 +79,17 @@ export default class ReadonlyNest<M extends UnknownNest = UnknownNest>  {
   /**
    * Retrieves the data hashed specified by the path
    */
-  public get<T extends UnknownNest = M>(): T;
-  public get<T = any>(...path: Key[]): T;
-  public get<T = any>(...path: Key[]): UnknownNest|T {
+  public get<T extends object = M>(): T;
+  public get<V = Infer, const P extends KeyPath = KeyPath>(
+    ...path: P
+  ): V extends Infer ? PathValue<M, P> : V;
+  public get(...path: Key[]): unknown {
     if (!path.length) {
       return this._data;
     }
 
     if (!this.has(...path)) {
-      return undefined as T;
+      return undefined;
     }
 
     const last = path.pop() as Key;
@@ -91,7 +99,7 @@ export default class ReadonlyNest<M extends UnknownNest = UnknownNest>  {
       pointer = pointer[step] as UnknownNest;
     });
 
-    return pointer[last] as T;
+    return pointer[last];
   }
 
   /**
@@ -151,4 +159,4 @@ export default class ReadonlyNest<M extends UnknownNest = UnknownNest>  {
   public values() {
     return Object.values(this._data);
   }
-}
+}

src/types.ts

@@ -42,10 +42,88 @@ export interface NestedObject<V = unknown> {
   [ key: Key ]: V|NestedObject<V>
 };
 export type UnknownNest = NestedObject<unknown>;
+export type Infer = { readonly __infer: unique symbol };
+export type KeyPath = readonly Key[];
 export type Scalar = string|number|boolean|null;
 export type Hash = NestedObject<Scalar>;
 export type ScalarInput = Scalar|Scalar[]|Hash;
 
+export type Widen<T> = T extends string
+  ? string
+  : T extends number
+    ? number
+    : T extends boolean
+      ? boolean
+      : T extends undefined
+        ? undefined
+        : T extends null
+          ? null
+          : T extends ReadonlyArray<infer V>
+            ? Widen<V>[]
+            : T extends object
+              ? { [K in keyof T]: Widen<T[K]> }
+              : T;
+
+type ArrayValue<T> = T extends ReadonlyArray<infer V> ? V : never;
+type IsArray<T> = T extends ReadonlyArray<any> ? true : false;
+type IsPlainObject<T> = T extends object
+  ? T extends Function
+    ? false
+    : IsArray<T> extends true
+      ? false
+      : true
+  : false;
+
+export type ValueAt<T, K extends Key> = T extends null | undefined
+  ? unknown
+  : K extends keyof T
+    ? T[K]
+    : K extends number
+      ? ArrayValue<T>
+      : K extends `${number}`
+        ? ArrayValue<T>
+        : unknown;
+
+export type PathValue<T, P extends KeyPath> = P extends readonly [
+  infer Head extends Key,
+  ...infer Rest extends KeyPath
+]
+  ? PathValue<ValueAt<T, Head>, Rest>
+  : T;
+
+export type PathObject<P extends KeyPath, V> = P extends readonly [
+  infer Head extends Key,
+  ...infer Rest extends KeyPath
+]
+  ? { [K in Head]: PathObject<Rest, V> }
+  : Widen<V>;
+
+export type Merge<A, B> = IsPlainObject<A> extends true
+  ? IsPlainObject<B> extends true
+    ? {
+        [K in keyof A | keyof B]: K extends keyof B
+          ? K extends keyof A
+            ? Merge<A[K], B[K]>
+            : B[K]
+          : K extends keyof A
+            ? A[K]
+            : never
+      }
+    : B
+  : B;
+
+export type SetResult<M, P extends KeyPath, V> = Merge<M, PathObject<P, V>>;
+
+export type SetInputResult<M, I extends Array<any>> = I extends []
+  ? M
+  : I extends [infer N extends object]
+    ? Merge<M, Widen<N>>
+    : I extends [...infer P, infer V]
+      ? P extends [Key, ...Key[]]
+        ? SetResult<M, P, V>
+        : M
+      : M;
+
 export type FileMeta = {
   data: Buffer|string,
   name: string,
@@ -56,9 +134,20 @@ export type CallableSet<V = any> = ((index: number) => V|undefined) & DataSet<V>
   index: (index: number) => V|undefined
 };
 export type CallableMap<K = any, V = any> = ((name: K) => V|undefined) & DataMap<K, V>;
-export type CallableNest<M extends UnknownNest = UnknownNest> = (
-  <T = any>(...path: Key[]) => T
-) & Nest<M>;
+export type CallableNest<M extends object = {}> = Omit<
+  Nest<M>,
+  'clear'|'delete'|'set'
+> & {
+  (): M;
+  <V = Infer, const P extends KeyPath = KeyPath>(
+    ...path: P
+  ): V extends Infer ? PathValue<M, P> : V;
+  clear(): CallableNest<{}>;
+  delete(...path: Key[]): CallableNest<M>;
+  set<const I extends Array<any>>(
+    ...input: I
+  ): CallableNest<SetInputResult<M, I>>;
+};
 
 export type DataSetIterator<
   V = any, 
@@ -234,6 +323,7 @@ export type RequestOptions<R = unknown> = {
 //this is a revision entry
 export type Revision = {
   action: 'set'|'remove',
+  options?: CookieOptions,
   value?: string|string[]
 };
 
@@ -353,4 +443,4 @@ export type TemplateOptions = {
   resolve?: TemplateResolver,
   helpers?: Record<string, TemplateHelper>,
   delimiters?: [ string, string ]
-};
+};