@semics-tech/mongolite 1.3.0 → 1.4.1

package/dist/server.js

@@ -0,0 +1,158 @@
+/**
+ * Server-side entry point: receives sync messages from a MongoLite client and applies
+ * them to MongoDB.
+ *
+ * Install this on the API that sits in front of your database, for deployments where
+ * the local instance cannot reach MongoDB directly.
+ *
+ * ```ts
+ * import { MongoClient } from 'mongodb';
+ * import { createSyncReceiver } from '@semics-tech/mongolite/server';
+ *
+ * const mongo = await new MongoClient(process.env.MONGO_URL!).connect();
+ * const receiver = createSyncReceiver({
+ *   client: mongo,
+ *   database: 'app',
+ *   allowedCollections: ['users', 'orders'],
+ * });
+ *
+ * app.post('/sync/app/_sync', async (req, res) => {
+ *   const result = await receiver.apply(req.body);
+ *   res.status(result.status).type('application/json').send(result.body);
+ * });
+ * ```
+ *
+ * This module imports nothing SQLite-related, so it is safe to install on a server that
+ * has no local database of its own.
+ */
+import { buildWriteCommand } from './sync/commands.js';
+import { executeWrites, fetchDocuments } from './sync/mongoExecutor.js';
+import { SYNC_PROTOCOL_VERSION, SyncProtocolError, decodeBody, encodeBody, parseApplyRequest, parseFetchRequest, } from './sync/protocol.js';
+export { SYNC_PROTOCOL_VERSION, SyncProtocolError } from './sync/protocol.js';
+const JSON_HEADERS = { 'content-type': 'application/json' };
+export class SyncReceiver {
+    constructor(options) {
+        this.options = options;
+        if (!options.client)
+            throw new Error('createSyncReceiver requires a connected `client`.');
+        this.db = options.client.db(options.database);
+    }
+    /**
+     * Applies a batch of operations.
+     *
+     * @param body The raw request body — a string, or an already-parsed object.
+     * @returns Status and Extended JSON body to send back.
+     */
+    async apply(body) {
+        try {
+            const decoded = decodeBody(body);
+            const { replicator, operations } = parseApplyRequest(decoded);
+            const maxOperations = this.options.maxOperations ?? 1000;
+            if (operations.length > maxOperations) {
+                throw new SyncProtocolError(`Batch of ${operations.length} exceeds the limit of ${maxOperations}`, 413);
+            }
+            const collections = [...new Set(operations.map((op) => op.collection))];
+            this.assertCollectionsAllowed(collections);
+            await this.authorise({ replicator, collections, operationCount: operations.length });
+            const writes = operations.map((op, index) => ({
+                index,
+                op,
+                command: this.commandFor(op, decoded, index),
+            }));
+            const result = await executeWrites(this.db, writes, {
+                writeConcern: this.options.writeConcern ?? { w: 'majority' },
+                versioning: this.options.versioning ?? true,
+                idMapping: this.options.idMapping,
+                ObjectId: this.options.ObjectId,
+            });
+            return this.ok({
+                protocol: SYNC_PROTOCOL_VERSION,
+                applied: result.applied,
+                failures: result.failures,
+                conflicts: result.conflicts,
+            });
+        }
+        catch (err) {
+            return this.error(err);
+        }
+    }
+    /** Reads documents back by `_id`, so a client can refresh its shadow after a conflict. */
+    async fetch(body) {
+        try {
+            const { collection, documentIds } = parseFetchRequest(decodeBody(body));
+            this.assertCollectionsAllowed([collection]);
+            await this.authorise({
+                replicator: 'fetch',
+                collections: [collection],
+                operationCount: documentIds.length,
+            });
+            const documents = await fetchDocuments(this.db, collection, documentIds, this.options.idMapping, this.options.ObjectId);
+            return this.ok({ protocol: SYNC_PROTOCOL_VERSION, documents });
+        }
+        catch (err) {
+            return this.error(err);
+        }
+    }
+    // ---------------------------------------------------------------- internals
+    /**
+     * Produces the command to execute for an operation.
+     *
+     * By default this **rebuilds** the command from the operation's own fields rather than
+     * using whatever the client sent. For a well-behaved client the two are identical;
+     * for a hostile one the difference is the whole security boundary.
+     */
+    commandFor(op, decoded, index) {
+        if (this.options.trustClientCommands) {
+            const wire = decoded.operations?.[index];
+            const command = wire?.command;
+            if (command && typeof command === 'object')
+                return command;
+        }
+        return buildWriteCommand(op, {
+            idMapping: this.options.idMapping,
+            versioning: this.options.versioning ?? true,
+            ObjectId: this.options.ObjectId,
+        });
+    }
+    assertCollectionsAllowed(collections) {
+        const allowed = this.options.allowedCollections;
+        if (!allowed)
+            return;
+        const permitted = new Set(allowed);
+        for (const collection of collections) {
+            if (!permitted.has(collection)) {
+                throw new SyncProtocolError(`Collection "${collection}" is not permitted`, 403);
+            }
+        }
+    }
+    async authorise(context) {
+        if (!this.options.verifyRequest)
+            return;
+        const verdict = await this.options.verifyRequest(context);
+        if (verdict === false) {
+            throw new SyncProtocolError('Request rejected', 403);
+        }
+    }
+    ok(payload) {
+        return { status: 200, body: encodeBody(payload), headers: JSON_HEADERS };
+    }
+    error(err) {
+        const status = err instanceof SyncProtocolError ? err.status : 500;
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+            status,
+            // 5xx bodies stay vague: an unexpected error can carry connection strings or
+            // document contents, and this response goes to a client.
+            body: encodeBody({
+                protocol: SYNC_PROTOCOL_VERSION,
+                error: status >= 500 ? 'Internal error applying sync batch' : message,
+            }),
+            headers: JSON_HEADERS,
+        };
+    }
+}
+/** Creates a receiver for sync messages posted by a MongoLite client. */
+export function createSyncReceiver(options) {
+    return new SyncReceiver(options);
+}
+//# sourceMappingURL=server.js.map

package/dist/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"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"}

package/dist/sync/commands.d.ts

@@ -0,0 +1,49 @@
+import type { SyncIdMapping, SyncOperation } from './types.js';
+/** Field carrying the optimistic-concurrency version on upstream documents. */
+export declare const VERSION_FIELD = "_v";
+/** Field carrying the server-stamped last-write time on upstream documents. */
+export declare const UPDATED_AT_FIELD = "_updatedAt";
+/** A single entry in a `bulkWrite` array. */
+export type MongoWriteCommand = Record<string, unknown>;
+/** Constructs an upstream `_id` value from MongoLite's string id. */
+export interface ObjectIdFactory {
+    new (id: string): unknown;
+    isValid(id: string): boolean;
+}
+export interface BuildCommandOptions {
+    /** See {@link SyncIdMapping}. Defaults to `'auto'`. */
+    idMapping?: SyncIdMapping;
+    /** Guard writes with a conditional update against `_v`. Defaults to `true`. */
+    versioning?: boolean;
+    /**
+     * `ObjectId` implementation to use. The direct sink passes the driver's so BSON
+     * instances match the connection that will serialise them; the HTTP sink uses the
+     * one from `bson`, which Extended JSON encodes as `{"$oid": …}` for the wire.
+     */
+    ObjectId?: ObjectIdFactory;
+}
+/** True when this operation asserts a specific upstream revision. */
+export declare function isConditional(op: SyncOperation): boolean;
+/** `_id` is the identity; `_v`/`_updatedAt` are managed by the update itself. */
+export declare function isReservedPath(path: string): boolean;
+export declare function stripReservedFields(value: Record<string, unknown>): Record<string, unknown>;
+/** Reads `_v` off an upstream document, tolerating its absence. */
+export declare function readVersion(document: Record<string, unknown> | undefined): number | null;
+/**
+ * MongoLite stores `_id` as a string. Converting ObjectId-shaped ids back to real
+ * `ObjectId`s keeps replicated documents indistinguishable from ones written by a
+ * native MongoDB client.
+ */
+export declare function toUpstreamId(documentId: string, idMapping?: SyncIdMapping, ObjectId?: ObjectIdFactory): unknown;
+/**
+ * Builds the upstream write for one operation.
+ *
+ * Every form is idempotent by `_id`, which is what makes at-least-once delivery safe:
+ * replaying a batch reproduces the same upstream state.
+ *
+ * With versioning on, writes are additionally *conditional* on the document still being
+ * at the version we last saw. That is the difference between "my change is newer, so it
+ * wins" — which cannot detect a lost update — and "I am replacing exactly the revision
+ * I read", which can.
+ */
+export declare function buildWriteCommand(op: SyncOperation, options?: BuildCommandOptions): MongoWriteCommand;

package/dist/sync/commands.js

@@ -0,0 +1,118 @@
+/**
+ * Builds the MongoDB write commands that realise a {@link SyncOperation}.
+ *
+ * This lives on its own because three places must agree on it byte for byte: the
+ * direct MongoDB sink, the HTTP sink that ships commands to a remote API, and the
+ * receiver on the far side that applies them. If any of the three built its own
+ * commands they would drift, and the drift would show up as data loss rather than as a
+ * test failure.
+ */
+import { ObjectId as BsonObjectId } from 'bson';
+/** Field carrying the optimistic-concurrency version on upstream documents. */
+export const VERSION_FIELD = '_v';
+/** Field carrying the server-stamped last-write time on upstream documents. */
+export const UPDATED_AT_FIELD = '_updatedAt';
+/** True when this operation asserts a specific upstream revision. */
+export function isConditional(op) {
+    return op.baseVersion !== null && op.baseVersion !== undefined;
+}
+/** `_id` is the identity; `_v`/`_updatedAt` are managed by the update itself. */
+export function isReservedPath(path) {
+    const root = path.split('.')[0];
+    return root === '_id' || root === VERSION_FIELD || root === UPDATED_AT_FIELD;
+}
+export function stripReservedFields(value) {
+    return Object.fromEntries(Object.entries(value).filter(([key]) => !isReservedPath(key)));
+}
+/** Reads `_v` off an upstream document, tolerating its absence. */
+export function readVersion(document) {
+    if (!document)
+        return null;
+    const raw = document[VERSION_FIELD];
+    return typeof raw === 'number' ? raw : null;
+}
+/**
+ * MongoLite stores `_id` as a string. Converting ObjectId-shaped ids back to real
+ * `ObjectId`s keeps replicated documents indistinguishable from ones written by a
+ * native MongoDB client.
+ */
+export function toUpstreamId(documentId, idMapping = 'auto', ObjectId = BsonObjectId) {
+    if (idMapping === 'string')
+        return documentId;
+    try {
+        return ObjectId.isValid(documentId) && /^[0-9a-fA-F]{24}$/.test(documentId)
+            ? new ObjectId(documentId)
+            : documentId;
+    }
+    catch {
+        return documentId;
+    }
+}
+/**
+ * Builds the upstream write for one operation.
+ *
+ * Every form is idempotent by `_id`, which is what makes at-least-once delivery safe:
+ * replaying a batch reproduces the same upstream state.
+ *
+ * With versioning on, writes are additionally *conditional* on the document still being
+ * at the version we last saw. That is the difference between "my change is newer, so it
+ * wins" — which cannot detect a lost update — and "I am replacing exactly the revision
+ * I read", which can.
+ */
+export function buildWriteCommand(op, options = {}) {
+    const { idMapping = 'auto', versioning = true, ObjectId } = options;
+    const _id = toUpstreamId(op.documentId, idMapping, ObjectId);
+    if (op.type === 'delete') {
+        const filter = isConditional(op) ? { _id, [VERSION_FIELD]: op.baseVersion } : { _id };
+        return { deleteOne: { filter } };
+    }
+    if (!versioning) {
+        // The local database is treated as authoritative: replace wholesale, so a field
+        // deleted locally disappears upstream too.
+        return {
+            replaceOne: { filter: { _id }, replacement: { ...(op.document ?? {}), _id }, upsert: true },
+        };
+    }
+    // Never been upstream: create it, and let a duplicate key tell us we lost the race to
+    // create. `$setOnInsert` alone means an existing document is left untouched.
+    if (!isConditional(op)) {
+        const document = stripReservedFields(op.document ?? {});
+        return {
+            updateOne: {
+                filter: { _id },
+                update: {
+                    $setOnInsert: { ...document, [VERSION_FIELD]: 1 },
+                    $currentDate: { [UPDATED_AT_FIELD]: true },
+                },
+                upsert: true,
+            },
+        };
+    }
+    // Known revision: apply only what changed, conditional on that revision.
+    const update = {
+        $inc: { [VERSION_FIELD]: 1 },
+        $currentDate: { [UPDATED_AT_FIELD]: true },
+    };
+    const diff = op.diff;
+    if (diff) {
+        const set = stripReservedFields(diff.set);
+        const unset = diff.unset.filter((path) => !isReservedPath(path));
+        if (Object.keys(set).length > 0)
+            update.$set = set;
+        if (unset.length > 0) {
+            update.$unset = Object.fromEntries(unset.map((path) => [path, '']));
+        }
+    }
+    else {
+        // No shadow to diff against — fall back to writing the whole document, minus the
+        // bookkeeping fields the update itself manages.
+        update.$set = stripReservedFields(op.document ?? {});
+    }
+    return {
+        updateOne: {
+            filter: { _id, [VERSION_FIELD]: op.baseVersion },
+            update,
+        },
+    };
+}
+//# sourceMappingURL=commands.js.map

package/dist/sync/commands.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.js","sourceRoot":"","sources":["../../src/sync/commands.ts"],"names":[],"mappings":"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"}

package/dist/sync/diff.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Field-level diffing between the last-known server state and the local document.
+ *
+ * Replication used to push whole documents, which meant a local edit to one field
+ * rewrote every other field too — including fields another writer had just changed,
+ * and including fields whose BSON type the local store cannot represent. Diffing
+ * narrows each push to `$set`/`$unset` of what genuinely changed, so everything else
+ * upstream is left exactly as it was.
+ */
+/** A minimal update expressed as dotted-path assignments and removals. */
+export interface DocumentDiff {
+    /** Dotted path → new value. */
+    set: Record<string, unknown>;
+    /** Dotted paths to remove. */
+    unset: string[];
+}
+/**
+ * Structural equality, insensitive to key order.
+ *
+ * `JSON.stringify` comparison would report `{a:1,b:2}` and `{b:2,a:1}` as different and
+ * push a spurious update on every sync.
+ */
+export declare function deepEqual(a: unknown, b: unknown): boolean;
+/**
+ * Computes the minimal update that turns `base` into `local`.
+ *
+ * `base` must be the **lossy JSON projection** of the server document — the same shape
+ * the local store would have produced for it (see `projectToLocalShape` in `shadow.ts`).
+ * That is what makes type preservation work: a server `Date` projects to the same ISO
+ * string the local store holds, compares equal, and so never appears in the diff — the
+ * upstream `Date` survives untouched.
+ *
+ * Nested objects recurse into dotted paths, so two writers editing different sub-fields
+ * of the same document do not collide.
+ *
+ * **Arrays are atomic.** Any change to an array replaces the whole array. Positional
+ * diffing of arrays is famously error-prone once elements are inserted or reordered, and
+ * a wrong answer here silently corrupts data — so this deliberately does not attempt it.
+ *
+ * @param base The last-known server state, projected to local shape. `null` if the
+ * document has never been upstream, in which case every field is new.
+ * @param local The current local document.
+ */
+export declare function computeDiff(base: Record<string, unknown> | null, local: Record<string, unknown>): DocumentDiff;
+/** True when the diff would change nothing upstream. */
+export declare function isEmptyDiff(diff: DocumentDiff): boolean;
+/**
+ * Applies a diff to a copy of `document`, mirroring what the upstream `$set`/`$unset`
+ * does.
+ *
+ * Used to roll the shadow forward after a successful push without a second round trip.
+ * Because it edits the *server* document in place, fields the diff never mentions keep
+ * their original BSON values — which is the whole point of diffing in the first place.
+ */
+export declare function applyDiff(document: Record<string, unknown>, diff: DocumentDiff): Record<string, unknown>;

package/dist/sync/diff.js

@@ -0,0 +1,169 @@
+/**
+ * Field-level diffing between the last-known server state and the local document.
+ *
+ * Replication used to push whole documents, which meant a local edit to one field
+ * rewrote every other field too — including fields another writer had just changed,
+ * and including fields whose BSON type the local store cannot represent. Diffing
+ * narrows each push to `$set`/`$unset` of what genuinely changed, so everything else
+ * upstream is left exactly as it was.
+ */
+/**
+ * True when `value` is a genuine plain object worth recursing into.
+ *
+ * Class instances are deliberately excluded. A `Date`, `ObjectId` or `Binary` is
+ * `typeof 'object'`, and treating one as a bag of fields would copy it into a plain
+ * object — destroying exactly the BSON types the shadow exists to preserve.
+ */
+function isPlainObject(value) {
+    if (typeof value !== 'object' || value === null || Array.isArray(value))
+        return false;
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+/**
+ * Structural equality, insensitive to key order.
+ *
+ * `JSON.stringify` comparison would report `{a:1,b:2}` and `{b:2,a:1}` as different and
+ * push a spurious update on every sync.
+ */
+export function deepEqual(a, b) {
+    if (a === b)
+        return true;
+    // NaN is the one primitive that isn't equal to itself.
+    if (typeof a === 'number' && typeof b === 'number')
+        return Number.isNaN(a) && Number.isNaN(b);
+    // Two equal instants are separate objects; without this every sync would rewrite
+    // any date-valued field.
+    if (a instanceof Date || b instanceof Date) {
+        return a instanceof Date && b instanceof Date && a.getTime() === b.getTime();
+    }
+    if (Array.isArray(a) || Array.isArray(b)) {
+        if (!Array.isArray(a) || !Array.isArray(b) || a.length !== b.length)
+            return false;
+        return a.every((item, index) => deepEqual(item, b[index]));
+    }
+    if (isPlainObject(a) && isPlainObject(b)) {
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length)
+            return false;
+        return aKeys.every((key) => Object.prototype.hasOwnProperty.call(b, key) && deepEqual(a[key], b[key]));
+    }
+    return false;
+}
+/**
+ * Computes the minimal update that turns `base` into `local`.
+ *
+ * `base` must be the **lossy JSON projection** of the server document — the same shape
+ * the local store would have produced for it (see `projectToLocalShape` in `shadow.ts`).
+ * That is what makes type preservation work: a server `Date` projects to the same ISO
+ * string the local store holds, compares equal, and so never appears in the diff — the
+ * upstream `Date` survives untouched.
+ *
+ * Nested objects recurse into dotted paths, so two writers editing different sub-fields
+ * of the same document do not collide.
+ *
+ * **Arrays are atomic.** Any change to an array replaces the whole array. Positional
+ * diffing of arrays is famously error-prone once elements are inserted or reordered, and
+ * a wrong answer here silently corrupts data — so this deliberately does not attempt it.
+ *
+ * @param base The last-known server state, projected to local shape. `null` if the
+ * document has never been upstream, in which case every field is new.
+ * @param local The current local document.
+ */
+export function computeDiff(base, local) {
+    const diff = { set: {}, unset: [] };
+    collect(base ?? {}, local, '', diff);
+    return diff;
+}
+function collect(base, local, prefix, diff) {
+    const keys = new Set([...Object.keys(base), ...Object.keys(local)]);
+    for (const key of keys) {
+        // `_id` is the identity, never part of the update.
+        if (prefix === '' && key === '_id')
+            continue;
+        const path = prefix === '' ? key : `${prefix}.${key}`;
+        const inLocal = Object.prototype.hasOwnProperty.call(local, key);
+        const inBase = Object.prototype.hasOwnProperty.call(base, key);
+        if (!inLocal) {
+            diff.unset.push(path);
+            continue;
+        }
+        const localValue = local[key];
+        const baseValue = base[key];
+        if (!inBase) {
+            diff.set[path] = localValue;
+            continue;
+        }
+        // Recurse only when both sides are objects; otherwise the shapes differ and the
+        // whole subtree is replaced.
+        if (isPlainObject(baseValue) && isPlainObject(localValue)) {
+            collect(baseValue, localValue, path, diff);
+            continue;
+        }
+        if (!deepEqual(baseValue, localValue)) {
+            diff.set[path] = localValue;
+        }
+    }
+}
+/** True when the diff would change nothing upstream. */
+export function isEmptyDiff(diff) {
+    return Object.keys(diff.set).length === 0 && diff.unset.length === 0;
+}
+/**
+ * Applies a diff to a copy of `document`, mirroring what the upstream `$set`/`$unset`
+ * does.
+ *
+ * Used to roll the shadow forward after a successful push without a second round trip.
+ * Because it edits the *server* document in place, fields the diff never mentions keep
+ * their original BSON values — which is the whole point of diffing in the first place.
+ */
+export function applyDiff(document, diff) {
+    const result = clone(document);
+    for (const [path, value] of Object.entries(diff.set)) {
+        setPath(result, path.split('.'), value);
+    }
+    for (const path of diff.unset) {
+        unsetPath(result, path.split('.'));
+    }
+    return result;
+}
+/**
+ * Structured clone that leaves class instances (BSON `Date`, `ObjectId`, `Binary`, …)
+ * by reference. Copying them field-by-field would destroy exactly the types the shadow
+ * exists to preserve.
+ */
+function clone(value) {
+    if (Array.isArray(value))
+        return value.map(clone);
+    if (isPlainObject(value)) {
+        const out = {};
+        for (const [key, item] of Object.entries(value))
+            out[key] = clone(item);
+        return out;
+    }
+    return value;
+}
+function setPath(target, segments, value) {
+    const [head, ...rest] = segments;
+    if (rest.length === 0) {
+        target[head] = value;
+        return;
+    }
+    const next = target[head];
+    // Mirror MongoDB: a dotted path creates intermediate objects as needed.
+    const container = isPlainObject(next) ? next : {};
+    target[head] = container;
+    setPath(container, rest, value);
+}
+function unsetPath(target, segments) {
+    const [head, ...rest] = segments;
+    if (rest.length === 0) {
+        delete target[head];
+        return;
+    }
+    const next = target[head];
+    if (isPlainObject(next))
+        unsetPath(next, rest);
+}
+//# sourceMappingURL=diff.js.map

package/dist/sync/diff.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.js","sourceRoot":"","sources":["../../src/sync/diff.ts"],"names":[],"mappings":"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"}