@livequery/mongoose 2.0.25 → 2.0.27

package/build/src/MongoQuery.js

@@ -334,6 +334,8 @@ export class MongoQuery {
         ];
     }
     static #build_cursor_paging($sort, req) {
+        if (req.options[':after'] || req.options[':before'] || req.options[':around']) {
+        }
         const { pipelines, summary } = this.#parse_summary(req);
         const limit = this.#get_limit(req);
         return [

package/build/src/MongooseDatasource.d.ts

@@ -1,22 +1,26 @@
 import { RouteOptions } from "./RouteOptions.js";
-import { LivequeryRequest, LivequeryBaseEntity, WebsocketSyncPayload, DatabaseEvent } from '@livequery/types';
-import { Observable } from "rxjs";
+import { LivequeryRequest, WebsocketSyncPayload, DatabaseEvent } from '@livequery/types';
+import { Observable, Subject } from "rxjs";
 import { Connection } from 'mongoose';
-export type MongooseDatasourceOptions<T> = Array<T & {
+export type LivequeryDatasourceOptions<T> = Array<T & {
     refs: string[];
 }>;
-export type LivequeryDatasource<Options = {}, StreamPayload = {}, Connection = any> = {
-    init(routes: MongooseDatasourceOptions<Options>, connections: {
-        [name: string]: Connection;
-    }): Promise<void>;
+export type LivequeryDatasourceProps<OptionsType = {}, RawDataChangeType = {}, InjectType = any> = {
+    routes: LivequeryDatasourceOptions<OptionsType>;
+    deps: {
+        [name: string]: InjectType;
+    };
+    rawChanges: Observable<RawDataChangeType>;
+};
+export type LivequeryDatasource<OptionsType = {}, RawDataChangeType = {}, InjectType = any> = {
+    init(props: LivequeryDatasourceProps<OptionsType, RawDataChangeType, InjectType>): any;
     query(query: LivequeryRequest): any;
-    enable_realtime?: (stream: Observable<StreamPayload>) => Observable<WebsocketSyncPayload>;
+    $: Observable<WebsocketSyncPayload>;
 };
 export declare class MongooseDatasource implements LivequeryDatasource<RouteOptions, DatabaseEvent, Connection> {
     #private;
-    init(routes: MongooseDatasourceOptions<RouteOptions>, connections: {
-        [name: string]: Connection;
-    }): Promise<void>;
+    readonly $: Subject<WebsocketSyncPayload>;
+    init({ deps, rawChanges, routes }: LivequeryDatasourceProps<RouteOptions, DatabaseEvent, Connection>): void;
     query(query: LivequeryRequest): Promise<import("mongodb").DeleteResult | import("mongoose").UpdateWriteOpResult | {
         items: any[];
         summary: any;
@@ -41,12 +45,4 @@ export declare class MongooseDatasource implements LivequeryDatasource<RouteOpti
     } | {
         item: any;
     }>;
-    enable_realtime<T extends LivequeryBaseEntity = LivequeryBaseEntity>(d: Observable<DatabaseEvent>): Observable<{
-        new_data: LivequeryBaseEntity;
-        old_data: LivequeryBaseEntity;
-        table: string;
-        type: "added" | "removed" | "modified";
-        old_ref: string;
-        new_ref: string;
-    }>;
 }

package/build/src/MongooseDatasource.js

@@ -1,5 +1,5 @@
 import { Cursor } from './Cursor.js';
-import { map, mergeAll } from "rxjs";
+import { map, mergeAll, Subject, pipe } from "rxjs";
 import { MongoQuery } from "./MongoQuery.js";
 import { ObjectId } from 'bson';
 export class MongooseDatasource {
@@ -7,8 +7,10 @@ export class MongooseDatasource {
     #routes = new Map();
     #realtime_collections = new Map();
     #conections = {};
-    async init(routes, connections) {
-        this.#conections = { ...connections };
+    $ = new Subject;
+    init({ deps, rawChanges, routes }) {
+        this.#conections = { ...deps };
+        rawChanges.pipe(this.#stream()).subscribe(this.$);
         for (const { refs, ...options } of routes) {
             for (const ref of refs) {
                 const schema_ref = ref.replaceAll(':', '');
@@ -153,55 +155,55 @@ export class MongooseDatasource {
         }, {});
         return await model.deleteOne(keys);
     }
-    enable_realtime(d) {
-        function parse_refs(ref, o, n) {
-            const keys = ref.split('/').map((k, i) => {
-                if (i % 2 == 0)
-                    return { v: { old_ref: k, new_ref: k } };
-                if (Array.isArray(o[k]) || Array.isArray(n[k])) {
-                    return [
-                        ...Array.isArray(o[k]) ? o[k] : [],
-                        ...Array.isArray(n[k]) ? n[k] : []
-                    ].reduce((p, c) => {
-                        p.set(c, {
-                            old_ref: Array.isArray(o[k]) && o[k].includes(c) ? c : null,
-                            new_ref: Array.isArray(n[k]) && n[k].includes(c) ? c : null,
-                        });
-                        return p;
-                    }, new Map());
-                }
+    #caculateRef(arr) {
+        const v = arr[0];
+        const x = v instanceof Map ? [...v] : Object.entries(v);
+        return x.map(([k, w]) => {
+            const { old_ref, new_ref } = w;
+            const next = arr.slice(1);
+            if (next.length == 0)
+                return { old_ref, new_ref };
+            const n = this.#caculateRef(next);
+            return n.map(nn => {
                 return {
-                    v: {
-                        old_ref: o[k],
-                        new_ref: n[k]
-                    }
+                    old_ref: `${old_ref}/${nn.old_ref}`,
+                    new_ref: `${new_ref}/${nn.new_ref}`
                 };
             });
-            function parse(arr) {
-                const v = arr[0];
-                const x = v instanceof Map ? [...v] : Object.entries(v);
-                return x.map(([k, w]) => {
-                    const { old_ref, new_ref } = w;
-                    const next = arr.slice(1);
-                    if (next.length == 0)
-                        return { old_ref, new_ref };
-                    const n = parse(next);
-                    return n.map(nn => {
-                        return {
-                            old_ref: `${old_ref}/${nn.old_ref}`,
-                            new_ref: `${new_ref}/${nn.new_ref}`
-                        };
+        }).flat(2);
+    }
+    #parse(ref, o, n) {
+        const keys = ref.split('/').map((k, i) => {
+            if (i % 2 == 0)
+                return { v: { old_ref: k, new_ref: k } };
+            if (Array.isArray(o[k]) || Array.isArray(n[k])) {
+                return [
+                    ...Array.isArray(o[k]) ? o[k] : [],
+                    ...Array.isArray(n[k]) ? n[k] : []
+                ].reduce((p, c) => {
+                    p.set(c, {
+                        old_ref: Array.isArray(o[k]) && o[k].includes(c) ? c : null,
+                        new_ref: Array.isArray(n[k]) && n[k].includes(c) ? c : null,
                     });
-                }).flat(2);
+                    return p;
+                }, new Map());
             }
-            return parse(keys);
-        }
-        return d.pipe(map((event) => {
+            return {
+                v: {
+                    old_ref: o[k],
+                    new_ref: n[k]
+                }
+            };
+        });
+        return this.#caculateRef(keys);
+    }
+    #stream() {
+        return pipe(map((event) => {
             const refs = this.#realtime_collections.get(event.table);
             if (!refs)
                 return [];
             return [...refs].map(ref => {
-                const refs_list = parse_refs(ref, event.old_data, event.new_data);
+                const refs_list = this.#parse(ref, event.old_data, event.new_data);
                 return refs_list.map(({ new_ref, old_ref }) => ({
                     new_data: event.new_data,
                     old_data: event.old_data,

package/package.json

@@ -6,7 +6,7 @@
     "repository": {
         "url": "git@github.com:livequery/mongoose.git"
     },
-    "version": "2.0.25",
+    "version": "2.0.27",
     "description": "Mongoose datasource mapping for @livequery ecosystem",
     "main": "./build/src/index.js",
     "types": "./build/src/index.d.ts",