@livequery/mongoose 2.0.25 → 2.0.47

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,23 +1,12 @@
 import { RouteOptions } from "./RouteOptions.js";
-import { LivequeryRequest, LivequeryBaseEntity, WebsocketSyncPayload, DatabaseEvent } from '@livequery/types';
-import { Observable } from "rxjs";
-import { Connection } from 'mongoose';
-export type MongooseDatasourceOptions<T> = Array<T & {
-    refs: string[];
-}>;
-export type LivequeryDatasource<Options = {}, StreamPayload = {}, Connection = any> = {
-    init(routes: MongooseDatasourceOptions<Options>, connections: {
-        [name: string]: Connection;
-    }): Promise<void>;
-    query(query: LivequeryRequest): any;
-    enable_realtime?: (stream: Observable<StreamPayload>) => Observable<WebsocketSyncPayload>;
+import { LivequeryRequest, LivequeryBaseEntity } from '@livequery/types';
+import mongoose, { Connection } from 'mongoose';
+export type LivequeryDatasource<T> = {
+    query(query: LivequeryRequest, options: T, connection: any): any;
 };
-export declare class MongooseDatasource implements LivequeryDatasource<RouteOptions, DatabaseEvent, Connection> {
+export declare class MongooseDatasource implements LivequeryDatasource<RouteOptions> {
     #private;
-    init(routes: MongooseDatasourceOptions<RouteOptions>, connections: {
-        [name: string]: Connection;
-    }): Promise<void>;
-    query(query: LivequeryRequest): Promise<import("mongodb").DeleteResult | import("mongoose").UpdateWriteOpResult | {
+    query(_: LivequeryRequest, config: RouteOptions, connection: Connection): Promise<mongoose.mongo.DeleteResult | mongoose.UpdateWriteOpResult | {
         items: any[];
         summary: any;
         has: {
@@ -41,12 +30,15 @@ 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;
+    normalizeRef(req: LivequeryRequest, schema: mongoose.Schema): Promise<LivequeryRequest | {
+        keys: any;
+        body: any;
+        ref: string;
+        is_collection: boolean;
+        collection_ref: string;
+        schema_collection_ref: string;
+        doc_id?: string;
+        options: import("@livequery/types").QueryOption<LivequeryBaseEntity>;
+        method?: string;
     }>;
 }

package/build/src/MongooseDatasource.js

@@ -1,44 +1,19 @@
 import { Cursor } from './Cursor.js';
-import { map, mergeAll } from "rxjs";
 import { MongoQuery } from "./MongoQuery.js";
+import mongoose from 'mongoose';
 import { ObjectId } from 'bson';
+import { SmartCache } from './SmartCache.js';
 export class MongooseDatasource {
-    #refs = new Map();
-    #routes = new Map();
-    #realtime_collections = new Map();
-    #conections = {};
-    async init(routes, connections) {
-        this.#conections = { ...connections };
-        for (const { refs, ...options } of routes) {
-            for (const ref of refs) {
-                const schema_ref = ref.replaceAll(':', '');
-                this.#routes.set(schema_ref, options);
-                this.#refs.set(options.schema, new Set([
-                    ...this.#refs.get(options.schema) || [],
-                    ref
-                ]));
-                if (options.realtime) {
-                    const table_name = options.schema.options.collection;
-                    const $ = schema_ref.split('/');
-                    const is_collection_ref = $.length % 2 == 1;
-                    this.#realtime_collections.set(table_name, new Set([
-                        ...this.#realtime_collections.get(table_name) || [],
-                        is_collection_ref ? schema_ref : $.slice(0, -1).join('/'),
-                        schema_ref
-                    ]));
-                }
-            }
-        }
-    }
-    async query(query) {
-        const config = this.#routes.get(query.schema_ref);
-        if (!config)
-            throw { status: 500, code: 'REF_NOT_FOUND', message: 'Missing ref config in livequery system' };
-        const db = await config.db?.(query) || process.env.DB_NAME;
-        const connection = config.connection ? this.#conections[await config.connection(query)] : Object.values(this.#conections)[0];
+    #schemas = new SmartCache();
+    #models = new SmartCache();
+    async query(_, config, connection) {
+        const db = typeof config.db == 'function' ? await config.db(_) : config.db || process.env.DB_NAME || 'main';
         const schema = config.schema;
         const collection_name = schema.options.collection;
-        const model = connection.useDb(db).model(collection_name, schema, collection_name, schema.options);
+        const model = await this.#models.get(`${db}::${collection_name}`, async () => {
+            return connection.model(collection_name, schema, collection_name);
+        });
+        const query = await this.normalizeRef(_, schema);
         if (query.method == 'get')
             return await this.#get(query, model);
         if (query.method == 'post')
@@ -153,64 +128,32 @@ 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());
+    #convert(obj, fields) {
+        return {
+            ...obj,
+            ...[...fields].reduce((p, c) => {
+                if (obj[c] && typeof obj[c] == 'string' && mongoose.Types.ObjectId.isValid(obj[c])) {
+                    return {
+                        ...p,
+                        [c]: new mongoose.Types.ObjectId(obj[c])
+                    };
                 }
-                return {
-                    v: {
-                        old_ref: o[k],
-                        new_ref: n[k]
-                    }
-                };
-            });
-            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);
-            }
-            return parse(keys);
-        }
-        return d.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);
-                return refs_list.map(({ new_ref, old_ref }) => ({
-                    new_data: event.new_data,
-                    old_data: event.old_data,
-                    table: event.table,
-                    type: event.type,
-                    old_ref,
-                    new_ref
-                }));
-            });
-        }), mergeAll(), mergeAll());
+                return p;
+            }, {})
+        };
+    }
+    async normalizeRef(req, schema) {
+        const fields = await this.#schemas.get(schema, async () => {
+            return new Set(Object.entries(schema.paths).filter(([k, v]) => {
+                return v.instance == 'ObjectID';
+            }).map(([k, v]) => k));
+        });
+        if (fields.size == 0)
+            return req;
+        return {
+            ...req,
+            keys: this.#convert(req.keys, fields),
+            body: this.#convert(req.body, fields)
+        };
     }
 }

package/build/src/RouteOptions.d.ts

@@ -3,6 +3,6 @@ import { Schema } from "mongoose";
 export type RouteOptions<T = any> = {
     realtime?: boolean;
     schema: Schema<T>;
-    connection?: (req: LivequeryRequest) => Promise<string> | string;
-    db?: (req: LivequeryRequest) => Promise<string> | string;
+    db?: string | ((req: LivequeryRequest) => Promise<string> | string);
+    object_ids_fields: string[];
 };

package/build/src/SmartCache.d.ts

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

package/build/src/SmartCache.js

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

package/build/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["../src/cursor.ts","../src/datachangepayload.ts","../src/mongoquery.ts","../src/mongoosedatasource.ts","../src/routeoptions.ts","../src/index.ts"],"version":"5.6.2"}
+{"root":["../src/cursor.ts","../src/datachangepayload.ts","../src/mongoquery.ts","../src/mongoosedatasource.ts","../src/routeoptions.ts","../src/smartcache.ts","../src/index.ts"],"version":"5.9.3"}

package/package.json

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