@ruiapp/rapid-core 0.2.2 → 0.2.3

package/dist/helpers/filterHelper.d.ts

@@ -1,2 +1,5 @@
-import { EntityFilterOptions } from "../types";
+import { EntityFilterOptions, RpdDataModel, RpdDataModelIndexOptions } from "../types";
+import { RowFilterOptions } from "../dataAccess/dataAccessTypes";
 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;

package/dist/helpers/metaHelper.d.ts

@@ -7,4 +7,6 @@ export declare function getEntityProperties(server: IRpdServer, model: RpdDataMo
 export declare function getEntityPropertiesIncludingBase(server: IRpdServer, model: RpdDataModel): RpdDataModelProperty[];
 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;
+export declare function getEntityOwnProperty(model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined;
 export declare function getEntityPropertyByFieldName(server: IRpdServer, model: RpdDataModel, fieldName: string): RpdDataModelProperty | undefined;

package/dist/index.js

@@ -2064,6 +2064,13 @@ function getEntityProperty(server, model, predicate) {
     }
     return property;
 }
+function getEntityOwnPropertyByCode(model, propertyCode) {
+    return getEntityOwnProperty(model, (e) => e.code === propertyCode);
+}
+function getEntityOwnProperty(model, predicate) {
+    let property = model.properties.find(predicate);
+    return property;
+}
 function getEntityPropertyByFieldName(server, model, fieldName) {
     let property = getEntityPropertyByCode(server, model, fieldName);
     if (!property) {
@@ -4150,6 +4157,120 @@ var getMetaModelDetail = /*#__PURE__*/Object.freeze({
   handler: handler$r
 });
 
+function removeFiltersWithNullValue(filters) {
+    const result = [];
+    if (!filters) {
+        return result;
+    }
+    for (const filter of filters) {
+        const { operator } = filter;
+        switch (operator) {
+            case "null":
+            case "notNull":
+                result.push(filter);
+                break;
+            case "exists":
+            case "notExists":
+            case "and":
+            case "or":
+                const transformedFilter = transformFilterWithSubFilters(filter);
+                if (transformedFilter !== null) {
+                    result.push(transformedFilter);
+                }
+                break;
+            default:
+                if (!isNullOrUndefined(filter.value)) {
+                    result.push(filter);
+                }
+        }
+    }
+    return result;
+}
+function transformFilterWithSubFilters(filter) {
+    const subFilters = removeFiltersWithNullValue(filter.filters);
+    if (!subFilters.length) {
+        return null;
+    }
+    filter.filters = subFilters;
+    return filter;
+}
+function convertModelIndexConditionsToRowFilterOptions(model, filters) {
+    if (!filters || !filters.length) {
+        return [];
+    }
+    const replacedFilters = [];
+    for (const filter of filters) {
+        const { operator } = filter;
+        if (operator === "and" || operator === "or") {
+            replacedFilters.push({
+                operator: operator,
+                filters: convertModelIndexConditionsToRowFilterOptions(model, filter.filters),
+            });
+        }
+        else {
+            replacedFilters.push(replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter));
+        }
+    }
+    return replacedFilters;
+}
+function replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter) {
+    const { operator } = filter;
+    const filterField = filter.field;
+    let property = getEntityOwnPropertyByCode(model, filterField);
+    let filterValue = filter.value;
+    let columnName = "";
+    if (property) {
+        if (isOneRelationProperty(property)) {
+            columnName = property.targetIdColumnName;
+            if (lodash.isPlainObject(filterValue)) {
+                filterValue = filterValue.id;
+            }
+        }
+        else if (isManyRelationProperty(property)) {
+            throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+        }
+        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.`);
+    }
+    else {
+        property = getEntityOwnProperty(model, (property) => {
+            return property.columnName === filterField;
+        });
+        if (property) {
+            columnName = property.columnName;
+        }
+        else {
+            // may be relation property.
+            property = getEntityOwnProperty(model, (property) => {
+                return property.targetIdColumnName === filterField;
+            });
+            if (property) {
+                if (isManyRelationProperty(property)) {
+                    throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+                }
+                columnName = property.targetIdColumnName;
+                if (lodash.isPlainObject(filterValue)) {
+                    filterValue = filterValue.id;
+                }
+            }
+            else {
+                throw new Error(`Unknown field "${filterField}" in index conditions.`);
+            }
+        }
+    }
+    // TODO: do not use `any` here
+    return {
+        operator: filter.operator,
+        field: columnName,
+        value: filterValue,
+        itemType: filter.itemType,
+    };
+}
+
 /**
  * Meta manager plugin
  */
@@ -4431,6 +4552,7 @@ async function syncDatabaseSchema(server, applicationConfig) {
         if (!model.indexes || !model.indexes.length) {
             continue;
         }
+        logger.debug(`Creating indexes of table ${queryBuilder.quoteTable(model)}`);
         for (const index of model.indexes) {
             const sqlCreateIndex = generateTableIndexDDL(queryBuilder, server, model, index);
             await server.tryQueryDatabaseObject(sqlCreateIndex, []);
@@ -4508,7 +4630,8 @@ function generateTableIndexDDL(queryBuilder, server, model, index) {
         tableName: model.tableName,
     })} (${indexColumns.join(", ")})`;
     if (index.conditions) {
-        ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, index.conditions)}`;
+        const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(model, index.conditions);
+        ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, rowFilterOptions)}`;
     }
     return ddl;
 }
@@ -4537,44 +4660,6 @@ async function runCollectionEntityActionHandler(ctx, options, code, handleEntity
     }
 }
 
-function removeFiltersWithNullValue(filters) {
-    const result = [];
-    if (!filters) {
-        return result;
-    }
-    for (const filter of filters) {
-        const { operator } = filter;
-        switch (operator) {
-            case "null":
-            case "notNull":
-                result.push(filter);
-                break;
-            case "exists":
-            case "notExists":
-            case "and":
-            case "or":
-                const transformedFilter = transformFilterWithSubFilters(filter);
-                if (transformedFilter !== null) {
-                    result.push(transformedFilter);
-                }
-                break;
-            default:
-                if (!isNullOrUndefined(filter.value)) {
-                    result.push(filter);
-                }
-        }
-    }
-    return result;
-}
-function transformFilterWithSubFilters(filter) {
-    const subFilters = removeFiltersWithNullValue(filter.filters);
-    if (!subFilters.length) {
-        return null;
-    }
-    filter.filters = subFilters;
-    return filter;
-}
-
 const code$q = "findCollectionEntities";
 async function handler$q(plugin, ctx, options) {
     await runCollectionEntityActionHandler(ctx, options, code$q, async (entityManager, input) => {

package/package.json

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

package/src/helpers/filterHelper.ts

@@ -1,5 +1,17 @@
-import { EntityFilterOptions, FindEntityExistenceFilterOptions, FindEntityLogicalFilterOptions } from "~/types";
+import {
+  EntityFilterOptions,
+  EntityNonRelationPropertyFilterOptions,
+  FindEntityExistenceFilterOptions,
+  FindEntityLogicalFilterOptions,
+  RpdDataModel,
+  RpdDataModelIndexOptions,
+  RpdDataModelProperty,
+} from "~/types";
 import { isNullOrUndefined } from "~/utilities/typeUtility";
+import { getEntityOwnProperty, getEntityOwnPropertyByCode, isManyRelationProperty, isOneRelationProperty } from "./metaHelper";
+import { IRpdServer } from "~/core/server";
+import { isPlainObject } from "lodash";
+import { RowFilterOptions } from "~/dataAccess/dataAccessTypes";
 
 export function removeFiltersWithNullValue(filters?: EntityFilterOptions[]) {
   const result: EntityFilterOptions[] = [];
@@ -45,3 +57,79 @@ function transformFilterWithSubFilters(
   filter.filters = subFilters;
   return filter;
 }
+
+export function convertModelIndexConditionsToRowFilterOptions(model: RpdDataModel, filters: RpdDataModelIndexOptions[]) {
+  if (!filters || !filters.length) {
+    return [];
+  }
+
+  const replacedFilters: RowFilterOptions[] = [];
+  for (const filter of filters) {
+    const { operator } = filter;
+    if (operator === "and" || operator === "or") {
+      replacedFilters.push({
+        operator: operator,
+        filters: convertModelIndexConditionsToRowFilterOptions(model, filter.filters),
+      });
+    } else {
+      replacedFilters.push(replaceModelIndexConditionEntityPropertyWithTableColumn(model, filter));
+    }
+  }
+  return replacedFilters;
+}
+export function replaceModelIndexConditionEntityPropertyWithTableColumn(model: RpdDataModel, filter: RpdDataModelIndexOptions): RowFilterOptions {
+  const { operator } = filter;
+  const filterField = (filter as EntityNonRelationPropertyFilterOptions).field;
+  let property: RpdDataModelProperty = getEntityOwnPropertyByCode(model, filterField);
+
+  let filterValue = (filter as any).value;
+
+  let columnName = "";
+  if (property) {
+    if (isOneRelationProperty(property)) {
+      columnName = property.targetIdColumnName;
+      if (isPlainObject(filterValue)) {
+        filterValue = filterValue.id;
+      }
+    } else if (isManyRelationProperty(property)) {
+      throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+    } 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.`);
+  } else {
+    property = getEntityOwnProperty(model, (property) => {
+      return property.columnName === filterField;
+    });
+
+    if (property) {
+      columnName = property.columnName;
+    } else {
+      // may be relation property.
+      property = getEntityOwnProperty(model, (property) => {
+        return property.targetIdColumnName === filterField;
+      });
+
+      if (property) {
+        if (isManyRelationProperty(property)) {
+          throw new Error(`Condition on many-relation property "${property.code}" is not supported.`);
+        }
+        columnName = property.targetIdColumnName;
+        if (isPlainObject(filterValue)) {
+          filterValue = filterValue.id;
+        }
+      } else {
+        throw new Error(`Unknown field "${filterField}" in index conditions.`);
+      }
+    }
+  }
+
+  // TODO: do not use `any` here
+  return {
+    operator: filter.operator,
+    field: columnName,
+    value: filterValue,
+    itemType: (filter as any).itemType,
+  } as RowFilterOptions;
+}

package/src/helpers/metaHelper.ts

@@ -66,6 +66,15 @@ export function getEntityProperty(
   return property;
 }
 
+export function getEntityOwnPropertyByCode(model: RpdDataModel, propertyCode: string): RpdDataModelProperty | undefined {
+  return getEntityOwnProperty(model, (e) => e.code === propertyCode);
+}
+
+export function getEntityOwnProperty(model: RpdDataModel, predicate: (item: RpdDataModelProperty) => boolean): RpdDataModelProperty | undefined {
+  let property = model.properties.find(predicate);
+  return property;
+}
+
 export function getEntityPropertyByFieldName(server: IRpdServer, model: RpdDataModel, fieldName: string): RpdDataModelProperty | undefined {
   let property = getEntityPropertyByCode(server, model, fieldName);
   if (!property) {

package/src/plugins/metaManage/MetaManagePlugin.ts

@@ -30,6 +30,7 @@ import { find, isString, map } from "lodash";
 import { getEntityPropertiesIncludingBase, getEntityPropertyByCode, isOneRelationProperty, isRelationProperty } from "~/helpers/metaHelper";
 import { DataAccessPgColumnTypes } from "~/dataAccess/dataAccessTypes";
 import { pgPropertyTypeColumnMap } from "~/dataAccess/columnTypeMapper";
+import { convertModelIndexConditionsToRowFilterOptions } from "~/helpers/filterHelper";
 
 class MetaManager implements RapidPlugin {
   get code(): string {
@@ -388,6 +389,7 @@ async function syncDatabaseSchema(server: IRpdServer, applicationConfig: RpdAppl
       continue;
     }
 
+    logger.debug(`Creating indexes of table ${queryBuilder.quoteTable(model)}`);
     for (const index of model.indexes) {
       const sqlCreateIndex = generateTableIndexDDL(queryBuilder, server, model, index);
       await server.tryQueryDatabaseObject(sqlCreateIndex, []);
@@ -493,7 +495,8 @@ function generateTableIndexDDL(queryBuilder: IQueryBuilder, server: IRpdServer,
   })} (${indexColumns.join(", ")})`;
 
   if (index.conditions) {
-    ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, index.conditions)}`;
+    const rowFilterOptions = convertModelIndexConditionsToRowFilterOptions(model, index.conditions);
+    ddl += ` WHERE ${queryBuilder.buildFiltersExpression(model, rowFilterOptions)}`;
   }
 
   return ddl;