@livequery/mongoose 2.0.51 → 2.0.53

package/build/src/MongooseDatasource.d.ts

@@ -1,14 +1,36 @@
-import { RouteOptions } from "./RouteOptions.js";
-import { LivequeryRequest, WebsocketSyncPayload } from '@livequery/types';
-import mongoose, { Connection } from 'mongoose';
+import { LivequeryRequest, LivequeryBaseEntity, WebsocketSyncPayload } from '@livequery/types';
+import mongoose, { Connection, Schema } from 'mongoose';
 import { Subject } from 'rxjs/internal/Subject';
-export type LivequeryDatasource<T> = {
-    query(query: LivequeryRequest, options: T, connection: any): any;
+import { Observable } from 'rxjs';
+export type LivequeryDatasource<RouteOptions> = Observable<WebsocketSyncPayload<LivequeryBaseEntity>> & {
+    init: (routes: Array<{
+        path: string;
+        options: RouteOptions;
+    }>) => any;
+    query?: (query: LivequeryRequest, options: RouteOptions) => any;
+};
+export type MongooseDatasourceConfig = {
+    connections: {
+        [key: string]: Connection;
+    };
+    databases: string[];
+};
+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<RouteOptions> {
     #private;
+    private config;
     readonly refs: Map<string, Set<string>>;
-    query(_: LivequeryRequest, config: RouteOptions, connection: Connection): 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: {
@@ -32,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,22 +3,34 @@ 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(_, config, connection) {
-        const db = typeof config.db == 'function' ? await config.db(_) : config.db || process.env.DB_NAME || 'main';
-        const schema = config.schema;
+    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 () => {
+        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(_, schema);
-        if (query.method == 'get') {
-            config.realtime && this.#log(query, model);
+        const query = await this.#normalizeRef(req, schema);
+        if (query.method == 'get')
             return await this.#get(query, model);
-        }
         if (query.method == 'post')
             return this.#post(query, model);
         if (query.method == 'put')
@@ -29,12 +41,6 @@ export class MongooseDatasource extends Subject {
             return this.#del(query, model);
         throw { status: 500, code: 'INVAILD_METHOD', message: 'Invaild method' };
     }
-    #log(req, model) {
-        const _ = this.refs.get(model.collection.name);
-        const set = _ || new Set();
-        set.add(req.collection_ref);
-        !_ && this.refs.set(model.collection.name, set);
-    }
     async #get(req, model) {
         const { limit, items, count, has, summary } = await MongoQuery.query(req, model);
         const current = items.length;
@@ -151,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';
@@ -165,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/build/src/index.d.ts

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

package/build/src/index.js

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

package/build/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"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"}
+{"root":["../src/cursor.ts","../src/datachangepayload.ts","../src/mongoquery.ts","../src/mongoosedatasource.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.51",
+    "version": "2.0.53",
     "description": "Mongoose datasource mapping for @livequery ecosystem",
     "main": "./build/src/index.js",
     "types": "./build/src/index.d.ts",
@@ -32,7 +32,7 @@
         "build": "rm -rf build; tsc -b .",
         "deploy": "rm -rf build && yarn build; git add .; git commit -m \"Update\"; git push origin master; npm publish --access public"
     },
-    "dependencies": {
+    "peerDependencies": {
         "bson": "*",
         "mongoose": "^8.6.2"
     }

package/build/src/RouteOptions.d.ts

@@ -1,7 +0,0 @@
-import { LivequeryRequest } from "@livequery/types";
-import { Schema } from "mongoose";
-export type RouteOptions<T = any> = {
-    realtime?: boolean;
-    schema: Schema<T>;
-    db?: string | ((req: LivequeryRequest) => Promise<string> | string);
-};

package/build/src/RouteOptions.js

@@ -1 +0,0 @@
-export {};