@ruiapp/rapid-core 0.8.4 → 0.8.5

package/dist/index.js

@@ -19,24 +19,6 @@ var xstate = require('xstate');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
-function _interopNamespace(e) {
-  if (e && e.__esModule) return e;
-  var n = Object.create(null);
-  if (e) {
-    Object.keys(e).forEach(function (k) {
-      if (k !== 'default') {
-        var d = Object.getOwnPropertyDescriptor(e, k);
-        Object.defineProperty(n, k, d.get ? d : {
-          enumerable: true,
-          get: function () { return e[k]; }
-        });
-      }
-    });
-  }
-  n["default"] = e;
-  return Object.freeze(n);
-}
-
 var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
 var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
@@ -45,7 +27,6 @@ var bcrypt__default = /*#__PURE__*/_interopDefaultLegacy(bcrypt);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 var nodemailer__default = /*#__PURE__*/_interopDefaultLegacy(nodemailer);
-var cron__namespace = /*#__PURE__*/_interopNamespace(cron);
 
 function fixBigIntJSONSerialize() {
     BigInt.prototype.toJSON = function () {
@@ -8486,11 +8467,12 @@ async function handler$1(plugin, ctx, options) {
     if (!input.code) {
         throw new Error(`Cron job code is required.`);
     }
-    const job = plugin.getJobConfigurationByCode(input.code);
+    const cronJobService = server.getService("cronJobService");
+    const job = cronJobService.getJobConfigurationByCode(input.code);
     if (!job) {
         throw new Error(`Cron job with code '${input.code}' was not found.`);
     }
-    await plugin.executeJob(server, job);
+    await cronJobService.executeJob(job);
     response.json({});
 }
 
@@ -8518,47 +8500,37 @@ var runCronJob = {
 
 var pluginRoutes$1 = [runCronJob];
 
-class CronJobPlugin {
+class CronJobService {
     #server;
-    constructor() { }
-    get code() {
-        return "cronJob";
-    }
-    get description() {
-        return "";
-    }
-    get extendingAbilities() {
-        return [];
-    }
-    get configurableTargets() {
-        return [];
-    }
-    get configurations() {
-        return [];
-    }
-    async initPlugin(server) {
+    #jobInstances;
+    constructor(server) {
         this.#server = server;
     }
-    async registerMiddlewares(server) { }
-    async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$1) {
-            server.registerActionHandler(this, actionHandler);
-        }
-    }
-    async registerEventHandlers(server) { }
-    async registerMessageHandlers(server) { }
-    async registerTaskProcessors(server) { }
-    async onLoadingApplication(server, applicationConfig) { }
-    async configureModels(server, applicationConfig) { }
-    async configureModelProperties(server, applicationConfig) { }
-    async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$1 });
+    /**
+     * 根据编号获取定时任务配置信息
+     * @param code
+     * @returns
+     */
+    getJobConfigurationByCode(code) {
+        return lodash.find(this.#server.listCronJobs(), (job) => job.code === code);
     }
-    async onApplicationLoaded(server, applicationConfig) { }
-    async onApplicationReady(server, applicationConfig) {
+    /**
+     * 重新加载定时任务
+     */
+    reloadJobs() {
+        const server = this.#server;
+        if (this.#jobInstances) {
+            for (const job of this.#jobInstances) {
+                job.instance.stop();
+            }
+        }
+        this.#jobInstances = [];
         const cronJobs = server.listCronJobs();
         for (const job of cronJobs) {
-            const jobInstance = cron__namespace.CronJob.from({
+            if (job.disabled) {
+                continue;
+            }
+            const jobInstance = cron.CronJob.from({
                 ...(job.jobOptions || {}),
                 cronTime: job.cronTime,
                 onTick: async () => {
@@ -8566,23 +8538,29 @@ class CronJobPlugin {
                 },
             });
             jobInstance.start();
+            this.#jobInstances.push({
+                code: job.code,
+                instance: jobInstance,
+            });
         }
     }
-    getJobConfigurationByCode(code) {
-        return lodash.find(this.#server.listCronJobs(), (job) => job.code === code);
-    }
     async tryExecuteJob(server, job) {
         const logger = server.getLogger();
         logger.info(`Executing cron job '${job.code}'...`);
         try {
-            await this.executeJob(server, job);
+            await this.executeJob(job);
             logger.info(`Completed cron job '${job.code}'...`);
         }
         catch (ex) {
             logger.error('Cron job "%s" execution error: %s', job.code, ex.message, { cronJobCode: job.code });
         }
     }
-    async executeJob(server, job) {
+    /**
+     * 执行指定任务
+     * @param job
+     */
+    async executeJob(job) {
+        const server = this.#server;
         const logger = server.getLogger();
         validateLicense(server);
         let handlerContext = {
@@ -8603,6 +8581,53 @@ class CronJobPlugin {
     }
 }
 
+class CronJobPlugin {
+    #server;
+    #cronJobService;
+    constructor() { }
+    get code() {
+        return "cronJob";
+    }
+    get description() {
+        return "";
+    }
+    get extendingAbilities() {
+        return [];
+    }
+    get configurableTargets() {
+        return [];
+    }
+    get configurations() {
+        return [];
+    }
+    async initPlugin(server) {
+        this.#server = server;
+    }
+    async registerMiddlewares(server) { }
+    async registerActionHandlers(server) {
+        for (const actionHandler of pluginActionHandlers$1) {
+            server.registerActionHandler(this, actionHandler);
+        }
+    }
+    async registerEventHandlers(server) { }
+    async registerMessageHandlers(server) { }
+    async registerTaskProcessors(server) { }
+    async onLoadingApplication(server, applicationConfig) { }
+    async configureModels(server, applicationConfig) { }
+    async configureModelProperties(server, applicationConfig) { }
+    async configureServices(server, applicationConfig) {
+        this.#cronJobService = new CronJobService(server);
+        server.registerService("cronJobService", this.#cronJobService);
+    }
+    async configureRoutes(server, applicationConfig) {
+        server.appendApplicationConfig({ routes: pluginRoutes$1 });
+    }
+    async onApplicationLoaded(server, applicationConfig) { }
+    async onApplicationReady(server, applicationConfig) {
+        this.#cronJobService.reloadJobs();
+    }
+}
+
 async function getStateMachineNextSnapshot(options) {
     const { machineConfig, currentState, event } = options;
     machineConfig.initial = currentState;

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

@@ -1,5 +1,4 @@
 import type { RpdApplicationConfig } from "../../types";
-import { CronJobConfiguration } from "../../types/cron-job-types";
 import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "../../core/server";
 declare class CronJobPlugin implements RapidPlugin {
     #private;
@@ -18,11 +17,9 @@ declare class CronJobPlugin implements RapidPlugin {
     onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureServices(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
     onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
-    getJobConfigurationByCode(code: string): CronJobConfiguration;
-    tryExecuteJob(server: IRpdServer, job: CronJobConfiguration): Promise<void>;
-    executeJob(server: IRpdServer, job: CronJobConfiguration): Promise<void>;
 }
 export default CronJobPlugin;

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

@@ -1,6 +1,11 @@
+import { CronJob } from "cron";
 export type RunCronJobActionHandlerOptions = {
     code?: string;
 };
 export type RunCronJobInput = {
     code?: string;
 };
+export type NamedCronJobInstance = {
+    code: string;
+    instance: CronJob;
+};

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

@@ -0,0 +1,22 @@
+import { IRpdServer } from "../../../core/server";
+import { CronJobConfiguration } from "../../../types/cron-job-types";
+export default class CronJobService {
+    #private;
+    constructor(server: IRpdServer);
+    /**
+     * 根据编号获取定时任务配置信息
+     * @param code
+     * @returns
+     */
+    getJobConfigurationByCode(code: string): CronJobConfiguration;
+    /**
+     * 重新加载定时任务
+     */
+    reloadJobs(): void;
+    tryExecuteJob(server: IRpdServer, job: CronJobConfiguration): Promise<void>;
+    /**
+     * 执行指定任务
+     * @param job
+     */
+    executeJob(job: CronJobConfiguration): Promise<void>;
+}

package/dist/types/cron-job-types.d.ts

@@ -8,6 +8,10 @@ export interface CronJobConfiguration {
      * 定时任务描述
      */
     description?: string;
+    /**
+     * 是否禁用
+     */
+    disabled?: boolean;
     /**
      * crontab 表达式
      */

package/package.json

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

package/src/plugins/cronJob/CronJobPlugin.ts

@@ -1,8 +1,6 @@
-import * as cron from "cron";
 import type { RpdApplicationConfig } from "~/types";
 import pluginActionHandlers from "./actionHandlers";
 import pluginRoutes from "./routes";
-import { CronJobConfiguration } from "~/types/cron-job-types";
 import {
   IRpdServer,
   RapidPlugin,
@@ -10,13 +8,11 @@ import {
   RpdServerPluginConfigurableTargetOptions,
   RpdServerPluginExtendingAbilities,
 } from "~/core/server";
-import { ActionHandlerContext } from "~/core/actionHandler";
-import { find } from "lodash";
-import { validateLicense } from "~/helpers/licenseHelper";
-import { RouteContext } from "~/core/routeContext";
+import CronJobService from "./services/CronJobService";
 
 class CronJobPlugin implements RapidPlugin {
   #server: IRpdServer;
+  #cronJobService!: CronJobService;
 
   constructor() {}
 
@@ -64,6 +60,11 @@ class CronJobPlugin implements RapidPlugin {
 
   async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
+  async configureServices(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    this.#cronJobService = new CronJobService(server);
+    server.registerService("cronJobService", this.#cronJobService);
+  }
+
   async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
     server.appendApplicationConfig({ routes: pluginRoutes });
   }
@@ -71,54 +72,7 @@ class CronJobPlugin implements RapidPlugin {
   async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
   async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-    const cronJobs = server.listCronJobs();
-    for (const job of cronJobs) {
-      const jobInstance = cron.CronJob.from({
-        ...(job.jobOptions || {}),
-        cronTime: job.cronTime,
-        onTick: async () => {
-          await this.tryExecuteJob(server, job);
-        },
-      });
-      jobInstance.start();
-    }
-  }
-
-  getJobConfigurationByCode(code: string) {
-    return find(this.#server.listCronJobs(), (job) => job.code === code);
-  }
-
-  async tryExecuteJob(server: IRpdServer, job: CronJobConfiguration) {
-    const logger = server.getLogger();
-    logger.info(`Executing cron job '${job.code}'...`);
-
-    try {
-      await this.executeJob(server, job);
-      logger.info(`Completed cron job '${job.code}'...`);
-    } catch (ex: any) {
-      logger.error('Cron job "%s" execution error: %s', job.code, ex.message, { cronJobCode: job.code });
-    }
-  }
-
-  async executeJob(server: IRpdServer, job: CronJobConfiguration) {
-    const logger = server.getLogger();
-    validateLicense(server);
-
-    let handlerContext: ActionHandlerContext = {
-      logger,
-      routerContext: RouteContext.newSystemOperationContext(server),
-      next: null,
-      server,
-      applicationConfig: null,
-      input: null,
-    };
-
-    if (job.actionHandlerCode) {
-      const actionHandler = server.getActionHandlerByCode(job.code);
-      await actionHandler(handlerContext, job.handleOptions);
-    } else {
-      await job.handler(handlerContext, job.handleOptions);
-    }
+    this.#cronJobService.reloadJobs();
   }
 }
 

package/src/plugins/cronJob/CronJobPluginTypes.ts

@@ -1,3 +1,5 @@
+import { CronJob } from "cron";
+
 export type RunCronJobActionHandlerOptions = {
   code?: string;
 };
@@ -5,3 +7,8 @@ export type RunCronJobActionHandlerOptions = {
 export type RunCronJobInput = {
   code?: string;
 };
+
+export type NamedCronJobInstance = {
+  code: string;
+  instance: CronJob;
+};

package/src/plugins/cronJob/actionHandlers/runCronJob.ts

@@ -1,6 +1,7 @@
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RunCronJobActionHandlerOptions, RunCronJobInput } from "../CronJobPluginTypes";
 import type CronJobPlugin from "../CronJobPlugin";
+import CronJobService from "../services/CronJobService";
 
 export const code = "runCronJob";
 
@@ -18,12 +19,13 @@ export async function handler(plugin: CronJobPlugin, ctx: ActionHandlerContext,
     throw new Error(`Cron job code is required.`);
   }
 
-  const job = plugin.getJobConfigurationByCode(input.code);
+  const cronJobService = server.getService<CronJobService>("cronJobService");
+  const job = cronJobService.getJobConfigurationByCode(input.code);
   if (!job) {
     throw new Error(`Cron job with code '${input.code}' was not found.`);
   }
 
-  await plugin.executeJob(server, job);
+  await cronJobService.executeJob(job);
 
   response.json({});
 }

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

@@ -0,0 +1,100 @@
+import { CronJob } from "cron";
+import { IRpdServer } from "~/core/server";
+import { find } from "lodash";
+import { RouteContext } from "~/core/routeContext";
+import { validateLicense } from "~/helpers/licenseHelper";
+import { NamedCronJobInstance } from "../CronJobPluginTypes";
+import { CronJobConfiguration } from "~/types/cron-job-types";
+import { ActionHandlerContext } from "~/core/actionHandler";
+
+export default class CronJobService {
+  #server: IRpdServer;
+  #jobInstances: NamedCronJobInstance[];
+
+  constructor(server: IRpdServer) {
+    this.#server = server;
+  }
+
+  /**
+   * 根据编号获取定时任务配置信息
+   * @param code
+   * @returns
+   */
+  getJobConfigurationByCode(code: string) {
+    return find(this.#server.listCronJobs(), (job) => job.code === code);
+  }
+
+  /**
+   * 重新加载定时任务
+   */
+  reloadJobs() {
+    const server = this.#server;
+
+    if (this.#jobInstances) {
+      for (const job of this.#jobInstances) {
+        job.instance.stop();
+      }
+    }
+
+    this.#jobInstances = [];
+
+    const cronJobs = server.listCronJobs();
+    for (const job of cronJobs) {
+      if (job.disabled) {
+        continue;
+      }
+
+      const jobInstance = CronJob.from({
+        ...(job.jobOptions || {}),
+        cronTime: job.cronTime,
+        onTick: async () => {
+          await this.tryExecuteJob(server, job);
+        },
+      });
+      jobInstance.start();
+
+      this.#jobInstances.push({
+        code: job.code,
+        instance: jobInstance,
+      });
+    }
+  }
+
+  async tryExecuteJob(server: IRpdServer, job: CronJobConfiguration) {
+    const logger = server.getLogger();
+    logger.info(`Executing cron job '${job.code}'...`);
+
+    try {
+      await this.executeJob(job);
+      logger.info(`Completed cron job '${job.code}'...`);
+    } catch (ex: any) {
+      logger.error('Cron job "%s" execution error: %s', job.code, ex.message, { cronJobCode: job.code });
+    }
+  }
+
+  /**
+   * 执行指定任务
+   * @param job
+   */
+  async executeJob(job: CronJobConfiguration) {
+    const server = this.#server;
+    const logger = server.getLogger();
+    validateLicense(server);
+
+    let handlerContext: ActionHandlerContext = {
+      logger,
+      routerContext: RouteContext.newSystemOperationContext(server),
+      next: null,
+      server,
+      applicationConfig: null,
+      input: null,
+    };
+
+    if (job.actionHandlerCode) {
+      const actionHandler = server.getActionHandlerByCode(job.code);
+      await actionHandler(handlerContext, job.handleOptions);
+    } else {
+      await job.handler(handlerContext, job.handleOptions);
+    }
+  }
+}

package/src/types/cron-job-types.ts

@@ -11,6 +11,11 @@ export interface CronJobConfiguration {
    */
   description?: string;
 
+  /**
+   * 是否禁用
+   */
+  disabled?: boolean;
+
   /**
    * crontab 表达式
    */