proto.io 0.0.179 → 0.0.181

package/dist/index.mjs

@@ -3,8 +3,8 @@ import { Server } from '@o2ter/server-js';
 import { Q as QueryValidator, r as resolveColumn, a as resolveDataType, g as generateId } from './internals/random-BSyWEK8G.mjs';
 import { P as PVK } from './internals/private-CNw40LZ7.mjs';
 import { asyncStream, prototypes, isBinaryData, base64ToBuffer } from '@o2ter/utils-js';
-import { T as TQuery, P as PROTO_NOTY_MSG, M as MASTER_USER_HEADER_NAME, a as MASTER_PASS_HEADER_NAME, A as AUTH_COOKIE_KEY, b as TUser, c as ProtoType, s as serialize, d as deserialize, U as UPLOAD_TOKEN_HEADER_NAME } from './internals/index-CPodB1P0.mjs';
-export { e as ProtoClient, f as classExtends, k as isFile, g as isObject, i as isQuery, j as isRole, h as isUser } from './internals/index-CPodB1P0.mjs';
+import { T as TQuery, P as PROTO_NOTY_MSG, M as MASTER_USER_HEADER_NAME, a as MASTER_PASS_HEADER_NAME, A as AUTH_COOKIE_KEY, b as TUser, c as ProtoType, s as serialize, d as deserialize, U as UPLOAD_TOKEN_HEADER_NAME } from './internals/index-CmJh3t_k.mjs';
+export { e as ProtoClient, f as classExtends, k as isFile, g as isObject, i as isQuery, j as isRole, h as isUser } from './internals/index-CmJh3t_k.mjs';
 import { i as isPointer, a as isRelation, T as TObject, b as isShape, d as defaultObjectKeyTypes, c as isPrimitive } from './internals/index-DyjcBbS1.mjs';
 import jwt from 'jsonwebtoken';
 import { Blob } from 'node:buffer';
@@ -520,6 +520,61 @@ const defaultSchema = {
             },
         ],
     },
+    '_Job': {
+        fields: {
+            name: 'string',
+            data: 'object',
+            error: 'object',
+            user: { type: 'pointer', target: 'User' },
+            startedAt: 'date',
+            completedAt: 'date',
+            locks: { type: 'relation', target: '_JobScope', foreignField: 'job' },
+        },
+        classLevelPermissions: {
+            find: [],
+            count: [],
+            create: [],
+            update: [],
+            delete: [],
+        },
+        fieldLevelPermissions: {
+            name: { update: [] },
+            data: { update: [] },
+            error: { update: [] },
+            user: { update: [] },
+            startedAt: { create: [], update: [] },
+            completedAt: { create: [], update: [] },
+            _expired_at: { create: [], update: [] },
+        },
+        indexes: [
+            { keys: { completedAt: 1, _created_at: 1 } },
+        ],
+    },
+    '_JobScope': {
+        fields: {
+            scope: 'string',
+            job: { type: 'pointer', target: '_Job' },
+        },
+        classLevelPermissions: {
+            get: [],
+            find: [],
+            count: [],
+            create: [],
+            update: [],
+            delete: [],
+        },
+        fieldLevelPermissions: {
+            scope: { update: [] },
+            job: { update: [] },
+            _expired_at: { create: [], update: [] },
+        },
+        indexes: [
+            {
+                keys: { scope: 1 },
+                unique: true,
+            },
+        ],
+    },
 };
 
 //
@@ -752,6 +807,8 @@ const mergeSchema = (...schemas) => _.reduce(schemas, (acc, schema) => ({
 class ProtoInternal {
     options;
     functions = {};
+    jobs = {};
+    jobRunner = new JobRunner();
     constructor(options) {
         validateSchemaName(options.schema);
         const schema = mergeSchema(defaultSchema, options.fileStorage.schema, options.schema);
@@ -770,6 +827,9 @@ class ProtoInternal {
     async prepare() {
         await this.options.storage.prepare(this.options.schema);
     }
+    shutdown() {
+        this.jobRunner.shutdown();
+    }
     generateId() {
         return generateId(this.options.objectIdSize);
     }
@@ -786,7 +846,7 @@ class ProtoInternal {
         return this.options.storage.setConfig(normalize(values), normalize(acl));
     }
     async run(proto, name, payload, options) {
-        const func = this.functions?.[name];
+        const func = this.functions[name];
         if (_.isNil(func))
             throw Error('Function not found');
         if (_.isFunction(func))
@@ -1036,6 +1096,127 @@ class ProtoInternal {
         const storage = _serviceOf(options)?.storage ?? this.options.storage;
         return storage.refs(object, classNames, options?.master ? undefined : roles);
     }
+    async scheduleJob(proto, name, params, options) {
+        const opt = this.jobs[name];
+        if (_.isNil(opt))
+            throw Error('Job not found');
+        const user = await proto.currentUser();
+        if (!_.isFunction(opt)) {
+            const roles = await proto.currentRoles();
+            const { validator } = opt;
+            if (!options?.master) {
+                if (!!validator?.requireUser && !user)
+                    throw Error('No permission');
+                if (!!validator?.requireMaster)
+                    throw Error('No permission');
+                if (_.isArray(validator?.requireAnyUserRoles) && !_.some(validator?.requireAnyUserRoles, x => _.includes(roles, x)))
+                    throw Error('No permission');
+                if (_.isArray(validator?.requireAllUserRoles) && _.some(validator?.requireAllUserRoles, x => !_.includes(roles, x)))
+                    throw Error('No permission');
+            }
+        }
+        const obj = proto.Object('_Job');
+        obj.set('name', name);
+        obj.set('data', params);
+        obj.set('user', user);
+        await obj.save({ master: true });
+        this.jobRunner.excuteJob(proto);
+        return obj;
+    }
+}
+class JobRunner {
+    _running = false;
+    _stopped = false;
+    static TIMEOUT = 1000 * 60 * 5;
+    static HEALTH = 1000 * 60;
+    shutdown() {
+        this._stopped = true;
+    }
+    async cleanUpOldJobs(proto) {
+        await proto.Query('_JobScope').or(q => q.lessThan('_updated_at', new Date(Date.now() - JobRunner.TIMEOUT)), q => q.notEqualTo('job.completedAt', null)).deleteMany({ master: true });
+    }
+    async getAvailableJobs(proto) {
+        const running = _.map(await proto.Query('_JobScope').find({ master: true }), x => x.get('scope'));
+        const availableJobs = _.pickBy(proto[PVK].jobs, opt => {
+            return _.isFunction(opt) || _.isEmpty(_.intersection(opt.scopes ?? [], running));
+        });
+        return _.keys(availableJobs);
+    }
+    async getNextJob(proto) {
+        const availableJobs = await this.getAvailableJobs(proto);
+        return await proto.Query('_Job')
+            .containsIn('name', availableJobs)
+            .or(q => q.lessThan('startedAt', new Date(Date.now() - JobRunner.TIMEOUT)), q => q.equalTo('startedAt', null))
+            .equalTo('completedAt', null)
+            .empty('locks')
+            .includes('*', 'user')
+            .sort({ _created_at: 1 })
+            .first({ master: true });
+    }
+    async startJob(proto, job, opt) {
+        await proto.withTransaction(async (session) => {
+            for (const scope of _.isFunction(opt) ? [] : opt.scopes ?? []) {
+                const obj = session.Object('_JobScope');
+                obj.set('scope', scope);
+                obj.set('job', job);
+                await obj.save({ master: true });
+            }
+            job.set('startedAt', new Date());
+            await job.save({ master: true, session });
+        });
+    }
+    async updateJobScope(proto, job) {
+        try {
+            await proto.Query('_JobScope').equalTo('job', job).updateOne({}, { master: true });
+        }
+        catch (e) { }
+    }
+    async executeJobFunction(proto, job, opt) {
+        const payload = Object.setPrototypeOf({ params: job.data, user: job.user, job }, this);
+        const func = _.isFunction(opt) ? opt : opt.callback;
+        await func(proxy(payload));
+    }
+    async finalizeJob(job, error = null) {
+        if (error)
+            job.set('error', _.pick(error, _.uniq(_.flatMap(prototypes(error), x => Object.getOwnPropertyNames(x)))));
+        job.set('completedAt', new Date());
+        await job.save({ master: true });
+    }
+    async excuteJob(proto) {
+        if (this._running || this._stopped)
+            return;
+        this._running = true;
+        while (!this._stopped) {
+            await this.cleanUpOldJobs(proto);
+            const job = await this.getNextJob(proto);
+            if (!job)
+                break;
+            const opt = proto[PVK].jobs[job.name];
+            if (_.isNil(opt))
+                continue;
+            try {
+                await this.startJob(proto, job, opt);
+            }
+            catch (e) {
+                continue;
+            }
+            (async () => {
+                const timer = setInterval(() => this.updateJobScope(proto, job), JobRunner.HEALTH);
+                try {
+                    await this.executeJobFunction(proto, job, opt);
+                    await this.finalizeJob(job);
+                }
+                catch (e) {
+                    await this.finalizeJob(job, e);
+                }
+                finally {
+                    clearInterval(timer);
+                }
+                this.excuteJob(proto);
+            })();
+        }
+        this._running = false;
+    }
 }
 
 //
@@ -1206,7 +1387,10 @@ const signUser = async (proto, res, user, options) => {
 const scheduleOp = {
     expireDocument: async (proto) => {
         await proto.gc();
-    }
+    },
+    excuteJob: async (proto) => {
+        proto[PVK].jobRunner.excuteJob(proto);
+    },
 };
 const schedule = (proto) => {
     let running = false;
@@ -1294,6 +1478,7 @@ class ProtoService extends ProtoType {
     }
     async shutdown() {
         this._schedule.destroy();
+        this[PVK].shutdown();
     }
     classes() {
         return _.keys(this[PVK].options.schema);
@@ -1433,6 +1618,12 @@ class ProtoService extends ProtoType {
     define(name, callback, options) {
         this[PVK].functions[name] = options ? { callback, ...options } : callback;
     }
+    scheduleJob(name, params, options) {
+        return this[PVK].scheduleJob(this, name, params, options);
+    }
+    defineJob(name, callback, options) {
+        this[PVK].jobs[name] = options ? { callback, ...options } : callback;
+    }
     lockTable(className, update) {
         return this.storage.lockTable(className, update);
     }
@@ -1883,6 +2074,55 @@ var functionRoute = (router, proto) => {
     return router;
 };
 
+//
+//  job.ts
+//
+//  The MIT License
+//  Copyright (c) 2021 - 2025 O2ter Limited. All rights reserved.
+//
+//  Permission is hereby granted, free of charge, to any person obtaining a copy
+//  of this software and associated documentation files (the "Software"), to deal
+//  in the Software without restriction, including without limitation the rights
+//  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+//  copies of the Software, and to permit persons to whom the Software is
+//  furnished to do so, subject to the following conditions:
+//
+//  The above copyright notice and this permission notice shall be included in
+//  all copies or substantial portions of the Software.
+//
+//  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+//  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+//  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+//  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+//  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+//  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+//  THE SOFTWARE.
+//
+var jobRoute = (router, proto) => {
+    router.get('/jobs/:name', async (req, res) => {
+        res.setHeader('Cache-Control', ['no-cache', 'no-store']);
+        const { name } = req.params;
+        if (_.isNil(proto[PVK].jobs[name]))
+            return void res.sendStatus(404);
+        await response(res, () => {
+            const payload = proto.connect(req);
+            return payload[PVK].scheduleJob(payload, name, null, { master: payload.isMaster });
+        });
+    });
+    router.post('/jobs/:name', Server.text({ type: '*/*' }), async (req, res) => {
+        res.setHeader('Cache-Control', ['no-cache', 'no-store']);
+        const { name } = req.params;
+        if (_.isNil(proto[PVK].jobs[name]))
+            return void res.sendStatus(404);
+        await response(res, () => {
+            const payload = proto.connect(req);
+            const params = payload.rebind(deserialize(req.body, { objAttrs: TObject.defaultReadonlyKeys }));
+            return payload[PVK].scheduleJob(payload, name, params, { master: payload.isMaster });
+        });
+    });
+    return router;
+};
+
 //
 //  files.ts
 //
@@ -2277,6 +2517,7 @@ const ProtoRoute = async (options) => {
     });
     classesRoute(router, proto);
     functionRoute(router, proto);
+    jobRoute(router, proto);
     filesRoute(router, proto);
     userRoute(router, proto);
     notifyRoute(router, proto);