@ruiapp/rapid-core 0.1.29 → 0.1.31

package/src/plugins/stateMachine/StateMachinePlugin.ts

@@ -0,0 +1,175 @@
+/**
+ * State machine plugin
+ */
+
+import {
+  CreateEntityOptions,
+  RpdApplicationConfig,
+  RpdDataModel,
+  RpdDataModelProperty,
+  UpdateEntityByIdOptions,
+} from "~/types";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+
+import pluginActionHandlers from "./actionHandlers";
+import pluginModels from "./models";
+import pluginRoutes from "./routes";
+import { filter, find, first, get, isEqual } from "lodash";
+import { PropertyStateMachineConfig } from "./StateMachinePluginTypes";
+import { isNullOrUndefined } from "~/utilities/typeUtility";
+import { getStateMachineNextSnapshot } from "./StateMachineService";
+
+
+class StateMachinePlugin implements RapidPlugin {
+  get code(): string {
+    return "stateMachinePlugin";
+  }
+
+  get description(): string {
+    return null;
+  }
+
+  get extendingAbilities(): RpdServerPluginExtendingAbilities[] {
+    return [];
+  }
+
+  get configurableTargets(): RpdServerPluginConfigurableTargetOptions[] {
+    return [];
+  }
+
+  get configurations(): RpdConfigurationItemOptions[] {
+    return [];
+  }
+
+  async registerActionHandlers(server: IRpdServer): Promise<any> {
+    for (const actionHandler of pluginActionHandlers) {
+      server.registerActionHandler(this, actionHandler);
+    }
+  }
+
+  async configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    server.appendApplicationConfig({ models: pluginModels });
+  }
+
+  async configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any> {
+    server.appendApplicationConfig({ routes: pluginRoutes });
+  }
+
+  async onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig) {
+    const models = server.getApplicationConfig().models;
+    for (const model of models) {
+      for (const property of model.properties) {
+        const propertyStateMachineConfig: PropertyStateMachineConfig = property.config?.stateMachine;
+        if (propertyStateMachineConfig) {
+          const stateMachineCode = getStateMachineCode(model, property);
+          const stateMachineConfig = propertyStateMachineConfig.config;
+
+          const stateMachineDataAccessor = server.getDataAccessor({
+            singularCode: "state_machine",
+          });
+          const stateMachine = await stateMachineDataAccessor.findOne({
+            filters: [
+              {
+                operator: "eq",
+                field: "code",
+                value: stateMachineCode,
+              },
+            ],
+          });
+
+          if (stateMachine) {
+            if (!isEqual(stateMachine.config, stateMachineConfig)) {
+              await stateMachineDataAccessor.updateById(stateMachine.id, {
+                config: stateMachineConfig,
+              });
+            }
+          } else {
+            await stateMachineDataAccessor.create({
+              code: stateMachineCode,
+              config: stateMachineConfig,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  /**
+   * 创建实体前的处理。
+   * 当属性启用了状态机管理，如创建实体时没有指定该属性的状态值，则应将该属性设置为 stateMachine.config.initial 。
+   * @param server 
+   * @param model 
+   * @param options 
+   */
+  async beforeCreateEntity(server: IRpdServer, model: RpdDataModel, options: CreateEntityOptions) {
+    for (const property of model.properties) {
+      const isStateMachineEnabled = get(property.config, "stateMachine.enabled", false);
+      if (isStateMachineEnabled && isNullOrUndefined(options.entity[property.code])
+      ) {
+        const initialState = get(property.config, "stateMachine.config.initial", null);
+        if (initialState) {
+          options.entity[property.code] = initialState;
+        }
+      }
+    }
+  }
+
+  /**
+   * 更新实体前的处理。
+   * 1. 对所有启用了状态机管理，且 transferControl 为 true 的属性，应禁止直接更新这些属性
+   * 2. 当更新实体时指定了operation，则查找启用了状态机管理的属性。
+   * 如果一个模型中存在多个属性启用了状态机管理，则以 options.stateProperty 中指定的为准。
+   * 对于该状态属性应用 options.operation，使其转换到下一状态。
+   * @param server 
+   * @param model 
+   * @param options 
+   */
+  async beforeUpdateEntity(server: IRpdServer, model: RpdDataModel, options: UpdateEntityByIdOptions, currentEntity: any) {
+    const entity = options.entityToSave;
+
+    for (const property of model.properties) {
+      const isStateMachineEnabled = get(property.config, "stateMachine.enabled", false);
+      const isTransferControlEnabled = get(property.config, "stateMachine.transferControl", false);
+      if (isStateMachineEnabled && isTransferControlEnabled && !isNullOrUndefined(entity[property.code])
+      ) {
+        throw new Error(`You're not allowed to change '${property.code}' property directly when transfer control is enabled, do an operation instead.`);
+      }
+    }
+
+    if (!options.operation) {
+      return;
+    }
+
+    const stateMachineEnabledProperties = filter(model.properties, (property) => get(property.config, "stateMachine.enabled", false)) as RpdDataModelProperty[];
+    let stateMachineEnabledProperty = first(stateMachineEnabledProperties);
+    if (options.stateProperty) {
+      stateMachineEnabledProperty = find(stateMachineEnabledProperties, (property) => property.code === options.stateProperty);
+    }
+
+    if (!stateMachineEnabledProperty) {
+      throw new Error(`State machine property not found.`);
+    }
+
+    const machineConfig = get(stateMachineEnabledProperty.config, "stateMachine.config", null);
+    if (!machineConfig) {
+      throw new Error(`State machine of property '${stateMachineEnabledProperty.code}' not configured.`);
+    }
+    machineConfig.id = getStateMachineCode(model, stateMachineEnabledProperty);
+
+    const nextSnapshot = await getStateMachineNextSnapshot(server, {
+      machineConfig,
+      context: {},
+      currentState: currentEntity[stateMachineEnabledProperty.code],
+      event: options.operation,
+    });
+
+    entity[stateMachineEnabledProperty.code] = nextSnapshot.value;
+  }
+
+}
+
+function getStateMachineCode(model: RpdDataModel, property: RpdDataModelProperty) {
+  return `propertyStateMachine.${model.namespace}.${model.singularCode}.${property.code}`;
+}
+
+export default StateMachinePlugin;

package/src/plugins/stateMachine/StateMachinePluginTypes.ts

@@ -0,0 +1,30 @@
+import { MachineConfig } from "xstate";
+
+
+export type PropertyStateMachineConfig = {
+  enabled: boolean;
+  config: MachineConfig<any, any>;
+  transferControl?: boolean;
+}
+
+export type SendStateMachineEventOptions = {
+  code: string;
+}
+
+export type SendStateMachineEventInput = {
+  code?: string;
+  context: any;
+  currentState: string;
+  event: StateMachineEvent;
+}
+
+export type StateMachineEvent = {
+  type: string;
+}
+
+export type GetStateMachineNextSnapshotOptions = {
+  machineConfig: MachineConfig<any, any>;
+  context: any;
+  currentState: string;
+  event: StateMachineEvent;
+}

package/src/plugins/stateMachine/StateMachineService.ts

@@ -0,0 +1,19 @@
+import { IRpdServer } from "~/core/server";
+import { GetStateMachineNextSnapshotOptions } from "./StateMachinePluginTypes";
+import { createMachine, getInitialSnapshot, getNextSnapshot } from "xstate";
+
+export async function getStateMachineNextSnapshot(server: IRpdServer, options: GetStateMachineNextSnapshotOptions) {
+  debugger
+  const { machineConfig, currentState, event } = options;
+  machineConfig.initial = currentState;
+
+  const machine = createMachine(machineConfig);
+  const snapshot = getInitialSnapshot(machine);
+
+  if (!snapshot.can(event)) {
+    throw new Error(`'${event.type}' action is not allowed at '${currentState}' state.`);
+  }
+
+  const nextSnapshot = getNextSnapshot(machine, snapshot, event);
+  return nextSnapshot;
+}

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

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

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

@@ -0,0 +1,55 @@
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+import { SendStateMachineEventInput, SendStateMachineEventOptions } from "../StateMachinePluginTypes";
+import { getStateMachineNextSnapshot } from "../StateMachineService";
+
+export const code = "sendStateMachineEvent";
+
+export async function handler(
+  plugin: RapidPlugin,
+  ctx: ActionHandlerContext,
+  options: SendStateMachineEventOptions,
+) {
+  const { server, routerContext } = ctx;
+  const { response } = routerContext;
+
+  const input: SendStateMachineEventInput = ctx.input;
+  if (options?.code) {
+    input.code = options.code;
+  }
+
+  if (!input.code) {
+    throw new Error(`State machine code is required when sending event.`);
+  }
+
+  const stateMachineDataAccessor = server.getDataAccessor({
+    singularCode: "state_machine",
+  });
+
+  const stateMachine = await stateMachineDataAccessor.findOne({
+    filters: [
+      {
+        operator: "eq",
+        field: "code",
+        value: input.code,
+      }
+    ]
+  });
+
+  if (!stateMachine) {
+    throw new Error(`State machine with code '${input.code}' was not found.`);
+  }
+
+  stateMachine.config.id = input.code;
+
+  const snapshot = await getStateMachineNextSnapshot(server, {
+    machineConfig: stateMachine.config,
+    context: input.context,
+    currentState: input.currentState,
+    event: input.event,
+  });
+
+  response.json({
+    state: snapshot.value,
+  });
+}

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

@@ -0,0 +1,42 @@
+import { RpdDataModel } from "~/types";
+
+export default     {
+  maintainedBy: "stateMachinePlugin",
+  namespace: "svc",
+  name: "state_machine",
+  singularCode: "state_machine",
+  pluralCode: "state_machines",
+  schema: "public",
+  tableName: "state_machines",
+  properties: [
+    {
+      name: "id",
+      code: "id",
+      columnName: "id",
+      type: "integer",
+      required: true,
+      autoIncrement: true,
+    },
+    {
+      name: "code",
+      code: "code",
+      columnName: "code",
+      type: "text",
+      required: true,
+    },
+    {
+      name: "description",
+      code: "description",
+      columnName: "description",
+      type: "text",
+      required: false,
+    },
+    {
+      name: "config",
+      code: "config",
+      columnName: "config",
+      type: "json",
+      required: false,
+    },
+  ],
+} as RpdDataModel;

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

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

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

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

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

@@ -0,0 +1,15 @@
+import { RpdRoute } from "~/types";
+
+export default {
+  namespace: "svc",
+  name: "svc.sendStateMachineEvent",
+  code: "svc.sendStateMachineEvent",
+  type: "RESTful",
+  method: "POST",
+  endpoint: "/svc/sendStateMachineEvent",
+  actions: [
+    {
+      code: "sendStateMachineEvent",
+    },
+  ],
+} satisfies RpdRoute;

package/src/server.ts

@@ -12,6 +12,7 @@ import {
   RapidServerConfig,
   RpdDataModelProperty,
   CreateEntityOptions,
+  UpdateEntityByIdOptions,
 } from "./types";
 
 import QueryBuilder from "./queryBuilder/queryBuilder";
@@ -335,4 +336,8 @@ export class RapidServer implements IRpdServer {
   async beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions) {
     await this.#pluginManager.beforeCreateEntity(model, options);
   }
+  
+  async beforeUpdateEntity(model: RpdDataModel, options: UpdateEntityByIdOptions, currentEntity: any) {
+    await this.#pluginManager.beforeUpdateEntity(model, options, currentEntity);
+  }
 }

package/src/types.ts

@@ -451,6 +451,8 @@ export interface UpdateEntityOptions {
 export interface UpdateEntityByIdOptions {
   id: any;
   entityToSave: any;
+  operation?: any;
+  stateProperty?: string;
 }
 
 export interface DeleteEntityOptions {
@@ -468,65 +470,3 @@ export interface RemoveEntityRelationsOptions {
   property: string;
   relations: {id?: number, [k: string]: any}[];
 }
-
-
-export type SequenceSegmentConfig =
-  | SequenceLiteralSegmentConfig
-  | SequenceYearSegmentConfig
-  | SequenceMonthSegmentConfig
-  | SequenceDayOfMonthSegmentConfig
-  | SequenceDayOfWeekSegmentConfig
-  | SequenceDayOfYearSegmentConfig
-  | SequenceParameterSegmentConfig
-  | SequenceAutoIncrementSegmentConfig
-  ;
-
-export type SequenceLiteralSegmentConfig = {
-  type: "literal",
-  content: string;
-}
-
-export type SequenceYearSegmentConfig = {
-  type: "year",
-  padding?: string;
-  length?: number;
-}
-
-export type SequenceMonthSegmentConfig = {
-  type: "month",
-  padding?: string;
-  length?: number;
-}
-
-export type SequenceDayOfMonthSegmentConfig = {
-  type: "dayOfMonth",
-  padding?: string;
-  length?: number;
-}
-
-export type SequenceDayOfWeekSegmentConfig = {
-  type: "dayOfWeek",
-  padding?: string;
-  length?: number;
-}
-
-export type SequenceDayOfYearSegmentConfig = {
-  type: "dayOfYear",
-  padding?: string;
-  length?: number;
-}
-
-export type SequenceParameterSegmentConfig = {
-  type: "parameter",
-  parameterName: string;
-  padding?: string;
-  length?: number;
-}
-
-export type SequenceAutoIncrementSegmentConfig = {
-  type: "autoIncrement",
-  scope: string;
-  period: "forever" | "day" | "month" | "year";
-  padding?: string;
-  length?: number;
-}

package/dist/plugins/sequence/sequence-types.d.ts

@@ -1,8 +0,0 @@
-import { SequenceSegmentConfig } from "../../types";
-export type PropertySequenceConfig = {
-    autoGenerate: boolean;
-    ruleConfig: SequenceRuleConfig;
-};
-export type SequenceRuleConfig = {
-    segments: SequenceSegmentConfig[];
-};

package/src/plugins/sequence/sequence-types.ts

@@ -1,10 +0,0 @@
-import { SequenceSegmentConfig } from "~/types";
-
-export type PropertySequenceConfig = {
-  autoGenerate: boolean;
-  ruleConfig: SequenceRuleConfig;
-}
-
-export type SequenceRuleConfig = {
-  segments: SequenceSegmentConfig[];
-}