proto.io 0.0.209 → 0.0.210

package/dist/index.mjs

@@ -1,10 +1,10 @@
 import _ from 'lodash';
 import { Server } from '@o2ter/server-js';
-import { Q as QueryValidator, r as resolveColumn, a as resolveDataType, g as generateId } from './internals/random-ZgzzM5v_.mjs';
+import { Q as QueryValidator, r as resolveColumn, a as resolveDataType, g as generateId } from './internals/random-ycCeBd0S.mjs';
 import { P as PVK } from './internals/private-CNw40LZ7.mjs';
 import { prototypes, asyncStream, isBinaryData, base64ToBuffer } from '@o2ter/utils-js';
-import { T as TQuery, d as deserialize, P as PROTO_NOTY_MSG, M as MASTER_USER_HEADER_NAME, a as MASTER_PASS_HEADER_NAME, A as AUTH_COOKIE_KEY, b as TUser, c as ProtoType, _ as _logLevels, s as serialize, U as UPLOAD_TOKEN_HEADER_NAME } from './internals/index-Eo70ZAdZ.mjs';
-export { e as ProtoClient, f as classExtends, k as isFile, l as isJob, g as isObject, i as isQuery, j as isRole, h as isUser } from './internals/index-Eo70ZAdZ.mjs';
+import { L as LiveQuerySubscription, T as TQuery, d as deserialize, s as serialize, a as TUser, P as ProtoType, _ as _logLevels } from './internals/index-BgSBzm-K.mjs';
+export { b as ProtoClient, c as classExtends, h as isFile, j as isJob, e as isObject, i as isQuery, g as isRole, f as isUser } from './internals/index-BgSBzm-K.mjs';
 import { i as isPointer, a as isRelation, T as TObject, b as isShape, d as defaultObjectKeyTypes, c as isPrimitive } from './internals/index-al1N-qi7.mjs';
 import jwt from 'jsonwebtoken';
 import { Blob } from 'node:buffer';
@@ -12,8 +12,9 @@ import { Readable } from 'node:stream';
 import { scrypt } from 'node:crypto';
 import { promisify } from 'util';
 import { randomBytes, randomUUID } from '@o2ter/crypto-js';
+import { P as PROTO_NOTY_MSG, a as PROTO_LIVEQUERY_MSG, M as MASTER_USER_HEADER_NAME, b as MASTER_PASS_HEADER_NAME, A as AUTH_COOKIE_KEY, U as UPLOAD_TOKEN_HEADER_NAME } from './internals/const-Dkp7Nsv5.mjs';
+import { Q as QuerySelector } from './internals/index-DPPLcZx8.mjs';
 export { Decimal } from 'decimal.js';
-import { Q as QuerySelector } from './internals/index-DlY33lfO.mjs';
 import queryType from 'query-types';
 import busboy from 'busboy';
 import 'axios';
@@ -335,6 +336,17 @@ class _ProtoQuery extends TQuery {
                 })();
             }
         }
+        if (this._proto.schema[this.className]?.liveQuery) {
+            (async () => {
+                try {
+                    await this._proto[PVK].publishLiveQuery(this._proto, 'create', _.filter(objects, x => x.__v === 0));
+                    await this._proto[PVK].publishLiveQuery(this._proto, 'update', _.filter(objects, x => x.__v !== 0));
+                }
+                catch (e) {
+                    this._proto.logger.error(e);
+                }
+            })();
+        }
     }
     _on_delete(objects) {
         const traggers = this._proto[PVK].triggers[this.className]?.delete ?? [];
@@ -350,6 +362,16 @@ class _ProtoQuery extends TQuery {
                 })();
             }
         }
+        if (this._proto.schema[this.className]?.liveQuery) {
+            (async () => {
+                try {
+                    await this._proto[PVK].publishLiveQuery(this._proto, 'delete', objects);
+                }
+                catch (e) {
+                    this._proto.logger.error(e);
+                }
+            })();
+        }
     }
     async insertMany(values, options) {
         const objs = this._objectMethods(await this._dispatcher(options).insert({
@@ -395,6 +417,9 @@ class ProtoQuery extends _ProtoQuery {
         clone[PVK].options = options ?? { ...this[PVK].options };
         return clone;
     }
+    subscribe() {
+        return new LiveQuerySubscription(this.className, this._proto, this[PVK].options.filter ?? []);
+    }
 }
 class ProtoRelationQuery extends _ProtoQuery {
     constructor(proto, opts) {
@@ -412,6 +437,9 @@ class ProtoRelationQuery extends _ProtoQuery {
         clone[PVK].options = options ?? { ...this[PVK].options };
         return clone;
     }
+    subscribe() {
+        throw Error('Unable to subscribe to relationship query');
+    }
 }
 
 //
@@ -752,6 +780,7 @@ const mergeSchema = (...schemas) => _.reduce(schemas, (acc, schema) => ({
             ]),
             ...(s.indexes ?? []),
         ],
+        liveQuery: acc[className]?.liveQuery || s.liveQuery,
     })),
 }), {});
 class ProtoInternal {
@@ -1023,9 +1052,39 @@ class ProtoInternal {
                 const { _rperm } = payload;
                 (async () => {
                     try {
-                        if (isMaster || _.some(await roles, x => _.includes(_rperm, x))) {
-                            callback(payload);
-                        }
+                        if (!isMaster && !_.some(await roles, x => _.includes(_rperm, x)))
+                            return;
+                        await callback(payload);
+                    }
+                    catch (e) {
+                        proto.logger.error(e);
+                    }
+                })();
+            }),
+        };
+    }
+    async publishLiveQuery(proto, event, objects) {
+        if (_.isEmpty(objects))
+            return;
+        return this.options.pubsub.publish(PROTO_LIVEQUERY_MSG, JSON.parse(serialize({ event, objects }, { objAttrs: TObject.defaultKeys })));
+    }
+    _liveQuery(proto, callback) {
+        const isMaster = proto.isMaster;
+        const roles = isMaster ? [] : this._perms(proto);
+        return {
+            remove: this.options.pubsub.subscribe(PROTO_LIVEQUERY_MSG, payload => {
+                const { event, objects } = deserialize(JSON.stringify(payload));
+                (async () => {
+                    try {
+                        const _roles = await roles;
+                        const payload = proto.rebind(_.filter(objects, object => {
+                            if (isMaster)
+                                return true;
+                            const acl = object.acl();
+                            const clp = proto.schema[object.className].classLevelPermissions?.get ?? ['*'];
+                            return _.some(_roles, x => _.includes(clp, x) && _.includes(acl.read, x));
+                        }));
+                        await callback(event, payload);
                     }
                     catch (e) {
                         proto.logger.error(e);
@@ -1034,6 +1093,26 @@ class ProtoInternal {
             }),
         };
     }
+    liveQuery(proto, event, className, filter, callback) {
+        const _filter = _.isEmpty(filter) ? true : QuerySelector.decode(filter);
+        return this._liveQuery(proto, (ev, objs) => {
+            if (event !== ev)
+                return;
+            for (const object of objs) {
+                if (className !== object.className)
+                    continue;
+                (async () => {
+                    try {
+                        if (_filter === true || _filter.eval(object))
+                            await callback(object);
+                    }
+                    catch (e) {
+                        proto.logger.error(e);
+                    }
+                })();
+            }
+        });
+    }
     validateCLPs(className, acls, keys) {
         if (!_.has(this.options.schema, className))
             throw Error('No permission');
@@ -1637,10 +1716,10 @@ class ProtoService extends ProtoType {
     }
     listen(callback, selector) {
         const _selector = !_.isNil(selector) ? QuerySelector.decode(selector) : undefined;
-        return this[PVK].listen(this, data => {
+        return this[PVK].listen(this, async (data) => {
             if (_selector && !_selector.eval(data))
                 return;
-            callback(data);
+            await callback(data);
         });
     }
     refs(object, options) {
@@ -2511,15 +2590,34 @@ const ProtoRoute = async (options) => {
 const registerProtoSocket = (proto, server, endpoint) => {
     const io = endpoint ? server.socket().of(endpoint) : server.socket();
     io.on('connection', async (socket) => {
-        let listeners = {};
+        let events = {};
+        let queries = {};
         const connect = async (token) => {
             const payload = await proto.connectWithSessionToken(token);
-            const { remove } = payload.listen(data => {
-                const ids = _.keys(_.pickBy(listeners, v => v instanceof QuerySelector ? v.eval(data) : v));
+            const { remove: remove_basic } = payload.listen(data => {
+                const ids = _.keys(_.pickBy(events, v => v instanceof QuerySelector ? v.eval(data) : v));
+                const payload = JSON.parse(serialize(data));
                 if (!_.isEmpty(ids))
-                    socket.emit('data', { ids, data });
+                    socket.emit('ON_EV_NOTIFY', { ids, data: payload });
+            });
+            const { remove: remove_livequery } = payload[PVK]._liveQuery(payload, (ev, objs) => {
+                const ids = {};
+                for (const obj of objs) {
+                    ids[obj.objectId] = _.keys(_.pickBy(queries, v => {
+                        if (v.event !== ev || v.className !== obj.className)
+                            return false;
+                        return v.filter instanceof QuerySelector ? v.filter.eval(obj) : v.filter;
+                    }));
+                }
+                if (_.isEmpty(ids))
+                    return;
+                const payload = JSON.parse(serialize(_.filter(objs, obj => !_.isEmpty(ids[obj.objectId]))));
+                socket.emit('ON_EV_LIVEQUERY', { ids, data: payload });
             });
-            return remove;
+            return () => {
+                remove_basic();
+                remove_livequery();
+            };
         };
         const { token } = socket.handshake.auth;
         let remove = connect(token);
@@ -2530,8 +2628,8 @@ const registerProtoSocket = (proto, server, endpoint) => {
         socket.on('disconnect', () => {
             remove.then(rm => rm());
         });
-        socket.on('register', (payload) => {
-            listeners = _.mapValues(payload, v => {
+        socket.on('EV_NOTIFY', (payload) => {
+            events = _.mapValues(payload, v => {
                 if (_.isBoolean(v))
                     return true;
                 try {
@@ -2543,6 +2641,20 @@ const registerProtoSocket = (proto, server, endpoint) => {
                 }
             });
         });
+        socket.on('EV_LIVEQUERY', (payload) => {
+            queries = _.mapValues(payload, v => {
+                const { event = '', className = '', filter } = v ?? {};
+                if (_.isBoolean(v))
+                    return { event, className, filter: true };
+                try {
+                    return { event, className, filter: QuerySelector.decode(filter) };
+                }
+                catch (error) {
+                    proto.logger.error(error);
+                    return { event, className, filter: false };
+                }
+            });
+        });
     });
     return io;
 };