@livequery/nestjs 1.0.40 → 1.0.41

package/build/index.d.ts

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

package/build/index.js

@@ -14,12 +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 });
-exports.LivequeryDatasourceInterceptors = exports.LivequeryRequest = void 0;
+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/createDatasourceMapper"), 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/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
@@ -57,15 +61,22 @@ let LivequeryInterceptor = class LivequeryInterceptor {
             body: req.body,
             method: req.method.toLowerCase()
         };
-        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/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/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.40",
+    "version": "1.0.41",
     "description": "",
     "main": "build/index.js",
     "types": "build/index.d.ts",
@@ -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"
+    }
+}