fix(FIR-34534): Properly parsing bigint (#111)

Author: ptiurin

src/statement/hydrateResponse.ts

@@ -46,6 +46,9 @@ const getHydratedValue = (
     ) {
       return value.toString();
     }
+    if (typeof value === "string" && type === "long") {
+      return new BigNumber(value);
+    }
     return value;
   }
   if (isByteAType(type) && value != null) {

test/integration/v2/fetchTypes.test.ts

@@ -0,0 +1,62 @@
+import { Firebolt } from "../../../src/index";
+import BigNumber from "bignumber.js";
+
+const connectionParams = {
+  auth: {
+    client_id: process.env.FIREBOLT_CLIENT_ID as string,
+    client_secret: process.env.FIREBOLT_CLIENT_SECRET as string
+  },
+  account: process.env.FIREBOLT_ACCOUNT as string,
+  database: process.env.FIREBOLT_DATABASE as string
+};
+
+jest.setTimeout(100000);
+
+describe("test type casting on fetch", () => {
+  it("select boolean", async () => {
+    const firebolt = Firebolt({
+      apiEndpoint: process.env.FIREBOLT_API_ENDPOINT as string
+    });
+
+    const connection = await firebolt.connect(connectionParams);
+
+    const statement = await connection.execute("select true::boolean");
+
+    const { data, meta } = await statement.fetchResult();
+    expect(meta[0].type).toEqual("boolean");
+    const row = data[0];
+    expect((row as unknown[])[0]).toEqual(true);
+  });
+  it("select bigint", async () => {
+    const firebolt = Firebolt({
+      apiEndpoint: process.env.FIREBOLT_API_ENDPOINT as string
+    });
+
+    const connection = await firebolt.connect(connectionParams);
+
+    // Max value for a signed 64-bit integer (bigint)
+    const statement = await connection.execute("select 9223372036854775807");
+
+    const { data, meta } = await statement.fetchResult();
+    expect(meta[0].type).toEqual("long");
+    const row = data[0];
+    expect((row as unknown[])[0]).toEqual(new BigNumber("9223372036854775807"));
+  });
+  it("select negative bigint", async () => {
+    const firebolt = Firebolt({
+      apiEndpoint: process.env.FIREBOLT_API_ENDPOINT as string
+    });
+
+    const connection = await firebolt.connect(connectionParams);
+
+    // Max negative value for a signed 64-bit integer (bigint)
+    const statement = await connection.execute("select -9223372036854775808");
+
+    const { data, meta } = await statement.fetchResult();
+    expect(meta[0].type).toEqual("long");
+    const row = data[0];
+    expect((row as unknown[])[0]).toEqual(
+      new BigNumber("-9223372036854775808")
+    );
+  });
+});

test/unit/statement.test.ts

@@ -7,8 +7,9 @@ import {
   Tuple
 } from "../../src/formatter";
 import { hydrateRow } from "../../src/statement/hydrateResponse";
+import "allure-jest";
 
-describe("format query", () => {
+describe("query formatting", () => {
   it("format", () => {
     const queryFormatter = new QueryFormatter();
     const query = "select ? from table";
@@ -298,6 +299,20 @@ describe("parse values", () => {
     expect(isNaN(res["pnan"])).toBe(true);
     expect(isNaN(res["nnan"])).toBe(true);
   });
+  it("parses bigint into BigNumber container", () => {
+    allure.description(
+      "JS natively doesn't support bigint so we use BigNumber container"
+    );
+    const row = {
+      big: "1000000000000000000000000000000000000"
+    };
+    const meta = [{ name: "big", type: "long" }];
+    const res: Record<string, BigNumber> = hydrateRow(row, meta, {});
+    expect(res["big"] instanceof BigNumber).toBe(true);
+    expect(res["big"]).toEqual(
+      new BigNumber(1000000000000000000000000000000000000)
+    );
+  });
 });
 
 describe("set statements", () => {