@rebasepro/server-postgres 0.13.1-canary.gcd6689e → 0.13.1-canary.gcef69d4

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-postgres",
   "type": "module",
-  "version": "0.13.1-canary.gcd6689e",
+  "version": "0.13.1-canary.gcef69d4",
   "description": "PostgreSQL data source backend implementation for Rebase with Drizzle ORM",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -47,11 +47,11 @@
     "execa": "^9.6.1",
     "pg": "^8.22.0",
     "ws": "^8.21.1",
-    "@rebasepro/codegen": "0.13.1-canary.gcd6689e",
-    "@rebasepro/common": "0.13.1-canary.gcd6689e",
-    "@rebasepro/types": "0.13.1-canary.gcd6689e",
-    "@rebasepro/utils": "0.13.1-canary.gcd6689e",
-    "@rebasepro/server": "0.13.1-canary.gcd6689e"
+    "@rebasepro/codegen": "0.13.1-canary.gcef69d4",
+    "@rebasepro/server": "0.13.1-canary.gcef69d4",
+    "@rebasepro/types": "0.13.1-canary.gcef69d4",
+    "@rebasepro/common": "0.13.1-canary.gcef69d4",
+    "@rebasepro/utils": "0.13.1-canary.gcef69d4"
   },
   "devDependencies": {
     "@hono/node-server": "^2.0.12",
@@ -60,7 +60,7 @@
     "@types/node": "^26.1.2",
     "@types/pg": "^8.20.0",
     "@types/ws": "^8.18.1",
-    "hono": "^4.12.27",
+    "hono": "^4.13.0",
     "jest": "^30.4.2",
     "ts-jest": "^29.4.12",
     "typescript": "^6.0.3",

package/src/collections/validate-relations.ts

@@ -378,9 +378,25 @@ export function assertRelationsResolve(
     );
 
     throw new Error(
-        `${defects.length} relation${defects.length === 1 ? "" : "s"} cannot resolve against the database schema.\n\n` +
+        `${defects.length} relation${defects.length === 1 ? "" : "s"} cannot resolve against ` +
+        "`backend/src/schema.generated.ts`.\n\n" +
         "Each of these would return no rows at query time rather than reporting an error, " +
         "so they are fatal at boot instead.\n\n" +
+        // This reads the *generated file*, not the database, and the difference
+        // is the whole diagnosis after an upgrade. Boot-ensure renames columns
+        // in the database — a 0.12 → 0.13 upgrade singularises a junction key,
+        // `categorie_id` → `category_id` — and the checked-in file still
+        // declares the old name. The config is then correct and the file is
+        // stale, so the per-defect advice below, which lists the columns this
+        // file has, names a column that no longer exists in the database.
+        // Following it turns a recoverable state into a broken config.
+        //
+        // Hence the ordering: regenerate first, and only then consider that the
+        // collection might be the thing that is wrong.
+        "If the database was migrated recently — an upgrade, a `db push`, a restore — this file is\n" +
+        "probably older than the schema it describes. Regenerate it before changing anything else:\n\n" +
+        "    rebase schema generate\n\n" +
+        "If it is already current, then the collection is what disagrees with it:\n\n" +
         lines.join("\n\n") + "\n"
     );
 }

package/src/data-transformer.ts

@@ -3,6 +3,7 @@ import { AnyPgColumn } from "drizzle-orm/pg-core";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { CollectionConfig, Properties, Property, ResolvedRelation, RelationProperty, Vector, BinaryProperty, hasForeignKeyOnTarget, type ResolvedBelongsTo, type ResolvedForeignKeyOnTarget, type ResolvedVia } from "@rebasepro/types";
 import { getTableName, resolveCollectionRelations, findRelation, createRelationRef, DEFAULT_ONE_OF_TYPE, DEFAULT_ONE_OF_VALUE } from "@rebasepro/common";
+import { isPrototypePollutingKey } from "@rebasepro/utils";
 import { PostgresCollectionRegistry } from "./collections/PostgresCollectionRegistry";
 import { DrizzleConditionBuilder } from "./utils/drizzle-conditions";
 import { getPrimaryKeys, buildCompositeId } from "./services/collection-helpers";
@@ -68,9 +69,15 @@ export function sanitizeAndConvertDates(obj: unknown): unknown {
     if (typeof obj === "object") {
         const newObj: Record<string, unknown> = {};
         for (const key in obj) {
-            if (Object.prototype.hasOwnProperty.call(obj, key)) {
-                newObj[key] = sanitizeAndConvertDates((obj as Record<string, unknown>)[key]);
-            }
+            if (!Object.prototype.hasOwnProperty.call(obj, key)) continue;
+            // `JSON.parse` creates `__proto__` as an *own* property, so it gets
+            // past the check above — and `newObj[key] = …` then invokes the
+            // prototype setter instead of creating a property. The row's
+            // prototype becomes whatever the request body supplied, so
+            // `row.isAdmin` answers `true` while `Object.keys(row)` shows
+            // nothing of the sort. No column can be reached by these names.
+            if (isPrototypePollutingKey(key)) continue;
+            newObj[key] = sanitizeAndConvertDates((obj as Record<string, unknown>)[key]);
         }
         return newObj;
     }
@@ -126,6 +133,9 @@ joinPathRelationUpdates: [] };
     });
 
     for (const [key, value] of Object.entries(row)) {
+        // Same reasoning as `sanitizeAndConvertDates`: these keys come from the
+        // request body, and no column answers to them.
+        if (isPrototypePollutingKey(key)) continue;
         const property = properties[key as keyof M] as Property;
 
         // Coerce empty strings to null for any field that acts as a foreign key

package/src/services/FetchService.ts

@@ -954,6 +954,16 @@ _distance: vectorMeta.distanceSelect }).from(table).$dynamic()
         collectionPath: string,
         options: {
             filter?: FilterValues<Extract<keyof M, string>>;
+            /**
+             * An `or(...)`/`and(...)` group, applied alongside `filter`.
+             *
+             * `fetchRowsWithConditions` below has always applied this; it was
+             * simply absent from this signature, so the only callers that could
+             * pass one were the ones that went around this method. Realtime
+             * came through here, which is why a subscription filtered by a
+             * logical group was pushed every row in the table.
+             */
+            logical?: LogicalCondition;
             orderBy?: string;
             order?: "desc" | "asc";
             limit?: number;

package/src/services/PersistService.ts

@@ -477,7 +477,20 @@ export class PersistService {
         const pgError = extractPgError(error);
 
         if (pgError) {
-            const { message } = pgErrorToFriendlyMessage(pgError, collectionSlug);
+            const { message, code } = pgErrorToFriendlyMessage(pgError, collectionSlug);
+            // This is the only layer that holds the SQLSTATE, so it is the only
+            // one that can say whose fault a failure was. Returning a bare
+            // `Error` threw that away, and the REST layer compensated by calling
+            // *every* unclassified error a 400 — so an unreachable database was
+            // reported to callers as a bad request. Classes 22 (data exception)
+            // and 23 (integrity constraint violation) are the caller's data;
+            // everything else — a dropped connection, a missing column, a
+            // permission problem — is ours, and stays a 500.
+            if (/^2[23]/.test(code)) {
+                return code === "23505"
+                    ? ApiError.conflict(message, `PG_${code}`)
+                    : ApiError.badRequest(message, `PG_${code}`);
+            }
             return new Error(message);
         }
 

package/src/services/dataService.ts

@@ -60,6 +60,8 @@ export class DataService implements DataRepository {
         collectionPath: string,
         options: {
             filter?: FilterValues<Extract<keyof M, string>>;
+            /** An `or(...)`/`and(...)` group, applied alongside `filter`. */
+            logical?: LogicalCondition;
             orderBy?: string;
             order?: "desc" | "asc";
             limit?: number;

package/src/services/realtimeService.ts

@@ -4,7 +4,7 @@ import { Client as PgClient } from "pg";
 import { randomUUID } from "crypto";
 import { DataService } from "./dataService";
 
-import { ANONYMOUS_USER_ID, FetchCollectionProps, ListenCollectionProps, ListenOneProps, DataDriver, CollectionUpdateMessage, SingleUpdateMessage, CollectionPatchMessage, WebSocketMessage, FilterValues, CollectionConfig, RebaseCallContext, resolveClientListLimit } from "@rebasepro/types";
+import { ANONYMOUS_USER_ID, FetchCollectionProps, ListenCollectionProps, ListenOneProps, DataDriver, CollectionUpdateMessage, SingleUpdateMessage, CollectionPatchMessage, WebSocketMessage, FilterValues, LogicalCondition, CollectionConfig, RebaseCallContext, resolveClientListLimit } from "@rebasepro/types";
 import { NodePgDatabase } from "drizzle-orm/node-postgres";
 import { sql as drizzleSql } from "drizzle-orm";
 import { RealtimeProvider, CollectionSubscriptionConfig, SingleSubscriptionConfig } from "../interfaces";
@@ -41,6 +41,28 @@ type RealTimeListenCollectionProps = ListenCollectionProps & {
     subscriptionId: string
 };
 
+/**
+ * The narrowing a collection subscription was created with, kept so that every
+ * refetch answers the same query the initial fetch did.
+ *
+ * Named once because it used to be written out inline in five places, and a
+ * field missing from one of them is accepted over the wire and then silently
+ * ignored: `offset` was declared on the incoming props and never stored, so a
+ * live list on page three served page one, and `logical` was never stored
+ * either, so an `or(...)` subscription was pushed every row in the table.
+ */
+type StoredCollectionRequest = {
+    filter?: Record<string, unknown>;
+    logical?: LogicalCondition;
+    orderBy?: string;
+    order?: "desc" | "asc";
+    limit?: number;
+    offset?: number;
+    startAfter?: Record<string, unknown>;
+    databaseId?: string;
+    searchString?: string;
+};
+
 type RealTimeListenEntityProps = ListenOneProps & { subscriptionId: string };
 
 /**
@@ -119,16 +141,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
         path: string;
         id?: string | number;
         // Store full collection request parameters for proper refetching
-        collectionRequest?: {
-            filter?: Record<string, unknown>;
-            orderBy?: string;
-            order?: "desc" | "asc";
-            limit?: number;
-            offset?: number;
-            startAfter?: Record<string, unknown>;
-            databaseId?: string;
-            searchString?: string;
-        };
+        collectionRequest?: StoredCollectionRequest;
         // Auth context for RLS — when set, refetches run in a transaction
         // with set_config('app.uid', ...) / set_config('app.user_roles', ...)
         authContext?: SubscriptionAuthContext;
@@ -212,16 +225,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
         type: "collection" | "single";
         path: string;
         id?: string | number;
-        collectionRequest?: {
-            filter?: Record<string, unknown>;
-            orderBy?: string;
-            order?: "desc" | "asc";
-            limit?: number;
-            offset?: number;
-            startAfter?: Record<string, unknown>;
-            databaseId?: string;
-            searchString?: string;
-        };
+        collectionRequest?: StoredCollectionRequest;
         authContext?: SubscriptionAuthContext;
     }) {
         this.debugLog("📋 [RealtimeService] Registering DataDriver subscription:", subscriptionId, subscription.authContext ? "(with auth)" : "(no auth)");
@@ -448,9 +452,11 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 path: request.path,
                 collectionRequest: {
                     filter: request.filter,
+                    logical: request.logical,
                     orderBy: request.orderBy,
                     order: request.order,
                     limit: boundedLimit,
+                    offset: request.offset,
                     startAfter: request.startAfter as Record<string, unknown> | undefined,
                     databaseId: request.collection?.databaseId,
                     searchString: request.searchString
@@ -458,17 +464,12 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 authContext
             });
 
-            // Send initial data
+            // Send initial data. Built from the request the subscription just
+            // stored, so the first answer and every refetch after it cannot
+            // describe different queries.
             const rows = await this.fetchCollectionWithAuth(
                 request.path,
-                {
-                    filter: request.filter,
-                    orderBy: request.orderBy,
-                    order: request.order,
-                    limit: boundedLimit,
-                    startAfter: request.startAfter as Record<string, unknown> | undefined,
-                    searchString: request.searchString
-                },
+                this._subscriptions.get(subscriptionId)!.collectionRequest!,
                 authContext
             );
 
@@ -679,7 +680,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
     private debouncedCollectionRefetch(
         subscriptionId: string,
         notifyPath: string,
-        subscription: { clientId: string; collectionRequest?: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; offset?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string }; authContext?: SubscriptionAuthContext }
+        subscription: { clientId: string; collectionRequest?: StoredCollectionRequest; authContext?: SubscriptionAuthContext }
     ) {
         const timerKey = `ws_${subscriptionId}`;
         const existing = this.refetchTimers.get(timerKey);
@@ -705,7 +706,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
     private debouncedDriverRefetch(
         subscriptionId: string,
         notifyPath: string,
-        subscription: { collectionRequest?: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; offset?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string }; authContext?: SubscriptionAuthContext },
+        subscription: { collectionRequest?: StoredCollectionRequest; authContext?: SubscriptionAuthContext },
         callback: (data: Record<string, unknown>[] | Record<string, unknown> | null) => void
     ) {
         const timerKey = `drv_${subscriptionId}`;
@@ -731,7 +732,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
      */
     private async fetchCollectionWithAuth(
         notifyPath: string,
-        collectionRequest: { filter?: Record<string, unknown>; orderBy?: string; order?: "desc" | "asc"; limit?: number; offset?: number; startAfter?: Record<string, unknown>; databaseId?: string; searchString?: string },
+        collectionRequest: StoredCollectionRequest,
         authContext?: SubscriptionAuthContext
     ): Promise<Record<string, unknown>[]> {
         if (this.driver) {
@@ -740,6 +741,7 @@ export class RealtimeService extends EventEmitter implements RealtimeProvider {
                 path: notifyPath,
                 collection: collection,
                 filter: collectionRequest.filter as FetchCollectionProps["filter"],
+                logical: collectionRequest.logical,
                 orderBy: collectionRequest.orderBy,
                 order: collectionRequest.order,
                 limit: collectionRequest.limit,
@@ -772,6 +774,7 @@ roles: ["anon"] };
                 } else {
                     fetchedEntities = await txEntityService.fetchCollection(notifyPath, {
                         filter: collectionRequest.filter as FilterValues<string>,
+                        logical: collectionRequest.logical,
                         orderBy: collectionRequest.orderBy,
                         order: collectionRequest.order,
                         limit: collectionRequest.limit,