@ruiapp/rapid-core 0.1.26 → 0.1.27

package/dist/index.js

@@ -8,6 +8,7 @@ var Router = require('koa-tree-router');
 var qs = require('qs');
 var jsonwebtoken = require('jsonwebtoken');
 var crypto = require('crypto');
+var dayjs = require('dayjs');
 var path = require('path');
 var fs = require('fs');
 var uuid = require('uuid');
@@ -17,6 +18,7 @@ function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'defau
 var Router__default = /*#__PURE__*/_interopDefaultLegacy(Router);
 var qs__default = /*#__PURE__*/_interopDefaultLegacy(qs);
 var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
+var dayjs__default = /*#__PURE__*/_interopDefaultLegacy(dayjs);
 var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
 var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
 
@@ -545,6 +547,14 @@ class PluginManager {
             }
         }
     }
+    /** 在创建实体前调用。 */
+    async beforeCreateEntity(model, options) {
+        for (const plugin of this.#plugins) {
+            if (plugin.beforeCreateEntity) {
+                await plugin.beforeCreateEntity(this.#server, model, options);
+            }
+        }
+    }
 }
 
 class EventManager {
@@ -672,6 +682,7 @@ class RapidResponse {
     }
     json(obj, status, headers) {
         const body = JSON.stringify(obj);
+        this.headers.set("Content-Type", "application/json");
         const responseHeaders = new Headers(this.headers);
         if (headers) {
             mergeHeaders(responseHeaders, headers);
@@ -2280,6 +2291,7 @@ class EntityManager {
     }
     async createEntity(options, plugin) {
         const model = this.getModel();
+        await this.#server.beforeCreateEntity(model, options);
         const newEntity = await createEntity(this.#server, this.#dataAccessor, options);
         this.#server.emitEvent("entity.create", {
             namespace: model.namespace,
@@ -2608,6 +2620,9 @@ class RapidServer {
     async beforeRunRouteActions(handlerContext) {
         await this.#pluginManager.beforeRunRouteActions(handlerContext);
     }
+    async beforeCreateEntity(model, options) {
+        await this.#pluginManager.beforeCreateEntity(model, options);
+    }
 }
 
 // Copyright 2018-2023 the Deno authors. All rights reserved. MIT license.
@@ -2757,32 +2772,32 @@ async function generateJwtSecretKey() {
     return encode(exportedKey);
 }
 
-const code$k = "listMetaModels";
-async function handler$k(plugin, ctx, options) {
+const code$l = "listMetaModels";
+async function handler$l(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.models };
 }
 
 var listMetaModels = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$k,
-  handler: handler$k
+  code: code$l,
+  handler: handler$l
 });
 
-const code$j = "listMetaRoutes";
-async function handler$j(plugin, ctx, options) {
+const code$k = "listMetaRoutes";
+async function handler$k(plugin, ctx, options) {
     const { applicationConfig } = ctx;
     ctx.output = { list: applicationConfig.routes };
 }
 
 var listMetaRoutes = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$j,
-  handler: handler$j
+  code: code$k,
+  handler: handler$k
 });
 
-const code$i = "getMetaModelDetail";
-async function handler$i(plugin, ctx, options) {
+const code$j = "getMetaModelDetail";
+async function handler$j(plugin, ctx, options) {
     const { server, input } = ctx;
     const model = server.getModel(input);
     ctx.output = model;
@@ -2790,8 +2805,8 @@ async function handler$i(plugin, ctx, options) {
 
 var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$i,
-  handler: handler$i
+  code: code$j,
+  handler: handler$j
 });
 
 /**
@@ -3143,9 +3158,9 @@ function transformFilterWithSubFilters(filter) {
     return filter;
 }
 
-const code$h = "findCollectionEntities";
-async function handler$h(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$h, async (entityManager, input) => {
+const code$i = "findCollectionEntities";
+async function handler$i(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$i, async (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         const entities = await entityManager.findEntities(input);
         const result = { list: entities };
@@ -3160,14 +3175,14 @@ async function handler$h(plugin, ctx, options) {
 
 var findCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$h,
-  handler: handler$h
+  code: code$i,
+  handler: handler$i
 });
 
-const code$g = "findCollectionEntityById";
-async function handler$g(plugin, ctx, options) {
+const code$h = "findCollectionEntityById";
+async function handler$h(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$g} handler...`, { input });
+    logger.debug(`Running ${code$h} handler...`, { input });
     const { id } = input;
     const entityManager = server.getEntityManager(options.singularCode);
     const entity = await entityManager.findById(id);
@@ -3179,13 +3194,13 @@ async function handler$g(plugin, ctx, options) {
 
 var findCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$g,
-  handler: handler$g
+  code: code$h,
+  handler: handler$h
 });
 
-const code$f = "countCollectionEntities";
-async function handler$f(plugin, ctx, options) {
-    await runCollectionEntityActionHandler(ctx, options, code$f, (entityManager, input) => {
+const code$g = "countCollectionEntities";
+async function handler$g(plugin, ctx, options) {
+    await runCollectionEntityActionHandler(ctx, options, code$g, (entityManager, input) => {
         input.filters = removeFiltersWithNullValue(input.filters);
         return entityManager.count(input);
     });
@@ -3193,16 +3208,16 @@ async function handler$f(plugin, ctx, options) {
 
 var countCollectionEntities = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$f,
-  handler: handler$f
+  code: code$g,
+  handler: handler$g
 });
 
-const code$e = "createCollectionEntity";
-async function handler$e(plugin, ctx, options) {
+const code$f = "createCollectionEntity";
+async function handler$f(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$e} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$f} handler...`, { defaultInput, fixedInput, mergedInput });
     const userId = ctx.routerContext.state?.userId;
     if (userId) {
         input.createdBy = userId;
@@ -3216,15 +3231,15 @@ async function handler$e(plugin, ctx, options) {
 
 var createCollectionEntity = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$e,
-  handler: handler$e
+  code: code$f,
+  handler: handler$f
 });
 
-const code$d = "createCollectionEntitiesBatch";
-async function handler$d(plugin, ctx, options) {
+const code$e = "createCollectionEntitiesBatch";
+async function handler$e(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
-    logger.debug(`Running ${code$d} handler...`, { defaultInput, fixedInput, input });
+    logger.debug(`Running ${code$e} handler...`, { defaultInput, fixedInput, input });
     const { entities } = input;
     if (!lodash.isArray(entities)) {
         throw new Error("input.entities should be an array.");
@@ -3247,16 +3262,16 @@ async function handler$d(plugin, ctx, options) {
 
 var createCollectionEntitiesBatch = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$d,
-  handler: handler$d
+  code: code$e,
+  handler: handler$e
 });
 
-const code$c = "updateCollectionEntityById";
-async function handler$c(plugin, ctx, options) {
+const code$d = "updateCollectionEntityById";
+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);
     const output = await entityManager.updateEntityById({ id: mergedInput.id, entityToSave: mergedInput }, plugin);
     ctx.output = output;
@@ -3264,14 +3279,14 @@ async function handler$c(plugin, ctx, options) {
 
 var updateCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$c,
-  handler: handler$c
+  code: code$d,
+  handler: handler$d
 });
 
-const code$b = "deleteCollectionEntityById";
-async function handler$b(plugin, ctx, options) {
+const code$c = "deleteCollectionEntityById";
+async function handler$c(plugin, ctx, options) {
     const { logger, server, input } = ctx;
-    logger.debug(`Running ${code$b} handler...`);
+    logger.debug(`Running ${code$c} handler...`);
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.deleteById(input.id, plugin);
     ctx.status = 200;
@@ -3280,16 +3295,16 @@ async function handler$b(plugin, ctx, options) {
 
 var deleteCollectionEntityById = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$b,
-  handler: handler$b
+  code: code$c,
+  handler: handler$c
 });
 
-const code$a = "addEntityRelations";
-async function handler$a(plugin, ctx, options) {
+const code$b = "addEntityRelations";
+async function handler$b(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$a} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$b} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.addRelations(mergedInput, plugin);
     ctx.output = {};
@@ -3297,16 +3312,16 @@ async function handler$a(plugin, ctx, options) {
 
 var addEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$a,
-  handler: handler$a
+  code: code$b,
+  handler: handler$b
 });
 
-const code$9 = "removeEntityRelations";
-async function handler$9(plugin, ctx, options) {
+const code$a = "removeEntityRelations";
+async function handler$a(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$9} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$a} handler...`, { defaultInput, fixedInput, mergedInput });
     const entityManager = server.getEntityManager(options.singularCode);
     await entityManager.removeRelations(mergedInput, plugin);
     ctx.output = {};
@@ -3314,16 +3329,16 @@ async function handler$9(plugin, ctx, options) {
 
 var removeEntityRelations = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$9,
-  handler: handler$9
+  code: code$a,
+  handler: handler$a
 });
 
-const code$8 = "queryDatabase";
-async function handler$8(plugin, ctx, options) {
+const code$9 = "queryDatabase";
+async function handler$9(plugin, ctx, options) {
     const { logger, server, input } = ctx;
     const { sql, querySingle, defaultInput, fixedInput } = options;
     const mergedInput = mergeInput(defaultInput, input, fixedInput);
-    logger.debug(`Running ${code$8} handler...`, { defaultInput, fixedInput, mergedInput });
+    logger.debug(`Running ${code$9} handler...`, { defaultInput, fixedInput, mergedInput });
     const result = await server.queryDatabaseObject(sql, mergedInput);
     if (querySingle) {
         ctx.output = lodash.first(result);
@@ -3335,8 +3350,8 @@ async function handler$8(plugin, ctx, options) {
 
 var queryDatabase = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$8,
-  handler: handler$8
+  code: code$9,
+  handler: handler$9
 });
 
 /**
@@ -3507,17 +3522,17 @@ async function sendSourceResponse(proxyCtx, targetRes) {
     srcRes.body = targetRes.body;
 }
 
-const code$7 = "httpProxy";
-async function handler$7(plugin, ctx, options) {
+const code$8 = "httpProxy";
+async function handler$8(plugin, ctx, options) {
     const { logger } = ctx;
-    logger.debug(`Running ${code$7} handler...`);
+    logger.debug(`Running ${code$8} handler...`);
     await doProxy(ctx.routerContext, options);
 }
 
 var httpProxy = /*#__PURE__*/Object.freeze({
   __proto__: null,
-  code: code$7,
-  handler: handler$7
+  code: code$8,
+  handler: handler$8
 });
 
 /**
@@ -3566,6 +3581,425 @@ class RouteManager {
     }
 }
 
+const segmentType$5 = "literal";
+async function resolveSegmentValue$5(server, ruleCode, config, input) {
+    return config.content || "";
+}
+
+var literal = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  segmentType: segmentType$5,
+  resolveSegmentValue: resolveSegmentValue$5
+});
+
+function padSegment(segment, length, fillString) {
+    if (!length) {
+        return segment;
+    }
+    if (segment.length > length) {
+        return segment.substring(segment.length - length);
+    }
+    else {
+        return segment.padStart(length, fillString || " ");
+    }
+}
+
+const segmentType$4 = "year";
+async function resolveSegmentValue$4(server, ruleCode, config, input) {
+    const segmentValue = (new Date).getFullYear().toString();
+    return padSegment(segmentValue, config.length || 4, config.padding || "0");
+}
+
+var year = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  segmentType: segmentType$4,
+  resolveSegmentValue: resolveSegmentValue$4
+});
+
+const segmentType$3 = "month";
+async function resolveSegmentValue$3(server, ruleCode, config, input) {
+    const segmentValue = ((new Date).getMonth() + 1).toString();
+    return padSegment(segmentValue, config.length || 2, config.padding || "0");
+}
+
+var month = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  segmentType: segmentType$3,
+  resolveSegmentValue: resolveSegmentValue$3
+});
+
+const segmentType$2 = "dayOfMonth";
+async function resolveSegmentValue$2(server, ruleCode, config, input) {
+    const segmentValue = (new Date).getDate().toString();
+    return padSegment(segmentValue, config.length || 2, config.padding || "0");
+}
+
+var dayOfMonth = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  segmentType: segmentType$2,
+  resolveSegmentValue: resolveSegmentValue$2
+});
+
+const segmentType$1 = "parameter";
+async function resolveSegmentValue$1(server, ruleCode, config, input) {
+    const segmentValue = lodash.get(input.parameters, config.parameterName, "");
+    return padSegment(segmentValue, config.length, config.padding);
+}
+
+var parameter = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  segmentType: segmentType$1,
+  resolveSegmentValue: resolveSegmentValue$1
+});
+
+const segmentType = "autoIncrement";
+async function resolveSegmentValue(server, ruleCode, config, input) {
+    const autoIncrementRecordDataAccessor = server.getDataAccessor({
+        singularCode: "sequence_auto_increment_record",
+    });
+    const scope = lodash.get(input.parameters, config.scope, "");
+    const autoIncrementRecord = await autoIncrementRecordDataAccessor.findOne({
+        filters: [
+            {
+                operator: "eq",
+                field: "rule_code",
+                value: ruleCode,
+            },
+            {
+                operator: "eq",
+                field: "scope",
+                value: scope,
+            },
+        ],
+    });
+    let now = dayjs__default["default"]();
+    let nowString = now.format("YYYY-MM-DD HH:mm:ss.SSS Z");
+    let nextValue = 1;
+    if (autoIncrementRecord) {
+        let shouldReset = false;
+        const period = config.period || "forever";
+        const lastUpdate = dayjs__default["default"](autoIncrementRecord.updated_at);
+        if (period === "year") {
+            if (now.year() > lastUpdate.year()) {
+                shouldReset = true;
+            }
+        }
+        else if (period === "month") {
+            if (now.year() !== lastUpdate.year() || now.month() !== lastUpdate.month()) {
+                shouldReset = true;
+            }
+        }
+        else if (period === "day") {
+            if (now.year() !== lastUpdate.year() || now.month() !== lastUpdate.month() || now.date() !== lastUpdate.date()) {
+                shouldReset = true;
+            }
+        }
+        if (!shouldReset) {
+            nextValue = autoIncrementRecord.current_value + 1;
+        }
+        await autoIncrementRecordDataAccessor.updateById(autoIncrementRecord.id, {
+            current_value: nextValue,
+            updated_at: nowString,
+        });
+    }
+    else {
+        await autoIncrementRecordDataAccessor.create({
+            rule_code: ruleCode,
+            scope: scope,
+            current_value: nextValue,
+            updated_at: nowString,
+        });
+    }
+    const segmentValue = nextValue.toString();
+    return padSegment(segmentValue, config.length, config.padding || "0");
+}
+
+var autoIncrement = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  segmentType: segmentType,
+  resolveSegmentValue: resolveSegmentValue
+});
+
+var segmentResolvers = [
+    literal,
+    year,
+    month,
+    dayOfMonth,
+    parameter,
+    autoIncrement,
+];
+
+async function generateSn$2(server, input) {
+    const sequenceNumbers = [];
+    const { ruleCode, parameters } = input;
+    let { amount } = input;
+    if (!amount) {
+        amount = 1;
+    }
+    const sequenceRuleDataAccessor = server.getDataAccessor({
+        singularCode: "sequence_rule",
+    });
+    const sequenceRule = await sequenceRuleDataAccessor.findOne({
+        filters: [
+            {
+                operator: "eq",
+                field: "code",
+                value: ruleCode,
+            }
+        ]
+    });
+    if (!sequenceRule) {
+        throw new Error(`Failed to generate sequence number. Sequence with code '${sequenceRule.code}' not found.`);
+    }
+    const sequenceConfig = sequenceRule.config;
+    if (!sequenceConfig || !sequenceConfig.segments) {
+        throw new Error("Failed to generate sequence number. Sequence not configured.");
+    }
+    for (let i = 0; i < amount; i++) {
+        let sequenceNumber = "";
+        for (const segmentConfig of sequenceConfig.segments) {
+            const segmentResolver = lodash.find(segmentResolvers, (item) => item.segmentType === segmentConfig.type);
+            if (!segmentResolver) {
+                // TODO: deal with unkown segment type
+                continue;
+            }
+            const segment = await segmentResolver.resolveSegmentValue(server, ruleCode, segmentConfig, input);
+            sequenceNumber += segment;
+        }
+        sequenceNumbers.push(sequenceNumber);
+    }
+    return sequenceNumbers;
+}
+
+const code$7 = "generateSn";
+async function handler$7(plugin, ctx, options) {
+    const { server, routerContext } = ctx;
+    const input = ctx.input;
+    if (options?.ruleCode) {
+        input.ruleCode = options.ruleCode;
+    }
+    if (!input.ruleCode) {
+        throw new Error(`Rule code is required when generating sequence numbers.`);
+    }
+    const sequences = await generateSn$2(server, input);
+    ctx.output = {
+        sequences,
+    };
+}
+
+var generateSn$1 = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  code: code$7,
+  handler: handler$7
+});
+
+var pluginActionHandlers$2 = [
+    generateSn$1,
+];
+
+var SequenceRule = {
+    maintainedBy: "sequencePlugin",
+    namespace: "svc",
+    name: "sequence_rule",
+    singularCode: "sequence_rule",
+    pluralCode: "sequence_rules",
+    schema: "public",
+    tableName: "sequence_rules",
+    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 SequenceAutoIncrementRecord = {
+    maintainedBy: "sequencePlugin",
+    namespace: "svc",
+    name: "sequence_auto_increment_record",
+    singularCode: "sequence_auto_increment_record",
+    pluralCode: "sequence_auto_increment_records",
+    schema: "public",
+    tableName: "sequence_auto_increment_records",
+    properties: [
+        {
+            name: "id",
+            code: "id",
+            columnName: "id",
+            type: "integer",
+            required: true,
+            autoIncrement: true,
+        },
+        {
+            name: "ruleCode",
+            code: "ruleCode",
+            columnName: "rule_code",
+            type: "text",
+            required: true,
+        },
+        {
+            name: "scope",
+            code: "scope",
+            columnName: "scope",
+            type: "text",
+            required: false,
+        },
+        {
+            name: "currentValue",
+            code: "currentValue",
+            columnName: "current_value",
+            type: "integer",
+            required: true,
+        },
+        {
+            name: "updatedAt",
+            code: "updatedAt",
+            columnName: "updated_at",
+            type: "datetime",
+            required: true,
+        },
+    ],
+};
+
+var pluginModels$1 = [
+    SequenceRule,
+    SequenceAutoIncrementRecord,
+];
+
+var generateSn = {
+    namespace: "svc",
+    name: "svc.generateSn",
+    code: "svc.generateSn",
+    type: "RESTful",
+    method: "POST",
+    endpoint: "/svc/generateSn",
+    actions: [
+        {
+            code: "generateSn",
+        },
+    ],
+};
+
+var pluginRoutes$2 = [
+    generateSn,
+];
+
+/**
+ * Sequence plugin
+ */
+class SequencePlugin {
+    get code() {
+        return "sequencePlugin";
+    }
+    get description() {
+        return null;
+    }
+    get extendingAbilities() {
+        return [];
+    }
+    get configurableTargets() {
+        return [];
+    }
+    get configurations() {
+        return [];
+    }
+    async registerActionHandlers(server) {
+        for (const actionHandler of pluginActionHandlers$2) {
+            server.registerActionHandler(this, actionHandler);
+        }
+    }
+    async configureModels(server, applicationConfig) {
+        server.appendApplicationConfig({ models: pluginModels$1 });
+    }
+    async configureRoutes(server, applicationConfig) {
+        server.appendApplicationConfig({ routes: pluginRoutes$2 });
+    }
+    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 ruleCode = getSequenceRuleCode(model, property);
+                    const ruleConfig = sequenceConfig.ruleConfig;
+                    const sequenceRuleDataAccessor = server.getDataAccessor({
+                        singularCode: "sequence_rule",
+                    });
+                    const sequenceRule = await sequenceRuleDataAccessor.findOne({
+                        filters: [
+                            {
+                                operator: "eq",
+                                field: "code",
+                                value: ruleCode,
+                            },
+                        ],
+                    });
+                    if (sequenceRule) {
+                        if (JSON.stringify(sequenceRule.config) !== JSON.stringify(ruleConfig)) {
+                            await sequenceRuleDataAccessor.updateById(sequenceRule.id, {
+                                config: ruleConfig,
+                            });
+                        }
+                    }
+                    else {
+                        await sequenceRuleDataAccessor.create({
+                            code: ruleCode,
+                            config: ruleConfig,
+                        });
+                    }
+                }
+            }
+        }
+    }
+    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))) {
+                const ruleCode = getSequenceRuleCode(model, property);
+                const sns = await generateSn$2(server, {
+                    ruleCode,
+                    amount: 1,
+                    parameters: entity,
+                });
+                entity[property.code] = sns[0];
+            }
+        }
+    }
+}
+function getSequenceRuleCode(model, property) {
+    return `propertyAutoGenerate.${model.namespace}.${model.singularCode}.${property.code}`;
+}
+
 var pluginConfig = {
     models: [
         {
@@ -4484,6 +4918,7 @@ exports.RapidRequest = RapidRequest;
 exports.RapidServer = RapidServer;
 exports.RouteContext = RouteContext;
 exports.RouteManagePlugin = RouteManager;
+exports.SequencePlugin = SequencePlugin;
 exports.ServerOperationPlugin = ServerOperationPlugin;
 exports.WebhooksPlugin = WebhooksPlugin;
 exports.bootstrapApplicationConfig = bootstrapApplicationConfig$1;