@rebasepro/server-postgresql 0.6.0 → 0.6.1

package/dist/utils/pg-array-null-patch.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Patches all PgArray columns on the given tables to handle NULL values safely.
+ *
+ * Drizzle ORM's `PgArray.mapFromDriverValue` calls `value.map(...)` without
+ * guarding against `null`. When a PostgreSQL native array column (`text[]`,
+ * `integer[]`, etc.) contains NULL, the pg driver returns `null` in JavaScript,
+ * and `null.map(...)` throws `TypeError: value.map is not a function`.
+ *
+ * This function walks every column of every registered table and, for any
+ * `PgArray` column, wraps its `mapFromDriverValue` to return `null` when the
+ * database value is nullish.
+ *
+ * This is a workaround for a known Drizzle ORM issue. Should be removed once
+ * Drizzle handles nullable arrays natively.
+ */
+export declare function patchPgArrayNullSafety(tables: Record<string, unknown>): void;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -71,11 +71,11 @@
     "hono": "^4.12.25",
     "pg": "^8.21.0",
     "ws": "^8.21.0",
-    "@rebasepro/common": "0.6.0",
-    "@rebasepro/types": "0.6.0",
-    "@rebasepro/server-core": "0.6.0",
-    "@rebasepro/sdk-generator": "0.6.0",
-    "@rebasepro/utils": "0.6.0"
+    "@rebasepro/types": "0.6.1",
+    "@rebasepro/server-core": "0.6.1",
+    "@rebasepro/sdk-generator": "0.6.1",
+    "@rebasepro/common": "0.6.1",
+    "@rebasepro/utils": "0.6.1"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/src/PostgresBootstrapper.ts

@@ -4,41 +4,31 @@
  * Implements the `BackendBootstrapper` interface for PostgreSQL.
  */
 
-import { getTableName, isTable, Relations, sql, Table } from "drizzle-orm";
+import { getTableName, isTable, Relations, sql } from "drizzle-orm";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
-import { PgEnum, PgTable, getTableConfig } from "drizzle-orm/pg-core";
+import { PgEnum, PgTable } from "drizzle-orm/pg-core";
 import type { RebasePgTable } from "./types";
 import {
+    type AuthAdapter,
     BackendBootstrapper,
-    InitializedDriver,
     BootstrappedAuth,
     DatabaseAdmin,
-    RealtimeProvider,
     type DataDriver,
-    type AuthAdapter,
     EntityCollection,
-    PostgresCollection
+    InitializedDriver,
+    RealtimeProvider
 } from "@rebasepro/types";
 import { PostgresBackendDriver } from "./PostgresBackendDriver";
 import { RealtimeService } from "./services/realtimeService";
 import { DatabasePoolManager } from "./databasePoolManager";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
-import {
-    createAuthRoutes,
-    requireAuth,
-    requireAdmin,
-    logger
-} from "@rebasepro/server-core";
+import { createEmailService, type EmailConfig, type EmailService, logger } from "@rebasepro/server-core";
 import { ensureAuthTablesExist } from "./auth/ensure-tables";
-import { UserService, PostgresAuthRepository, AuthSchemaTables } from "./auth/services";
+import { AuthSchemaTables, PostgresAuthRepository, UserService } from "./auth/services";
 import { createAuthSchema } from "./schema/auth-schema";
-
-import { createEmailService, type EmailConfig, type EmailService } from "@rebasepro/server-core";
-import { createHistoryRoutes } from "@rebasepro/server-core";
 import { HistoryService } from "./history/HistoryService";
 import { ensureHistoryTableExists } from "./history/ensure-history-table";
-import type { Hono } from "hono";
-import type { HonoEnv } from "@rebasepro/server-core";
+import { patchPgArrayNullSafety } from "./utils/pg-array-null-patch";
 
 export interface PostgresDriverConfig {
     connectionString?: string;
@@ -108,6 +98,13 @@ export function createPostgresBootstrapper(pgConfig: PostgresDriverConfig): Back
             if (pgConfig.schema?.enums) registry.registerEnums(pgConfig.schema.enums as Record<string, PgEnum<[string, ...string[]]>>);
             if (pgConfig.schema?.relations) registry.registerRelations(pgConfig.schema.relations as Record<string, Relations>);
 
+            // Patch Drizzle's PgArray columns to handle NULL values safely.
+            // Drizzle's mapFromDriverValue crashes with "value.map is not a function"
+            // when a native array column (text[], integer[], etc.) contains NULL.
+            if (pgConfig.schema?.tables) {
+                patchPgArrayNullSafety(pgConfig.schema.tables as Record<string, unknown>);
+            }
+
             // Build schema-aware Drizzle connection
             const mergedSchema: Record<string, unknown> = {
                 ...pgConfig.schema?.tables,

package/src/data-transformer.ts

@@ -244,8 +244,12 @@ export function serializePropertyToServer(value: unknown, property: Property): u
                         };
                     });
                 }
+                return value;
             }
-            return value;
+            // Non-array value for an array property — coerce to avoid .map() crashes downstream
+            logger.warn(`Expected array value for array property, got ${typeof value}. Coercing to empty array.`);
+            return [];
+
 
         case "map":
             if (typeof value === "object" && property.properties) {
@@ -585,6 +589,10 @@ export function parsePropertyFromServer(value: unknown, property: Property, coll
                         };
                     });
                 }
+            } else {
+                // Non-array value from DB for an array property — coerce to avoid .map() crashes
+                logger.warn(`Expected array value from DB for array property, got ${typeof value}. Coercing to array.`);
+                return typeof value === "string" ? [value] : [];
             }
             return value;
 

package/src/services/EntityPersistService.ts

@@ -192,17 +192,17 @@ export class EntityPersistService {
             }
         }
 
-        // Transform relations to IDs, then sanitize
-        const serializedResult = serializeDataToServer(otherValues as M, collection.properties as Properties, collection, this.registry);
+        let savedId: string | number;
+        try {
+            // Transform relations to IDs, then sanitize
+            const serializedResult = serializeDataToServer(otherValues as M, collection.properties as Properties, collection, this.registry);
 
-        // Extract relation updates from the typed result
-        const inverseRelationUpdates = serializedResult.inverseRelationUpdates;
-        const joinPathRelationUpdates = serializedResult.joinPathRelationUpdates;
+            // Extract relation updates from the typed result
+            const inverseRelationUpdates = serializedResult.inverseRelationUpdates;
+            const joinPathRelationUpdates = serializedResult.joinPathRelationUpdates;
 
-        const entityData = sanitizeAndConvertDates(serializedResult.scalarData);
+            const entityData = sanitizeAndConvertDates(serializedResult.scalarData);
 
-        let savedId: string | number;
-        try {
             savedId = await this.db.transaction(async (tx) => {
                 let currentId: string | number;
 

package/src/utils/pg-array-null-patch.ts

@@ -0,0 +1,42 @@
+import { getTableColumns } from "drizzle-orm";
+import { PgArray, PgTable } from "drizzle-orm/pg-core";
+import { logger } from "@rebasepro/server-core";
+
+/**
+ * Patches all PgArray columns on the given tables to handle NULL values safely.
+ *
+ * Drizzle ORM's `PgArray.mapFromDriverValue` calls `value.map(...)` without
+ * guarding against `null`. When a PostgreSQL native array column (`text[]`,
+ * `integer[]`, etc.) contains NULL, the pg driver returns `null` in JavaScript,
+ * and `null.map(...)` throws `TypeError: value.map is not a function`.
+ *
+ * This function walks every column of every registered table and, for any
+ * `PgArray` column, wraps its `mapFromDriverValue` to return `null` when the
+ * database value is nullish.
+ *
+ * This is a workaround for a known Drizzle ORM issue. Should be removed once
+ * Drizzle handles nullable arrays natively.
+ */
+export function patchPgArrayNullSafety(tables: Record<string, unknown>): void {
+    let patchedCount = 0;
+
+    for (const tableOrRelation of Object.values(tables)) {
+        if (!(tableOrRelation instanceof PgTable)) continue;
+
+        const columns = getTableColumns(tableOrRelation);
+        for (const column of Object.values(columns)) {
+            if (column instanceof PgArray) {
+                const original = column.mapFromDriverValue.bind(column);
+                column.mapFromDriverValue = function (value: unknown) {
+                    if (value == null) return null;
+                    return original(value as string | unknown[]);
+                };
+                patchedCount++;
+            }
+        }
+    }
+
+    if (patchedCount > 0) {
+        logger.debug(`[PgArray] Patched ${patchedCount} array column(s) for null-safety`);
+    }
+}

package/test/array-null-safety.test.ts

@@ -0,0 +1,335 @@
+import { describe, it, expect } from "@jest/globals";
+import {
+    serializePropertyToServer,
+    parsePropertyFromServer,
+    serializeDataToServer
+} from "../src/data-transformer";
+import type { Property, Properties, EntityCollection } from "@rebasepro/types";
+
+// ─────────────────────────────────────────────────────────────
+// Fixture helpers
+// ─────────────────────────────────────────────────────────────
+function makeCollection(slug: string, properties: Properties): EntityCollection {
+    return {
+        name: slug,
+        slug,
+        path: slug,
+        collectionType: "postgres",
+        tableName: slug,
+        properties
+    } as unknown as EntityCollection;
+}
+
+// ─────────────────────────────────────────────────────────────
+// Property fixtures
+// ─────────────────────────────────────────────────────────────
+const arrayOfStringsProp: Property = {
+    type: "array",
+    name: "Tags",
+    of: { type: "string", name: "Tag" }
+} as Property;
+
+const arrayOfNumbersProp: Property = {
+    type: "array",
+    name: "Scores",
+    of: { type: "number", name: "Score" }
+} as Property;
+
+const arrayOfMapsProp: Property = {
+    type: "array",
+    name: "Addresses",
+    of: {
+        type: "map",
+        name: "Address",
+        properties: {
+            street: { type: "string", name: "Street" },
+            city: { type: "string", name: "City" }
+        }
+    }
+} as Property;
+
+const arrayOneOfProp: Property = {
+    type: "array",
+    name: "Blocks",
+    oneOf: {
+        typeField: "type",
+        valueField: "value",
+        properties: {
+            text: { type: "string", name: "Text" } as Property,
+            number: { type: "number", name: "Number" } as Property
+        }
+    }
+} as Property;
+
+const arrayOfRelationsProp: Property = {
+    type: "array",
+    name: "Authors",
+    of: { type: "relation", name: "Author" }
+} as Property;
+
+// A bare array property without `of` or `oneOf`
+const bareArrayProp: Property = {
+    type: "array",
+    name: "RawArray"
+} as Property;
+
+// ─────────────────────────────────────────────────────────────
+// 1. serializePropertyToServer — array null safety
+// ─────────────────────────────────────────────────────────────
+describe("serializePropertyToServer — array null safety", () => {
+
+    // ── Null / undefined early return ──
+    it("returns null when value is null with array-of-strings property", () => {
+        expect(serializePropertyToServer(null, arrayOfStringsProp)).toBeNull();
+    });
+
+    it("returns undefined when value is undefined with array-of-strings property", () => {
+        expect(serializePropertyToServer(undefined, arrayOfStringsProp)).toBeUndefined();
+    });
+
+    // ── Empty array ──
+    it("returns [] when value is an empty array", () => {
+        expect(serializePropertyToServer([], arrayOfStringsProp)).toEqual([]);
+    });
+
+    // ── Null with different sub-types ──
+    it("returns null when value is null with array-of-numbers property", () => {
+        expect(serializePropertyToServer(null, arrayOfNumbersProp)).toBeNull();
+    });
+
+    it("returns null when value is null with array-of-maps property", () => {
+        expect(serializePropertyToServer(null, arrayOfMapsProp)).toBeNull();
+    });
+
+    it("returns null when value is null with array oneOf property", () => {
+        expect(serializePropertyToServer(null, arrayOneOfProp)).toBeNull();
+    });
+
+    // ── Non-array values (coerced to empty array) ──
+    it("coerces a non-array string to empty array for array property", () => {
+        expect(serializePropertyToServer("not-an-array", arrayOfStringsProp)).toEqual([]);
+    });
+
+    it("coerces a non-array number to empty array for array property", () => {
+        expect(serializePropertyToServer(42, arrayOfStringsProp)).toEqual([]);
+    });
+
+    it("coerces a non-array object to empty array for bare array property", () => {
+        const obj = { a: 1 };
+        expect(serializePropertyToServer(obj, bareArrayProp)).toEqual([]);
+    });
+
+    it("coerces a boolean to empty array for array property", () => {
+        expect(serializePropertyToServer(true, arrayOfStringsProp)).toEqual([]);
+        expect(serializePropertyToServer(false, arrayOfStringsProp)).toEqual([]);
+    });
+
+    // ── Arrays with null / undefined elements ──
+    it("handles array with null elements by passing each through sub-serialization", () => {
+        const result = serializePropertyToServer([null, "a", null], arrayOfStringsProp);
+        expect(result).toEqual([null, "a", null]);
+    });
+
+    it("handles array with undefined elements by passing each through sub-serialization", () => {
+        const result = serializePropertyToServer([undefined, "a"], arrayOfStringsProp);
+        expect(result).toEqual([undefined, "a"]);
+    });
+
+    // ── Array of relation objects with null entries ──
+    it("serializes array of relation objects with null entries correctly", () => {
+        const value = [{ id: "1" }, null, { id: "2" }];
+        const result = serializePropertyToServer(value, arrayOfRelationsProp);
+        // null entries pass through serializePropertyToServer for the sub-property
+        // which returns null for null values
+        expect(result).toEqual(["1", null, "2"]);
+    });
+
+    // ── Array of maps where some entries are null ──
+    it("handles array of maps where some entries are null gracefully", () => {
+        const value = [
+            { street: "123 Main", city: "NYC" },
+            null,
+            { street: "456 Oak", city: "LA" }
+        ];
+        const result = serializePropertyToServer(value, arrayOfMapsProp);
+        expect(result).toEqual([
+            { street: "123 Main", city: "NYC" },
+            null,
+            { street: "456 Oak", city: "LA" }
+        ]);
+    });
+
+    // ── Empty array with oneOf property ──
+    it("returns [] when value is an empty array with oneOf property", () => {
+        expect(serializePropertyToServer([], arrayOneOfProp)).toEqual([]);
+    });
+
+    // ── Nested array of arrays (unusual) ──
+    it("returns nested array of arrays as-is for bare array property", () => {
+        const nested = [["a", "b"], ["c"]];
+        // Without `of` or `oneOf`, the array case falls through to `return value`
+        expect(serializePropertyToServer(nested, bareArrayProp)).toEqual([["a", "b"], ["c"]]);
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// 2. parsePropertyFromServer — array null safety
+// ─────────────────────────────────────────────────────────────
+describe("parsePropertyFromServer — array null safety", () => {
+    const dummyCollection = makeCollection("items", {
+        tags: arrayOfStringsProp
+    });
+
+    // ── Null / undefined early return ──
+    it("returns null when value is null with array property", () => {
+        expect(parsePropertyFromServer(null, arrayOfStringsProp, dummyCollection)).toBeNull();
+    });
+
+    it("returns undefined when value is undefined with array property", () => {
+        expect(parsePropertyFromServer(undefined, arrayOfStringsProp, dummyCollection)).toBeUndefined();
+    });
+
+    // ── Empty array ──
+    it("returns [] when value is an empty array with array-of-strings", () => {
+        expect(parsePropertyFromServer([], arrayOfStringsProp, dummyCollection)).toEqual([]);
+    });
+
+    // ── Non-array values (coerced to array) ──
+    it("coerces a non-array string to single-element array for array property", () => {
+        expect(parsePropertyFromServer("not-an-array", arrayOfStringsProp, dummyCollection)).toEqual(["not-an-array"]);
+    });
+
+    it("coerces a non-array number to empty array for array property", () => {
+        expect(parsePropertyFromServer(99, arrayOfStringsProp, dummyCollection)).toEqual([]);
+    });
+
+    // ── Null with oneOf ──
+    it("returns null when value is null with array oneOf property", () => {
+        expect(parsePropertyFromServer(null, arrayOneOfProp, dummyCollection)).toBeNull();
+    });
+
+    // ── Array with null elements ──
+    it("handles array with null elements for parsing gracefully", () => {
+        const result = parsePropertyFromServer([null, "a", null], arrayOfStringsProp, dummyCollection);
+        expect(result).toEqual([null, "a", null]);
+    });
+
+    // ── Falsy non-null values (coerced to array) ──
+    it("coerces falsy number 0 to empty array for array property", () => {
+        expect(parsePropertyFromServer(0, arrayOfStringsProp, dummyCollection)).toEqual([]);
+    });
+
+    it("coerces false to empty array for array property", () => {
+        expect(parsePropertyFromServer(false, arrayOfStringsProp, dummyCollection)).toEqual([]);
+    });
+
+    it("coerces empty string to single-element array for array property", () => {
+        expect(parsePropertyFromServer("", arrayOfStringsProp, dummyCollection)).toEqual([""]);
+    });
+});
+
+// ─────────────────────────────────────────────────────────────
+// 3. serializeDataToServer — entity with null array fields
+// ─────────────────────────────────────────────────────────────
+describe("serializeDataToServer — entity with null array fields", () => {
+    const tagsProperty: Property = {
+        type: "array",
+        name: "Tags",
+        of: { type: "string", name: "Tag" }
+    } as Property;
+
+    const categoriesProperty: Property = {
+        type: "array",
+        name: "Categories",
+        of: { type: "string", name: "Category" }
+    } as Property;
+
+    const metadataProperty: Property = {
+        type: "map",
+        name: "Metadata",
+        properties: {
+            labels: {
+                type: "array",
+                name: "Labels",
+                of: { type: "string", name: "Label" }
+            } as Property
+        }
+    } as Property;
+
+    const properties: Properties = {
+        tags: tagsProperty
+    };
+
+    // ── Null array field ──
+    it("serializes entity with tags: null — scalarData.tags should be null", () => {
+        const result = serializeDataToServer(
+            { tags: null },
+            properties
+        );
+        expect(result.scalarData.tags).toBeNull();
+    });
+
+    // ── Undefined array field ──
+    it("serializes entity with tags: undefined — tags value should be undefined in scalarData", () => {
+        const result = serializeDataToServer(
+            { tags: undefined },
+            properties
+        );
+        // Object.entries iterates keys even when value is undefined,
+        // and serializePropertyToServer returns undefined for undefined input
+        expect(result.scalarData.tags).toBeUndefined();
+    });
+
+    // ── Empty array field ──
+    it("serializes entity with tags: [] — scalarData.tags should be []", () => {
+        const result = serializeDataToServer(
+            { tags: [] },
+            properties
+        );
+        expect(result.scalarData.tags).toEqual([]);
+    });
+
+    // ── Multiple array fields, mixed null / populated ──
+    it("handles entity with multiple array fields, some null, some populated", () => {
+        const multiProperties: Properties = {
+            tags: tagsProperty,
+            categories: categoriesProperty
+        };
+
+        const result = serializeDataToServer(
+            { tags: null, categories: ["cat-a", "cat-b"] },
+            multiProperties
+        );
+        expect(result.scalarData.tags).toBeNull();
+        expect(result.scalarData.categories).toEqual(["cat-a", "cat-b"]);
+    });
+
+    // ── Nested map containing null array ──
+    it("handles entity with nested map containing array field that is null", () => {
+        const nestedProperties: Properties = {
+            metadata: metadataProperty
+        };
+
+        const result = serializeDataToServer(
+            { metadata: { labels: null } },
+            nestedProperties
+        );
+        // The map serializer recurses into sub-properties; the inner array gets null-checked
+        expect(result.scalarData.metadata).toEqual({ labels: null });
+    });
+
+    // ── All array fields null ──
+    it("handles entity with only array fields, all null — scalarData should have all null values", () => {
+        const allArrayProperties: Properties = {
+            tags: tagsProperty,
+            categories: categoriesProperty
+        };
+
+        const result = serializeDataToServer(
+            { tags: null, categories: null },
+            allArrayProperties
+        );
+        expect(result.scalarData.tags).toBeNull();
+        expect(result.scalarData.categories).toBeNull();
+    });
+});

package/test/data-transformer.test.ts

@@ -149,14 +149,65 @@ path: "authors" }
             of: { type: "string" } as Property
         } as unknown as Property;
 
+        const arrayOfNumbersProp: Property = {
+            type: "array",
+            of: { type: "number" } as Property
+        } as unknown as Property;
+
+        const arrayOfRelationsProp: Property = {
+            type: "array",
+            of: { type: "relation" } as Property
+        } as unknown as Property;
+
         it("should serialize array elements through their sub-property type", () => {
             expect(serializePropertyToServer(["a", "b", "c"], arrayOfStringsProp))
                 .toEqual(["a", "b", "c"]);
         });
 
-        it("should pass through non-array values", () => {
+        it("should coerce non-array values to empty array", () => {
             expect(serializePropertyToServer("not-an-array", arrayOfStringsProp))
-                .toBe("not-an-array");
+                .toEqual([]);
+        });
+
+        // --- Null safety ---
+        it("should return null for null array value", () => {
+            expect(serializePropertyToServer(null, arrayOfStringsProp)).toBeNull();
+        });
+
+        it("should return undefined for undefined array value", () => {
+            expect(serializePropertyToServer(undefined, arrayOfStringsProp)).toBeUndefined();
+        });
+
+        it("should return empty array for empty array value", () => {
+            expect(serializePropertyToServer([], arrayOfStringsProp)).toEqual([]);
+        });
+
+        it("should return null for null value with array-of-numbers property", () => {
+            expect(serializePropertyToServer(null, arrayOfNumbersProp)).toBeNull();
+        });
+
+        it("should handle array with null elements", () => {
+            const result = serializePropertyToServer([null, "a", null, "b"], arrayOfStringsProp);
+            expect(result).toEqual([null, "a", null, "b"]);
+        });
+
+        it("should handle array of relation objects with null entries", () => {
+            const value = [{ id: "1", path: "tags" }, null, { id: "2", path: "tags" }];
+            const result = serializePropertyToServer(value, arrayOfRelationsProp);
+            expect(result).toEqual(["1", null, "2"]);
+        });
+
+        it("should coerce number value to empty array for array property", () => {
+            expect(serializePropertyToServer(42, arrayOfStringsProp)).toEqual([]);
+        });
+
+        it("should coerce boolean value to empty array for array property", () => {
+            expect(serializePropertyToServer(true, arrayOfStringsProp)).toEqual([]);
+        });
+
+        it("should coerce object value to empty array for array property", () => {
+            const obj = { a: 1 };
+            expect(serializePropertyToServer(obj, arrayOfStringsProp)).toEqual([]);
         });
     });
 

package/test/pg-array-null-patch.test.ts

@@ -0,0 +1,65 @@
+import { describe, it, expect, jest } from "@jest/globals";
+import { pgTable, text, integer, boolean } from "drizzle-orm/pg-core";
+import { patchPgArrayNullSafety } from "../src/utils/pg-array-null-patch";
+import { getTableColumns } from "drizzle-orm";
+import { PgArray } from "drizzle-orm/pg-core";
+
+// Build a table that has native array columns
+const testTable = pgTable("test_items", {
+    id: text("id").primaryKey(),
+    name: text("name"),
+    tags: text("tags").array(),
+    scores: integer("scores").array(),
+    flags: boolean("flags").array(),
+});
+
+describe("patchPgArrayNullSafety", () => {
+    it("should patch PgArray columns to handle null", () => {
+        patchPgArrayNullSafety({ test_items: testTable });
+
+        const columns = getTableColumns(testTable);
+        const tagsColumn = columns.tags;
+
+        // Before patch, calling mapFromDriverValue(null) would throw TypeError
+        // After patch, it should return null
+        expect(tagsColumn.mapFromDriverValue(null as any)).toBeNull();
+        expect(tagsColumn.mapFromDriverValue(undefined as any)).toBeNull();
+    });
+
+    it("should still process valid array values correctly", () => {
+        patchPgArrayNullSafety({ test_items: testTable });
+
+        const columns = getTableColumns(testTable);
+        const tagsColumn = columns.tags;
+        const scoresColumn = columns.scores;
+
+        // Valid arrays should still work
+        expect(tagsColumn.mapFromDriverValue(["hello", "world"])).toEqual(["hello", "world"]);
+        expect(tagsColumn.mapFromDriverValue([])).toEqual([]);
+        expect(scoresColumn.mapFromDriverValue([1, 2, 3])).toEqual([1, 2, 3]);
+    });
+
+    it("should not patch non-array columns", () => {
+        patchPgArrayNullSafety({ test_items: testTable });
+
+        const columns = getTableColumns(testTable);
+        const nameColumn = columns.name;
+
+        // Non-array columns should not be PgArray instances
+        expect(nameColumn instanceof PgArray).toBe(false);
+    });
+
+    it("should handle tables with no array columns", () => {
+        const simpleTable = pgTable("simple", {
+            id: text("id").primaryKey(),
+            name: text("name"),
+        });
+
+        // Should not throw
+        expect(() => patchPgArrayNullSafety({ simple: simpleTable })).not.toThrow();
+    });
+
+    it("should handle empty input", () => {
+        expect(() => patchPgArrayNullSafety({})).not.toThrow();
+    });
+});