@ruiapp/rapid-core 0.1.41 → 0.1.43

package/src/plugins/sequence/models/index.ts

@@ -1,7 +1,4 @@
 import SequenceRule from "./SequenceRule";
 import SequenceAutoIncrementRecord from "./SequenceAutoIncrementRecord";
 
-export default [
-  SequenceRule,
-  SequenceAutoIncrementRecord,
-]
+export default [SequenceRule, SequenceAutoIncrementRecord];

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

@@ -12,4 +12,4 @@ export default {
       code: "generateSn",
     },
   ],
-} satisfies RpdRoute;
+} satisfies RpdRoute;

package/src/plugins/sequence/routes/index.ts

@@ -1,5 +1,3 @@
 import generateSn from "./generateSn";
 
-export default [
-  generateSn,
-]
+export default [generateSn];

package/src/plugins/sequence/segment-utility.ts

@@ -8,4 +8,4 @@ export function padSegment(segment: string, length?: number, fillString?: string
   } else {
     return segment.padStart(length, fillString || " ");
   }
-}
+}

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

@@ -45,7 +45,7 @@ export async function resolveSegmentValue(server: IRpdServer, ruleCode: string,
       if (now.year() !== lastUpdate.year() || now.month() !== lastUpdate.month()) {
         shouldReset = true;
       }
-    } else  if (period === "day") {
+    } else if (period === "day") {
       if (now.year() !== lastUpdate.year() || now.month() !== lastUpdate.month() || now.date() !== lastUpdate.date()) {
         shouldReset = true;
       }
@@ -64,14 +64,10 @@ export async function resolveSegmentValue(server: IRpdServer, ruleCode: string,
       scope: scope,
       current_value: nextValue,
       updated_at: nowString,
-    })
+    });
   }
 
   const segmentValue = nextValue.toString();
 
-  return padSegment(
-    segmentValue,
-    config.length,
-    config.padding || "0",
-  );
-}
+  return padSegment(segmentValue, config.length, config.padding || "0");
+}

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

@@ -6,11 +6,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "dayOfMonth";
 
 export async function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceDayOfMonthSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string> {
-  const segmentValue = (new Date).getDate().toString();
+  const segmentValue = new Date().getDate().toString();
 
-  return padSegment(
-    segmentValue,
-    config.length || 2,
-    config.padding || "0",
-  );
-}
+  return padSegment(segmentValue, config.length || 2, config.padding || "0");
+}

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

@@ -6,11 +6,4 @@ import * as dayOfMonth from "./dayOfMonth";
 import * as parameter from "./parameter";
 import * as autoIncrement from "./autoIncrement";
 
-export default [
-  literal,
-  year,
-  month,
-  dayOfMonth,
-  parameter,
-  autoIncrement,
-] satisfies SegmentResolver[];
+export default [literal, year, month, dayOfMonth, parameter, autoIncrement] satisfies SegmentResolver[];

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

@@ -6,4 +6,4 @@ export const segmentType = "literal";
 
 export async function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceLiteralSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string> {
   return config.content || "";
-}
+}

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

@@ -6,11 +6,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "month";
 
 export async function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceMonthSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string> {
-  const segmentValue = ((new Date).getMonth() + 1).toString();
+  const segmentValue = (new Date().getMonth() + 1).toString();
 
-  return padSegment(
-    segmentValue,
-    config.length || 2,
-    config.padding || "0",
-  );
-}
+  return padSegment(segmentValue, config.length || 2, config.padding || "0");
+}

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

@@ -7,11 +7,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "parameter";
 
 export async function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceParameterSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string> {
-  const segmentValue = get(input.parameters, config.parameterName, "");
+  const segmentValue = get(input.parameters, config.parameterName, config.defaultContent || "");
 
-  return padSegment(
-    segmentValue,
-    config.length,
-    config.padding,
-  );
-}
+  return padSegment(segmentValue, config.length, config.padding);
+}

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

@@ -6,11 +6,7 @@ import { IRpdServer } from "~/core/server";
 export const segmentType = "year";
 
 export async function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceYearSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string> {
-  const segmentValue = (new Date).getFullYear().toString();
+  const segmentValue = new Date().getFullYear().toString();
 
-  return padSegment(
-    segmentValue,
-    config.length || 4,
-    config.padding || "0",
-  );
-}
+  return padSegment(segmentValue, config.length || 4, config.padding || "0");
+}

package/src/plugins/serverOperation/ServerOperationPlugin.ts

@@ -31,11 +31,9 @@ class ServerOperationPlugin implements RapidPlugin {
     return [];
   }
 
-  async initPlugin(server: IRpdServer): Promise<any> {
-  }
+  async initPlugin(server: IRpdServer): Promise<any> {}
 
-  async registerMiddlewares(server: IRpdServer): Promise<any> {
-  }
+  async registerMiddlewares(server: IRpdServer): Promise<any> {}
 
   async registerActionHandlers(server: IRpdServer): Promise<any> {
     for (const actionHandler of pluginActionHandlers) {
@@ -43,23 +41,17 @@ class ServerOperationPlugin implements RapidPlugin {
     }
   }
 
-  async registerEventHandlers(server: IRpdServer): Promise<any> {
-  }
+  async registerEventHandlers(server: IRpdServer): Promise<any> {}
 
-  async registerMessageHandlers(server: IRpdServer): Promise<any> {
-  }
+  async registerMessageHandlers(server: IRpdServer): Promise<any> {}
 
-  async registerTaskProcessors(server: IRpdServer): Promise<any> {
-  }
+  async registerTaskProcessors(server: IRpdServer): Promise<any> {}
 
-  async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
+  async onLoadingApplication(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
-  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
+  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
-  async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
+  async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
   async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
     const routes: RpdRoute[] = [];
@@ -76,19 +68,17 @@ class ServerOperationPlugin implements RapidPlugin {
             code: "runServerOperation",
             config: {
               operation: operation.handler,
-            }
+            },
           },
         ],
-      })
+      });
     }
     server.appendApplicationConfig({ routes });
   }
 
-  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
+  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
-  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
+  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 }
 
 export default ServerOperationPlugin;

package/src/plugins/serverOperation/ServerOperationPluginTypes.ts

@@ -10,4 +10,4 @@ export interface ServerOperation {
 
 export interface ServerOperationPluginInitOptions {
   operations: ServerOperation[];
-}
+}

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

@@ -1,6 +1,4 @@
 import { IPluginActionHandler } from "~/core/actionHandler";
 import * as runServerOperation from "./runServerOperation";
 
-export default [
-  runServerOperation,
-] satisfies IPluginActionHandler[];
+export default [runServerOperation] satisfies IPluginActionHandler[];

package/src/plugins/stateMachine/StateMachinePlugin.ts

@@ -2,13 +2,7 @@
  * State machine plugin
  */
 
-import {
-  CreateEntityOptions,
-  RpdApplicationConfig,
-  RpdDataModel,
-  RpdDataModelProperty,
-  UpdateEntityByIdOptions,
-} from "~/types";
+import { CreateEntityOptions, RpdApplicationConfig, RpdDataModel, RpdDataModelProperty, UpdateEntityByIdOptions } from "~/types";
 import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
 
 import pluginActionHandlers from "./actionHandlers";
@@ -18,7 +12,7 @@ import { filter, find, first, get, isEqual } from "lodash";
 import { PropertyStateMachineConfig } from "./StateMachinePluginTypes";
 import { isNullOrUndefined } from "~/utilities/typeUtility";
 import { getStateMachineNextSnapshot } from "./stateMachineHelper";
-
+import { getEntityPropertiesIncludingBase } from "~/dataAccess/metaHelper";
 
 class StateMachinePlugin implements RapidPlugin {
   get code(): string {
@@ -58,7 +52,7 @@ class StateMachinePlugin implements RapidPlugin {
   async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
     const models = server.getApplicationConfig().models;
     for (const model of models) {
-      for (const property of model.properties) {
+      for (const property of getEntityPropertiesIncludingBase(server, model)) {
         const propertyStateMachineConfig: PropertyStateMachineConfig = property.config?.stateMachine;
         if (propertyStateMachineConfig) {
           const stateMachineCode = getStateMachineCode(model, property);
@@ -97,15 +91,14 @@ class StateMachinePlugin implements RapidPlugin {
   /**
    * 创建实体前的处理。
    * 当属性启用了状态机管理，如创建实体时没有指定该属性的状态值，则应将该属性设置为 stateMachine.config.initial 。
-   * @param server 
-   * @param model 
-   * @param options 
+   * @param server
+   * @param model
+   * @param options
    */
   async beforeCreateEntity(server: IRpdServer, model: RpdDataModel, options: CreateEntityOptions) {
-    for (const property of model.properties) {
+    for (const property of getEntityPropertiesIncludingBase(server, model)) {
       const isStateMachineEnabled = get(property.config, "stateMachine.enabled", false);
-      if (isStateMachineEnabled && isNullOrUndefined(options.entity[property.code])
-      ) {
+      if (isStateMachineEnabled && isNullOrUndefined(options.entity[property.code])) {
         const initialState = get(property.config, "stateMachine.config.initial", null);
         if (initialState) {
           options.entity[property.code] = initialState;
@@ -120,15 +113,15 @@ class StateMachinePlugin implements RapidPlugin {
    * 2. 当更新实体时指定了operation，则查找启用了状态机管理的属性。
    * 如果一个模型中存在多个属性启用了状态机管理，则以 options.stateProperty 中指定的为准。
    * 对于该状态属性应用 options.operation，使其转换到下一状态。
-   * @param server 
-   * @param model 
-   * @param options 
+   * @param server
+   * @param model
+   * @param options
    */
   async beforeUpdateEntity(server: IRpdServer, model: RpdDataModel, options: UpdateEntityByIdOptions, currentEntity: any) {
     const entity = options.entityToSave;
 
     const stateMachineEnabledProperties: RpdDataModelProperty[] = [];
-    for (const property of model.properties) {
+    for (const property of getEntityPropertiesIncludingBase(server, model)) {
       const isStateMachineEnabled = get(property.config, "stateMachine.enabled", false);
 
       if (isStateMachineEnabled) {
@@ -163,21 +156,25 @@ class StateMachinePlugin implements RapidPlugin {
         throw new Error(`State machine of property '${statePropertyToUpdate.code}' not configured.`);
       }
       machineConfig.id = getStateMachineCode(model, statePropertyToUpdate);
-  
+
       const nextSnapshot = await getStateMachineNextSnapshot({
         machineConfig,
         context: {},
         currentState: currentEntity[statePropertyToUpdate.code],
         event: options.operation,
       });
-  
+
       entity[statePropertyToUpdate.code] = nextSnapshot.value;
     }
   }
 }
 
 function getStateMachineCode(model: RpdDataModel, property: RpdDataModelProperty) {
-  return `propertyStateMachine.${model.namespace}.${model.singularCode}.${property.code}`;
+  if (property.isBaseProperty) {
+    return `propertyStateMachine.${model.namespace}.${model.base}.${property.code}`;
+  } else {
+    return `propertyStateMachine.${model.namespace}.${model.singularCode}.${property.code}`;
+  }
 }
 
 export default StateMachinePlugin;

package/src/plugins/stateMachine/StateMachinePluginTypes.ts

@@ -1,15 +1,14 @@
 import { AnyActorRef, AnyEventObject, EventObject, MachineConfig, MachineContext, MachineSnapshot, MetaObject, StateValue } from "xstate";
 
-
 export type PropertyStateMachineConfig = {
   enabled: boolean;
   config: MachineConfig<any, any>;
   transferControl?: boolean;
-}
+};
 
 export type SendStateMachineEventOptions = {
   code: string;
-}
+};
 
 export type StateMachineEvent = AnyEventObject;
 
@@ -18,14 +17,14 @@ export type SendStateMachineEventInput = {
   context: any;
   currentState: string;
   event: StateMachineEvent;
-}
+};
 
 export type GetStateMachineNextSnapshotOptions = {
   machineConfig: MachineConfig<any, any>;
   context: any;
   currentState: string;
   event: StateMachineEvent;
-}
+};
 
 export type DefaultStateMachineSnapshot = MachineSnapshot<MachineContext, EventObject, Record<string, AnyActorRef | undefined>, StateValue, string, unknown, MetaObject>;
 
@@ -34,8 +33,8 @@ export type TryGetStateMachineNextSnapshotResult = TryGetStateMachineNextSnapsho
 export type TryGetStateMachineNextSnapshotPositiveResult = {
   canTransfer: true;
   nextSnapshot: DefaultStateMachineSnapshot;
-}
+};
 
 export type TryGetStateMachineNextSnapshotNegativeResult = {
   canTransfer: false;
-}
+};

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

@@ -1,6 +1,4 @@
 import { IPluginActionHandler } from "~/core/actionHandler";
 import * as sendStateMachineEvent from "./sendStateMachineEvent";
 
-export default [
-  sendStateMachineEvent,
-] satisfies IPluginActionHandler[];
+export default [sendStateMachineEvent] satisfies IPluginActionHandler[];

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

@@ -5,11 +5,7 @@ import { getStateMachineNextSnapshot } from "../stateMachineHelper";
 
 export const code = "sendStateMachineEvent";
 
-export async function handler(
-  plugin: RapidPlugin,
-  ctx: ActionHandlerContext,
-  options: SendStateMachineEventOptions,
-) {
+export async function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: SendStateMachineEventOptions) {
   const { server, routerContext } = ctx;
   const { response } = routerContext;
 
@@ -32,8 +28,8 @@ export async function handler(
         operator: "eq",
         field: "code",
         value: input.code,
-      }
-    ]
+      },
+    ],
   });
 
   if (!stateMachine) {

package/src/plugins/stateMachine/models/StateMachine.ts

@@ -1,6 +1,6 @@
 import { RpdDataModel } from "~/types";
 
-export default     {
+export default {
   maintainedBy: "stateMachinePlugin",
   namespace: "svc",
   name: "state_machine",
@@ -39,4 +39,4 @@ export default     {
       required: false,
     },
   ],
-} as RpdDataModel;
+} as RpdDataModel;

package/src/plugins/stateMachine/models/index.ts

@@ -1,5 +1,3 @@
 import StateMachine from "./StateMachine";
 
-export default [
-  StateMachine,
-]
+export default [StateMachine];

package/src/plugins/stateMachine/routes/index.ts

@@ -1,5 +1,3 @@
 import sendStateMachineEvent from "./sendStateMachineEvent";
 
-export default [
-  sendStateMachineEvent,
-]
+export default [sendStateMachineEvent];

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

@@ -12,4 +12,4 @@ export default {
       code: "sendStateMachineEvent",
     },
   ],
-} satisfies RpdRoute;
+} satisfies RpdRoute;

package/src/plugins/webhooks/WebhooksPlugin.ts

@@ -2,19 +2,12 @@
  * Webhooks plugin
  */
 
-import {
-  RpdApplicationConfig,
-  RpdEntityCreateEventPayload,
-  RpdEntityDeleteEventPayload,
-  RpdEntityUpdateEventPayload,
-  RpdServerEventTypes,
-} from "~/types";
+import { RpdApplicationConfig, RpdEntityCreateEventPayload, RpdEntityDeleteEventPayload, RpdEntityUpdateEventPayload, RpdServerEventTypes } from "~/types";
 import { RpdServerPluginExtendingAbilities, RpdServerPluginConfigurableTargetOptions, RpdConfigurationItemOptions, IRpdServer, RapidPlugin } from "~/core/server";
 import { fetchWithTimeout } from "~/utilities/httpUtility";
 import pluginConfig from "./pluginConfig";
 import { indexOf } from "lodash";
 
-
 export interface Webhook {
   name: string;
   url: string;
@@ -26,10 +19,7 @@ export interface Webhook {
   enabled: boolean;
 }
 
-
-function listWebhooks(
-  server: IRpdServer,
-) {
+function listWebhooks(server: IRpdServer) {
   const logger = server.getLogger();
   logger.info("Loading meta of webhooks...");
 
@@ -49,7 +39,6 @@ function listWebhooks(
   }
 }
 
-
 class WebhooksPlugin implements RapidPlugin {
   #webhooks: Webhook[];
 
@@ -78,16 +67,9 @@ class WebhooksPlugin implements RapidPlugin {
   }
 
   async registerEventHandlers(server: IRpdServer): Promise<any> {
-    const events: (keyof RpdServerEventTypes)[] = [
-      "entity.create",
-      "entity.update",
-      "entity.delete",
-    ];
+    const events: (keyof RpdServerEventTypes)[] = ["entity.create", "entity.update", "entity.delete"];
     for (const event of events) {
-      server.registerEventHandler(
-        event,
-        this.handleEntityEvent.bind(this, server, event),
-      );
+      server.registerEventHandler(event, this.handleEntityEvent.bind(this, server, event));
     }
   }
 
@@ -97,28 +79,17 @@ class WebhooksPlugin implements RapidPlugin {
     });
   }
 
-  async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
+  async configureModelProperties(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
-  async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
+  async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
   async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
     this.#webhooks = await listWebhooks(server);
   }
 
-  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
-  }
+  async onApplicationReady(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {}
 
-  async handleEntityEvent(
-    server: IRpdServer,
-    event: keyof RpdServerEventTypes,
-    sender: RapidPlugin,
-    payload:
-      | RpdEntityCreateEventPayload
-      | RpdEntityUpdateEventPayload
-      | RpdEntityDeleteEventPayload,
-  ) {
+  async handleEntityEvent(server: IRpdServer, event: keyof RpdServerEventTypes, sender: RapidPlugin, payload: RpdEntityCreateEventPayload | RpdEntityUpdateEventPayload | RpdEntityDeleteEventPayload) {
     if (sender === this) {
       return;
     }
@@ -140,10 +111,7 @@ class WebhooksPlugin implements RapidPlugin {
         continue;
       }
 
-      if (
-        webhook.namespace != payload.namespace ||
-        webhook.modelSingularCode !== payload.modelSingularCode
-      ) {
+      if (webhook.namespace != payload.namespace || webhook.modelSingularCode !== payload.modelSingularCode) {
         continue;
       }
 

package/src/polyfill.ts

@@ -2,4 +2,4 @@ export function fixBigIntJSONSerialize() {
   (BigInt.prototype as any).toJSON = function () {
     return this.toString();
   };
-};
+}

package/src/proxy/mod.ts

@@ -1,20 +1,14 @@
 import { fetchWithTimeout } from "../utilities/httpUtility";
 import { ProxyContext, ProxyOptions } from "./types";
-import { RouteContext} from "~/core/routeContext";
+import { RouteContext } from "~/core/routeContext";
 
-export async function doProxy(
-  sourceRouterCtx: RouteContext,
-  options: ProxyOptions,
-) {
+export async function doProxy(sourceRouterCtx: RouteContext, options: ProxyOptions) {
   const proxyCtx = createProxyContext(sourceRouterCtx, options);
   const targetRes = await sendTargetRequest(proxyCtx);
   sendSourceResponse(proxyCtx, targetRes);
 }
 
-export function createProxyContext(
-  sourceRouterCtx: RouteContext,
-  options: ProxyOptions,
-) {
+export function createProxyContext(sourceRouterCtx: RouteContext, options: ProxyOptions) {
   return {
     sourceContext: {
       request: sourceRouterCtx.request,
@@ -37,10 +31,7 @@ export async function sendTargetRequest(proxyCtx: ProxyContext) {
   return await fetchWithTimeout(target, reqInit, timeout);
 }
 
-export async function sendSourceResponse(
-  proxyCtx: ProxyContext,
-  targetRes: Response,
-) {
+export async function sendSourceResponse(proxyCtx: ProxyContext, targetRes: Response) {
   const { response: srcRes } = proxyCtx.sourceContext;
   srcRes.status = targetRes.status;
   srcRes.body = targetRes.body;