@ruiapp/rapid-core 0.10.4 → 0.10.6

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;
@@ -2600,8 +2600,8 @@ async function findEntities(server, dataAccessor, options) {
             }
         }
     });
-    // if `keepNonPropertyFields` is true and `properties` are not specified, then select relation columns automatically.
-    if (options.keepNonPropertyFields && (!options.properties || !options.properties.length)) {
+    // if `keepNonPropertyFields` is true, then select relation columns automatically.
+    if (options.keepNonPropertyFields) {
         const oneRelationPropertiesWithNoLinkTable = getEntityPropertiesIncludingBase(server, model).filter((property) => property.relation === "one" && !property.linkTableName);
         oneRelationPropertiesWithNoLinkTable.forEach((property) => {
             if (property.targetIdColumnName) {
@@ -2675,12 +2675,12 @@ async function findEntities(server, dataAccessor, options) {
                                 return lodash.find(relationLinks, (link) => {
                                     return link[relationProperty.selfIdColumnName] == row["id"] && link[relationProperty.targetIdColumnName] == targetEntity["id"];
                                 });
-                            }).map((targetEntity) => mapDbRowToEntity(server, relationModel, targetEntity, options.keepNonPropertyFields));
+                            });
                         }
                         else {
                             row[relationProperty.code] = lodash.filter(relationLinks, (link) => {
                                 return link[relationProperty.selfIdColumnName] == row["id"];
-                            }).map((link) => mapDbRowToEntity(server, relationModel, link.targetEntity, options.keepNonPropertyFields));
+                            }).map((link) => link.targetEntity);
                         }
                     });
                 }
@@ -2708,20 +2708,20 @@ async function findEntities(server, dataAccessor, options) {
                         selectRelationOptions: relationOptions[relationProperty.code],
                     });
                 }
-                const targetModel = server.getModel({
+                server.getModel({
                     singularCode: relationProperty.targetSingularCode,
                 });
                 rows.forEach((row) => {
                     if (isManyRelation) {
                         row[relationProperty.code] = lodash.filter(relatedEntities, (relatedEntity) => {
                             return relatedEntity[relationProperty.selfIdColumnName] == row.id;
-                        }).map((item) => mapDbRowToEntity(server, targetModel, item, options.keepNonPropertyFields));
+                        });
                     }
                     else {
-                        row[relationProperty.code] = mapDbRowToEntity(server, targetModel, lodash.find(relatedEntities, (relatedEntity) => {
+                        row[relationProperty.code] = lodash.find(relatedEntities, (relatedEntity) => {
                             // TODO: id property code should be configurable.
                             return relatedEntity["id"] == row[relationProperty.targetIdColumnName];
-                        }), options.keepNonPropertyFields);
+                        });
                     }
                 });
             }
@@ -4117,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;
@@ -4491,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);
     }
@@ -5498,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;
@@ -5531,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) {
@@ -6121,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;
@@ -6140,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({
@@ -6168,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;
@@ -6185,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,
@@ -6203,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)) {
@@ -6250,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) {
@@ -6285,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) {
@@ -6315,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,
@@ -6333,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);
@@ -6349,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);
@@ -6364,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
@@ -6484,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) {
@@ -7679,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",
@@ -7740,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;
@@ -7771,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];
@@ -9397,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;

package/package.json

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

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/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/dataAccess/entityManager.ts

@@ -208,8 +208,8 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     }
   });
 
-  // if `keepNonPropertyFields` is true and `properties` are not specified, then select relation columns automatically.
-  if (options.keepNonPropertyFields && (!options.properties || !options.properties.length)) {
+  // if `keepNonPropertyFields` is true, then select relation columns automatically.
+  if (options.keepNonPropertyFields) {
     const oneRelationPropertiesWithNoLinkTable = getEntityPropertiesIncludingBase(server, model).filter(
       (property) => property.relation === "one" && !property.linkTableName,
     );
@@ -289,11 +289,11 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
                 return find(relationLinks, (link: any) => {
                   return link[relationProperty.selfIdColumnName!] == row["id"] && link[relationProperty.targetIdColumnName!] == targetEntity["id"];
                 });
-              }).map((targetEntity) => mapDbRowToEntity(server, relationModel, targetEntity, options.keepNonPropertyFields));
+              });
             } else {
               row[relationProperty.code] = filter(relationLinks, (link: any) => {
                 return link[relationProperty.selfIdColumnName!] == row["id"];
-              }).map((link) => mapDbRowToEntity(server, relationModel, link.targetEntity, options.keepNonPropertyFields));
+              }).map((link) => link.targetEntity);
             }
           });
         }
@@ -332,17 +332,12 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
           if (isManyRelation) {
             row[relationProperty.code] = filter(relatedEntities, (relatedEntity: any) => {
               return relatedEntity[relationProperty.selfIdColumnName!] == row.id;
-            }).map((item) => mapDbRowToEntity(server, targetModel!, item, options.keepNonPropertyFields));
+            });
           } else {
-            row[relationProperty.code] = mapDbRowToEntity(
-              server,
-              targetModel!,
-              find(relatedEntities, (relatedEntity: any) => {
-                // TODO: id property code should be configurable.
-                return relatedEntity["id"] == row[relationProperty.targetIdColumnName!];
-              }),
-              options.keepNonPropertyFields,
-            );
+            row[relationProperty.code] = find(relatedEntities, (relatedEntity: any) => {
+              // TODO: id property code should be configurable.
+              return relatedEntity["id"] == row[relationProperty.targetIdColumnName!];
+            });
           }
         });
       }

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;