@rebasepro/server-postgresql 0.5.0 → 0.6.1

package/dist/{server-postgresql/src/services → services}/EntityPersistService.d.ts

@@ -37,18 +37,4 @@ export declare class EntityPersistService {
      * Translate raw PostgreSQL / Drizzle errors into user-friendly messages.
      */
     private toUserFriendlyError;
-    /**
-     * Walk the error cause chain and return the deepest meaningful message.
-     */
-    private extractCauseMessage;
-    /**
-     * Strip the raw SQL query from a Drizzle "Failed query: ..." message,
-     * keeping only the error description.
-     */
-    private stripSqlFromMessage;
-    /**
-     * Extract the underlying PostgreSQL error from a Drizzle wrapper.
-     * Drizzle wraps PG errors in a `cause` property.
-     */
-    private extractPgError;
 }

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/dist/utils/pg-error-utils.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Shared PostgreSQL error extraction and user-friendly message formatting.
+ *
+ * Drizzle wraps native PG errors in a `.cause` chain. These utilities
+ * unwrap that chain to get the real PostgreSQL error (identified by a
+ * 5-character alphanumeric `code` such as `42P01`) and translate it into
+ * a message that is safe and helpful to show to end-users.
+ */
+/** Shape of PostgreSQL errors with diagnostic metadata. */
+export interface PostgresError extends Error {
+    code?: string;
+    detail?: string;
+    hint?: string;
+    constraint?: string;
+    column?: string;
+    table?: string;
+    dataType?: string;
+    cause?: unknown;
+}
+/**
+ * Extract the underlying PostgreSQL error from a Drizzle wrapper.
+ * Drizzle wraps PG errors in a `cause` property — this function
+ * recursively walks the chain until it finds an object with a PG
+ * error code (5-char alphanumeric, e.g. `42P01`).
+ */
+export declare function extractPgError(error: unknown): PostgresError | null;
+/**
+ * Walk the error cause chain and return the deepest meaningful message.
+ */
+export declare function extractCauseMessage(error: unknown): string | null;
+/**
+ * Translate a raw PostgreSQL error into a user-friendly message.
+ *
+ * @param pgError  - The extracted PostgreSQL error (from {@link extractPgError})
+ * @param context  - A human-readable context string (e.g. collection slug or path)
+ * @returns An object with a `message` safe for the client and the PG `code`.
+ */
+export declare function pgErrorToFriendlyMessage(pgError: PostgresError, context: string): {
+    message: string;
+    code: string;
+};
+/**
+ * Sanitize any error into a message safe and helpful for the client.
+ *
+ * Extracts the PG error from the Drizzle cause chain when possible;
+ * falls back to a generic message that doesn't leak SQL.
+ *
+ * @param error   - The raw caught error
+ * @param context - A human-readable context string (e.g. collection path)
+ * @returns An object with `message` (user-friendly) and optional `code` (PG code).
+ */
+export declare function sanitizeErrorForClient(error: unknown, context: string): {
+    message: string;
+    code?: string;
+};

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgresql",
   "type": "module",
-  "version": "0.5.0",
+  "version": "0.6.1",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -15,7 +15,7 @@
   },
   "main": "./dist/index.umd.js",
   "module": "./dist/index.es.js",
-  "types": "./dist/server-postgresql/src/index.d.ts",
+  "types": "./dist/index.d.ts",
   "source": "src/index.ts",
   "engines": {
     "node": ">=20"
@@ -43,15 +43,18 @@
       "node"
     ],
     "moduleNameMapper": {
+      "^chalk$": "<rootDir>/test/mocks/chalk.cjs",
       "^@rebasepro/client$": "<rootDir>/../client/src/index.ts",
       "^@rebasepro/common$": "<rootDir>/../common/src/index.ts",
       "^@rebasepro/types$": "<rootDir>/../types/src/index.ts",
-      "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts"
+      "^@rebasepro/utils$": "<rootDir>/../utils/src/index.ts",
+      "^@rebasepro/server-core$": "<rootDir>/../server-core/src/index.ts",
+      "^(\\.{1,2}/.*)\\.js$": "$1"
     }
   },
   "exports": {
     ".": {
-      "types": "./dist/server-postgresql/src/index.d.ts",
+      "types": "./dist/index.d.ts",
       "development": "./dist/index.es.js",
       "import": "./dist/index.es.js",
       "require": "./dist/index.umd.js"
@@ -60,31 +63,31 @@
   },
   "dependencies": {
     "arg": "^5.0.2",
-    "chalk": "^4.1.2",
+    "chalk": "^5.6.2",
     "chokidar": "5.0.0",
-    "dotenv": "^16.6.1",
-    "drizzle-orm": "^0.44.7",
+    "dotenv": "^17.4.2",
+    "drizzle-orm": "^0.45.2",
     "execa": "^9.6.1",
-    "hono": "^4.12.21",
+    "hono": "^4.12.25",
     "pg": "^8.21.0",
-    "ws": "^8.20.1",
-    "@rebasepro/sdk-generator": "0.5.0",
-    "@rebasepro/server-core": "0.5.0",
-    "@rebasepro/types": "0.5.0",
-    "@rebasepro/utils": "0.5.0",
-    "@rebasepro/common": "0.5.0"
+    "ws": "^8.21.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": "^29.5.14",
-    "@types/node": "^20.19.41",
+    "@types/jest": "^30.0.0",
+    "@types/node": "^25.9.3",
     "@types/pg": "^8.20.0",
     "@types/ws": "^8.18.1",
-    "@vitejs/plugin-react": "^4.7.0",
+    "@vitejs/plugin-react": "^6.0.2",
     "drizzle-kit": "^0.31.10",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.4.10",
-    "typescript": "^5.9.3",
-    "vite": "^5.4.21"
+    "jest": "^30.4.2",
+    "ts-jest": "^29.4.11",
+    "typescript": "^6.0.3",
+    "vite": "^8.0.16"
   },
   "gitHead": "d935eefa5aa8d1009a2398cfac2c1e4ee9aeb6b6",
   "publishConfig": {

package/src/PostgresAdapter.ts

@@ -1,55 +1,54 @@
 import { DatabaseAdapter, InitializedDriver, RealtimeProvider, DataDriver, DatabaseAdmin, BootstrappedAuth } from "@rebasepro/types";
 import { createPostgresBootstrapper } from "./PostgresBootstrapper";
-// @ts-ignore
-import type { PostgresDriverConfig } from "@rebasepro/server-core";
+import type { PostgresDriverConfig } from "./PostgresBootstrapper";
 
 /**
  * Creates a Postgres database adapter for Rebase.
  */
 export function createPostgresAdapter(pgConfig: PostgresDriverConfig): DatabaseAdapter {
     const bootstrapper = createPostgresBootstrapper(pgConfig);
-    
+
     return {
         type: bootstrapper.type,
-        
+
         async initializeDriver(config) {
             return bootstrapper.initializeDriver(config);
         },
-        
+
         async initializeRealtime(driverResult) {
             if (bootstrapper.initializeRealtime) {
                 return bootstrapper.initializeRealtime({}, driverResult);
             }
             return undefined;
         },
-        
+
         async initializeAuth(config, driverResult) {
             if (bootstrapper.initializeAuth) {
                 return bootstrapper.initializeAuth(config, driverResult);
             }
             return undefined;
         },
-        
+
         async initializeHistory(config, driverResult) {
             if (bootstrapper.initializeHistory) {
                 return bootstrapper.initializeHistory(config, driverResult);
             }
             return undefined;
         },
-        
+
         initializeWebsockets(server, realtimeService, driver, config) {
             if (bootstrapper.initializeWebsockets) {
                 return bootstrapper.initializeWebsockets(server, realtimeService, driver, config);
             }
         },
-        
+
         getAdmin(driverResult) {
             if (bootstrapper.getAdmin) {
                 return bootstrapper.getAdmin(driverResult);
             }
             return undefined;
         },
-        
+
         mountRoutes(app, basePath, driverResult) {
             if (bootstrapper.mountRoutes) {
                 bootstrapper.mountRoutes(app, basePath, driverResult);