Parse AND and OR

src/ast/binary.ts

 import * as AST from "../ast";
 
 export enum BinaryExpressionTypes {
-  ADDITION,
-  SUBTRACTION,
-  MULTIPLICATION,
-  DIVISION,
-  EQUALITY,
+  ADDITION = "ADDITION",
+  AND = "AND",
+  DIVISION = "DIVISION",
+  EQUALITY = "EQUALITY",
+  MULTIPLICATION = "MULTIPLICATION",
+  OR = "OR",
+  SUBTRACTION = "SUBTRACTION",
 }
 
 interface IBinaryOptions {

src/parser.ts

   }
 
   private expr(): AST.Expr | Error {
-    return this.equality();
+    return this.or();
+  }
+
+  private or(): AST.Expr | Error {
+    const left = this.and();
+    if (isError(left)) {
+      return left;
+    }
+
+    if (this.match(TokenKind.OR)) {
+      this.eat(TokenKind.OR);
+      const right = this.and();
+      if (isError(right)) {
+        return right;
+      }
+      return new AST.Binary({
+        left,
+        right,
+        type: AST.BinaryExpressionTypes.OR,
+      });
+    }
+
+    return left;
+  }
+
+  private and(): AST.Expr | Error {
+    const left = this.equality();
+    if (isError(left)) {
+      return left;
+    }
+
+    if (this.match(TokenKind.AND)) {
+      this.eat(TokenKind.AND);
+      const right = this.equality();
+      if (isError(right)) {
+        return right;
+      }
+      return new AST.Binary({
+        left,
+        right,
+        type: AST.BinaryExpressionTypes.AND,
+      });
+    }
+
+    return left;
   }
 
   private equality(): AST.Expr | Error {

test/parser.test.ts

       }),
     ]);
   });
+
+  it("should parse a where with a boolean expression", () => {
+    const tree = parse("select a from b where c and d");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Binary({
+          left: new AST.Identifier("c"),
+          right: new AST.Identifier("d"),
+          type: AST.BinaryExpressionTypes.AND,
+        }),
+      }),
+    ]);
+  });
 });