proto.io 0.0.171 → 0.0.173

package/dist/client.d.ts

@@ -1,7 +1,7 @@
-import { P as ProtoClient } from './internals/index-D_GYwO8X.js';
-export { c as classExtends, e as isFile, a as isObject, i as isQuery, d as isRole, b as isUser } from './internals/index-D_GYwO8X.js';
+import { P as ProtoClient } from './internals/index-Cpv1DoEI.js';
+export { c as classExtends, e as isFile, a as isObject, i as isQuery, d as isRole, b as isUser } from './internals/index-Cpv1DoEI.js';
 export { Decimal } from 'decimal.js';
-export { D as DeserializeOptions, S as SerializeOptions, d as TSerializable, e as deserialize, s as serialize } from './internals/index-BB2vDnq0.js';
+export { D as DeserializeOptions, S as SerializeOptions, d as TSerializable, e as deserialize, s as serialize } from './internals/index-lX-M76Tn.js';
 import '@o2ter/utils-js';
 import 'socket.io-client';
 import '@socket.io/component-emitter';

package/dist/client.js

@@ -2,7 +2,7 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var index = require('./internals/index-BJP46VGq.js');
+var index = require('./internals/index-CIecB6mS.js');
 var Decimal = require('decimal.js');
 require('./internals/index-CVutVPmd.js');
 require('lodash');

package/dist/client.mjs

@@ -1,5 +1,5 @@
-import { c as ProtoClient } from './internals/index-D0hHgn2P.mjs';
-export { e as classExtends, d as deserialize, j as isFile, f as isObject, i as isQuery, h as isRole, g as isUser, s as serialize } from './internals/index-D0hHgn2P.mjs';
+import { c as ProtoClient } from './internals/index-BZNPlw1L.mjs';
+export { e as classExtends, d as deserialize, j as isFile, f as isObject, i as isQuery, h as isRole, g as isUser, s as serialize } from './internals/index-BZNPlw1L.mjs';
 export { Decimal } from 'decimal.js';
 import './internals/index-BYbMU-Ao.mjs';
 import 'lodash';

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import * as socket_io from 'socket.io';
 import { Router } from 'express';
 import { Server } from '@o2ter/server-js';
-import { T as TSchema, _ as _TValue, P as ProtoService, a as ProtoServiceOptions, b as ProtoServiceKeyOptions } from './internals/index-BB2vDnq0.js';
-export { D as DeserializeOptions, S as SerializeOptions, c as TFileStorage, d as TSerializable, e as deserialize, s as serialize } from './internals/index-BB2vDnq0.js';
+import { T as TSchema, _ as _TValue, P as ProtoService, a as ProtoServiceOptions, b as ProtoServiceKeyOptions } from './internals/index-lX-M76Tn.js';
+export { D as DeserializeOptions, S as SerializeOptions, c as TFileStorage, d as TSerializable, e as deserialize, s as serialize } from './internals/index-lX-M76Tn.js';
 import Decimal from 'decimal.js';
 export { Decimal } from 'decimal.js';
-export { P as ProtoClient, c as classExtends, e as isFile, a as isObject, i as isQuery, d as isRole, b as isUser } from './internals/index-D_GYwO8X.js';
+export { P as ProtoClient, c as classExtends, e as isFile, a as isObject, i as isQuery, d as isRole, b as isUser } from './internals/index-Cpv1DoEI.js';
 import '@o2ter/utils-js';
 import 'jsonwebtoken';
 import 'lodash';

package/dist/index.js

@@ -7,7 +7,7 @@ var serverJs = require('@o2ter/server-js');
 var random = require('./internals/random-Dytum6Nh.js');
 var _private = require('./internals/private-CSB1Ep4g.js');
 var utilsJs = require('@o2ter/utils-js');
-var index = require('./internals/index-BJP46VGq.js');
+var index = require('./internals/index-CIecB6mS.js');
 var index$1 = require('./internals/index-CVutVPmd.js');
 var jwt = require('jsonwebtoken');
 var node_buffer = require('node:buffer');
@@ -186,6 +186,13 @@ const dispatcher = (proto, options, disableSecurity) => {
                 throw Error('No permission');
             return proto.storage.atomic((storage) => storage.updateOne(_validator.decodeQuery(normalize(query), 'update'), normalize(_validator.validateFields(query.className, update, 'update', random.QueryValidator.patterns.path))));
         },
+        async updateMany(query, update) {
+            random.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', random.QueryValidator.patterns.path))));
+        },
         async upsertOne(query, update, setOnInsert) {
             random.QueryValidator.recursiveCheck(query, update, setOnInsert);
             const _validator = await validator();
@@ -205,6 +212,25 @@ const dispatcher = (proto, options, disableSecurity) => {
                 }
             }
         },
+        async upsertMany(query, update, setOnInsert) {
+            random.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', random.QueryValidator.patterns.path));
+            const _setOnInsert = normalize(_validator.validateFields(query.className, setOnInsert, 'create', random.QueryValidator.patterns.name));
+            while (true) {
+                try {
+                    return await proto.storage.atomic((storage) => storage.upsertMany(_query, _update, _setOnInsert), { lockTable: query.className, retry: true });
+                }
+                catch (e) {
+                    if (proto.storage.isDuplicateIdError(e))
+                        continue;
+                    throw e;
+                }
+            }
+        },
         async deleteOne(query) {
             random.QueryValidator.recursiveCheck(query);
             const _validator = await validator();
@@ -443,6 +469,33 @@ class _ProtoQuery extends index.TQuery {
         }
         return result;
     }
+    async updateMany(update, options) {
+        const context = options?.context ?? {};
+        const silent = _.castArray(options?.silent ?? []);
+        const beforeSave = _.includes(silent, 'beforeSave') ? null : this._proto[_private.PVK].triggers?.beforeSave?.[this.className];
+        const afterSave = _.includes(silent, 'afterSave') ? null : this._proto[_private.PVK].triggers?.afterSave?.[this.className];
+        if (_.isFunction(beforeSave) || _.isFunction(afterSave)) {
+            const objects = this._objectMethods(await utilsJs.asyncIterableToArray(this._dispatcher(options).find(this._queryOptions)));
+            if (_.isEmpty(objects))
+                return 0;
+            if (_.isFunction(beforeSave)) {
+                await Promise.all(_.map(objects, object => beforeSave(proxy(Object.setPrototypeOf({ object, context }, options?.session ?? this._proto)))));
+            }
+            if (!_.isFunction(afterSave)) {
+                return this._dispatcher(options).updateMany({
+                    ...this._queryOptions,
+                    filter: { _id: { $in: _.map(objects, x => x.objectId) } },
+                }, update);
+            }
+            const updated = await Promise.all(_.map(objects, x => this._dispatcher(options).updateOne({
+                ...this._queryOptions,
+                filter: { _id: { $eq: x.objectId } },
+            }, update)));
+            await Promise.all(_.map(updated, object => afterSave(proxy(Object.setPrototypeOf({ object, context }, options?.session ?? this._proto)))));
+            return updated.length;
+        }
+        return this._dispatcher(options).updateMany(this._queryOptions, update);
+    }
     async upsertOne(update, setOnInsert, options) {
         const context = options?.context ?? {};
         const silent = _.castArray(options?.silent ?? []);
@@ -481,6 +534,47 @@ class _ProtoQuery extends index.TQuery {
         }
         return result;
     }
+    async upsertMany(update, setOnInsert, options) {
+        const context = options?.context ?? {};
+        const silent = _.castArray(options?.silent ?? []);
+        const beforeSave = _.includes(silent, 'beforeSave') ? null : this._proto[_private.PVK].triggers?.beforeSave?.[this.className];
+        const afterSave = _.includes(silent, 'afterSave') ? null : this._proto[_private.PVK].triggers?.afterSave?.[this.className];
+        if (_.isFunction(beforeSave) || _.isFunction(afterSave)) {
+            const objects = this._objectMethods(await utilsJs.asyncIterableToArray(this._dispatcher(options).find(this._queryOptions)));
+            if (!_.isEmpty(objects) && _.isFunction(beforeSave)) {
+                await Promise.all(_.map(objects, object => beforeSave(proxy(Object.setPrototypeOf({ object, context }, options?.session ?? this._proto)))));
+            }
+            if (_.isEmpty(objects)) {
+                const result = await this._dispatcher(options).insert({
+                    className: this.className,
+                    includes: this[_private.PVK].options.includes,
+                    matches: this[_private.PVK].options.matches,
+                }, setOnInsert);
+                if (!result)
+                    throw Error('Unable to insert document');
+                if (_.isFunction(afterSave)) {
+                    await afterSave(proxy(Object.setPrototypeOf({ object: result, context }, options?.session ?? this._proto)));
+                }
+                return { updated: 0, inserted: 1 };
+            }
+            if (!_.isFunction(afterSave)) {
+                return {
+                    inserted: 0,
+                    updated: await this._dispatcher(options).updateMany({
+                        ...this._queryOptions,
+                        filter: { _id: { $in: _.map(objects, x => x.objectId) } },
+                    }, update),
+                };
+            }
+            const updated = await Promise.all(_.map(objects, x => this._dispatcher(options).updateOne({
+                ...this._queryOptions,
+                filter: { _id: { $eq: x.objectId } },
+            }, update)));
+            await Promise.all(_.map(updated, object => afterSave(proxy(Object.setPrototypeOf({ object, context }, options?.session ?? this._proto)))));
+            return { updated: updated.length, inserted: 0 };
+        }
+        return this._dispatcher(options).upsertMany(this._queryOptions, update, setOnInsert);
+    }
     async deleteOne(options) {
         const context = options?.context ?? {};
         const silent = _.castArray(options?.silent ?? []);
@@ -851,7 +945,7 @@ class ProtoInternal {
         validateSchemaName(options.schema);
         const schema = mergeSchema(defaultSchema, options.fileStorage.schema, options.schema);
         validateSchema(schema);
-        if (!_.every(options.roleInheritKeys, k => {
+        if (!_.every(options.roleResolver?.inheritKeys, k => {
             const type = random.resolveDataType(schema, 'Role', k);
             return type && index$1.isRelation(type) && _.includes(['User', 'Role'], type.target);
         })) {
@@ -1357,7 +1451,7 @@ class ProtoService extends index.ProtoType {
     constructor(options) {
         super();
         this[_private.PVK] = new ProtoInternal({
-            roleInheritKeys: [],
+            roleResolver: {},
             objectIdSize: 10,
             maxFetchLimit: 1000,
             maxUploadSize: 20 * 1024 * 1024,
@@ -1444,30 +1538,36 @@ class ProtoService extends index.ProtoType {
         return _.assign(payload, _.isFunction(attrs) ? attrs(payload) : attrs);
     }
     async userRoles(user) {
-        const roleInheritKeys = this[_private.PVK].options.roleInheritKeys;
-        const schema = this.schema;
-        const userKeys = _.filter(roleInheritKeys, k => {
-            const type = random.resolveDataType(schema, 'Role', k);
-            return !!type && index$1.isRelation(type) && type.target === 'User';
-        });
-        const roleKeys = _.filter(roleInheritKeys, k => {
-            const type = random.resolveDataType(schema, 'Role', k);
-            return !!type && index$1.isRelation(type) && type.target === 'Role';
-        });
-        let queue = await this.Query('Role')
-            .or(_.map(_.uniq(['users', ...userKeys]), k => q => q.isIntersect(k, [user])))
-            .includes('name')
-            .find({ master: true });
-        let roles = queue;
-        while (!_.isEmpty(queue)) {
-            queue = await this.Query('Role')
-                .or(_.map(_.uniq(['roles', ...roleKeys]), k => q => q.isIntersect(k, queue)))
-                .notContainsIn('_id', _.compact(_.map(roles, x => x.objectId)))
+        const self = this;
+        const { inheritKeys, resolver } = self[_private.PVK].options.roleResolver;
+        const defaultResolver = async () => {
+            const schema = self.schema;
+            const userKeys = _.filter(inheritKeys, k => {
+                const type = random.resolveDataType(schema, 'Role', k);
+                return !!type && index$1.isRelation(type) && type.target === 'User';
+            });
+            const roleKeys = _.filter(inheritKeys, k => {
+                const type = random.resolveDataType(schema, 'Role', k);
+                return !!type && index$1.isRelation(type) && type.target === 'Role';
+            });
+            let queue = await self.Query('Role')
+                .or(_.map(_.uniq(['users', ...userKeys]), k => q => q.isIntersect(k, [user])))
                 .includes('name')
                 .find({ master: true });
-            roles = _.uniqBy([...roles, ...queue], x => x.objectId);
-        }
-        return roles;
+            let roles = queue;
+            while (!_.isEmpty(queue)) {
+                queue = await self.Query('Role')
+                    .or(_.map(_.uniq(['roles', ...roleKeys]), k => q => q.isIntersect(k, queue)))
+                    .notContainsIn('_id', _.compact(_.map(roles, x => x.objectId)))
+                    .includes('name')
+                    .find({ master: true });
+                roles = _.uniqBy([...roles, ...queue], x => x.objectId);
+            }
+            return roles;
+        };
+        if (resolver)
+            return resolver(user, defaultResolver);
+        return defaultResolver();
     }
     async becomeUser(req, user, options) {
         if (!user.objectId)
@@ -1772,7 +1872,9 @@ var classesRoute = (router, proto) => {
             case 'insert': return query.insert(attributes, opts);
             case 'insertMany': return query.insertMany(attributes, opts);
             case 'updateOne': return query.updateOne(update, opts);
+            case 'updateMany': return query.updateMany(update, opts);
             case 'upsertOne': return query.upsertOne(update, setOnInsert, opts);
+            case 'upsertMany': return query.upsertMany(update, setOnInsert, opts);
             case 'deleteOne': return query.deleteOne(opts);
             case 'deleteMany': return query.deleteMany(opts);
             default: throw Error('Invalid operation');
@@ -1876,6 +1978,16 @@ var classesRoute = (router, proto) => {
         const payload = proto.connect(req);
         await response(res, async () => payload.refs(payload.Object(name, id), { master: payload.isMaster }));
     });
+    router.patch('/classes/:name', serverJs.Server.text({ type: '*/*' }), async (req, res) => {
+        res.setHeader('Cache-Control', ['no-cache', 'no-store']);
+        const { name } = req.params;
+        const classes = proto.classes();
+        if (!_.includes(classes, name))
+            return void res.sendStatus(404);
+        const payload = proto.connect(req);
+        const update = _.mapValues(index.deserialize(req.body), v => ({ $set: v }));
+        await response(res, () => createQuery(payload, req, false).updateMany(update, { master: payload.isMaster }));
+    });
     router.patch('/classes/:name/:id', serverJs.Server.text({ type: '*/*' }), async (req, res) => {
         res.setHeader('Cache-Control', ['no-cache', 'no-store']);
         const { name, id } = req.params;