@livequery/mongoose 2.0.27 → 2.0.47

package/build/src/MongooseDatasource.d.ts

@@ -1,27 +1,12 @@
 import { RouteOptions } from "./RouteOptions.js";
-import { LivequeryRequest, WebsocketSyncPayload, DatabaseEvent } from '@livequery/types';
-import { Observable, Subject } from "rxjs";
-import { Connection } from 'mongoose';
-export type LivequeryDatasourceOptions<T> = Array<T & {
-    refs: string[];
-}>;
-export type LivequeryDatasourceProps<OptionsType = {}, RawDataChangeType = {}, InjectType = any> = {
-    routes: LivequeryDatasourceOptions<OptionsType>;
-    deps: {
-        [name: string]: InjectType;
-    };
-    rawChanges: Observable<RawDataChangeType>;
+import { LivequeryRequest, LivequeryBaseEntity } from '@livequery/types';
+import mongoose, { Connection } from 'mongoose';
+export type LivequeryDatasource<T> = {
+    query(query: LivequeryRequest, options: T, connection: any): any;
 };
-export type LivequeryDatasource<OptionsType = {}, RawDataChangeType = {}, InjectType = any> = {
-    init(props: LivequeryDatasourceProps<OptionsType, RawDataChangeType, InjectType>): any;
-    query(query: LivequeryRequest): any;
-    $: Observable<WebsocketSyncPayload>;
-};
-export declare class MongooseDatasource implements LivequeryDatasource<RouteOptions, DatabaseEvent, Connection> {
+export declare class MongooseDatasource implements LivequeryDatasource<RouteOptions> {
     #private;
-    readonly $: Subject<WebsocketSyncPayload>;
-    init({ deps, rawChanges, routes }: LivequeryDatasourceProps<RouteOptions, DatabaseEvent, Connection>): 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: {
@@ -45,4 +30,15 @@ export declare class MongooseDatasource implements LivequeryDatasource<RouteOpti
     } | {
         item: any;
     }>;
+    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,46 +1,19 @@
 import { Cursor } from './Cursor.js';
-import { map, mergeAll, Subject, pipe } 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 = {};
-    $ = 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(':', '');
-                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')
@@ -155,64 +128,32 @@ export class MongooseDatasource {
         }, {});
         return await model.deleteOne(keys);
     }
-    #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 {
-                    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,
-                    });
-                    return p;
-                }, new Map());
-            }
-            return {
-                v: {
-                    old_ref: o[k],
-                    new_ref: n[k]
+    #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 this.#caculateRef(keys);
+                return p;
+            }, {})
+        };
     }
-    #stream() {
-        return pipe(map((event) => {
-            const refs = this.#realtime_collections.get(event.table);
-            if (!refs)
-                return [];
-            return [...refs].map(ref => {
-                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,
-                    table: event.table,
-                    type: event.type,
-                    old_ref,
-                    new_ref
-                }));
-            });
-        }), mergeAll(), mergeAll());
+    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.27",
+    "version": "2.0.47",
     "description": "Mongoose datasource mapping for @livequery ecosystem",
     "main": "./build/src/index.js",
     "types": "./build/src/index.d.ts",