@ruiapp/rapid-core 0.11.3 → 0.11.4

package/dist/index.js

@@ -983,8 +983,119 @@ function isNullOrUndefinedOrEmpty(val) {
     return isNull(val) || isUndefined(val) || val === "";
 }
 
-async function buildRoutes(server, applicationConfig) {
+/**
+ * 在事务中执行`func`
+ * @param routeContext
+ * @param func
+ * @returns
+ */
+async function executeInDbTransaction(routeContext, func) {
+    if (!routeContext) {
+        throw new Error(`Patameter "routeContext" is required if you want run in transaction.`);
+    }
+    let transactionDbClient;
+    try {
+        transactionDbClient = await routeContext.initDbTransactionClient();
+        await routeContext.beginDbTransaction();
+        const result = await func();
+        await routeContext.commitDbTransaction();
+        return result;
+    }
+    catch (ex) {
+        await routeContext.rollbackDbTransaction();
+        throw ex;
+    }
+    finally {
+        if (transactionDbClient) {
+            transactionDbClient.release();
+        }
+    }
+}
+async function executeInRouteContext(routeContext, inDbTransaction, func) {
+    if (inDbTransaction) {
+        return await executeInDbTransaction(routeContext, func);
+    }
+    else {
+        return await func();
+    }
+}
+
+async function executeHandlerOfActions(server, routeConfig, handlerContext) {
+    let handler = routeConfig.handler;
+    if (handler) {
+        if (lodash.isString(handler)) {
+            handler = new Function(`return (${routeConfig.handler})`);
+        }
+        if (lodash.isFunction(handler)) {
+            const result = handler(handlerContext);
+            if (result instanceof Promise) {
+                await result;
+            }
+        }
+        else {
+            throw new Error(`Invalid handler for route ${routeConfig.code}: ${routeConfig.handler}`);
+        }
+    }
+    else if (routeConfig.actions) {
+        for (const actionConfig of routeConfig.actions) {
+            const actionCode = actionConfig.code;
+            const handler = server.getActionHandlerByCode(actionCode);
+            if (!handler) {
+                throw new Error("Unknown handler: " + actionCode);
+            }
+            await server.beforeRunActionHandler(handlerContext, actionConfig);
+            const result = handler(handlerContext, actionConfig.config);
+            if (result instanceof Promise) {
+                await result;
+            }
+        }
+    }
+}
+async function handleRouteRequest(routeContext, next, server, routeConfig) {
+    if (!routeConfig.handler && !routeConfig.actions) {
+        throw new Error(`No handler or actions defined for route ${routeConfig.code}`);
+    }
     const logger = server.getLogger();
+    routeConfig = lodash.cloneDeep(routeConfig);
+    routeContext.routeConfig = routeConfig;
+    const { request, params } = routeContext;
+    let search = request.url.search;
+    if (search && search.startsWith("?")) {
+        search = search.substring(1);
+    }
+    const query = qs__default["default"].parse(search);
+    const input = Object.assign({}, params, query);
+    const requestMethod = request.method;
+    if (requestMethod === "POST" || requestMethod === "PUT" || requestMethod === "PATCH") {
+        const body = request.body;
+        if (body) {
+            Object.assign(input, body.value);
+        }
+    }
+    // Normalize input value
+    logger.debug("Processing rapid request.", {
+        method: requestMethod,
+        url: request.url.toString(),
+        input,
+    });
+    routeContext.response.status = 200;
+    let handlerContext = {
+        logger,
+        routerContext: routeContext,
+        next,
+        server,
+        input,
+        results: [],
+    };
+    await server.beforeRunRouteActions(handlerContext);
+    await executeInRouteContext(routeContext, routeConfig.executeInDbTransaction, async () => {
+        await executeHandlerOfActions(server, routeConfig, handlerContext);
+    });
+    if (!isNullOrUndefined(handlerContext.output)) {
+        routeContext.json(handlerContext.output, handlerContext.status);
+    }
+}
+async function buildRoutes(server, applicationConfig) {
     const router = new Router__default["default"]();
     let baseUrl = server.config.baseUrl;
     if (baseUrl) {
@@ -1000,74 +1111,7 @@ async function buildRoutes(server, applicationConfig) {
             return;
         }
         const routePath = baseUrl + routeConfig.endpoint;
-        router[routeConfig.method.toLowerCase()](routePath, async (routerContext, next) => {
-            routerContext.routeConfig = lodash.cloneDeep(routeConfig);
-            const { request, params } = routerContext;
-            let search = request.url.search;
-            if (search && search.startsWith("?")) {
-                search = search.substring(1);
-            }
-            const query = qs__default["default"].parse(search);
-            const input = Object.assign({}, params, query);
-            const requestMethod = request.method;
-            if (requestMethod === "POST" || requestMethod === "PUT" || requestMethod === "PATCH") {
-                const body = request.body;
-                if (body) {
-                    Object.assign(input, body.value);
-                }
-            }
-            // Normalize input value
-            logger.debug("Processing rapid request.", {
-                method: requestMethod,
-                url: request.url.toString(),
-                input,
-            });
-            routerContext.response.status = 200;
-            let handlerContext = {
-                logger,
-                routerContext,
-                next,
-                server,
-                input,
-                results: [],
-            };
-            await server.beforeRunRouteActions(handlerContext);
-            let handler = routeConfig.handler;
-            if (handler) {
-                if (lodash.isString(handler)) {
-                    handler = new Function(`return (${routeConfig.handler})`);
-                }
-                if (lodash.isFunction(handler)) {
-                    const result = handler(handlerContext);
-                    if (result instanceof Promise) {
-                        await result;
-                    }
-                }
-                else {
-                    throw new Error(`Invalid handler for route ${routeConfig.code}: ${routeConfig.handler}`);
-                }
-            }
-            else if (routeConfig.actions) {
-                for (const actionConfig of routeConfig.actions) {
-                    const actionCode = actionConfig.code;
-                    const handler = server.getActionHandlerByCode(actionCode);
-                    if (!handler) {
-                        throw new Error("Unknown handler: " + actionCode);
-                    }
-                    await server.beforeRunActionHandler(handlerContext, actionConfig);
-                    const result = handler(handlerContext, actionConfig.config);
-                    if (result instanceof Promise) {
-                        await result;
-                    }
-                }
-            }
-            else {
-                throw new Error(`No handler or actions defined for route ${routeConfig.code}`);
-            }
-            if (!isNullOrUndefined(handlerContext.output)) {
-                routerContext.json(handlerContext.output, handlerContext.status);
-            }
-        });
+        router[routeConfig.method.toLowerCase()](routePath, (routeContext, next) => handleRouteRequest(routeContext, next, server, routeConfig));
     });
     return router.routes();
 }
@@ -5511,43 +5555,6 @@ var licenseHelper = /*#__PURE__*/Object.freeze({
   tryValidateLicense: tryValidateLicense
 });
 
-/**
- * 在事务中执行`func`
- * @param routeContext
- * @param func
- * @returns
- */
-async function executeInDbTransaction(routeContext, func) {
-    if (!routeContext) {
-        throw new Error(`Patameter "routeContext" is required if you want run in transaction.`);
-    }
-    let transactionDbClient;
-    try {
-        transactionDbClient = await routeContext.initDbTransactionClient();
-        await routeContext.beginDbTransaction();
-        const result = await func();
-        await routeContext.commitDbTransaction();
-        return result;
-    }
-    catch (ex) {
-        await routeContext.rollbackDbTransaction();
-        throw ex;
-    }
-    finally {
-        if (transactionDbClient) {
-            transactionDbClient.release();
-        }
-    }
-}
-async function executeInRouteContext(routeContext, inDbTransaction, func) {
-    if (inDbTransaction) {
-        return await executeInDbTransaction(routeContext, func);
-    }
-    else {
-        return await func();
-    }
-}
-
 const values = new Map();
 async function set(key, value, options) {
     let expireAt = -1;

package/dist/types.d.ts

@@ -494,6 +494,7 @@ export interface RpdRoute {
     type: "RESTful";
     method: RpdHttpMethod;
     endpoint: string;
+    executeInDbTransaction?: boolean;
     actions?: RpdRouteActionConfig[];
     handler?: string | ((ctx: ActionHandlerContext) => Promise<void>);
 }

package/package.json

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

package/src/core/routesBuilder.ts

@@ -2,13 +2,101 @@ import Router from "koa-tree-router";
 import qs from "qs";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { IRpdServer } from "~/core/server";
-import { RpdApplicationConfig } from "~/types";
+import { RpdApplicationConfig, RpdRoute } from "~/types";
 import { isNullOrUndefined } from "~/utilities/typeUtility";
 import { Next, RouteContext } from "./routeContext";
 import { cloneDeep, isFunction, isString } from "lodash";
+import { executeInRouteContext } from "~/helpers/dbTransactionHelper";
+
+async function executeHandlerOfActions(server: IRpdServer, routeConfig: RpdRoute, handlerContext: ActionHandlerContext) {
+  let handler = routeConfig.handler as any;
+  if (handler) {
+    if (isString(handler)) {
+      handler = new Function(`return (${routeConfig.handler})`) as any;
+    }
+
+    if (isFunction(handler)) {
+      const result = handler(handlerContext);
+      if (result instanceof Promise) {
+        await result;
+      }
+    } else {
+      throw new Error(`Invalid handler for route ${routeConfig.code}: ${routeConfig.handler}`);
+    }
+  } else if (routeConfig.actions) {
+    for (const actionConfig of routeConfig.actions) {
+      const actionCode = actionConfig.code;
+      const handler = server.getActionHandlerByCode(actionCode);
+      if (!handler) {
+        throw new Error("Unknown handler: " + actionCode);
+      }
+
+      await server.beforeRunActionHandler(handlerContext, actionConfig);
+
+      const result = handler(handlerContext, actionConfig.config);
+      if (result instanceof Promise) {
+        await result;
+      }
+    }
+  }
+}
+
+async function handleRouteRequest(routeContext: RouteContext, next: Next, server: IRpdServer, routeConfig: RpdRoute) {
+  if (!routeConfig.handler && !routeConfig.actions) {
+    throw new Error(`No handler or actions defined for route ${routeConfig.code}`);
+  }
 
-export async function buildRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
   const logger = server.getLogger();
+  routeConfig = cloneDeep(routeConfig);
+  routeContext.routeConfig = routeConfig;
+  const { request, params } = routeContext;
+
+  let search = request.url.search;
+  if (search && search.startsWith("?")) {
+    search = search.substring(1);
+  }
+  const query = qs.parse(search);
+  const input = Object.assign({}, params, query);
+
+  const requestMethod = request.method;
+  if (requestMethod === "POST" || requestMethod === "PUT" || requestMethod === "PATCH") {
+    const body = request.body;
+    if (body) {
+      Object.assign(input, body.value);
+    }
+  }
+
+  // Normalize input value
+
+  logger.debug("Processing rapid request.", {
+    method: requestMethod,
+    url: request.url.toString(),
+    input,
+  });
+
+  routeContext.response.status = 200;
+
+  let handlerContext: ActionHandlerContext = {
+    logger,
+    routerContext: routeContext,
+    next,
+    server,
+    input,
+    results: [],
+  };
+
+  await server.beforeRunRouteActions(handlerContext);
+
+  await executeInRouteContext(routeContext, routeConfig.executeInDbTransaction, async () => {
+    await executeHandlerOfActions(server, routeConfig, handlerContext);
+  });
+
+  if (!isNullOrUndefined(handlerContext.output)) {
+    routeContext.json(handlerContext.output, handlerContext.status);
+  }
+}
+
+export async function buildRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
   const router = new Router();
 
   let baseUrl = server.config.baseUrl;
@@ -27,83 +115,7 @@ export async function buildRoutes(server: IRpdServer, applicationConfig: RpdAppl
 
     const routePath = baseUrl + routeConfig.endpoint;
 
-    (router as any)[routeConfig.method.toLowerCase()](routePath, async (routerContext: RouteContext, next: Next) => {
-      routerContext.routeConfig = cloneDeep(routeConfig);
-      const { request, params } = routerContext;
-
-      let search = request.url.search;
-      if (search && search.startsWith("?")) {
-        search = search.substring(1);
-      }
-      const query = qs.parse(search);
-      const input = Object.assign({}, params, query);
-
-      const requestMethod = request.method;
-      if (requestMethod === "POST" || requestMethod === "PUT" || requestMethod === "PATCH") {
-        const body = request.body;
-        if (body) {
-          Object.assign(input, body.value);
-        }
-      }
-
-      // Normalize input value
-
-      logger.debug("Processing rapid request.", {
-        method: requestMethod,
-        url: request.url.toString(),
-        input,
-      });
-
-      routerContext.response.status = 200;
-
-      let handlerContext: ActionHandlerContext = {
-        logger,
-        routerContext,
-        next,
-        server,
-        input,
-        results: [],
-      };
-
-      await server.beforeRunRouteActions(handlerContext);
-
-      let handler = routeConfig.handler as any;
-      if (handler) {
-        if (isString(handler)) {
-          handler = new Function(`return (${routeConfig.handler})`) as any;
-        }
-
-        if (isFunction(handler)) {
-          const result = handler(handlerContext);
-          if (result instanceof Promise) {
-            await result;
-          }
-        } else {
-          throw new Error(`Invalid handler for route ${routeConfig.code}: ${routeConfig.handler}`);
-        }
-      } else if (routeConfig.actions) {
-        for (const actionConfig of routeConfig.actions) {
-          const actionCode = actionConfig.code;
-          const handler = server.getActionHandlerByCode(actionCode);
-          if (!handler) {
-            throw new Error("Unknown handler: " + actionCode);
-          }
-
-          await server.beforeRunActionHandler(handlerContext, actionConfig);
-
-          const result = handler(handlerContext, actionConfig.config);
-          if (result instanceof Promise) {
-            await result;
-          }
-        }
-      } else {
-        throw new Error(`No handler or actions defined for route ${routeConfig.code}`);
-      }
-
-      if (!isNullOrUndefined(handlerContext.output)) {
-        routerContext.json(handlerContext.output, handlerContext.status);
-      }
-    });
+    (router as any)[routeConfig.method.toLowerCase()](routePath, (routeContext, next) => handleRouteRequest(routeContext, next, server, routeConfig));
   });
 
   return router.routes();

package/src/types.ts

@@ -600,6 +600,7 @@ export interface RpdRoute {
   type: "RESTful";
   method: RpdHttpMethod;
   endpoint: string;
+  executeInDbTransaction?: boolean;
   actions?: RpdRouteActionConfig[];
   handler?: string | ((ctx: ActionHandlerContext) => Promise<void>);
 }