proto.io 0.0.222 → 0.0.224

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-DX2nXeQo.mjs';
+import { Q as QueryValidator, a as QueryExpression, r as resolveColumn, b as resolveDataType, c as QuerySelector } from './internals/validator-0I1kvhsL.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-CsclRNTO.mjs';
-export { b as ProtoClient, c as classExtends } from './internals/index-CsclRNTO.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-BZ79Ljis.mjs';
+export { b as ProtoClient, c as classExtends } from './internals/index-BZ79Ljis.mjs';
 import { i as isPointer, a as isRelation, T as TObject, b as isShape, d as defaultObjectKeyTypes, c as isPrimitive } from './internals/index-gWcE22mf.mjs';
 import jwt from 'jsonwebtoken';
 import { Blob } from 'node:buffer';
@@ -324,7 +324,7 @@ class _ProtoQuery extends TQuery {
                 yield self._objectMethods(object);
         });
     }
-    _on_upsert(objects) {
+    _on_upsert_traggers(objects) {
         const createTraggers = this._proto[PVK].triggers[this.className]?.create ?? [];
         const updateTraggers = this._proto[PVK].triggers[this.className]?.update ?? [];
         for (const obj of objects) {
@@ -339,6 +339,8 @@ class _ProtoQuery extends TQuery {
                 })();
             }
         }
+    }
+    _on_upsert(objects) {
         if (this._proto.schema[this.className]?.liveQuery) {
             (async () => {
                 try {
@@ -351,7 +353,7 @@ class _ProtoQuery extends TQuery {
             })();
         }
     }
-    _on_delete(objects) {
+    _on_delete_traggers(objects) {
         const traggers = this._proto[PVK].triggers[this.className]?.delete ?? [];
         for (const obj of objects) {
             for (const tragger of traggers) {
@@ -365,6 +367,8 @@ class _ProtoQuery extends TQuery {
                 })();
             }
         }
+    }
+    _on_delete(objects) {
         if (this._proto.schema[this.className]?.liveQuery) {
             (async () => {
                 try {
@@ -383,26 +387,30 @@ class _ProtoQuery extends TQuery {
             matches: this[PVK].options.matches,
             groupMatches: this[PVK].options.groupMatches,
         }, values));
-        if (!options?.silent)
-            this._on_upsert(objs);
+        this._on_upsert(objs);
+        if (!options?.silent || !options.master)
+            this._on_upsert_traggers(objs);
         return objs;
     }
     async updateMany(update, options) {
         const objs = this._objectMethods(await this._dispatcher(options).update(this._queryOptions, update));
-        if (!options?.silent)
-            this._on_upsert(objs);
+        this._on_upsert(objs);
+        if (!options?.silent || !options.master)
+            this._on_upsert_traggers(objs);
         return objs;
     }
     async upsertMany(update, setOnInsert, options) {
         const objs = this._objectMethods(await this._dispatcher(options).upsert(this._queryOptions, update, setOnInsert));
-        if (!options?.silent)
-            this._on_upsert(objs);
+        this._on_upsert(objs);
+        if (!options?.silent || !options.master)
+            this._on_upsert_traggers(objs);
         return objs;
     }
     async deleteMany(options) {
         const objs = this._objectMethods(await this._dispatcher(options).delete(this._queryOptions));
-        if (!options?.silent)
-            this._on_delete(objs);
+        this._on_delete(objs);
+        if (!options?.silent || !options.master)
+            this._on_delete_traggers(objs);
         return objs;
     }
 }
@@ -470,6 +478,30 @@ class ProtoRelationQuery extends _ProtoQuery {
 //  THE SOFTWARE.
 //
 const defaultSchema = {
+    '_Session': {
+        fields: {
+            token: 'string',
+            user: { type: 'pointer', target: 'User' },
+            loginedAt: 'date',
+        },
+        classLevelPermissions: {
+            find: [],
+            count: [],
+            create: [],
+            update: [],
+            delete: [],
+        },
+        fieldLevelPermissions: {
+            token: { update: [] },
+            _expired_at: { create: [], update: [] },
+        },
+        indexes: [
+            {
+                keys: { token: 1 },
+                unique: true,
+            },
+        ],
+    },
     'User': {
         fields: {
             password: 'object',
@@ -1048,14 +1080,14 @@ class ProtoInternal {
         });
     }
     listen(proto, callback) {
-        const isMaster = proto.isMaster;
-        const roles = isMaster ? [] : this._perms(proto);
         return {
             remove: this.options.pubsub.subscribe(PROTO_NOTY_MSG, payload => {
                 const { _rperm } = payload;
                 (async () => {
                     try {
-                        if (!isMaster && !_.some(await roles, x => _.includes(_rperm, x)))
+                        const isMaster = proto.isMaster;
+                        const roles = isMaster ? [] : await this._perms(proto);
+                        if (!isMaster && !_.some(roles, x => _.includes(_rperm, x)))
                             return;
                         await callback(payload);
                     }
@@ -1072,18 +1104,17 @@ class ProtoInternal {
         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 isMaster = proto.isMaster;
+                        const roles = isMaster ? [] : await this._perms(proto);
                         const payload = proto.rebind(isMaster ? objects : _.filter(objects, object => {
                             const acl = object.acl();
                             const clp = proto.schema[object.className].classLevelPermissions?.get ?? ['*'];
-                            return _.some(_roles, x => _.includes(clp, x) && _.includes(acl.read, x));
+                            return _.some(roles, x => _.includes(clp, x) && _.includes(acl.read, x));
                         }));
                         if (!_.isEmpty(payload))
                             await callback(event, payload);
@@ -1278,98 +1309,102 @@ class JobRunner {
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-const sessionMap = new WeakMap();
-const _sessionWithToken = (proto, token) => {
+const _sessionWithToken = async (proto, token) => {
     if (_.isEmpty(token))
         return;
-    const payload = proto[PVK].jwtVarify(token, 'login');
-    if (!_.isObject(payload))
+    const payload = proto[PVK].jwtVarify(token, 'login') ?? {};
+    if (!_.isString(payload.sessionId) || _.isEmpty(payload.sessionId))
+        return;
+    const session = await proto.Query('_Session')
+        .equalTo('token', payload.sessionId)
+        .includes('user')
+        .first({ master: true });
+    if (!session)
         return;
+    return { payload, session };
+};
+const userCacheMap = new WeakMap();
+const fetchUserRole = async (proto, user) => {
+    if (!userCacheMap.has(proto[PVK]))
+        userCacheMap.set(proto[PVK], {});
+    const cache = userCacheMap.get(proto[PVK]);
+    if (_.isNil(user?.id))
+        return {};
+    if (_.isNil(cache[user.id]))
+        cache[user.id] = (async () => {
+            const _roles = user instanceof TUser ? _.filter(await proto.userRoles(user), x => !_.isEmpty(x.name)) : [];
+            cache[user.id] = undefined;
+            return _roles;
+        })();
+    const _roles = await cache[user.id];
     return {
-        ...payload,
-        sessionId: payload.sessionId ?? randomUUID(),
-        createdAt: payload.createdAt && _.isSafeInteger(payload.createdAt) ? new Date(payload.createdAt) : new Date,
-        loginedAt: payload.loginedAt && _.isSafeInteger(payload.loginedAt) ? new Date(payload.loginedAt) : new Date,
+        user: user?.clone(),
+        _roles: _.map(_roles, x => x.clone()),
     };
 };
-const _session = (proto, request) => {
+const sessionMap = new WeakMap();
+const _session = async (proto, request) => {
     const cached = sessionMap.get(request);
     if (cached)
-        return cached;
-    sessionMap.set(request, {
-        sessionId: randomUUID(),
-        createdAt: new Date,
-        loginedAt: new Date,
-    });
-    const jwtToken = proto[PVK].options.jwtToken;
-    if (_.isEmpty(jwtToken))
-        throw Error('Invalid jwt token');
+        return {
+            sessionId: cached.session.sessionId,
+            createdAt: cached.session.createdAt,
+            updatedAt: cached.session.updatedAt,
+            loginedAt: cached.session.loginedAt,
+            user: cached.session.user,
+            cookieOptions: cached.payload.cookieOptions,
+        };
     const cookieKey = _.last(_.castArray(request.headers[AUTH_ALT_COOKIE_KEY] || [])) || AUTH_COOKIE_KEY;
-    let authorization = '';
+    let sessionId = '';
     if (request.headers.authorization) {
         const parts = request.headers.authorization.split(' ');
         if (parts.length === 2 && parts[0] === 'Bearer')
-            authorization = parts[1];
+            sessionId = parts[1];
     }
     else if (request.cookies[cookieKey]) {
-        authorization = request.cookies[cookieKey];
+        sessionId = request.cookies[cookieKey];
     }
-    if (_.isEmpty(authorization))
-        return;
-    const session = _sessionWithToken(proto, authorization);
-    if (!_.isObject(session))
+    const { payload, session } = await _sessionWithToken(proto, sessionId) ?? {};
+    if (!session)
         return;
-    sessionMap.set(request, session);
-    return session;
-};
-const sessionId = (proto, request) => {
-    const session = _session(proto, request);
-    return sessionMap.get(request)?.sessionId ?? session?.sessionId;
-};
-const userCacheMap = new WeakMap;
-const fetchSessionInfo = async (proto, userId = '') => {
-    if (!userCacheMap.has(proto[PVK]))
-        userCacheMap.set(proto[PVK], {});
-    const cache = userCacheMap.get(proto[PVK]);
-    if (_.isNil(cache[userId]))
-        cache[userId] = (async () => {
-            const _user = userId ? await proto.Query('User').get(userId, { master: true }) : undefined;
-            const user = proto.req ? await proto[PVK].options.userResolver(proto, _user) : _user;
-            const _roles = user instanceof TUser ? _.filter(await proto.userRoles(user), x => !_.isEmpty(x.name)) : [];
-            cache[userId] = undefined;
-            return { user, _roles };
-        })();
-    const { user, _roles } = await cache[userId];
+    sessionMap.set(request, { payload, session });
     return {
-        user: user?.clone(),
-        _roles: _.map(_roles, x => x.clone()),
-    };
-};
-const sessionWithToken = async (proto, token) => {
-    const session = _sessionWithToken(proto, token);
-    const info = await fetchSessionInfo(proto, session?.user);
-    return {
-        ...session ?? {},
-        ...info,
-        loginedAt: info?.user ? session?.loginedAt : undefined,
+        sessionId: session.sessionId,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        loginedAt: session.loginedAt,
+        user: session.user,
+        cookieOptions: payload.cookieOptions,
     };
 };
-const sessionInfoMap = new WeakMap();
+const userRoleMap = new WeakMap();
 const session = async (proto, request) => {
-    const session = _session(proto, request);
-    const cached = sessionInfoMap.get(request);
+    const session = await _session(proto, request);
+    const cached = userRoleMap.get(request);
     if (cached)
         return {
             ...session ?? {},
             ...cached,
-            loginedAt: cached?.user ? session?.loginedAt : undefined,
         };
-    const info = await fetchSessionInfo(proto, session?.user);
-    sessionInfoMap.set(request, info);
+    const info = await fetchUserRole(proto, session?.user);
+    userRoleMap.set(request, info);
     return {
         ...session ?? {},
         ...info,
-        loginedAt: info?.user ? session?.loginedAt : undefined,
+    };
+};
+const sessionWithToken = async (proto, token) => {
+    const { payload, session } = await _sessionWithToken(proto, token) ?? {};
+    if (!session)
+        return;
+    const info = await fetchUserRole(proto, session?.user);
+    return {
+        sessionId: session.sessionId,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        loginedAt: session.loginedAt,
+        cookieOptions: payload.cookieOptions,
+        ...info,
     };
 };
 const sessionIsMaster = (proto, request) => {
@@ -1382,18 +1417,30 @@ const sessionIsMaster = (proto, request) => {
 const signUser = async (proto, res, user, options) => {
     if (_.isNil(proto[PVK].options.jwtToken))
         return;
-    const session = _session(proto, res.req);
+    const session = await _session(proto, res.req);
     const cookieOptions = options?.cookieOptions ?? session?.cookieOptions ?? proto[PVK].options.cookieOptions;
+    const sessionId = session?.sessionId ?? randomUUID();
+    const expiredAt = cookieOptions?.expires ?? (cookieOptions?.maxAge ? new Date(Date.now() + cookieOptions.maxAge) : undefined);
+    const loginedAt = user ? session?.loginedAt ?? new Date() : undefined;
+    await proto.Query('_Session')
+        .equalTo('token', sessionId)
+        .upsertOne({
+        loginedAt: { $set: loginedAt },
+        user: { $set: user },
+        _expired_at: { $set: expiredAt },
+    }, {
+        token: sessionId,
+        loginedAt: loginedAt,
+        user,
+        _expired_at: expiredAt,
+    }, { master: true });
     const token = proto[PVK].jwtSign({
-        sessionId: session?.sessionId ?? randomUUID(),
-        createdAt: session?.createdAt?.getTime() ?? Date.now(),
-        loginedAt: user ? session?.loginedAt?.getTime() ?? Date.now() : undefined,
-        user: user?.id,
+        sessionId,
         cookieOptions,
     }, options?.jwtSignOptions ?? 'login');
     const cookieKey = _.last(_.castArray(res.req.headers[AUTH_ALT_COOKIE_KEY] || [])) || AUTH_COOKIE_KEY;
     res.cookie(cookieKey, token, cookieOptions);
-    sessionInfoMap.set(res.req, user ? await fetchSessionInfo(proto, user.id) : {});
+    userRoleMap.set(res.req, user ? await fetchUserRole(proto, user) : {});
 };
 
 //
@@ -1488,7 +1535,6 @@ class ProtoService extends ProtoType {
     constructor(options) {
         super();
         this[PVK] = new ProtoInternal({
-            userResolver: (_req, user) => user,
             roleResolver: {},
             objectIdSize: 10,
             maxFetchLimit: 1000,
@@ -1555,11 +1601,6 @@ class ProtoService extends ProtoType {
     InsecureQuery(className) {
         return new ProtoQuery(className, this, { insecure: true });
     }
-    get sessionId() {
-        if (this.session)
-            return this.session.sessionId;
-        return this.req ? sessionId(this, this.req) : undefined;
-    }
     async sessionInfo() {
         if (this.session)
             return this.session;
@@ -1589,8 +1630,14 @@ class ProtoService extends ProtoType {
     }
     async connectWithSessionToken(token, attrs) {
         const session = _.isString(token) ? await sessionWithToken(this, token) : undefined;
-        const payload = _.create(this, { session });
-        return _.assign(payload, _.isFunction(attrs) ? attrs(payload) : attrs);
+        if (Object.getPrototypeOf(this) instanceof ProtoService) {
+            this.session = session;
+            return _.assign(this, _.isFunction(attrs) ? attrs(this) : attrs);
+        }
+        else {
+            const payload = _.create(this, { session });
+            return _.assign(payload, _.isFunction(attrs) ? attrs(payload) : attrs);
+        }
     }
     async userRoles(user) {
         const self = this;
@@ -2590,43 +2637,37 @@ const ProtoRoute = async (options) => {
 const registerProtoSocket = (proto, server, endpoint) => {
     const io = endpoint ? server.socket().of(endpoint) : server.socket();
     io.on('connection', async (socket) => {
+        let { token } = socket.handshake.auth;
+        const service = await proto.connectWithSessionToken(token);
+        socket.on('auth', (t) => {
+            token = t;
+            service.connectWithSessionToken(t);
+        });
         let events = {};
         let queries = {};
-        const connect = async (token) => {
-            const payload = await proto.connectWithSessionToken(token);
-            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('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.id] = _.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.id]))));
-                socket.emit('ON_EV_LIVEQUERY', { ids, data: payload });
-            });
-            return () => {
-                remove_basic();
-                remove_livequery();
-            };
-        };
-        const { token } = socket.handshake.auth;
-        let remove = connect(token);
-        socket.on('auth', (token) => {
-            remove.then(rm => rm());
-            remove = connect(token);
+        const { remove: remove_basic } = service.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('ON_EV_NOTIFY', { ids, data: payload });
+        });
+        const { remove: remove_livequery } = service[PVK]._liveQuery(service, (ev, objs) => {
+            const ids = {};
+            for (const obj of objs) {
+                ids[obj.id] = _.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.id]))));
+            socket.emit('ON_EV_LIVEQUERY', { ids, data: payload });
         });
         socket.on('disconnect', () => {
-            remove.then(rm => rm());
+            remove_basic();
+            remove_livequery();
         });
         socket.on('EV_NOTIFY', (payload) => {
             events = _.mapValues(payload, v => {