@ruiapp/rapid-core 0.2.1 → 0.2.3

package/dist/dataAccess/entityManager.d.ts

@@ -1,4 +1,4 @@
-import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, FindEntitySelectRelationOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, RpdDataModelIndex, RpdDataModelProperty, UpdateEntityByIdOptions } from "../types";
+import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, RpdDataModelIndex, RpdDataModelProperty, UpdateEntityByIdOptions, FindEntityFindOneRelationEntitiesOptions, FindEntityFindManyRelationEntitiesOptions } from "../types";
 import { IRpdServer, RapidPlugin } from "../core/server";
 import { RouteContext } from "../core/routeContext";
 export type FindOneRelationEntitiesOptions = {
@@ -6,14 +6,14 @@ export type FindOneRelationEntitiesOptions = {
     mainModel: RpdDataModel;
     relationProperty: RpdDataModelProperty;
     relationEntityIds: any[];
-    selectRelationOptions?: FindEntitySelectRelationOptions;
+    selectRelationOptions?: FindEntityFindOneRelationEntitiesOptions;
 };
 export type FindManyRelationEntitiesOptions = {
     server: IRpdServer;
     mainModel: RpdDataModel;
     relationProperty: RpdDataModelProperty;
     mainEntityIds: any[];
-    selectRelationOptions?: FindEntitySelectRelationOptions;
+    selectRelationOptions?: FindEntityFindManyRelationEntitiesOptions;
 };
 export type CheckEntityDuplicatedOptions = {
     routeContext?: RouteContext;

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) {
@@ -2748,7 +2755,9 @@ async function findManyRelationLinksViaLinkTable(options) {
     const command = `SELECT * FROM ${server.queryBuilder.quoteTable({
         schema: relationProperty.linkSchema,
         tableName: relationProperty.linkTableName,
-    })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName)} = ANY($1::int[])`;
+    })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName)} = ANY($1::int[])
+    ORDER BY id
+  `;
     const params = [mainEntityIds];
     const links = await server.queryDatabaseObject(command, params);
     const targetEntityIds = links.map((link) => link[relationProperty.targetIdColumnName]);
@@ -2774,6 +2783,18 @@ async function findManyRelationLinksViaLinkTable(options) {
             if (selectRelationOptions.relations) {
                 findEntityOptions.relations = selectRelationOptions.relations;
             }
+            if (selectRelationOptions.orderBy) {
+                findEntityOptions.orderBy = selectRelationOptions.orderBy;
+            }
+            if (selectRelationOptions.pagination) {
+                findEntityOptions.pagination = selectRelationOptions.pagination;
+            }
+            if (selectRelationOptions.filters) {
+                findEntityOptions.filters = [...findEntityOptions.filters, ...selectRelationOptions.filters];
+            }
+            if (!lodash.isUndefined(selectRelationOptions.keepNonPropertyFields)) {
+                findEntityOptions.keepNonPropertyFields = selectRelationOptions.keepNonPropertyFields;
+            }
         }
     }
     const targetEntities = await findEntities(server, dataAccessor, findEntityOptions);
@@ -2795,6 +2816,11 @@ async function findManyRelatedEntitiesViaIdPropertyCode(options) {
                 value: mainEntityIds,
             },
         ],
+        orderBy: [
+            {
+                field: "id",
+            },
+        ],
         extraColumnsToSelect: [relationProperty.selfIdColumnName],
         keepNonPropertyFields: true,
     };
@@ -2806,6 +2832,18 @@ async function findManyRelatedEntitiesViaIdPropertyCode(options) {
             if (selectRelationOptions.relations) {
                 findEntityOptions.relations = selectRelationOptions.relations;
             }
+            if (selectRelationOptions.orderBy) {
+                findEntityOptions.orderBy = selectRelationOptions.orderBy;
+            }
+            if (selectRelationOptions.pagination) {
+                findEntityOptions.pagination = selectRelationOptions.pagination;
+            }
+            if (selectRelationOptions.filters) {
+                findEntityOptions.filters = [...findEntityOptions.filters, ...selectRelationOptions.filters];
+            }
+            if (!lodash.isUndefined(selectRelationOptions.keepNonPropertyFields)) {
+                findEntityOptions.keepNonPropertyFields = selectRelationOptions.keepNonPropertyFields;
+            }
         }
     }
     return await findEntities(server, dataAccessor, findEntityOptions);
@@ -4119,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
  */
@@ -4400,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, []);
@@ -4477,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;
 }
@@ -4506,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/dist/types.d.ts

@@ -391,7 +391,7 @@ export interface FindEntityOptions {
     orderBy?: FindEntityOrderByOptions[];
     pagination?: FindEntityPaginationOptions;
     properties?: string[];
-    relations?: Record<string, FindEntitySelectRelationOptions>;
+    relations?: Record<string, FindEntityFindRelationEntitiesOptions>;
     extraColumnsToSelect?: ColumnSelectOptions[];
     keepNonPropertyFields?: boolean;
 }
@@ -399,7 +399,7 @@ export interface FindEntityByIdOptions {
     routeContext?: RouteContext;
     id: any;
     properties?: string[];
-    relations?: Record<string, FindEntitySelectRelationOptions>;
+    relations?: Record<string, FindEntityFindRelationEntitiesOptions>;
     keepNonPropertyFields?: boolean;
 }
 export interface FindEntityRelationalFilterOptions {
@@ -437,9 +437,19 @@ export interface FindEntityPaginationOptions {
     limit: number;
     withoutTotal?: boolean;
 }
-export type FindEntitySelectRelationOptions = true | {
+export type FindEntityFindRelationEntitiesOptions = FindEntityFindOneRelationEntitiesOptions | FindEntityFindManyRelationEntitiesOptions;
+export type FindEntityFindOneRelationEntitiesOptions = true | {
     properties?: string[];
-    relations?: Record<string, FindEntitySelectRelationOptions>;
+    relations?: Record<string, FindEntityFindRelationEntitiesOptions>;
+    keepNonPropertyFields?: boolean;
+};
+export type FindEntityFindManyRelationEntitiesOptions = true | {
+    properties?: string[];
+    relations?: Record<string, FindEntityFindRelationEntitiesOptions>;
+    filters?: EntityFilterOptions[];
+    orderBy?: FindEntityOrderByOptions[];
+    pagination?: FindEntityPaginationOptions;
+    keepNonPropertyFields?: boolean;
 };
 export interface FindEntityOrderByOptions {
     field: string;

package/package.json

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

package/src/dataAccess/entityManager.ts

@@ -10,7 +10,6 @@ import {
   FindEntityByIdOptions,
   FindEntityOptions,
   FindEntityOrderByOptions,
-  FindEntitySelectRelationOptions,
   IRpdDataAccessor,
   RemoveEntityRelationsOptions,
   RpdDataModel,
@@ -18,13 +17,15 @@ import {
   RpdDataModelIndexOptions,
   RpdDataModelProperty,
   UpdateEntityByIdOptions,
+  FindEntityFindOneRelationEntitiesOptions,
+  FindEntityFindManyRelationEntitiesOptions,
 } from "~/types";
 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 { cloneDeep, filter, find, first, forEach, isArray, isNumber, isObject, isPlainObject, isString, keys, map, reject, uniq } from "lodash";
+import { cloneDeep, filter, find, first, forEach, isArray, isNumber, isObject, isPlainObject, isString, isUndefined, keys, map, reject, uniq } from "lodash";
 import {
   getEntityPropertiesIncludingBase,
   getEntityProperty,
@@ -37,7 +38,6 @@ import {
 import { ColumnSelectOptions, CountRowOptions, FindRowOptions, FindRowOrderByOptions, RowFilterOptions } from "./dataAccessTypes";
 import { newEntityOperationError } from "~/utilities/errorUtility";
 import { getNowStringWithTimezone } from "~/utilities/timeUtility";
-import { or } from "xstate";
 import { RouteContext } from "~/core/routeContext";
 
 export type FindOneRelationEntitiesOptions = {
@@ -45,7 +45,7 @@ export type FindOneRelationEntitiesOptions = {
   mainModel: RpdDataModel;
   relationProperty: RpdDataModelProperty;
   relationEntityIds: any[];
-  selectRelationOptions?: FindEntitySelectRelationOptions;
+  selectRelationOptions?: FindEntityFindOneRelationEntitiesOptions;
 };
 
 export type FindManyRelationEntitiesOptions = {
@@ -53,7 +53,7 @@ export type FindManyRelationEntitiesOptions = {
   mainModel: RpdDataModel;
   relationProperty: RpdDataModelProperty;
   mainEntityIds: any[];
-  selectRelationOptions?: FindEntitySelectRelationOptions;
+  selectRelationOptions?: FindEntityFindManyRelationEntitiesOptions;
 };
 
 function convertEntityOrderByToRowOrderBy(server: IRpdServer, model: RpdDataModel, baseModel?: RpdDataModel, orderByList?: FindEntityOrderByOptions[]) {
@@ -583,7 +583,9 @@ async function findManyRelationLinksViaLinkTable(options: FindManyRelationEntiti
   const command = `SELECT * FROM ${server.queryBuilder.quoteTable({
     schema: relationProperty.linkSchema,
     tableName: relationProperty.linkTableName!,
-  })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName!)} = ANY($1::int[])`;
+  })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName!)} = ANY($1::int[])
+    ORDER BY id
+  `;
   const params = [mainEntityIds];
   const links = await server.queryDatabaseObject(command, params);
   const targetEntityIds = links.map((link) => link[relationProperty.targetIdColumnName!]);
@@ -612,6 +614,18 @@ async function findManyRelationLinksViaLinkTable(options: FindManyRelationEntiti
       if (selectRelationOptions.relations) {
         findEntityOptions.relations = selectRelationOptions.relations;
       }
+      if (selectRelationOptions.orderBy) {
+        findEntityOptions.orderBy = selectRelationOptions.orderBy;
+      }
+      if (selectRelationOptions.pagination) {
+        findEntityOptions.pagination = selectRelationOptions.pagination;
+      }
+      if (selectRelationOptions.filters) {
+        findEntityOptions.filters = [...findEntityOptions.filters, ...selectRelationOptions.filters];
+      }
+      if (!isUndefined(selectRelationOptions.keepNonPropertyFields)) {
+        findEntityOptions.keepNonPropertyFields = selectRelationOptions.keepNonPropertyFields;
+      }
     }
   }
 
@@ -638,6 +652,11 @@ async function findManyRelatedEntitiesViaIdPropertyCode(options: FindManyRelatio
         value: mainEntityIds,
       },
     ],
+    orderBy: [
+      {
+        field: "id",
+      },
+    ],
     extraColumnsToSelect: [relationProperty.selfIdColumnName],
     keepNonPropertyFields: true,
   };
@@ -650,6 +669,18 @@ async function findManyRelatedEntitiesViaIdPropertyCode(options: FindManyRelatio
       if (selectRelationOptions.relations) {
         findEntityOptions.relations = selectRelationOptions.relations;
       }
+      if (selectRelationOptions.orderBy) {
+        findEntityOptions.orderBy = selectRelationOptions.orderBy;
+      }
+      if (selectRelationOptions.pagination) {
+        findEntityOptions.pagination = selectRelationOptions.pagination;
+      }
+      if (selectRelationOptions.filters) {
+        findEntityOptions.filters = [...findEntityOptions.filters, ...selectRelationOptions.filters];
+      }
+      if (!isUndefined(selectRelationOptions.keepNonPropertyFields)) {
+        findEntityOptions.keepNonPropertyFields = selectRelationOptions.keepNonPropertyFields;
+      }
     }
   }
 

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;

package/src/types.ts

@@ -509,7 +509,7 @@ export interface FindEntityOptions {
   orderBy?: FindEntityOrderByOptions[];
   pagination?: FindEntityPaginationOptions;
   properties?: string[];
-  relations?: Record<string, FindEntitySelectRelationOptions>;
+  relations?: Record<string, FindEntityFindRelationEntitiesOptions>;
   extraColumnsToSelect?: ColumnSelectOptions[];
   keepNonPropertyFields?: boolean;
 }
@@ -518,7 +518,7 @@ export interface FindEntityByIdOptions {
   routeContext?: RouteContext;
   id: any;
   properties?: string[];
-  relations?: Record<string, FindEntitySelectRelationOptions>;
+  relations?: Record<string, FindEntityFindRelationEntitiesOptions>;
   keepNonPropertyFields?: boolean;
 }
 
@@ -564,11 +564,25 @@ export interface FindEntityPaginationOptions {
   withoutTotal?: boolean;
 }
 
-export type FindEntitySelectRelationOptions =
+export type FindEntityFindRelationEntitiesOptions = FindEntityFindOneRelationEntitiesOptions | FindEntityFindManyRelationEntitiesOptions;
+
+export type FindEntityFindOneRelationEntitiesOptions =
+  | true
+  | {
+      properties?: string[];
+      relations?: Record<string, FindEntityFindRelationEntitiesOptions>;
+      keepNonPropertyFields?: boolean;
+    };
+
+export type FindEntityFindManyRelationEntitiesOptions =
   | true
   | {
       properties?: string[];
-      relations?: Record<string, FindEntitySelectRelationOptions>;
+      relations?: Record<string, FindEntityFindRelationEntitiesOptions>;
+      filters?: EntityFilterOptions[];
+      orderBy?: FindEntityOrderByOptions[];
+      pagination?: FindEntityPaginationOptions;
+      keepNonPropertyFields?: boolean;
     };
 
 export interface FindEntityOrderByOptions {