@ruiapp/rapid-core 0.10.2 → 0.10.3

package/dist/helpers/dbTransactionHelper.d.ts

@@ -0,0 +1,9 @@
+import { RouteContext } from "../core/routeContext";
+/**
+ * 在事务中执行`func`
+ * @param routeContext
+ * @param func
+ * @returns
+ */
+export declare function executeInDbTransaction<TResult>(routeContext: RouteContext, func: () => Promise<TResult>): Promise<TResult>;
+export declare function executeInRouteContext<TResult>(routeContext: RouteContext, inDbTransaction: boolean | undefined | null, func: () => Promise<TResult>): Promise<TResult>;

package/dist/index.d.ts

@@ -23,6 +23,7 @@ export * from "./helpers/licenseHelper";
 export * as entityHelper from "./helpers/entityHelper";
 export * as licenseHelper from "./helpers/licenseHelper";
 export * as metaHelper from "./helpers/metaHelper";
+export * from "./helpers/dbTransactionHelper";
 export * from "./deno-std/http/cookie";
 export { mapDbRowToEntity } from "./dataAccess/entityMapper";
 export * as bootstrapApplicationConfig from "./bootstrapApplicationConfig";

package/dist/index.js

@@ -5380,6 +5380,43 @@ 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;
@@ -8279,7 +8316,9 @@ class SequencePlugin {
 const code$5 = "runServerOperation";
 async function handler$5(plugin, ctx, options) {
     const { operation } = options;
-    await operation(ctx);
+    await executeInRouteContext(ctx.routerContext, options.executeInDbTransaction, async () => {
+        await operation(ctx);
+    });
 }
 
 var runServerOperation = /*#__PURE__*/Object.freeze({
@@ -8339,6 +8378,7 @@ class ServerOperationPlugin {
                         config: {
                             operation: operation.handler,
                             permissionCheck: operation.permissionCheck,
+                            executeInDbTransaction: operation.executeInDbTransaction,
                         },
                     },
                 ],
@@ -9360,13 +9400,15 @@ class CronJobService {
         let lastErrorStack;
         try {
             validateLicense(server);
-            if (job.actionHandlerCode) {
-                const actionHandler = server.getActionHandlerByCode(job.code);
-                await actionHandler(handlerContext, job.handleOptions);
-            }
-            else {
-                await job.handler(handlerContext, job.handleOptions);
-            }
+            await executeInRouteContext(handlerContext.routerContext, job.executeInDbTransaction, async () => {
+                if (job.actionHandlerCode) {
+                    const actionHandler = server.getActionHandlerByCode(job.code);
+                    await actionHandler(handlerContext, job.handleOptions);
+                }
+                else {
+                    await job.handler(handlerContext, job.handleOptions);
+                }
+            });
             result = "success";
             logger.info(`Completed cron job '${jobCode}'...`);
         }
@@ -9947,6 +9989,8 @@ exports.detectChangedFieldsOfEntity = detectChangedFieldsOfEntity;
 exports.ensureDirectoryExists = ensureDirectoryExists;
 exports.entityHelper = entityHelper;
 exports.enumFileBaseNamesInDirectory = enumFileBaseNamesInDirectory;
+exports.executeInDbTransaction = executeInDbTransaction;
+exports.executeInRouteContext = executeInRouteContext;
 exports.formatDateTimeWithTimezone = formatDateTimeWithTimezone;
 exports.generateJwtSecretKey = generateJwtSecretKey;
 exports.generatePasswordHash = generatePasswordHash;

package/dist/plugins/serverOperation/ServerOperationPluginTypes.d.ts

@@ -6,6 +6,10 @@ export interface ServerOperation {
     description?: string;
     method: RpdHttpMethod;
     permissionCheck?: PermissionCheckPolicy;
+    /**
+     * 是否在事务中执行
+     */
+    executeInDbTransaction?: boolean;
     handler: (ctx: ActionHandlerContext) => Promise<void>;
 }
 export interface ServerOperationPluginInitOptions {

package/dist/plugins/serverOperation/actionHandlers/runServerOperation.d.ts

@@ -3,4 +3,5 @@ import { RapidPlugin } from "../../../core/server";
 export declare const code = "runServerOperation";
 export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: {
     operation: (ctx: ActionHandlerContext) => Promise<void>;
+    executeInDbTransaction?: boolean;
 }): Promise<void>;

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

@@ -20,6 +20,10 @@ export interface CronJobConfiguration {
      * 任务设置
      */
     jobOptions?: CronJobOptions;
+    /**
+     * 是否在事务中执行
+     */
+    executeInDbTransaction?: boolean;
     /**
      * 任务处理程序编号。当指定处理程序编号时，忽略 handler 配置。
      */

package/package.json

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

package/src/helpers/dbTransactionHelper.ts

@@ -0,0 +1,42 @@
+import { RouteContext } from "~/core/routeContext";
+import { IDatabaseClient } from "~/types";
+
+/**
+ * 在事务中执行`func`
+ * @param routeContext
+ * @param func
+ * @returns
+ */
+export async function executeInDbTransaction<TResult>(routeContext: RouteContext, func: () => Promise<TResult>): Promise<TResult> {
+  if (!routeContext) {
+    throw new Error(`Patameter "routeContext" is required if you want run in transaction.`);
+  }
+  let transactionDbClient: IDatabaseClient | undefined;
+
+  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();
+    }
+  }
+}
+
+export async function executeInRouteContext<TResult>(
+  routeContext: RouteContext,
+  inDbTransaction: boolean | undefined | null,
+  func: () => Promise<TResult>,
+): Promise<TResult> {
+  if (inDbTransaction) {
+    return await executeInDbTransaction(routeContext, func);
+  } else {
+    return await func();
+  }
+}

package/src/index.ts

@@ -31,6 +31,7 @@ export * from "./helpers/licenseHelper";
 export * as entityHelper from "./helpers/entityHelper";
 export * as licenseHelper from "./helpers/licenseHelper";
 export * as metaHelper from "./helpers/metaHelper";
+export * from "./helpers/dbTransactionHelper";
 
 export * from "./deno-std/http/cookie";
 

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

@@ -7,6 +7,7 @@ import { JobRunningResult, NamedCronJobInstance, SysCronJob, UpdateJobConfigOpti
 import { CronJobConfiguration } from "~/types/cron-job-types";
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { formatDateTimeWithTimezone, getNowStringWithTimezone } from "~/utilities/timeUtility";
+import { executeInRouteContext } from "~/helpers/dbTransactionHelper";
 
 export default class CronJobService {
   #server: IRpdServer;
@@ -144,12 +145,15 @@ export default class CronJobService {
     try {
       validateLicense(server);
 
-      if (job.actionHandlerCode) {
-        const actionHandler = server.getActionHandlerByCode(job.code);
-        await actionHandler(handlerContext, job.handleOptions);
-      } else {
-        await job.handler(handlerContext, job.handleOptions);
-      }
+      await executeInRouteContext(handlerContext.routerContext, job.executeInDbTransaction, async () => {
+        if (job.actionHandlerCode) {
+          const actionHandler = server.getActionHandlerByCode(job.code);
+          await actionHandler(handlerContext, job.handleOptions);
+        } else {
+          await job.handler(handlerContext, job.handleOptions);
+        }
+      });
+
       result = "success";
       logger.info(`Completed cron job '${jobCode}'...`);
     } catch (ex: any) {

package/src/plugins/serverOperation/ServerOperationPlugin.ts

@@ -75,6 +75,7 @@ class ServerOperationPlugin implements RapidPlugin {
             config: {
               operation: operation.handler,
               permissionCheck: operation.permissionCheck,
+              executeInDbTransaction: operation.executeInDbTransaction,
             },
           },
         ],

package/src/plugins/serverOperation/ServerOperationPluginTypes.ts

@@ -7,6 +7,11 @@ export interface ServerOperation {
   description?: string;
   method: RpdHttpMethod;
   permissionCheck?: PermissionCheckPolicy;
+
+  /**
+   * 是否在事务中执行
+   */
+  executeInDbTransaction?: boolean;
   handler: (ctx: ActionHandlerContext) => Promise<void>;
 }
 

package/src/plugins/serverOperation/actionHandlers/runServerOperation.ts

@@ -1,5 +1,6 @@
 import { ActionHandlerContext } from "~/core/actionHandler";
 import { RapidPlugin } from "~/core/server";
+import { executeInDbTransaction, executeInRouteContext } from "~/helpers/dbTransactionHelper";
 
 export const code = "runServerOperation";
 
@@ -8,8 +9,12 @@ export async function handler(
   ctx: ActionHandlerContext,
   options: {
     operation: (ctx: ActionHandlerContext) => Promise<void>;
+    executeInDbTransaction?: boolean;
   },
 ) {
   const { operation } = options;
-  await operation(ctx);
+
+  await executeInRouteContext(ctx.routerContext, options.executeInDbTransaction, async () => {
+    await operation(ctx);
+  });
 }

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

@@ -26,6 +26,11 @@ export interface CronJobConfiguration {
    */
   jobOptions?: CronJobOptions;
 
+  /**
+   * 是否在事务中执行
+   */
+  executeInDbTransaction?: boolean;
+
   /**
    * 任务处理程序编号。当指定处理程序编号时，忽略 handler 配置。
    */