refactor: cleanup & preserve object when using $where

Author: anuraghazra

Diff for: interpreter.ts

@@ -1,13 +1,13 @@
 import { Parser, ParserError } from "./parser";
 import { Tokenize } from "./tokenizer";
-import { GetByField, TuplifyUnion, UnionToIntersection } from "./utils";
+import { GetByField, IsUnion, TuplifyUnion } from "./utils";
 
 type PushError<Errors extends any[], AST> = AST extends ParserError<infer E>
   ? [...Errors, E]
   : [];
 
 export type Interpret<
-  Obj,
+  Obj extends Record<any, any>,
   AST,
   Errors extends string[] = []
 > = AST extends ParserError<infer Err>
@@ -41,7 +41,9 @@ export type Interpret<
       value: infer FilterBy;
     }
   ? Interpret<
-      TuplifyUnion<GetByField<Obj, FilterBy>>,
+      IsUnion<GetByField<Obj, FilterBy>> extends true
+        ? TuplifyUnion<GetByField<Obj, FilterBy>>
+        : GetByField<Obj, FilterBy>,
       {},
       PushError<Errors, FilterBy>
     >

Diff for: parser.ts

@@ -1,5 +1,5 @@
 import { Interpret } from "./interpreter";
-import { Tokenize, TokenTypes } from "./tokenizer";
+import { Token, Tokenize, TokenTypes } from "./tokenizer";
 import { Head, Head2, ParseObj, TailBy } from "./utils";
 
 export type ParserError<T extends string> = T & { __brand: "ParserError" };
@@ -22,14 +22,13 @@ type Eat<T extends { type: keyof TokenTypes }, Type extends string> = Expect<
   : Expect<T, Type, true>;
 
 type IsToken<
-  Tok extends { type: string },
+  Tok extends { type: keyof TokenTypes },
   TokenType extends keyof TokenTypes
 > = Tok["type"] extends TokenType ? true : false;
 
-type HasErrors<
-  E extends ParserError<string>,
-  Else
-> = E extends ParserError<string> ? E : Else;
+type HasErrors<Value extends unknown, Else> = Value extends ParserError<string>
+  ? Value
+  : Else;
 
 type GetValueIfNoParserError<T, K> = [Exclude<T, K>] extends [never]
   ? T
@@ -44,8 +43,8 @@ type ParseIndexAccess<T extends any[]> = [
   ? GetValueIfNoParserError<
       HasErrors<
         P1 | P2 | Rest[0],
-        P2 extends { type: "NUMBER" }
-          ? { type: "ArrayAccess"; index: P2["value"]; eat: 3 }
+        P2 extends { type: "NUMBER"; value: infer Index }
+          ? { type: "ArrayAccess"; index: Index; eat: 3 }
           : { type: "ArrayAccess"; index: never; eat: 3 }
       >,
       { type: "ArrayAccess" }
@@ -61,21 +60,21 @@ type ParseWhereClause<T extends any[]> = [
   ? GetValueIfNoParserError<
       HasErrors<
         P1 | P2 | P3 | P4,
-        { type: "WhereClause"; value: ParseObj<P3["name"]>; eat: 4 }
+        P3 extends { type: "IDENT"; name: infer Name }
+          ? { type: "WhereClause"; value: ParseObj<Name & string>; eat: 4 }
+          : { type: "WhereClause"; value: {}; eat: 4 }
       >,
       { type: "WhereClause" }
     >
   : never;
 
-type DD = ParseWhereClause<Tokenize<"$where(a:1)">>;
-
 export type Parser<
-  T extends any[],
+  T extends Token[],
   AST = {},
-  Cursor = Head<T>,
-  LookAhead = Head2<T>
+  Cursor extends Token = Head<T>,
+  LookAhead extends Token = Head2<T>
 > = IsToken<Cursor, "WHERE"> extends true
-  ? Parser<TailBy<T, 4>, AST & ParseWhereClause<T>>
+  ? Parser<TailBy<T, 4>, ParseWhereClause<T>>
   : IsToken<Cursor, "IDENT"> extends true
   ? Parser<TailBy<T, 1>, AST & { type: "Identifier"; value: Cursor["name"] }>
   : IsToken<Cursor, "DOT"> extends true
@@ -112,10 +111,16 @@ export type Parser<
 // type D = ParseIndexAccess<Tokenize<"0]">>;
 // type K = Interpret<{ a: { b: [0] } }, L3>;
 
-type Toks = Tokenize<"a[].$where(id:1,age:2)">;
+// TODO Throw error on where syntax
+type Toks = Tokenize<"b[].$where().i[].$where(id:i11)">;
 type AST = Parser<Toks>;
 type K = Interpret<
-  { a: [{ id: 1; age: 2; name: "one" }, { id: 2; age: 2; name: "two" }] },
+  {
+    b: [
+      { id: 1; i: [{ id: "i11" }, { id: "i12" }] },
+      { id: 2; i: [{ id: "i21" }, { id: "i22" }] }
+    ];
+  },
   AST
 >;
 

Diff for: tokenizer.ts

@@ -22,9 +22,10 @@ export type TokenMap = {
   ")": { type: TokenTypes["PAREN_END"] };
   "[": { type: TokenTypes["BRACKET_START"] };
   "]": { type: TokenTypes["BRACKET_END"] };
-  "$where": { type: TokenTypes["WHERE"] };
+  $where: { type: TokenTypes["WHERE"] };
   ".": { type: TokenTypes["DOT"] };
 };
+export type Token = { type: keyof TokenTypes; [x: string]: any };
 
 type ExtractIdentifier<
   Acc extends string[],
@@ -37,8 +38,6 @@ type ExtractIdentifier<
   ? never
   : Identifier<Tok>;
 
-type E = ExtractIdentifier<['where']>
-
 type SwitchToken<T> = T extends keyof TokenMap ? TokenMap[T] : T;
 
 type TokenizeInternal<
@@ -65,4 +64,4 @@ export type Tokenize<T extends string> = TokenizeInternal<Split<T, "">>;
 
 type Demo1 = Tokenize<"invoices.$where(1)">;
 type Demo2 = Tokenize<"invoices.data[].$where(id:2)">;
-// type Demo3 = Tokenize<"comments[].$where(id:abcdefghijklm)">;
+// type Demo3 = Tokenize<"comments[].$where(id:abcdefghijklm)">;

Diff for: utils.ts

@@ -82,6 +82,7 @@ export type TuplifyUnion<
   N = [T] extends [never] ? true : false
 > = true extends N ? [] : Push<TuplifyUnion<Exclude<T, L>>, L>;
 
+export type IsUnion<T> = [T] extends [UnionToIntersection<T>] ? false : true;
 export type GetByField<T, Query> = Extract<T, Query>;
 export type ParseObj<
   ObjStr extends string,