@livequery/mongoose 2.0.52 → 2.0.53

package/build/src/MongooseDatasource.d.ts

@@ -2,12 +2,12 @@ import { LivequeryRequest, LivequeryBaseEntity, WebsocketSyncPayload } from '@li
 import mongoose, { Connection, Schema } from 'mongoose';
 import { Subject } from 'rxjs/internal/Subject';
 import { Observable } from 'rxjs';
-export type LivequeryDatasource<Config, RouteOptions> = Observable<WebsocketSyncPayload<LivequeryBaseEntity>> & {
-    init?: (config: Config, options: Array<{
+export type LivequeryDatasource<RouteOptions> = Observable<WebsocketSyncPayload<LivequeryBaseEntity>> & {
+    init: (routes: Array<{
         path: string;
         options: RouteOptions;
-    }>) => Promise<void>;
-    query?: (query: LivequeryRequest, config: Config, options: RouteOptions) => any;
+    }>) => any;
+    query?: (query: LivequeryRequest, options: RouteOptions) => any;
 };
 export type MongooseDatasourceConfig = {
     connections: {
@@ -19,11 +19,18 @@ export type RouteOptions<T = any> = {
     realtime?: boolean;
     schema: Schema<T>;
     db?: string | ((req: LivequeryRequest) => Promise<string> | string);
+    connection?: string | ((req: LivequeryRequest) => Promise<string> | string);
 };
-export declare class MongooseDatasource extends Subject<WebsocketSyncPayload<any>> implements LivequeryDatasource<MongooseDatasourceConfig, RouteOptions> {
+export declare class MongooseDatasource extends Subject<WebsocketSyncPayload<any>> implements LivequeryDatasource<RouteOptions> {
     #private;
+    private config;
     readonly refs: Map<string, Set<string>>;
-    query(req: LivequeryRequest, config: MongooseDatasourceConfig, options: RouteOptions): Promise<mongoose.mongo.DeleteResult | mongoose.UpdateWriteOpResult | {
+    constructor(config: MongooseDatasourceConfig);
+    init(routes: {
+        path: string;
+        options: RouteOptions<any>;
+    }[]): Promise<void>;
+    query(req: LivequeryRequest, options: RouteOptions): Promise<mongoose.UpdateWriteOpResult | mongoose.mongo.DeleteResult | {
         items: any[];
         summary: any;
         has: {
@@ -47,5 +54,8 @@ export declare class MongooseDatasource extends Subject<WebsocketSyncPayload<any
     } | {
         item: any;
     }>;
-    normalizeRef(req: LivequeryRequest, schema: mongoose.Schema): Promise<LivequeryRequest>;
+    link(watcher: (routes: Array<{
+        path: string;
+        options: RouteOptions;
+    }>, config: MongooseDatasourceConfig) => Observable<WebsocketSyncPayload>): import("rxjs").Subscription;
 }

package/build/src/MongooseDatasource.js

@@ -3,18 +3,32 @@ import { MongoQuery } from "./MongoQuery.js";
 import { ObjectId } from 'bson';
 import { SmartCache } from './SmartCache.js';
 import { Subject } from 'rxjs/internal/Subject';
+import { BehaviorSubject, switchMap } from 'rxjs';
 export class MongooseDatasource extends Subject {
+    config;
     #schemas = new SmartCache();
     #models = new SmartCache();
     refs = new Map();
-    async query(req, config, options) {
-        const db = typeof options.db == 'function' ? await options.db(req) : options.db || process.env.DB_NAME || 'main';
+    constructor(config) {
+        super();
+        this.config = config;
+    }
+    #routes$ = new BehaviorSubject([]);
+    async init(routes) {
+        this.#routes$.next(routes);
+    }
+    async query(req, options) {
+        const connection_name = typeof options.connection == 'function' ? await options.connection(req) : (options.connection || Object.keys(this.config.connections)[0] || 'default');
+        const db = typeof options.db == 'function' ? await options.db(req) : (options.db || process.env.DB_NAME || 'main');
         const schema = options.schema;
         const collection_name = schema.options.collection;
-        const model = await this.#models.get(`${db}|${collection_name}`, async () => {
-            return config.connections[db].model(collection_name, schema, collection_name);
+        const model = await this.#models.get(`${collection_name}|${db}|${collection_name}`, async () => {
+            const connection = this.config.connections[connection_name];
+            if (!connection)
+                throw { status: 500, code: 'DB_CONNECTION_NOT_FOUND', message: `Database connection "${connection_name}" not found` };
+            return connection.model(collection_name, schema, collection_name);
         });
-        const query = await this.normalizeRef(req, schema);
+        const query = await this.#normalizeRef(req, schema);
         if (query.method == 'get')
             return await this.#get(query, model);
         if (query.method == 'post')
@@ -143,7 +157,7 @@ export class MongooseDatasource extends Subject {
             }, {})
         };
     }
-    async normalizeRef(req, schema) {
+    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 == 'Array' ? v.getEmbeddedSchemaType().instance : v.instance) == 'ObjectId';
@@ -157,4 +171,7 @@ export class MongooseDatasource extends Subject {
             ...req.body ? { body: this.#convert(req.body, fields) } : {}
         };
     }
+    link(watcher) {
+        return this.#routes$.pipe(switchMap(routes => watcher(routes, this.config))).subscribe();
+    }
 }

package/package.json

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