@ruiapp/rapid-core 0.8.5 → 0.8.7

package/dist/dataAccess/entityManager.d.ts

@@ -28,8 +28,8 @@ export default class EntityManager<TEntity = any> {
     constructor(server: IRpdServer, dataAccessor: IRpdDataAccessor);
     getModel(): RpdDataModel;
     findEntities(options: FindEntityOptions): Promise<TEntity[]>;
-    findEntity(options: FindEntityOptions): Promise<TEntity | null>;
-    findById(options: FindEntityByIdOptions | string | number): Promise<TEntity | null>;
+    findEntity(options: FindEntityOptions): Promise<TEntity | undefined>;
+    findById(options: FindEntityByIdOptions | string | number): Promise<TEntity | undefined>;
     createEntity(options: CreateEntityOptions, plugin?: RapidPlugin): Promise<TEntity>;
     updateEntityById(options: UpdateEntityByIdOptions, plugin?: RapidPlugin): Promise<TEntity>;
     count(options: CountEntityOptions): Promise<number>;

package/dist/dataAccess/entityValidator.d.ts

@@ -0,0 +1,3 @@
+import { IRpdServer } from "../core/server";
+import { RpdDataModel } from "../types";
+export declare function validateEntity(server: IRpdServer, model: RpdDataModel, entity: any): Promise<any>;

package/dist/helpers/entityHelpers.d.ts

@@ -1,3 +1,3 @@
 import { IRpdServer } from "../core/server";
 import { RpdDataModel } from "../types";
-export declare function getEntityPartChanges(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null;
+export declare function detectChangedFieldsOfEntity(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null;

package/dist/helpers/metaHelper.d.ts

@@ -5,6 +5,13 @@ export declare function isOneRelationProperty(property: RpdDataModelProperty): b
 export declare function isManyRelationProperty(property: RpdDataModelProperty): boolean;
 export declare function getEntityProperties(server: IRpdServer, model: RpdDataModel, predicate?: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty[];
 export declare function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel, predicate?: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty[];
+/**
+ * 根据 code 获取实体属性信息。如实体为派生实体，可能会返回基础实体中的属性信息。
+ * @param server
+ * @param model
+ * @param propertyCode
+ * @returns
+ */
 export declare function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined;
 export declare function getEntityProperty(server: IRpdServer, model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined;
 export declare function getEntityOwnPropertyByCode(model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined;

package/dist/index.d.ts

@@ -15,6 +15,7 @@ export * from "./utilities/accessControlUtility";
 export * from "./utilities/entityUtility";
 export * from "./utilities/jwtUtility";
 export * from "./utilities/timeUtility";
+export * from "./helpers/entityHelpers";
 export * from "./helpers/licenseHelper";
 export * from "./deno-std/http/cookie";
 export { mapDbRowToEntity } from "./dataAccess/entityMapper";

package/dist/index.js

@@ -2425,6 +2425,13 @@ function getEntityPropertiesIncludingBase(server, model, predicate) {
     }
     return [...baseProperties, ...properties];
 }
+/**
+ * 根据 code 获取实体属性信息。如实体为派生实体，可能会返回基础实体中的属性信息。
+ * @param server
+ * @param model
+ * @param propertyCode
+ * @returns
+ */
 function getEntityPropertyByCode(server, model, propertyCode) {
     return getEntityProperty(server, model, (e) => e.code === propertyCode);
 }
@@ -2463,6 +2470,16 @@ function getEntityPropertyByFieldName(server, model, fieldName) {
     return property;
 }
 
+function getNowString() {
+    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSS");
+}
+function getNowStringWithTimezone() {
+    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSSZ");
+}
+function getDateString(timeString) {
+    return dayjs__default["default"](timeString).format("YYYY-MM-DD");
+}
+
 // TODO Generate mapper and cache it.
 function mapDbRowToEntity(server, model, row, keepNonPropertyFields) {
     if (!row) {
@@ -2505,8 +2522,16 @@ function mapDbRowToEntity(server, model, row, keepNonPropertyFields) {
             }
         }
         else {
+            let fieldValue = row[columnName];
+            if (property) {
+                if (property.type === "date") {
+                    if (fieldValue) {
+                        fieldValue = getDateString(fieldValue);
+                    }
+                }
+            }
             if (!result[propertyName]) {
-                result[propertyName] = row[columnName];
+                result[propertyName] = fieldValue;
             }
         }
     });
@@ -2566,7 +2591,7 @@ function mapPropertyNameToColumnName(server, model, propertyName) {
     return property.columnName || property.code;
 }
 
-function getEntityPartChanges(server, model, before, after) {
+function detectChangedFieldsOfEntity(server, model, before, after) {
     if (!before) {
         throw new Error("Argument 'before' can not be null.");
     }
@@ -2642,11 +2667,23 @@ function getEntityPartChanges(server, model, before, after) {
     return null;
 }
 
-function getNowString() {
-    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSS");
-}
-function getNowStringWithTimezone() {
-    return dayjs__default["default"]().format("YYYY-MM-DD HH:mm:ss.SSSZ");
+async function validateEntity(server, model, entity) {
+    for (const propCode in entity) {
+        let prop = getEntityPropertyByCode(server, model, propCode);
+        if (!prop) {
+            getEntityPropertyByFieldName(server, model, propCode);
+        }
+        if (!prop) {
+            continue;
+        }
+        if (prop.type === "date") {
+            const originValue = entity[propCode];
+            if (originValue) {
+                entity[propCode] = getDateString(originValue);
+            }
+        }
+    }
+    return entity;
 }
 
 function convertEntityOrderByToRowOrderBy(server, model, baseModel, orderByList) {
@@ -3286,7 +3323,9 @@ async function createEntity(server, dataAccessor, options, plugin) {
     if (model.derivedTypePropertyCode) {
         throw newEntityOperationError("Create base entity directly is not allowed.");
     }
-    const { entity, routeContext } = options;
+    let { entity } = options;
+    entity = await validateEntity(server, model, entity);
+    const { routeContext } = options;
     const userId = options.routeContext?.state?.userId;
     if (userId) {
         const createdByProperty = getEntityPropertyByCode(server, model, "createdBy");
@@ -3537,6 +3576,8 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     if (!id) {
         throw new Error("Id is required when updating an entity.");
     }
+    let { entityToSave } = options;
+    entityToSave = await validateEntity(server, model, entityToSave);
     const entity = await findById(server, dataAccessor, {
         routeContext,
         id,
@@ -3545,8 +3586,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
     if (!entity) {
         throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
     }
-    let { entityToSave } = options;
-    let changes = getEntityPartChanges(server, model, entity, entityToSave);
+    let changes = detectChangedFieldsOfEntity(server, model, entity, entityToSave);
     if (!changes && !options.operation) {
         return entity;
     }
@@ -3576,7 +3616,7 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         sender: plugin,
         routeContext: options.routeContext,
     });
-    changes = getEntityPartChanges(server, model, entity, entityToSave);
+    changes = detectChangedFieldsOfEntity(server, model, entity, entityToSave);
     // check readonly properties
     Object.keys(changes).forEach((propertyName) => {
         let isReadonlyProperty = false;
@@ -8472,7 +8512,15 @@ async function handler$1(plugin, ctx, options) {
     if (!job) {
         throw new Error(`Cron job with code '${input.code}' was not found.`);
     }
-    await cronJobService.executeJob(job);
+    let jobExecutionContext = {
+        logger: server.getLogger(),
+        routerContext,
+        next: null,
+        server,
+        applicationConfig: null,
+        input: input.input,
+    };
+    await cronJobService.executeJob(jobExecutionContext, job);
     response.json({});
 }
 
@@ -8534,7 +8582,7 @@ class CronJobService {
                 ...(job.jobOptions || {}),
                 cronTime: job.cronTime,
                 onTick: async () => {
-                    await this.tryExecuteJob(server, job);
+                    await this.tryExecuteJob(job);
                 },
             });
             jobInstance.start();
@@ -8544,33 +8592,41 @@ class CronJobService {
             });
         }
     }
-    async tryExecuteJob(server, job) {
+    async tryExecuteJob(job) {
+        const server = this.#server;
         const logger = server.getLogger();
         logger.info(`Executing cron job '${job.code}'...`);
+        let handlerContext = {
+            logger,
+            routerContext: RouteContext.newSystemOperationContext(server),
+            next: null,
+            server,
+            applicationConfig: null,
+            input: null,
+        };
         try {
-            await this.executeJob(job);
+            await this.executeJob(handlerContext, job);
             logger.info(`Completed cron job '${job.code}'...`);
         }
         catch (ex) {
-            logger.error('Cron job "%s" execution error: %s', job.code, ex.message, { cronJobCode: job.code });
+            logger.error('Cron job "%s" execution error: %s', job.code, ex.message);
+            if (job.onError) {
+                try {
+                    await job.onError(handlerContext, ex);
+                }
+                catch (ex) {
+                    logger.error('Error handler of cron job "%s" execution failed: %s', job.code, ex.message);
+                }
+            }
         }
     }
     /**
      * 执行指定任务
      * @param job
      */
-    async executeJob(job) {
+    async executeJob(handlerContext, job) {
         const server = this.#server;
-        const logger = server.getLogger();
         validateLicense(server);
-        let handlerContext = {
-            logger,
-            routerContext: RouteContext.newSystemOperationContext(server),
-            next: null,
-            server,
-            applicationConfig: null,
-            input: null,
-        };
         if (job.actionHandlerCode) {
             const actionHandler = server.getActionHandlerByCode(job.code);
             await actionHandler(handlerContext, job.handleOptions);
@@ -9039,8 +9095,10 @@ exports.bootstrapApplicationConfig = bootstrapApplicationConfig$1;
 exports.createJwt = createJwt;
 exports.decodeJwt = decodeJwt;
 exports.deleteCookie = deleteCookie;
+exports.detectChangedFieldsOfEntity = detectChangedFieldsOfEntity;
 exports.generateJwtSecretKey = generateJwtSecretKey;
 exports.getCookies = getCookies;
+exports.getDateString = getDateString;
 exports.getEntityRelationTargetId = getEntityRelationTargetId;
 exports.getNowString = getNowString;
 exports.getNowStringWithTimezone = getNowStringWithTimezone;

package/dist/plugins/cronJob/CronJobPluginTypes.d.ts

@@ -4,6 +4,7 @@ export type RunCronJobActionHandlerOptions = {
 };
 export type RunCronJobInput = {
     code?: string;
+    input?: any;
 };
 export type NamedCronJobInstance = {
     code: string;

package/dist/plugins/cronJob/services/CronJobService.d.ts

@@ -1,5 +1,6 @@
 import { IRpdServer } from "../../../core/server";
 import { CronJobConfiguration } from "../../../types/cron-job-types";
+import { ActionHandlerContext } from "../../../core/actionHandler";
 export default class CronJobService {
     #private;
     constructor(server: IRpdServer);
@@ -13,10 +14,10 @@ export default class CronJobService {
      * 重新加载定时任务
      */
     reloadJobs(): void;
-    tryExecuteJob(server: IRpdServer, job: CronJobConfiguration): Promise<void>;
+    tryExecuteJob(job: CronJobConfiguration): Promise<void>;
     /**
      * 执行指定任务
      * @param job
      */
-    executeJob(job: CronJobConfiguration): Promise<void>;
+    executeJob(handlerContext: ActionHandlerContext, job: CronJobConfiguration): Promise<void>;
 }

package/dist/types/cron-job-types.d.ts

@@ -35,6 +35,13 @@ export interface CronJobConfiguration {
      * 处理定时任务时的设置选项
      */
     handleOptions?: any;
+    /**
+     * 定时任务执行失败时的处理
+     * @param ctx
+     * @param error
+     * @returns
+     */
+    onError?: (ctx: ActionHandlerContext, error: any) => Promise<void>;
 }
 export interface CronJobOptions {
     /**

package/dist/utilities/timeUtility.d.ts

@@ -1,2 +1,3 @@
 export declare function getNowString(): string;
 export declare function getNowStringWithTimezone(): string;
+export declare function getDateString(timeString: any): string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ruiapp/rapid-core",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/core/actionHandler.ts

@@ -2,6 +2,7 @@ import { RpdApplicationConfig } from "~/types";
 import { IRpdServer, RapidPlugin } from "./server";
 import { Next, RouteContext } from "./routeContext";
 import { Logger } from "~/facilities/log/LogFacility";
+import { CronJobConfiguration } from "~/types/cron-job-types";
 
 export interface ActionHandlerContext {
   logger: Logger;

package/src/dataAccess/entityManager.ts

@@ -23,7 +23,7 @@ import { isNullOrUndefined } from "~/utilities/typeUtility";
 import { mapDbRowToEntity, mapEntityToDbRow } from "./entityMapper";
 import { mapPropertyNameToColumnName } from "./propertyMapper";
 import { IRpdServer, RapidPlugin } from "~/core/server";
-import { getEntityPartChanges } from "~/helpers/entityHelpers";
+import { detectChangedFieldsOfEntity } from "~/helpers/entityHelpers";
 import {
   cloneDeep,
   concat,
@@ -58,6 +58,7 @@ import { ColumnSelectOptions, CountRowOptions, FindRowOptions, FindRowOrderByOpt
 import { newEntityOperationError } from "~/utilities/errorUtility";
 import { getNowStringWithTimezone } from "~/utilities/timeUtility";
 import { RouteContext } from "~/core/routeContext";
+import { validateEntity } from "./entityValidator";
 
 export type FindOneRelationEntitiesOptions = {
   server: IRpdServer;
@@ -777,8 +778,10 @@ async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     throw newEntityOperationError("Create base entity directly is not allowed.");
   }
 
-  const { entity, routeContext } = options;
+  let { entity } = options;
+  entity = await validateEntity(server, model, entity);
 
+  const { routeContext } = options;
   const userId = options.routeContext?.state?.userId;
   if (userId) {
     const createdByProperty = getEntityPropertyByCode(server, model, "createdBy");
@@ -1051,6 +1054,9 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
     throw new Error("Id is required when updating an entity.");
   }
 
+  let { entityToSave } = options;
+  entityToSave = await validateEntity(server, model, entityToSave);
+
   const entity = await findById(server, dataAccessor, {
     routeContext,
     id,
@@ -1060,8 +1066,7 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
     throw new Error(`${model.namespace}.${model.singularCode}  with id "${id}" was not found.`);
   }
 
-  let { entityToSave } = options;
-  let changes = getEntityPartChanges(server, model, entity, entityToSave);
+  let changes = detectChangedFieldsOfEntity(server, model, entity, entityToSave);
   if (!changes && !options.operation) {
     return entity;
   }
@@ -1096,7 +1101,7 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
     routeContext: options.routeContext,
   });
 
-  changes = getEntityPartChanges(server, model, entity, entityToSave);
+  changes = detectChangedFieldsOfEntity(server, model, entity, entityToSave);
 
   // check readonly properties
   Object.keys(changes).forEach((propertyName) => {
@@ -1787,11 +1792,11 @@ export default class EntityManager<TEntity = any> {
     return await findEntities(this.#server, this.#dataAccessor, options);
   }
 
-  async findEntity(options: FindEntityOptions): Promise<TEntity | null> {
+  async findEntity(options: FindEntityOptions): Promise<TEntity | undefined> {
     return await findEntity(this.#server, this.#dataAccessor, options);
   }
 
-  async findById(options: FindEntityByIdOptions | string | number): Promise<TEntity | null> {
+  async findById(options: FindEntityByIdOptions | string | number): Promise<TEntity | undefined> {
     // options is id
     if (!isObject(options)) {
       options = {

package/src/dataAccess/entityMapper.ts

@@ -1,6 +1,7 @@
 import type { IRpdServer } from "~/core/server";
 import { RpdDataModel } from "~/types";
 import { getEntityProperty, getEntityPropertyByCode, isRelationProperty } from "../helpers/metaHelper";
+import { getDateString } from "~/utilities/timeUtility";
 
 // TODO Generate mapper and cache it.
 
@@ -45,8 +46,18 @@ export function mapDbRowToEntity(server: IRpdServer, model: RpdDataModel, row: a
         result[columnName] = row[columnName];
       }
     } else {
+      let fieldValue = row[columnName];
+
+      if (property) {
+        if (property.type === "date") {
+          if (fieldValue) {
+            fieldValue = getDateString(fieldValue);
+          }
+        }
+      }
+
       if (!result[propertyName]) {
-        result[propertyName] = row[columnName];
+        result[propertyName] = fieldValue;
       }
     }
   });

package/src/dataAccess/entityValidator.ts

@@ -0,0 +1,26 @@
+import { IRpdServer } from "~/core/server";
+import { getEntityPropertyByCode, getEntityPropertyByFieldName } from "~/helpers/metaHelper";
+import { RpdDataModel } from "~/types";
+import { getDateString } from "~/utilities/timeUtility";
+
+export async function validateEntity(server: IRpdServer, model: RpdDataModel, entity: any) {
+  for (const propCode in entity) {
+    let prop = getEntityPropertyByCode(server, model, propCode);
+    if (!prop) {
+      getEntityPropertyByFieldName(server, model, propCode);
+    }
+
+    if (!prop) {
+      continue;
+    }
+
+    if (prop.type === "date") {
+      const originValue = entity[propCode];
+      if (originValue) {
+        entity[propCode] = getDateString(originValue);
+      }
+    }
+  }
+
+  return entity;
+}

package/src/helpers/entityHelpers.ts

@@ -3,7 +3,7 @@ import { IRpdServer } from "~/core/server";
 import { getEntityPropertyByCode, isOneRelationProperty } from "~/helpers/metaHelper";
 import { RpdDataModel } from "~/types";
 
-export function getEntityPartChanges(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null {
+export function detectChangedFieldsOfEntity(server: IRpdServer, model: RpdDataModel, before: any, after: any): Record<string, any> | null {
   if (!before) {
     throw new Error("Argument 'before' can not be null.");
   }

package/src/helpers/metaHelper.ts

@@ -53,6 +53,13 @@ export function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdD
   return [...baseProperties, ...properties];
 }
 
+/**
+ * 根据 code 获取实体属性信息。如实体为派生实体，可能会返回基础实体中的属性信息。
+ * @param server
+ * @param model
+ * @param propertyCode
+ * @returns
+ */
 export function getEntityPropertyByCode(server: IRpdServer, model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined {
   return getEntityProperty(server, model, (e) => e.code === propertyCode);
 }

package/src/index.ts

@@ -23,6 +23,7 @@ export * from "./utilities/entityUtility";
 export * from "./utilities/jwtUtility";
 export * from "./utilities/timeUtility";
 
+export * from "./helpers/entityHelpers";
 export * from "./helpers/licenseHelper";
 
 export * from "./deno-std/http/cookie";

package/src/plugins/cronJob/CronJobPluginTypes.ts

@@ -6,6 +6,7 @@ export type RunCronJobActionHandlerOptions = {
 
 export type RunCronJobInput = {
   code?: string;
+  input?: any;
 };
 
 export type NamedCronJobInstance = {

package/src/plugins/cronJob/actionHandlers/runCronJob.ts

@@ -25,7 +25,15 @@ export async function handler(plugin: CronJobPlugin, ctx: ActionHandlerContext,
     throw new Error(`Cron job with code '${input.code}' was not found.`);
   }
 
-  await cronJobService.executeJob(job);
+  let jobExecutionContext: ActionHandlerContext = {
+    logger: server.getLogger(),
+    routerContext,
+    next: null,
+    server,
+    applicationConfig: null,
+    input: input.input,
+  };
+  await cronJobService.executeJob(jobExecutionContext, job);
 
   response.json({});
 }

package/src/plugins/cronJob/services/CronJobService.ts

@@ -48,7 +48,7 @@ export default class CronJobService {
         ...(job.jobOptions || {}),
         cronTime: job.cronTime,
         onTick: async () => {
-          await this.tryExecuteJob(server, job);
+          await this.tryExecuteJob(job);
         },
       });
       jobInstance.start();
@@ -60,15 +60,33 @@ export default class CronJobService {
     }
   }
 
-  async tryExecuteJob(server: IRpdServer, job: CronJobConfiguration) {
+  async tryExecuteJob(job: CronJobConfiguration) {
+    const server = this.#server;
     const logger = server.getLogger();
     logger.info(`Executing cron job '${job.code}'...`);
 
+    let handlerContext: ActionHandlerContext = {
+      logger,
+      routerContext: RouteContext.newSystemOperationContext(server),
+      next: null,
+      server,
+      applicationConfig: null,
+      input: null,
+    };
+
     try {
-      await this.executeJob(job);
+      await this.executeJob(handlerContext, job);
       logger.info(`Completed cron job '${job.code}'...`);
     } catch (ex: any) {
-      logger.error('Cron job "%s" execution error: %s', job.code, ex.message, { cronJobCode: job.code });
+      logger.error('Cron job "%s" execution error: %s', job.code, ex.message);
+
+      if (job.onError) {
+        try {
+          await job.onError(handlerContext, ex);
+        } catch (ex) {
+          logger.error('Error handler of cron job "%s" execution failed: %s', job.code, ex.message);
+        }
+      }
     }
   }
 
@@ -76,20 +94,10 @@ export default class CronJobService {
    * 执行指定任务
    * @param job
    */
-  async executeJob(job: CronJobConfiguration) {
+  async executeJob(handlerContext: ActionHandlerContext, job: CronJobConfiguration) {
     const server = this.#server;
-    const logger = server.getLogger();
     validateLicense(server);
 
-    let handlerContext: ActionHandlerContext = {
-      logger,
-      routerContext: RouteContext.newSystemOperationContext(server),
-      next: null,
-      server,
-      applicationConfig: null,
-      input: null,
-    };
-
     if (job.actionHandlerCode) {
       const actionHandler = server.getActionHandlerByCode(job.code);
       await actionHandler(handlerContext, job.handleOptions);

package/src/types/cron-job-types.ts

@@ -43,6 +43,14 @@ export interface CronJobConfiguration {
    * 处理定时任务时的设置选项
    */
   handleOptions?: any;
+
+  /**
+   * 定时任务执行失败时的处理
+   * @param ctx
+   * @param error
+   * @returns
+   */
+  onError?: (ctx: ActionHandlerContext, error: any) => Promise<void>;
 }
 
 export interface CronJobOptions {

package/src/utilities/timeUtility.ts

@@ -7,3 +7,7 @@ export function getNowString() {
 export function getNowStringWithTimezone() {
   return dayjs().format("YYYY-MM-DD HH:mm:ss.SSSZ");
 }
+
+export function getDateString(timeString) {
+  return dayjs(timeString).format("YYYY-MM-DD");
+}