proto.io 0.0.228 → 0.0.229

package/dist/index.mjs

@@ -1,10 +1,10 @@
 import _ from 'lodash';
 import { Server } from '@o2ter/server-js';
-import { Q as QueryValidator, a as QueryExpression, r as resolveColumn, b as resolveDataType, c as QuerySelector } from './internals/validator-Boj1PUjM.mjs';
+import { Q as QueryValidator, a as QueryExpression, b as QueryAccumulator, r as resolveColumn, c as resolveDataType, d as QuerySelector } from './internals/validator-DubDY921.mjs';
 import { P as PVK } from './internals/private-CNw40LZ7.mjs';
 import { prototypes, asyncStream, isBinaryData, base64ToBuffer } from '@o2ter/utils-js';
-import { L as LiveQuerySubscription, T as TQuery, d as deserialize, s as serialize, a as TUser, P as ProtoType, _ as _logLevels } from './internals/index-BWZIV3_T.mjs';
-export { b as ProtoClient, c as classExtends } from './internals/index-BWZIV3_T.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-DG2-4tQ1.mjs';
+export { b as ProtoClient, c as classExtends } from './internals/index-DG2-4tQ1.mjs';
 import { i as isPointer, a as isRelation, T as TObject, d as defaultObjectKeyTypes, b as isShape, c as isPrimitive } from './internals/index-CSOoWRr1.mjs';
 import jwt from 'jsonwebtoken';
 import { Blob } from 'node:buffer';
@@ -113,6 +113,16 @@ const dispatcher = (proto, options) => {
                 throw Error('No permission');
             return proto.storage.find(decoded);
         },
+        async groupFind(query, accumulators) {
+            QueryValidator.recursiveCheck(query);
+            const _validator = await validator();
+            const decoded = _validator.decodeQuery(normalize(query), 'read');
+            const isGet = _validator.isGetMethod(decoded.filter);
+            if (!_validator.validateCLPs(query.className, isGet ? 'get' : 'find'))
+                throw Error('No permission');
+            const acc = _.mapValues(accumulators, x => QueryAccumulator.decode(x).simplify());
+            return proto.storage.groupFind(decoded, acc);
+        },
         async nonrefs(query) {
             QueryValidator.recursiveCheck(query);
             const _validator = await validator();
@@ -309,6 +319,9 @@ class _ProtoQuery extends TQuery {
                 yield self._objectMethods(object);
         });
     }
+    groupFind(accumulators, options) {
+        return this._dispatcher(options).groupFind(this._queryOptions, accumulators);
+    }
     nonrefs(options) {
         const self = this;
         return asyncStream(async function* () {
@@ -523,6 +536,8 @@ const defaultSchema = {
     'User': {
         fields: {
             password: 'object',
+            password_history: 'array',
+            password_changed_at: 'date',
         },
         classLevelPermissions: {
             find: [],
@@ -532,7 +547,7 @@ const defaultSchema = {
         fieldLevelPermissions: {
             _expired_at: { create: [], update: [] },
         },
-        secureFields: ['password'],
+        secureFields: ['password', 'password_history', 'password_changed_at'],
     },
     'Role': {
         fields: {
@@ -913,13 +928,39 @@ class ProtoInternal {
             throw Error('Invalid user object');
         if (_.isEmpty(password))
             throw Error('Invalid password');
+        const { maxPasswordHistory, validatorCallback, } = this.options.passwordPolicy || {};
+        if (validatorCallback) {
+            const isValid = await validatorCallback(password, user);
+            if (!isValid)
+                throw Error('Password does not meet the policy requirements');
+        }
         const { alg, ...opts } = this.options.passwordHashOptions;
         const hashed = await passwordHash(alg, password, opts);
+        let history = [];
+        if (maxPasswordHistory && maxPasswordHistory > 0) {
+            const _user = await proto.InsecureQuery('User')
+                .equalTo('_id', user.id)
+                .includes('_id', 'password_history')
+                .first(options);
+            history = _.slice(_user?.get('password_history') ?? [], 0, maxPasswordHistory);
+            for (const entry of history) {
+                const { alg, ...opts } = entry;
+                if (await verifyPassword(alg, password, opts)) {
+                    throw Error('Cannot reuse previous passwords');
+                }
+            }
+        }
         await proto.InsecureQuery('User')
             .equalTo('_id', user.id)
             .includes('_id')
             .updateOne({
             password: { $set: hashed },
+            password_history: {
+                $set: maxPasswordHistory && maxPasswordHistory > 0
+                    ? _.slice([{ ...hashed, password }, ...history], 0, maxPasswordHistory)
+                    : [],
+            },
+            password_changed_at: { $set: new Date() },
         }, options);
     }
     async unsetPassword(proto, user, options) {
@@ -930,6 +971,7 @@ class ProtoInternal {
             .includes('_id')
             .updateOne({
             password: { $set: {} },
+            password_changed_at: { $set: new Date() },
         }, options);
     }
     async updateFile(proto, object, options) {
@@ -1974,7 +2016,7 @@ const verifyRelatedBy = (relatedBy) => {
 var classesRoute = (router, proto) => {
     const defaultHandler = async (req) => {
         const { name } = req.params;
-        const { operation, random, attributes, update, setOnInsert, relatedBy, silent, ...options } = deserialize(req.body);
+        const { operation, accumulators, random, attributes, update, setOnInsert, relatedBy, silent, ...options } = deserialize(req.body);
         verifyRelatedBy(relatedBy);
         const payload = proto.connect(req);
         const query = relatedBy ? payload.Relation(payload.Object(relatedBy.className, relatedBy.id), relatedBy.key) : payload.Query(name);
@@ -1995,15 +2037,16 @@ var classesRoute = (router, proto) => {
                     query[PVK].options.limit = query[PVK].options.limit ?? maxFetchLimit;
                     if (query[PVK].options.limit > maxFetchLimit)
                         throw Error('Query over limit');
-                    return await query.find(opts);
+                    return query.find(opts);
                 }
+            case 'groupFind': return query.groupFind(accumulators, opts);
             case 'random':
                 {
                     const maxFetchLimit = payload[PVK].options.maxFetchLimit;
                     query[PVK].options.limit = query[PVK].options.limit ?? maxFetchLimit;
                     if (query[PVK].options.limit > maxFetchLimit)
                         throw Error('Query over limit');
-                    return await query.random(random, opts);
+                    return query.random(random, opts);
                 }
             case 'nonrefs':
                 {
@@ -2011,7 +2054,7 @@ var classesRoute = (router, proto) => {
                     query[PVK].options.limit = query[PVK].options.limit ?? maxFetchLimit;
                     if (query[PVK].options.limit > maxFetchLimit)
                         throw Error('Query over limit');
-                    return await query.nonrefs(opts);
+                    return query.nonrefs(opts);
                 }
             case 'insert': return query.insert(attributes, opts);
             case 'insertMany': return query.insertMany(attributes, opts);