proto.io 0.0.222 → 0.0.223

package/dist/index.mjs

@@ -3,8 +3,8 @@ 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 { 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-BozJOOCD.mjs';
+export { b as ProtoClient, c as classExtends } from './internals/index-BozJOOCD.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';
@@ -470,6 +470,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',
@@ -1278,98 +1302,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))
+    const { payload, session } = await _sessionWithToken(proto, sessionId) ?? {};
+    if (!session)
         return;
-    const session = _sessionWithToken(proto, authorization);
-    if (!_.isObject(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];
-    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);
+    sessionMap.set(request, { payload, session });
     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 +1410,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 +1528,6 @@ class ProtoService extends ProtoType {
     constructor(options) {
         super();
         this[PVK] = new ProtoInternal({
-            userResolver: (_req, user) => user,
             roleResolver: {},
             objectIdSize: 10,
             maxFetchLimit: 1000,
@@ -1555,11 +1594,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 +1623,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;
@@ -2592,15 +2632,14 @@ const registerProtoSocket = (proto, server, endpoint) => {
     io.on('connection', async (socket) => {
         let events = {};
         let queries = {};
-        const connect = async (token) => {
-            const payload = await proto.connectWithSessionToken(token);
-            const { remove: remove_basic } = payload.listen(data => {
+        const connect = (proto) => {
+            const { remove: remove_basic } = proto.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 { remove: remove_livequery } = proto[PVK]._liveQuery(proto, (ev, objs) => {
                 const ids = {};
                 for (const obj of objs) {
                     ids[obj.id] = _.keys(_.pickBy(queries, v => {
@@ -2620,13 +2659,13 @@ const registerProtoSocket = (proto, server, endpoint) => {
             };
         };
         const { token } = socket.handshake.auth;
-        let remove = connect(token);
+        const service = await proto.connectWithSessionToken(token);
+        const remove = connect(service);
         socket.on('auth', (token) => {
-            remove.then(rm => rm());
-            remove = connect(token);
+            service.connectWithSessionToken(token);
         });
         socket.on('disconnect', () => {
-            remove.then(rm => rm());
+            remove();
         });
         socket.on('EV_NOTIFY', (payload) => {
             events = _.mapValues(payload, v => {