Adding parseInt8 option

C2FO · Feb 29, 2016 · cc6efef · cc6efef
1 parent 5205831
commit cc6efef
Show file tree

Hide file tree

Showing 4 changed files with 101 additions and 3 deletions.
diff --git a/lib/adapters/postgres.js b/lib/adapters/postgres.js
@@ -44,7 +44,8 @@ var pg = require("pg"),
     stream = require("stream"),
     PassThroughStream = stream.PassThrough,
     pipeAll = require("../utils").pipeAll,
-    hashPick = comb.hash.pick;
+    hashPick = comb.hash.pick,
+    isSafeInteger = Number.isSafeInteger || require('is-safe-integer');
 
 var getPatio = function () {
     return patio || (patio = require("../index.js"));
@@ -77,6 +78,19 @@ var byteaParser = function (val) {
 };
 
 PgTypes.setTypeParser(17, "text", byteaParser);
+
+PgTypes.setTypeParser(20, 'text', function (val) {
+    if (!getPatio().parseInt8) {
+        return val;
+    }
+
+    var i = parseInt(val, 10);
+    if (!isSafeInteger(i)) {
+        throw new Error(format("The value '%s' cannot be represented by a javascript number.", val));
+    }
+    return i;
+});
+
 var timestampOrig = PgTypes.getTypeParser(1114, "text");
 //PgTypes.setTypeParser(25, "text", byteaParser);
 PgTypes.setTypeParser(1114, "text", function (val) {

diff --git a/lib/index.js b/lib/index.js
@@ -57,6 +57,8 @@ var Patio = singleton([EventEmitter, Time], {
 
         __inImportOfModels: false,
 
+        __parseInt8: false,
+
 
         /**
          * A singleton class that acts as the entry point for all actions performed in patio.
@@ -69,6 +71,7 @@ var Patio = singleton([EventEmitter, Time], {
          *
          * patio.camelize = true;
          * patio.quoteIdentifiers=false;
+         * patio.parseInt8=false
          * patio.defaultPrimaryKeyType = "integer" //"bigint"
          *
          * patio.createModel("my_table");
@@ -715,6 +718,11 @@ var Patio = singleton([EventEmitter, Time], {
             /**@ignore*/
             underscore: function () {
                 return this.__underscore;
+            },
+
+            /**@ignore*/
+            parseInt8: function () {
+                return this.__parseInt8;
             }
 
         },
@@ -886,6 +894,21 @@ var Patio = singleton([EventEmitter, Time], {
                 this.__underscore = underscore;
             },
 
+            /**
+             * Sets whether bigint types should be parsed to a number. An error will be thrown if set and the number is
+             * set and the number is greater than 2^53 or less than -2^53.
+             *
+             * @ignoreCode
+             * @field
+             * @type Boolean
+             *
+             * @example
+             *   patio.parseInt8 = true
+             * */
+            parseInt8: function (value) {
+                this.__parseInt8 = value;
+            },
+
             /**
              * Set the default primary key type when not specified for all databases by default. By default,
              * patio uses "integer".
@@ -911,4 +934,4 @@ patio.__Patio = Patio;
 var adapters = Database.ADAPTERS;
 for (var i in adapters) {
     patio[i] = adapters[i];
-}
+}
diff --git a/package.json b/package.json
@@ -37,6 +37,7 @@
         "pg": "4.0.0",
         "pg-query-stream": "0.7.0",
         "pg-types": "1.6.0",
+        "is-safe-integer": "1.0.1",
         "validator": "~1.5.1"
     },
     "scripts": {

diff --git a/test/adapters/postgres.test.js b/test/adapters/postgres.test.js
@@ -7,7 +7,8 @@ var it = require('it'),
     when = comb.when,
     serial = comb.serial,
     format = comb.string.format,
-    hitch = comb.hitch;
+    hitch = comb.hitch,
+    PgTypes = require('pg-types');
 
 if (process.env.PATIO_DB === "pg") {
     it.describe("patio.adapters.Postgres", function (it) {
@@ -549,6 +550,65 @@ if (process.env.PATIO_DB === "pg") {
                 ]);
             });
 
+            it.describe("parseInt8", function (it) {
+
+                it.beforeEach(function () {
+                    return db.forceCreateTable("posts", function () {
+                        this.postId("bigint");
+                    });
+                });
+
+                it.afterAll(function () {
+                    patio.parseInt8 = false;
+                    return db.dropTable("posts");
+                });
+
+                it.should("parse bigints on select if true", function () {
+                    var ds = db.from("posts");
+                    patio.parseInt8 = true;
+                    return ds.insert({postId: "9007199254740991"})
+                    .chain(function () {
+                        return ds.one();
+                    }).chain(function (post) {
+                        assert.strictEqual(post.postId, 9007199254740991);
+                    });
+                });
+
+                it.should("parse negative bigints as well", function () {
+                    var ds = db.from("posts");
+                    patio.parseInt8 = true;
+                    return ds.insert({postId: "-9007199254740991"})
+                        .chain(function () {
+                            return ds.one();
+                        }).chain(function (post) {
+                            assert.strictEqual(post.postId, -9007199254740991);
+                        });
+                });
+
+                it.should("not parse bigints if false", function () {
+                    var ds = db.from("posts");
+                    patio.parseInt8 = false;
+                    return ds.insert({postId: "9007199254740992"})
+                        .chain(function () {
+                            return ds.one();
+                        }).chain(function (post) {
+                            assert.strictEqual(post.postId, "9007199254740992");
+                        });
+                });
+
+                it.should("should throw if bigint is outside the range of max safe integer", function () {
+                    patio.parseInt8 = true;
+                    var bigIntParser = PgTypes.getTypeParser(20, 'text');
+                    assert.throws(function () {
+                        bigIntParser("9007199254740992");
+                    }, /The value \'9007199254740992\' cannot be represented by a javascript number\./);
+                    assert.throws(function () {
+                        bigIntParser("-9007199254740992");
+                    }, /The value \'\-9007199254740992\' cannot be represented by a javascript number\./);
+                });
+
+            });
+
             it.should("support opclass specification", function () {
                 return db.createTable("posts", function () {
                     this.title("text");