@ruiapp/rapid-core 0.1.26 → 0.1.28

package/dist/plugins/auth/actionHandlers/changePassword.d.ts

@@ -0,0 +1,4 @@
+import { ActionHandlerContext } from "../../../core/actionHandler";
+import { RapidPlugin } from "../../../core/server";
+export declare const code = "changePassword";
+export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any): Promise<void>;

package/dist/plugins/auth/actionHandlers/index.d.ts

@@ -1,5 +1,6 @@
 import * as createSession from "./createSession";
 import * as deleteSession from "./deleteSession";
 import * as getMyProfile from "./getMyProfile";
-declare const _default: (typeof createSession | typeof deleteSession | typeof getMyProfile)[];
+import * as resetPassword from "./resetPassword";
+declare const _default: (typeof createSession | typeof deleteSession | typeof getMyProfile | typeof resetPassword)[];
 export default _default;

package/dist/plugins/auth/actionHandlers/resetPassword.d.ts

@@ -0,0 +1,4 @@
+import { ActionHandlerContext } from "../../../core/actionHandler";
+import { RapidPlugin } from "../../../core/server";
+export declare const code = "resetPassword";
+export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: any): Promise<void>;

package/dist/plugins/sequence/SequencePlugin.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Sequence plugin
+ */
+import { CreateEntityOptions, RpdApplicationConfig, RpdDataModel } from "../../types";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "../../core/server";
+declare class SequencePlugin implements RapidPlugin {
+    get code(): string;
+    get description(): string;
+    get extendingAbilities(): RpdServerPluginExtendingAbilities[];
+    get configurableTargets(): RpdServerPluginConfigurableTargetOptions[];
+    get configurations(): RpdConfigurationItemOptions[];
+    registerActionHandlers(server: IRpdServer): Promise<any>;
+    configureModels(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    configureRoutes(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<any>;
+    onApplicationLoaded(server: IRpdServer, applicationConfig: RpdApplicationConfig): Promise<void>;
+    beforeCreateEntity(server: IRpdServer, model: RpdDataModel, options: CreateEntityOptions): Promise<void>;
+}
+export default SequencePlugin;

package/dist/plugins/sequence/SequenceService.d.ts

@@ -0,0 +1,15 @@
+import { IRpdServer } from "../../core/server";
+import { SequenceSegmentConfig } from "../../types";
+export interface GenerateSequenceNumbersInput {
+    ruleCode: string;
+    parameters: Record<string, string>;
+    amount: number;
+}
+export interface GenerateSequenceNumbersOutput {
+    sequences: string[];
+}
+export interface SegmentResolver {
+    segmentType: string;
+    resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;
+}
+export declare function generateSn(server: IRpdServer, input: GenerateSequenceNumbersInput): Promise<string[]>;

package/dist/plugins/sequence/actionHandlers/generateSn.d.ts

@@ -0,0 +1,7 @@
+import { ActionHandlerContext } from "../../../core/actionHandler";
+import { RapidPlugin } from "../../../core/server";
+export interface GenerateSequenceNumbersOptions {
+    ruleCode: string;
+}
+export declare const code = "generateSn";
+export declare function handler(plugin: RapidPlugin, ctx: ActionHandlerContext, options: GenerateSequenceNumbersOptions): Promise<void>;

package/dist/plugins/sequence/actionHandlers/index.d.ts

@@ -0,0 +1,3 @@
+import * as generateSn from "./generateSn";
+declare const _default: (typeof generateSn)[];
+export default _default;

package/dist/plugins/sequence/models/SequenceAutoIncrementRecord.d.ts

@@ -0,0 +1,3 @@
+import { RpdDataModel } from "../../../types";
+declare const _default: RpdDataModel;
+export default _default;

package/dist/plugins/sequence/models/SequenceRule.d.ts

@@ -0,0 +1,3 @@
+import { RpdDataModel } from "../../../types";
+declare const _default: RpdDataModel;
+export default _default;

package/dist/plugins/sequence/models/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("../../..").RpdDataModel[];
+export default _default;

package/dist/plugins/sequence/routes/generateSn.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    namespace: string;
+    name: string;
+    code: string;
+    type: "RESTful";
+    method: "POST";
+    endpoint: string;
+    actions: {
+        code: string;
+    }[];
+};
+export default _default;

package/dist/plugins/sequence/routes/index.d.ts

@@ -0,0 +1,12 @@
+declare const _default: {
+    namespace: string;
+    name: string;
+    code: string;
+    type: "RESTful";
+    method: "POST";
+    endpoint: string;
+    actions: {
+        code: string;
+    }[];
+}[];
+export default _default;

package/dist/plugins/sequence/segment-utility.d.ts

@@ -0,0 +1 @@
+export declare function padSegment(segment: string, length?: number, fillString?: string): string;

package/dist/plugins/sequence/segments/autoIncrement.d.ts

@@ -0,0 +1,5 @@
+import { SequenceAutoIncrementSegmentConfig } from "../../../types";
+import { GenerateSequenceNumbersInput } from "../SequenceService";
+import { IRpdServer } from "../../../core/server";
+export declare const segmentType = "autoIncrement";
+export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceAutoIncrementSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/dayOfMonth.d.ts

@@ -0,0 +1,5 @@
+import { SequenceDayOfMonthSegmentConfig } from "../../../types";
+import { GenerateSequenceNumbersInput } from "../SequenceService";
+import { IRpdServer } from "../../../core/server";
+export declare const segmentType = "dayOfMonth";
+export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceDayOfMonthSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/index.d.ts

@@ -0,0 +1,8 @@
+import * as literal from "./literal";
+import * as year from "./year";
+import * as month from "./month";
+import * as dayOfMonth from "./dayOfMonth";
+import * as parameter from "./parameter";
+import * as autoIncrement from "./autoIncrement";
+declare const _default: (typeof literal | typeof year | typeof month | typeof dayOfMonth | typeof parameter | typeof autoIncrement)[];
+export default _default;

package/dist/plugins/sequence/segments/literal.d.ts

@@ -0,0 +1,5 @@
+import { SequenceLiteralSegmentConfig } from "../../../types";
+import { GenerateSequenceNumbersInput } from "../SequenceService";
+import { IRpdServer } from "../../../core/server";
+export declare const segmentType = "literal";
+export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceLiteralSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/month.d.ts

@@ -0,0 +1,5 @@
+import { SequenceMonthSegmentConfig } from "../../../types";
+import { GenerateSequenceNumbersInput } from "../SequenceService";
+import { IRpdServer } from "../../../core/server";
+export declare const segmentType = "month";
+export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceMonthSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/parameter.d.ts

@@ -0,0 +1,5 @@
+import { SequenceParameterSegmentConfig } from "../../../types";
+import { GenerateSequenceNumbersInput } from "../SequenceService";
+import { IRpdServer } from "../../../core/server";
+export declare const segmentType = "parameter";
+export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceParameterSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

package/dist/plugins/sequence/segments/year.d.ts

@@ -0,0 +1,5 @@
+import { SequenceYearSegmentConfig } from "../../../types";
+import { GenerateSequenceNumbersInput } from "../SequenceService";
+import { IRpdServer } from "../../../core/server";
+export declare const segmentType = "year";
+export declare function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceYearSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string>;

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

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

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty } from "./types";
+import { GetDataAccessorOptions, GetModelOptions, IDatabaseAccessor, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RpdApplicationConfig, RpdDataModel, RpdServerEventTypes, RapidServerConfig, RpdDataModelProperty, CreateEntityOptions } from "./types";
 import { ActionHandler, ActionHandlerContext, IPluginActionHandler } from "./core/actionHandler";
 import { IRpdServer, RapidPlugin } from "./core/server";
 import { Next } from "./core/routeContext";
@@ -39,6 +39,7 @@ export declare class RapidServer implements IRpdServer {
     queryDatabaseObject(sql: string, params?: unknown[] | Record<string, unknown>): Promise<any[]>;
     tryQueryDatabaseObject(sql: string, params?: unknown[] | Record<string, unknown>): Promise<any[]>;
     get middlewares(): any[];
-    handleRequest(request: Request, next: Next): any;
+    handleRequest(request: Request, next: Next): Promise<Response>;
     beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;
+    beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions): Promise<void>;
 }

package/dist/types.d.ts

@@ -355,3 +355,46 @@ export interface RemoveEntityRelationsOptions {
         [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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.1.26",
+  "version": "0.1.28",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -18,6 +18,8 @@
     "typescript": "^4.8.4"
   },
   "dependencies": {
+    "bcrypt": "^5.1.1",
+    "dayjs": "^1.11.7",
     "jsonwebtoken": "^9.0.2",
     "koa-tree-router": "^0.12.1",
     "lodash": "^4.17.21",

package/src/core/pluginManager.ts

@@ -1,4 +1,4 @@
-import { RpdApplicationConfig } from "~/types";
+import { CreateEntityOptions, RpdApplicationConfig, RpdDataModel } from "~/types";
 import { IRpdServer, RapidPlugin } from "./server";
 import { RouteContext } from "./routeContext";
 import { ActionHandlerContext } from "./actionHandler";
@@ -159,6 +159,18 @@ class PluginManager {
       }
     }
   }
+
+  /** 在创建实体前调用。 */
+  async beforeCreateEntity(
+    model: RpdDataModel,
+    options: CreateEntityOptions,
+  ) {
+    for (const plugin of this.#plugins) {
+      if (plugin.beforeCreateEntity) {
+        await plugin.beforeCreateEntity(this.#server, model, options);
+      }
+    }
+  }
 }
 
 export default PluginManager;

package/src/core/response.ts

@@ -50,6 +50,7 @@ export class RapidResponse {
     headers?: HeadersInit,
   ) {
     const body = JSON.stringify(obj);
+    this.headers.set("Content-Type", "application/json");
     const responseHeaders = new Headers(this.headers);
     if (headers) {
       mergeHeaders(responseHeaders, headers);

package/src/core/server.ts

@@ -1,4 +1,4 @@
-import { GetDataAccessorOptions, GetModelOptions, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RapidServerConfig, RpdApplicationConfig, RpdDataModel, RpdDataModelProperty, RpdServerEventTypes } from "~/types";
+import { CreateEntityOptions, GetDataAccessorOptions, GetModelOptions, IDatabaseConfig, IQueryBuilder, IRpdDataAccessor, RapidServerConfig, RpdApplicationConfig, RpdDataModel, RpdDataModelProperty, RpdServerEventTypes } from "~/types";
 import { IPluginActionHandler, ActionHandler, ActionHandlerContext } from "./actionHandler";
 import { Next, RouteContext } from "./routeContext";
 import EntityManager from "~/dataAccess/entityManager";
@@ -48,6 +48,7 @@ export interface IRpdServer {
   ): void;
   handleRequest(request: Request, next: Next): Promise<Response>;
   beforeRunRouteActions(handlerContext: ActionHandlerContext): Promise<void>;
+  beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions): Promise<void>;
 }
 
 
@@ -139,4 +140,6 @@ export interface RapidPlugin {
   onPrepareRouteContext?: (server: IRpdServer, routeContext: RouteContext) => Promise<any>;
   /** 在接收到HTTP请求，执行 actions 前调用。 */
   beforeRunRouteActions?: (server: IRpdServer, handlerContext: ActionHandlerContext) => Promise<any>;
+  /** 在创建实体前调用。 */
+  beforeCreateEntity?: (server: IRpdServer, model: RpdDataModel, options: CreateEntityOptions) => Promise<any>;
 }

package/src/dataAccess/entityManager.ts

@@ -733,6 +733,9 @@ export default class EntityManager<TEntity=any> {
 
   async createEntity(options: CreateEntityOptions, plugin?: RapidPlugin): Promise<TEntity> {
     const model = this.getModel();
+
+    await this.#server.beforeCreateEntity(model, options);
+
     const newEntity = await createEntity(this.#server, this.#dataAccessor, options);
 
     this.#server.emitEvent(

package/src/index.ts

@@ -17,6 +17,7 @@ export * as bootstrapApplicationConfig from "./bootstrapApplicationConfig";
 export { default as MetaManagePlugin } from "./plugins/metaManage/MetaManagePlugin";
 export { default as DataManagePlugin } from "./plugins/dataManage/DataManagePlugin";
 export { default as RouteManagePlugin } from "./plugins/routeManage/RouteManagePlugin";
+export { default as SequencePlugin } from "./plugins/sequence/SequencePlugin";
 export { default as WebhooksPlugin } from "./plugins/webhooks/WebhooksPlugin";
 export { default as AuthPlugin } from "./plugins/auth/AuthPlugin";
 export { default as FileManagePlugin } from "./plugins/fileManage/FileManagePlugin";

package/src/plugins/auth/actionHandlers/changePassword.ts

@@ -0,0 +1,58 @@
+import bcrypt from "bcrypt";
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+
+export const code = "changePassword";
+
+export async function handler(
+  plugin: RapidPlugin,
+  ctx: ActionHandlerContext,
+  options: any,
+) {
+  const { server, input, routerContext } = ctx;
+  const { response } = routerContext;
+  const { id, oldPassword, newPassword } = input;
+
+  const userId = routerContext.state.userId;
+  if (!userId) {
+    ctx.status = 401;
+    ctx.output = {
+      error: {
+        message: "You are not signed in."
+      }
+    }
+    return;
+  }
+
+  const userDataAccessor = server.getDataAccessor({
+    singularCode: "oc_user",
+  });
+
+  const user = await userDataAccessor.findOne({
+    filters: [
+      {
+        operator: "eq",
+        field: "id",
+        value: userId,
+      }
+    ]
+  });
+
+  if (!user) {
+    throw new Error("User not found.");
+  }
+
+  const isMatch = await bcrypt.compare(oldPassword, user.password);
+  if (!isMatch) {
+    throw new Error("旧密码错误。");
+  }
+
+  const saltRounds = 10;
+  const passwordHash = await bcrypt.hash(newPassword, saltRounds);
+
+  await userDataAccessor.updateById(user.id, {
+    password: passwordHash,
+  });
+
+  ctx.output = {};
+}

package/src/plugins/auth/actionHandlers/createSession.ts

@@ -1,3 +1,4 @@
+import bcrypt from "bcrypt";
 import { setCookie } from "~/deno-std/http/cookie";
 import { createJwt } from "~/utilities/jwtUtility";
 import { ActionHandlerContext } from "~/core/actionHandler";
@@ -34,7 +35,12 @@ export async function handler(
   });
 
   if (!user) {
-    throw new Error("Wrong account or password.");
+    throw new Error("用户名或密码错误。");
+  }
+
+  const isMatch = await bcrypt.compare(password, user.password);
+  if (!isMatch) {
+    throw new Error("用户名或密码错误。");
   }
 
   const secretKey = Buffer.from(server.config.jwtKey, "base64");

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

@@ -2,9 +2,11 @@ import { IPluginActionHandler } from "~/core/actionHandler";
 import * as createSession from "./createSession";
 import * as deleteSession from "./deleteSession";
 import * as getMyProfile from "./getMyProfile";
+import * as resetPassword from "./resetPassword";
 
 export default [
   createSession,
   deleteSession,
   getMyProfile,
+  resetPassword,
 ] satisfies IPluginActionHandler[];

package/src/plugins/auth/actionHandlers/resetPassword.ts

@@ -0,0 +1,42 @@
+import bcrypt from "bcrypt";
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+
+export const code = "resetPassword";
+
+export async function handler(
+  plugin: RapidPlugin,
+  ctx: ActionHandlerContext,
+  options: any,
+) {
+  const { server, input, routerContext } = ctx;
+  const { response } = routerContext;
+  const { userId, password } = input;
+
+  const userDataAccessor = server.getDataAccessor({
+    singularCode: "oc_user",
+  });
+
+  const user = await userDataAccessor.findOne({
+    filters: [
+      {
+        operator: "eq",
+        field: "id",
+        value: userId,
+      }
+    ]
+  });
+
+  if (!user) {
+    throw new Error("User not found.");
+  }
+
+  const saltRounds = 10;
+  const passwordHash = await bcrypt.hash(password, saltRounds);
+
+  await userDataAccessor.updateById(user.id, {
+    password: passwordHash,
+  });
+
+  ctx.output = {};
+}

package/src/plugins/sequence/SequencePlugin.ts

@@ -0,0 +1,122 @@
+/**
+ * Sequence plugin
+ */
+
+import {
+  CreateEntityOptions,
+  RpdApplicationConfig,
+  RpdDataModel,
+  RpdDataModelProperty,
+} from "~/types";
+import { IRpdServer, RapidPlugin, RpdConfigurationItemOptions, RpdServerPluginConfigurableTargetOptions, RpdServerPluginExtendingAbilities } from "~/core/server";
+
+import pluginActionHandlers from "./actionHandlers";
+import pluginModels from "./models";
+import pluginRoutes from "./routes";
+import { RouteContext } from "~/core/routeContext";
+import { PropertySequenceConfig } from "./sequence-types";
+import { isNull, isUndefined } from "lodash";
+import { generateSn } from "./SequenceService";
+
+
+class SequencePlugin implements RapidPlugin {
+  get code(): string {
+    return "sequencePlugin";
+  }
+
+  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 sequenceConfig: PropertySequenceConfig = 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: IRpdServer, model: RpdDataModel, options: CreateEntityOptions) {
+    debugger;
+    const entity = options.entity;
+    for (const property of model.properties) {
+      const sequenceConfig: PropertySequenceConfig = property.config?.sequence;
+      const propertyValue = entity[property.code];
+      if (sequenceConfig &&
+        sequenceConfig.autoGenerate &&
+        (isUndefined(propertyValue) || isNull(propertyValue))
+      ) {
+        const ruleCode = getSequenceRuleCode(model, property);
+        const sns = await generateSn(server, {
+          ruleCode,
+          amount: 1,
+          parameters: entity,
+        });
+        entity[property.code] = sns[0];
+      }
+    }
+  }
+}
+
+function getSequenceRuleCode(model: RpdDataModel, property: RpdDataModelProperty) {
+  return `propertyAutoGenerate.${model.namespace}.${model.singularCode}.${property.code}`;
+}
+
+export default SequencePlugin;