@ruiapp/rapid-core 0.3.0 → 0.4.0

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

@@ -7,8 +7,8 @@ import { getFileBaseName } from "~/utilities/pathUtility";
 export const code = "downloadDocument";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) {
-  const { server, applicationConfig, routerContext, input } = ctx;
-  const { request, response } = routerContext;
+  const { server, applicationConfig, routerContext: routeContext, input } = ctx;
+  const { request, response } = routeContext;
 
   const documentDataAccessor = ctx.server.getDataAccessor({
     singularCode: "ecm_document",
@@ -24,7 +24,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
   let fileName: string;
   let { revisionId, documentId } = input;
   if (revisionId) {
-    const revision = await revisionDataAccessor.findById(revisionId);
+    const revision = await revisionDataAccessor.findById(revisionId, routeContext?.getDbTransactionClient());
     if (!revision) {
       ctx.output = { error: new Error(`Revision with id "${revisionId}" was not found.`) };
       return;
@@ -32,14 +32,14 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
     storageObjectId = revision.storage_object_id;
 
     documentId = revision.document_id;
-    const document = await documentDataAccessor.findById(documentId);
+    const document = await documentDataAccessor.findById(documentId, routeContext?.getDbTransactionClient());
     if (!document) {
       ctx.output = { error: new Error(`Document with id "${documentId}" was not found.`) };
       return;
     }
     fileName = `${getFileBaseName(document.name!)}${revision.ext_name}`;
   } else if (documentId) {
-    const document = await documentDataAccessor.findById(documentId);
+    const document = await documentDataAccessor.findById(documentId, routeContext?.getDbTransactionClient());
     if (!document) {
       ctx.output = { error: new Error(`Document with id "${documentId}" was not found.`) };
       return;
@@ -51,7 +51,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
     return;
   }
 
-  const storageObject = await storageDataAccessor.findById(storageObjectId);
+  const storageObject = await storageDataAccessor.findById(storageObjectId, routeContext?.getDbTransactionClient());
   if (!storageObject) {
     ctx.output = { error: new Error(`Storage object with id "${storageObjectId}" was not found.`) };
     return;

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

@@ -13,8 +13,8 @@ export type DownloadFileInput = {
 export const code = "downloadFile";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any) {
-  const { server, applicationConfig, routerContext } = ctx;
-  const { request, response } = routerContext;
+  const { server, applicationConfig, routerContext: routeContext } = ctx;
+  const { request, response } = routeContext;
   //TODO: only public files can download by this handler
 
   const input: DownloadFileInput = ctx.input;
@@ -26,7 +26,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
       singularCode: "ecm_storage_object",
     });
 
-    const storageObject = await dataAccessor.findById(input.fileId);
+    const storageObject = await dataAccessor.findById(input.fileId, routeContext?.getDbTransactionClient());
     if (!storageObject) {
       ctx.output = { error: new Error("Storage object not found.") };
       return;

package/src/plugins/metaManage/MetaManagePlugin.ts

@@ -31,6 +31,7 @@ import { getEntityPropertiesIncludingBase, getEntityPropertyByCode, isOneRelatio
 import { DataAccessPgColumnTypes } from "~/dataAccess/dataAccessTypes";
 import { pgPropertyTypeColumnMap } from "~/dataAccess/columnTypeMapper";
 import { convertModelIndexConditionsToRowFilterOptions } from "~/helpers/filterHelper";
+import { RouteContext } from "~/core/routeContext";
 
 class MetaManager implements RapidPlugin {
   get code(): string {
@@ -119,7 +120,7 @@ async function handleEntityUpdateEvent(server: IRpdServer, sender: RapidPlugin,
   }
 }
 
-async function handleEntityDeleteEvent(server: IRpdServer, sender: RapidPlugin, payload: RpdEntityDeleteEventPayload) {
+async function handleEntityDeleteEvent(server: IRpdServer, sender: RapidPlugin, payload: RpdEntityDeleteEventPayload, routeContext?: RouteContext) {
   if (sender === this) {
     return;
   }
@@ -150,7 +151,7 @@ async function handleEntityDeleteEvent(server: IRpdServer, sender: RapidPlugin,
       namespace: "meta",
       singularCode: "model",
     });
-    const model = await dataAccessor.findById((deletedProperty as any).modelId);
+    const model = await dataAccessor.findById((deletedProperty as any).modelId, routeContext?.getDbTransactionClient());
     if (model) {
       await server.queryDatabaseObject(`ALTER TABLE ${queryBuilder.quoteTable(model)} DROP COLUMN ${queryBuilder.quoteObject(columnNameToDrop)}`, []);
     }

package/src/plugins/notification/models/Notification.ts

@@ -45,11 +45,14 @@ export default {
       columnName: "details",
       description: '{"url": "", "actions": [{"text": "", "url": ""}]}',
       type: "json",
+      required: false,
     },
     {
       name: "用户",
       code: "user",
       type: "relation",
+      required: false,
+      relation: "one",
       targetSingularCode: "oc_user",
       targetIdColumnName: "user_id",
     },

package/src/plugins/sequence/SequencePlugin.ts

@@ -78,29 +78,39 @@ class SequencePlugin implements RapidPlugin {
           const sequenceRuleDataAccessor = server.getDataAccessor({
             singularCode: "sequence_rule",
           });
-          const sequenceRule = await sequenceRuleDataAccessor.findOne({
-            filters: [
-              {
-                operator: "eq",
-                field: {
-                  name: "code",
+          const sequenceRule = await sequenceRuleDataAccessor.findOne(
+            {
+              filters: [
+                {
+                  operator: "eq",
+                  field: {
+                    name: "code",
+                  },
+                  value: ruleCode,
                 },
-                value: ruleCode,
-              },
-            ],
-          });
+              ],
+            },
+            null,
+          );
 
           if (sequenceRule) {
             if (isEqual(sequenceRule.config, ruleConfig)) {
-              await sequenceRuleDataAccessor.updateById(sequenceRule.id, {
-                config: ruleConfig,
-              });
+              await sequenceRuleDataAccessor.updateById(
+                sequenceRule.id,
+                {
+                  config: ruleConfig,
+                },
+                null,
+              );
             }
           } else {
-            await sequenceRuleDataAccessor.create({
-              code: ruleCode,
-              config: ruleConfig,
-            });
+            await sequenceRuleDataAccessor.create(
+              {
+                code: ruleCode,
+                config: ruleConfig,
+              },
+              null,
+            );
           }
         }
       }
@@ -108,13 +118,13 @@ class SequencePlugin implements RapidPlugin {
   }
 
   async beforeCreateEntity(server: IRpdServer, model: RpdDataModel, options: CreateEntityOptions) {
-    const entity = options.entity;
+    const { routeContext, entity } = options;
     for (const property of getEntityPropertiesIncludingBase(server, model)) {
       const sequenceConfig: PropertySequenceConfig = property.config?.sequence;
       const propertyValue = entity[property.code];
       if (sequenceConfig && sequenceConfig.enabled && isNullOrUndefined(propertyValue)) {
         const ruleCode = getSequenceRuleCode(model, property);
-        const numbers = await this.#sequenceService.generateSn(server, {
+        const numbers = await this.#sequenceService.generateSn(routeContext, server, {
           ruleCode,
           amount: 1,
           parameters: entity,

package/src/plugins/sequence/SequenceService.ts

@@ -2,6 +2,7 @@ import { IRpdServer } from "~/core/server";
 import segmentResolvers from "./segments";
 import { find } from "lodash";
 import { SequenceRuleConfig, SequenceSegmentConfig } from "./SequencePluginTypes";
+import { RouteContext } from "~/core/routeContext";
 
 export interface GenerateSequenceNumbersInput {
   ruleCode: string;
@@ -15,7 +16,13 @@ export interface GenerateSequenceNumbersOutput {
 
 export interface SegmentResolver {
   segmentType: string;
-  resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+  resolveSegmentValue(
+    routeContext: RouteContext,
+    server: IRpdServer,
+    ruleCode: string,
+    config: SequenceSegmentConfig,
+    input: GenerateSequenceNumbersInput,
+  ): Promise<string>;
 }
 
 export default class SequenceService {
@@ -25,7 +32,7 @@ export default class SequenceService {
     this.#server = server;
   }
 
-  async generateSn(server: IRpdServer, input: GenerateSequenceNumbersInput): Promise<string[]> {
+  async generateSn(routeContext: RouteContext | null, server: IRpdServer, input: GenerateSequenceNumbersInput): Promise<string[]> {
     const sequenceNumbers = [];
     const { ruleCode, parameters } = input;
     let { amount } = input;
@@ -38,17 +45,20 @@ export default class SequenceService {
       singularCode: "sequence_rule",
     });
 
-    const sequenceRule = await sequenceRuleDataAccessor.findOne({
-      filters: [
-        {
-          operator: "eq",
-          field: {
-            name: "code",
+    const sequenceRule = await sequenceRuleDataAccessor.findOne(
+      {
+        filters: [
+          {
+            operator: "eq",
+            field: {
+              name: "code",
+            },
+            value: ruleCode,
           },
-          value: ruleCode,
-        },
-      ],
-    });
+        ],
+      },
+      routeContext?.getDbTransactionClient(),
+    );
 
     if (!sequenceRule) {
       throw new Error(`Failed to generate sequence number. Sequence with code '${sequenceRule.code}' not found.`);
@@ -65,11 +75,12 @@ export default class SequenceService {
       for (const segmentConfig of sequenceConfig.segments) {
         const segmentResolver: SegmentResolver = find(segmentResolvers, (item) => item.segmentType === segmentConfig.type);
         if (!segmentResolver) {
-          // TODO: deal with unkown segment type
+          // TODO: deal with unknown segment type
+          server.getLogger().warn(`Unknown segment type "${segmentConfig.type}"`);
           continue;
         }
 
-        const segment = await segmentResolver.resolveSegmentValue(server, ruleCode, segmentConfig, input);
+        const segment = await segmentResolver.resolveSegmentValue(routeContext, server, ruleCode, segmentConfig, input);
         sequenceNumber += segment;
       }
 

package/src/plugins/sequence/actionHandlers/generateSn.ts

@@ -9,8 +9,8 @@ export interface GenerateSequenceNumbersOptions {
 export const code = "generateSn";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: GenerateSequenceNumbersOptions) {
-  const { server, routerContext } = ctx;
-  const { response } = routerContext;
+  const { server, routerContext: routeContext } = ctx;
+  const { response } = routeContext;
 
   const input: GenerateSequenceNumbersInput = ctx.input;
 
@@ -24,7 +24,7 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
 
   const sequenceService = server.getService<SequenceService>("sequenceService");
 
-  const sequences = await sequenceService.generateSn(server, input);
+  const sequences = await sequenceService.generateSn(routeContext, server, input);
 
   ctx.output = {
     sequences,

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

@@ -4,10 +4,12 @@ import { IRpdServer } from "~/core/server";
 import { get } from "lodash";
 import dayjs from "dayjs";
 import { SequenceAutoIncrementSegmentConfig } from "../SequencePluginTypes";
+import { RouteContext } from "~/core/routeContext";
 
 export const segmentType = "autoIncrement";
 
 export async function resolveSegmentValue(
+  routeContext: RouteContext,
   server: IRpdServer,
   ruleCode: string,
   config: SequenceAutoIncrementSegmentConfig,
@@ -19,20 +21,23 @@ export async function resolveSegmentValue(
 
   const scope = get(input.parameters, config.scope, "");
 
-  const autoIncrementRecord = await autoIncrementRecordDataAccessor.findOne({
-    filters: [
-      {
-        operator: "eq",
-        field: "rule_code",
-        value: ruleCode,
-      },
-      {
-        operator: "eq",
-        field: "scope",
-        value: scope,
-      },
-    ],
-  });
+  const autoIncrementRecord = await autoIncrementRecordDataAccessor.findOne(
+    {
+      filters: [
+        {
+          operator: "eq",
+          field: "rule_code",
+          value: ruleCode,
+        },
+        {
+          operator: "eq",
+          field: "scope",
+          value: scope,
+        },
+      ],
+    },
+    routeContext?.getDbTransactionClient(),
+  );
 
   let now = dayjs();
   let nowString = now.format("YYYY-MM-DD HH:mm:ss.SSS Z");
@@ -59,17 +64,24 @@ export async function resolveSegmentValue(
     if (!shouldReset) {
       nextValue = autoIncrementRecord.current_value + 1;
     }
-    await autoIncrementRecordDataAccessor.updateById(autoIncrementRecord.id, {
-      current_value: nextValue,
-      updated_at: nowString,
-    });
+    await autoIncrementRecordDataAccessor.updateById(
+      autoIncrementRecord.id,
+      {
+        current_value: nextValue,
+        updated_at: nowString,
+      },
+      routeContext?.getDbTransactionClient(),
+    );
   } else {
-    await autoIncrementRecordDataAccessor.create({
-      rule_code: ruleCode,
-      scope: scope,
-      current_value: nextValue,
-      updated_at: nowString,
-    });
+    await autoIncrementRecordDataAccessor.create(
+      {
+        rule_code: ruleCode,
+        scope: scope,
+        current_value: nextValue,
+        updated_at: nowString,
+      },
+      routeContext?.getDbTransactionClient(),
+    );
   }
 
   const segmentValue = nextValue.toString();

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

@@ -1,3 +1,4 @@
+import { RouteContext } from "~/core/routeContext";
 import { SequenceDayOfMonthSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
@@ -6,6 +7,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "dayOfMonth";
 
 export async function resolveSegmentValue(
+  routeContext: RouteContext,
   server: IRpdServer,
   ruleCode: string,
   config: SequenceDayOfMonthSegmentConfig,

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

@@ -1,3 +1,4 @@
+import { RouteContext } from "~/core/routeContext";
 import { SequenceLiteralSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { IRpdServer } from "~/core/server";
@@ -5,6 +6,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "literal";
 
 export async function resolveSegmentValue(
+  routeContext: RouteContext,
   server: IRpdServer,
   ruleCode: string,
   config: SequenceLiteralSegmentConfig,

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

@@ -1,3 +1,4 @@
+import { RouteContext } from "~/core/routeContext";
 import { SequenceMonthSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
@@ -6,6 +7,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "month";
 
 export async function resolveSegmentValue(
+  routeContext: RouteContext,
   server: IRpdServer,
   ruleCode: string,
   config: SequenceMonthSegmentConfig,

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

@@ -1,3 +1,4 @@
+import { RouteContext } from "~/core/routeContext";
 import { SequenceParameterSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
@@ -7,6 +8,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "parameter";
 
 export async function resolveSegmentValue(
+  routeContext: RouteContext,
   server: IRpdServer,
   ruleCode: string,
   config: SequenceParameterSegmentConfig,

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

@@ -1,3 +1,4 @@
+import { RouteContext } from "~/core/routeContext";
 import { SequenceYearSegmentConfig } from "../SequencePluginTypes";
 import { GenerateSequenceNumbersInput } from "../SequenceService";
 import { padSegment } from "../segment-utility";
@@ -6,6 +7,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "year";
 
 export async function resolveSegmentValue(
+  routeContext: RouteContext,
   server: IRpdServer,
   ruleCode: string,
   config: SequenceYearSegmentConfig,

package/src/plugins/stateMachine/StateMachinePlugin.ts

@@ -67,27 +67,37 @@ class StateMachinePlugin implements RapidPlugin {
           const stateMachineDataAccessor = server.getDataAccessor({
             singularCode: "state_machine",
           });
-          const stateMachine = await stateMachineDataAccessor.findOne({
-            filters: [
-              {
-                operator: "eq",
-                field: "code",
-                value: stateMachineCode,
-              },
-            ],
-          });
+          const stateMachine = await stateMachineDataAccessor.findOne(
+            {
+              filters: [
+                {
+                  operator: "eq",
+                  field: "code",
+                  value: stateMachineCode,
+                },
+              ],
+            },
+            null,
+          );
 
           if (stateMachine) {
             if (!isEqual(stateMachine.config, stateMachineConfig)) {
-              await stateMachineDataAccessor.updateById(stateMachine.id, {
-                config: stateMachineConfig,
-              });
+              await stateMachineDataAccessor.updateById(
+                stateMachine.id,
+                {
+                  config: stateMachineConfig,
+                },
+                null,
+              );
             }
           } else {
-            await stateMachineDataAccessor.create({
-              code: stateMachineCode,
-              config: stateMachineConfig,
-            });
+            await stateMachineDataAccessor.create(
+              {
+                code: stateMachineCode,
+                config: stateMachineConfig,
+              },
+              null,
+            );
           }
         }
       }

package/src/plugins/stateMachine/actionHandlers/sendStateMachineEvent.ts

@@ -6,8 +6,8 @@ import { getStateMachineNextSnapshot } from "../stateMachineHelper";
 export const code = "sendStateMachineEvent";
 
 export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: SendStateMachineEventOptions) {
-  const { server, routerContext } = ctx;
-  const { response } = routerContext;
+  const { server, routerContext: routeContext } = ctx;
+  const { response } = routeContext;
 
   const input: SendStateMachineEventInput = ctx.input;
   if (options?.code) {
@@ -22,15 +22,18 @@ export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, op
     singularCode: "state_machine",
   });
 
-  const stateMachine = await stateMachineDataAccessor.findOne({
-    filters: [
-      {
-        operator: "eq",
-        field: "code",
-        value: input.code,
-      },
-    ],
-  });
+  const stateMachine = await stateMachineDataAccessor.findOne(
+    {
+      filters: [
+        {
+          operator: "eq",
+          field: "code",
+          value: input.code,
+        },
+      ],
+    },
+    routeContext?.getDbTransactionClient(),
+  );
 
   if (!stateMachine) {
     throw new Error(`State machine with code '${input.code}' was not found.`);

package/src/server.ts

@@ -139,6 +139,10 @@ export class RapidServer implements IRpdServer {
     return this.#applicationConfig;
   }
 
+  getDatabaseAccessor(): IDatabaseAccessor {
+    return this.#databaseAccessor;
+  }
+
   appendApplicationConfig(config: Partial<RpdApplicationConfig>) {
     const { models, dataDictionaries, routes } = config;
     if (models) {

package/src/types.ts

@@ -24,8 +24,14 @@ export type DatabaseQuery = {
   params?: unknown[] | Record<string, unknown>;
 };
 
+export interface IDatabaseClient {
+  release();
+  query(sql: any, params?: any): Promise<any>;
+}
+
 export interface IDatabaseAccessor {
-  queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>) => Promise<any[]>;
+  getClient(): Promise<IDatabaseClient>;
+  queryDatabaseObject: (sql: string, params?: unknown[] | Record<string, unknown>, client?: IDatabaseClient) => Promise<any[]>;
 }
 
 export interface RunEntityActionHandlerOptions {
@@ -460,13 +466,13 @@ export interface RpdRouteActionConfig {
 
 export interface IRpdDataAccessor<T = any> {
   getModel(): RpdDataModel;
-  create(entity: any): Promise<any>;
-  updateById(id: any, entity: any): Promise<any>;
-  find(options: FindRowOptions): Promise<T[]>;
-  findOne(options: FindRowOptions): Promise<T | null>;
-  findById(id: any): Promise<T | null>;
-  count(options: CountRowOptions): Promise<number>;
-  deleteById(id: any): Promise<void>;
+  create(entity: any, databaseClient: IDatabaseClient | null): Promise<any>;
+  updateById(id: any, entity: any, databaseClient: IDatabaseClient | null): Promise<any>;
+  find(options: FindRowOptions, databaseClient: IDatabaseClient | null): Promise<T[]>;
+  findOne(options: FindRowOptions, databaseClient: IDatabaseClient | null): Promise<T | null>;
+  findById(id: any, databaseClient: IDatabaseClient | null): Promise<T | null>;
+  count(options: CountRowOptions, databaseClient: IDatabaseClient | null): Promise<number>;
+  deleteById(id: any, databaseClient: IDatabaseClient | null): Promise<void>;
 }
 
 export type EntityFilterRelationalOperators =