proto.io 0.0.205 → 0.0.207

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-6nHcBOxn.mjs';
+import { Q as QueryValidator, r as resolveColumn, a as resolveDataType, g as generateId } from './internals/random-ZgzzM5v_.mjs';
 import { P as PVK } from './internals/private-CNw40LZ7.mjs';
 import { asyncStream, prototypes, 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, s as serialize, U as UPLOAD_TOKEN_HEADER_NAME } from './internals/index-DtCgllhg.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-DtCgllhg.mjs';
+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, s as serialize, U as UPLOAD_TOKEN_HEADER_NAME } from './internals/index-DAkcqabS.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-DAkcqabS.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';
@@ -13,7 +13,7 @@ import { scrypt } from 'node:crypto';
 import { promisify } from 'util';
 import { randomBytes, randomUUID } from '@o2ter/crypto-js';
 export { Decimal } from 'decimal.js';
-import { Q as QuerySelector } from './internals/index-Blw7vAq5.mjs';
+import { Q as QuerySelector } from './internals/index-DlY33lfO.mjs';
 import queryType from 'query-types';
 import busboy from 'busboy';
 import 'axios';
@@ -85,6 +85,7 @@ const dispatcher = (proto, options) => {
         master: options.master ?? false,
         disableSecurity: options.disableSecurity,
     });
+    const createFile = options.createFile;
     return {
         async explain(query) {
             QueryValidator.recursiveCheck(query);
@@ -131,35 +132,9 @@ const dispatcher = (proto, options) => {
                 throw Error('No permission');
             return proto.storage.random(decoded, opts);
         },
-        async insert(options, attrs) {
-            QueryValidator.recursiveCheck(attrs);
-            const _validator = await validator();
-            _validator.validateCountMatches(options.className, options.countMatches ?? []);
-            const _includes = _validator.decodeIncludes(options.className, options.includes ?? ['*']);
-            const _matches = _validator.decodeMatches(options.className, options.matches ?? {}, _includes);
-            if (!_validator.validateCLPs(options.className, 'create'))
-                throw Error('No permission');
-            const _attrs = normalize(_validator.validateFields(options.className, attrs, 'create', QueryValidator.patterns.path));
-            while (true) {
-                try {
-                    return await proto.storage.atomic((storage) => storage.insert({
-                        className: options.className,
-                        includes: _includes,
-                        matches: _matches,
-                        countMatches: options.countMatches ?? [],
-                        objectIdSize: proto[PVK].options.objectIdSize
-                    }, _attrs), { lockTable: options.className, retry: true });
-                }
-                catch (e) {
-                    if (proto.storage.isDuplicateIdError(e))
-                        continue;
-                    throw e;
-                }
-            }
-        },
-        async insertMany(options, values) {
-            if (options.className === 'File')
-                throw Error('File is not support insertMany');
+        async insert(options, values) {
+            if (!createFile && options.className === 'File')
+                throw Error('File is not support insert');
             QueryValidator.recursiveCheck(values);
             const _validator = await validator();
             _validator.validateCountMatches(options.className, options.countMatches ?? []);
@@ -170,7 +145,7 @@ const dispatcher = (proto, options) => {
             const _attrs = normalize(_.map(values, attr => _validator.validateFields(options.className, attr, 'create', QueryValidator.patterns.path)));
             while (true) {
                 try {
-                    return await proto.storage.atomic((storage) => storage.insertMany({
+                    return await proto.storage.atomic((storage) => storage.insert({
                         className: options.className,
                         includes: _includes,
                         matches: _matches,
@@ -185,44 +160,16 @@ const dispatcher = (proto, options) => {
                 }
             }
         },
-        async updateOne(query, update) {
-            QueryValidator.recursiveCheck(query, update);
-            const _validator = await validator();
-            if (!_validator.validateCLPs(query.className, 'update'))
-                throw Error('No permission');
-            return proto.storage.atomic((storage) => storage.updateOne(_validator.decodeQuery(normalize(query), 'update'), normalize(_validator.validateFields(query.className, update, 'update', QueryValidator.patterns.path))));
-        },
-        async updateMany(query, update) {
+        async update(query, update) {
             QueryValidator.recursiveCheck(query, update);
             const _validator = await validator();
             if (!_validator.validateCLPs(query.className, 'update'))
                 throw Error('No permission');
-            return proto.storage.atomic((storage) => storage.updateMany(_validator.decodeQuery(normalize(query), 'update'), normalize(_validator.validateFields(query.className, update, 'update', QueryValidator.patterns.path))));
-        },
-        async upsertOne(query, update, setOnInsert) {
-            if (query.className === 'File')
-                throw Error('File is not support upsertOne');
-            QueryValidator.recursiveCheck(query, update, setOnInsert);
-            const _validator = await validator();
-            if (!_validator.validateCLPs(query.className, 'create', 'update'))
-                throw Error('No permission');
-            const _query = _validator.decodeQuery(normalize(query), 'update');
-            const _update = normalize(_validator.validateFields(query.className, update, 'update', QueryValidator.patterns.path));
-            const _setOnInsert = normalize(_validator.validateFields(query.className, setOnInsert, 'create', QueryValidator.patterns.path));
-            while (true) {
-                try {
-                    return await proto.storage.atomic((storage) => storage.upsertOne(_query, _update, _setOnInsert), { lockTable: query.className, retry: true });
-                }
-                catch (e) {
-                    if (proto.storage.isDuplicateIdError(e))
-                        continue;
-                    throw e;
-                }
-            }
+            return proto.storage.atomic((storage) => storage.update(_validator.decodeQuery(normalize(query), 'update'), normalize(_validator.validateFields(query.className, update, 'update', QueryValidator.patterns.path))));
         },
-        async upsertMany(query, update, setOnInsert) {
+        async upsert(query, update, setOnInsert) {
             if (query.className === 'File')
-                throw Error('File is not support upsertOne');
+                throw Error('File is not support upsert');
             QueryValidator.recursiveCheck(query, update, setOnInsert);
             const _validator = await validator();
             if (!_validator.validateCLPs(query.className, 'create', 'update'))
@@ -232,7 +179,7 @@ const dispatcher = (proto, options) => {
             const _setOnInsert = normalize(_validator.validateFields(query.className, setOnInsert, 'create', QueryValidator.patterns.path));
             while (true) {
                 try {
-                    return await proto.storage.atomic((storage) => storage.upsertMany(_query, _update, _setOnInsert), { lockTable: query.className, retry: true });
+                    return await proto.storage.atomic((storage) => storage.upsert(_query, _update, _setOnInsert), { lockTable: query.className, retry: true });
                 }
                 catch (e) {
                     if (proto.storage.isDuplicateIdError(e))
@@ -241,19 +188,12 @@ const dispatcher = (proto, options) => {
                 }
             }
         },
-        async deleteOne(query) {
+        async delete(query) {
             QueryValidator.recursiveCheck(query);
             const _validator = await validator();
             if (!_validator.validateCLPs(query.className, 'delete'))
                 throw Error('No permission');
-            return proto.storage.atomic((storage) => storage.deleteOne(_validator.decodeQuery(normalize(query), 'update')));
-        },
-        async deleteMany(query) {
-            QueryValidator.recursiveCheck(query);
-            const _validator = await validator();
-            if (!_validator.validateCLPs(query.className, 'delete'))
-                throw Error('No permission');
-            return proto.storage.atomic((storage) => storage.deleteMany(_validator.decodeQuery(normalize(query), 'update')));
+            return proto.storage.atomic((storage) => storage.delete(_validator.decodeQuery(normalize(query), 'update')));
         },
     };
 };
@@ -308,6 +248,7 @@ class _ProtoQuery extends TQuery {
         return dispatcher(_serviceOf(options) ?? this._proto, {
             ...options ?? {},
             disableSecurity: !!this._opts.insecure,
+            createFile: !!this._opts.createFile,
         });
     }
     explain(options) {
@@ -343,45 +284,22 @@ class _ProtoQuery extends TQuery {
                 yield self._objectMethods(object);
         });
     }
-    async insert(attrs, options) {
-        const result = this._objectMethods(await this._dispatcher(options).insert({
-            className: this.className,
-            includes: this[PVK].options.includes,
-            matches: this[PVK].options.matches,
-            countMatches: this[PVK].options.countMatches,
-        }, attrs));
-        if (!result)
-            throw Error('Unable to insert document');
-        return result;
-    }
     async insertMany(values, options) {
-        return this._dispatcher(options).insertMany({
+        return this._objectMethods(await this._dispatcher(options).insert({
             className: this.className,
             includes: this[PVK].options.includes,
             matches: this[PVK].options.matches,
             countMatches: this[PVK].options.countMatches,
-        }, values);
-    }
-    async updateOne(update, options) {
-        return this._objectMethods(await this._dispatcher(options).updateOne(this._queryOptions, update));
+        }, values));
     }
     async updateMany(update, options) {
-        return this._dispatcher(options).updateMany(this._queryOptions, update);
-    }
-    async upsertOne(update, setOnInsert, options) {
-        const result = this._objectMethods(await this._dispatcher(options).upsertOne(this._queryOptions, update, setOnInsert));
-        if (!result)
-            throw Error('Unable to upsert document');
-        return result;
+        return this._objectMethods(await this._dispatcher(options).update(this._queryOptions, update));
     }
     async upsertMany(update, setOnInsert, options) {
-        return this._dispatcher(options).upsertMany(this._queryOptions, update, setOnInsert);
-    }
-    async deleteOne(options) {
-        return this._objectMethods(await this._dispatcher(options).deleteOne(this._queryOptions));
+        return this._objectMethods(await this._dispatcher(options).upsert(this._queryOptions, update, setOnInsert));
     }
     async deleteMany(options) {
-        return this._dispatcher(options).deleteMany(this._queryOptions);
+        return this._objectMethods(await this._dispatcher(options).delete(this._queryOptions));
     }
 }
 class ProtoQuery extends _ProtoQuery {
@@ -958,9 +876,8 @@ class ProtoInternal {
             object.set('size', file.size);
             if (nonce)
                 object.set('nonce', nonce);
-            const created = await proto.Query('File')
-                .includes(...object.keys())
-                .insert(_.fromPairs([...object._set_entries()]), options);
+            const query = new ProtoQuery('File', proto, { createFile: true });
+            const created = await query.includes(...object.keys()).insert(_.fromPairs([...object._set_entries()]), options);
             if (created) {
                 object[PVK].attributes = created.attributes;
                 object[PVK].mutated = {};
@@ -1640,8 +1557,11 @@ class ProtoService extends ProtoType {
     notify(data) {
         return this[PVK].notify(this, data);
     }
-    listen(callback) {
+    listen(callback, selector) {
+        const _selector = !_.isNil(selector) ? QuerySelector.decode(selector) : undefined;
         return this[PVK].listen(this, data => {
+            if (_selector && !_selector.eval(data))
+                return;
             callback(data);
         });
     }
@@ -1673,7 +1593,7 @@ class ProtoService extends ProtoType {
                         await this.fileStorage.destroy(this, token);
                 }
             }
-            await this.storage.deleteMany({
+            await this.storage.delete({
                 className,
                 filter: QuerySelector.decode({ _expired_at: { $lt: time } }),
                 includes: ['_id', '_expired_at'],
@@ -2513,10 +2433,13 @@ 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 = {};
         const connect = async (token) => {
             const payload = await proto.connectWithSessionToken(token);
             const { remove } = payload.listen(data => {
-                socket.emit('data', data);
+                const ids = _.keys(_.pickBy(listeners, v => v instanceof QuerySelector ? v.eval(data) : v));
+                if (!_.isEmpty(ids))
+                    socket.emit('data', { ids, data });
             });
             return remove;
         };
@@ -2529,6 +2452,19 @@ const registerProtoSocket = (proto, server, endpoint) => {
         socket.on('disconnect', () => {
             remove.then(rm => rm());
         });
+        socket.on('register', (payload) => {
+            listeners = _.mapValues(payload, v => {
+                if (_.isBoolean(v))
+                    return true;
+                try {
+                    return QuerySelector.decode(v);
+                }
+                catch (error) {
+                    console.error(error);
+                    return false;
+                }
+            });
+        });
     });
     return io;
 };