@livequery/nestjs 1.0.38 → 1.0.41

package/build/index.d.ts

@@ -1,5 +1,7 @@
-export * from './src/LivequeryRequest';
+export { LivequeryRequest } from './src/LivequeryRequest';
 export * from './src/LivequeryResponse';
 export * from './src/LivequeryInterceptor';
 export * from './src/LivequeryWebsocketSync';
-export * from './src/PathHelper';
+export * from './src/helpers/createDatasourceMapper';
+export { LivequeryDatasourceInterceptors } from './src/LivequeryDatasourceInterceptors';
+export { UseWebsocketPublicKey, UseWebsocketPrivateKey } from './src/UseWebsocketShareKeyPair';

package/build/index.js

@@ -14,8 +14,15 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./src/LivequeryRequest"), exports);
+exports.UseWebsocketPrivateKey = exports.UseWebsocketPublicKey = exports.LivequeryDatasourceInterceptors = exports.LivequeryRequest = void 0;
+var LivequeryRequest_1 = require("./src/LivequeryRequest");
+Object.defineProperty(exports, "LivequeryRequest", { enumerable: true, get: function () { return LivequeryRequest_1.LivequeryRequest; } });
 __exportStar(require("./src/LivequeryResponse"), exports);
 __exportStar(require("./src/LivequeryInterceptor"), exports);
 __exportStar(require("./src/LivequeryWebsocketSync"), exports);
-__exportStar(require("./src/PathHelper"), exports);
+__exportStar(require("./src/helpers/createDatasourceMapper"), exports);
+var LivequeryDatasourceInterceptors_1 = require("./src/LivequeryDatasourceInterceptors");
+Object.defineProperty(exports, "LivequeryDatasourceInterceptors", { enumerable: true, get: function () { return LivequeryDatasourceInterceptors_1.LivequeryDatasourceInterceptors; } });
+var UseWebsocketShareKeyPair_1 = require("./src/UseWebsocketShareKeyPair");
+Object.defineProperty(exports, "UseWebsocketPublicKey", { enumerable: true, get: function () { return UseWebsocketShareKeyPair_1.UseWebsocketPublicKey; } });
+Object.defineProperty(exports, "UseWebsocketPrivateKey", { enumerable: true, get: function () { return UseWebsocketShareKeyPair_1.UseWebsocketPrivateKey; } });

package/build/src/LivequeryDatasourceInterceptors.d.ts

@@ -0,0 +1,16 @@
+import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
+import { LivequeryRequest } from '@livequery/types';
+import { ModuleRef } from '@nestjs/core';
+export declare type DatasourceOptions<T> = Array<T & {
+    refs: string[];
+}>;
+export declare type Datasource<T = any> = {
+    query(query: LivequeryRequest): any;
+};
+export declare const DatasourceList: Map<new (...args: any[]) => Datasource, Datasource<any>>;
+export declare const $__datasource_factory_token: unique symbol;
+export declare class LivequeryDatasourceInterceptors implements NestInterceptor {
+    private moduleRef;
+    constructor(moduleRef: ModuleRef);
+    intercept(ctx: ExecutionContext, next: CallHandler): Promise<import("rxjs").Observable<any>>;
+}

package/build/src/LivequeryDatasourceInterceptors.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LivequeryDatasourceInterceptors = exports.$__datasource_factory_token = exports.DatasourceList = void 0;
+const common_1 = require("@nestjs/common");
+const rxjs_1 = require("rxjs");
+const core_1 = require("@nestjs/core");
+exports.DatasourceList = new Map();
+exports.$__datasource_factory_token = Symbol();
+let LivequeryDatasourceInterceptors = class LivequeryDatasourceInterceptors {
+    moduleRef;
+    constructor(moduleRef) {
+        this.moduleRef = moduleRef;
+    }
+    async intercept(ctx, next) {
+        const token = Reflect.getMetadata(exports.$__datasource_factory_token, ctx.getHandler());
+        const datasource = exports.DatasourceList.has(token) ? exports.DatasourceList.get(token) : this.moduleRef.get(token);
+        const req = ctx.switchToHttp().getRequest();
+        req.livequery_response = await datasource.query(req.livequery);
+        return next.handle().pipe((0, rxjs_1.map)(rs => rs ?? req.livequery_response));
+    }
+};
+LivequeryDatasourceInterceptors = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [core_1.ModuleRef])
+], LivequeryDatasourceInterceptors);
+exports.LivequeryDatasourceInterceptors = LivequeryDatasourceInterceptors;

package/build/src/LivequeryInterceptor.d.ts

@@ -1,10 +1,15 @@
 import { CallHandler, ExecutionContext, NestInterceptor } from "@nestjs/common";
-import { LivequeryWebsocketSync } from './LivequeryWebsocketSync';
+import { LivequeryWebsocketSync } from "./LivequeryWebsocketSync";
+export declare type RealtimeSubscription = {
+    collection_ref: string;
+    doc_id: string;
+};
 export declare class LivequeryInterceptor implements NestInterceptor {
     private LivequeryWebsocketSync;
-    constructor(LivequeryWebsocketSync?: LivequeryWebsocketSync);
-    intercept(context: ExecutionContext, next: CallHandler): import("rxjs").Observable<{
+    private secret_or_private_key;
+    constructor(LivequeryWebsocketSync: LivequeryWebsocketSync, secret_or_private_key: string);
+    intercept(context: ExecutionContext, next: CallHandler): Promise<import("rxjs").Observable<{
         data: any;
-    }>;
+    }>>;
 }
 export declare const UseLivequeryInterceptor: () => MethodDecorator & ClassDecorator;

package/build/src/LivequeryInterceptor.js

@@ -14,15 +14,19 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UseLivequeryInterceptor = exports.LivequeryInterceptor = void 0;
 const common_1 = require("@nestjs/common");
-const LivequeryWebsocketSync_1 = require("./LivequeryWebsocketSync");
 const operators_1 = require("rxjs/operators");
-const PathHelper_1 = require("./PathHelper");
+const PathHelper_1 = require("./helpers/PathHelper");
+const LivequeryWebsocketSync_1 = require("./LivequeryWebsocketSync");
+const UseWebsocketShareKeyPair_1 = require("./UseWebsocketShareKeyPair");
+const JWT = require('jsonwebtoken');
 let LivequeryInterceptor = class LivequeryInterceptor {
     LivequeryWebsocketSync;
-    constructor(LivequeryWebsocketSync = null) {
+    secret_or_private_key;
+    constructor(LivequeryWebsocketSync, secret_or_private_key) {
         this.LivequeryWebsocketSync = LivequeryWebsocketSync;
+        this.secret_or_private_key = secret_or_private_key;
     }
-    intercept(context, next) {
+    async intercept(context, next) {
         const req = context.switchToHttp().getRequest();
         const { _limit = 20, _cursor, _order_by, _sort, _select, ...rest } = req.query;
         const filters = Object
@@ -36,8 +40,8 @@ let LivequeryInterceptor = class LivequeryInterceptor {
                 return [name, expression || 'eq', rest[key]];
             }
         });
-        const { ref, is_collection, collection_ref, doc_id, } = PathHelper_1.PathHelper.livequeryPathExtractor(req._parsedUrl.pathname);
-        const { collection_ref: schema_collection_ref, ref: schema_ref } = PathHelper_1.PathHelper.livequeryPathExtractor(req.route.path);
+        const { ref, is_collection, collection_ref, doc_id, } = PathHelper_1.PathHelper.parseHttpRequestPath(req._parsedUrl.pathname);
+        const { collection_ref: schema_collection_ref, ref: schema_ref } = PathHelper_1.PathHelper.parseHttpRequestPath(req.route.path);
         req.livequery = {
             ref,
             schema_ref,
@@ -57,16 +61,22 @@ let LivequeryInterceptor = class LivequeryInterceptor {
             body: req.body,
             method: req.method.toLowerCase()
         };
-        console.log({ req: req.livequery });
-        const socket_id = req.headers.socket_id;
-        socket_id && this.LivequeryWebsocketSync?.listen(socket_id, collection_ref, doc_id);
-        return next.handle().pipe((0, operators_1.map)(data => ({ data })));
+        req.headers.socket_id && this.LivequeryWebsocketSync?.listen(req.headers.socket_id, { collection_ref, doc_id });
+        const realtime_token = await new Promise(s => {
+            if (this.LivequeryWebsocketSync || !this.secret_or_private_key || req.method.toLowerCase() != 'get' || req.query._cursor)
+                return s(null);
+            JWT.sign({ collection_ref, doc_id }, this.secret_or_private_key, {}, (error, data) => s(error ? null : data));
+        });
+        return next.handle().pipe((0, operators_1.map)(data => ({ data: { ...data, realtime_token } })));
     }
 };
 LivequeryInterceptor = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, common_1.Optional)()),
-    __metadata("design:paramtypes", [LivequeryWebsocketSync_1.LivequeryWebsocketSync])
+    __param(0, (0, common_1.Inject)((0, common_1.forwardRef)(() => LivequeryWebsocketSync_1.LivequeryWebsocketSync))),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, UseWebsocketShareKeyPair_1.InjectWebsocketPrivateKey)()),
+    __metadata("design:paramtypes", [LivequeryWebsocketSync_1.LivequeryWebsocketSync, String])
 ], LivequeryInterceptor);
 exports.LivequeryInterceptor = LivequeryInterceptor;
 const UseLivequeryInterceptor = () => (0, common_1.UseInterceptors)(LivequeryInterceptor);

package/build/src/LivequeryWebsocketSync.d.ts

@@ -1,20 +1,27 @@
-import { UpdatedData } from "@livequery/types";
 import { Subject } from "rxjs";
+import { LivequeryInterceptor, RealtimeSubscription } from "./LivequeryInterceptor";
+import { UpdatedData } from "@livequery/types";
 export declare class LivequeryWebsocketSync {
+    private secret_or_public_key;
     private connections;
     private refs;
     readonly changes: Subject<UpdatedData<any>>;
-    constructor();
+    constructor(secret_or_public_key: string, LivequeryInterceptor: LivequeryInterceptor);
     private handleDisconnect;
-    subscribe({ id }: {
+    start({ id }: {
         id: string;
     }, socket: WebSocket & {
         id: string;
     }): void;
+    subscribe({ realtime_token }: {
+        realtime_token: string;
+    }, socket: WebSocket & {
+        id: string;
+    }): Promise<void>;
     unsubscribe({ ref }: {
         ref: string;
     }, socket: WebSocket & {
         id: string;
     }): void;
-    listen(connection_id: string, collection_ref: string, doc_id?: string): void;
+    listen(connection_id: string, subscription: RealtimeSubscription): void;
 }

package/build/src/LivequeryWebsocketSync.js

@@ -15,51 +15,62 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.LivequeryWebsocketSync = void 0;
 const websockets_1 = require("@nestjs/websockets");
 const rxjs_1 = require("rxjs");
+const LivequeryInterceptor_1 = require("./LivequeryInterceptor");
+const uuid_1 = require("uuid");
+const common_1 = require("@nestjs/common");
+const UseWebsocketShareKeyPair_1 = require("./UseWebsocketShareKeyPair");
+const JWT = require('jsonwebtoken');
 let LivequeryWebsocketSync = class LivequeryWebsocketSync {
+    secret_or_public_key;
     connections = new Map();
     refs = new Map();
     changes = new rxjs_1.Subject();
-    constructor() {
-        this.changes.subscribe(({ ref, data, type }) => {
-            const refs = ref.split('/');
-            const collection_ref = refs.length % 2 == 1 ? ref : refs.slice(0, refs.length - 1).join('/');
+    constructor(secret_or_public_key, LivequeryInterceptor) {
+        this.secret_or_public_key = secret_or_public_key;
+        if (!LivequeryInterceptor && !secret_or_public_key)
+            throw new Error('Missing api-websocket key pair, please use UseWebsocketPublicKey in providers list');
+        this.changes.subscribe(({ ref, data, type, ...rest }) => {
             const connections = new Set([
-                ...this.refs.get(collection_ref) || [],
-                ...this.refs.get(`${collection_ref}/${data.id}`) || []
+                ...this.refs.get(ref)?.values() || [],
+                ...this.refs.get(`${ref}/${data.id}`)?.values() || []
             ]);
-            if (!connections)
-                return;
-            const payload = JSON.stringify({ event: 'sync', data: { changes: [{ ref, data, type }] } });
-            for (const cid of connections) {
-                const connection = this.connections.get(cid);
-                connection && connection.socket.OPEN && connection.socket.send(payload);
+            if (connections.size > 0) {
+                const payload = JSON.stringify({ event: 'sync', data: { changes: [{ ref, data, type }] } });
+                connections.forEach(({ socket }) => socket.OPEN && socket.send(payload));
             }
         });
     }
     async handleDisconnect(socket) {
-        for (const ref of this.connections.get(socket.id)?.refs || []) {
+        this.connections.get(socket.id)?.refs.forEach(ref => {
             this.refs.get(ref)?.delete(socket.id);
-        }
+        });
         this.connections.delete(socket.id);
     }
-    subscribe({ id }, socket) {
-        this.connections.set(id, { refs: new Set(), socket });
-        socket.id = id;
+    start({ id = (0, uuid_1.v4)() }, socket) {
+        if (typeof id == 'string' && id.length < 40) {
+            socket.id = id;
+            this.connections.set(id, { socket, refs: new Set() });
+        }
+    }
+    async subscribe({ realtime_token }, socket) {
+        if (realtime_token && this.secret_or_public_key) {
+            const options = await new Promise(s => JWT.verify(realtime_token, this.secret_or_public_key, {}, (error, data) => s(error ? null : data)));
+            options && this.listen(socket.id, options);
+        }
     }
     unsubscribe({ ref }, socket) {
-        if (!this.connections.has(socket.id))
-            return;
-        this.connections.get(socket.id)?.refs?.delete(ref);
+        this.connections.get(socket.id)?.refs.delete(ref);
         this.refs.get(ref)?.delete(socket.id);
-        this.refs.get(ref)?.size == 0 && this.refs.delete(ref);
     }
-    listen(connection_id, collection_ref, doc_id) {
-        const cnn = this.connections.get(connection_id);
-        if (cnn) {
+    listen(connection_id, subscription) {
+        const connection = this.connections.get(connection_id);
+        if (connection) {
+            const { collection_ref, doc_id } = subscription;
             const ref = `${collection_ref}${doc_id ? `/${doc_id}` : ''}`;
-            !cnn.refs.has(collection_ref) && cnn.refs.add(ref);
-            !this.refs.has(ref) && this.refs.set(ref, new Set());
-            this.refs.get(ref).add(connection_id);
+            const { socket, refs } = connection;
+            refs.add(ref);
+            !this.refs.has(ref) && this.refs.set(ref, new Map());
+            !this.refs.get(ref).has(connection_id) && this.refs.get(ref).set(connection_id, { socket });
         }
     }
 };
@@ -70,6 +81,14 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object, Object]),
     __metadata("design:returntype", void 0)
+], LivequeryWebsocketSync.prototype, "start", null);
+__decorate([
+    (0, websockets_1.SubscribeMessage)('subscribe'),
+    __param(0, (0, websockets_1.MessageBody)()),
+    __param(1, (0, websockets_1.ConnectedSocket)()),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Object, Object]),
+    __metadata("design:returntype", Promise)
 ], LivequeryWebsocketSync.prototype, "subscribe", null);
 __decorate([
     (0, websockets_1.SubscribeMessage)('unsubscribe'),
@@ -81,6 +100,10 @@ __decorate([
 ], LivequeryWebsocketSync.prototype, "unsubscribe", null);
 LivequeryWebsocketSync = __decorate([
     (0, websockets_1.WebSocketGateway)({ path: process.env.REALTIME_UPDATE_SOCKET_PATH || '/livequery/realtime-updates' }),
-    __metadata("design:paramtypes", [])
+    __param(0, (0, common_1.Optional)()),
+    __param(0, (0, UseWebsocketShareKeyPair_1.InjectWebsocketPublicKey)()),
+    __param(1, (0, common_1.Optional)()),
+    __param(1, (0, common_1.Inject)((0, common_1.forwardRef)(() => LivequeryInterceptor_1.LivequeryInterceptor))),
+    __metadata("design:paramtypes", [String, LivequeryInterceptor_1.LivequeryInterceptor])
 ], LivequeryWebsocketSync);
 exports.LivequeryWebsocketSync = LivequeryWebsocketSync;

package/build/src/PathHelper.d.ts

@@ -1,11 +1,11 @@
 export declare class PathHelper {
-    #private;
-    static livequeryPathExtractor(path: string): {
+    static trimLivequeryHotkey(path: string): string;
+    static parseHttpRequestPath(path: string): {
         ref: string;
         schema_ref: string;
         is_collection: boolean;
         doc_id: string;
         collection_ref: string;
     };
-    static nestjsPathResolver(target: Function, method: string): string[];
+    static join(a: string | string[], b: string | string[]): string[];
 }

package/build/src/PathHelper.js

@@ -3,9 +3,21 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PathHelper = void 0;
 const const_1 = require("./const");
 class PathHelper {
-    static #toArray = (a) => typeof a == 'string' ? [a] : a;
-    static livequeryPathExtractor(path) {
+    static trimLivequeryHotkey(path) {
+        const ref = path
+            ?.split('~')[0]
+            ?.replaceAll(':', '')
+            ?.split(const_1.LIVEQUERY_MAGIC_KEY)?.[1]
+            ?.split('/')
+            ?.filter(s => s.length > 0)
+            ?.join('/');
+        if (!ref)
+            throw 'LIVEQUERY_MAGIC_KEY_NOT_FOUND';
+        return ref;
+    }
+    static parseHttpRequestPath(path) {
         const refs = path
+            ?.split('~')[0]
             ?.replaceAll(':', '')
             ?.split(const_1.LIVEQUERY_MAGIC_KEY)?.[1]
             ?.split('/')
@@ -19,10 +31,14 @@ class PathHelper {
         const doc_id = is_collection ? null : refs[refs.length - 1];
         return { ref, schema_ref, is_collection, doc_id, collection_ref };
     }
-    static nestjsPathResolver(target, method) {
-        const collection_paths = this.#toArray(Reflect.getMetadata('path', target) || '');
-        const method_paths = this.#toArray(Reflect.getMetadata('path', target.prototype[method]) || '');
-        return collection_paths.map(collection_path => method_paths.map(method_path => `${collection_path}/${method_path}`)).flat(2);
+    static join(a, b) {
+        return [a || '']
+            .flat(2)
+            .map(r1 => [b || ''].flat(2).map(r2 => `${r1}/${r2}`))
+            .flat(2)
+            .map(r => r.split('/')
+            .filter(r => r != '')
+            .join('/'));
     }
 }
 exports.PathHelper = PathHelper;

package/build/src/UseWebsocketShareKeyPair.d.ts

@@ -0,0 +1,5 @@
+import { Provider } from "@nestjs/common";
+export declare const InjectWebsocketPublicKey: () => (target: object, key: string | symbol, index?: number) => void;
+export declare const InjectWebsocketPrivateKey: () => (target: object, key: string | symbol, index?: number) => void;
+export declare const UseWebsocketPublicKey: (secret_or_public_key: string) => Provider<any>;
+export declare const UseWebsocketPrivateKey: (secret_or_private_key: string) => Provider<any>;

package/build/src/UseWebsocketShareKeyPair.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UseWebsocketPrivateKey = exports.UseWebsocketPublicKey = exports.InjectWebsocketPrivateKey = exports.InjectWebsocketPublicKey = void 0;
+const common_1 = require("@nestjs/common");
+const WebsocketPublicKey = 'WebsocketPublicKey';
+const WebsocketPrivateKey = 'WebsocketPrivateKey';
+const InjectWebsocketPublicKey = () => (0, common_1.Inject)(WebsocketPublicKey);
+exports.InjectWebsocketPublicKey = InjectWebsocketPublicKey;
+const InjectWebsocketPrivateKey = () => (0, common_1.Inject)(WebsocketPrivateKey);
+exports.InjectWebsocketPrivateKey = InjectWebsocketPrivateKey;
+const UseWebsocketPublicKey = (secret_or_public_key) => ({
+    provide: WebsocketPublicKey,
+    useFactory: () => secret_or_public_key
+});
+exports.UseWebsocketPublicKey = UseWebsocketPublicKey;
+const UseWebsocketPrivateKey = (secret_or_private_key) => ({
+    provide: WebsocketPrivateKey,
+    useFactory: () => secret_or_private_key
+});
+exports.UseWebsocketPrivateKey = UseWebsocketPrivateKey;

package/build/src/createDatasourceMapper.d.ts

@@ -0,0 +1,6 @@
+import { Provider } from "@nestjs/common";
+import { Datasource, DatasourceOptions } from "./LivequeryDatasourceInterceptors";
+export declare const createDatasourceMapper: <T extends {}>(datasource_factory: new (...args: any[]) => Datasource) => [({ useFactory, inject }: {
+    useFactory: (options: DatasourceOptions<T>, ...injects: any[]) => Datasource<T> | Promise<Datasource<T>>;
+    inject?: any[];
+}) => Provider<any>, (options: T) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void];

package/build/src/createDatasourceMapper.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDatasourceMapper = void 0;
+const common_1 = require("@nestjs/common");
+const LivequeryDatasourceInterceptors_1 = require("./LivequeryDatasourceInterceptors");
+const LivequeryInterceptor_1 = require("./LivequeryInterceptor");
+const PathHelper_1 = require("./PathHelper");
+const createDatasourceMapper = (datasource_factory) => {
+    const RouteConfigList = [];
+    const decorator = (options) => (0, common_1.applyDecorators)((target, method) => RouteConfigList.push({ target, method, options }), (0, LivequeryInterceptor_1.UseLivequeryInterceptor)(), (0, common_1.UseInterceptors)(LivequeryDatasourceInterceptors_1.LivequeryDatasourceInterceptors), (target, method, descriptor) => {
+        Reflect.defineMetadata(LivequeryDatasourceInterceptors_1.$__datasource_factory_token, datasource_factory, descriptor.value);
+    });
+    const UseDatasource = ({ useFactory, inject }) => {
+        return {
+            provide: datasource_factory,
+            inject,
+            useFactory: async (...injects) => {
+                const options = RouteConfigList.map(config => {
+                    return {
+                        ...(config.options || {}),
+                        refs: PathHelper_1.PathHelper.join(Reflect.getMetadata('path', config.target.constructor), Reflect.getMetadata('path', config.target[config.method])).map(PathHelper_1.PathHelper.trimLivequeryHotkey)
+                    };
+                });
+                const datasource = await useFactory(options, ...injects);
+                LivequeryDatasourceInterceptors_1.DatasourceList.set(datasource_factory, datasource);
+                return datasource;
+            }
+        };
+    };
+    return [UseDatasource, decorator];
+};
+exports.createDatasourceMapper = createDatasourceMapper;

package/build/src/helpers/PathHelper.d.ts

@@ -0,0 +1,11 @@
+export declare class PathHelper {
+    static trimLivequeryHotkey(path: string): string;
+    static parseHttpRequestPath(path: string): {
+        ref: string;
+        schema_ref: string;
+        is_collection: boolean;
+        doc_id: string;
+        collection_ref: string;
+    };
+    static join(a: string | string[], b: string | string[]): string[];
+}

package/build/src/helpers/PathHelper.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PathHelper = void 0;
+const const_1 = require("../const");
+class PathHelper {
+    static trimLivequeryHotkey(path) {
+        const ref = path
+            ?.split('~')[0]
+            ?.replaceAll(':', '')
+            ?.split(const_1.LIVEQUERY_MAGIC_KEY)?.[1]
+            ?.split('/')
+            ?.filter(s => s.length > 0)
+            ?.join('/');
+        if (!ref)
+            throw 'LIVEQUERY_MAGIC_KEY_NOT_FOUND';
+        return ref;
+    }
+    static parseHttpRequestPath(path) {
+        const refs = path
+            ?.split('~')[0]
+            ?.replaceAll(':', '')
+            ?.split(const_1.LIVEQUERY_MAGIC_KEY)?.[1]
+            ?.split('/')
+            ?.filter(s => s.length > 0);
+        if (!refs)
+            throw 'LIVEQUERY_MAGIC_KEY_NOT_FOUND';
+        const is_collection = refs.length % 2 == 1;
+        const ref = refs.join('/');
+        const collection_ref = is_collection ? ref : refs.slice(0, refs.length - 1).join('/');
+        const schema_ref = refs.filter((_, i) => i % 2 == 0).join('/');
+        const doc_id = is_collection ? null : refs[refs.length - 1];
+        return { ref, schema_ref, is_collection, doc_id, collection_ref };
+    }
+    static join(a, b) {
+        return [a || '']
+            .flat(2)
+            .map(r1 => [b || ''].flat(2).map(r2 => `${r1}/${r2}`))
+            .flat(2)
+            .map(r => r.split('/')
+            .filter(r => r != '')
+            .join('/'));
+    }
+}
+exports.PathHelper = PathHelper;

package/build/src/helpers/createDatasourceMapper.d.ts

@@ -0,0 +1,6 @@
+import { Provider } from "@nestjs/common";
+import { Datasource, DatasourceOptions } from "../LivequeryDatasourceInterceptors";
+export declare const createDatasourceMapper: <T extends {}>(datasource_factory: new (...args: any[]) => Datasource) => [({ useFactory, inject }: {
+    useFactory: (options: DatasourceOptions<T>, ...injects: any[]) => Datasource<T> | Promise<Datasource<T>>;
+    inject?: any[];
+}) => Provider<any>, (options: T) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void];

package/build/src/helpers/createDatasourceMapper.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDatasourceMapper = void 0;
+const common_1 = require("@nestjs/common");
+const LivequeryDatasourceInterceptors_1 = require("../LivequeryDatasourceInterceptors");
+const LivequeryInterceptor_1 = require("../LivequeryInterceptor");
+const PathHelper_1 = require("./PathHelper");
+const createDatasourceMapper = (datasource_factory) => {
+    const RouteConfigList = [];
+    const decorator = (options) => (0, common_1.applyDecorators)((target, method) => RouteConfigList.push({ target, method, options }), (0, LivequeryInterceptor_1.UseLivequeryInterceptor)(), (0, common_1.UseInterceptors)(LivequeryDatasourceInterceptors_1.LivequeryDatasourceInterceptors), (target, method, descriptor) => {
+        Reflect.defineMetadata(LivequeryDatasourceInterceptors_1.$__datasource_factory_token, datasource_factory, descriptor.value);
+    });
+    const UseDatasource = ({ useFactory, inject }) => {
+        return {
+            provide: datasource_factory,
+            inject,
+            useFactory: async (...injects) => {
+                const options = RouteConfigList.map(config => {
+                    return {
+                        ...(config.options || {}),
+                        refs: PathHelper_1.PathHelper.join(Reflect.getMetadata('path', config.target.constructor), Reflect.getMetadata('path', config.target[config.method])).map(PathHelper_1.PathHelper.trimLivequeryHotkey)
+                    };
+                });
+                const datasource = await useFactory(options, ...injects);
+                LivequeryDatasourceInterceptors_1.DatasourceList.set(datasource_factory, datasource);
+                return datasource;
+            }
+        };
+    };
+    return [UseDatasource, decorator];
+};
+exports.createDatasourceMapper = createDatasourceMapper;

package/package.json

@@ -3,7 +3,7 @@
     "repository": {
         "url": "git@github.com:livequery/nestjs.git"
     },
-    "version": "1.0.38",
+    "version": "1.0.41",
     "description": "",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -11,14 +11,14 @@
         "build/**/*"
     ],
     "devDependencies": {
-        "@livequery/types": "^1.0.34",
-        "@nestjs/common": "^8.2.3",
-        "@nestjs/core": "^8.2.3",
-        "@nestjs/websockets": "^8.2.3",
-        "@types/express": "^4.17.11",
-        "@types/node": "^14.14.20",
-        "reflect-metadata": "^0.1.13",
-        "rxjs": "^7.4.0"
+        "@livequery/types": "1.x",
+        "@nestjs/common": "8.x",
+        "@nestjs/core": "8.x",
+        "@nestjs/websockets": "8.x",
+        "@types/express": "4.x",
+        "@types/node": "14.x",
+        "reflect-metadata": "0.x",
+        "rxjs": "^.x"
     },
     "peerDependencies": {
         "@nestjs/common": "^7.6.17",
@@ -33,5 +33,9 @@
         "deploy": "yarn build; git add .; git commit -m \"Update\"; git push origin master; npm publish --access public"
     },
     "author": "",
-    "license": "ISC"
+    "license": "ISC",
+    "dependencies": {
+        "@types/jsonwebtoken": "^8.5.8",
+        "jsonwebtoken": "^8.5.1"
+    }
 }

package/build/src/UseDatasource.d.ts

@@ -1,28 +0,0 @@
-import { LivequeryRequest } from "@livequery/types";
-import { CallHandler, ExecutionContext } from "@nestjs/common";
-import { ModuleRef, Reflector } from "@nestjs/core";
-declare type Datasource = {
-    query(req: LivequeryRequest): Promise<any>;
-};
-export declare class UseDatasource {
-    private moduleRef;
-    private reflector;
-    private static ControllerList;
-    constructor(moduleRef: ModuleRef, reflector: Reflector);
-    static createDatasourceMapper<T = {}>(factory: {
-        new (): Datasource;
-    }): [(options: T & {
-        _manual_query?: boolean;
-    }) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol, descriptor?: TypedPropertyDescriptor<Y>) => void, () => {
-        paths: {
-            ref: string;
-            schema_ref: string;
-            is_collection: boolean;
-            doc_id: string;
-            collection_ref: string;
-        }[];
-        options: T;
-    }[]];
-    intercept(context: ExecutionContext, next: CallHandler): Promise<import("rxjs").Observable<any>>;
-}
-export {};

package/build/src/UseDatasource.js

@@ -1,59 +0,0 @@
-"use strict";
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
-};
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
-};
-var UseDatasource_1;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UseDatasource = void 0;
-const common_1 = require("@nestjs/common");
-const core_1 = require("@nestjs/core");
-const LivequeryInterceptor_1 = require("./LivequeryInterceptor");
-const LivequeryRequest_1 = require("./LivequeryRequest");
-const PathHelper_1 = require("./PathHelper");
-const rxjs_1 = require("rxjs");
-let UseDatasource = UseDatasource_1 = class UseDatasource {
-    moduleRef;
-    reflector;
-    static ControllerList = [];
-    constructor(moduleRef, reflector) {
-        this.moduleRef = moduleRef;
-        this.reflector = reflector;
-    }
-    static createDatasourceMapper(factory) {
-        const decorator = (options) => (0, common_1.applyDecorators)((0, common_1.UseInterceptors)(LivequeryInterceptor_1.LivequeryInterceptor), ...options._manual_query == true ? [] : [
-            (0, common_1.SetMetadata)(UseDatasource_1, { options, factory }),
-            (0, common_1.UseInterceptors)(this)
-        ], (target, method) => this.ControllerList.push({
-            target: target.constructor,
-            method,
-            options
-        }));
-        const list = () => this.ControllerList.map(({ method, target, options }) => {
-            const paths = PathHelper_1.PathHelper.nestjsPathResolver(target, method).map(path => {
-                return PathHelper_1.PathHelper.livequeryPathExtractor(path);
-            });
-            return { paths, options: options };
-        }).flat(2);
-        return [decorator, list];
-    }
-    async intercept(context, next) {
-        const request = context.switchToHttp().getRequest();
-        const livequery = request[LivequeryRequest_1.LivequeryRequestKey];
-        const { factory } = this.reflector.get(UseDatasource_1, context.getHandler());
-        const ds = await this.moduleRef.get(factory);
-        const result = await ds.query(livequery);
-        return next.handle().pipe((0, rxjs_1.map)(data => data ?? result));
-    }
-};
-UseDatasource = UseDatasource_1 = __decorate([
-    (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [core_1.ModuleRef,
-        core_1.Reflector])
-], UseDatasource);
-exports.UseDatasource = UseDatasource;