@ruiapp/rapid-core 0.2.5 → 0.2.6

package/dist/helpers/filterHelper.d.ts

@@ -1,5 +1,6 @@
 import { EntityFilterOptions, RpdDataModel, RpdDataModelIndexOptions } from "../types";
 import { RowFilterOptions } from "../dataAccess/dataAccessTypes";
+import { Logger } from "../facilities/log/LogFacility";
 export declare function removeFiltersWithNullValue(filters?: EntityFilterOptions[]): EntityFilterOptions[];
-export declare function convertModelIndexConditionsToRowFilterOptions(model: RpdDataModel, filters: RpdDataModelIndexOptions[]): RowFilterOptions[];
-export declare function replaceModelIndexConditionEntityPropertyWithTableColumn(model: RpdDataModel, filter: RpdDataModelIndexOptions): RowFilterOptions;
+export declare function convertModelIndexConditionsToRowFilterOptions(logger: Logger, model: RpdDataModel, filters: RpdDataModelIndexOptions[]): RowFilterOptions[];
+export declare function replaceModelIndexConditionEntityPropertyWithTableColumn(logger: Logger, model: RpdDataModel, filter: RpdDataModelIndexOptions): RowFilterOptions;

package/dist/index.js

@@ -1649,6 +1649,14 @@ var bootstrapApplicationConfig = {
                     type: "text",
                     required: false,
                 },
+                {
+                    name: "readonly",
+                    code: "readonly",
+                    columnName: "readonly",
+                    type: "boolean",
+                    required: true,
+                    defaultValue: "false",
+                },
                 {
                     name: "config",
                     code: "config",
@@ -3157,6 +3165,23 @@ async function updateEntityById(server, dataAccessor, options, plugin) {
         routeContext: options.routeContext,
     });
     changes = getEntityPartChanges(server, model, entity, entityToSave);
+    // check readonly properties
+    Object.keys(changes).forEach((propertyName) => {
+        let isReadonlyProperty = false;
+        const property = getEntityPropertyByCode(server, model, propertyName);
+        if (property && property.readonly) {
+            isReadonlyProperty = true;
+        }
+        else {
+            const oneRelationProperty = getEntityProperty(server, model, (item) => item.relation === "one" && item.targetIdColumnName === propertyName);
+            if (oneRelationProperty && oneRelationProperty.readonly) {
+                isReadonlyProperty = true;
+            }
+        }
+        if (isReadonlyProperty) {
+            throw new Error(`Updating "${property.name}" property is not allowed because it's readonly.`);
+        }
+    });
     // check unique constraints
     if (!options.postponeUniquenessCheck) {
         if (model.indexes && model.indexes.length) {
@@ -4215,7 +4240,7 @@ function transformFilterWithSubFilters(filter) {
     filter.filters = subFilters;
     return filter;
 }
-function convertModelIndexConditionsToRowFilterOptions(model, filters) {
+function convertModelIndexConditionsToRowFilterOptions(logger, model, filters) {
     if (!filters || !filters.length) {
         return [];
     }
@@ -4225,16 +4250,19 @@ function convertModelIndexConditionsToRowFilterOptions(model, filters) {
         if (operator === "and" || operator === "or") {
             replacedFilters.push({
                 operator: operator,
-                filters: convertModelIndexConditionsToRowFilterOptions(model, filter.filters),
+                filters: convertModelIndexConditionsToRowFilterOptions(logger, model, filter.filters),
             });
         }
         else {
-            replacedFilters.push(replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter));
+            const replacedFilter = replaceModelIndexConditionEntityPropertyWithTableColumn(logger, model, filter);
+            if (replacedFilter) {
+                replacedFilters.push(replacedFilter);
+            }
         }
     }
     return replacedFilters;
 }
-function replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter) {
+function replaceModelIndexConditionEntityPropertyWithTableColumn(logger, model, filter) {
     const { operator } = filter;
     const filterField = filter.field;
     let property = getEntityOwnPropertyByCode(model, filterField);
@@ -4248,14 +4276,16 @@ function replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter)
             }
         }
         else if (isManyRelationProperty(property)) {
-            throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+            logger.warn(`Index condition on many-relation property "${property.code}" is not supported.`);
+            return null;
         }
         else {
             columnName = property.columnName || property.code;
         }
     }
     else if (operator === "exists" || operator === "notExists") {
-        throw new Error(`"exists" and "notExists" operators are not supported in index conditions.`);
+        logger.warn(`"exists" and "notExists" operators are not supported in index conditions.`);
+        return null;
     }
     else {
         property = getEntityOwnProperty(model, (property) => {
@@ -4271,7 +4301,8 @@ function replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter)
             });
             if (property) {
                 if (isManyRelationProperty(property)) {
-                    throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+                    logger.warn(`Index condition on many-relation property "${property.code}" is not supported.`);
+                    return null;
                 }
                 columnName = property.targetIdColumnName;
                 if (lodash.isPlainObject(filterValue)) {
@@ -4279,7 +4310,8 @@ function replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter)
                 }
             }
             else {
-                throw new Error(`Unknown field "${filterField}" in index conditions.`);
+                logger.warn(`Unknown field "${filterField}" in index conditions.`);
+                return null;
             }
         }
     }
@@ -4651,7 +4683,8 @@ function generateTableIndexDDL(queryBuilder, server, model, index) {
         tableName: model.tableName,
     })} (${indexColumns.join(", ")})`;
     if (index.conditions) {
-        const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(model, index.conditions);
+        const logger = server.getLogger();
+        const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(logger, model, index.conditions);
         ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, rowFilterOptions)}`;
     }
     return ddl;

package/dist/types.d.ts

@@ -272,6 +272,10 @@ export interface RpdDataModelProperty {
      * 当设置了 linkTableName 时，可以设置关联关系表所在的 Schema。
      */
     linkSchema?: string;
+    /**
+     * 当设置为`true`时，仅允许在创建时设置此属性的值，不允许更新。
+     */
+    readonly?: boolean;
 }
 export type RpdDataPropertyTypes = "integer" | "long" | "float" | "double" | "decimal" | "text" | "boolean" | "date" | "time" | "datetime" | "json" | "relation" | "relation[]" | "option" | "option[]" | "file" | "file[]" | "image" | "image[]";
 /**

package/package.json

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

package/src/bootstrapApplicationConfig.ts

@@ -229,6 +229,14 @@ export default {
           type: "text",
           required: false,
         },
+        {
+          name: "readonly",
+          code: "readonly",
+          columnName: "readonly",
+          type: "boolean",
+          required: true,
+          defaultValue: "false",
+        },
         {
           name: "config",
           code: "config",

package/src/dataAccess/entityManager.ts

@@ -1008,6 +1008,23 @@ async function updateEntityById(server: IRpdServer, dataAccessor: IRpdDataAccess
 
   changes = getEntityPartChanges(server, model, entity, entityToSave);
 
+  // check readonly properties
+  Object.keys(changes).forEach((propertyName) => {
+    let isReadonlyProperty = false;
+    const property = getEntityPropertyByCode(server, model, propertyName);
+    if (property && property.readonly) {
+      isReadonlyProperty = true;
+    } else {
+      const oneRelationProperty = getEntityProperty(server, model, (item) => item.relation === "one" && item.targetIdColumnName === propertyName);
+      if (oneRelationProperty && oneRelationProperty.readonly) {
+        isReadonlyProperty = true;
+      }
+    }
+    if (isReadonlyProperty) {
+      throw new Error(`Updating "${property.name}" property is not allowed because it's readonly.`);
+    }
+  });
+
   // check unique constraints
   if (!options.postponeUniquenessCheck) {
     if (model.indexes && model.indexes.length) {

package/src/helpers/filterHelper.ts

@@ -12,6 +12,7 @@ import { getEntityOwnProperty, getEntityOwnPropertyByCode, isManyRelationPropert
 import { IRpdServer } from "~/core/server";
 import { isPlainObject } from "lodash";
 import { RowFilterOptions } from "~/dataAccess/dataAccessTypes";
+import { Logger } from "~/facilities/log/LogFacility";
 
 export function removeFiltersWithNullValue(filters?: EntityFilterOptions[]) {
   const result: EntityFilterOptions[] = [];
@@ -58,7 +59,7 @@ function transformFilterWithSubFilters(
   return filter;
 }
 
-export function convertModelIndexConditionsToRowFilterOptions(model: RpdDataModel, filters: RpdDataModelIndexOptions[]) {
+export function convertModelIndexConditionsToRowFilterOptions(logger: Logger, model: RpdDataModel, filters: RpdDataModelIndexOptions[]) {
   if (!filters || !filters.length) {
     return [];
   }
@@ -69,15 +70,23 @@ export function convertModelIndexConditionsToRowFilterOptions(model: RpdDataMode
     if (operator === "and" || operator === "or") {
       replacedFilters.push({
         operator: operator,
-        filters: convertModelIndexConditionsToRowFilterOptions(model, filter.filters),
+        filters: convertModelIndexConditionsToRowFilterOptions(logger, model, filter.filters),
       });
     } else {
-      replacedFilters.push(replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter));
+      const replacedFilter = replaceModelIndexConditionEntityPropertyWithTableColumn(logger, model, filter);
+      if (replacedFilter) {
+        replacedFilters.push(replacedFilter);
+      }
     }
   }
   return replacedFilters;
 }
-export function replaceModelIndexConditionEntityPropertyWithTableColumn(model: RpdDataModel, filter: RpdDataModelIndexOptions): RowFilterOptions {
+
+export function replaceModelIndexConditionEntityPropertyWithTableColumn(
+  logger: Logger,
+  model: RpdDataModel,
+  filter: RpdDataModelIndexOptions,
+): RowFilterOptions {
   const { operator } = filter;
   const filterField = (filter as EntityNonRelationPropertyFilterOptions).field;
   let property: RpdDataModelProperty = getEntityOwnPropertyByCode(model, filterField);
@@ -92,12 +101,14 @@ export function replaceModelIndexConditionEntityPropertyWithTableColumn(model: R
         filterValue = filterValue.id;
       }
     } else if (isManyRelationProperty(property)) {
-      throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+      logger.warn(`Index condition on many-relation property "${property.code}" is not supported.`);
+      return null;
     } else {
       columnName = property.columnName || property.code;
     }
   } else if ((operator as any) === "exists" || (operator as any) === "notExists") {
-    throw new Error(`"exists" and "notExists" operators are not supported in index conditions.`);
+    logger.warn(`"exists" and "notExists" operators are not supported in index conditions.`);
+    return null;
   } else {
     property = getEntityOwnProperty(model, (property) => {
       return property.columnName === filterField;
@@ -113,14 +124,16 @@ export function replaceModelIndexConditionEntityPropertyWithTableColumn(model: R
 
       if (property) {
         if (isManyRelationProperty(property)) {
-          throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+          logger.warn(`Index condition on many-relation property "${property.code}" is not supported.`);
+          return null;
         }
         columnName = property.targetIdColumnName;
         if (isPlainObject(filterValue)) {
           filterValue = filterValue.id;
         }
       } else {
-        throw new Error(`Unknown field "${filterField}" in index conditions.`);
+        logger.warn(`Unknown field "${filterField}" in index conditions.`);
+        return null;
       }
     }
   }

package/src/plugins/metaManage/MetaManagePlugin.ts

@@ -495,7 +495,8 @@ function generateTableIndexDDL(queryBuilder: IQueryBuilder, server: IRpdServer,
   })} (${indexColumns.join(", ")})`;
 
   if (index.conditions) {
-    const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(model, index.conditions);
+    const logger = server.getLogger();
+    const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(logger, model, index.conditions);
     ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, rowFilterOptions)}`;
   }
 

package/src/types.ts

@@ -302,6 +302,11 @@ export interface RpdDataModelProperty {
    * 当设置了 linkTableName 时，可以设置关联关系表所在的 Schema。
    */
   linkSchema?: string;
+
+  /**
+   * 当设置为`true`时，仅允许在创建时设置此属性的值，不允许更新。
+   */
+  readonly?: boolean;
 }
 
 export type RpdDataPropertyTypes =