@taladb/sync-mongodb 0.8.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 thinkgrid-labs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.mts

@@ -0,0 +1,56 @@
+import { SyncAdapter, SerializedChangeset } from 'taladb';
+import { Collection } from 'mongodb';
+
+interface MongoSyncAdapterOptions {
+    /**
+     * The MongoDB collection to use as the change store. Create it from your own
+     * `MongoClient` so the app owns the connection lifecycle. Index `changed_at`
+     * for pull performance: `await collection.createIndex({ changed_at: 1 })`.
+     */
+    collection: Collection;
+}
+/**
+ * A {@link SyncAdapter} backed by MongoDB. Pair with `db.sync()`:
+ *
+ * ```ts
+ * import { MongoClient } from 'mongodb';
+ * import { MongoSyncAdapter } from '@taladb/sync-mongodb';
+ *
+ * const client = new MongoClient(process.env.MONGO_URI!);
+ * await client.connect();
+ * const store = client.db('sync').collection('taladb_changes');
+ * const adapter = new MongoSyncAdapter({ collection: store });
+ *
+ * await db.sync(adapter, { collections: ['notes'] });
+ * ```
+ *
+ * Or let the adapter open the connection for you with {@link MongoSyncAdapter.connect}.
+ */
+declare class MongoSyncAdapter implements SyncAdapter {
+    private readonly store;
+    constructor(options: MongoSyncAdapterOptions);
+    /**
+     * Convenience: open a MongoDB connection from a URI and return a ready
+     * adapter plus a `close()` to release it. Creates the `changed_at` index.
+     *
+     * ```ts
+     * const { adapter, close } = await MongoSyncAdapter.connect({
+     *   uri: process.env.MONGO_URI!, db: 'sync',
+     * });
+     * await db.sync(adapter, { collections: ['notes'] });
+     * await close();
+     * ```
+     */
+    static connect(opts: {
+        uri: string;
+        db: string;
+        collection?: string;
+    }): Promise<{
+        adapter: MongoSyncAdapter;
+        close: () => Promise<void>;
+    }>;
+    push(changeset: SerializedChangeset): Promise<void>;
+    pull(sinceMs: number): Promise<SerializedChangeset>;
+}
+
+export { MongoSyncAdapter, type MongoSyncAdapterOptions };

package/dist/index.d.ts

@@ -0,0 +1,56 @@
+import { SyncAdapter, SerializedChangeset } from 'taladb';
+import { Collection } from 'mongodb';
+
+interface MongoSyncAdapterOptions {
+    /**
+     * The MongoDB collection to use as the change store. Create it from your own
+     * `MongoClient` so the app owns the connection lifecycle. Index `changed_at`
+     * for pull performance: `await collection.createIndex({ changed_at: 1 })`.
+     */
+    collection: Collection;
+}
+/**
+ * A {@link SyncAdapter} backed by MongoDB. Pair with `db.sync()`:
+ *
+ * ```ts
+ * import { MongoClient } from 'mongodb';
+ * import { MongoSyncAdapter } from '@taladb/sync-mongodb';
+ *
+ * const client = new MongoClient(process.env.MONGO_URI!);
+ * await client.connect();
+ * const store = client.db('sync').collection('taladb_changes');
+ * const adapter = new MongoSyncAdapter({ collection: store });
+ *
+ * await db.sync(adapter, { collections: ['notes'] });
+ * ```
+ *
+ * Or let the adapter open the connection for you with {@link MongoSyncAdapter.connect}.
+ */
+declare class MongoSyncAdapter implements SyncAdapter {
+    private readonly store;
+    constructor(options: MongoSyncAdapterOptions);
+    /**
+     * Convenience: open a MongoDB connection from a URI and return a ready
+     * adapter plus a `close()` to release it. Creates the `changed_at` index.
+     *
+     * ```ts
+     * const { adapter, close } = await MongoSyncAdapter.connect({
+     *   uri: process.env.MONGO_URI!, db: 'sync',
+     * });
+     * await db.sync(adapter, { collections: ['notes'] });
+     * await close();
+     * ```
+     */
+    static connect(opts: {
+        uri: string;
+        db: string;
+        collection?: string;
+    }): Promise<{
+        adapter: MongoSyncAdapter;
+        close: () => Promise<void>;
+    }>;
+    push(changeset: SerializedChangeset): Promise<void>;
+    pull(sinceMs: number): Promise<SerializedChangeset>;
+}
+
+export { MongoSyncAdapter, type MongoSyncAdapterOptions };

package/dist/index.js

@@ -0,0 +1,97 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  MongoSyncAdapter: () => MongoSyncAdapter
+});
+module.exports = __toCommonJS(index_exports);
+var MongoSyncAdapter = class _MongoSyncAdapter {
+  constructor(options) {
+    this.store = options.collection;
+  }
+  /**
+   * Convenience: open a MongoDB connection from a URI and return a ready
+   * adapter plus a `close()` to release it. Creates the `changed_at` index.
+   *
+   * ```ts
+   * const { adapter, close } = await MongoSyncAdapter.connect({
+   *   uri: process.env.MONGO_URI!, db: 'sync',
+   * });
+   * await db.sync(adapter, { collections: ['notes'] });
+   * await close();
+   * ```
+   */
+  static async connect(opts) {
+    const { MongoClient } = await import("mongodb");
+    const client = new MongoClient(opts.uri);
+    await client.connect();
+    const store = client.db(opts.db).collection(opts.collection ?? "taladb_changes");
+    await store.createIndex({ changed_at: 1 });
+    return {
+      adapter: new _MongoSyncAdapter({ collection: store }),
+      close: () => client.close()
+    };
+  }
+  async push(changeset) {
+    const changes = JSON.parse(changeset);
+    if (changes.length === 0) return;
+    const ops = changes.map((chg) => {
+      const key = `${chg.collection}::${chg.id}`;
+      return {
+        updateOne: {
+          filter: { _id: key },
+          update: [
+            {
+              $replaceWith: {
+                $cond: [
+                  { $gt: [chg.changed_at, { $ifNull: ["$changed_at", -1] }] },
+                  { _id: key, changed_at: chg.changed_at, change: JSON.stringify(chg) },
+                  "$$ROOT"
+                ]
+              }
+            }
+          ],
+          upsert: true
+        }
+      };
+    });
+    await this.store.bulkWrite(ops, { ordered: false });
+  }
+  async pull(sinceMs) {
+    const rows = await this.store.find({ changed_at: { $gt: sinceMs } }).sort({ changed_at: 1 }).toArray();
+    if (rows.length === 0) return "[]";
+    return `[${rows.map((r) => r.change).join(",")}]`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  MongoSyncAdapter
+});

package/dist/index.mjs

@@ -0,0 +1,62 @@
+// src/index.ts
+var MongoSyncAdapter = class _MongoSyncAdapter {
+  constructor(options) {
+    this.store = options.collection;
+  }
+  /**
+   * Convenience: open a MongoDB connection from a URI and return a ready
+   * adapter plus a `close()` to release it. Creates the `changed_at` index.
+   *
+   * ```ts
+   * const { adapter, close } = await MongoSyncAdapter.connect({
+   *   uri: process.env.MONGO_URI!, db: 'sync',
+   * });
+   * await db.sync(adapter, { collections: ['notes'] });
+   * await close();
+   * ```
+   */
+  static async connect(opts) {
+    const { MongoClient } = await import("mongodb");
+    const client = new MongoClient(opts.uri);
+    await client.connect();
+    const store = client.db(opts.db).collection(opts.collection ?? "taladb_changes");
+    await store.createIndex({ changed_at: 1 });
+    return {
+      adapter: new _MongoSyncAdapter({ collection: store }),
+      close: () => client.close()
+    };
+  }
+  async push(changeset) {
+    const changes = JSON.parse(changeset);
+    if (changes.length === 0) return;
+    const ops = changes.map((chg) => {
+      const key = `${chg.collection}::${chg.id}`;
+      return {
+        updateOne: {
+          filter: { _id: key },
+          update: [
+            {
+              $replaceWith: {
+                $cond: [
+                  { $gt: [chg.changed_at, { $ifNull: ["$changed_at", -1] }] },
+                  { _id: key, changed_at: chg.changed_at, change: JSON.stringify(chg) },
+                  "$$ROOT"
+                ]
+              }
+            }
+          ],
+          upsert: true
+        }
+      };
+    });
+    await this.store.bulkWrite(ops, { ordered: false });
+  }
+  async pull(sinceMs) {
+    const rows = await this.store.find({ changed_at: { $gt: sinceMs } }).sort({ changed_at: 1 }).toArray();
+    if (rows.length === 0) return "[]";
+    return `[${rows.map((r) => r.change).join(",")}]`;
+  }
+};
+export {
+  MongoSyncAdapter
+};

package/package.json

@@ -0,0 +1,58 @@
+{
+  "name": "@taladb/sync-mongodb",
+  "version": "0.8.4",
+  "description": "MongoDB bidirectional sync adapter for TalaDB — sync a local TalaDB with a MongoDB collection, no intermediate API",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "keywords": [
+    "taladb",
+    "mongodb",
+    "sync",
+    "replication",
+    "local-first",
+    "offline"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thinkgrid-labs/taladb.git",
+    "directory": "packages/adapters/mongodb"
+  },
+  "homepage": "https://thinkgrid-labs.github.io/taladb/guide/bidirectional-sync",
+  "bugs": {
+    "url": "https://github.com/thinkgrid-labs/taladb/issues"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "peerDependencies": {
+    "mongodb": ">=5.0.0",
+    "taladb": "^0.8.4"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "mongodb": "^6.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.9.3",
+    "vitest": "^3.2.0",
+    "taladb": "0.8.4"
+  },
+  "scripts": {
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  }
+}