@livequery/mongodb 2.0.0 → 2.0.148

package/README.md

@@ -24,6 +24,7 @@ For local development in this workspace, `@livequery/core` is installed as a dev
 ```ts
 export * from './MongoDatasource.js'
 export * from './DataChangePayload.js'
+export * from './MongodbRealtime.js'
 export * from './types.js'
 ```
 
@@ -305,6 +306,86 @@ Returns:
 
 The collection cache key includes connection, database, and collection name to avoid reusing collection handles across tenants or connections.
 
+### `MongodbRealtime`
+
+MongoDB change stream watcher for realtime Livequery updates. This replaces the need to use the separate `@livequery/mongodb-mapper` package in native MongoDB projects.
+
+```ts
+import { WebsocketGateway } from '@livequery/core'
+import { MongoDatasource, MongodbRealtime } from '@livequery/mongodb'
+
+const datasource = new MongoDatasource({
+  connections: { default: client },
+  databases: ['main'],
+})
+
+await datasource.init([
+  {
+    method: 'GET',
+    path: '/products',
+    collection: 'products',
+    realtime: true,
+  },
+])
+
+const websocketGateway = new WebsocketGateway(server)
+
+new MongodbRealtime()
+  .watch(datasource.config, [
+    {
+      // LivequeryRequestParser.parse(...).schema — document-id segment already stripped
+      schema: 'products',
+      options: { collection: 'products', realtime: true },
+    },
+  ])
+  .subscribe(websocketGateway)
+```
+
+`MongoRealtimeRoute`:
+
+```ts
+type MongoRealtimeRoute = {
+  schema: string        // parsed route path from @livequery/core, e.g. 'users/:userId/posts'
+  options: RouteOptions
+}
+```
+
+Realtime route requirements:
+
+- `realtime` must be `true`.
+- `schema` is the parsed route path (`LivequeryRequestParser.parse(...).schema`), so the document-id segment is already stripped and each `:param` names the document field holding the parent value.
+- `collection` must be a static string. Dynamic collection, database, or connection resolver functions are skipped because database watchers must be known up front.
+- When watching a `MongoClient`, `db` or `config.databases` decides which database names to watch. When watching a `Db`, that database is used directly.
+
+By default, `MongodbRealtime` enables MongoDB pre/post images with `collMod` and watches with `fullDocument: 'updateLookup'` and `fullDocumentBeforeChange: 'whenAvailable'`.
+
+Disable the `collMod` call when your deployment manages pre/post images separately:
+
+```ts
+new MongodbRealtime({ enablePreAndPostImages: false })
+```
+
+For nested collection refs, name the route param after the document field that holds the parent value:
+
+```ts
+{
+  schema: 'users/:userId/posts',
+  options: { collection: 'posts', realtime: true },
+}
+```
+
+If the document field is an array (one document belongs to many parents), the change is fanned out to one ref per array element, and array membership changes emit `added`/`removed` per ref.
+
+An inserted `{ _id: 'post1', userId: 'user1', title: 'Hello' }` emits:
+
+```ts
+{
+  ref: 'users/user1/posts',
+  type: 'added',
+  data: { id: 'post1', userId: 'user1', title: 'Hello' },
+}
+```
+
 ### `DataChangePayload<T>`
 
 Type-only realtime/change payload contract.
@@ -360,7 +441,7 @@ type RouteOptions = {
 
 Fields:
 
-- `realtime`: optional marker for realtime routes. The current adapter does not use it for query execution.
+- `realtime`: marks a static collection route for `MongodbRealtime.watch()`. Query execution itself is unchanged.
 - `collection`: required collection name or resolver function.
 - `db`: optional database name or resolver function.
 - `connection`: optional connection name or resolver function.

package/build/src/Cursor.d.ts

@@ -1,5 +1,4 @@
-import type { LivequeryBaseEntity, QueryOption } from "./types.js";
 export declare class Cursor {
-    static caculate<T extends LivequeryBaseEntity>(item: T, options: QueryOption<T>): string;
-    static parse<T extends LivequeryBaseEntity>(cursor: string): any;
+    static caculate(item: Record<string, any>, options: Record<string, any>): string;
+    static parse(cursor: string): any;
 }

package/build/src/MongoDatasource.d.ts

@@ -1,15 +1,7 @@
 import type { LivequeryContext, LivequeryDatasource as CoreLivequeryDatasource, LivequeryDatasourceInitConfig } from '@livequery/core';
-import type { LivequeryRequest, LivequeryBaseEntity, WebsocketSyncPayload } from './types.js';
+import type { LivequeryRequest, LivequeryBaseEntity, UpdatedData } from '@livequery/core';
 import type { Db, MongoClient } from 'mongodb';
 import { Subject } from 'rxjs';
-export type LivequeryDatasource<Config, RouteOptions> = Subject<WebsocketSyncPayload<LivequeryBaseEntity>> & {
-    init(config: Config, routes: Array<{
-        path: string;
-        method: number;
-        options: RouteOptions;
-    }>): Promise<void>;
-    query: (query: LivequeryRequest, options: RouteOptions) => Promise<any>;
-};
 export type MongoConnection = MongoClient | Db;
 export type MongoDatasourceConfig = {
     connections: {
@@ -17,12 +9,6 @@ export type MongoDatasourceConfig = {
     };
     databases?: string[];
 };
-type LegacyRouteConfig<RouteOptions> = {
-    path: string;
-    method: number | string;
-    options?: RouteOptions;
-    config?: RouteOptions;
-};
 export type RouteOptions = {
     realtime?: boolean;
     collection: string | ((req: LivequeryRequest) => Promise<string> | string);
@@ -30,16 +16,15 @@ export type RouteOptions = {
     connection?: string | ((req: LivequeryRequest) => Promise<string> | string);
     objectIdFields?: string[];
 };
-export declare class MongoDatasource extends Subject<WebsocketSyncPayload<LivequeryBaseEntity>> implements LivequeryDatasource<MongoDatasourceConfig, RouteOptions>, CoreLivequeryDatasource<RouteOptions> {
+export declare class MongoDatasource extends Subject<UpdatedData<LivequeryBaseEntity>> implements CoreLivequeryDatasource<RouteOptions> {
     #private;
     readonly refs: Map<string, Set<string>>;
     config: MongoDatasourceConfig;
     routes: Map<string, RouteOptions>;
     constructor(config?: MongoDatasourceConfig);
     init(routes: Array<LivequeryDatasourceInitConfig<RouteOptions>>): Promise<void>;
-    init(config: MongoDatasourceConfig, routes: Array<LegacyRouteConfig<RouteOptions>>): Promise<void>;
     handle(ctx: LivequeryContext): Promise<{}>;
-    query(req: LivequeryRequest, options: RouteOptions): Promise<import("mongodb").DeleteResult | {
+    query(req: LivequeryRequest, options: RouteOptions): Promise<{
         items: any[];
         summary: any;
         cursor: {
@@ -62,6 +47,5 @@ export declare class MongoDatasource extends Subject<WebsocketSyncPayload<Livequ
         };
     } | {
         item: any;
-    } | import("mongodb").UpdateResult<any>>;
+    }>;
 }
-export {};

package/build/src/MongoDatasource.js

@@ -1,6 +1,6 @@
 import { Cursor } from './Cursor.js';
 import { MongoQuery } from "./MongoQuery.js";
-import { ObjectId } from 'bson';
+import { ObjectId } from 'mongodb';
 import { SmartCache } from './SmartCache.js';
 import { Subject } from 'rxjs';
 export class MongoDatasource extends Subject {
@@ -14,23 +14,18 @@ export class MongoDatasource extends Subject {
             this.config = config;
         this.routes = new Map();
     }
-    async init(configOrRoutes, maybeRoutes) {
-        const routes = Array.isArray(configOrRoutes)
-            ? configOrRoutes
-            : maybeRoutes || [];
-        if (!Array.isArray(configOrRoutes)) {
-            this.config = configOrRoutes;
-        }
+    async init(routes) {
         this.routes = routes.reduce((p, c) => {
-            const options = this.#getRouteOptions(c);
-            if (!options.collection)
+            const { method, path, ...options } = c;
+            const routeOptions = options;
+            if (!routeOptions.collection)
                 return p;
             const key = this.#routeKey(c.method, c.path);
             const set = p.get(key) || p.get(c.path);
-            if (set && set.collection != options.collection)
+            if (set && set.collection != routeOptions.collection)
                 throw new Error('Collection mismatch for route path "' + c.path + '"');
-            p.set(key, options);
-            p.set(c.path, options);
+            p.set(key, routeOptions);
+            p.set(c.path, routeOptions);
             return p;
         }, new Map());
     }
@@ -59,15 +54,6 @@ export class MongoDatasource extends Subject {
             return this.#del(query, collection);
         throw { status: 500, code: 'INVAILD_METHOD', message: 'Invaild method' };
     }
-    #getRouteOptions(route) {
-        const legacy = route;
-        if (legacy.options)
-            return legacy.options;
-        if (legacy.config)
-            return legacy.config;
-        const { method, path, ...options } = route;
-        return options;
-    }
     #getOptions(ctx) {
         const routePath = ctx.request.ref || ctx.request.path;
         const options = this.routes.get(this.#routeKey(ctx.request.method, routePath)) || this.routes.get(routePath);
@@ -87,23 +73,20 @@ export class MongoDatasource extends Subject {
             is_collection: !livequery.document_id,
             collection_ref: livequery.collection_ref,
             schema_collection_ref: livequery.schema_collection_ref,
-            doc_id: livequery.document_id,
+            document_id: livequery.document_id,
             keys: livequery.keys || {},
             query: livequery.query || {},
-            options: livequery.query || {},
             method: livequery.method?.toLowerCase(),
             body: livequery.body,
         };
     }
     #normalizeRequest(req) {
-        const options = req.options || req.query || {};
+        const query = req.query || {};
         return {
             ...req,
             keys: req.keys || {},
-            query: req.query || options,
-            options,
+            query,
             is_collection: typeof req.is_collection == 'boolean' ? req.is_collection : !req.document_id,
-            doc_id: req.doc_id || req.document_id,
             method: req.method?.toLowerCase(),
         };
     }
@@ -128,8 +111,8 @@ export class MongoDatasource extends Subject {
         const total = current + count.next + count.prev;
         const paging = {
             cursor: {
-                last: Cursor.caculate(items[items.length - 1], req.options),
-                first: Cursor.caculate(items[0], req.options)
+                last: Cursor.caculate(items[items.length - 1], req.query),
+                first: Cursor.caculate(items[0], req.query)
             },
             has,
             count: {
@@ -186,26 +169,46 @@ export class MongoDatasource extends Subject {
         };
     }
     async #put(req, collection) {
-        return await collection.updateOne(this.#keys(req), this.#update(req.body));
+        await collection.updateOne(this.#keys(req), this.#update(req.body));
+        return { item: this.#writtenItem(req) };
     }
     async #patch(req, collection) {
-        return await collection.updateOne(this.#keys(req), this.#update(req.body));
+        await collection.updateOne(this.#keys(req), this.#update(req.body));
+        return { item: this.#writtenItem(req) };
     }
     async #del(req, collection) {
-        return await collection.deleteOne(this.#keys(req));
+        await collection.deleteOne(this.#keys(req));
+        return { item: this.#writtenItem(req) };
+    }
+    #writtenItem(req) {
+        const keys = req.keys || {};
+        const isPlainBody = req.body && typeof req.body === 'object'
+            && !Object.keys(req.body).some(k => k.startsWith('$'));
+        const id = keys.id ?? req.document_id;
+        return {
+            ...keys,
+            ...isPlainBody ? req.body : {},
+            ...id ? { id } : {}
+        };
     }
     #keys(req) {
         return Object.entries(req.keys).reduce((p, [k, c]) => {
             return {
                 ...p,
                 ...k == 'id' ? {
-                    _id: ObjectId.createFromHexString(req.keys.id)
+                    _id: this.#objectId('id', req.keys.id)
                 } : {
                     [k]: c
                 }
             };
         }, {});
     }
+    #objectId(field, value) {
+        if (typeof value != 'string' || !ObjectId.isValid(value)) {
+            throw { status: 400, code: 'INVALID_OBJECT_ID', message: `Invalid ObjectId for field "${field}": ${JSON.stringify(value)}` };
+        }
+        return ObjectId.createFromHexString(value);
+    }
     #update(body) {
         if (!body || Object.keys(body).some(key => key.startsWith('$')))
             return body;

package/build/src/MongoQuery.d.ts

@@ -1,4 +1,4 @@
-import type { LivequeryBaseEntity, LivequeryRequest } from "./types.js";
+import type { LivequeryBaseEntity, LivequeryRequest } from "@livequery/core";
 import type { Collection } from "mongodb";
 export declare class MongoQuery {
     #private;

package/build/src/MongoQuery.js

@@ -1,5 +1,5 @@
 import { Cursor } from "./Cursor.js";
-import { ObjectId } from "bson";
+import { ObjectId } from "mongodb";
 export class MongoQuery {
     static #is_operator(c) {
         return ['+', '-', '*', '/', '(', ')', '~'].indexOf(c) !== -1;
@@ -91,6 +91,23 @@ export class MongoQuery {
         }
         return stack.pop();
     }
+    static #escape_regex(value) {
+        return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+    }
+    static #objectId(field, value) {
+        if (typeof value != 'string' || !ObjectId.isValid(value)) {
+            throw { status: 400, code: 'INVALID_OBJECT_ID', message: `Invalid ObjectId for field "${field}": ${JSON.stringify(value)}` };
+        }
+        return ObjectId.createFromHexString(value);
+    }
+    static #parse_cursor(token) {
+        try {
+            return Cursor.parse(token);
+        }
+        catch {
+            throw { status: 400, code: 'INVALID_CURSOR', message: 'Invalid pagination cursor' };
+        }
+    }
     static #parse_array(value) {
         if (Array.isArray(value))
             return value;
@@ -106,7 +123,7 @@ export class MongoQuery {
     }
     static #parse_summary(req) {
         const parsed = Object
-            .entries(req.options)
+            .entries(req.query)
             .map(([key, v], index) => {
             if (!key.startsWith('::'))
                 return [];
@@ -201,19 +218,25 @@ export class MongoQuery {
         };
     }
     static #parse_conditions(filters) {
+        const $match = this.#build_match(filters);
+        return Object.keys($match).length > 0 ? [{ $match }] : [];
+    }
+    static #build_match(filters) {
         if (!filters)
-            return [];
+            return {};
         const { ':and': and, ':or': or, ':not': not, ...rest } = filters;
         const $or = Object.entries(rest).filter(([k]) => k.endsWith(':like')).map(([k, v]) => {
             const key = k.split(':like')[0];
             const value = `${v}`;
             return {
-                [key]: { $regex: value }
+                [key]: { $regex: this.#escape_regex(value), $options: 'i' }
             };
         });
-        const $match = Object.entries(rest).reduce((p, [k, value]) => {
+        const fields = Object.entries(rest).reduce((p, [k, value]) => {
             if (k.startsWith('::'))
                 return p;
+            if (k.endsWith(':like'))
+                return p;
             const [key, expression] = k.split(':');
             const map = {
                 eq: () => ({ $eq: value }),
@@ -245,20 +268,35 @@ export class MongoQuery {
                     ...fn()
                 }
             };
-        }, $or.length > 0 ? { $or } : {});
-        return [
-            ...Object.keys($match).length > 0 ? [{ $match }] : [],
-            ...and && Object.keys(and).length > 0 ? [{ $expr: { $and: this.#parse_conditions(and) } }] : [],
-            ...or && Object.keys(and).length > 0 ? [{ $expr: { $or: this.#parse_conditions(or) } }] : [],
-            ...not && Object.keys(and).length > 0 ? [{ $not: { $and: this.#parse_conditions(not) } }] : [],
-        ];
+        }, {});
+        const clauses = [];
+        if (Object.keys(fields).length > 0)
+            clauses.push(fields);
+        if ($or.length > 0)
+            clauses.push({ $or });
+        const andMatch = and ? this.#build_match(and) : {};
+        if (Object.keys(andMatch).length > 0)
+            clauses.push(andMatch);
+        const orMatch = or ? this.#build_match(or) : {};
+        if (Object.keys(orMatch).length > 0) {
+            clauses.push({ $or: Object.entries(orMatch).map(([k, v]) => ({ [k]: v })) });
+        }
+        const notMatch = not ? this.#build_match(not) : {};
+        if (Object.keys(notMatch).length > 0) {
+            clauses.push({ $nor: Object.entries(notMatch).map(([k, v]) => ({ [k]: v })) });
+        }
+        if (clauses.length === 0)
+            return {};
+        if (clauses.length === 1)
+            return clauses[0];
+        return { $and: clauses };
     }
     static #build_search_query(req) {
-        const search = req.options[":search"];
+        const search = req.query[":search"];
         return search ? [{ $match: { $text: { $search: `${search}` } } }] : [];
     }
     static #get_limit(req) {
-        const l = Number(req.options[':limit']);
+        const l = Number(req.query[':limit']);
         if (isNaN(l))
             return 10;
         if (l < 1)
@@ -276,13 +314,19 @@ export class MongoQuery {
             }
         ];
     }
+    static #topn_sorter($sort) {
+        return Object.entries($sort).reduce((p, [key, order]) => ({
+            ...p,
+            [key == '_id' ? 'id' : key]: order
+        }), {});
+    }
     static #build_cursor_query($sort, req, reverse = false) {
         const limit = this.#get_limit(req);
-        const after = req.options[':after'];
-        const before = req.options[':before'];
-        const around = req.options[':around'];
+        const after = req.query[':after'];
+        const before = req.query[':before'];
+        const around = req.query[':around'];
         const pagination_token = around || before || after;
-        const cursor = pagination_token ? Cursor.parse(pagination_token) : (reverse ? null : {});
+        const cursor = pagination_token ? this.#parse_cursor(pagination_token) : (reverse ? null : {});
         if (!cursor)
             return [{ $limit: 1 }, { $match: { _id: 0 } }];
         const $or = Object.entries({ ...$sort, _id: $sort._id || -1 }).map(([key, order], index, arr) => {
@@ -317,7 +361,7 @@ export class MongoQuery {
                         items: {
                             [reverse ? '$bottomN' : '$topN']: {
                                 n: limit,
-                                sortBy: {},
+                                sortBy: this.#topn_sorter($sort),
                                 output: "$$ROOT"
                             }
                         }
@@ -336,7 +380,7 @@ export class MongoQuery {
         ];
     }
     static #build_cursor_paging($sort, req) {
-        if (req.options[':after'] || req.options[':before'] || req.options[':around']) {
+        if (req.query[':after'] || req.query[':before'] || req.query[':around']) {
         }
         const { pipelines, summary } = this.#parse_summary(req);
         const limit = this.#get_limit(req);
@@ -384,15 +428,48 @@ export class MongoQuery {
         ];
     }
     static #build_offset_paging(req) {
-        return [];
+        const limit = this.#get_limit(req);
+        const page = Math.max(1, Math.floor(Number(req.query[':page'])) || 1);
+        const skip = (page - 1) * limit;
+        const { pipelines, summary } = this.#parse_summary(req);
+        return [
+            {
+                $facet: {
+                    ...pipelines,
+                    items: [{ $skip: skip }, { $limit: limit }],
+                    total: [{ $count: 'count' }],
+                }
+            },
+            {
+                $project: {
+                    summary,
+                    items: 1,
+                    total: { $ifNull: [{ $arrayElemAt: ['$total.count', 0] }, 0] },
+                }
+            },
+            {
+                $project: {
+                    summary: 1,
+                    items: 1,
+                    has: {
+                        prev: { $gt: [skip, 0] },
+                        next: { $gt: ['$total', skip + limit] },
+                    },
+                    count: {
+                        prev: { $literal: skip },
+                        next: { $max: [{ $subtract: ['$total', skip + limit] }, 0] },
+                    },
+                }
+            }
+        ];
     }
     static #build_query_filter(req) {
-        const { ":after": after, ":before": before, ':around': around, ":limit": _limit, ":page": _page, ":search": search, ...rest } = req.options;
+        const { ":after": after, ":before": before, ':around': around, ":limit": _limit, ":page": _page, ":search": search, ...rest } = req.query;
         return this.#parse_conditions({ ...rest, ...req.keys });
     }
     static #get_sorter(req) {
         let default_sort = -1;
-        const $sort = Object.entries(req.options).reduce((p, [k, order]) => {
+        const $sort = Object.entries(req.query).reduce((p, [k, order]) => {
             if (!k.endsWith(':sort'))
                 return p;
             const by = k.split(':sort')[0];
@@ -417,7 +494,7 @@ export class MongoQuery {
                 {
                     $match: {
                         ...req.keys,
-                        ...req.keys.id ? { id: undefined, _id: ObjectId.createFromHexString(req.keys.id) } : {}
+                        ...req.keys.id ? { id: undefined, _id: this.#objectId('id', req.keys.id) } : {}
                     }
                 },
                 ...this.#rename_id(),
@@ -436,7 +513,7 @@ export class MongoQuery {
                 summary: {}
             };
         }
-        const is_cursor_paging = req.options[':after'] || req.options[':before'] || req.options[':around'] || !req.options['page'];
+        const is_cursor_paging = req.query[':after'] || req.query[':before'] || req.query[':around'] || !req.query[':page'];
         const $sort = this.#get_sorter(req);
         const pipelines = [
             { $sort },

package/build/src/MongodbRealtime.d.ts

@@ -0,0 +1,17 @@
+import { Observable } from 'rxjs';
+import type { UpdatedData } from '@livequery/core';
+import type { MongoDatasourceConfig, RouteOptions } from './MongoDatasource.js';
+export type MongoRealtimeChangeType = 'added' | 'modified' | 'removed';
+export type MongoRealtimeOptions = {
+    enablePreAndPostImages?: boolean;
+};
+export type MongoRealtimeRoute = {
+    schema: string;
+    options: RouteOptions;
+};
+export declare class MongodbRealtime {
+    #private;
+    private options;
+    constructor(options?: MongoRealtimeOptions);
+    watch(config: MongoDatasourceConfig, routes: MongoRealtimeRoute[]): Observable<UpdatedData<any>>;
+}

package/build/src/MongodbRealtime.js

@@ -0,0 +1,206 @@
+import { EMPTY, Observable, from, map, mergeAll, mergeMap, retry } from 'rxjs';
+const changeTypes = {
+    insert: 'added',
+    update: 'modified',
+    replace: 'modified',
+    delete: 'removed',
+};
+export class MongodbRealtime {
+    options;
+    constructor(options = {}) {
+        this.options = options;
+    }
+    #reformatId(obj) {
+        if (!obj)
+            return undefined;
+        const { _id, __v, id, ...rest } = obj;
+        return {
+            id: _id ? String(_id) : id || '#',
+            ...Object.entries(rest).reduce((acc, [key, value]) => {
+                if (key.startsWith('_'))
+                    return acc;
+                return { ...acc, [key]: value };
+            }, {}),
+        };
+    }
+    #isDb(connection) {
+        return typeof connection.collection == 'function';
+    }
+    #collection(source) {
+        if (this.#isDb(source.connection))
+            return source.connection.collection(source.collection);
+        return source.connection.db(source.dbName).collection(source.collection);
+    }
+    #watchSources(config, routes) {
+        const sources = new Map();
+        for (const route of routes) {
+            const options = route.options;
+            if (!options?.realtime)
+                continue;
+            if (typeof options.collection != 'string')
+                continue;
+            if (typeof options.connection == 'function' || typeof options.db == 'function')
+                continue;
+            const connectionName = options.connection || Object.keys(config.connections)[0] || 'default';
+            const connection = config.connections[connectionName];
+            if (!connection)
+                continue;
+            const dbNames = this.#isDb(connection)
+                ? [undefined]
+                : options.db ? [options.db] : config.databases || ['main'];
+            for (const dbName of dbNames) {
+                const key = `${connectionName}|${dbName || ''}|${options.collection}`;
+                sources.set(key, { connection, dbName, collection: options.collection });
+            }
+        }
+        return [...sources.values()];
+    }
+    #listenRawChanges(config, routes) {
+        const sources = this.#watchSources(config, routes);
+        if (sources.length === 0)
+            return EMPTY;
+        return from(sources).pipe(mergeMap(async (source) => {
+            const collection = this.#collection(source);
+            if (this.options.enablePreAndPostImages !== false) {
+                await collection.db.command({
+                    collMod: source.collection,
+                    changeStreamPreAndPostImages: { enabled: true },
+                });
+            }
+            return new Observable(observer => {
+                const stream = collection.watch([], {
+                    fullDocument: 'updateLookup',
+                    fullDocumentBeforeChange: 'whenAvailable',
+                });
+                stream
+                    .on('error', error => observer.error(error))
+                    .on('change', (change) => {
+                    const type = changeTypes[change.operationType];
+                    if (!type)
+                        return;
+                    const fields = new Set(type == 'modified'
+                        ? [
+                            ...Object.keys(change.updateDescription?.updatedFields || {}).map(field => field.split('.')[0]),
+                            ...(change.updateDescription?.removedFields || []).map(field => field.split('.')[0]),
+                        ].filter(field => !field.startsWith('_'))
+                        : []);
+                    observer.next({
+                        table: change.ns.coll,
+                        type,
+                        new_data: this.#reformatId(change.fullDocument),
+                        old_data: this.#reformatId(change.fullDocumentBeforeChange ?? change.documentKey),
+                        fields,
+                    });
+                });
+                return () => {
+                    void stream.close();
+                };
+            });
+        }), mergeMap(stream => stream), retry());
+    }
+    #routeRefMetadata(route) {
+        const options = route.options;
+        if (!options?.realtime)
+            return;
+        if (typeof options.collection != 'string')
+            return;
+        const segments = route.schema.split('/').filter(Boolean);
+        const ref = segments.filter(segment => !segment.startsWith(':')).join('/');
+        if (!ref)
+            return;
+        const metadata = segments
+            .map((collection, index) => {
+            if (index % 2 === 1)
+                return [];
+            const param = segments[index + 1];
+            if (!param?.startsWith(':'))
+                return [{ collection }];
+            const field = param.slice(1);
+            return [{ collection, field: field == 'id' ? '_id' : field }];
+        })
+            .flat();
+        return [ref, metadata];
+    }
+    #paths(routes) {
+        return routes.reduce((paths, route) => {
+            const options = route.options;
+            const entry = this.#routeRefMetadata(route);
+            if (!options || !entry || typeof options.collection != 'string')
+                return paths;
+            const [ref, metadata] = entry;
+            const refs = paths.get(options.collection) || new Map();
+            refs.set(ref, metadata);
+            paths.set(options.collection, refs);
+            return paths;
+        }, new Map());
+    }
+    #format(paths, event) {
+        const refs = paths.get(event.table);
+        if (!refs)
+            return [];
+        const merged = {
+            ...event.old_data || {},
+            ...event.new_data || {},
+        };
+        const changes = Object.keys(merged)
+            .filter(key => event.fields.has(key))
+            .reduce((acc, key) => ({ ...acc, [key]: event.new_data?.[key] }), { id: merged.id });
+        const typeForField = (field, pathValue) => {
+            const oldValue = event.old_data?.[field];
+            const newValue = event.new_data?.[field];
+            const value = String(pathValue);
+            if (Array.isArray(oldValue) || Array.isArray(newValue)) {
+                const oldArray = (Array.isArray(oldValue) ? oldValue : []).map(item => String(item));
+                const newArray = (Array.isArray(newValue) ? newValue : []).map(item => String(item));
+                if (oldArray.includes(value) && !newArray.includes(value))
+                    return 'removed';
+                if (!oldArray.includes(value) && newArray.includes(value))
+                    return 'added';
+                return 'modified';
+            }
+            if (String(newValue) == value && String(oldValue) != value)
+                return 'added';
+            if (String(oldValue) == value && String(newValue) != value)
+                return 'removed';
+            return 'modified';
+        };
+        const buildRefs = ([{ collection, field }, ...fields]) => {
+            if (fields.length === 0 || !field)
+                return [{ refs: [collection], type: event.type }];
+            const oldValues = event.old_data?.[field];
+            const newValues = event.new_data?.[field];
+            const values = Array.isArray(oldValues) || Array.isArray(newValues)
+                ? [...new Set([
+                        ...(Array.isArray(oldValues) ? oldValues : []).map((item) => String(item)),
+                        ...(Array.isArray(newValues) ? newValues : []).map((item) => String(item)),
+                    ])]
+                : [merged[field] ?? '-'];
+            return values.flatMap(value => {
+                return buildRefs(fields).map(next => ({
+                    type: event.type == 'added' || event.type == 'removed'
+                        ? event.type
+                        : next.type == 'added' || next.type == 'removed'
+                            ? next.type
+                            : typeForField(field, value),
+                    refs: [collection, String(value), ...next.refs],
+                }));
+            });
+        };
+        return [...refs.values()].flatMap(metadata => {
+            return buildRefs(metadata).map(({ refs, type }) => ({
+                ref: refs.join('/'),
+                type,
+                data: type == 'added' ? merged : {
+                    ...type == 'modified' ? changes : {},
+                    id: merged.id,
+                },
+            }));
+        });
+    }
+    watch(config, routes) {
+        const paths = this.#paths(routes);
+        if (paths.size === 0)
+            return EMPTY;
+        return this.#listenRawChanges(config, routes).pipe(map(event => this.#format(paths, event)), mergeAll());
+    }
+}

package/build/src/SmartCache.d.ts

@@ -1,4 +1,4 @@
 export declare class SmartCache {
     #private;
-    get<T>(key: any, reslover: () => Promise<T>): Promise<any>;
+    get<T>(key: any, resolver: () => Promise<T>): Promise<any>;
 }

package/build/src/SmartCache.js

@@ -1,10 +1,10 @@
 export class SmartCache {
     #storage = new Map();
-    async get(key, reslover) {
+    async get(key, resolver) {
         const cache = this.#storage.get(key);
         if (cache)
             return await cache;
-        const value = reslover();
+        const value = resolver();
         this.#storage.set(key, value);
         return await value;
     }

package/build/src/index.d.ts

@@ -1,3 +1,3 @@
 export * from './MongoDatasource.js';
 export * from './DataChangePayload.js';
-export * from './types.js';
+export * from './MongodbRealtime.js';

package/build/src/index.js

@@ -1,3 +1,3 @@
 export * from './MongoDatasource.js';
 export * from './DataChangePayload.js';
-export * from './types.js';
+export * from './MongodbRealtime.js';

package/build/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/cursor.ts","../src/datachangepayload.ts","../src/mongodatasource.ts","../src/mongoquery.ts","../src/smartcache.ts","../src/index.ts","../src/types.ts"],"version":"5.9.3"}
+{"root":["../src/cursor.ts","../src/datachangepayload.ts","../src/mongodatasource.ts","../src/mongoquery.ts","../src/mongodbrealtime.ts","../src/smartcache.ts","../src/index.ts"],"version":"5.9.3"}

package/package.json

@@ -6,7 +6,7 @@
     "repository": {
         "url": "git@github.com:livequery/mongodb.git"
     },
-    "version": "2.0.0",
+    "version": "2.0.148",
     "description": "MongoDB datasource mapping for @livequery ecosystem",
     "main": "./build/src/index.js",
     "types": "./build/src/index.d.ts",
@@ -34,7 +34,6 @@
         "deploy": "rm -rf build && yarn build; git add .; git commit -m \"Update\"; git push origin master; npm publish --access public"
     },
     "peerDependencies": {
-        "bson": "*",
         "mongodb": "^6.20.0"
     }
 }

package/build/src/types.d.ts

@@ -1,46 +0,0 @@
-import type { LivequeryRequest as CoreLivequeryRequest } from '@livequery/core';
-export type LivequeryBaseEntity = {
-    id?: string;
-    [key: string]: any;
-};
-export type QueryOption<T extends LivequeryBaseEntity = LivequeryBaseEntity> = Record<string, any>;
-export type FilterConditions<T extends LivequeryBaseEntity = LivequeryBaseEntity> = Record<string, any>;
-export type Paging = {
-    cursor: {
-        last: string | null;
-        first: string | null;
-    };
-    has: {
-        prev: boolean;
-        next: boolean;
-    };
-    count: {
-        prev: number;
-        next: number;
-        current: number;
-        total: number;
-    };
-    page: {
-        current: number;
-        total: number;
-    };
-};
-export type WebsocketSyncPayload<T extends LivequeryBaseEntity = LivequeryBaseEntity> = {
-    ref?: string;
-    type?: string;
-    data?: T;
-    [key: string]: any;
-};
-export type LivequeryRequest<T = any> = Partial<CoreLivequeryRequest<T>> & {
-    keys: Record<string, any>;
-    ref: string;
-    collection_ref?: string;
-    schema_collection_ref?: string;
-    method: string;
-    body?: T;
-    query?: Record<string, any>;
-    options: Record<string, any>;
-    is_collection: boolean;
-    doc_id?: string;
-    document_id?: string;
-};

package/build/src/types.js

@@ -1 +0,0 @@
-export {};