Parse simple where

src/ast.ts

 export type Primary = _Number | Identifier;
 export type Secondary = Primary | Alias;
 export type Statement = SelectStatement;
+export type Expr = Secondary;

src/ast/selectStatement.ts

 export interface ISelectStatementOptions {
   arguments: AST.Secondary[];
   from?: AST.Secondary | null;
+  where?: AST.Expr | null
 }
 
 export class SelectStatement {
   public arguments: AST.Secondary[];
   public from: AST.Secondary | null;
+  public where: AST.Expr | null;
 
   constructor(opts: ISelectStatementOptions) {
     this.arguments = opts.arguments;
     this.from = opts.from ? opts.from : null;
+    this.where = opts.where ? opts.where : null;
   }
 }

src/parser.ts

       return args;
     }
 
-    const currentToken = this.currentToken();
-    const from = currentToken.kind === TokenKind.FROM ? this.from() : null;
+    const from = this.currentToken().kind === TokenKind.FROM ? this.from() : null;
     if (isError(from)) {
       return from;
     }
 
+    const where = this.currentToken().kind === TokenKind.WHERE ? this.where() : null;
+    if (isError(where)) {
+      return where;
+    }
+
     return new AST.SelectStatement({
       arguments: args,
       from,
+      where,
     });
   }
 
     return this.alias(this.identifier);
   }
 
+  private where(): AST.Expr | Error {
+    this.eat(TokenKind.WHERE);
+    return this.expr();
+  }
+
+  private expr(): AST.Expr | Error {
+    return this.alias();
+  }
+
   private alias(fn: () => AST.Primary | Error = this.primary): AST.Secondary | Error {
     const primary = fn.bind(this)();
     if (isError(primary)) {

test/parser.test.ts

     const fn = () => parse("select 1 from 2");
     expect(fn).to.throw("Unexpected token: { kind: NUMBER, value: 2 }");
   });
+
+  it("should parse a where with a number", () => {
+    const tree = parse("select a from b where 1");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Number(1),
+      }),
+    ]);
+  });
+
+  it("should parse a where with an identifier", () => {
+    const tree = parse("select a from b where c");
+    expect(tree).to.deep.equal([
+      new AST.SelectStatement({
+        arguments: [new AST.Identifier("a")],
+        from: new AST.Identifier("b"),
+        where: new AST.Identifier("c"),
+      }),
+    ]);
+  });
 });