@rebasepro/server-mongo 0.16.0 → 0.16.1-canary.g0d7af95

package/dist/schema/plan-schema-change.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Planning a collection change for MongoDB.
+ *
+ * Shorter than the Postgres one by the whole of its difficulty. A document
+ * database has no table to alter: adding a property adds nothing, removing one
+ * removes nothing, and a document written yesterday is still valid tomorrow. So
+ * the plan is the commit, and there is no DDL to run, refuse or get wrong.
+ *
+ * ## Why this exists at all, rather than leaving Mongo unsupported
+ *
+ * Because "unsupported" was the wrong answer, and it was the answer only
+ * because nothing had been written here. `isSchemaEditingAdmin` is a structural
+ * check — a driver either offers `planSchemaChange` or it does not — so a Mongo
+ * project got `SCHEMA_EDITING_UNSUPPORTED` and fell back to the source-only
+ * editor, which is off in production. A schemaless database is the one place
+ * where changing a collection against a *running* backend is completely safe,
+ * and it was the one place it did not work.
+ *
+ * ## What a verdict means here
+ *
+ * Every change is `safe`, because none of them can fail. That is not the
+ * classifier being lax: on Postgres a verdict answers "will the database end up
+ * matching this configuration", and here it always does — there is nothing in
+ * the database that describes the shape.
+ *
+ * What the changes still say is what happens to the **data**, because that is
+ * the part a reader can be surprised by. Removing a property does not delete
+ * the field from documents that have it; those documents keep it and the API
+ * stops serving it. Saying so is the difference between a reader who knows the
+ * data is still there and one who assumes it is gone.
+ */
+import type { CollectionConfig, SchemaChange, SchemaChangePlan } from "@rebasepro/types";
+/**
+ * What changed, in the terms a document database makes true.
+ *
+ * Exported because it is the interesting half and worth testing without a
+ * driver: the shape of the answer is the product, and the rest is plumbing.
+ */
+export declare function classifyMongoChanges(before: CollectionConfig[], after: CollectionConfig[]): SchemaChange[];
+/**
+ * The plan: a commit, and nothing to run.
+ *
+ * `files` is empty here and filled by the caller with the rewritten collection
+ * source. Postgres adds generated artifacts — a Drizzle schema, declarative
+ * DDL — because a stale one breaks the next deploy. MongoDB generates none, so
+ * the collection file is the whole of the change.
+ */
+export declare function planMongoSchemaChange(before: CollectionConfig[], after: CollectionConfig[]): Promise<SchemaChangePlan>;
+//# sourceMappingURL=plan-schema-change.d.ts.map

package/dist/schema/plan-schema-change.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-schema-change.d.ts","sourceRoot":"","sources":["../../src/schema/plan-schema-change.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,OAAO,KAAK,EACR,gBAAgB,EAChB,YAAY,EACZ,gBAAgB,EACnB,MAAM,kBAAkB,CAAC;AAa1B;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAChC,MAAM,EAAE,gBAAgB,EAAE,EAC1B,KAAK,EAAE,gBAAgB,EAAE,GAC1B,YAAY,EAAE,CA4DhB;AAqBD;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CACvC,MAAM,EAAE,gBAAgB,EAAE,EAC1B,KAAK,EAAE,gBAAgB,EAAE,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CAS3B"}

package/dist/services/MongoDriver.d.ts

@@ -6,9 +6,9 @@
  */
 import { Db } from "mongodb";
 import { DataDriver, DeleteProps, CollectionConfig, FetchCollectionProps, FetchOneProps, ListenCollectionProps, ListenOneProps, SaveProps, CollectionRegistryInterface, User, RebaseClient, RebaseSdkData } from "@rebasepro/types";
-import { MongoDataService } from "../db/MongoDataService";
-import { MongoRealtimeService } from "./MongoRealtimeService";
-import { MongoHistoryService } from "./MongoHistoryService";
+import { MongoDataService } from "../db/MongoDataService.js";
+import { MongoRealtimeService } from "./MongoRealtimeService.js";
+import { MongoHistoryService } from "./MongoHistoryService.js";
 /**
  * MongoDB DataDriver Delegate
  *

package/dist/services/MongoHistoryService.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MongoHistoryService.d.ts","sourceRoot":"","sources":["../../src/services/MongoHistoryService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AA0BvC;;GAEG;AACH,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,EAAE,GAAG,IAAI,CA8BjB;AAED,YAAY,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAExG;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC;IAChF,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,IAAI,CAAC;CACpB;AAOD,qBAAa,mBAAmB;IAIxB,OAAO,CAAC,EAAE;IAHP,SAAS,EAAE,sBAAsB,CAAC;gBAG7B,EAAE,EAAE,EAAE,EACd,SAAS,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC;IAMzC,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;YA0CjD,YAAY;CA+B7B"}
+{"version":3,"file":"MongoHistoryService.d.ts","sourceRoot":"","sources":["../../src/services/MongoHistoryService.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,EAAE,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AA0BvC;;GAEG;AACH,wBAAgB,iBAAiB,CAC7B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAClC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GACnC,MAAM,EAAE,GAAG,IAAI,CA8BjB;AAED,YAAY,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AACpF,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,sBAAsB,EAAE,MAAM,kBAAkB,CAAC;AAExG;;;;;;;;GAQG;AACH,MAAM,WAAW,oBAAqB,SAAQ,IAAI,CAAC,kBAAkB,EAAE,YAAY,CAAC;IAChF,GAAG,CAAC,EAAE,QAAQ,CAAC;IACf,UAAU,EAAE,IAAI,CAAC;CACpB;AAOD,qBAAa,mBAAmB;IAIxB,OAAO,CAAC,EAAE;IAHP,SAAS,EAAE,sBAAsB,CAAC;gBAG7B,EAAE,EAAE,EAAE,EACd,SAAS,CAAC,EAAE,OAAO,CAAC,sBAAsB,CAAC;IAMzC,aAAa,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC;YA0CjD,YAAY;CA8C7B"}

package/dist/services/MongoRealtimeService.d.ts

@@ -7,7 +7,7 @@
 import { Db, ChangeStream } from "mongodb";
 import { RealtimeProvider, CollectionSubscriptionConfig, SingleSubscriptionConfig } from "@rebasepro/types";
 import { WebSocket } from "ws";
-import type { MongoDriver } from "./MongoDriver";
+import type { MongoDriver } from "./MongoDriver.js";
 /** The acting user for a subscription, as the driver and the socket carry it. */
 export interface SubscriptionAuthContext {
     uid: string;

package/dist/websocket.d.ts

@@ -1,7 +1,7 @@
 import { DatabaseAdmin, AuthAdapter } from "@rebasepro/types";
 import { Server } from "http";
 import type { RebaseAuthConfig } from "@rebasepro/server";
-import { MongoRealtimeService } from "./services/MongoRealtimeService";
-import { MongoDriver } from "./services/MongoDriver";
+import { MongoRealtimeService } from "./services/MongoRealtimeService.js";
+import { MongoDriver } from "./services/MongoDriver.js";
 export declare function createMongoWebSocket(server: Server, realtimeService: MongoRealtimeService, driver: MongoDriver, authConfig?: RebaseAuthConfig, admin?: DatabaseAdmin, authAdapter?: AuthAdapter): void;
 //# sourceMappingURL=websocket.d.ts.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rebasepro/server-mongo",
   "type": "module",
-  "version": "0.16.0",
+  "version": "0.16.1-canary.g0d7af95",
   "description": "MongoDB backend for Rebase",
   "funding": {
     "url": "https://github.com/sponsors/rebaseco"
@@ -40,9 +40,9 @@
   "dependencies": {
     "mongodb": "^7.5.0",
     "ws": "^8.21.1",
-    "@rebasepro/common": "0.16.0",
-    "@rebasepro/types": "0.16.0",
-    "@rebasepro/utils": "0.16.0"
+    "@rebasepro/common": "0.16.1-canary.g0d7af95",
+    "@rebasepro/types": "0.16.1-canary.g0d7af95",
+    "@rebasepro/utils": "0.16.1-canary.g0d7af95"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",
@@ -55,7 +55,7 @@
     "vite": "^8.1.5"
   },
   "peerDependencies": {
-    "@rebasepro/server": "0.16.0"
+    "@rebasepro/server": "0.16.1-canary.g0d7af95"
   },
   "peerDependenciesMeta": {
     "@rebasepro/server": {
@@ -72,7 +72,7 @@
   },
   "scripts": {
     "watch": "vite build --watch",
-    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json && node ../../scripts/assert-build-output.mjs",
+    "build": "vite build && tsc --emitDeclarationOnly -p tsconfig.prod.json && node ../../tooling/scripts/add-dts-extensions.mjs dist && node ../../tooling/scripts/assert-build-output.mjs",
     "test:lint": "eslint \"src/**\" --quiet",
     "test": "jest --passWithNoTests --forceExit",
     "clean": "rm -rf dist && find ./src -name '*.js' -type f | xargs rm -f"

package/src/factory.ts

@@ -13,7 +13,8 @@ import { MongoRealtimeService } from "./services/MongoRealtimeService";
 import { MongoDriver } from "./services/MongoDriver";
 import { MongoHistoryService, HistoryRetentionConfig } from "./services/MongoHistoryService";
 import { MongoDBConnection } from "./connection";
-import { BackendConfig, BackendInstance, CollectionRegistryInterface, DataRepository, RealtimeProvider, DatabaseConnection, DatabaseAdmin, DocumentAdmin, SchemaAdmin, HealthCheckResult } from "@rebasepro/types";
+import { BackendConfig, BackendInstance, CollectionRegistryInterface, DataRepository, RealtimeProvider, DatabaseConnection, DatabaseAdmin, DocumentAdmin, SchemaAdmin, SchemaEditingAdmin, HealthCheckResult } from "@rebasepro/types";
+import { planMongoSchemaChange } from "./schema/plan-schema-change";
 
 /**
  * Configuration for creating a MongoDB backend.
@@ -161,6 +162,15 @@ export function createMongoBackend(config: MongoBackendConfig): MongoBackendInst
 
     // Build admin capabilities for MongoDB
     const admin: DatabaseAdmin = {
+        // A document database has no table to alter, so a collection change is
+        // the commit and nothing else. Offered here because `isSchemaEditingAdmin`
+        // is a structural check: without this method a Mongo project was told
+        // live schema editing was *unsupported*, when it is the one place the
+        // change cannot fail.
+        planSchemaChange: async (before, after) => planMongoSchemaChange(
+            before as CollectionConfig[],
+            after as CollectionConfig[]
+        ),
         async executeAggregate(pipeline: Record<string, unknown>[]) {
             // Run aggregation on a collection — requires a target collection
             // from the pipeline's $match or $lookup stage:
@@ -201,7 +211,10 @@ foreignKeys: [],
 junctions: [],
 policies: [] };
         }
-    } satisfies DocumentAdmin & SchemaAdmin;
+        // `satisfies` narrows the literal regardless of the annotation above, so
+        // the schema-editing method has to be named here too or it reads as an
+        // excess property.
+    } satisfies DocumentAdmin & SchemaAdmin & SchemaEditingAdmin;
 
     return {
         // Abstract interface implementations

package/src/schema/plan-schema-change.ts

@@ -0,0 +1,159 @@
+/**
+ * Planning a collection change for MongoDB.
+ *
+ * Shorter than the Postgres one by the whole of its difficulty. A document
+ * database has no table to alter: adding a property adds nothing, removing one
+ * removes nothing, and a document written yesterday is still valid tomorrow. So
+ * the plan is the commit, and there is no DDL to run, refuse or get wrong.
+ *
+ * ## Why this exists at all, rather than leaving Mongo unsupported
+ *
+ * Because "unsupported" was the wrong answer, and it was the answer only
+ * because nothing had been written here. `isSchemaEditingAdmin` is a structural
+ * check — a driver either offers `planSchemaChange` or it does not — so a Mongo
+ * project got `SCHEMA_EDITING_UNSUPPORTED` and fell back to the source-only
+ * editor, which is off in production. A schemaless database is the one place
+ * where changing a collection against a *running* backend is completely safe,
+ * and it was the one place it did not work.
+ *
+ * ## What a verdict means here
+ *
+ * Every change is `safe`, because none of them can fail. That is not the
+ * classifier being lax: on Postgres a verdict answers "will the database end up
+ * matching this configuration", and here it always does — there is nothing in
+ * the database that describes the shape.
+ *
+ * What the changes still say is what happens to the **data**, because that is
+ * the part a reader can be surprised by. Removing a property does not delete
+ * the field from documents that have it; those documents keep it and the API
+ * stops serving it. Saying so is the difference between a reader who knows the
+ * data is still there and one who assumes it is gone.
+ */
+import type {
+    CollectionConfig,
+    SchemaChange,
+    SchemaChangePlan
+} from "@rebasepro/types";
+
+const bySlug = (collections: CollectionConfig[]): Map<string, CollectionConfig> => {
+    const map = new Map<string, CollectionConfig>();
+    for (const collection of collections) {
+        if (collection.slug) map.set(collection.slug, collection);
+    }
+    return map;
+};
+
+const propertiesOf = (collection: CollectionConfig): Record<string, unknown> =>
+    (collection.properties ?? {}) as Record<string, unknown>;
+
+/**
+ * What changed, in the terms a document database makes true.
+ *
+ * Exported because it is the interesting half and worth testing without a
+ * driver: the shape of the answer is the product, and the rest is plumbing.
+ */
+export function classifyMongoChanges(
+    before: CollectionConfig[],
+    after: CollectionConfig[]
+): SchemaChange[] {
+    const previous = bySlug(before);
+    const next = bySlug(after);
+    const changes: SchemaChange[] = [];
+
+    for (const [slug, collection] of next) {
+        if (!previous.has(slug)) {
+            changes.push({
+                kind: "add-collection",
+                verdict: "safe",
+                collection: slug,
+                detail: `New collection "${slug}". MongoDB creates it on the first write; nothing ` +
+                    "is created now."
+            });
+            continue;
+        }
+
+        const oldProps = propertiesOf(previous.get(slug)!);
+        const newProps = propertiesOf(collection);
+
+        for (const name of Object.keys(newProps)) {
+            if (name in oldProps) continue;
+            changes.push({
+                kind: "add-property",
+                verdict: "safe",
+                collection: slug,
+                property: name,
+                detail: `New property "${name}". Existing documents do not have it and are not ` +
+                    "rewritten; reads return it as absent until something writes it."
+            });
+        }
+
+        for (const name of Object.keys(oldProps)) {
+            if (name in newProps) continue;
+            changes.push({
+                kind: "remove-property",
+                verdict: "safe",
+                collection: slug,
+                property: name,
+                // The one thing worth being explicit about. On Postgres this is
+                // refused because it would drop a column; here nothing is
+                // dropped, and a reader who assumes otherwise has it backwards.
+                detail: `"${name}" is no longer served. Documents that have it keep it — MongoDB ` +
+                    "stores no schema, so nothing is removed from the data."
+            });
+        }
+    }
+
+    for (const [slug] of previous) {
+        if (next.has(slug)) continue;
+        changes.push({
+            kind: "remove-collection",
+            verdict: "safe",
+            collection: slug,
+            detail: `Collection "${slug}" is no longer served. The MongoDB collection and every ` +
+                "document in it are left exactly as they are."
+        });
+    }
+
+    return changes;
+}
+
+/** A commit message that says what changed rather than that something did. */
+function commitMessage(changes: SchemaChange[]): string {
+    if (changes.length === 0) return "chore(schema): no change";
+
+    const collections = [...new Set(changes.map(c => c.collection))].sort();
+    const added = changes.filter(c => c.kind === "add-collection");
+    const properties = changes.filter(c => c.kind === "add-property");
+
+    const subject = added.length === 1 && changes.length === 1
+        ? `add the ${added[0].collection} collection`
+        : properties.length === 1 && changes.length === 1
+            ? `add ${properties[0].property} to ${properties[0].collection}`
+            : collections.length === 1
+                ? `${changes.length} change(s) to ${collections[0]}`
+                : `${changes.length} change(s) across ${collections.length} collections`;
+
+    return `feat(schema): ${subject}\n\n${changes.map(c => `- ${c.detail}`).join("\n")}\n`;
+}
+
+/**
+ * The plan: a commit, and nothing to run.
+ *
+ * `files` is empty here and filled by the caller with the rewritten collection
+ * source. Postgres adds generated artifacts — a Drizzle schema, declarative
+ * DDL — because a stale one breaks the next deploy. MongoDB generates none, so
+ * the collection file is the whole of the change.
+ */
+export async function planMongoSchemaChange(
+    before: CollectionConfig[],
+    after: CollectionConfig[]
+): Promise<SchemaChangePlan> {
+    const changes = classifyMongoChanges(before, after);
+    return {
+        files: [],
+        statements: [],
+        classified: { changes, verdict: "safe", applicable: true },
+        message: commitMessage(changes),
+        withheldConstraints: []
+    };
+}

package/src/services/MongoHistoryService.ts

@@ -141,21 +141,36 @@ export class MongoHistoryService {
         const collection = this.db.collection("__rebase_history");
 
         // 1. Enforce maxEntries
-        const count = await collection.countDocuments({ entity_id: id,
-table_name: tableName });
-        if (count > this.retention.maxEntries) {
-            const toDelete = count - this.retention.maxEntries;
-            const oldestEntries = await collection
-                .find({ entity_id: id,
+        //
+        // One read decides both WHICH rows go and HOW MANY. It used to be two:
+        // countDocuments gave a quantity, and a second find(...).limit(quantity)
+        // chose the victims. recordHistory fires this without awaiting it, so a
+        // row updated twice in quick succession runs two prunes at once — and
+        // the quantity from one snapshot was applied to another. Both observe
+        // three rows and decide "drop one"; the first deletes the oldest, the
+        // second re-reads, now sees a different oldest, and deletes that too.
+        // Two rows go where one should have, and the history falls BELOW
+        // maxEntries. Observed as "Expected length: 2, Received length: 1".
+        //
+        // Sorting newest-first and skipping maxEntries names the survivors by
+        // position instead, so every _id returned was genuinely surplus at a
+        // single consistent read. A concurrent prune that already removed some
+        // of them makes the delete a no-op; a concurrent insert is simply not
+        // in this snapshot, and the prune that insert fires deals with it.
+        //
+        // _id breaks ties on updated_at. Two writes inside the same millisecond
+        // are otherwise ordered arbitrarily, and an unstable sort under skip()
+        // can hand back a row that is not surplus at all.
+        const surplus = await collection
+            .find({ entity_id: id,
 table_name: tableName })
-                .sort({ updated_at: 1 })
-                .limit(toDelete)
-                .toArray();
+            .sort({ updated_at: -1,
+_id: -1 })
+            .skip(this.retention.maxEntries)
+            .toArray();
 
-            if (oldestEntries.length > 0) {
-                const idsToDelete = oldestEntries.map(entry => entry._id);
-                await collection.deleteMany({ _id: { $in: idsToDelete } });
-            }
+        if (surplus.length > 0) {
+            await collection.deleteMany({ _id: { $in: surplus.map(entry => entry._id) } });
         }
 
         // 2. Enforce ttlDays