proto.io 0.0.172 → 0.0.174

package/dist/index.mjs

@@ -1,18 +1,18 @@
 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-BCpwYpyw.mjs';
+import { Q as QueryValidator, r as resolveColumn, a as resolveDataType, g as generateId } from './internals/random-DPRG8oW6.mjs';
 import { P as PVK } from './internals/private-BUpLAMZi.mjs';
 import { prototypes, asyncStream, asyncIterableToArray, isBinaryData, base64ToBuffer } from '@o2ter/utils-js';
-import { T as TQuery, M as MASTER_USER_HEADER_NAME, a as MASTER_PASS_HEADER_NAME, A as AUTH_COOKIE_KEY, b as TUser, P as ProtoType, s as serialize, d as deserialize, U as UPLOAD_TOKEN_HEADER_NAME } from './internals/index-D0hHgn2P.mjs';
-export { c as ProtoClient, e as classExtends, j as isFile, f as isObject, i as isQuery, h as isRole, g as isUser } from './internals/index-D0hHgn2P.mjs';
-import { i as isPointer, a as isRelation, d as decodeUpdateOp, T as TObject, b as isShape, c as defaultObjectKeyTypes, e as isPrimitive } from './internals/index-BYbMU-Ao.mjs';
+import { T as TQuery, M as MASTER_USER_HEADER_NAME, a as MASTER_PASS_HEADER_NAME, A as AUTH_COOKIE_KEY, b as TUser, P as ProtoType, s as serialize, d as deserialize, U as UPLOAD_TOKEN_HEADER_NAME } from './internals/index-R0gbIGc-.mjs';
+export { c as ProtoClient, e as classExtends, j as isFile, f as isObject, i as isQuery, h as isRole, g as isUser } from './internals/index-R0gbIGc-.mjs';
+import { i as isPointer, a as isRelation, d as decodeUpdateOp, T as TObject, b as isShape, c as defaultObjectKeyTypes, e as isPrimitive } from './internals/index--ifyu-GL.mjs';
 import jwt from 'jsonwebtoken';
 import { Blob } from 'node:buffer';
 import { Readable } from 'node:stream';
 import { scrypt } from 'node:crypto';
 import { promisify } from 'util';
 import { randomBytes, randomUUID } from '@o2ter/crypto-js';
-import { Q as QuerySelector } from './internals/index-B1wqSio6.mjs';
+import { Q as QuerySelector } from './internals/index-C3fbOqmn.mjs';
 import queryType from 'query-types';
 import busboy from 'busboy';
 export { Decimal } from 'decimal.js';
@@ -183,6 +183,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', QueryValidator.patterns.path))));
         },
+        async updateMany(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) {
             QueryValidator.recursiveCheck(query, update, setOnInsert);
             const _validator = await validator();
@@ -202,6 +209,25 @@ const dispatcher = (proto, options, disableSecurity) => {
                 }
             }
         },
+        async upsertMany(query, update, setOnInsert) {
+            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.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) {
             QueryValidator.recursiveCheck(query);
             const _validator = await validator();
@@ -383,7 +409,12 @@ class _ProtoQuery extends TQuery {
         if (!result)
             throw Error('Unable to insert document');
         if (_.isFunction(afterSave)) {
-            await afterSave(proxy(Object.setPrototypeOf({ object: result, context }, options?.session ?? this._proto)));
+            try {
+                await afterSave(proxy(Object.setPrototypeOf({ object: result.clone(), context }, options?.session ?? this._proto)));
+            }
+            catch (e) {
+                console.error(e);
+            }
         }
         return result;
     }
@@ -411,7 +442,14 @@ class _ProtoQuery extends TQuery {
                 matches: this[PVK].options.matches,
             }, _.map(objects, x => _.fromPairs([...x._set_entries()])));
             if (_.isFunction(afterSave)) {
-                await Promise.all(_.map(objects, object => afterSave(proxy(Object.setPrototypeOf({ object, context }, options?.session ?? this._proto)))));
+                await Promise.all(_.map(objects, async (object) => {
+                    try {
+                        await afterSave(proxy(Object.setPrototypeOf({ object: object.clone(), context }, options?.session ?? this._proto)));
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }));
             }
             return objects.length;
         }
@@ -436,10 +474,49 @@ class _ProtoQuery extends TQuery {
         }
         const result = this._objectMethods(await this._dispatcher(options).updateOne(this._queryOptions, update));
         if (result && _.isFunction(afterSave)) {
-            await afterSave(proxy(Object.setPrototypeOf({ object: result, context }, options?.session ?? this._proto)));
+            try {
+                await afterSave(proxy(Object.setPrototypeOf({ object: result.clone(), context }, options?.session ?? this._proto)));
+            }
+            catch (e) {
+                console.error(e);
+            }
         }
         return result;
     }
+    async updateMany(update, options) {
+        const context = options?.context ?? {};
+        const silent = _.castArray(options?.silent ?? []);
+        const beforeSave = _.includes(silent, 'beforeSave') ? null : this._proto[PVK].triggers?.beforeSave?.[this.className];
+        const afterSave = _.includes(silent, 'afterSave') ? null : this._proto[PVK].triggers?.afterSave?.[this.className];
+        if (_.isFunction(beforeSave) || _.isFunction(afterSave)) {
+            const objects = this._objectMethods(await 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 = _.compact(await Promise.all(_.map(objects, x => this._dispatcher(options).updateOne({
+                ...this._queryOptions,
+                filter: { _id: { $eq: x.objectId } },
+            }, update))));
+            await Promise.all(_.map(updated, async (object) => {
+                try {
+                    await afterSave(proxy(Object.setPrototypeOf({ object: object.clone(), context }, options?.session ?? this._proto)));
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }));
+            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 ?? []);
@@ -474,10 +551,68 @@ class _ProtoQuery extends TQuery {
         if (!result)
             throw Error('Unable to upsert document');
         if (_.isFunction(afterSave)) {
-            await afterSave(proxy(Object.setPrototypeOf({ object: result, context }, options?.session ?? this._proto)));
+            try {
+                await afterSave(proxy(Object.setPrototypeOf({ object: result.clone(), context }, options?.session ?? this._proto)));
+            }
+            catch (e) {
+                console.error(e);
+            }
         }
         return result;
     }
+    async upsertMany(update, setOnInsert, options) {
+        const context = options?.context ?? {};
+        const silent = _.castArray(options?.silent ?? []);
+        const beforeSave = _.includes(silent, 'beforeSave') ? null : this._proto[PVK].triggers?.beforeSave?.[this.className];
+        const afterSave = _.includes(silent, 'afterSave') ? null : this._proto[PVK].triggers?.afterSave?.[this.className];
+        if (_.isFunction(beforeSave) || _.isFunction(afterSave)) {
+            const objects = this._objectMethods(await 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[PVK].options.includes,
+                    matches: this[PVK].options.matches,
+                }, setOnInsert);
+                if (!result)
+                    throw Error('Unable to insert document');
+                if (_.isFunction(afterSave)) {
+                    try {
+                        await afterSave(proxy(Object.setPrototypeOf({ object: result.clone(), context }, options?.session ?? this._proto)));
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }
+                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 = _.compact(await Promise.all(_.map(objects, x => this._dispatcher(options).updateOne({
+                ...this._queryOptions,
+                filter: { _id: { $eq: x.objectId } },
+            }, update))));
+            await Promise.all(_.map(updated, async (object) => {
+                try {
+                    await afterSave(proxy(Object.setPrototypeOf({ object: object.clone(), context }, options?.session ?? this._proto)));
+                }
+                catch (e) {
+                    console.error(e);
+                }
+            }));
+            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 ?? []);
@@ -498,7 +633,12 @@ class _ProtoQuery extends TQuery {
             result = this._objectMethods(await this._dispatcher(options).deleteOne(this._queryOptions));
         }
         if (result && _.isFunction(afterDelete)) {
-            await afterDelete(proxy(Object.setPrototypeOf({ object: result, context }, options?.session ?? this._proto)));
+            try {
+                await afterDelete(proxy(Object.setPrototypeOf({ object: result.clone(), context }, options?.session ?? this._proto)));
+            }
+            catch (e) {
+                console.error(e);
+            }
         }
         return result;
     }
@@ -519,7 +659,14 @@ class _ProtoQuery extends TQuery {
                 filter: { _id: { $in: _.map(objects, x => x.objectId) } },
             });
             if (_.isFunction(afterDelete)) {
-                await Promise.all(_.map(objects, object => afterDelete(proxy(Object.setPrototypeOf({ object, context }, options?.session ?? this._proto)))));
+                await Promise.all(_.map(objects, async (object) => {
+                    try {
+                        await afterDelete(proxy(Object.setPrototypeOf({ object: object.clone(), context }, options?.session ?? this._proto)));
+                    }
+                    catch (e) {
+                        console.error(e);
+                    }
+                }));
             }
             return objects.length;
         }
@@ -1442,8 +1589,8 @@ class ProtoService extends ProtoType {
     }
     async userRoles(user) {
         const self = this;
+        const { inheritKeys, resolver } = self[PVK].options.roleResolver;
         const defaultResolver = async () => {
-            const inheritKeys = self[PVK].options.roleResolver?.inheritKeys ?? [];
             const schema = self.schema;
             const userKeys = _.filter(inheritKeys, k => {
                 const type = resolveDataType(schema, 'Role', k);
@@ -1468,7 +1615,6 @@ class ProtoService extends ProtoType {
             }
             return roles;
         };
-        const resolver = self[PVK].options.roleResolver?.resolver;
         if (resolver)
             return resolver(user, defaultResolver);
         return defaultResolver();
@@ -1776,7 +1922,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');
@@ -1880,6 +2028,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', 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(deserialize(req.body), v => ({ $set: v }));
+        await response(res, () => createQuery(payload, req, false).updateMany(update, { master: payload.isMaster }));
+    });
     router.patch('/classes/:name/:id', Server.text({ type: '*/*' }), async (req, res) => {
         res.setHeader('Cache-Control', ['no-cache', 'no-store']);
         const { name, id } = req.params;
@@ -2271,19 +2429,84 @@ var configRoute = (router, proto) => {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
+/**
+ * Schema definition utility functions.
+ */
 const schema = _.assign((x) => x, {
+    /**
+     * Defines a boolean schema.
+     * @param defaultValue - The default value for the boolean.
+     * @returns The boolean schema.
+     */
     boolean: (defaultValue) => ({ type: 'boolean', default: defaultValue }),
+    /**
+     * Defines a number schema.
+     * @param defaultValue - The default value for the number.
+     * @returns The number schema.
+     */
     number: (defaultValue) => ({ type: 'number', default: defaultValue }),
+    /**
+     * Defines a decimal schema.
+     * @param defaultValue - The default value for the decimal.
+     * @returns The decimal schema.
+     */
     decimal: (defaultValue) => ({ type: 'decimal', default: defaultValue }),
+    /**
+     * Defines a string schema.
+     * @param defaultValue - The default value for the string.
+     * @returns The string schema.
+     */
     string: (defaultValue) => ({ type: 'string', default: defaultValue }),
+    /**
+     * Defines a date schema.
+     * @param defaultValue - The default value for the date.
+     * @returns The date schema.
+     */
     date: (defaultValue) => ({ type: 'date', default: defaultValue }),
+    /**
+     * Defines an object schema.
+     * @param defaultValue - The default value for the object.
+     * @returns The object schema.
+     */
     object: (defaultValue) => ({ type: 'object', default: defaultValue }),
+    /**
+     * Defines an array schema.
+     * @param defaultValue - The default value for the array.
+     * @returns The array schema.
+     */
     array: (defaultValue) => ({ type: 'array', default: defaultValue }),
+    /**
+     * Defines a vector schema.
+     * @param dimension - The dimension of the vector.
+     * @param defaultValue - The default value for the vector.
+     * @returns The vector schema.
+     */
     vector: (dimension, defaultValue) => ({ type: 'vector', dimension, default: defaultValue }),
+    /**
+     * Defines a shape schema.
+     * @param shape - The shape definition.
+     * @returns The shape schema.
+     */
     shape: (shape) => ({ type: 'shape', shape }),
+    /**
+     * Defines a pointer schema.
+     * @param target - The target of the pointer.
+     * @returns The pointer schema.
+     */
     pointer: (target) => ({ type: 'pointer', target }),
+    /**
+     * Defines a relation schema.
+     * @param target - The target of the relation.
+     * @param foreignField - The foreign field of the relation.
+     * @returns The relation schema.
+     */
     relation: (target, foreignField) => ({ type: 'relation', target, foreignField }),
 });
+/**
+ * Creates a ProtoRoute.
+ * @param options - The options for the ProtoRoute.
+ * @returns A promise that resolves to a Router.
+ */
 const ProtoRoute = async (options) => {
     const proto = options.proto instanceof ProtoService ? options.proto : new ProtoService(options.proto);
     await proto[PVK].prepare();
@@ -2306,6 +2529,13 @@ const ProtoRoute = async (options) => {
     configRoute(router, proto);
     return router;
 };
+/**
+ * Registers a ProtoSocket.
+ * @param proto - The ProtoService instance.
+ * @param server - The server instance.
+ * @param endpoint - The optional endpoint.
+ * @returns The socket.io instance.
+ */
 const registerProtoSocket = (proto, server, endpoint) => {
     const io = endpoint ? server.socket().of(endpoint) : server.socket();
     io.on('connection', async (socket) => {