@ruiapp/rapid-core 0.10.3 → 0.10.5

package/dist/core/ExpressionInterpreter.d.ts

@@ -0,0 +1,2 @@
+export declare function interpreteExpression(expressionString: string, rootVars: Record<string, any>): any;
+export declare function interpreteConfigExpressions(config: Record<string, any>, vars: Record<string, any>): void;

package/dist/core/actionHandler.d.ts

@@ -1,15 +1,15 @@
-import { RpdApplicationConfig } from "../types";
 import { IRpdServer, RapidPlugin } from "./server";
 import { Next, RouteContext } from "./routeContext";
 import { Logger } from "../facilities/log/LogFacility";
 export interface ActionHandlerContext {
     logger: Logger;
     routerContext: RouteContext;
-    next: Next;
+    next?: Next;
     server: IRpdServer;
-    applicationConfig: RpdApplicationConfig;
+    vars?: Record<string, any>;
     input?: any;
     output?: any;
+    results: any[];
     status?: Response["status"];
 }
 export type ActionHandler = (ctx: ActionHandlerContext, options: any) => void | Promise<void>;

package/dist/core/server.d.ts

@@ -31,6 +31,7 @@ export interface IRpdServer {
     registerEntityWatcher(entityWatcher: EntityWatcherType): any;
     emitEvent<TEventName extends keyof RpdServerEventTypes>(event: EmitServerEventOptions<TEventName>): void;
     handleRequest(request: RapidRequest, next: Next): Promise<Response>;
+    runActionHandlers(handlerContext: ActionHandlerContext, actions: RpdRouteActionConfig[]): Promise<void>;
     beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;
     beforeRunActionHandler(handlerContext: ActionHandlerContext, actionConfig: RpdRouteActionConfig): Promise<void>;
     beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions): Promise<void>;

package/dist/index.js

@@ -1028,8 +1028,8 @@ async function buildRoutes(server, applicationConfig) {
                 routerContext,
                 next,
                 server,
-                applicationConfig,
                 input,
+                results: [],
             };
             await server.beforeRunRouteActions(handlerContext);
             let handler = routeConfig.handler;
@@ -1582,6 +1582,13 @@ var bootstrapApplicationConfig = {
                     type: "text",
                     required: false,
                 },
+                {
+                    name: "target type column name",
+                    code: "targetTypeColumnName",
+                    columnName: "target_type_column_name",
+                    type: "text",
+                    required: false,
+                },
                 {
                     name: "target id column name",
                     code: "targetIdColumnName",
@@ -4110,14 +4117,51 @@ var healthz = {
     type: "RESTful",
     method: "GET",
     endpoint: "/healthz",
-    handler: handler$x,
+    handler: handler$y,
 };
-async function handler$x(ctx) {
+async function handler$y(ctx) {
     ctx.output = {};
 }
 
 var coreRoutes = [healthz];
 
+const genExpression = lodash.memoize((varNames, expressionString) => {
+    // eslint-disable-next-line no-new-func
+    return new Function(...varNames, `return (${expressionString})`);
+}, (varNames, expressionString) => {
+    return varNames.join(",") + ":" + expressionString;
+});
+function interpreteExpression(expressionString, rootVars) {
+    const varNames = [];
+    const varValues = [];
+    for (const name in rootVars) {
+        varNames.push(name);
+        varValues.push(rootVars[name]);
+    }
+    let result;
+    try {
+        const expression = genExpression(varNames, expressionString);
+        result = expression(...varValues);
+    }
+    catch (err) {
+        console.error(`Expression interprete error. expression: '${expressionString}', error:`, err.message);
+    }
+    return result;
+}
+function interpreteConfigExpressions(config, vars) {
+    if (!config) {
+        return;
+    }
+    const propExpressions = config.$exps;
+    if (!propExpressions) {
+        return;
+    }
+    for (const propName in propExpressions) {
+        const propValue = interpreteExpression(propExpressions[propName], vars);
+        lodash.set(config, propName, propValue);
+    }
+}
+
 class RapidServer {
     #logger;
     #facilityFactories;
@@ -4484,6 +4528,22 @@ class RapidServer {
         }
         return response.getResponse();
     }
+    async runActionHandlers(handlerContext, actions) {
+        if (!actions) {
+            return;
+        }
+        for (const action of actions) {
+            const actionCode = action.code;
+            interpreteConfigExpressions(action.config, handlerContext.vars);
+            const handler = this.getActionHandlerByCode(actionCode);
+            if (!handler) {
+                throw new Error("Unknown handler: " + actionCode);
+            }
+            await this.beforeRunActionHandler(handlerContext, action);
+            const result = await handler(handlerContext, action.config);
+            handlerContext.results.push(result);
+        }
+    }
     async beforeRunRouteActions(handlerContext) {
         await this.#pluginManager.beforeRunRouteActions(handlerContext);
     }
@@ -4996,7 +5056,7 @@ class RapidRequest {
         else if (contentType.startsWith("multipart/form-data")) {
             this.#body = {
                 type: "form-data",
-                value: await parseFormDataBody(req),
+                value: await parseFormDataBody(req, { all: true }),
             };
         }
         this.#bodyParsed = true;
@@ -5491,32 +5551,34 @@ class CacheFactory {
     }
 }
 
-const code$w = "listMetaModels";
-async function handler$w(plugin, ctx, options) {
-    const { applicationConfig } = ctx;
+const code$x = "listMetaModels";
+async function handler$x(plugin, ctx, options) {
+    const { server } = ctx;
+    const applicationConfig = server.getApplicationConfig();
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$w,
-  handler: handler$w
+  code: code$x,
+  handler: handler$x
 });
 
-const code$v = "listMetaRoutes";
-async function handler$v(plugin, ctx, options) {
-    const { applicationConfig } = ctx;
+const code$w = "listMetaRoutes";
+async function handler$w(plugin, ctx, options) {
+    const { server } = ctx;
+    const applicationConfig = server.getApplicationConfig();
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$v,
-  handler: handler$v
+  code: code$w,
+  handler: handler$w
 });
 
-const code$u = "getMetaModelDetail";
-async function handler$u(plugin, ctx, options) {
+const code$v = "getMetaModelDetail";
+async function handler$v(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -5524,8 +5586,8 @@ async function handler$u(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$u,
-  handler: handler$u
+  code: code$v,
+  handler: handler$v
 });
 
 function removeFiltersWithNullValue(filters) {
@@ -6114,9 +6176,9 @@ async function runCollectionEntityActionHandler(ctx, options, code, autoMergeInp
     }
 }
 
-const code$t = "findCollectionEntities";
-async function handler$t(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$t, true, false, async (entityManager, input) => {
+const code$u = "findCollectionEntities";
+async function handler$u(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$u, true, false, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = routeContext;
@@ -6133,13 +6195,13 @@ async function handler$t(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$t,
-  handler: handler$t
+  code: code$u,
+  handler: handler$u
 });
 
-const code$s = "findCollectionEntityById";
-async function handler$s(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$s, true, true, async (entityManager, input) => {
+const code$t = "findCollectionEntityById";
+async function handler$t(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$t, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const { id } = input;
         const entity = await entityManager.findById({
@@ -6161,13 +6223,13 @@ async function handler$s(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$s,
-  handler: handler$s
+  code: code$t,
+  handler: handler$t
 });
 
-const code$r = "countCollectionEntities";
-async function handler$r(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$r, true, false, async (entityManager, input) => {
+const code$s = "countCollectionEntities";
+async function handler$s(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$s, true, false, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         input.filters = removeFiltersWithNullValue(input.filters);
         input.routeContext = routeContext;
@@ -6178,13 +6240,13 @@ async function handler$r(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$r,
-  handler: handler$r
+  code: code$s,
+  handler: handler$s
 });
 
-const code$q = "createCollectionEntity";
-async function handler$q(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$q, true, true, async (entityManager, input) => {
+const code$r = "createCollectionEntity";
+async function handler$r(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$r, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const output = await entityManager.createEntity({
             entity: input,
@@ -6196,16 +6258,16 @@ async function handler$q(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$q,
-  handler: handler$q
+  code: code$r,
+  handler: handler$r
 });
 
-const code$p = "createCollectionEntitiesBatch";
-async function handler$p(plugin, ctx, options) {
+const code$q = "createCollectionEntitiesBatch";
+async function handler$q(plugin, ctx, options) {
     const { input } = ctx;
     const { noTransaction } = input;
     const { defaultInput, fixedInput } = options;
-    await runCollectionEntityActionHandler(ctx, options, code$p, false, !noTransaction, async (entityManager, input) => {
+    await runCollectionEntityActionHandler(ctx, options, code$q, false, !noTransaction, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const { entities } = input;
         if (!lodash.isArray(entities)) {
@@ -6243,13 +6305,13 @@ async function createEntities(options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$p,
-  handler: handler$p
+  code: code$q,
+  handler: handler$q
 });
 
-const code$o = "updateCollectionEntityById";
-async function handler$o(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$o, true, true, async (entityManager, input) => {
+const code$p = "updateCollectionEntityById";
+async function handler$p(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$p, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const operation = input.$operation;
         if (operation) {
@@ -6278,15 +6340,15 @@ async function handler$o(plugin, ctx, options) {
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$o,
-  handler: handler$o
+  code: code$p,
+  handler: handler$p
 });
 
-const code$n = "deleteCollectionEntities";
-async function handler$n(plugin, ctx, options) {
+const code$o = "deleteCollectionEntities";
+async function handler$o(plugin, ctx, options) {
     const { input } = ctx;
     const { noTransaction } = input;
-    await runCollectionEntityActionHandler(ctx, options, code$n, true, !noTransaction, async (entityManager, input) => {
+    await runCollectionEntityActionHandler(ctx, options, code$o, true, !noTransaction, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         const { filters } = input;
         if (!filters || !filters.length) {
@@ -6308,13 +6370,13 @@ async function handler$n(plugin, ctx, options) {
 
 var deleteCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$n,
-  handler: handler$n
+  code: code$o,
+  handler: handler$o
 });
 
-const code$m = "deleteCollectionEntityById";
-async function handler$m(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$m, true, true, async (entityManager, input) => {
+const code$n = "deleteCollectionEntityById";
+async function handler$n(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$n, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         await entityManager.deleteById({
             id: input.id,
@@ -6326,13 +6388,13 @@ async function handler$m(plugin, ctx, options) {
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$m,
-  handler: handler$m
+  code: code$n,
+  handler: handler$n
 });
 
-const code$l = "addEntityRelations";
-async function handler$l(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$l, true, true, async (entityManager, input) => {
+const code$m = "addEntityRelations";
+async function handler$m(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$m, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         input.routeContext = routeContext;
         await entityManager.addRelations(input, plugin);
@@ -6342,13 +6404,13 @@ async function handler$l(plugin, ctx, options) {
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$l,
-  handler: handler$l
+  code: code$m,
+  handler: handler$m
 });
 
-const code$k = "removeEntityRelations";
-async function handler$k(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$k, true, true, async (entityManager, input) => {
+const code$l = "removeEntityRelations";
+async function handler$l(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$l, true, true, async (entityManager, input) => {
         const { routerContext: routeContext } = ctx;
         input.routeContext = routeContext;
         await entityManager.removeRelations(input, plugin);
@@ -6357,6 +6419,41 @@ async function handler$k(plugin, ctx, options) {
 }
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$l,
+  handler: handler$l
+});
+
+const code$k = "saveEntity";
+async function handler$k(plugin, ctx, options) {
+    const { server, routerContext: routeContext, vars } = ctx;
+    interpreteConfigExpressions(options, vars || {});
+    const input = options.entity;
+    const operation = input.$operation;
+    if (operation) {
+        delete input.$operation;
+    }
+    const stateProperties = input.$stateProperties;
+    if (stateProperties) {
+        delete input.$stateProperties;
+    }
+    const relationPropertiesToUpdate = input.$relationPropertiesToUpdate;
+    if (relationPropertiesToUpdate) {
+        delete input.$relationPropertiesToUpdate;
+    }
+    const entityManager = server.getEntityManager(options.singularCode);
+    const updateEntityByIdOptions = {
+        id: input.id,
+        entityToSave: input,
+        operation,
+        stateProperties,
+        relationPropertiesToUpdate,
+        routeContext,
+    };
+    ctx.output = await entityManager.updateEntityById(updateEntityByIdOptions, plugin);
+}
+
+var saveEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
   code: code$k,
   handler: handler$k
@@ -6477,6 +6574,7 @@ class DataManager {
         server.registerActionHandler(this, removeEntityRelations);
         server.registerActionHandler(this, deleteCollectionEntities);
         server.registerActionHandler(this, deleteCollectionEntityById);
+        server.registerActionHandler(this, saveEntity);
         server.registerActionHandler(this, queryDatabase);
     }
     async configureRoutes(server, applicationConfig) {
@@ -7672,7 +7770,7 @@ function getFileBaseName(pathname) {
 
 const code$a = "downloadDocument";
 async function handler$a(plugin, ctx, options) {
-    const { server, applicationConfig, routerContext: routeContext, input } = ctx;
+    const { server, routerContext: routeContext, input } = ctx;
     const { request, response } = routeContext;
     const documentDataAccessor = ctx.server.getDataAccessor({
         singularCode: "ecm_document",
@@ -7733,7 +7831,7 @@ var downloadDocumentActionHandler = /*#__PURE__*/Object.freeze({
 
 const code$9 = "downloadFile";
 async function handler$9(plugin, ctx, options) {
-    const { server, applicationConfig, routerContext: routeContext } = ctx;
+    const { server, routerContext: routeContext } = ctx;
     const { request, response } = routeContext;
     //TODO: only public files can download by this handler
     const input = ctx.input;
@@ -7764,7 +7862,7 @@ var downloadFileActionHandler = /*#__PURE__*/Object.freeze({
 
 const code$8 = "uploadFile";
 async function handler$8(plugin, ctx, options) {
-    const { server, applicationConfig, routerContext, input } = ctx;
+    const { server, routerContext, input } = ctx;
     let file = input.file || input.files;
     if (lodash.isArray(file)) {
         file = file[0];
@@ -9390,10 +9488,9 @@ class CronJobService {
         let handlerContext = {
             logger,
             routerContext: RouteContext.newSystemOperationContext(server),
-            next: null,
             server,
-            applicationConfig: null,
             input,
+            results: [],
         };
         let result;
         let lastErrorMessage;

package/dist/plugins/dataManage/actionHandlers/saveEntity.d.ts

@@ -0,0 +1,8 @@
+import { ActionHandlerContext } from "../../../core/actionHandler";
+import { RapidPlugin } from "../../../core/server";
+export declare const code = "saveEntity";
+export type SaveEntityActionHandlerOptions = {
+    singularCode: string;
+    entity?: Record<string, any>;
+};
+export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: SaveEntityActionHandlerOptions): Promise<void>;

package/dist/server.d.ts

@@ -57,6 +57,7 @@ export declare class RapidServer implements IRpdServer {
     tryQueryDatabaseObject(sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient, dropErrorLog?: boolean): Promise<any[]>;
     get middlewares(): any[];
     handleRequest(rapidRequest: RapidRequest, next: Next): Promise<Response>;
+    runActionHandlers(handlerContext: ActionHandlerContext, actions: RpdRouteActionConfig[]): Promise<void>;
     beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;
     beforeRunActionHandler(handlerContext: ActionHandlerContext, actionConfig: RpdRouteActionConfig): Promise<void>;
     beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions): Promise<void>;

package/dist/types.d.ts

@@ -29,6 +29,9 @@ export interface IDatabaseAccessor {
     getClient(): Promise<IDatabaseClient>;
     queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient) => Promise<any[]>;
 }
+export type RunActionHandlersOptions = {
+    actions: RpdRouteActionConfig[];
+};
 export interface RunEntityActionHandlerOptions {
     /** 模型所在的命名空间 */
     namespace: string;
@@ -315,6 +318,10 @@ export interface RpdDataModelProperty {
      * 关联实体的singular code，不管 relation 为 one 或者 many 都需要设置。
      */
     targetSingularCode?: string;
+    /**
+     * 保存关联实体类型的字段名。当设置 targetTypeColumnName 时，表示关联实体类型不固定，可以关联不同类型的实体。
+     */
+    targetTypeColumnName?: string;
     /**
      * 当 relation 为 one 时，设置当前模型表中表示关联实体 id 的列名。
      * 当 relation 为 many，并且使用关联关系表保存关联信息时，设置关联关系表中表示关联实体 id 的列名。

package/package.json

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

package/src/bootstrapApplicationConfig.ts

@@ -350,6 +350,13 @@ export default {
           type: "text",
           required: false,
         },
+        {
+          name: "target type column name",
+          code: "targetTypeColumnName",
+          columnName: "target_type_column_name",
+          type: "text",
+          required: false,
+        },
         {
           name: "target id column name",
           code: "targetIdColumnName",

package/src/core/ExpressionInterpreter.ts

@@ -0,0 +1,45 @@
+import { memoize, set } from "lodash";
+
+const genExpression = memoize(
+  (varNames: string[], expressionString: string) => {
+    // eslint-disable-next-line no-new-func
+    return new Function(...varNames, `return (${expressionString})`);
+  },
+  (varNames, expressionString) => {
+    return varNames.join(",") + ":" + expressionString;
+  },
+);
+
+export function interpreteExpression(expressionString: string, rootVars: Record<string, any>) {
+  const varNames = [];
+  const varValues = [];
+  for (const name in rootVars) {
+    varNames.push(name);
+    varValues.push(rootVars[name]);
+  }
+
+  let result;
+  try {
+    const expression = genExpression(varNames, expressionString);
+    result = expression(...varValues);
+  } catch (err: any) {
+    console.error(`Expression interprete error. expression: '${expressionString}', error:`, err.message);
+  }
+  return result;
+}
+
+export function interpreteConfigExpressions(config: Record<string, any>, vars: Record<string, any>) {
+  if (!config) {
+    return;
+  }
+
+  const propExpressions = config.$exps;
+  if (!propExpressions) {
+    return;
+  }
+
+  for (const propName in propExpressions) {
+    const propValue = interpreteExpression(propExpressions[propName], vars);
+    set(config, propName, propValue);
+  }
+}

package/src/core/actionHandler.ts

@@ -7,11 +7,12 @@ import { CronJobConfiguration } from "~/types/cron-job-types";
 export interface ActionHandlerContext {
   logger: Logger;
   routerContext: RouteContext;
-  next: Next;
+  next?: Next;
   server: IRpdServer;
-  applicationConfig: RpdApplicationConfig;
+  vars?: Record<string, any>;
   input?: any;
   output?: any;
+  results: any[];
   status?: Response["status"];
 }
 

package/src/core/http/formDataParser.ts

@@ -1,5 +1,3 @@
-import type { RapidRequest } from "../request";
-
 export type BodyData = Record<string, string | File | (string | File)[]>;
 export type ParseBodyOptions = {
   /**

package/src/core/request.ts

@@ -66,7 +66,7 @@ export class RapidRequest {
     } else if (contentType.startsWith("multipart/form-data")) {
       this.#body = {
         type: "form-data",
-        value: await parseFormDataBody(req),
+        value: await parseFormDataBody(req, { all: true }),
       };
     }
     this.#bodyParsed = true;

package/src/core/routesBuilder.ts

@@ -61,8 +61,8 @@ export async function buildRoutes(server: IRpdServer, applicationConfig: RpdAppl
         routerContext,
         next,
         server,
-        applicationConfig,
         input,
+        results: [],
       };
 
       await server.beforeRunRouteActions(handlerContext);

package/src/core/server.ts

@@ -15,6 +15,7 @@ import {
   RpdDataModelProperty,
   RpdRouteActionConfig,
   RpdServerEventTypes,
+  RunActionHandlersOptions,
   UpdateEntityByIdOptions,
 } from "~/types";
 import { IPluginActionHandler, ActionHandler, ActionHandlerContext } from "./actionHandler";
@@ -53,6 +54,7 @@ export interface IRpdServer {
   registerEntityWatcher(entityWatcher: EntityWatcherType);
   emitEvent<TEventName extends keyof RpdServerEventTypes>(event: EmitServerEventOptions<TEventName>): void;
   handleRequest(request: RapidRequest, next: Next): Promise<Response>;
+  runActionHandlers(handlerContext: ActionHandlerContext, actions: RpdRouteActionConfig[]): Promise<void>;
   beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;
   beforeRunActionHandler(handlerContext: ActionHandlerContext, actionConfig: RpdRouteActionConfig): Promise<void>;
   beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions): Promise<void>;

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

@@ -133,10 +133,9 @@ export default class CronJobService {
     let handlerContext: ActionHandlerContext = {
       logger,
       routerContext: RouteContext.newSystemOperationContext(server),
-      next: null,
       server,
-      applicationConfig: null,
       input,
+      results: [],
     };
 
     let result: JobRunningResult;

package/src/plugins/dataManage/DataManagePlugin.ts

@@ -16,6 +16,7 @@ import * as deleteCollectionEntities from "./actionHandlers/deleteCollectionEnti
 import * as deleteCollectionEntityById from "./actionHandlers/deleteCollectionEntityById";
 import * as addEntityRelations from "./actionHandlers/addEntityRelations";
 import * as removeEntityRelations from "./actionHandlers/removeEntityRelations";
+import * as saveEntity from "./actionHandlers/saveEntity";
 import * as queryDatabase from "./actionHandlers/queryDatabase";
 import {
   RpdServerPluginExtendingAbilities,
@@ -125,6 +126,7 @@ class DataManager implements RapidPlugin {
     server.registerActionHandler(this, removeEntityRelations);
     server.registerActionHandler(this, deleteCollectionEntities);
     server.registerActionHandler(this, deleteCollectionEntityById);
+    server.registerActionHandler(this, saveEntity);
     server.registerActionHandler(this, queryDatabase);
   }
 

package/src/plugins/dataManage/actionHandlers/saveEntity.ts

@@ -0,0 +1,46 @@
+import { RunEntityActionHandlerOptions, UpdateEntityByIdOptions } from "~/types";
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+import runCollectionEntityActionHandler from "~/helpers/runCollectionEntityActionHandler";
+import { interpreteConfigExpressions } from "~/core/ExpressionInterpreter";
+
+export const code = "saveEntity";
+
+export type SaveEntityActionHandlerOptions = {
+  singularCode: string;
+  entity?: Record<string, any>;
+};
+
+export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: SaveEntityActionHandlerOptions) {
+  const { server, routerContext: routeContext, vars } = ctx;
+
+  interpreteConfigExpressions(options, vars || {});
+
+  const input = options.entity;
+
+  const operation = input.$operation;
+  if (operation) {
+    delete input.$operation;
+  }
+
+  const stateProperties = input.$stateProperties;
+  if (stateProperties) {
+    delete input.$stateProperties;
+  }
+
+  const relationPropertiesToUpdate = input.$relationPropertiesToUpdate;
+  if (relationPropertiesToUpdate) {
+    delete input.$relationPropertiesToUpdate;
+  }
+
+  const entityManager = server.getEntityManager(options.singularCode);
+  const updateEntityByIdOptions: UpdateEntityByIdOptions = {
+    id: input.id,
+    entityToSave: input,
+    operation,
+    stateProperties,
+    relationPropertiesToUpdate,
+    routeContext,
+  };
+  ctx.output = await entityManager.updateEntityById(updateEntityByIdOptions, plugin);
+}

package/src/plugins/fileManage/actionHandlers/downloadDocument.ts

@@ -7,7 +7,7 @@ import { getFileBaseName } from "~/utilities/pathUtility";
 export const code = "downloadDocument";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) {
-  const { server, applicationConfig, routerContext: routeContext, input } = ctx;
+  const { server, routerContext: routeContext, input } = ctx;
   const { request, response } = routeContext;
 
   const documentDataAccessor = ctx.server.getDataAccessor({

package/src/plugins/fileManage/actionHandlers/downloadFile.ts

@@ -13,7 +13,7 @@ export type DownloadFileInput = {
 export const code = "downloadFile";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) {
-  const { server, applicationConfig, routerContext: routeContext } = ctx;
+  const { server, routerContext: routeContext } = ctx;
   const { request, response } = routeContext;
   //TODO: only public files can download by this handler
 

package/src/plugins/fileManage/actionHandlers/uploadFile.ts

@@ -8,7 +8,7 @@ import { RapidPlugin } from "~/core/server";
 export const code = "uploadFile";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) {
-  const { server, applicationConfig, routerContext, input } = ctx;
+  const { server, routerContext, input } = ctx;
   const { request, response } = routerContext;
 
   let file: File | File[] | null = input.file || input.files;

package/src/plugins/metaManage/actionHandlers/listMetaModels.ts

@@ -4,6 +4,7 @@ import { RapidPlugin } from "~/core/server";
 export const code = "listMetaModels";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) {
-  const { applicationConfig } = ctx;
+  const { server } = ctx;
+  const applicationConfig = server.getApplicationConfig();
   ctx.output = { list: applicationConfig.models };
 }

package/src/plugins/metaManage/actionHandlers/listMetaRoutes.ts

@@ -4,6 +4,7 @@ import { RapidPlugin } from "~/core/server";
 export const code = "listMetaRoutes";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) {
-  const { applicationConfig } = ctx;
+  const { server } = ctx;
+  const applicationConfig = server.getApplicationConfig();
   ctx.output = { list: applicationConfig.routes };
 }

package/src/server.ts

@@ -19,6 +19,7 @@ import {
   EmitServerEventOptions,
   IDatabaseClient,
   RpdRouteActionConfig,
+  RunActionHandlersOptions,
 } from "./types";
 
 import QueryBuilder from "./queryBuilder/queryBuilder";
@@ -36,6 +37,7 @@ import { Logger } from "./facilities/log/LogFacility";
 import { FacilityFactory } from "./core/facility";
 import { CronJobConfiguration } from "./types/cron-job-types";
 import coreRoutes from "./core/routes";
+import { interpreteConfigExpressions } from "./core/ExpressionInterpreter";
 
 export interface InitServerOptions {
   logger: Logger;
@@ -474,6 +476,26 @@ export class RapidServer implements IRpdServer {
     return response.getResponse();
   }
 
+  async runActionHandlers(handlerContext: ActionHandlerContext, actions: RpdRouteActionConfig[]) {
+    if (!actions) {
+      return;
+    }
+    for (const action of actions) {
+      const actionCode = action.code;
+      interpreteConfigExpressions(action.config, handlerContext.vars);
+
+      const handler = this.getActionHandlerByCode(actionCode);
+      if (!handler) {
+        throw new Error("Unknown handler: " + actionCode);
+      }
+
+      await this.beforeRunActionHandler(handlerContext, action);
+
+      const result = await handler(handlerContext, action.config);
+      handlerContext.results.push(result);
+    }
+  }
+
   async beforeRunRouteActions(handlerContext: ActionHandlerContext) {
     await this.#pluginManager.beforeRunRouteActions(handlerContext);
   }

package/src/types.ts

@@ -35,6 +35,10 @@ export interface IDatabaseAccessor {
   queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient) => Promise<any[]>;
 }
 
+export type RunActionHandlersOptions = {
+  actions: RpdRouteActionConfig[];
+};
+
 export interface RunEntityActionHandlerOptions {
   /** 模型所在的命名空间 */
   namespace: string;
@@ -359,6 +363,10 @@ export interface RpdDataModelProperty {
    * 关联实体的singular code，不管 relation 为 one 或者 many 都需要设置。
    */
   targetSingularCode?: string;
+  /**
+   * 保存关联实体类型的字段名。当设置 targetTypeColumnName 时，表示关联实体类型不固定，可以关联不同类型的实体。
+   */
+  targetTypeColumnName?: string;
   /**
    * 当 relation 为 one 时，设置当前模型表中表示关联实体 id 的列名。
    * 当 relation 为 many，并且使用关联关系表保存关联信息时，设置关联关系表中表示关联实体 id 的列名。