proto.io 0.0.160 → 0.0.162

package/dist/index.mjs

@@ -1,18 +1,18 @@
 import _ from 'lodash';
 import { Server } from '@o2ter/server-js';
-import { Q as QueryValidator, g as generateId, r as resolveDataType } from './internals/random-DifCxbl6.mjs';
+import { Q as QueryValidator, r as resolveColumn, g as generateId, a as resolveDataType } from './internals/random-w8WDYQEe.mjs';
 import { P as PVK } from './internals/private-BUpLAMZi.mjs';
 import { 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-B01TqoO1.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-B01TqoO1.mjs';
-import { d as decodeUpdateOp, T as TObject, i as isShape, a as isPointer, b as isRelation, c as defaultObjectKeyTypes, e as isPrimitive } from './internals/index-BmRuvHVZ.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-CupbSHHH.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-CupbSHHH.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-ByfpVHca.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-tU-lsQqj.mjs';
+import { Q as QuerySelector } from './internals/index-S5Bq-KsU.mjs';
 import queryType from 'query-types';
 import busboy from 'busboy';
 export { Decimal } from 'decimal.js';
@@ -316,19 +316,19 @@ const _serviceOf = (options) => options?.session instanceof ProtoService ? optio
 //  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 //  THE SOFTWARE.
 //
-class ProtoQuery extends TQuery {
+class _ProtoQuery extends TQuery {
     _proto;
     _opts;
-    constructor(className, proto, opts) {
-        super(className);
+    constructor(proto, opts) {
+        super();
         this._proto = proto;
         this._opts = opts;
     }
     get _queryOptions() {
         return {
+            ...this[PVK].options,
             className: this.className,
             relatedBy: this._opts.relatedBy,
-            ...this[PVK].options,
         };
     }
     _dispatcher(options) {
@@ -344,11 +344,6 @@ class ProtoQuery extends TQuery {
     count(options) {
         return this._dispatcher(options).count(this._queryOptions);
     }
-    clone(options) {
-        const clone = new ProtoQuery(this.className, this._proto, this._opts);
-        clone[PVK].options = options ?? { ...this[PVK].options };
-        return clone;
-    }
     _objectMethods(object) {
         return this._proto.rebind(object);
     }
@@ -538,6 +533,38 @@ class ProtoQuery extends TQuery {
         return this._dispatcher(options).deleteMany(this._queryOptions);
     }
 }
+class ProtoQuery extends _ProtoQuery {
+    _className;
+    constructor(className, proto, opts) {
+        super(proto, opts);
+        this._className = className;
+    }
+    get className() {
+        return this._className;
+    }
+    clone(options) {
+        const clone = new ProtoQuery(this.className, this._proto, this._opts);
+        clone[PVK].options = options ?? { ...this[PVK].options };
+        return clone;
+    }
+}
+class ProtoRelationQuery extends _ProtoQuery {
+    constructor(proto, opts) {
+        super(proto, opts);
+    }
+    get className() {
+        const { className, key } = this._opts.relatedBy;
+        const { dataType } = resolveColumn(this._proto.schema, className, key);
+        if (!isPointer(dataType) && !isRelation(dataType))
+            throw Error(`Invalid relation key: ${key}`);
+        return dataType.target;
+    }
+    clone(options) {
+        const clone = new ProtoRelationQuery(this._proto, this._opts);
+        clone[PVK].options = options ?? { ...this[PVK].options };
+        return clone;
+    }
+}
 
 //
 //  defaults.ts
@@ -1168,13 +1195,24 @@ const sessionId = (proto, request) => {
     const session = _session(proto, request);
     return sessionMap.get(request)?.sessionId ?? session?.sessionId;
 };
-const sessionInfoMap = new WeakMap();
+const userCacheMap = new WeakMap;
 const fetchSessionInfo = async (proto, userId) => {
-    const user = _.isString(userId) ? await proto.Query('User').get(userId, { master: true }) : undefined;
-    const roles = user instanceof TUser ? _.filter(await proto.userRoles(user), x => !_.isEmpty(x.name)) : [];
+    if (!userId)
+        return {};
+    if (!userCacheMap.has(proto[PVK]))
+        userCacheMap.set(proto[PVK], {});
+    const cache = userCacheMap.get(proto[PVK]);
+    if (_.isNil(cache[userId]))
+        cache[userId] = (async () => {
+            const user = _.isString(userId) ? await proto.Query('User').get(userId, { master: true }) : undefined;
+            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 {
-        _roles: roles,
-        user: user instanceof TUser ? user : undefined,
+        user: user?.clone(),
+        _roles: _.map(_roles, x => x.clone()),
     };
 };
 const sessionWithToken = async (proto, token) => {
@@ -1186,6 +1224,7 @@ const sessionWithToken = async (proto, token) => {
         loginedAt: info?.user ? session?.loginedAt : undefined,
     };
 };
+const sessionInfoMap = new WeakMap();
 const session = async (proto, request) => {
     const session = _session(proto, request);
     const cached = sessionInfoMap.get(request);
@@ -1369,11 +1408,11 @@ class ProtoService extends ProtoType {
     Query(className) {
         return new ProtoQuery(className, this, {});
     }
-    Relation(className, object, key) {
+    Relation(object, key) {
         const objectId = object.objectId;
         if (!objectId)
             throw Error('Invalid object');
-        return new ProtoQuery(className, this, {
+        return new ProtoRelationQuery(this, {
             relatedBy: {
                 className: object.className,
                 objectId,
@@ -1658,64 +1697,70 @@ const verifyRelatedBy = (relatedBy) => {
         throw Error('Invalid option');
 };
 var classesRoute = (router, proto) => {
+    const defaultHandler = async (req) => {
+        const { name } = req.params;
+        const { operation, context, silent, random, attributes, update, setOnInsert, relatedBy, ...options } = deserialize(req.body);
+        verifyRelatedBy(relatedBy);
+        const payload = proto.connect(req);
+        const query = relatedBy ? payload.Relation(payload.Object(relatedBy.className, relatedBy.objectId), relatedBy.key) : payload.Query(name);
+        query[PVK].options = options;
+        const opts = { master: payload.isMaster, context, silent };
+        switch (operation) {
+            case 'explain':
+                if (!payload.isMaster)
+                    throw Error('No permission');
+                return query.explain(opts);
+            case 'count': return query.count(opts);
+            case 'find':
+                {
+                    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.find(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);
+                }
+            case 'nonrefs':
+                {
+                    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.nonrefs(opts);
+                }
+            case 'insert': return query.insert(attributes, opts);
+            case 'insertMany': return query.insertMany(attributes, opts);
+            case 'updateOne': return query.updateOne(update, opts);
+            case 'upsertOne': return query.upsertOne(update, setOnInsert, opts);
+            case 'deleteOne': return query.deleteOne(opts);
+            case 'deleteMany': return query.deleteMany(opts);
+            default: throw Error('Invalid operation');
+        }
+    };
     router.post('/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 res.sendStatus(404);
-        await response(res, async () => {
-            const { operation, context, silent, random, attributes, update, setOnInsert, relatedBy, ...options } = deserialize(req.body);
-            verifyRelatedBy(relatedBy);
-            const payload = proto.connect(req);
-            const query = relatedBy ? payload.Relation(name, payload.Object(relatedBy.className, relatedBy.objectId), relatedBy.key) : payload.Query(name);
-            query[PVK].options = options;
-            const opts = { master: payload.isMaster, context, silent };
-            switch (operation) {
-                case 'explain':
-                    if (!payload.isMaster)
-                        throw Error('No permission');
-                    return query.explain(opts);
-                case 'count': return query.count(opts);
-                case 'find':
-                    {
-                        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.find(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);
-                    }
-                case 'nonrefs':
-                    {
-                        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.nonrefs(opts);
-                    }
-                case 'insert': return query.insert(attributes, opts);
-                case 'insertMany': return query.insertMany(attributes, opts);
-                case 'updateOne': return query.updateOne(update, opts);
-                case 'upsertOne': return query.upsertOne(update, setOnInsert, opts);
-                case 'deleteOne': return query.deleteOne(opts);
-                case 'deleteMany': return query.deleteMany(opts);
-                default: throw Error('Invalid operation');
-            }
-        });
+        await response(res, () => defaultHandler(req));
+    });
+    router.post('/relation', Server.text({ type: '*/*' }), async (req, res) => {
+        res.setHeader('Cache-Control', ['no-cache', 'no-store']);
+        await response(res, () => defaultHandler(req));
     });
     const createQuery = (payload, req, checkLimit) => {
         const { name } = req.params;
         const { filter, sort, includes, skip, limit, relatedBy, } = req.query;
         verifyRelatedBy(relatedBy);
-        const query = relatedBy ? payload.Relation(name, payload.Object(relatedBy.className, relatedBy.objectId), relatedBy.key) : payload.Query(name);
+        const query = relatedBy ? payload.Relation(payload.Object(relatedBy.className, relatedBy.objectId), relatedBy.key) : payload.Query(name);
         query[PVK].options.filter = !_.isEmpty(filter) && _.isString(filter) ? _.castArray(deserialize(filter)) : [];
         query[PVK].options.sort = _.isPlainObject(sort) && _.every(_.values(sort), _.isNumber) ? sort : undefined;
         query[PVK].options.includes = _.isArray(includes) && _.every(includes, _.isString) ? includes : undefined;
@@ -1740,6 +1785,11 @@ var classesRoute = (router, proto) => {
         const payload = proto.connect(req);
         await response(res, async () => createQuery(payload, req, true).find({ master: payload.isMaster }));
     });
+    router.get('/relation', queryType.middleware(), async (req, res) => {
+        res.setHeader('Cache-Control', ['no-cache', 'no-store']);
+        const payload = proto.connect(req);
+        await response(res, async () => createQuery(payload, req, true).find({ master: payload.isMaster }));
+    });
     router.get('/classes/:name/random', queryType.middleware(), async (req, res) => {
         res.setHeader('Cache-Control', ['no-cache', 'no-store']);
         const { name } = req.params;
@@ -1752,6 +1802,14 @@ var classesRoute = (router, proto) => {
             throw Error('Invalid operation');
         await response(res, async () => createQuery(payload, req, true).random({ weight }, { master: payload.isMaster }));
     });
+    router.get('/relation/random', queryType.middleware(), async (req, res) => {
+        res.setHeader('Cache-Control', ['no-cache', 'no-store']);
+        const payload = proto.connect(req);
+        const { weight } = req.query;
+        if (_.isEmpty(weight) || !_.isString(weight))
+            throw Error('Invalid operation');
+        await response(res, async () => createQuery(payload, req, true).random({ weight }, { master: payload.isMaster }));
+    });
     router.get('/classes/:name/nonrefs', queryType.middleware(), async (req, res) => {
         res.setHeader('Cache-Control', ['no-cache', 'no-store']);
         const { name } = req.params;
@@ -1761,6 +1819,11 @@ var classesRoute = (router, proto) => {
         const payload = proto.connect(req);
         await response(res, async () => createQuery(payload, req, true).nonrefs({ master: payload.isMaster }));
     });
+    router.get('/relation/nonrefs', queryType.middleware(), async (req, res) => {
+        res.setHeader('Cache-Control', ['no-cache', 'no-store']);
+        const payload = proto.connect(req);
+        await response(res, async () => createQuery(payload, req, true).nonrefs({ master: payload.isMaster }));
+    });
     router.get('/classes/:name/:id', async (req, res) => {
         res.setHeader('Cache-Control', ['no-cache', 'no-store']);
         const { name, id } = req.params;
@@ -1801,6 +1864,13 @@ var classesRoute = (router, proto) => {
         const payload = proto.connect(req);
         await response(res, () => createQuery(payload, req, false).deleteMany({ master: payload.isMaster }));
     });
+    router.delete('/relation', Server.text({ type: '*/*' }), async (req, res) => {
+        res.setHeader('Cache-Control', ['no-cache', 'no-store']);
+        if (!_.isEmpty(req.body))
+            return res.sendStatus(400);
+        const payload = proto.connect(req);
+        await response(res, () => createQuery(payload, req, false).deleteMany({ master: payload.isMaster }));
+    });
     router.delete('/classes/:name/:id', Server.text({ type: '*/*' }), async (req, res) => {
         res.setHeader('Cache-Control', ['no-cache', 'no-store']);
         if (!_.isEmpty(req.body))