@ruiapp/rapid-core 0.1.29 → 0.1.31

package/dist/index.js

@@ -13,6 +13,7 @@ var bcrypt = require('bcrypt');
 var path = require('path');
 var fs = require('fs');
 var uuid = require('uuid');
+var xstate = require('xstate');
 
 function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
 
@@ -557,6 +558,14 @@ class PluginManager {
             }
         }
     }
+    /** 在更新实体前调用。 */
+    async beforeUpdateEntity(model, options, currentEntity) {
+        for (const plugin of this.#plugins) {
+            if (plugin.beforeUpdateEntity) {
+                await plugin.beforeUpdateEntity(this.#server, model, options, currentEntity);
+            }
+        }
+    }
 }
 
 class EventManager {
@@ -2153,10 +2162,13 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     if (!entity) {
         throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
     }
-    const changes = getEntityPartChanges(entity, entityToSave);
-    if (!changes) {
+    let changes = getEntityPartChanges(entity, entityToSave);
+    if (!changes && !options.operation) {
         return entity;
     }
+    options.entityToSave = changes || {};
+    await server.beforeUpdateEntity(model, options, entity);
+    changes = options.entityToSave;
     const oneRelationPropertiesToUpdate = [];
     const manyRelationPropertiesToUpdate = [];
     lodash.keys(changes).forEach((propertyCode) => {
@@ -2635,6 +2647,9 @@ class RapidServer {
     async beforeCreateEntity(model, options) {
         await this.#pluginManager.beforeCreateEntity(model, options);
     }
+    async beforeUpdateEntity(model, options, currentEntity) {
+        await this.#pluginManager.beforeUpdateEntity(model, options, currentEntity);
+    }
 }
 
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
@@ -2784,32 +2799,32 @@ async function generateJwtSecretKey() {
     return encode(exportedKey);
 }
 
-const code$n = "listMetaModels";
-async function handler$n(plugin, ctx, options) {
+const code$o = "listMetaModels";
+async function handler$o(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$n,
-  handler: handler$n
+  code: code$o,
+  handler: handler$o
 });
 
-const code$m = "listMetaRoutes";
-async function handler$m(plugin, ctx, options) {
+const code$n = "listMetaRoutes";
+async function handler$n(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$m,
-  handler: handler$m
+  code: code$n,
+  handler: handler$n
 });
 
-const code$l = "getMetaModelDetail";
-async function handler$l(plugin, ctx, options) {
+const code$m = "getMetaModelDetail";
+async function handler$m(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -2817,8 +2832,8 @@ async function handler$l(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$l,
-  handler: handler$l
+  code: code$m,
+  handler: handler$m
 });
 
 /**
@@ -3170,9 +3185,9 @@ function transformFilterWithSubFilters(filter) {
     return filter;
 }
 
-const code$k = "findCollectionEntities";
-async function handler$k(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$k, async (entityManager, input) => {
+const code$l = "findCollectionEntities";
+async function handler$l(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$l, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         const entities = await entityManager.findEntities(input);
         const result = { list: entities };
@@ -3187,14 +3202,14 @@ async function handler$k(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$k,
-  handler: handler$k
+  code: code$l,
+  handler: handler$l
 });
 
-const code$j = "findCollectionEntityById";
-async function handler$j(plugin, ctx, options) {
+const code$k = "findCollectionEntityById";
+async function handler$k(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$j} handler...`, { input });
+    logger.debug(`Running ${code$k} handler...`, { input });
     const { id } = input;
     const entityManager = server.getEntityManager(options.singularCode);
     const entity = await entityManager.findById(id);
@@ -3206,13 +3221,13 @@ async function handler$j(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$j,
-  handler: handler$j
+  code: code$k,
+  handler: handler$k
 });
 
-const code$i = "countCollectionEntities";
-async function handler$i(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$i, (entityManager, input) => {
+const code$j = "countCollectionEntities";
+async function handler$j(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$j, (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         return entityManager.count(input);
     });
@@ -3220,16 +3235,16 @@ async function handler$i(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$i,
-  handler: handler$i
+  code: code$j,
+  handler: handler$j
 });
 
-const code$h = "createCollectionEntity";
-async function handler$h(plugin, ctx, options) {
+const code$i = "createCollectionEntity";
+async function handler$i(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$h} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$i} handler...`, { defaultInput, fixedInput, mergedInput });
     const userId = ctx.routerContext.state?.userId;
     if (userId) {
         input.createdBy = userId;
@@ -3243,15 +3258,15 @@ async function handler$h(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$h,
-  handler: handler$h
+  code: code$i,
+  handler: handler$i
 });
 
-const code$g = "createCollectionEntitiesBatch";
-async function handler$g(plugin, ctx, options) {
+const code$h = "createCollectionEntitiesBatch";
+async function handler$h(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    logger.debug(`Running ${code$g} handler...`, { defaultInput, fixedInput, input });
+    logger.debug(`Running ${code$h} handler...`, { defaultInput, fixedInput, input });
     const { entities } = input;
     if (!lodash.isArray(entities)) {
         throw new Error("input.entities should be an array.");
@@ -3274,31 +3289,35 @@ async function handler$g(plugin, ctx, options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$g,
-  handler: handler$g
+  code: code$h,
+  handler: handler$h
 });
 
-const code$f = "updateCollectionEntityById";
-async function handler$f(plugin, ctx, options) {
+const code$g = "updateCollectionEntityById";
+async function handler$g(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$f} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$g} handler...`, { defaultInput, fixedInput, mergedInput });
+    const operation = mergedInput.$operation;
+    if (operation) {
+        delete mergedInput.$operation;
+    }
     const entityManager = server.getEntityManager(options.singularCode);
-    const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput }, plugin);
+    const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput, operation }, plugin);
     ctx.output = output;
 }
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$f,
-  handler: handler$f
+  code: code$g,
+  handler: handler$g
 });
 
-const code$e = "deleteCollectionEntityById";
-async function handler$e(plugin, ctx, options) {
+const code$f = "deleteCollectionEntityById";
+async function handler$f(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$e} handler...`);
+    logger.debug(`Running ${code$f} handler...`);
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.deleteById(input.id, plugin);
     ctx.status = 200;
@@ -3307,16 +3326,16 @@ async function handler$e(plugin, ctx, options) {
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$e,
-  handler: handler$e
+  code: code$f,
+  handler: handler$f
 });
 
-const code$d = "addEntityRelations";
-async function handler$d(plugin, ctx, options) {
+const code$e = "addEntityRelations";
+async function handler$e(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$d} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$e} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.addRelations(mergedInput, plugin);
     ctx.output = {};
@@ -3324,16 +3343,16 @@ async function handler$d(plugin, ctx, options) {
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$d,
-  handler: handler$d
+  code: code$e,
+  handler: handler$e
 });
 
-const code$c = "removeEntityRelations";
-async function handler$c(plugin, ctx, options) {
+const code$d = "removeEntityRelations";
+async function handler$d(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$c} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$d} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.removeRelations(mergedInput, plugin);
     ctx.output = {};
@@ -3341,16 +3360,16 @@ async function handler$c(plugin, ctx, options) {
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$c,
-  handler: handler$c
+  code: code$d,
+  handler: handler$d
 });
 
-const code$b = "queryDatabase";
-async function handler$b(plugin, ctx, options) {
+const code$c = "queryDatabase";
+async function handler$c(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$b} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$c} handler...`, { defaultInput, fixedInput, mergedInput });
     const result = await server.queryDatabaseObject(sql, mergedInput);
     if (querySingle) {
         ctx.output = lodash.first(result);
@@ -3362,8 +3381,8 @@ async function handler$b(plugin, ctx, options) {
 
 var queryDatabase = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$b,
-  handler: handler$b
+  code: code$c,
+  handler: handler$c
 });
 
 /**
@@ -3534,17 +3553,17 @@ async function sendSourceResponse(proxyCtx, targetRes) {
     srcRes.body = targetRes.body;
 }
 
-const code$a = "httpProxy";
-async function handler$a(plugin, ctx, options) {
+const code$b = "httpProxy";
+async function handler$b(plugin, ctx, options) {
     const { logger } = ctx;
-    logger.debug(`Running ${code$a} handler...`);
+    logger.debug(`Running ${code$b} handler...`);
     await doProxy(ctx.routerContext, options);
 }
 
 var httpProxy = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$a,
-  handler: handler$a
+  code: code$b,
+  handler: handler$b
 });
 
 /**
@@ -3783,8 +3802,8 @@ async function generateSn$2(server, input) {
     return sequenceNumbers;
 }
 
-const code$9 = "generateSn";
-async function handler$9(plugin, ctx, options) {
+const code$a = "generateSn";
+async function handler$a(plugin, ctx, options) {
     const { server, routerContext } = ctx;
     const input = ctx.input;
     if (options?.ruleCode) {
@@ -3801,11 +3820,11 @@ async function handler$9(plugin, ctx, options) {
 
 var generateSn$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$9,
-  handler: handler$9
+  code: code$a,
+  handler: handler$a
 });
 
-var pluginActionHandlers$2 = [
+var pluginActionHandlers$3 = [
     generateSn$1,
 ];
 
@@ -3898,7 +3917,7 @@ var SequenceAutoIncrementRecord = {
     ],
 };
 
-var pluginModels$1 = [
+var pluginModels$2 = [
     SequenceRule,
     SequenceAutoIncrementRecord,
 ];
@@ -3917,7 +3936,7 @@ var generateSn = {
     ],
 };
 
-var pluginRoutes$2 = [
+var pluginRoutes$3 = [
     generateSn,
 ];
 
@@ -3941,24 +3960,24 @@ class SequencePlugin {
         return [];
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$2) {
+        for (const actionHandler of pluginActionHandlers$3) {
             server.registerActionHandler(this, actionHandler);
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels$1 });
+        server.appendApplicationConfig({ models: pluginModels$2 });
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$2 });
+        server.appendApplicationConfig({ routes: pluginRoutes$3 });
     }
     async onApplicationLoaded(server, applicationConfig) {
         const models = server.getApplicationConfig().models;
         for (const model of models) {
             for (const property of model.properties) {
-                const sequenceConfig = property.config?.sequence;
-                if (sequenceConfig) {
+                const propertySequenceConfig = property.config?.sequence;
+                if (propertySequenceConfig) {
                     const ruleCode = getSequenceRuleCode(model, property);
-                    const ruleConfig = sequenceConfig.ruleConfig;
+                    const ruleConfig = propertySequenceConfig.config;
                     const sequenceRuleDataAccessor = server.getDataAccessor({
                         singularCode: "sequence_rule",
                     });
@@ -3972,7 +3991,7 @@ class SequencePlugin {
                         ],
                     });
                     if (sequenceRule) {
-                        if (JSON.stringify(sequenceRule.config) !== JSON.stringify(ruleConfig)) {
+                        if (lodash.isEqual(sequenceRule.config, ruleConfig)) {
                             await sequenceRuleDataAccessor.updateById(sequenceRule.id, {
                                 config: ruleConfig,
                             });
@@ -3989,21 +4008,20 @@ class SequencePlugin {
         }
     }
     async beforeCreateEntity(server, model, options) {
-        debugger;
         const entity = options.entity;
         for (const property of model.properties) {
             const sequenceConfig = property.config?.sequence;
             const propertyValue = entity[property.code];
             if (sequenceConfig &&
-                sequenceConfig.autoGenerate &&
-                (lodash.isUndefined(propertyValue) || lodash.isNull(propertyValue))) {
+                sequenceConfig.enabled &&
+                isNullOrUndefined(propertyValue)) {
                 const ruleCode = getSequenceRuleCode(model, property);
-                const sns = await generateSn$2(server, {
+                const numbers = await generateSn$2(server, {
                     ruleCode,
                     amount: 1,
                     parameters: entity,
                 });
-                entity[property.code] = sns[0];
+                entity[property.code] = numbers[0];
             }
         }
     }
@@ -4192,8 +4210,8 @@ class WebhooksPlugin {
     }
 }
 
-const code$8 = "changePassword";
-async function handler$8(plugin, ctx, options) {
+const code$9 = "changePassword";
+async function handler$9(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { id, oldPassword, newPassword } = input;
     const userId = routerContext.state.userId;
@@ -4235,12 +4253,12 @@ async function handler$8(plugin, ctx, options) {
 
 var changePassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$8,
-  handler: handler$8
+  code: code$9,
+  handler: handler$9
 });
 
-const code$7 = "createSession";
-async function handler$7(plugin, ctx, options) {
+const code$8 = "createSession";
+async function handler$8(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     const { account, password } = input;
@@ -4283,12 +4301,12 @@ async function handler$7(plugin, ctx, options) {
 
 var createSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$7,
-  handler: handler$7
+  code: code$8,
+  handler: handler$8
 });
 
-const code$6 = "deleteSession";
-async function handler$6(plugin, ctx, options) {
+const code$7 = "deleteSession";
+async function handler$7(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { response } = routerContext;
     setCookie(response.headers, {
@@ -4301,12 +4319,12 @@ async function handler$6(plugin, ctx, options) {
 
 var deleteSession = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$6,
-  handler: handler$6
+  code: code$7,
+  handler: handler$7
 });
 
-const code$5 = "getMyProfile";
-async function handler$5(plugin, ctx, options) {
+const code$6 = "getMyProfile";
+async function handler$6(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const userId = routerContext.state.userId;
     if (!userId) {
@@ -4336,12 +4354,12 @@ async function handler$5(plugin, ctx, options) {
 
 var getMyProfile$2 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$5,
-  handler: handler$5
+  code: code$6,
+  handler: handler$6
 });
 
-const code$4 = "resetPassword";
-async function handler$4(plugin, ctx, options) {
+const code$5 = "resetPassword";
+async function handler$5(plugin, ctx, options) {
     const { server, input, routerContext } = ctx;
     const { userId, password } = input;
     const userDataAccessor = server.getDataAccessor({
@@ -4369,11 +4387,11 @@ async function handler$4(plugin, ctx, options) {
 
 var resetPassword$1 = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$4,
-  handler: handler$4
+  code: code$5,
+  handler: handler$5
 });
 
-var pluginActionHandlers$1 = [
+var pluginActionHandlers$2 = [
     changePassword$1,
     createSession,
     deleteSession,
@@ -4436,7 +4454,7 @@ var AccessToken = {
     ],
 };
 
-var pluginModels = [
+var pluginModels$1 = [
     AccessToken,
 ];
 
@@ -4510,7 +4528,7 @@ var signout$1 = {
     ],
 };
 
-var pluginRoutes$1 = [
+var pluginRoutes$2 = [
     changePassword,
     getMyProfile$1,
     resetPassword,
@@ -4538,15 +4556,15 @@ class AuthPlugin {
         return [];
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers$1) {
+        for (const actionHandler of pluginActionHandlers$2) {
             server.registerActionHandler(this, actionHandler);
         }
     }
     async configureModels(server, applicationConfig) {
-        server.appendApplicationConfig({ models: pluginModels });
+        server.appendApplicationConfig({ models: pluginModels$1 });
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes$1 });
+        server.appendApplicationConfig({ routes: pluginRoutes$2 });
     }
     async onPrepareRouteContext(server, routeContext) {
         const request = routeContext.request;
@@ -4602,8 +4620,8 @@ async function appendFile(path, data) {
     });
 }
 
-const code$3 = "downloadDocument";
-async function handler$3(plugin, ctx, options) {
+const code$4 = "downloadDocument";
+async function handler$4(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const documentDataAccessor = ctx.server.getDataAccessor({
@@ -4631,12 +4649,12 @@ async function handler$3(plugin, ctx, options) {
 
 var downloadDocumentActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$3,
-  handler: handler$3
+  code: code$4,
+  handler: handler$4
 });
 
-const code$2 = "downloadFile";
-async function handler$2(plugin, ctx, options) {
+const code$3 = "downloadFile";
+async function handler$3(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     const { request, response } = routerContext;
     const dataAccessor = ctx.server.getDataAccessor({
@@ -4656,12 +4674,12 @@ async function handler$2(plugin, ctx, options) {
 
 var downloadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$2,
-  handler: handler$2
+  code: code$3,
+  handler: handler$3
 });
 
-const code$1 = "uploadFile";
-async function handler$1(plugin, ctx, options) {
+const code$2 = "uploadFile";
+async function handler$2(plugin, ctx, options) {
     const { server, applicationConfig, routerContext, input } = ctx;
     let file = input.file || input.files;
     if (lodash.isArray(file)) {
@@ -4682,8 +4700,8 @@ async function handler$1(plugin, ctx, options) {
 
 var uploadFileActionHandler = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$1,
-  handler: handler$1
+  code: code$2,
+  handler: handler$2
 });
 
 var getMyProfile = {
@@ -4728,7 +4746,7 @@ var signout = {
     ],
 };
 
-var pluginRoutes = [
+var pluginRoutes$1 = [
     getMyProfile,
     signin,
     signout,
@@ -4759,23 +4777,23 @@ class FileManager {
         server.registerActionHandler(this, uploadFileActionHandler);
     }
     async configureRoutes(server, applicationConfig) {
-        server.appendApplicationConfig({ routes: pluginRoutes });
+        server.appendApplicationConfig({ routes: pluginRoutes$1 });
     }
 }
 
-const code = "runServerOperation";
-async function handler(plugin, ctx, options) {
+const code$1 = "runServerOperation";
+async function handler$1(plugin, ctx, options) {
     const { operation } = options;
     await operation(ctx);
 }
 
 var runServerOperation = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code,
-  handler: handler
+  code: code$1,
+  handler: handler$1
 });
 
-var pluginActionHandlers = [
+var pluginActionHandlers$1 = [
     runServerOperation,
 ];
 
@@ -4804,7 +4822,7 @@ class ServerOperationPlugin {
     async registerMiddlewares(server) {
     }
     async registerActionHandlers(server) {
-        for (const actionHandler of pluginActionHandlers) {
+        for (const actionHandler of pluginActionHandlers$1) {
             server.registerActionHandler(this, actionHandler);
         }
     }
@@ -4848,6 +4866,263 @@ class ServerOperationPlugin {
     }
 }
 
+async function getStateMachineNextSnapshot(server, options) {
+    debugger;
+    const { machineConfig, currentState, event } = options;
+    machineConfig.initial = currentState;
+    const machine = xstate.createMachine(machineConfig);
+    const snapshot = xstate.getInitialSnapshot(machine);
+    if (!snapshot.can(event)) {
+        throw new Error(`'${event.type}' action is not allowed at '${currentState}' state.`);
+    }
+    const nextSnapshot = xstate.getNextSnapshot(machine, snapshot, event);
+    return nextSnapshot;
+}
+
+const code = "sendStateMachineEvent";
+async function handler(plugin, ctx, options) {
+    const { server, routerContext } = ctx;
+    const { response } = routerContext;
+    const input = 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,
+    });
+}
+
+var sendStateMachineEvent$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code,
+  handler: handler
+});
+
+var pluginActionHandlers = [
+    sendStateMachineEvent$1,
+];
+
+var StateMachine = {
+    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,
+        },
+    ],
+};
+
+var pluginModels = [
+    StateMachine,
+];
+
+var sendStateMachineEvent = {
+    namespace: "svc",
+    name: "svc.sendStateMachineEvent",
+    code: "svc.sendStateMachineEvent",
+    type: "RESTful",
+    method: "POST",
+    endpoint: "/svc/sendStateMachineEvent",
+    actions: [
+        {
+            code: "sendStateMachineEvent",
+        },
+    ],
+};
+
+var pluginRoutes = [
+    sendStateMachineEvent,
+];
+
+/**
+ * State machine plugin
+ */
+class StateMachinePlugin {
+    get code() {
+        return "stateMachinePlugin";
+    }
+    get description() {
+        return null;
+    }
+    get extendingAbilities() {
+        return [];
+    }
+    get configurableTargets() {
+        return [];
+    }
+    get configurations() {
+        return [];
+    }
+    async registerActionHandlers(server) {
+        for (const actionHandler of pluginActionHandlers) {
+            server.registerActionHandler(this, actionHandler);
+        }
+    }
+    async configureModels(server, applicationConfig) {
+        server.appendApplicationConfig({ models: pluginModels });
+    }
+    async configureRoutes(server, applicationConfig) {
+        server.appendApplicationConfig({ routes: pluginRoutes });
+    }
+    async onApplicationLoaded(server, applicationConfig) {
+        const models = server.getApplicationConfig().models;
+        for (const model of models) {
+            for (const property of model.properties) {
+                const 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 (!lodash.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, model, options) {
+        for (const property of model.properties) {
+            const isStateMachineEnabled = lodash.get(property.config, "stateMachine.enabled", false);
+            if (isStateMachineEnabled && isNullOrUndefined(options.entity[property.code])) {
+                const initialState = lodash.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, model, options, currentEntity) {
+        const entity = options.entityToSave;
+        for (const property of model.properties) {
+            const isStateMachineEnabled = lodash.get(property.config, "stateMachine.enabled", false);
+            const isTransferControlEnabled = lodash.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 = lodash.filter(model.properties, (property) => lodash.get(property.config, "stateMachine.enabled", false));
+        let stateMachineEnabledProperty = lodash.first(stateMachineEnabledProperties);
+        if (options.stateProperty) {
+            stateMachineEnabledProperty = lodash.find(stateMachineEnabledProperties, (property) => property.code === options.stateProperty);
+        }
+        if (!stateMachineEnabledProperty) {
+            throw new Error(`State machine property not found.`);
+        }
+        const machineConfig = lodash.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, property) {
+    return `propertyStateMachine.${model.namespace}.${model.singularCode}.${property.code}`;
+}
+
 class EntityWatchPlugin {
     #createEventEmitters;
     #updateEventEmitters;
@@ -5048,6 +5323,7 @@ exports.RouteContext = RouteContext;
 exports.RouteManagePlugin = RouteManager;
 exports.SequencePlugin = SequencePlugin;
 exports.ServerOperationPlugin = ServerOperationPlugin;
+exports.StateMachinePlugin = StateMachinePlugin;
 exports.WebhooksPlugin = WebhooksPlugin;
 exports.bootstrapApplicationConfig = bootstrapApplicationConfig$1;
 exports.createJwt = createJwt;