@livequery/mongoose 2.0.52 → 2.0.54

package/build/src/MongooseDatasource.d.ts

@@ -1,13 +1,13 @@
 import { LivequeryRequest, LivequeryBaseEntity, WebsocketSyncPayload } from '@livequery/types';
 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<{
+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, config: Config, options: RouteOptions) => any;
+    }>): Promise<void>;
+    query: (query: LivequeryRequest, options: RouteOptions) => Promise<any>;
 };
 export type MongooseDatasourceConfig = {
     connections: {
@@ -19,11 +19,19 @@ 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<LivequeryBaseEntity>> implements LivequeryDatasource<MongooseDatasourceConfig, RouteOptions> {
     #private;
     readonly refs: Map<string, Set<string>>;
-    query(req: LivequeryRequest, config: MongooseDatasourceConfig, options: RouteOptions): Promise<mongoose.mongo.DeleteResult | mongoose.UpdateWriteOpResult | {
+    config: MongooseDatasourceConfig;
+    routes: Map<string, RouteOptions<any>>;
+    init(config: MongooseDatasourceConfig, routes: Array<{
+        path: string;
+        method: number;
+        options: RouteOptions;
+    }>): Promise<void>;
+    query(req: LivequeryRequest, options: RouteOptions): Promise<mongoose.mongo.DeleteResult | mongoose.UpdateWriteOpResult | {
         items: any[];
         summary: any;
         has: {
@@ -47,5 +55,4 @@ export declare class MongooseDatasource extends Subject<WebsocketSyncPayload<any
     } | {
         item: any;
     }>;
-    normalizeRef(req: LivequeryRequest, schema: mongoose.Schema): Promise<LivequeryRequest>;
 }

package/build/src/MongooseDatasource.js

@@ -2,19 +2,35 @@ import { Cursor } from './Cursor.js';
 import { MongoQuery } from "./MongoQuery.js";
 import { ObjectId } from 'bson';
 import { SmartCache } from './SmartCache.js';
-import { Subject } from 'rxjs/internal/Subject';
+import { Subject } from 'rxjs';
 export class MongooseDatasource extends Subject {
     #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';
+    config;
+    routes;
+    async init(config, routes) {
+        this.config = config;
+        this.routes = routes.reduce((p, c) => {
+            const set = p.get(c.path);
+            if (set && set.schema != c.options.schema)
+                throw new Error('Schema mismatch for route path "' + c.path + '"');
+            p.set(c.path, c.options);
+            return p;
+        }, new Map());
+    }
+    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 +159,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';

package/build/src/index.d.ts

@@ -1,2 +1,2 @@
-export { MongooseDatasource, LivequeryDatasource, MongooseDatasourceConfig, RouteOptions } from './MongooseDatasource.js';
+export * from './MongooseDatasource.js';
 export * from './DataChangePayload.js';

package/build/src/index.js

@@ -1,2 +1,2 @@
-export { MongooseDatasource } from './MongooseDatasource.js';
+export * from './MongooseDatasource.js';
 export * from './DataChangePayload.js';

package/package.json

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