sql: serialize JS arrays in sql(object) as PostgreSQL array literals

src/bun.js/bindings/JSValue.zig

@@ -405,19 +405,26 @@ pub const JSValue = enum(i64) {
         return bun.jsc.fromJSHostCallGeneric(globalObject, @src(), JSC__JSValue__push, .{ value, globalObject, out });
     }
 
-    extern fn JSC__JSValue__toISOString(*jsc.JSGlobalObject, jsc.JSValue, *[28]u8) c_int;
-    pub fn toISOString(this: JSValue, globalObject: *jsc.JSGlobalObject, buf: *[28]u8) []const u8 {
+    extern fn JSC__JSValue__toISOString(*jsc.JSGlobalObject, jsc.JSValue, *[29]u8) c_int;
+    /// Writes the ISO 8601 UTC representation of a JS Date into `buf`
+    /// (e.g. "2024-01-01T00:00:00.000Z", max 28 chars + NUL). Returns an empty
+    /// slice for non-Date or non-finite values.
+    pub fn toISOString(this: JSValue, globalObject: *jsc.JSGlobalObject, buf: *[29]u8) []const u8 {
         const count = JSC__JSValue__toISOString(globalObject, this, buf);
-        if (count < 0) {
+        // Defensive: the C++ side asserts `count < 29` but asserts are
+        // compiled out in release. Clamp to the buffer so we never slice
+        // out of bounds even if the binding is ever changed to write more.
+        if (count < 0 or count > buf.len) {
             return "";
         }
 
         return buf[0..@as(usize, @intCast(count))];
     }
-    extern fn JSC__JSValue__DateNowISOString(*JSGlobalObject, f64) JSValue;
+    extern fn JSC__JSValue__DateNowISOString(*JSGlobalObject, *[28]u8) c_int;
     pub fn getDateNowISOString(globalObject: *jsc.JSGlobalObject, buf: *[28]u8) []const u8 {
+        // `JSC__JSValue__DateNowISOString` writes at most 28 bytes (no NUL).
         const count = JSC__JSValue__DateNowISOString(globalObject, buf);
-        if (count < 0) {
+        if (count < 0 or count > buf.len) {
             return "";
         }
 

src/bun.js/bindings/bindings.cpp

@@ -5815,7 +5815,6 @@ extern "C" EncodedJSValue JSC__JSValue__dateInstanceFromNullTerminatedString(JSC
 // this is largely copied from dateProtoFuncToISOString
 extern "C" int JSC__JSValue__toISOString(JSC::JSGlobalObject* globalObject, EncodedJSValue dateValue, char* buf)
 {
-    char buffer[64];
     JSC::DateInstance* thisDateObj = JSC::jsDynamicCast<JSC::DateInstance*>(JSC::JSValue::decode(dateValue));
     if (!thisDateObj)
         return -1;
@@ -5825,7 +5824,10 @@ extern "C" int JSC__JSValue__toISOString(JSC::JSGlobalObject* globalObject, Enco
 
     auto& vm = JSC::getVM(globalObject);
 
-    return static_cast<int>(Bun::toISOString(vm, thisDateObj->internalNumber(), buffer));
+    // Bun::toISOString writes up to 28 bytes plus a NUL terminator into
+    // `buf`. Callers must provide a 29-byte buffer (fits ISO 8601 in UTC with
+    // millisecond precision, e.g. "2024-01-01T00:00:00.000Z" = 24 chars).
+    return static_cast<int>(Bun::toISOString(vm, thisDateObj->internalNumber(), buf));
 }
 
 extern "C" int JSC__JSValue__DateNowISOString(JSC::JSGlobalObject* globalObject, char* buf)

src/sql/postgres/DataCell.zig

@@ -62,6 +62,58 @@ fn trySlice(slice: []const u8, count: usize) []const u8 {
     if (slice.len <= count) return "";
     return slice[count..];
 }
+
+/// Binary 1-D numeric array with one or more NULL elements. Typed arrays
+/// can't represent holes, so build a regular JS array of per-element cells.
+/// Element stream layout (after the 20-byte header):
+///     { i32 length, [length]u8 data }*   // length = -1 → NULL element
+fn decodeBinaryNumericArrayWithNulls(bytes: []const u8, comptime tag: types.Tag) !SQLDataCell {
+    // Caller has already validated bytes.len >= 12 and dimensions == 1.
+    if (bytes.len < 20) return error.InvalidBinaryData;
+    const dim_size_raw: int4 = @bitCast(bytes[12..16].*);
+    const dim_size: u32 = @bitCast(@byteSwap(dim_size_raw));
+
+    const element_bytes = @sizeOf(try tag.byteArrayType());
+
+    var array: std.ArrayListUnmanaged(SQLDataCell) = .empty;
+    errdefer if (array.capacity > 0) array.deinit(bun.default_allocator);
+    try array.ensureTotalCapacityPrecise(bun.default_allocator, dim_size);
+
+    var cursor: usize = 20;
+    var i: u32 = 0;
+    while (i < dim_size) : (i += 1) {
+        if (cursor + 4 > bytes.len) return error.InvalidBinaryData;
+        const len_raw: i32 = @bitCast(bytes[cursor..][0..4].*);
+        const len: i32 = @bitCast(@byteSwap(@as(u32, @bitCast(len_raw))));
+        cursor += 4;
+
+        if (len < 0) {
+            // NULL element (length = -1).
+            array.appendAssumeCapacity(SQLDataCell{ .tag = .null, .value = .{ .null = 0 } });
+            continue;
+        }
+
+        if (len != element_bytes) return error.InvalidBinaryData;
+        if (cursor + element_bytes > bytes.len) return error.InvalidBinaryData;
+        const value_bytes = bytes[cursor..][0..element_bytes];
+        cursor += element_bytes;
+
+        switch (tag) {
+            .int4_array => {
+                const raw: i32 = @bitCast(value_bytes[0..4].*);
+                array.appendAssumeCapacity(SQLDataCell{ .tag = .int4, .value = .{ .int4 = @byteSwap(raw) } });
+            },
+            .float4_array => {
+                const raw: u32 = @bitCast(value_bytes[0..4].*);
+                const f: f32 = @bitCast(@byteSwap(raw));
+                array.appendAssumeCapacity(SQLDataCell{ .tag = .float8, .value = .{ .float8 = @floatCast(f) } });
+            },
+            else => comptime unreachable,
+        }
+    }
+
+    return SQLDataCell{ .tag = .array, .value = .{ .array = .{ .ptr = array.items.ptr, .len = @truncate(array.items.len), .cap = @truncate(array.capacity) } } };
+}
 fn parseArray(bytes: []const u8, bigint: bool, comptime arrayType: types.Tag, globalObject: *jsc.JSGlobalObject, offset: ?*usize, comptime is_json_sub_array: bool) !SQLDataCell {
     const closing_brace = if (is_json_sub_array) ']' else '}';
     const opening_brace = if (is_json_sub_array) '[' else '{';
@@ -215,6 +267,7 @@ fn parseArray(bytes: []const u8, bigint: bool, comptime arrayType: types.Tag, gl
                     .aclitem_array,
                     .pg_database_array,
                     .pg_database_array2,
+                    .uuid_array,
                     => {
                         // this is also a string until we reach "," or "}" but a single word string like Bun
                         var current_idx: usize = 0;
@@ -473,10 +526,6 @@ pub fn fromBytes(binary: bool, bigint: bool, oid: types.Tag, bytes: []const u8,
                     return error.MultidimensionalArrayNotSupportedYet;
                 }
 
-                if (contains_nulls != 0) {
-                    return error.NullsInArrayNotSupportedYet;
-                }
-
                 if (dimensions == 0) {
                     return SQLDataCell{
                         .tag = .typed_array,
@@ -491,6 +540,13 @@ pub fn fromBytes(binary: bool, bigint: bool, oid: types.Tag, bytes: []const u8,
                     };
                 }
 
+                if (contains_nulls != 0) {
+                    // Binary 1-D array with NULL elements: can't use the
+                    // typed-array fast path (holes have no in-place slot).
+                    // Decode element-by-element into a regular JS array.
+                    return try decodeBinaryNumericArrayWithNulls(bytes, tag);
+                }
+
                 const elements = (try tag.pgArrayType()).init(bytes).slice();
 
                 return SQLDataCell{
@@ -693,6 +749,8 @@ pub fn fromBytes(binary: bool, bigint: bool, oid: types.Tag, bytes: []const u8,
         .timestamp_array,
         .timestamptz_array,
         .interval_array,
+
+        .uuid_array,
         => |tag| {
             return try parseArray(bytes, bigint, tag, globalObject, null, false);
         },

src/sql/postgres/PostgresRequest.zig

@@ -38,6 +38,10 @@ pub fn writeBind(
         const force_text = is_custom_type or (tag.isBinaryFormatSupported() and brk: {
             iter.to(@truncate(i));
             if (try iter.next()) |value| {
+                // If the user passed a JS array for an array-typed parameter,
+                // we'll emit a PostgreSQL array literal in text format below,
+                // so request format 0 here too.
+                if (value.isArray() and tag.isArray()) break :brk true;
                 break :brk value.isString();
             }
             if (iter.anyFailed()) {
@@ -95,6 +99,16 @@ pub fn writeBind(
             debug("  -> {s}", .{tag.tagName() orelse "(unknown)"});
         }
 
+        // When the server-inferred parameter type is a PG array and the user
+        // passed a plain JS array (e.g. from `sql({ col: [1, 2] })`), emit a
+        // text-format PG array literal instead of falling through to the
+        // generic `String.fromJS` path — which would produce the comma-joined
+        // `Array.prototype.toString` result and get rejected as malformed.
+        if (value.isArray() and tag.isArray()) {
+            try types.array_serializer.writeTo(globalObject, value, tag.arrayElementTag(), Context, writer);
+            continue;
+        }
+
         switch (
         // If they pass a value as a string, let's avoid attempting to
         // convert it to the binary representation. This minimizes the room

src/sql/postgres/PostgresTypes.zig

@@ -1,5 +1,6 @@
 pub const @"bool" = @import("./types/bool.zig");
 
+pub const array_serializer = @import("./types/array_serializer.zig");
 pub const bytea = @import("./types/bytea.zig");
 pub const date = @import("./types/date.zig");
 pub const json = @import("./types/json.zig");

src/sql/postgres/types/Tag.zig

@@ -105,6 +105,7 @@ pub const Tag = enum(short) {
     varbit = 1562,
     numeric = 1700,
     uuid = 2950,
+    uuid_array = 2951,
 
     bool_array = 1000,
     bytea_array = 1001,
@@ -184,6 +185,75 @@ pub const Tag = enum(short) {
         return 0;
     }
 
+    /// Returns true for `*_array` type OIDs (e.g. `text_array`, `int4_array`).
+    pub fn isArray(this: Tag) bool {
+        return switch (this) {
+            .bool_array,
+            .bytea_array,
+            .char_array,
+            .name_array,
+            .int8_array,
+            .int2_array,
+            .int2vector_array,
+            .int4_array,
+            .text_array,
+            .oid_array,
+            .tid_array,
+            .xid_array,
+            .cid_array,
+            .json_array,
+            .xml_array,
+            .point_array,
+            .lseg_array,
+            .path_array,
+            .box_array,
+            .polygon_array,
+            .line_array,
+            .cidr_array,
+            .float4_array,
+            .float8_array,
+            .circle_array,
+            .macaddr8_array,
+            .money_array,
+            .macaddr_array,
+            .inet_array,
+            .aclitem_array,
+            .bpchar_array,
+            .varchar_array,
+            .date_array,
+            .time_array,
+            .timestamp_array,
+            .timestamptz_array,
+            .interval_array,
+            .pg_database_array,
+            .timetz_array,
+            .bit_array,
+            .varbit_array,
+            .numeric_array,
+            .jsonb_array,
+            .jsonpath_array,
+            .pg_database_array2,
+            .uuid_array,
+            => true,
+            else => false,
+        };
+    }
+
+    /// For array type OIDs, returns the element tag that the array serializer
+    /// treats specially (bool/bytea/json/jsonb for element formatting, box for
+    /// the `;` delimiter). Every other array — and every non-array tag —
+    /// maps to `.text`, which is the `String.fromJS` fallback path.
+    pub fn arrayElementTag(this: Tag) Tag {
+        return switch (this) {
+            .bool_array => .bool,
+            .bytea_array => .bytea,
+            .json_array => .json,
+            .jsonb_array => .jsonb,
+            .box_array => .box,
+            else => .text,
+        };
+    }
+
     fn PostgresBinarySingleDimensionArray(comptime T: type) type {
         return extern struct {
             // struct array_int4 {