@ruiapp/rapid-core 0.1.26 → 0.1.28

package/src/plugins/sequence/SequenceService.ts

@@ -0,0 +1,72 @@
+import { IRpdServer } from "~/core/server";
+import { SequenceSegmentConfig } from "~/types";
+import segmentResolvers from "./segments";
+import { find } from "lodash";
+import { SequenceRuleConfig } from "./sequence-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 async function generateSn(server: IRpdServer, input: GenerateSequenceNumbersInput): Promise<string[]> {
+  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: SequenceRuleConfig = 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: string = "";
+
+    for (const segmentConfig of sequenceConfig.segments) {
+      const segmentResolver: SegmentResolver = 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;
+}

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

@@ -0,0 +1,36 @@
+import { ActionHandlerContext } from "~/core/actionHandler";
+import { RapidPlugin } from "~/core/server";
+import { GenerateSequenceNumbersInput, GenerateSequenceNumbersOutput, generateSn } from "../SequenceService";
+
+export interface GenerateSequenceNumbersOptions {
+  ruleCode: string;
+}
+
+
+export const code = "generateSn";
+
+export async function handler(
+  plugin: RapidPlugin,
+  ctx: ActionHandlerContext,
+  options: GenerateSequenceNumbersOptions,
+) {
+  const { server, routerContext } = ctx;
+  const { response } = routerContext;
+  
+  const input: GenerateSequenceNumbersInput = ctx.input;
+  const { parameters, amount } = 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(server, input);
+
+  ctx.output = {
+    sequences,
+  } satisfies GenerateSequenceNumbersOutput;
+}

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

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

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

@@ -0,0 +1,49 @@
+import { RpdDataModel } from "~/types";
+
+export default     {
+  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,
+    },
+  ],
+} as RpdDataModel;

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

@@ -0,0 +1,42 @@
+import { RpdDataModel } from "~/types";
+
+export default     {
+  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,
+    },
+  ],
+} as RpdDataModel;

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

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

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

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

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

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

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

@@ -0,0 +1,11 @@
+export function padSegment(segment: string, length?: number, fillString?: string) {
+  if (!length) {
+    return segment;
+  }
+
+  if (segment.length > length) {
+    return segment.substring(segment.length - length);
+  } else {
+    return segment.padStart(length, fillString || " ");
+  }
+}

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

@@ -0,0 +1,77 @@
+import { SequenceAutoIncrementSegmentConfig } from "~/types";
+import { GenerateSequenceNumbersInput } from "../SequenceService";
+import { padSegment } from "../segment-utility";
+import { IRpdServer } from "~/core/server";
+import { get } from "lodash";
+import dayjs from "dayjs";
+
+export const segmentType = "autoIncrement";
+
+export async function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceAutoIncrementSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string> {
+  const autoIncrementRecordDataAccessor = server.getDataAccessor({
+    singularCode: "sequence_auto_increment_record",
+  });
+
+  const scope = 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();
+  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(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",
+  );
+}

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

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

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

@@ -0,0 +1,16 @@
+import { SegmentResolver } from "../SequenceService";
+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";
+
+export default [
+  literal,
+  year,
+  month,
+  dayOfMonth,
+  parameter,
+  autoIncrement,
+] satisfies SegmentResolver[];

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

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

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

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

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

@@ -0,0 +1,17 @@
+import { SequenceParameterSegmentConfig } from "~/types";
+import { GenerateSequenceNumbersInput } from "../SequenceService";
+import { padSegment } from "../segment-utility";
+import { get } from "lodash";
+import { IRpdServer } from "~/core/server";
+
+export const segmentType = "parameter";
+
+export async function resolveSegmentValue(server: IRpdServer, ruleCode: string, config: SequenceParameterSegmentConfig, input: GenerateSequenceNumbersInput): Promise<string> {
+  const segmentValue = get(input.parameters, config.parameterName, "");
+
+  return padSegment(
+    segmentValue,
+    config.length,
+    config.padding,
+  );
+}

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

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

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

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

package/src/server.ts

@@ -11,6 +11,7 @@ import {
   RpdServerEventTypes,
   RapidServerConfig,
   RpdDataModelProperty,
+  CreateEntityOptions,
 } from "./types";
 
 import QueryBuilder from "./queryBuilder/queryBuilder";
@@ -311,14 +312,27 @@ export class RapidServer implements IRpdServer {
   async handleRequest(request: Request, next: Next) {
     const rapidRequest = new RapidRequest(this, request);
     await rapidRequest.parseBody();
-    const routeContext = new RouteContext(this, rapidRequest);
-    await this.#pluginManager.onPrepareRouteContext(routeContext);
+    const routeContext: RouteContext = new RouteContext(this, rapidRequest);
 
-    await this.#buildedRoutes(routeContext, next);
+    try {
+      await this.#pluginManager.onPrepareRouteContext(routeContext);
+      await this.#buildedRoutes(routeContext, next);
+    } catch (ex) {
+      this.#logger.error('handle request error:', ex)
+      routeContext.response.json({
+        error: {
+          message: ex.message || ex,
+        },
+      }, 500);
+    }
     return routeContext.response.getResponse();
   }
 
   async beforeRunRouteActions(handlerContext: ActionHandlerContext) {
     await this.#pluginManager.beforeRunRouteActions(handlerContext);
   }
+
+  async beforeCreateEntity(model: RpdDataModel, options: CreateEntityOptions) {
+    await this.#pluginManager.beforeCreateEntity(model, options);
+  }
 }

package/src/types.ts

@@ -468,3 +468,65 @@ 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;
+}