Convert bigint columns to number type with Number() conversion

Bun SQL returns bigint/int8/bigserial/serial8 as strings to avoid precision
loss. For typical use cases (auto-incrementing IDs), JavaScript's number
type (safe up to 2^53-1) is sufficient.

Changes:
- columnType() now returns 'number' for bigint types instead of 'string'
- manyDecl() and oneDecl() wrap bigint column access with Number()
- Nullable bigint columns use: row[i] === null ? null : Number(row[i])
- Added tests for Number() conversion behavior

Author: tylergannon

src/drivers/bun-sql.codegen.test.ts

@@ -82,6 +82,68 @@ describe("bun-sql driver codegen", () => {
     expect(output).toContain("as GetThingRowValues[]");
   });
 
+  it("wraps bigint columns with Number() in :many", () => {
+    const driver = new BunSqlDriver();
+
+    const params: Parameter[] = [];
+
+    const columns: Column[] = [
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ({ name: "id", type: { name: "bigint" }, notNull: true } as unknown as Column),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ({ name: "name", type: { name: "text" }, notNull: true } as unknown as Column),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ({ name: "nullable_id", type: { name: "int8" }, notNull: false } as unknown as Column),
+    ];
+
+    const node = driver.manyDecl(
+      "listThings",
+      "listThingsQuery",
+      undefined,
+      "ListThingsRow",
+      params,
+      columns
+    );
+
+    const output = print(node);
+
+    // Non-nullable bigint: Number(row[0])
+    expect(output).toContain("id: Number(row[0])");
+    // Regular text column: row[1] (no conversion)
+    expect(output).toContain("name: row[1]");
+    // Nullable bigint: row[2] === null ? null : Number(row[2])
+    expect(output).toContain("nullableId: row[2] === null ? null : Number(row[2])");
+  });
+
+  it("wraps bigint columns with Number() in :one", () => {
+    const driver = new BunSqlDriver();
+
+    const params: Parameter[] = [];
+
+    const columns: Column[] = [
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ({ name: "id", type: { name: "bigserial" }, notNull: true } as unknown as Column),
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions
+      ({ name: "parent_id", type: { name: "serial8" }, notNull: false } as unknown as Column),
+    ];
+
+    const node = driver.oneDecl(
+      "getThing",
+      "getThingQuery",
+      undefined,
+      "GetThingRow",
+      params,
+      columns
+    );
+
+    const output = print(node);
+
+    // Non-nullable bigserial: Number(row[0])
+    expect(output).toContain("id: Number(row[0])");
+    // Nullable serial8: row[1] === null ? null : Number(row[1])
+    expect(output).toContain("parentId: row[1] === null ? null : Number(row[1])");
+  });
+
   it("maps common Postgres alias types", () => {
     const driver = new BunSqlDriver();
     const columns: Column[] = [
@@ -109,8 +171,9 @@ describe("bun-sql driver codegen", () => {
     const output = print(node);
 
     expect(output).toContain("export type AliasRowValues");
+    // bigint is now mapped to number (with runtime Number() conversion)
     expect(output).toMatch(
-      /\[\s*number,\s*number,\s*string,\s*number,\s*number,\s*number,\s*Date,\s*Date,\s*string\s*\]/
+      /\[\s*number,\s*number,\s*number,\s*number,\s*number,\s*number,\s*Date,\s*Date,\s*string\s*\]/
     );
   });
 });

src/drivers/bun-sql.ts

@@ -9,6 +9,59 @@ import {
 import { Parameter, Column } from "../gen/plugin/codegen_pb";
 import { argName, colName } from "./utlis";
 
+// PostgreSQL types that Bun SQL returns as strings but we want as numbers.
+// These are 64-bit integers which Bun returns as strings to avoid precision loss,
+// but for typical use cases (auto-incrementing IDs), converting to JS number is safe.
+const BIGINT_TYPES = new Set(["int8", "bigint", "bigserial", "serial8"]);
+
+function isBigIntType(column?: Column): boolean {
+  if (!column?.type?.name) return false;
+  let typeName = column.type.name;
+  const pgCatalog = "pg_catalog.";
+  if (typeName.startsWith(pgCatalog)) {
+    typeName = typeName.slice(pgCatalog.length);
+  }
+  return BIGINT_TYPES.has(typeName.toLowerCase());
+}
+
+// Creates an expression to access row[i], with Number() conversion for bigint types.
+// For nullable bigint columns: row[i] === null ? null : Number(row[i])
+// For non-nullable bigint columns: Number(row[i])
+// For other columns: row[i]
+function createRowAccessExpression(col: Column, index: number) {
+  const rowAccess = factory.createElementAccessExpression(
+    factory.createIdentifier("row"),
+    factory.createNumericLiteral(`${index}`)
+  );
+
+  if (!isBigIntType(col)) {
+    return rowAccess;
+  }
+
+  const numberCall = factory.createCallExpression(
+    factory.createIdentifier("Number"),
+    undefined,
+    [rowAccess]
+  );
+
+  if (col.notNull) {
+    return numberCall;
+  }
+
+  // row[i] === null ? null : Number(row[i])
+  return factory.createConditionalExpression(
+    factory.createBinaryExpression(
+      rowAccess,
+      factory.createToken(SyntaxKind.EqualsEqualsEqualsToken),
+      factory.createNull()
+    ),
+    factory.createToken(SyntaxKind.QuestionToken),
+    factory.createNull(),
+    factory.createToken(SyntaxKind.ColonToken),
+    numberCall
+  );
+}
+
 function funcParamsDecl(iface: string | undefined, params: Parameter[]) {
   let funcParams = [
     factory.createParameterDeclaration(
@@ -64,7 +117,7 @@ export class Driver {
         break;
       }
       case "bigserial": {
-        // string
+        typ = factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
         break;
       }
       case "bit": {
@@ -159,11 +212,11 @@ export class Driver {
         break;
       }
       case "int8": {
-        // string
+        typ = factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
         break;
       }
       case "bigint": {
-        // string
+        typ = factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
         break;
       }
       case "interval": {
@@ -251,7 +304,7 @@ export class Driver {
         break;
       }
       case "serial8": {
-        // string
+        typ = factory.createKeywordTypeNode(SyntaxKind.NumberKeyword);
         break;
       }
       case "smallserial": {
@@ -526,10 +579,7 @@ export class Driver {
                     columns.map((col, i) =>
                       factory.createPropertyAssignment(
                         factory.createIdentifier(colName(i, col)),
-                        factory.createElementAccessExpression(
-                          factory.createIdentifier("row"),
-                          factory.createNumericLiteral(`${i}`)
-                        )
+                        createRowAccessExpression(col, i)
                       )
                     ),
                     true
@@ -678,10 +728,7 @@ export class Driver {
               columns.map((col, i) =>
                 factory.createPropertyAssignment(
                   factory.createIdentifier(colName(i, col)),
-                  factory.createElementAccessExpression(
-                    factory.createIdentifier("row"),
-                    factory.createNumericLiteral(`${i}`)
-                  )
+                  createRowAccessExpression(col, i)
                 )
               ),
               true