@ruiapp/rapid-core 0.1.31 → 0.1.32

package/dist/index.d.ts

@@ -17,6 +17,8 @@ export { default as AuthPlugin } from "./plugins/auth/AuthPlugin";
 export { default as FileManagePlugin } from "./plugins/fileManage/FileManagePlugin";
 export { default as ServerOperationPlugin } from "./plugins/serverOperation/ServerOperationPlugin";
 export * from "./plugins/serverOperation/ServerOperationPluginTypes";
+export { default as CronJobPlugin } from "./plugins/cronJob/CronJobPlugin";
+export * from "./plugins/cronJob/CronJobPluginTypes";
 export { default as StateMachinePlugin } from "./plugins/stateMachine/StateMachinePlugin";
 export * from "./plugins/stateMachine/StateMachinePluginTypes";
 export { default as EntityWatchPlugin } from "./plugins/entityWatch/EntityWatchPlugin";

package/dist/index.js

@@ -13,10 +13,29 @@ var bcrypt = require('bcrypt');
 var path = require('path');
 var fs = require('fs');
 var uuid = require('uuid');
+var cron = require('cron');
 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 crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
@@ -24,6 +43,7 @@ var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
 var bcrypt__default = /*#__PURE__*/_interopDefaultLegacy(bcrypt);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+var cron__namespace = /*#__PURE__*/_interopNamespace(cron);
 
 function fixBigIntJSONSerialize() {
     BigInt.prototype.toJSON = function () {
@@ -2799,32 +2819,32 @@ async function generateJwtSecretKey() {
     return encode(exportedKey);
 }
 
-const code$o = "listMetaModels";
-async function handler$o(plugin, ctx, options) {
+const code$p = "listMetaModels";
+async function handler$p(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$o,
-  handler: handler$o
+  code: code$p,
+  handler: handler$p
 });
 
-const code$n = "listMetaRoutes";
-async function handler$n(plugin, ctx, options) {
+const code$o = "listMetaRoutes";
+async function handler$o(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$n,
-  handler: handler$n
+  code: code$o,
+  handler: handler$o
 });
 
-const code$m = "getMetaModelDetail";
-async function handler$m(plugin, ctx, options) {
+const code$n = "getMetaModelDetail";
+async function handler$n(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -2832,8 +2852,8 @@ async function handler$m(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$m,
-  handler: handler$m
+  code: code$n,
+  handler: handler$n
 });
 
 /**
@@ -3185,9 +3205,9 @@ function transformFilterWithSubFilters(filter) {
     return filter;
 }
 
-const code$l = "findCollectionEntities";
-async function handler$l(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$l, async (entityManager, input) => {
+const code$m = "findCollectionEntities";
+async function handler$m(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$m, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         const entities = await entityManager.findEntities(input);
         const result = { list: entities };
@@ -3202,14 +3222,14 @@ async function handler$l(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$l,
-  handler: handler$l
+  code: code$m,
+  handler: handler$m
 });
 
-const code$k = "findCollectionEntityById";
-async function handler$k(plugin, ctx, options) {
+const code$l = "findCollectionEntityById";
+async function handler$l(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$k} handler...`, { input });
+    logger.debug(`Running ${code$l} handler...`, { input });
     const { id } = input;
     const entityManager = server.getEntityManager(options.singularCode);
     const entity = await entityManager.findById(id);
@@ -3221,13 +3241,13 @@ async function handler$k(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$k,
-  handler: handler$k
+  code: code$l,
+  handler: handler$l
 });
 
-const code$j = "countCollectionEntities";
-async function handler$j(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$j, (entityManager, input) => {
+const code$k = "countCollectionEntities";
+async function handler$k(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$k, (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         return entityManager.count(input);
     });
@@ -3235,16 +3255,16 @@ async function handler$j(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$j,
-  handler: handler$j
+  code: code$k,
+  handler: handler$k
 });
 
-const code$i = "createCollectionEntity";
-async function handler$i(plugin, ctx, options) {
+const code$j = "createCollectionEntity";
+async function handler$j(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$i} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$j} handler...`, { defaultInput, fixedInput, mergedInput });
     const userId = ctx.routerContext.state?.userId;
     if (userId) {
         input.createdBy = userId;
@@ -3258,15 +3278,15 @@ async function handler$i(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$i,
-  handler: handler$i
+  code: code$j,
+  handler: handler$j
 });
 
-const code$h = "createCollectionEntitiesBatch";
-async function handler$h(plugin, ctx, options) {
+const code$i = "createCollectionEntitiesBatch";
+async function handler$i(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    logger.debug(`Running ${code$h} handler...`, { defaultInput, fixedInput, input });
+    logger.debug(`Running ${code$i} handler...`, { defaultInput, fixedInput, input });
     const { entities } = input;
     if (!lodash.isArray(entities)) {
         throw new Error("input.entities should be an array.");
@@ -3289,16 +3309,16 @@ async function handler$h(plugin, ctx, options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$h,
-  handler: handler$h
+  code: code$i,
+  handler: handler$i
 });
 
-const code$g = "updateCollectionEntityById";
-async function handler$g(plugin, ctx, options) {
+const code$h = "updateCollectionEntityById";
+async function handler$h(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$g} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$h} handler...`, { defaultInput, fixedInput, mergedInput });
     const operation = mergedInput.$operation;
     if (operation) {
         delete mergedInput.$operation;
@@ -3310,14 +3330,14 @@ async function handler$g(plugin, ctx, options) {
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$g,
-  handler: handler$g
+  code: code$h,
+  handler: handler$h
 });
 
-const code$f = "deleteCollectionEntityById";
-async function handler$f(plugin, ctx, options) {
+const code$g = "deleteCollectionEntityById";
+async function handler$g(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$f} handler...`);
+    logger.debug(`Running ${code$g} handler...`);
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.deleteById(input.id, plugin);
     ctx.status = 200;
@@ -3326,16 +3346,16 @@ async function handler$f(plugin, ctx, options) {
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$f,
-  handler: handler$f
+  code: code$g,
+  handler: handler$g
 });
 
-const code$e = "addEntityRelations";
-async function handler$e(plugin, ctx, options) {
+const code$f = "addEntityRelations";
+async function handler$f(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$e} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$f} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.addRelations(mergedInput, plugin);
     ctx.output = {};
@@ -3343,16 +3363,16 @@ async function handler$e(plugin, ctx, options) {
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$e,
-  handler: handler$e
+  code: code$f,
+  handler: handler$f
 });
 
-const code$d = "removeEntityRelations";
-async function handler$d(plugin, ctx, options) {
+const code$e = "removeEntityRelations";
+async function handler$e(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$d} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$e} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.removeRelations(mergedInput, plugin);
     ctx.output = {};
@@ -3360,16 +3380,16 @@ async function handler$d(plugin, ctx, options) {
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$d,
-  handler: handler$d
+  code: code$e,
+  handler: handler$e
 });
 
-const code$c = "queryDatabase";
-async function handler$c(plugin, ctx, options) {
+const code$d = "queryDatabase";
+async function handler$d(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$c} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$d} handler...`, { defaultInput, fixedInput, mergedInput });
     const result = await server.queryDatabaseObject(sql, mergedInput);
     if (querySingle) {
         ctx.output = lodash.first(result);
@@ -3381,8 +3401,8 @@ async function handler$c(plugin, ctx, options) {
 
 var queryDatabase = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$c,
-  handler: handler$c
+  code: code$d,
+  handler: handler$d
 });
 
 /**
@@ -3553,17 +3573,17 @@ async function sendSourceResponse(proxyCtx, targetRes) {
     srcRes.body = targetRes.body;
 }
 
-const code$b = "httpProxy";
-async function handler$b(plugin, ctx, options) {
+const code$c = "httpProxy";
+async function handler$c(plugin, ctx, options) {
     const { logger } = ctx;
-    logger.debug(`Running ${code$b} handler...`);
+    logger.debug(`Running ${code$c} handler...`);
     await doProxy(ctx.routerContext, options);
 }
 
 var httpProxy = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$b,
-  handler: handler$b
+  code: code$c,
+  handler: handler$c
 });
 
 /**
@@ -3802,8 +3822,8 @@ async function generateSn$2(server, input) {
     return sequenceNumbers;
 }
 
-const code$a = "generateSn";
-async function handler$a(plugin, ctx, options) {
+const code$b = "generateSn";
+async function handler$b(plugin, ctx, options) {
     const { server, routerContext } = ctx;
     const input = ctx.input;
     if (options?.ruleCode) {
@@ -3820,11 +3840,11 @@ async function handler$a(plugin, ctx, options) {
 
 var generateSn$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$a,
-  handler: handler$a
+  code: code$b,
+  handler: handler$b
 });
 
-var pluginActionHandlers$3 = [
+var pluginActionHandlers$4 = [
     generateSn$1,
 ];
 
@@ -3936,7 +3956,7 @@ var generateSn = {
     ],
 };
 
-var pluginRoutes$3 = [
+var pluginRoutes$4 = [
     generateSn,
 ];
 
@@ -3960,7 +3980,7 @@ class SequencePlugin {
         return [];
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$3) {
+        for (const actionHandler of pluginActionHandlers$4) {
             server.registerActionHandler(this, actionHandler);
         }
     }
@@ -3968,7 +3988,7 @@ class SequencePlugin {
         server.appendApplicationConfig({ models: pluginModels$2 });
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$3 });
+        server.appendApplicationConfig({ routes: pluginRoutes$4 });
     }
     async onApplicationLoaded(server, applicationConfig) {
         const models = server.getApplicationConfig().models;
@@ -4210,8 +4230,8 @@ class WebhooksPlugin {
     }
 }
 
-const code$9 = "changePassword";
-async function handler$9(plugin, ctx, options) {
+const code$a = "changePassword";
+async function handler$a(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { id, oldPassword, newPassword } = input;
     const userId = routerContext.state.userId;
@@ -4253,12 +4273,12 @@ async function handler$9(plugin, ctx, options) {
 
 var changePassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$9,
-  handler: handler$9
+  code: code$a,
+  handler: handler$a
 });
 
-const code$8 = "createSession";
-async function handler$8(plugin, ctx, options) {
+const code$9 = "createSession";
+async function handler$9(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     const { account, password } = input;
@@ -4301,12 +4321,12 @@ async function handler$8(plugin, ctx, options) {
 
 var createSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$8,
-  handler: handler$8
+  code: code$9,
+  handler: handler$9
 });
 
-const code$7 = "deleteSession";
-async function handler$7(plugin, ctx, options) {
+const code$8 = "deleteSession";
+async function handler$8(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     setCookie(response.headers, {
@@ -4319,12 +4339,12 @@ async function handler$7(plugin, ctx, options) {
 
 var deleteSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$7,
-  handler: handler$7
+  code: code$8,
+  handler: handler$8
 });
 
-const code$6 = "getMyProfile";
-async function handler$6(plugin, ctx, options) {
+const code$7 = "getMyProfile";
+async function handler$7(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const userId = routerContext.state.userId;
     if (!userId) {
@@ -4354,12 +4374,12 @@ async function handler$6(plugin, ctx, options) {
 
 var getMyProfile$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$6,
-  handler: handler$6
+  code: code$7,
+  handler: handler$7
 });
 
-const code$5 = "resetPassword";
-async function handler$5(plugin, ctx, options) {
+const code$6 = "resetPassword";
+async function handler$6(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { userId, password } = input;
     const userDataAccessor = server.getDataAccessor({
@@ -4387,11 +4407,11 @@ async function handler$5(plugin, ctx, options) {
 
 var resetPassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$5,
-  handler: handler$5
+  code: code$6,
+  handler: handler$6
 });
 
-var pluginActionHandlers$2 = [
+var pluginActionHandlers$3 = [
     changePassword$1,
     createSession,
     deleteSession,
@@ -4528,7 +4548,7 @@ var signout$1 = {
     ],
 };
 
-var pluginRoutes$2 = [
+var pluginRoutes$3 = [
     changePassword,
     getMyProfile$1,
     resetPassword,
@@ -4556,7 +4576,7 @@ class AuthPlugin {
         return [];
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$2) {
+        for (const actionHandler of pluginActionHandlers$3) {
             server.registerActionHandler(this, actionHandler);
         }
     }
@@ -4564,7 +4584,7 @@ class AuthPlugin {
         server.appendApplicationConfig({ models: pluginModels$1 });
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$2 });
+        server.appendApplicationConfig({ routes: pluginRoutes$3 });
     }
     async onPrepareRouteContext(server, routeContext) {
         const request = routeContext.request;
@@ -4620,8 +4640,8 @@ async function appendFile(path, data) {
     });
 }
 
-const code$4 = "downloadDocument";
-async function handler$4(plugin, ctx, options) {
+const code$5 = "downloadDocument";
+async function handler$5(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const documentDataAccessor = ctx.server.getDataAccessor({
@@ -4649,12 +4669,12 @@ async function handler$4(plugin, ctx, options) {
 
 var downloadDocumentActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$4,
-  handler: handler$4
+  code: code$5,
+  handler: handler$5
 });
 
-const code$3 = "downloadFile";
-async function handler$3(plugin, ctx, options) {
+const code$4 = "downloadFile";
+async function handler$4(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const dataAccessor = ctx.server.getDataAccessor({
@@ -4674,12 +4694,12 @@ async function handler$3(plugin, ctx, options) {
 
 var downloadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$3,
-  handler: handler$3
+  code: code$4,
+  handler: handler$4
 });
 
-const code$2 = "uploadFile";
-async function handler$2(plugin, ctx, options) {
+const code$3 = "uploadFile";
+async function handler$3(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     let file = input.file || input.files;
     if (lodash.isArray(file)) {
@@ -4700,8 +4720,8 @@ async function handler$2(plugin, ctx, options) {
 
 var uploadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$2,
-  handler: handler$2
+  code: code$3,
+  handler: handler$3
 });
 
 var getMyProfile = {
@@ -4746,7 +4766,7 @@ var signout = {
     ],
 };
 
-var pluginRoutes$1 = [
+var pluginRoutes$2 = [
     getMyProfile,
     signin,
     signout,
@@ -4777,23 +4797,23 @@ class FileManager {
         server.registerActionHandler(this, uploadFileActionHandler);
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$1 });
+        server.appendApplicationConfig({ routes: pluginRoutes$2 });
     }
 }
 
-const code$1 = "runServerOperation";
-async function handler$1(plugin, ctx, options) {
+const code$2 = "runServerOperation";
+async function handler$2(plugin, ctx, options) {
     const { operation } = options;
     await operation(ctx);
 }
 
 var runServerOperation = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$1,
-  handler: handler$1
+  code: code$2,
+  handler: handler$2
 });
 
-var pluginActionHandlers$1 = [
+var pluginActionHandlers$2 = [
     runServerOperation,
 ];
 
@@ -4822,7 +4842,7 @@ class ServerOperationPlugin {
     async registerMiddlewares(server) {
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$1) {
+        for (const actionHandler of pluginActionHandlers$2) {
             server.registerActionHandler(this, actionHandler);
         }
     }
@@ -4866,6 +4886,137 @@ class ServerOperationPlugin {
     }
 }
 
+const code$1 = "runCronJob";
+async function handler$1(plugin, ctx, options) {
+    const { server, routerContext } = ctx;
+    const { response } = routerContext;
+    const input = ctx.input;
+    if (options.code) {
+        input.code = options.code;
+    }
+    if (!input.code) {
+        throw new Error(`Cron job code is required.`);
+    }
+    const job = plugin.getJobConfigurationByCode(input.code);
+    if (!job) {
+        throw new Error(`Cron job with code '${input.code}' was not found.`);
+    }
+    await plugin.executeJob(server, job);
+    response.json({});
+}
+
+var runCronJob$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$1,
+  handler: handler$1
+});
+
+var pluginActionHandlers$1 = [
+    runCronJob$1,
+];
+
+var runCronJob = {
+    namespace: "svc",
+    name: "svc.runCronJob",
+    code: "svc.runCronJob",
+    type: "RESTful",
+    method: "POST",
+    endpoint: "/svc/runCronJob",
+    actions: [
+        {
+            code: "runCronJob",
+        },
+    ],
+};
+
+var pluginRoutes$1 = [
+    runCronJob,
+];
+
+class CronJobPlugin {
+    #jobs;
+    constructor(options) {
+        this.#jobs = options.jobs || [];
+    }
+    get code() {
+        return "cronJob";
+    }
+    get description() {
+        return "";
+    }
+    get extendingAbilities() {
+        return [];
+    }
+    get configurableTargets() {
+        return [];
+    }
+    get configurations() {
+        return [];
+    }
+    async initPlugin(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 });
+    }
+    async onApplicationLoaded(server, applicationConfig) {
+    }
+    async onApplicationReady(server, applicationConfig) {
+        for (const job of this.#jobs) {
+            cron__namespace.CronJob.from({
+                cronTime: job.cronTime,
+                onTick: async () => {
+                    await this.executeJob(server, job);
+                },
+            });
+        }
+    }
+    getJobConfigurationByCode(code) {
+        return lodash.find(this.#jobs, (job) => job.code === code);
+    }
+    async executeJob(server, job) {
+        const logger = server.getLogger();
+        try {
+            let handlerContext = {
+                logger,
+                routerContext: null,
+                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);
+            }
+        }
+        catch (ex) {
+            logger.error("Cron job execution error: " + ex.message);
+        }
+    }
+}
+
 async function getStateMachineNextSnapshot(server, options) {
     debugger;
     const { machineConfig, currentState, event } = options;
@@ -5311,6 +5462,7 @@ class EntityAccessControlPlugin {
 fixBigIntJSONSerialize();
 
 exports.AuthPlugin = AuthPlugin;
+exports.CronJobPlugin = CronJobPlugin;
 exports.DataManagePlugin = DataManager;
 exports.EntityAccessControlPlugin = EntityAccessControlPlugin;
 exports.EntityWatchPlugin = EntityWatchPlugin;

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

@@ -0,0 +1,27 @@
+import type { RpdApplicationConfig } from "../../types";
+import { CronJobConfiguration, CronJobPluginInitOptions } from "./CronJobPluginTypes";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "../../core/server";
+declare class CronJobPlugin implements RapidPlugin {
+    #private;
+    constructor(options: CronJobPluginInitOptions);
+    get code(): string;
+    get description(): string;
+    get extendingAbilities(): RpdServerPluginExtendingAbilities[];
+    get configurableTargets(): RpdServerPluginConfigurableTargetOptions[];
+    get configurations(): RpdConfigurationItemOptions[];
+    initPlugin(server: IRpdServer): Promise<any>;
+    registerMiddlewares(server: IRpdServer): Promise<any>;
+    registerActionHandlers(server: IRpdServer): Promise<any>;
+    registerEventHandlers(server: IRpdServer): Promise<any>;
+    registerMessageHandlers(server: IRpdServer): Promise<any>;
+    registerTaskProcessors(server: IRpdServer): Promise<any>;
+    onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureModelProperties(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;
+    executeJob(server: IRpdServer, job: CronJobConfiguration): Promise<void>;
+}
+export default CronJobPlugin;

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

@@ -0,0 +1,39 @@
+import { ActionHandlerContext } from "../../core/actionHandler";
+export interface CronJobConfiguration {
+    /**
+     * 定时任务编号
+     */
+    code: string;
+    /**
+     * 定时任务描述
+     */
+    description?: string;
+    /**
+     * crontab 表达式
+     */
+    cronTime: string;
+    /**
+     * 任务处理程序编号。当指定处理程序编号时，忽略 handler 配置。
+     */
+    actionHandlerCode?: string;
+    /**
+     * 定时任务处理程序
+     * @param ctx
+     * @param options
+     * @returns
+     */
+    handler?: (ctx: ActionHandlerContext, options: any) => Promise<void>;
+    /**
+     * 处理定时任务时的设置选项
+     */
+    handleOptions?: any;
+}
+export interface CronJobPluginInitOptions {
+    jobs: CronJobConfiguration[];
+}
+export type RunCronJobActionHandlerOptions = {
+    code?: string;
+};
+export type RunCronJobInput = {
+    code?: string;
+};

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

@@ -0,0 +1,3 @@
+import * as runCronJob from "./runCronJob";
+declare const _default: (typeof runCronJob)[];
+export default _default;

package/dist/plugins/cronJob/actionHandlers/runCronJob.d.ts

@@ -0,0 +1,5 @@
+import { ActionHandlerContext } from "../../../core/actionHandler";
+import { RunCronJobActionHandlerOptions } from "../CronJobPluginTypes";
+import type CronJobPlugin from "../CronJobPlugin";
+export declare const code = "runCronJob";
+export declare function handler(plugin: CronJobPlugin, ctx: ActionHandlerContext, options: RunCronJobActionHandlerOptions): Promise<void>;

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

@@ -0,0 +1,12 @@
+declare const _default: {
+    namespace: string;
+    name: string;
+    code: string;
+    type: "RESTful";
+    method: "POST";
+    endpoint: string;
+    actions: {
+        code: string;
+    }[];
+}[];
+export default _default;

package/dist/plugins/cronJob/routes/runCronJob.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    namespace: string;
+    name: string;
+    code: string;
+    type: "RESTful";
+    method: "POST";
+    endpoint: string;
+    actions: {
+        code: string;
+    }[];
+};
+export default _default;

package/dist/plugins/sequence/SequenceService.d.ts

@@ -1,5 +1,5 @@
 import { IRpdServer } from "../../core/server";
-import { SequenceSegmentConfig } from "../../types";
+import { SequenceSegmentConfig } from "./SequencePluginTypes";
 export interface GenerateSequenceNumbersInput {
     ruleCode: string;
     parameters: Record<string, string>;

package/dist/plugins/sequence/segments/autoIncrement.d.ts

@@ -1,5 +1,5 @@
-import { SequenceAutoIncrementSegmentConfig } from "../../../types";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
+import { SequenceAutoIncrementSegmentConfig } from "../SequencePluginTypes";
 export declare const segmentType = "autoIncrement";
 export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceAutoIncrementSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/dayOfMonth.d.ts

@@ -1,4 +1,4 @@
-import { SequenceDayOfMonthSegmentConfig } from "../../../types";
+import { SequenceDayOfMonthSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "dayOfMonth";

package/dist/plugins/sequence/segments/literal.d.ts

@@ -1,4 +1,4 @@
-import { SequenceLiteralSegmentConfig } from "../../../types";
+import { SequenceLiteralSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "literal";

package/dist/plugins/sequence/segments/month.d.ts

@@ -1,4 +1,4 @@
-import { SequenceMonthSegmentConfig } from "../../../types";
+import { SequenceMonthSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "month";

package/dist/plugins/sequence/segments/parameter.d.ts

@@ -1,4 +1,4 @@
-import { SequenceParameterSegmentConfig } from "../../../types";
+import { SequenceParameterSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "parameter";

package/dist/plugins/sequence/segments/year.d.ts

@@ -1,4 +1,4 @@
-import { SequenceYearSegmentConfig } from "../../../types";
+import { SequenceYearSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "../../../core/server";
 export declare const segmentType = "year";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.1.31",
+  "version": "0.1.32",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -19,6 +19,7 @@
   },
   "dependencies": {
     "bcrypt": "^5.1.1",
+    "cron": "^3.1.7",
     "dayjs": "^1.11.7",
     "jsonwebtoken": "^9.0.2",
     "koa-tree-router": "^0.12.1",

package/src/index.ts

@@ -32,6 +32,9 @@ export { default as FileManagePlugin } from "./plugins/fileManage/FileManagePlug
 export { default as ServerOperationPlugin } from "./plugins/serverOperation/ServerOperationPlugin";
 export * from "./plugins/serverOperation/ServerOperationPluginTypes";
 
+export { default as CronJobPlugin } from "./plugins/cronJob/CronJobPlugin";
+export * from "./plugins/cronJob/CronJobPluginTypes";
+
 export { default as StateMachinePlugin } from "./plugins/stateMachine/StateMachinePlugin";
 export * from "./plugins/stateMachine/StateMachinePluginTypes";
 

package/src/plugins/cronJob/CronJobPlugin.ts

@@ -0,0 +1,113 @@
+import * as cron from 'cron';
+import type { RpdApplicationConfig } from "~/types";
+import pluginActionHandlers from "./actionHandlers";
+import pluginRoutes from "./routes";
+import { CronJobConfiguration, CronJobPluginInitOptions } from "./CronJobPluginTypes";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+import { ActionHandlerContext } from '~/core/actionHandler';
+import { find } from 'lodash';
+
+class CronJobPlugin implements RapidPlugin {
+  #jobs: CronJobConfiguration[];
+
+  constructor(options: CronJobPluginInitOptions) {
+    this.#jobs = options.jobs || [];
+  }
+
+  get code(): string {
+    return "cronJob";
+  }
+
+  get description(): string {
+    return "";
+  }
+
+  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
+    return [];
+  }
+
+  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
+    return [];
+  }
+
+  get configurations(): RpdConfigurationItemOptions[] {
+    return [];
+  }
+
+  async initPlugin(server: IRpdServer): Promise<any> {
+  }
+
+  async registerMiddlewares(server: IRpdServer): Promise<any> {
+  }
+
+  async registerActionHandlers(server: IRpdServer): Promise<any> {
+    for (const actionHandler of pluginActionHandlers) {
+      server.registerActionHandler(this, actionHandler);
+    }
+  }
+
+  async registerEventHandlers(server: IRpdServer): Promise<any> {
+  }
+
+  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 configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+  }
+
+  async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    server.appendApplicationConfig({ routes: pluginRoutes });
+  }
+
+  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+  }
+
+  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    for (const job of this.#jobs) {
+      const jobInstance = cron.CronJob.from({
+        cronTime: job.cronTime,
+        onTick: async () => {
+          await this.executeJob(server, job);
+        },
+      });
+    }
+  }
+
+  getJobConfigurationByCode(code: string) {
+    return find(this.#jobs, (job) => job.code === code);
+  }
+
+  async executeJob(server: IRpdServer, job: CronJobConfiguration) {
+    const logger = server.getLogger();
+    try {
+      let handlerContext: ActionHandlerContext = {
+        logger,
+        routerContext: null,
+        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);
+      }
+    } catch (ex) {
+      logger.error("Cron job execution error: " + ex.message);
+    }
+  }
+}
+
+export default CronJobPlugin;

package/src/plugins/cronJob/CronJobPluginTypes.ts

@@ -0,0 +1,49 @@
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RpdHttpMethod } from "~/types";
+
+export interface CronJobConfiguration {
+  /**
+   * 定时任务编号
+   */
+  code: string;
+
+  /**
+   * 定时任务描述
+   */
+  description?: string;
+  
+  /**
+   * crontab 表达式
+   */
+  cronTime: string;
+  
+  /**
+   * 任务处理程序编号。当指定处理程序编号时，忽略 handler 配置。
+   */
+  actionHandlerCode?: string;
+  
+  /**
+   * 定时任务处理程序
+   * @param ctx 
+   * @param options 
+   * @returns 
+   */
+  handler?: (ctx: ActionHandlerContext, options: any) => Promise<void>;
+  
+  /**
+   * 处理定时任务时的设置选项
+   */
+  handleOptions?: any;
+}
+
+export interface CronJobPluginInitOptions {
+  jobs: CronJobConfiguration[];
+}
+
+export type RunCronJobActionHandlerOptions = {
+  code?: string;
+}
+
+export type RunCronJobInput = {
+  code?: string;
+}

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

@@ -0,0 +1,6 @@
+import { IPluginActionHandler } from "~/core/actionHandler";
+import * as runCronJob from "./runCronJob";
+
+export default [
+  runCronJob,
+] satisfies IPluginActionHandler[];

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

@@ -0,0 +1,34 @@
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RunCronJobActionHandlerOptions, RunCronJobInput } from "../CronJobPluginTypes";
+import type CronJobPlugin from "../CronJobPlugin";
+
+export const code = "runCronJob";
+
+export async function handler(
+  plugin: CronJobPlugin,
+  ctx: ActionHandlerContext,
+  options: RunCronJobActionHandlerOptions,
+) {
+  const { server, routerContext } = ctx;
+  const { response } = routerContext;
+  
+  const input: RunCronJobInput = ctx.input;
+
+  if (options.code) {
+    input.code = options.code;
+  }
+
+  if (!input.code) {
+    throw new Error(`Cron job code is required.`);
+  }
+
+  const job = plugin.getJobConfigurationByCode(input.code);
+  if (!job) {
+    throw new Error(`Cron job with code '${input.code}' was not found.`);
+  }
+
+  await plugin.executeJob(server, job);
+
+  response.json({
+  });
+}

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

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

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

@@ -0,0 +1,15 @@
+import { RpdRoute } from "~/types";
+
+export default {
+  namespace: "svc",
+  name: "svc.runCronJob",
+  code: "svc.runCronJob",
+  type: "RESTful",
+  method: "POST",
+  endpoint: "/svc/runCronJob",
+  actions: [
+    {
+      code: "runCronJob",
+    },
+  ],
+} satisfies RpdRoute;

package/src/plugins/sequence/SequenceService.ts

@@ -1,8 +1,7 @@
 import { IRpdServer } from "~/core/server";
-import { SequenceSegmentConfig } from "~/types";
 import segmentResolvers from "./segments";
 import { find } from "lodash";
-import { SequenceRuleConfig } from "./SequencePluginTypes";
+import { SequenceRuleConfig, SequenceSegmentConfig } from "./SequencePluginTypes";
 
 export interface GenerateSequenceNumbersInput {
   ruleCode: string;

package/src/plugins/sequence/segments/autoIncrement.ts

@@ -1,9 +1,9 @@
-import { SequenceAutoIncrementSegmentConfig } from "~/types";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
 import { IRpdServer } from "~/core/server";
 import { get } from "lodash";
 import dayjs from "dayjs";
+import { SequenceAutoIncrementSegmentConfig } from "../SequencePluginTypes";
 
 export const segmentType = "autoIncrement";
 

package/src/plugins/sequence/segments/dayOfMonth.ts

@@ -1,4 +1,4 @@
-import { SequenceDayOfMonthSegmentConfig } from "~/types";
+import { SequenceDayOfMonthSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
 import { IRpdServer } from "~/core/server";

package/src/plugins/sequence/segments/literal.ts

@@ -1,4 +1,4 @@
-import { SequenceLiteralSegmentConfig } from "~/types";
+import { SequenceLiteralSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "~/core/server";
 

package/src/plugins/sequence/segments/month.ts

@@ -1,4 +1,4 @@
-import { SequenceMonthSegmentConfig } from "~/types";
+import { SequenceMonthSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
 import { IRpdServer } from "~/core/server";

package/src/plugins/sequence/segments/parameter.ts

@@ -1,4 +1,4 @@
-import { SequenceParameterSegmentConfig } from "~/types";
+import { SequenceParameterSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
 import { get } from "lodash";

package/src/plugins/sequence/segments/year.ts

@@ -1,4 +1,4 @@
-import { SequenceYearSegmentConfig } from "~/types";
+import { SequenceYearSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
 import { IRpdServer } from "~/core/server";