Merge 18464cf into 29e894b

scull7 · Jul 8, 2018 · 09b702b · 09b702b
2 parents 29e894b + 18464cf
commit 09b702b
Show file tree

Hide file tree

Showing 19 changed files with 443 additions and 255 deletions.
diff --git a/.travis.yml b/.travis.yml
@@ -9,5 +9,3 @@ before_install:
   - sudo apt-get -qq update
   - sudo apt-get install -y jq
   - mysql -e 'CREATE DATABASE IF NOT EXISTS test;'
-before_script:
-  - yarn install:peers
diff --git a/README.md b/README.md
@@ -54,13 +54,13 @@ and [Named Placeholders](#named-placeholders).
 #### Standard Query Method
 ```reason
 let conn
-  = MySql2.connect(~host=127.0.0.1, ~port=3306, ~user="root", ());
+  = MySql2.Connection.connect(~host=127.0.0.1, ~port=3306, ~user="root", ());
 
 MySql2.execute(conn, "SHOW DATABASES", None, res => {
     switch res {
     | `Error(e) => Js.log2("ERROR: ", e)
-    | `Select(rows, meta) => Js.log3("SELECT: ", rows, meta)
-    | `Mutation(count, id) => Js.log3("MUTATION: ", count, id)
+    | `Select(select) => Js.log2("SELECT: ", select)
+    | `Mutation(mutation) => Js.log2("MUTATION: ", mutation)
     }
   MySql2.close(conn);
 });
@@ -72,9 +72,9 @@ MySql2.execute(conn, "SHOW DATABASES", None, res => {
 ##### Named Placeholders
 ```reason
 let conn
-  = MySql2.connect(~host=127.0.0.1, ~port=3306, ~user="root", ());
+  = MySql2.Connect.connect(~host=127.0.0.1, ~port=3306, ~user="root", ());
 
-let named = `Named(
+let named = MySql2.Params.named(
   Json.Encode.object_([
     ("x", Json.Encode.int(1)),
     ("y", Json.Encode.int(2)),
@@ -84,8 +84,8 @@ let named = `Named(
 MySql2.execute(conn, "SELECT :x + :y AS result", Some(named), res => {
     switch res {
     | `Error(e) => Js.log2("ERROR: ", e)
-    | `Select(rows, meta) => Js.log3("SELECT: ", rows, meta)
-    | `Mutation(count, id) => Js.log3("MUTATION: ", count, id)
+    | `Select(select) => Js.log2("SELECT: ", select)
+    | `Mutation(mutation) => Js.log2("MUTATION: ", mutation)
     }
   }
   MySql2.close(conn);
@@ -95,17 +95,17 @@ MySql2.execute(conn, "SELECT :x + :y AS result", Some(named), res => {
 ##### Unnamed Placeholders
 ```reason
 let conn
-  = MySql2.connect(~host=127.0.0.1, ~port=3306, ~user="root", ());
+  = MySql2.Connection.connect(~host=127.0.0.1, ~port=3306, ~user="root", ());
 
-let positional = `Positional(
+let positional = MySql2.Params.positional(
   Belt_Array.map([|5, 6|], Json.Encode.int) |> Json.Encode.jsonArray
 );
 
 MySql2.execute(conn, "SELECT 1 + ? + ? AS result", Some(positional), res => {
     switch res {
     | `Error(e) => Js.log2("ERROR: ", e)
-    | `Select(rows, meta) => Js.log3("SELECT: ", rows, meta)
-    | `Mutation(count, id) => Js.log3("MUTATION: ", count, id)
+    | `Select(rows, meta) => Js.log2("SELECT: ", rows, meta)
+    | `Mutation(count, id) => Js.log2("MUTATION: ", count, id)
     }
   }
   MySql2.close(conn);

diff --git a/__tests__/Test_mysql2_error.re b/__tests__/Test_mysql2_error.re
@@ -1,23 +1,23 @@
 open Jest;
 
 let connect = () =>
-  MySql2.connect(~host="127.0.0.1", ~port=3306, ~user="root", ());
+  MySql2.Connection.connect(~host="127.0.0.1", ~port=3306, ~user="root", ());
 
 describe("MySql2 Error Handling", () => {
   let conn = connect();
 
-  afterAll(() => MySql2.close(conn));
+  afterAll(() => MySql2.Connection.close(conn));
 
   let accessDeniedTest = "Should respond with an access denied error";
   testAsync(
     accessDeniedTest,
     finish => {
-      let c = MySql2.connect(~password="s0m3 g@rb@g3 pw", ());
+      let c = MySql2.Connection.connect(~password="s0m3 g@rb@g3 pw", ());
       let sql = "SELECT 1+1 AS result";
       MySql2.execute(c, sql, None, res =>
         switch (res) {
-        | `Select(_, _) => fail("unexpected_select_result") |> finish
-        | `Mutation(_, _) => fail("unexpected_mutation_result") |> finish
+        | `Select(_) => fail("unexpected_select_result") |> finish
+        | `Mutation(_) => fail("unexpected_mutation_result") |> finish
         | `Error(e) =>
           Expect.expect(() =>
             raise(e)
@@ -36,8 +36,8 @@ describe("MySql2 Error Handling", () => {
       let sql = "SELECT invalid, AS result";
       MySql2.execute(conn, sql, None, res =>
         switch (res) {
-        | `Select(_, _) => fail("unexpected_select_result") |> finish
-        | `Mutation(_, _) => fail("unexpected_mutation_result") |> finish
+        | `Select(_) => fail("unexpected_select_result") |> finish
+        | `Mutation(_) => fail("unexpected_mutation_result") |> finish
         | `Error(e) =>
           Expect.expect(() =>
             raise(e)
@@ -51,41 +51,47 @@ describe("MySql2 Error Handling", () => {
 
   test("Should parse out an empty error with defaults", () => {
     /* Use raw JS here toe retrieve a garbage object */
-    let e = [%raw {| (function () { return { message: "IDKWTM" } })() |} ];
+    let e = [%raw {| (function () { return { message: "IDKWTM" } })() |}];
     let actual = MySql2_error.fromJs(e);
 
-    Expect.expect(() => raise(actual))
+    Expect.expect(() =>
+      raise(actual)
+    )
     |> Expect.toThrowMessage("Failure,-2,UNKNOWN - 99999 (99999) - IDKWTM");
   });
 
   test("Should return a defaulted error", () => {
     /* Use raw JS here toe retrieve a garbage object */
-    let e = [%raw {| (function () { return {} })()|} ];
+    let e = [%raw {| (function () { return {} })()|}];
     let actual = MySql2_error.fromJs(e);
 
-    Expect.expect(() => raise(actual))
+    Expect.expect(() =>
+      raise(actual)
+    )
     |> Expect.toThrowMessage("UNKNOWN - 99999 (99999) - EMPTY_MESSAGE");
   });
 
-  test("should give appropriate message when only a sqlState is given", () =>{
+  test("should give appropriate message when only a sqlState is given", () => {
     /* Use raw JS here toe retrieve a garbage object */
-    let e = [%raw {| (function () { return { sqlState: "test" } })()|} ];
+    let e = [%raw {| (function () { return { sqlState: "test" } })()|}];
     let actual = MySql2_error.fromJs(e);
-
-    Expect.expect(() => raise(actual))
+
+    Expect.expect(() =>
+      raise(actual)
+    )
     |> Expect.toThrowMessage(
-      "UNKNOWN - 99999 (99999) - EMPTY_MESSAGE - (test)"
-    );
+         "UNKNOWN - 99999 (99999) - EMPTY_MESSAGE - (test)",
+       );
   });
 
-  test("should give appropriate message when only a sqlMessage is given", () =>{
+  test("should give appropriate message when only a sqlMessage is given", () => {
     /* Use raw JS here toe retrieve a garbage object */
-    let e = [%raw {| (function () { return { sqlMessage: "test" } })()|} ];
+    let e = [%raw {| (function () { return { sqlMessage: "test" } })()|}];
     let actual = MySql2_error.fromJs(e);
-    
-    Expect.expect(() => raise(actual))
-    |> Expect.toThrowMessage(
-      "UNKNOWN - 99999 (99999) - EMPTY_MESSAGE - test"
-    );
+
+    Expect.expect(() =>
+      raise(actual)
+    )
+    |> Expect.toThrowMessage("UNKNOWN - 99999 (99999) - EMPTY_MESSAGE - test");
   });
 });
diff --git a/__tests__/parse_response.re b/__tests__/parse_response.re
@@ -1,12 +1,14 @@
 open Jest;
 
+module Response = MySql2_response;
+
 describe("MySql2.parseResponse", () => {
   test("Should return an error when given an unexpected boolean.", () => {
     let invalid = Js.Json.boolean(true);
     let message =
-      switch (MySql2.parseResponse(invalid, [||])) {
-      | `Select(_, _) => Failure("invalid_select_result")
-      | `Mutation(_, _) => Failure("invalid_mutation_result")
+      switch (Response.fromDriverResponse(invalid, [||])) {
+      | `Select(_) => Failure("unexpected_select_result")
+      | `Mutation(_) => Failure("unexpected_mutation_result")
       | `Error(e) => e
       };
     Expect.expect(() =>
@@ -17,9 +19,9 @@ describe("MySql2.parseResponse", () => {
   test("Should return an error when given an unexpected string", () => {
     let invalid = Js.Json.string("invalid");
     let message =
-      switch (MySql2.parseResponse(invalid, [||])) {
-      | `Select(_, _) => Failure("invalid_select_result")
-      | `Mutation(_, _) => Failure("invalid_mutation_result")
+      switch (Response.fromDriverResponse(invalid, [||])) {
+      | `Select(_) => Failure("invalid_select_result")
+      | `Mutation(_) => Failure("invalid_mutation_result")
       | `Error(e) => e
       };
     Expect.expect(() =>

diff --git a/__tests__/query.re b/__tests__/query.re
@@ -1,7 +1,10 @@
 open Jest;
 
+[@bs.val] [@bs.scope "Number"]
+external max_safe_integer : int = "MAX_SAFE_INTEGER";
+
 let connect = () =>
-  MySql2.connect(~host="127.0.0.1", ~port=3306, ~user="root", ());
+  MySql2.Connection.connect(~host="127.0.0.1", ~port=3306, ~user="root", ());
 
 type insert = {
   affected_rows: int,
@@ -19,27 +22,27 @@ let onSelect = (next, fn, res) =>
   switch (res) {
   | `Error(e) => raise(e)
   | `Mutation(_) => fail("unexpected_mutation_result") |> next
-  | `Select(rows, meta) => fn(rows, meta, next)
+  | `Select(select) => fn(select, next)
   };
 
 let onMutation = (next, fn, res) =>
   switch (res) {
   | `Error(e) => raise(e)
-  | `Mutation(count, id) => fn(count, id, next)
-  | `Select(_, _) => fail("unexpected_select_result") |> next
+  | `Mutation(mutation) => fn(mutation, next)
+  | `Select(_) => fail("unexpected_select_result") |> next
   };
 
 describe("Raw SQL Query Test", () => {
   let conn = connect();
-  afterAll(() => MySql2.close(conn));
+  afterAll(() => MySql2.Connection.close(conn));
   testAsync("Expect a test database to be listed", finish =>
     MySql2.execute(
       conn,
       "SHOW DATABASES",
       None,
-      onSelect(finish, (rows, _, next) =>
-        rows
-        |> Js.Array.map(Json.Decode.dict(Json.Decode.string))
+      onSelect(finish, (select, next) =>
+        select
+        |. MySql2.Select.mapDecoder(Json.Decode.dict(Json.Decode.string))
         |> Js.Array.map(x => Js.Dict.unsafeGet(x, "Database"))
         |> Expect.expect
         |> Expect.toContain("test")
@@ -62,35 +65,36 @@ describe("Raw SQL Query Test Sequence", () => {
     MySql2.execute(conn, "DROP TABLE IF EXISTS `test`.`simple`", None, res =>
       switch (res) {
       | `Error(e) => raiseError(e)
-      | `Mutation(_, _) => next()
-      | `Select(_, _) => failwith("unexpected_select_result")
+      | `Mutation(_) => next()
+      | `Select(_) => failwith("unexpected_select_result")
       }
     );
   let create = next =>
     MySql2.execute(conn, table_sql, None, res =>
       switch (res) {
       | `Error(e) => raiseError(e)
-      | `Mutation(_, _) => next()
-      | `Select(_, _) => failwith("unexpected_select_result")
+      | `Mutation(_) => next()
+      | `Select(_) => failwith("unexpected_select_result")
       }
     );
   beforeAllAsync(finish => drop(() => create(finish)));
-  afterAll(() => MySql2.close(conn));
+  afterAll(() => MySql2.Connection.close(conn));
   testAsync("Expect a mutation result for an INSERT query", finish => {
     let sql = "INSERT INTO `test`.`simple` (`code`) VALUES ('foo')";
     MySql2.execute(
       conn,
       sql,
       None,
-      onMutation(
-        finish,
-        (count, id, next) => {
-          let countIsOne = count == 1;
-          let idIsOne = id == 1;
-          Expect.expect([|countIsOne, idIsOne|])
-          |> Expect.toBeSupersetOf([|true, true|])
-          |> next;
-        },
+      onMutation(finish, (mutation, next) =>
+        (
+          MySql2.Mutation.insertId(mutation)
+          |. Belt.Option.getExn
+          |. MySql2.Id.toString,
+          MySql2.Mutation.affectedRows(mutation),
+        )
+        |> Expect.expect
+        |> Expect.toEqual(("1", 1))
+        |> next
       ),
     );
   });
@@ -100,15 +104,14 @@ describe("Raw SQL Query Test Sequence", () => {
       conn,
       sql,
       None,
-      onMutation(
-        finish,
-        (count, id, next) => {
-          let countIsOne = count == 1;
-          let idIsZero = id == 0;
-          Expect.expect([|countIsOne, idIsZero|])
-          |> Expect.toBeSupersetOf([|true, true|])
-          |> next;
-        },
+      onMutation(finish, (mutation, next) =>
+        (
+          MySql2.Mutation.insertId(mutation),
+          MySql2.Mutation.affectedRows(mutation),
+        )
+        |> Expect.expect
+        |> Expect.toEqual((None, 1))
+        |> next
       ),
     );
   });
@@ -119,8 +122,9 @@ describe("Raw SQL Query Test Sequence", () => {
       conn,
       sql,
       None,
-      onSelect(finish, (rows, _, next) =>
-        Belt_Array.map(rows, decoder)
+      onSelect(finish, (select, next) =>
+        select
+        |. MySql2.Select.mapDecoder(decoder)
         |> Expect.expect
         |> Expect.toHaveLength(0)
         |> next
@@ -143,13 +147,57 @@ describe("Raw SQL Query Test Sequence", () => {
       conn,
       sql,
       None,
-      onSelect(finish, (rows, _, next) =>
-        Belt_Array.map(rows, decoder)
+      onSelect(finish, (select, next) =>
+        select
+        |. MySql2.Select.mapDecoder(decoder)
         |> first_row
         |> Expect.expect
         |> Expect.toBeSupersetOf([|true, true|])
         |> next
       ),
     );
   });
+  testAsync("Expect a JS representable BIGINT be a string", finish => {
+    let sql = {j|
+      INSERT INTO `test`.`simple` (`id`,`code`)
+      VALUES
+      (9007199254740991, '2^53-1')
+    |j};
+
+    MySql2.execute(
+      conn,
+      sql,
+      None,
+      onMutation(finish, (mutation, next) =>
+        MySql2.Mutation.insertId(mutation)
+        |. Belt.Option.getExn
+        |. MySql2.Id.toString
+        |> Expect.expect
+        |> Expect.toBe(max_safe_integer |. string_of_int)
+        |> next
+      ),
+    );
+  });
+  testAsync("Expect a non-JS representable BIGINT be a string", finish => {
+    let sql = {j|
+      INSERT INTO `test`.`simple` (`id`,`code`)
+      VALUES
+      (9007199254740993, '2^53-1')
+    |j};
+
+    MySql2.execute(
+      conn,
+      sql,
+      None,
+      onMutation(finish, (mutation, next) =>
+        mutation
+        |. MySql2.Mutation.insertId
+        |. Belt.Option.getExn
+        |. MySql2.Id.toString
+        |> Expect.expect
+        |> Expect.toBe("9007199254740993")
+        |> next
+      ),
+    );
+  });
 });