@ruiapp/rapid-core 0.8.9 → 0.8.11

package/dist/core/routeContext.d.ts

@@ -4,6 +4,7 @@ import { HttpStatus } from "./http-types";
 import { IRpdServer } from "./server";
 import { IDatabaseAccessor, IDatabaseClient } from "../types";
 export type Next = () => Promise<void>;
+export type TransactionState = "uninited" | "inited" | "started";
 export declare class RouteContext {
     #private;
     readonly request: RapidRequest;
@@ -22,7 +23,8 @@ export declare class RouteContext {
     json(obj: any, status?: HttpStatus, headers?: HeadersInit): void;
     redirect(url: string, status?: HttpStatus): void;
     getDbTransactionClient(): IDatabaseClient | undefined;
-    beginDbTransaction(): Promise<IDatabaseClient>;
+    initDbTransactionClient(): Promise<IDatabaseClient>;
+    beginDbTransaction(): Promise<void>;
     commitDbTransaction(): Promise<void>;
     rollbackDbTransaction(): Promise<void>;
 }

package/dist/index.js

@@ -1052,12 +1052,14 @@ class RouteContext {
     routeConfig;
     #server;
     #dbTransactionClient;
+    #dbTransactionState;
     static newSystemOperationContext(server) {
         return new RouteContext(server);
     }
     constructor(server, request) {
         this.#server = server;
         this.databaseAccessor = server.getDatabaseAccessor();
+        this.#dbTransactionState = "uninited";
         this.request = request;
         this.state = {};
         this.response = new RapidResponse();
@@ -1091,27 +1093,45 @@ class RouteContext {
     getDbTransactionClient() {
         return this.#dbTransactionClient;
     }
-    async beginDbTransaction() {
+    async initDbTransactionClient() {
         let dbClient = this.#dbTransactionClient;
         if (dbClient) {
-            throw new Error("Database transaction has been started. You can not start a transaction more than once in a request context.");
+            return dbClient;
         }
         dbClient = await this.databaseAccessor.getClient();
-        await this.databaseAccessor.queryDatabaseObject("BEGIN", [], dbClient);
+        this.#dbTransactionState = "inited";
         this.#dbTransactionClient = dbClient;
         return dbClient;
     }
+    async beginDbTransaction() {
+        if (!this.#dbTransactionClient) {
+            throw new Error("Database transaction has not been inited. You should call initDbTransactionClient() first.");
+        }
+        if (this.#dbTransactionState === "started") {
+            throw new Error("Database transaction has been started. You can not begin a new transaction before you commit or rollback it.");
+        }
+        await this.databaseAccessor.queryDatabaseObject("BEGIN", [], this.#dbTransactionClient);
+        this.#dbTransactionState = "started";
+    }
     async commitDbTransaction() {
         if (!this.#dbTransactionClient) {
+            throw new Error("Database transaction has not been inited. You should call initDbTransactionClient() first.");
+        }
+        if (this.#dbTransactionState !== "started") {
             throw new Error("Database transaction has not been started. You should call beginDbTransaction() first.");
         }
         await this.databaseAccessor.queryDatabaseObject("COMMIT", [], this.#dbTransactionClient);
+        this.#dbTransactionState = "inited";
     }
     async rollbackDbTransaction() {
         if (!this.#dbTransactionClient) {
+            throw new Error("Database transaction has not been inited. You should call initDbTransactionClient() first.");
+        }
+        if (this.#dbTransactionState !== "started") {
             throw new Error("Database transaction has not been started. You should call beginDbTransaction() first.");
         }
         await this.databaseAccessor.queryDatabaseObject("ROLLBACK", [], this.#dbTransactionClient);
+        this.#dbTransactionState = "inited";
     }
 }
 
@@ -2478,6 +2498,9 @@ function getNowStringWithTimezone() {
 }
 function getDateString(timeString) {
     return dayjs__default["default"](timeString).format("YYYY-MM-DD");
+}
+function formatDateTimeWithTimezone(source) {
+    return dayjs__default["default"](source).format("YYYY-MM-DD HH:mm:ss.SSSZ");
 }
 
 // TODO Generate mapper and cache it.
@@ -5593,7 +5616,8 @@ async function runCollectionEntityActionHandler(ctx, options, code, autoMergeInp
     if (runInTransaction) {
         let transactionDbClient;
         try {
-            transactionDbClient = await routeContext.beginDbTransaction();
+            transactionDbClient = await routeContext.initDbTransactionClient();
+            await routeContext.beginDbTransaction();
             const result = handleEntityAction(entityManager, autoMergeInput ? mergedInput : input);
             if (result instanceof Promise) {
                 ctx.output = await result;
@@ -6239,7 +6263,7 @@ var SequenceAutoIncrementRecord = {
     ],
 };
 
-var pluginModels$6 = [SequenceRule, SequenceAutoIncrementRecord];
+var pluginModels$7 = [SequenceRule, SequenceAutoIncrementRecord];
 
 var generateSn = {
     namespace: "svc",
@@ -6478,7 +6502,7 @@ class SequencePlugin$1 {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$6 });
+        server.appendApplicationConfig({ models: pluginModels$7 });
     }
     async configureServices(server, applicationConfig) {
         this.#sequenceService = new SequenceService(server);
@@ -6962,7 +6986,7 @@ var AccessToken = {
     ],
 };
 
-var pluginModels$5 = [AccessToken];
+var pluginModels$6 = [AccessToken];
 
 var changePassword = {
     namespace: "auth",
@@ -7082,7 +7106,7 @@ class AuthPlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$5 });
+        server.appendApplicationConfig({ models: pluginModels$6 });
     }
     async configureServices(server, applicationConfig) {
         this.#authService = new AuthService(server, server.config.jwtKey);
@@ -7357,7 +7381,7 @@ var getLicense$1 = /*#__PURE__*/Object.freeze({
 
 var pluginActionHandlers$6 = [getLicense$1];
 
-var pluginModels$4 = [];
+var pluginModels$5 = [];
 
 var getLicense = {
     namespace: "svc",
@@ -7528,7 +7552,7 @@ class LicensePlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$4 });
+        server.appendApplicationConfig({ models: pluginModels$5 });
     }
     async configureServices(server, applicationConfig) {
         this.#licenseService = new LicenseService(server, this.#encryptionKey);
@@ -7544,7 +7568,7 @@ class LicensePlugin {
 
 var pluginActionHandlers$5 = [];
 
-var pluginModels$3 = [];
+var pluginModels$4 = [];
 
 var pluginRoutes$4 = [];
 
@@ -7610,7 +7634,7 @@ class MailPlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$3 });
+        server.appendApplicationConfig({ models: pluginModels$4 });
     }
     async configureServices(server, applicationConfig) {
         this.#mailService = new MailService(server, this.#config.smtpServer);
@@ -7683,7 +7707,7 @@ var Notification = {
     ],
 };
 
-var pluginModels$2 = [Notification];
+var pluginModels$3 = [Notification];
 
 var pluginRoutes$3 = [];
 
@@ -7735,7 +7759,7 @@ class SequencePlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$2 });
+        server.appendApplicationConfig({ models: pluginModels$3 });
     }
     async configureServices(server, applicationConfig) {
         this.#notificationService = new NotificationService(server);
@@ -8253,7 +8277,7 @@ var UserSettingItemSetting = {
     ],
 };
 
-var pluginModels$1 = [SystemSettingGroupSetting, SystemSettingItem, SystemSettingItemSetting, UserSettingGroupSetting, UserSettingItem, UserSettingItemSetting];
+var pluginModels$2 = [SystemSettingGroupSetting, SystemSettingItem, SystemSettingItemSetting, UserSettingGroupSetting, UserSettingItem, UserSettingItemSetting];
 
 var getUserSettingValues = {
     namespace: "svc",
@@ -8508,7 +8532,7 @@ class SettingPlugin {
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$1 });
+        server.appendApplicationConfig({ models: pluginModels$2 });
     }
     async configureServices(server, applicationConfig) {
         this.#settingService = new SettingService(server);
@@ -8520,6 +8544,136 @@ class SettingPlugin {
     async onApplicationLoaded(server, applicationConfig) { }
 }
 
+var CronJob = {
+    maintainedBy: "cronJob",
+    namespace: "sys",
+    name: "sys_cron_job",
+    singularCode: "sys_cron_job",
+    pluralCode: "sys_cron_jobs",
+    schema: "public",
+    tableName: "sys_cron_jobs",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "code",
+            code: "code",
+            columnName: "code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "description",
+            code: "description",
+            columnName: "description",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "cronTime",
+            code: "cronTime",
+            columnName: "cron_time",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "disabled",
+            code: "disabled",
+            columnName: "disabled",
+            type: "boolean",
+            required: true,
+            defaultValue: "false",
+        },
+        {
+            name: "jobOptions",
+            code: "jobOptions",
+            columnName: "job_options",
+            type: "json",
+            required: false,
+        },
+        {
+            name: "isRunning",
+            code: "isRunning",
+            columnName: "is_running",
+            type: "boolean",
+            required: true,
+            defaultValue: "false",
+        },
+        {
+            name: "nextRunningTime",
+            code: "nextRunningTime",
+            columnName: "next_running_time",
+            type: "datetime",
+            required: false,
+        },
+        {
+            name: "lastRunningTime",
+            code: "lastRunningTime",
+            columnName: "last_running_time",
+            type: "datetime",
+            required: false,
+        },
+        // success, failed, error
+        {
+            name: "lastRunningResult",
+            code: "lastRunningResult",
+            columnName: "last_running_result",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "lastErrorMessage",
+            code: "lastErrorMessage",
+            columnName: "last_error_message",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "lastErrorStack",
+            code: "lastErrorStack",
+            columnName: "last_error_stack",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "actionHandlerCode",
+            code: "actionHandlerCode",
+            columnName: "action_handler_code",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "handler",
+            code: "handler",
+            columnName: "handler",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "handleOptions",
+            code: "handleOptions",
+            columnName: "handle_options",
+            type: "json",
+            required: false,
+        },
+        {
+            name: "onError",
+            code: "onError",
+            columnName: "on_error",
+            type: "text",
+            required: false,
+        },
+    ],
+};
+
+var pluginModels$1 = [CronJob];
+
 const code$1 = "runCronJob";
 async function handler$1(plugin, ctx, options) {
     const { server, routerContext } = ctx;
@@ -8572,9 +8726,30 @@ var runCronJob = {
 
 var pluginRoutes$1 = [runCronJob];
 
+var cronJobEntityWatchers = [
+    {
+        eventName: "entity.update",
+        modelSingularCode: "sys_cron_job",
+        handler: async (ctx) => {
+            const { server, payload, routerContext: routeContext } = ctx;
+            const cronJobService = server.getService("cronJobService");
+            const changes = payload.changes;
+            const after = payload.after;
+            await cronJobService.updateJobConfig(routeContext, {
+                code: after.code,
+                cronTime: changes.cronTime,
+                disabled: changes.disabled,
+                jobOptions: changes.jobOptions,
+            });
+        },
+    },
+];
+
+var pluginEntityWatchers = [...cronJobEntityWatchers];
+
 class CronJobService {
     #server;
-    #jobInstances;
+    #namedJobInstances;
     constructor(server) {
         this.#server = server;
     }
@@ -8586,32 +8761,80 @@ class CronJobService {
     getJobConfigurationByCode(code) {
         return lodash.find(this.#server.listCronJobs(), (job) => job.code === code);
     }
+    #createJobInstance(job) {
+        return cron.CronJob.from({
+            ...(job.jobOptions || {}),
+            cronTime: job.cronTime,
+            onTick: async () => {
+                await this.tryExecuteJob(job);
+            },
+        });
+    }
+    async #startJobInstance(routeContext, jobConfiguration, jobInstance) {
+        const server = this.#server;
+        const jobCode = jobConfiguration.code;
+        const cronJobManager = server.getEntityManager("sys_cron_job");
+        const cronJobInDb = await cronJobManager.findEntity({
+            routeContext,
+            filters: [{ operator: "eq", field: "code", value: jobCode }],
+        });
+        if (cronJobInDb) {
+            let nextRunningTime;
+            nextRunningTime = formatDateTimeWithTimezone(jobInstance.nextDate().toISO());
+            await cronJobManager.updateEntityById({
+                routeContext,
+                id: cronJobInDb.id,
+                entityToSave: {
+                    nextRunningTime,
+                },
+            });
+        }
+        jobInstance.start();
+    }
+    async #setJobNextRunningTime(routeContext, jobCode, nextRunningTime) {
+        const server = this.#server;
+        const cronJobManager = server.getEntityManager("sys_cron_job");
+        const cronJobInDb = await cronJobManager.findEntity({
+            routeContext,
+            filters: [{ operator: "eq", field: "code", value: jobCode }],
+        });
+        await cronJobManager.updateEntityById({
+            routeContext,
+            id: cronJobInDb.id,
+            entityToSave: {
+                nextRunningTime,
+            },
+        });
+    }
     /**
      * 重新加载定时任务
      */
-    reloadJobs() {
+    async reloadJobs() {
         const server = this.#server;
-        if (this.#jobInstances) {
-            for (const job of this.#jobInstances) {
+        const routeContext = RouteContext.newSystemOperationContext(server);
+        if (this.#namedJobInstances) {
+            for (const job of this.#namedJobInstances) {
                 job.instance.stop();
             }
         }
-        this.#jobInstances = [];
-        const cronJobs = server.listCronJobs();
-        for (const job of cronJobs) {
-            if (job.disabled) {
+        this.#namedJobInstances = [];
+        const cronJobManager = server.getEntityManager("sys_cron_job");
+        const cronJobConfigurationsInDb = await cronJobManager.findEntities({ routeContext });
+        const cronJobConfigurations = server.listCronJobs();
+        for (const cronJobConfig of cronJobConfigurations) {
+            const jobCode = cronJobConfig.code;
+            const jobConfigInDb = lodash.find(cronJobConfigurationsInDb, { code: jobCode });
+            if (jobConfigInDb) {
+                overrideJobConfig(cronJobConfig, jobConfigInDb);
+            }
+            if (cronJobConfig.disabled) {
+                await this.#setJobNextRunningTime(routeContext, jobCode, null);
                 continue;
             }
-            const jobInstance = cron.CronJob.from({
-                ...(job.jobOptions || {}),
-                cronTime: job.cronTime,
-                onTick: async () => {
-                    await this.tryExecuteJob(job);
-                },
-            });
-            jobInstance.start();
-            this.#jobInstances.push({
-                code: job.code,
+            const jobInstance = this.#createJobInstance(cronJobConfig);
+            await this.#startJobInstance(routeContext, cronJobConfig, jobInstance);
+            this.#namedJobInstances.push({
+                code: jobCode,
                 instance: jobInstance,
             });
         }
@@ -8619,7 +8842,8 @@ class CronJobService {
     async tryExecuteJob(job) {
         const server = this.#server;
         const logger = server.getLogger();
-        logger.info(`Executing cron job '${job.code}'...`);
+        const jobCode = job.code;
+        logger.info(`Executing cron job '${jobCode}'...`);
         let handlerContext = {
             logger,
             routerContext: RouteContext.newSystemOperationContext(server),
@@ -8628,21 +8852,54 @@ class CronJobService {
             applicationConfig: null,
             input: null,
         };
+        let result;
+        let lastErrorMessage;
+        let lastErrorStack;
         try {
             await this.executeJob(handlerContext, job);
-            logger.info(`Completed cron job '${job.code}'...`);
+            result = "success";
+            logger.info(`Completed cron job '${jobCode}'...`);
         }
         catch (ex) {
-            logger.error('Cron job "%s" execution error: %s', job.code, ex.message);
+            logger.error('Cron job "%s" execution error: %s', jobCode, ex.message);
+            if (lodash.isString(ex)) {
+                lastErrorMessage = ex;
+            }
+            else {
+                lastErrorMessage = ex.message;
+                lastErrorStack = ex.stack;
+            }
+            result = "failed";
             if (job.onError) {
                 try {
                     await job.onError(handlerContext, ex);
                 }
                 catch (ex) {
-                    logger.error('Error handler of cron job "%s" execution failed: %s', job.code, ex.message);
+                    logger.error('Error handler of cron job "%s" execution failed: %s', jobCode, ex.message);
                 }
             }
         }
+        const cronJobManager = server.getEntityManager("sys_cron_job");
+        const cronJobInDb = await cronJobManager.findEntity({
+            filters: [{ operator: "eq", field: "code", value: jobCode }],
+        });
+        if (cronJobInDb) {
+            let nextRunningTime;
+            const namedJobInstance = lodash.find(this.#namedJobInstances, { code: jobCode });
+            if (namedJobInstance && namedJobInstance.instance) {
+                nextRunningTime = formatDateTimeWithTimezone(namedJobInstance.instance.nextDate().toISO());
+            }
+            await cronJobManager.updateEntityById({
+                id: cronJobInDb.id,
+                entityToSave: {
+                    nextRunningTime,
+                    lastRunningResult: result,
+                    lastRunningTime: getNowStringWithTimezone(),
+                    lastErrorMessage,
+                    lastErrorStack,
+                },
+            });
+        }
     }
     /**
      * 执行指定任务
@@ -8659,6 +8916,50 @@ class CronJobService {
             await job.handler(handlerContext, job.handleOptions);
         }
     }
+    async updateJobConfig(routeContext, options) {
+        const server = this.#server;
+        const cronJobs = server.listCronJobs();
+        const jobCode = options.code;
+        if (!jobCode) {
+            throw new Error(`options.code is required.`);
+        }
+        const cronJobConfig = lodash.find(cronJobs, { code: jobCode });
+        if (!cronJobConfig) {
+            throw new Error(`Cron job with code "${jobCode}" not found.`);
+        }
+        if (!["cronTime", "disabled", "jobOptions"].some((field) => !lodash.isNil(options[field]))) {
+            return;
+        }
+        overrideJobConfig(cronJobConfig, options);
+        const namedJobInstance = lodash.find(this.#namedJobInstances, { code: jobCode });
+        if (namedJobInstance && namedJobInstance.instance) {
+            namedJobInstance.instance.stop();
+            namedJobInstance.instance = null;
+        }
+        if (cronJobConfig.disabled) {
+            await this.#setJobNextRunningTime(routeContext, jobCode, null);
+        }
+        else {
+            const jobInstance = this.#createJobInstance(cronJobConfig);
+            await this.#startJobInstance(routeContext, cronJobConfig, jobInstance);
+            if (namedJobInstance) {
+                namedJobInstance.instance = jobInstance;
+            }
+            else {
+                this.#namedJobInstances.push({
+                    code: cronJobConfig.code,
+                    instance: jobInstance,
+                });
+            }
+        }
+    }
+}
+function overrideJobConfig(original, overrides) {
+    ["cronTime", "disabled", "jobOptions"].forEach((field) => {
+        if (!lodash.isNil(overrides[field])) {
+            original[field] = overrides[field];
+        }
+    });
 }
 
 class CronJobPlugin {
@@ -8689,11 +8990,16 @@ class CronJobPlugin {
             server.registerActionHandler(this, actionHandler);
         }
     }
-    async registerEventHandlers(server) { }
+    async registerEventHandlers(server) {
+        for (const entityWatcher of pluginEntityWatchers)
+            server.registerEntityWatcher(entityWatcher);
+    }
     async registerMessageHandlers(server) { }
     async registerTaskProcessors(server) { }
     async onLoadingApplication(server, applicationConfig) { }
-    async configureModels(server, applicationConfig) { }
+    async configureModels(server, applicationConfig) {
+        server.appendApplicationConfig({ models: pluginModels$1 });
+    }
     async configureModelProperties(server, applicationConfig) { }
     async configureServices(server, applicationConfig) {
         this.#cronJobService = new CronJobService(server);
@@ -8702,9 +9008,24 @@ class CronJobPlugin {
     async configureRoutes(server, applicationConfig) {
         server.appendApplicationConfig({ routes: pluginRoutes$1 });
     }
-    async onApplicationLoaded(server, applicationConfig) { }
+    async onApplicationLoaded(server, applicationConfig) {
+        await saveCronJobsToDatabase(server);
+    }
     async onApplicationReady(server, applicationConfig) {
-        this.#cronJobService.reloadJobs();
+        await this.#cronJobService.reloadJobs();
+    }
+}
+async function saveCronJobsToDatabase(server) {
+    const cronJobManager = server.getEntityManager("sys_cron_job");
+    for (const cronJobToSave of server.listCronJobs()) {
+        const currentCronJob = await cronJobManager.findEntity({
+            filters: [{ operator: "eq", field: "code", value: cronJobToSave.code }],
+        });
+        if (!currentCronJob) {
+            await cronJobManager.createEntity({
+                entity: lodash.pick(cronJobToSave, ["code", "description", "cronTime", "disabled"]),
+            });
+        }
     }
 }
 
@@ -9120,6 +9441,7 @@ exports.createJwt = createJwt;
 exports.decodeJwt = decodeJwt;
 exports.deleteCookie = deleteCookie;
 exports.detectChangedFieldsOfEntity = detectChangedFieldsOfEntity;
+exports.formatDateTimeWithTimezone = formatDateTimeWithTimezone;
 exports.generateJwtSecretKey = generateJwtSecretKey;
 exports.getCookies = getCookies;
 exports.getDateString = getDateString;

package/dist/plugins/cronJob/CronJobPluginTypes.d.ts

@@ -1,4 +1,5 @@
 import { CronJob } from "cron";
+import { CronJobConfiguration } from "../../types/cron-job-types";
 export type RunCronJobActionHandlerOptions = {
     code?: string;
 };
@@ -10,3 +11,28 @@ export type NamedCronJobInstance = {
     code: string;
     instance: CronJob;
 };
+export type JobRunningResult = "success" | "failed" | "error";
+export type SysCronJob = {
+    id: number;
+    code: string;
+    description: string;
+    cronTime: string;
+    disabled: boolean;
+    jobOptions: CronJobConfiguration["jobOptions"];
+    isRunning: boolean;
+    nextRunningTime: string;
+    lastRunningTime: string;
+    lastRunningResult?: JobRunningResult;
+    lastErrorMessage?: string;
+    lastErrorStack?: string;
+    actionHandlerCode?: string;
+    handler?: string;
+    handleOptions?: Record<string, any>;
+    onError?: string;
+};
+export type UpdateJobConfigOptions = {
+    code: string;
+    cronTime?: string;
+    disabled?: boolean;
+    jobOptions?: CronJobConfiguration["jobOptions"];
+};

package/dist/plugins/cronJob/entityWatchers/cronJobEntityWatchers.d.ts

@@ -0,0 +1,7 @@
+import type { EntityWatchHandlerContext } from "../../../types";
+declare const _default: {
+    eventName: string;
+    modelSingularCode: string;
+    handler: (ctx: EntityWatchHandlerContext<"entity.update">) => Promise<void>;
+}[];
+export default _default;

package/dist/plugins/cronJob/entityWatchers/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    eventName: string;
+    modelSingularCode: string;
+    handler: (ctx: import("../../../types").EntityWatchHandlerContext<"entity.update">) => Promise<void>;
+}[];
+export default _default;