@ruiapp/rapid-core 0.8.9 → 0.8.11

package/dist/plugins/cronJob/models/CronJob.d.ts

@@ -0,0 +1,3 @@
+import { RpdDataModel } from "../../../types";
+declare const _default: RpdDataModel;
+export default _default;

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

@@ -0,0 +1,2 @@
+declare const _default: import("../../..").RpdDataModel[];
+export default _default;

package/dist/plugins/cronJob/services/CronJobService.d.ts

@@ -1,4 +1,6 @@
 import { IRpdServer } from "../../../core/server";
+import { RouteContext } from "../../../core/routeContext";
+import { UpdateJobConfigOptions } from "../CronJobPluginTypes";
 import { CronJobConfiguration } from "../../../types/cron-job-types";
 import { ActionHandlerContext } from "../../../core/actionHandler";
 export default class CronJobService {
@@ -13,11 +15,12 @@ export default class CronJobService {
     /**
      * 重新加载定时任务
      */
-    reloadJobs(): void;
+    reloadJobs(): Promise<void>;
     tryExecuteJob(job: CronJobConfiguration): Promise<void>;
     /**
      * 执行指定任务
      * @param job
      */
     executeJob(handlerContext: ActionHandlerContext, job: CronJobConfiguration): Promise<void>;
+    updateJobConfig(routeContext: RouteContext, options: UpdateJobConfigOptions): Promise<void>;
 }

package/dist/utilities/timeUtility.d.ts

@@ -1,3 +1,4 @@
 export declare function getNowString(): string;
 export declare function getNowStringWithTimezone(): string;
 export declare function getDateString(timeString: any): string;
+export declare function formatDateTimeWithTimezone(source: any): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.8.9",
+  "version": "0.8.11",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/routeContext.ts

@@ -1,13 +1,13 @@
-import { isArray, isObject } from "lodash";
 import { RapidRequest } from "./request";
 import { RapidResponse } from "./response";
-import { HttpStatus, ResponseData } from "./http-types";
+import { HttpStatus } from "./http-types";
 import { IRpdServer } from "./server";
-import { Logger } from "~/facilities/log/LogFacility";
 import { IDatabaseAccessor, IDatabaseClient } from "~/types";
 
 export type Next = () => Promise<void>;
 
+export type TransactionState = "uninited" | "inited" | "started";
+
 // TODO: should divide to RequestContext and OperationContext
 
 export class RouteContext {
@@ -21,6 +21,7 @@ export class RouteContext {
   routeConfig: any;
   #server: IRpdServer;
   #dbTransactionClient: IDatabaseClient | undefined;
+  #dbTransactionState: TransactionState;
 
   static newSystemOperationContext(server: IRpdServer) {
     return new RouteContext(server);
@@ -29,6 +30,8 @@ export class RouteContext {
   constructor(server: IRpdServer, request?: RapidRequest) {
     this.#server = server;
     this.databaseAccessor = server.getDatabaseAccessor();
+    this.#dbTransactionState = "uninited";
+
     this.request = request;
     this.state = {};
     this.response = new RapidResponse();
@@ -71,29 +74,54 @@ export class RouteContext {
     return this.#dbTransactionClient;
   }
 
-  async beginDbTransaction(): Promise<IDatabaseClient> {
+  async initDbTransactionClient(): Promise<IDatabaseClient> {
     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(): Promise<void> {
+    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(): Promise<void> {
     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(): Promise<void> {
     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";
   }
 }

package/src/helpers/runCollectionEntityActionHandler.ts

@@ -28,7 +28,8 @@ export default async function runCollectionEntityActionHandler(
     let transactionDbClient: IDatabaseClient;
 
     try {
-      transactionDbClient = await routeContext.beginDbTransaction();
+      transactionDbClient = await routeContext.initDbTransactionClient();
+      await routeContext.beginDbTransaction();
 
       const result = handleEntityAction(entityManager, autoMergeInput ? mergedInput : input);
       if (result instanceof Promise) {

package/src/plugins/cronJob/CronJobPlugin.ts

@@ -1,6 +1,8 @@
 import type { RpdApplicationConfig } from "~/types";
+import pluginModels from "./models";
 import pluginActionHandlers from "./actionHandlers";
 import pluginRoutes from "./routes";
+import pluginEntityWatchers from "./entityWatchers";
 import {
   IRpdServer,
   RapidPlugin,
@@ -9,6 +11,8 @@ import {
   RpdServerPluginExtendingAbilities,
 } from "~/core/server";
 import CronJobService from "./services/CronJobService";
+import { SysCronJob } from "./CronJobPluginTypes";
+import { pick } from "lodash";
 
 class CronJobPlugin implements RapidPlugin {
   #server: IRpdServer;
@@ -48,15 +52,18 @@ class CronJobPlugin implements RapidPlugin {
     }
   }
 
-  async registerEventHandlers(server: IRpdServer): Promise<any> {}
-
+  async registerEventHandlers(server: IRpdServer): Promise<any> {
+    for (const entityWatcher of pluginEntityWatchers) server.registerEntityWatcher(entityWatcher);
+  }
   async registerMessageHandlers(server: IRpdServer): Promise<any> {}
 
   async registerTaskProcessors(server: IRpdServer): Promise<any> {}
 
   async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
-  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
+  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    server.appendApplicationConfig({ models: pluginModels });
+  }
 
   async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
@@ -69,11 +76,29 @@ class CronJobPlugin implements RapidPlugin {
     server.appendApplicationConfig({ routes: pluginRoutes });
   }
 
-  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
+  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    await saveCronJobsToDatabase(server);
+  }
 
   async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-    this.#cronJobService.reloadJobs();
+    await this.#cronJobService.reloadJobs();
   }
 }
 
 export default CronJobPlugin;
+
+async function saveCronJobsToDatabase(server: IRpdServer) {
+  const cronJobManager = server.getEntityManager<SysCronJob>("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: pick(cronJobToSave, ["code", "description", "cronTime", "disabled"]),
+      });
+    }
+  }
+}

package/src/plugins/cronJob/CronJobPluginTypes.ts

@@ -1,4 +1,5 @@
 import { CronJob } from "cron";
+import { CronJobConfiguration } from "~/types/cron-job-types";
 
 export type RunCronJobActionHandlerOptions = {
   code?: string;
@@ -13,3 +14,31 @@ 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/src/plugins/cronJob/entityWatchers/cronJobEntityWatchers.ts

@@ -0,0 +1,24 @@
+import type { EntityWatcher, EntityWatchHandlerContext } from "~/types";
+import CronJobService from "../services/CronJobService";
+import { SysCronJob } from "../CronJobPluginTypes";
+
+export default [
+  {
+    eventName: "entity.update",
+    modelSingularCode: "sys_cron_job",
+    handler: async (ctx: EntityWatchHandlerContext<"entity.update">) => {
+      const { server, payload, routerContext: routeContext } = ctx;
+
+      const cronJobService = server.getService<CronJobService>("cronJobService");
+
+      const changes: Partial<SysCronJob> = payload.changes;
+      const after: SysCronJob = payload.after;
+      await cronJobService.updateJobConfig(routeContext, {
+        code: after.code,
+        cronTime: changes.cronTime,
+        disabled: changes.disabled,
+        jobOptions: changes.jobOptions,
+      });
+    },
+  },
+] satisfies EntityWatcher<any>[];

package/src/plugins/cronJob/entityWatchers/index.ts

@@ -0,0 +1,4 @@
+import { EntityWatcher } from "~/types";
+import cronJobEntityWatchers from "./cronJobEntityWatchers";
+
+export default [...cronJobEntityWatchers] satisfies EntityWatcher<any>[];

package/src/plugins/cronJob/models/CronJob.ts

@@ -0,0 +1,129 @@
+import { RpdDataModel } from "~/types";
+
+export default {
+  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,
+    },
+  ],
+} as RpdDataModel;

package/src/plugins/cronJob/models/index.ts

@@ -0,0 +1,3 @@
+import CronJob from "./CronJob";
+
+export default [CronJob];

package/src/plugins/cronJob/services/CronJobService.ts

@@ -1,15 +1,16 @@
 import { CronJob } from "cron";
 import { IRpdServer } from "~/core/server";
-import { find } from "lodash";
+import { find, isNil, isString, Many } from "lodash";
 import { RouteContext } from "~/core/routeContext";
 import { validateLicense } from "~/helpers/licenseHelper";
-import { NamedCronJobInstance } from "../CronJobPluginTypes";
+import { JobRunningResult, NamedCronJobInstance, SysCronJob, UpdateJobConfigOptions } from "../CronJobPluginTypes";
 import { CronJobConfiguration } from "~/types/cron-job-types";
 import { ActionHandlerContext } from "~/core/actionHandler";
+import { formatDateTimeWithTimezone, getNowStringWithTimezone } from "~/utilities/timeUtility";
 
 export default class CronJobService {
   #server: IRpdServer;
-  #jobInstances: NamedCronJobInstance[];
+  #namedJobInstances: NamedCronJobInstance[];
 
   constructor(server: IRpdServer) {
     this.#server = server;
@@ -24,37 +25,93 @@ export default class CronJobService {
     return find(this.#server.listCronJobs(), (job) => job.code === code);
   }
 
+  #createJobInstance(job: CronJobConfiguration) {
+    return CronJob.from({
+      ...(job.jobOptions || {}),
+      cronTime: job.cronTime,
+      onTick: async () => {
+        await this.tryExecuteJob(job);
+      },
+    });
+  }
+
+  async #startJobInstance(routeContext: RouteContext, jobConfiguration: CronJobConfiguration, jobInstance: CronJob) {
+    const server = this.#server;
+    const jobCode = jobConfiguration.code;
+    const cronJobManager = server.getEntityManager<SysCronJob>("sys_cron_job");
+    const cronJobInDb = await cronJobManager.findEntity({
+      routeContext,
+      filters: [{ operator: "eq", field: "code", value: jobCode }],
+    });
+
+    if (cronJobInDb) {
+      let nextRunningTime: string | null;
+      nextRunningTime = formatDateTimeWithTimezone(jobInstance.nextDate().toISO());
+
+      await cronJobManager.updateEntityById({
+        routeContext,
+        id: cronJobInDb.id,
+        entityToSave: {
+          nextRunningTime,
+        } as Partial<SysCronJob>,
+      });
+    }
+
+    jobInstance.start();
+  }
+
+  async #setJobNextRunningTime(routeContext: RouteContext, jobCode: string, nextRunningTime: string | null) {
+    const server = this.#server;
+    const cronJobManager = server.getEntityManager<SysCronJob>("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,
+      } as Partial<SysCronJob>,
+    });
+  }
+
   /**
    * 重新加载定时任务
    */
-  reloadJobs() {
+  async reloadJobs() {
     const server = this.#server;
+    const routeContext = RouteContext.newSystemOperationContext(server);
 
-    if (this.#jobInstances) {
-      for (const job of this.#jobInstances) {
+    if (this.#namedJobInstances) {
+      for (const job of this.#namedJobInstances) {
         job.instance.stop();
       }
     }
 
-    this.#jobInstances = [];
+    this.#namedJobInstances = [];
 
-    const cronJobs = server.listCronJobs();
-    for (const job of cronJobs) {
-      if (job.disabled) {
+    const cronJobManager = server.getEntityManager<SysCronJob>("sys_cron_job");
+    const cronJobConfigurationsInDb = await cronJobManager.findEntities({ routeContext });
+
+    const cronJobConfigurations = server.listCronJobs();
+    for (const cronJobConfig of cronJobConfigurations) {
+      const jobCode = cronJobConfig.code;
+      const jobConfigInDb = find(cronJobConfigurationsInDb, { code: jobCode });
+      if (jobConfigInDb) {
+        overrideJobConfig(cronJobConfig, jobConfigInDb);
+      }
+
+      if (cronJobConfig.disabled) {
+        await this.#setJobNextRunningTime(routeContext, jobCode, null);
         continue;
       }
 
-      const jobInstance = CronJob.from({
-        ...(job.jobOptions || {}),
-        cronTime: job.cronTime,
-        onTick: async () => {
-          await this.tryExecuteJob(job);
-        },
-      });
-      jobInstance.start();
+      const jobInstance = this.#createJobInstance(cronJobConfig);
+      await this.#startJobInstance(routeContext, cronJobConfig, jobInstance);
 
-      this.#jobInstances.push({
-        code: job.code,
+      this.#namedJobInstances.push({
+        code: jobCode,
         instance: jobInstance,
       });
     }
@@ -63,7 +120,9 @@ export default class CronJobService {
   async tryExecuteJob(job: CronJobConfiguration) {
     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: ActionHandlerContext = {
       logger,
@@ -74,20 +133,55 @@ export default class CronJobService {
       input: null,
     };
 
+    let result: JobRunningResult;
+    let lastErrorMessage: string | null;
+    let lastErrorStack: string | null;
     try {
       await this.executeJob(handlerContext, job);
-      logger.info(`Completed cron job '${job.code}'...`);
+      result = "success";
+      logger.info(`Completed cron job '${jobCode}'...`);
     } catch (ex: any) {
-      logger.error('Cron job "%s" execution error: %s', job.code, ex.message);
+      logger.error('Cron job "%s" execution error: %s', jobCode, ex.message);
+      if (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<SysCronJob>("sys_cron_job");
+    const cronJobInDb = await cronJobManager.findEntity({
+      filters: [{ operator: "eq", field: "code", value: jobCode }],
+    });
+
+    if (cronJobInDb) {
+      let nextRunningTime: string | null;
+      const namedJobInstance = 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,
+        } as Partial<SysCronJob>,
+      });
+    }
   }
 
   /**
@@ -105,4 +199,54 @@ export default class CronJobService {
       await job.handler(handlerContext, job.handleOptions);
     }
   }
+
+  async updateJobConfig(routeContext: RouteContext, options: UpdateJobConfigOptions) {
+    const server = this.#server;
+    const cronJobs = server.listCronJobs();
+    const jobCode = options.code;
+    if (!jobCode) {
+      throw new Error(`options.code is required.`);
+    }
+
+    const cronJobConfig = find(cronJobs, { code: jobCode });
+    if (!cronJobConfig) {
+      throw new Error(`Cron job with code "${jobCode}" not found.`);
+    }
+
+    if (!(["cronTime", "disabled", "jobOptions"] as (keyof typeof options)[]).some((field) => !isNil(options[field]))) {
+      return;
+    }
+
+    overrideJobConfig(cronJobConfig, options);
+
+    const namedJobInstance = 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: Partial<SysCronJob> | CronJobConfiguration, overrides: Partial<SysCronJob>) {
+  (["cronTime", "disabled", "jobOptions"] as (keyof typeof overrides)[]).forEach((field: string) => {
+    if (!isNil(overrides[field])) {
+      original[field] = overrides[field];
+    }
+  });
 }

package/src/utilities/timeUtility.ts

@@ -11,3 +11,7 @@ export function getNowStringWithTimezone() {
 export function getDateString(timeString) {
   return dayjs(timeString).format("YYYY-MM-DD");
 }
+
+export function formatDateTimeWithTimezone(source: any) {
+  return dayjs(source).format("YYYY-MM-DD HH:mm:ss.SSSZ");
+}