@ruiapp/rapid-core 0.1.62 → 0.1.63

package/dist/dataAccess/dataAccessTypes.d.ts

@@ -6,7 +6,7 @@ export type RowFilterExistenceOperators = "exists" | "notExists";
 export type RowFilterOperators = RowFilterRelationalOperators | RowFilterSetOperators | RowFilterLogicalOperators | RowFilterUnaryOperators | RowFilterExistenceOperators;
 export type RowFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowLogicalFilterOptions | FindRowUnaryFilterOptions | FindRowExistenceFilterOptions;
 export type RowNonRelationPropertyFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowUnaryFilterOptions;
-export type ColumnQueryOptions = string | ColumnNameWithTableName;
+export type ColumnSelectOptions = string | ColumnNameWithTableName;
 export type ColumnNameWithTableName = {
     name: string;
     tableName?: string;
@@ -15,16 +15,16 @@ export interface FindRowOptions {
     filters?: RowFilterOptions[];
     orderBy?: FindRowOrderByOptions[];
     pagination?: FindRowPaginationOptions;
-    fields?: ColumnQueryOptions[];
+    fields?: ColumnSelectOptions[];
     keepNonPropertyFields?: boolean;
 }
 export interface FindRowRelationalFilterOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     operator: RowFilterRelationalOperators;
     value: any;
 }
 export interface FindRowSetFilterOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     operator: RowFilterSetOperators;
     value: any[];
     itemType?: string;
@@ -34,11 +34,11 @@ export interface FindRowLogicalFilterOptions {
     filters: RowFilterOptions[];
 }
 export interface FindRowUnaryFilterOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     operator: RowFilterUnaryOperators;
 }
 export interface FindRowExistenceFilterOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     operator: RowFilterExistenceOperators;
     filters: RowFilterOptions[];
 }
@@ -48,7 +48,7 @@ export interface FindRowPaginationOptions {
     withoutTotal?: boolean;
 }
 export interface FindRowOrderByOptions {
-    field: ColumnQueryOptions;
+    field: ColumnSelectOptions;
     desc?: boolean;
 }
 export interface CountRowOptions {

package/dist/dataAccess/entityManager.d.ts

@@ -1,5 +1,19 @@
-import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, UpdateEntityByIdOptions } from "../types";
+import { AddEntityRelationsOptions, CountEntityOptions, CountEntityResult, CreateEntityOptions, DeleteEntityByIdOptions, FindEntityByIdOptions, FindEntityOptions, FindEntitySelectRelationOptions, IRpdDataAccessor, RemoveEntityRelationsOptions, RpdDataModel, RpdDataModelProperty, UpdateEntityByIdOptions } from "../types";
 import { IRpdServer, RapidPlugin } from "../core/server";
+export type FindOneRelationEntitiesOptions = {
+    server: IRpdServer;
+    mainModel: RpdDataModel;
+    relationProperty: RpdDataModelProperty;
+    relationEntityIds: any[];
+    selectRelationOptions?: FindEntitySelectRelationOptions;
+};
+export type FindManyRelationEntitiesOptions = {
+    server: IRpdServer;
+    mainModel: RpdDataModel;
+    relationProperty: RpdDataModelProperty;
+    mainEntityIds: any[];
+    selectRelationOptions?: FindEntitySelectRelationOptions;
+};
 export default class EntityManager<TEntity = any> {
     #private;
     constructor(server: IRpdServer, dataAccessor: IRpdDataAccessor);

package/dist/index.js

@@ -277,9 +277,11 @@ class QueryBuilder {
             command += `${this.quoteObject(derivedModel.tableName)}.* FROM `;
         }
         else {
-            command += columns.map((column) => {
+            command += columns
+                .map((column) => {
                 return this.quoteColumn(column, ctx.emitTableAlias);
-            }).join(", ");
+            })
+                .join(", ");
             command += " FROM ";
         }
         command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(baseModel.tableName)}.id`;
@@ -2001,16 +2003,18 @@ async function findEntities(server, dataAccessor, options) {
             singularCode: model.base,
         });
     }
-    let propertiesToSlect;
+    let propertiesToSelect;
+    let relationOptions = options.relations || {};
+    let relationPropertyCodes = Object.keys(relationOptions) || [];
     if (!options.properties || !options.properties.length) {
-        propertiesToSlect = getEntityPropertiesIncludingBase(server, model).filter((property) => !isRelationProperty(property));
+        propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter((property) => !isRelationProperty(property) || relationPropertyCodes.includes(property.code));
     }
     else {
-        propertiesToSlect = getEntityPropertiesIncludingBase(server, model).filter((property) => options.properties.includes(property.code));
+        propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter((property) => options.properties.includes(property.code) || relationPropertyCodes.includes(property.code));
     }
     const columnsToSelect = [];
     const relationPropertiesToSelect = [];
-    lodash.forEach(propertiesToSlect, (property) => {
+    lodash.forEach(propertiesToSelect, (property) => {
         if (isRelationProperty(property)) {
             relationPropertiesToSelect.push(property);
             if (property.relation === "one" && !property.linkTableName) {
@@ -2058,6 +2062,31 @@ async function findEntities(server, dataAccessor, options) {
             }
         });
     }
+    if (options.extraColumnsToSelect) {
+        lodash.forEach(options.extraColumnsToSelect, (extraColumnToSelect) => {
+            const columnSelectOptionExists = lodash.find(columnsToSelect, (item) => {
+                if (typeof item === "string") {
+                    if (typeof extraColumnToSelect === "string") {
+                        return item === extraColumnToSelect;
+                    }
+                    else {
+                        return item == extraColumnToSelect.name;
+                    }
+                }
+                else {
+                    if (typeof extraColumnToSelect === "string") {
+                        return item.name === extraColumnToSelect;
+                    }
+                    else {
+                        return item.name == extraColumnToSelect.name;
+                    }
+                }
+            });
+            if (!columnSelectOptionExists) {
+                columnsToSelect.push(extraColumnToSelect);
+            }
+        });
+    }
     const rowFilters = await convertEntityFiltersToRowFilters(server, model, baseModel, options.filters);
     const findRowOptions = {
         filters: rowFilters,
@@ -2074,27 +2103,45 @@ async function findEntities(server, dataAccessor, options) {
         for (const relationProperty of relationPropertiesToSelect) {
             const isManyRelation = relationProperty.relation === "many";
             if (relationProperty.linkTableName) {
-                const targetModel = server.getModel({ singularCode: relationProperty.targetSingularCode });
-                if (!targetModel) {
+                const relationModel = server.getModel({ singularCode: relationProperty.targetSingularCode });
+                if (!relationModel) {
                     continue;
                 }
                 if (isManyRelation) {
-                    const relationLinks = await findManyRelationLinksViaLinkTable(server, targetModel, relationProperty, entityIds);
+                    const relationLinks = await findManyRelationLinksViaLinkTable({
+                        server,
+                        mainModel: relationModel,
+                        relationProperty,
+                        mainEntityIds: entityIds,
+                        selectRelationOptions: relationOptions[relationProperty.code],
+                    });
                     lodash.forEach(rows, (row) => {
                         row[relationProperty.code] = lodash.filter(relationLinks, (link) => {
                             return link[relationProperty.selfIdColumnName] == row["id"];
-                        }).map((link) => mapDbRowToEntity(server, targetModel, link.targetEntity, options.keepNonPropertyFields));
+                        }).map((link) => mapDbRowToEntity(server, relationModel, link.targetEntity, options.keepNonPropertyFields));
                     });
                 }
             }
             else {
                 let relatedEntities;
                 if (isManyRelation) {
-                    relatedEntities = await findManyRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, entityIds);
+                    relatedEntities = await findManyRelatedEntitiesViaIdPropertyCode({
+                        server,
+                        mainModel: model,
+                        relationProperty,
+                        mainEntityIds: entityIds,
+                        selectRelationOptions: relationOptions[relationProperty.code],
+                    });
                 }
                 else {
                     const targetEntityIds = lodash.uniq(lodash.reject(lodash.map(rows, (entity) => entity[relationProperty.targetIdColumnName]), isNullOrUndefined));
-                    relatedEntities = await findOneRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, targetEntityIds);
+                    relatedEntities = await findOneRelatedEntitiesViaIdPropertyCode({
+                        server,
+                        mainModel: model,
+                        relationProperty,
+                        relationEntityIds: targetEntityIds,
+                        selectRelationOptions: relationOptions[relationProperty.code],
+                    });
                 }
                 const targetModel = server.getModel({
                     singularCode: relationProperty.targetSingularCode,
@@ -2354,68 +2401,99 @@ async function convertEntityFiltersToRowFilters(server, model, baseModel, filter
     }
     return replacedFilters;
 }
-async function findManyRelationLinksViaLinkTable(server, targetModel, relationProperty, entityIds) {
+async function findManyRelationLinksViaLinkTable(options) {
+    const { server, relationProperty, mainModel: relationModel, mainEntityIds, selectRelationOptions } = options;
     const command = `SELECT * FROM ${server.queryBuilder.quoteTable({
         schema: relationProperty.linkSchema,
         tableName: relationProperty.linkTableName,
     })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName)} = ANY($1::int[])`;
-    const params = [entityIds];
+    const params = [mainEntityIds];
     const links = await server.queryDatabaseObject(command, params);
     const targetEntityIds = links.map((link) => link[relationProperty.targetIdColumnName]);
+    const dataAccessor = server.getDataAccessor({
+        namespace: relationModel.namespace,
+        singularCode: relationModel.singularCode,
+    });
     const findEntityOptions = {
         filters: [
             {
-                field: {
-                    name: "id",
-                },
+                field: "id",
                 operator: "in",
                 value: targetEntityIds,
             },
         ],
+        keepNonPropertyFields: true,
     };
-    const dataAccessor = server.getDataAccessor({
-        namespace: targetModel.namespace,
-        singularCode: targetModel.singularCode,
-    });
-    const targetEntities = await dataAccessor.find(findEntityOptions);
+    if (selectRelationOptions) {
+        if (typeof selectRelationOptions !== "boolean") {
+            if (selectRelationOptions.properties) {
+                findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+            }
+            if (selectRelationOptions.relations) {
+                findEntityOptions.relations = selectRelationOptions.relations;
+            }
+        }
+    }
+    const targetEntities = await findEntities(server, dataAccessor, findEntityOptions);
     lodash.forEach(links, (link) => {
         link.targetEntity = lodash.find(targetEntities, (e) => e["id"] == link[relationProperty.targetIdColumnName]);
     });
     return links;
 }
-function findManyRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, entityIds) {
+async function findManyRelatedEntitiesViaIdPropertyCode(options) {
+    const { server, relationProperty, mainEntityIds, selectRelationOptions } = options;
+    const dataAccessor = server.getDataAccessor({
+        singularCode: relationProperty.targetSingularCode,
+    });
     const findEntityOptions = {
         filters: [
             {
-                field: {
-                    name: relationProperty.selfIdColumnName,
-                },
+                field: relationProperty.selfIdColumnName,
                 operator: "in",
-                value: entityIds,
+                value: mainEntityIds,
             },
         ],
+        extraColumnsToSelect: [relationProperty.selfIdColumnName],
+        keepNonPropertyFields: true,
     };
+    if (selectRelationOptions) {
+        if (typeof selectRelationOptions !== "boolean") {
+            if (selectRelationOptions.properties) {
+                findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+            }
+            if (selectRelationOptions.relations) {
+                findEntityOptions.relations = selectRelationOptions.relations;
+            }
+        }
+    }
+    return await findEntities(server, dataAccessor, findEntityOptions);
+}
+async function findOneRelatedEntitiesViaIdPropertyCode(options) {
+    const { server, relationProperty, relationEntityIds, selectRelationOptions } = options;
     const dataAccessor = server.getDataAccessor({
         singularCode: relationProperty.targetSingularCode,
     });
-    return dataAccessor.find(findEntityOptions);
-}
-function findOneRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, targetEntityIds) {
     const findEntityOptions = {
         filters: [
             {
-                field: {
-                    name: "id",
-                },
+                field: "id",
                 operator: "in",
-                value: targetEntityIds,
+                value: relationEntityIds,
             },
         ],
+        keepNonPropertyFields: true,
     };
-    const dataAccessor = server.getDataAccessor({
-        singularCode: relationProperty.targetSingularCode,
-    });
-    return dataAccessor.find(findEntityOptions);
+    if (selectRelationOptions) {
+        if (typeof selectRelationOptions !== "boolean") {
+            if (selectRelationOptions.properties) {
+                findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+            }
+            if (selectRelationOptions.relations) {
+                findEntityOptions.relations = selectRelationOptions.relations;
+            }
+        }
+    }
+    return await findEntities(server, dataAccessor, findEntityOptions);
 }
 async function createEntity(server, dataAccessor, options, plugin) {
     const model = dataAccessor.getModel();

package/dist/queryBuilder/queryBuilder.d.ts

@@ -1,5 +1,5 @@
 import { RpdDataModel, CreateEntityOptions, QuoteTableOptions, DatabaseQuery } from "../types";
-import { CountRowOptions, DeleteRowOptions, FindRowOptions, RowFilterOptions, UpdateRowOptions, ColumnQueryOptions } from "../dataAccess/dataAccessTypes";
+import { CountRowOptions, DeleteRowOptions, FindRowOptions, RowFilterOptions, UpdateRowOptions, ColumnSelectOptions } from "../dataAccess/dataAccessTypes";
 export interface BuildQueryContext {
     builder: QueryBuilder;
     params: any[];
@@ -13,7 +13,7 @@ export default class QueryBuilder {
     constructor(options: InitQueryBuilderOptions);
     quoteTable(options: QuoteTableOptions): string;
     quoteObject(name: string): string;
-    quoteColumn(column: ColumnQueryOptions, emitTableAlias: boolean): string;
+    quoteColumn(column: ColumnSelectOptions, emitTableAlias: boolean): string;
     select(model: RpdDataModel, options: FindRowOptions): DatabaseQuery;
     selectDerived(derivedModel: RpdDataModel, baseModel: RpdDataModel, options: FindRowOptions): DatabaseQuery;
     count(model: RpdDataModel, options: CountRowOptions): DatabaseQuery;

package/dist/types.d.ts

@@ -1,6 +1,6 @@
 import { RouteContext } from "./core/routeContext";
 import { IRpdServer, RapidPlugin } from "./core/server";
-import { CountRowOptions, FindRowOptions } from "./dataAccess/dataAccessTypes";
+import { ColumnSelectOptions, CountRowOptions, FindRowOptions } from "./dataAccess/dataAccessTypes";
 export type RapidServerConfig = {
     baseUrl?: string;
     sessionCookieName: string;
@@ -355,12 +355,15 @@ export interface FindEntityOptions {
     orderBy?: FindEntityOrderByOptions[];
     pagination?: FindEntityPaginationOptions;
     properties?: string[];
+    relations?: Record<string, FindEntitySelectRelationOptions>;
+    extraColumnsToSelect?: ColumnSelectOptions[];
     keepNonPropertyFields?: boolean;
 }
 export interface FindEntityByIdOptions {
     routeContext?: RouteContext;
     id: any;
     properties?: string[];
+    relations?: Record<string, FindEntitySelectRelationOptions>;
     keepNonPropertyFields?: boolean;
 }
 export interface FindEntityRelationalFilterOptions {
@@ -392,6 +395,10 @@ export interface FindEntityPaginationOptions {
     limit: number;
     withoutTotal?: boolean;
 }
+export type FindEntitySelectRelationOptions = true | {
+    properties?: string[];
+    relations?: Record<string, FindEntitySelectRelationOptions>;
+};
 export interface FindEntityOrderByOptions {
     field: string;
     desc?: boolean;

package/package.json

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

package/src/dataAccess/dataAccessTypes.ts

@@ -1,4 +1,18 @@
-export type RowFilterRelationalOperators = "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "contains" | "notContains" | "containsCS" | "notContainsCS" | "startsWith" | "notStartsWith" | "endsWith" | "notEndsWith";
+export type RowFilterRelationalOperators =
+  | "eq"
+  | "ne"
+  | "lt"
+  | "lte"
+  | "gt"
+  | "gte"
+  | "contains"
+  | "notContains"
+  | "containsCS"
+  | "notContainsCS"
+  | "startsWith"
+  | "notStartsWith"
+  | "endsWith"
+  | "notEndsWith";
 
 export type RowFilterSetOperators = "in" | "notIn";
 
@@ -8,38 +22,47 @@ export type RowFilterUnaryOperators = "null" | "notNull";
 
 export type RowFilterExistenceOperators = "exists" | "notExists";
 
-export type RowFilterOperators = RowFilterRelationalOperators | RowFilterSetOperators | RowFilterLogicalOperators | RowFilterUnaryOperators | RowFilterExistenceOperators;
+export type RowFilterOperators =
+  | RowFilterRelationalOperators
+  | RowFilterSetOperators
+  | RowFilterLogicalOperators
+  | RowFilterUnaryOperators
+  | RowFilterExistenceOperators;
 
-export type RowFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowLogicalFilterOptions | FindRowUnaryFilterOptions | FindRowExistenceFilterOptions;
+export type RowFilterOptions =
+  | FindRowRelationalFilterOptions
+  | FindRowSetFilterOptions
+  | FindRowLogicalFilterOptions
+  | FindRowUnaryFilterOptions
+  | FindRowExistenceFilterOptions;
 
 export type RowNonRelationPropertyFilterOptions = FindRowRelationalFilterOptions | FindRowSetFilterOptions | FindRowUnaryFilterOptions;
 
-export type ColumnQueryOptions = string | ColumnNameWithTableName;
+export type ColumnSelectOptions = string | ColumnNameWithTableName;
 
 export type ColumnNameWithTableName = {
   name: string;
   tableName?: string;
-}
+};
 
 export interface FindRowOptions {
   filters?: RowFilterOptions[];
   orderBy?: FindRowOrderByOptions[];
   pagination?: FindRowPaginationOptions;
   // TODO: may be `columns` is a better name.
-  fields?: ColumnQueryOptions[];
+  fields?: ColumnSelectOptions[];
   keepNonPropertyFields?: boolean;
 }
 
-
 export interface FindRowRelationalFilterOptions {
   // TODO: may be `column` is a better name.
-  field: ColumnQueryOptions;
+  field: ColumnSelectOptions;
   operator: RowFilterRelationalOperators;
   value: any;
 }
 
 export interface FindRowSetFilterOptions {
-  field: ColumnQueryOptions;
+  field: ColumnSelectOptions;
   operator: RowFilterSetOperators;
   value: any[];
   itemType?: string;
@@ -51,12 +74,12 @@ export interface FindRowLogicalFilterOptions {
 }
 
 export interface FindRowUnaryFilterOptions {
-  field: ColumnQueryOptions;
+  field: ColumnSelectOptions;
   operator: RowFilterUnaryOperators;
 }
 
 export interface FindRowExistenceFilterOptions {
-  field: ColumnQueryOptions;
+  field: ColumnSelectOptions;
   operator: RowFilterExistenceOperators;
   filters: RowFilterOptions[];
 }
@@ -68,7 +91,7 @@ export interface FindRowPaginationOptions {
 }
 
 export interface FindRowOrderByOptions {
-  field: ColumnQueryOptions;
+  field: ColumnSelectOptions;
   desc?: boolean;
 }
 
@@ -83,4 +106,4 @@ export interface UpdateRowOptions {
 
 export interface DeleteRowOptions {
   filters?: RowFilterOptions[];
-}
+}

package/src/dataAccess/entityManager.ts

@@ -10,6 +10,7 @@ import {
   FindEntityByIdOptions,
   FindEntityOptions,
   FindEntityOrderByOptions,
+  FindEntitySelectRelationOptions,
   IRpdDataAccessor,
   RemoveEntityRelationsOptions,
   RpdDataModel,
@@ -24,10 +25,26 @@ import { IRpdServer, RapidPlugin } from "~/core/server";
 import { getEntityPartChanges } from "~/helpers/entityHelpers";
 import { filter, find, first, forEach, isArray, isObject, keys, map, reject, uniq } from "lodash";
 import { getEntityPropertiesIncludingBase, getEntityProperty, getEntityPropertyByCode } from "./metaHelper";
-import { ColumnQueryOptions, CountRowOptions, FindRowOptions, FindRowOrderByOptions, RowFilterOptions } from "./dataAccessTypes";
+import { ColumnSelectOptions, CountRowOptions, FindRowOptions, FindRowOrderByOptions, RowFilterOptions } from "./dataAccessTypes";
 import { newEntityOperationError } from "~/utilities/errorUtility";
 import { getNowStringWithTimezone } from "~/utilities/timeUtility";
 
+export type FindOneRelationEntitiesOptions = {
+  server: IRpdServer;
+  mainModel: RpdDataModel;
+  relationProperty: RpdDataModelProperty;
+  relationEntityIds: any[];
+  selectRelationOptions?: FindEntitySelectRelationOptions;
+};
+
+export type FindManyRelationEntitiesOptions = {
+  server: IRpdServer;
+  mainModel: RpdDataModel;
+  relationProperty: RpdDataModelProperty;
+  mainEntityIds: any[];
+  selectRelationOptions?: FindEntitySelectRelationOptions;
+};
+
 function convertEntityOrderByToRowOrderBy(server: IRpdServer, model: RpdDataModel, baseModel?: RpdDataModel, orderByList?: FindEntityOrderByOptions[]) {
   if (!orderByList) {
     return null;
@@ -66,17 +83,23 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     });
   }
 
-  let propertiesToSlect: RpdDataModelProperty[];
+  let propertiesToSelect: RpdDataModelProperty[];
+  let relationOptions = options.relations || {};
+  let relationPropertyCodes = Object.keys(relationOptions) || [];
   if (!options.properties || !options.properties.length) {
-    propertiesToSlect = getEntityPropertiesIncludingBase(server, model).filter((property) => !isRelationProperty(property));
+    propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter(
+      (property) => !isRelationProperty(property) || relationPropertyCodes.includes(property.code),
+    );
   } else {
-    propertiesToSlect = getEntityPropertiesIncludingBase(server, model).filter((property) => options.properties.includes(property.code));
+    propertiesToSelect = getEntityPropertiesIncludingBase(server, model).filter(
+      (property) => options.properties.includes(property.code) || relationPropertyCodes.includes(property.code),
+    );
   }
 
-  const columnsToSelect: ColumnQueryOptions[] = [];
+  const columnsToSelect: ColumnSelectOptions[] = [];
 
   const relationPropertiesToSelect: RpdDataModelProperty[] = [];
-  forEach(propertiesToSlect, (property) => {
+  forEach(propertiesToSelect, (property) => {
     if (isRelationProperty(property)) {
       relationPropertiesToSelect.push(property);
 
@@ -127,6 +150,30 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
     });
   }
 
+  if (options.extraColumnsToSelect) {
+    forEach(options.extraColumnsToSelect, (extraColumnToSelect: ColumnSelectOptions) => {
+      const columnSelectOptionExists = find(columnsToSelect, (item: ColumnSelectOptions) => {
+        if (typeof item === "string") {
+          if (typeof extraColumnToSelect === "string") {
+            return item === extraColumnToSelect;
+          } else {
+            return item == extraColumnToSelect.name;
+          }
+        } else {
+          if (typeof extraColumnToSelect === "string") {
+            return item.name === extraColumnToSelect;
+          } else {
+            return item.name == extraColumnToSelect.name;
+          }
+        }
+      });
+
+      if (!columnSelectOptionExists) {
+        columnsToSelect.push(extraColumnToSelect);
+      }
+    });
+  }
+
   const rowFilters = await convertEntityFiltersToRowFilters(server, model, baseModel, options.filters);
   const findRowOptions: FindRowOptions = {
     filters: rowFilters,
@@ -145,24 +192,36 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
       const isManyRelation = relationProperty.relation === "many";
 
       if (relationProperty.linkTableName) {
-        const targetModel = server.getModel({ singularCode: relationProperty.targetSingularCode! });
-        if (!targetModel) {
+        const relationModel = server.getModel({ singularCode: relationProperty.targetSingularCode! });
+        if (!relationModel) {
           continue;
         }
 
         if (isManyRelation) {
-          const relationLinks = await findManyRelationLinksViaLinkTable(server, targetModel, relationProperty, entityIds);
+          const relationLinks = await findManyRelationLinksViaLinkTable({
+            server,
+            mainModel: relationModel,
+            relationProperty,
+            mainEntityIds: entityIds,
+            selectRelationOptions: relationOptions[relationProperty.code],
+          });
 
           forEach(rows, (row: any) => {
             row[relationProperty.code] = filter(relationLinks, (link: any) => {
               return link[relationProperty.selfIdColumnName!] == row["id"];
-            }).map((link) => mapDbRowToEntity(server, targetModel, link.targetEntity, options.keepNonPropertyFields));
+            }).map((link) => mapDbRowToEntity(server, relationModel, link.targetEntity, options.keepNonPropertyFields));
           });
         }
       } else {
         let relatedEntities: any[];
         if (isManyRelation) {
-          relatedEntities = await findManyRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, entityIds);
+          relatedEntities = await findManyRelatedEntitiesViaIdPropertyCode({
+            server,
+            mainModel: model,
+            relationProperty,
+            mainEntityIds: entityIds,
+            selectRelationOptions: relationOptions[relationProperty.code],
+          });
         } else {
           const targetEntityIds = uniq(
             reject(
@@ -170,7 +229,13 @@ async function findEntities(server: IRpdServer, dataAccessor: IRpdDataAccessor,
               isNullOrUndefined,
             ),
           );
-          relatedEntities = await findOneRelatedEntitiesViaIdPropertyCode(server, model, relationProperty, targetEntityIds);
+          relatedEntities = await findOneRelatedEntitiesViaIdPropertyCode({
+            server,
+            mainModel: model,
+            relationProperty,
+            relationEntityIds: targetEntityIds,
+            selectRelationOptions: relationOptions[relationProperty.code],
+          });
         }
 
         const targetModel = server.getModel({
@@ -451,30 +516,44 @@ async function convertEntityFiltersToRowFilters(
   return replacedFilters;
 }
 
-async function findManyRelationLinksViaLinkTable(server: IRpdServer, targetModel: RpdDataModel, relationProperty: RpdDataModelProperty, entityIds: any[]) {
+async function findManyRelationLinksViaLinkTable(options: FindManyRelationEntitiesOptions) {
+  const { server, relationProperty, mainModel: relationModel, mainEntityIds, selectRelationOptions } = options;
   const command = `SELECT * FROM ${server.queryBuilder.quoteTable({
     schema: relationProperty.linkSchema,
     tableName: relationProperty.linkTableName!,
   })} WHERE ${server.queryBuilder.quoteObject(relationProperty.selfIdColumnName!)} = ANY($1::int[])`;
-  const params = [entityIds];
+  const params = [mainEntityIds];
   const links = await server.queryDatabaseObject(command, params);
   const targetEntityIds = links.map((link) => link[relationProperty.targetIdColumnName!]);
-  const findEntityOptions: FindRowOptions = {
+
+  const dataAccessor = server.getDataAccessor({
+    namespace: relationModel.namespace,
+    singularCode: relationModel.singularCode,
+  });
+
+  const findEntityOptions: FindEntityOptions = {
     filters: [
       {
-        field: {
-          name: "id",
-        },
+        field: "id",
         operator: "in",
         value: targetEntityIds,
       },
     ],
+    keepNonPropertyFields: true,
   };
-  const dataAccessor = server.getDataAccessor({
-    namespace: targetModel.namespace,
-    singularCode: targetModel.singularCode,
-  });
-  const targetEntities = await dataAccessor.find(findEntityOptions);
+
+  if (selectRelationOptions) {
+    if (typeof selectRelationOptions !== "boolean") {
+      if (selectRelationOptions.properties) {
+        findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+      }
+      if (selectRelationOptions.relations) {
+        findEntityOptions.relations = selectRelationOptions.relations;
+      }
+    }
+  }
+
+  const targetEntities = await findEntities(server, dataAccessor, findEntityOptions);
 
   forEach(links, (link: any) => {
     link.targetEntity = find(targetEntities, (e: any) => e["id"] == link[relationProperty.targetIdColumnName!]);
@@ -483,42 +562,68 @@ async function findManyRelationLinksViaLinkTable(server: IRpdServer, targetModel
   return links;
 }
 
-function findManyRelatedEntitiesViaIdPropertyCode(server: IRpdServer, model: RpdDataModel, relationProperty: RpdDataModelProperty, entityIds: any[]) {
-  const findEntityOptions: FindRowOptions = {
+async function findManyRelatedEntitiesViaIdPropertyCode(options: FindManyRelationEntitiesOptions) {
+  const { server, relationProperty, mainEntityIds, selectRelationOptions } = options;
+  const dataAccessor = server.getDataAccessor({
+    singularCode: relationProperty.targetSingularCode as string,
+  });
+
+  const findEntityOptions: FindEntityOptions = {
     filters: [
       {
-        field: {
-          name: relationProperty.selfIdColumnName,
-        },
+        field: relationProperty.selfIdColumnName,
         operator: "in",
-        value: entityIds,
+        value: mainEntityIds,
       },
     ],
+    extraColumnsToSelect: [relationProperty.selfIdColumnName],
+    keepNonPropertyFields: true,
   };
+
+  if (selectRelationOptions) {
+    if (typeof selectRelationOptions !== "boolean") {
+      if (selectRelationOptions.properties) {
+        findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+      }
+      if (selectRelationOptions.relations) {
+        findEntityOptions.relations = selectRelationOptions.relations;
+      }
+    }
+  }
+
+  return await findEntities(server, dataAccessor, findEntityOptions);
+}
+
+async function findOneRelatedEntitiesViaIdPropertyCode(options: FindOneRelationEntitiesOptions) {
+  const { server, relationProperty, relationEntityIds, selectRelationOptions } = options;
+
   const dataAccessor = server.getDataAccessor({
     singularCode: relationProperty.targetSingularCode as string,
   });
 
-  return dataAccessor.find(findEntityOptions);
-}
-
-function findOneRelatedEntitiesViaIdPropertyCode(server: IRpdServer, model: RpdDataModel, relationProperty: RpdDataModelProperty, targetEntityIds: any[]) {
-  const findEntityOptions: FindRowOptions = {
+  const findEntityOptions: FindEntityOptions = {
     filters: [
       {
-        field: {
-          name: "id",
-        },
+        field: "id",
         operator: "in",
-        value: targetEntityIds,
+        value: relationEntityIds,
       },
     ],
+    keepNonPropertyFields: true,
   };
-  const dataAccessor = server.getDataAccessor({
-    singularCode: relationProperty.targetSingularCode as string,
-  });
 
-  return dataAccessor.find(findEntityOptions);
+  if (selectRelationOptions) {
+    if (typeof selectRelationOptions !== "boolean") {
+      if (selectRelationOptions.properties) {
+        findEntityOptions.properties = ["id", ...selectRelationOptions.properties];
+      }
+      if (selectRelationOptions.relations) {
+        findEntityOptions.relations = selectRelationOptions.relations;
+      }
+    }
+  }
+
+  return await findEntities(server, dataAccessor, findEntityOptions);
 }
 
 async function createEntity(server: IRpdServer, dataAccessor: IRpdDataAccessor, options: CreateEntityOptions, plugin?: RapidPlugin) {

package/src/queryBuilder/queryBuilder.ts

@@ -1,11 +1,5 @@
 import { find } from "lodash";
-import {
-  RpdDataModel,
-  RpdDataModelProperty,
-  CreateEntityOptions,
-  QuoteTableOptions,
-  DatabaseQuery,
-} from "../types";
+import { RpdDataModel, RpdDataModelProperty, CreateEntityOptions, QuoteTableOptions, DatabaseQuery } from "../types";
 import {
   CountRowOptions,
   DeleteRowOptions,
@@ -17,7 +11,7 @@ import {
   RowFilterOptions,
   RowFilterRelationalOperators,
   UpdateRowOptions,
-  ColumnQueryOptions,
+  ColumnSelectOptions,
 } from "~/dataAccess/dataAccessTypes";
 
 const objLeftQuoteChar = '"';
@@ -64,7 +58,7 @@ export default class QueryBuilder {
     return `${objLeftQuoteChar}${name}${objRightQuoteChar}`;
   }
 
-  quoteColumn(column: ColumnQueryOptions, emitTableAlias: boolean) {
+  quoteColumn(column: ColumnSelectOptions, emitTableAlias: boolean) {
     if (typeof column === "string") {
       return `${objLeftQuoteChar}${column}${objRightQuoteChar}`;
     } else if (emitTableAlias && column.tableName) {
@@ -100,7 +94,7 @@ export default class QueryBuilder {
       command += " ORDER BY ";
       command += orderBy
         .map((item) => {
-          const quotedName = this.quoteColumn(item.field,  ctx.emitTableAlias);
+          const quotedName = this.quoteColumn(item.field, ctx.emitTableAlias);
           return item.desc ? quotedName + " DESC" : quotedName;
         })
         .join(", ");
@@ -133,13 +127,17 @@ export default class QueryBuilder {
     if (!columns || !columns.length) {
       command += `${this.quoteObject(derivedModel.tableName)}.* FROM `;
     } else {
-      command += columns.map((column) => {
-        return this.quoteColumn(column, ctx.emitTableAlias);
-      }).join(", ");
+      command += columns
+        .map((column) => {
+          return this.quoteColumn(column, ctx.emitTableAlias);
+        })
+        .join(", ");
       command += " FROM ";
     }
 
-    command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(baseModel.tableName)}.id`;
+    command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(
+      baseModel.tableName,
+    )}.id`;
 
     if (filters && filters.length) {
       command += " WHERE ";
@@ -203,7 +201,9 @@ export default class QueryBuilder {
     let { filters } = options;
     let command = 'SELECT COUNT(*)::int as "count" FROM ';
 
-    command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(baseModel.tableName)}.id`;
+    command += `${this.quoteTable(derivedModel)} LEFT JOIN ${this.quoteTable(baseModel)} ON ${this.quoteObject(derivedModel.tableName)}.id = ${this.quoteObject(
+      baseModel.tableName,
+    )}.id`;
 
     if (filters && filters.length) {
       command += " WHERE ";

package/src/types.ts

@@ -1,6 +1,6 @@
 import { RouteContext } from "./core/routeContext";
 import { IRpdServer, RapidPlugin } from "./core/server";
-import { CountRowOptions, FindRowOptions } from "./dataAccess/dataAccessTypes";
+import { ColumnSelectOptions, CountRowOptions, FindRowOptions } from "./dataAccess/dataAccessTypes";
 
 export type RapidServerConfig = {
   baseUrl?: string;
@@ -296,7 +296,21 @@ export interface RpdDataModelProperty {
   linkSchema?: string;
 }
 
-export type RpdDataPropertyTypes = "integer" | "long" | "float" | "double" | "decimal" | "text" | "boolean" | "date" | "time" | "datetime" | "json" | "relation" | "relation[]" | "option";
+export type RpdDataPropertyTypes =
+  | "integer"
+  | "long"
+  | "float"
+  | "double"
+  | "decimal"
+  | "text"
+  | "boolean"
+  | "date"
+  | "time"
+  | "datetime"
+  | "json"
+  | "relation"
+  | "relation[]"
+  | "option";
 
 /**
  * 数据字典
@@ -388,7 +402,21 @@ export interface IRpdDataAccessor<T = any> {
   deleteById(id: any): Promise<void>;
 }
 
-export type EntityFilterRelationalOperators = "eq" | "ne" | "lt" | "lte" | "gt" | "gte" | "contains" | "notContains" | "containsCS" | "notContainsCS" | "startsWith" | "notStartsWith" | "endsWith" | "notEndsWith";
+export type EntityFilterRelationalOperators =
+  | "eq"
+  | "ne"
+  | "lt"
+  | "lte"
+  | "gt"
+  | "gte"
+  | "contains"
+  | "notContains"
+  | "containsCS"
+  | "notContainsCS"
+  | "startsWith"
+  | "notStartsWith"
+  | "endsWith"
+  | "notEndsWith";
 
 export type EntityFilterSetOperators = "in" | "notIn";
 
@@ -398,9 +426,19 @@ export type EntityFilterUnaryOperators = "null" | "notNull";
 
 export type EntityFilterExistenceOperators = "exists" | "notExists";
 
-export type EntityFilterOperators = EntityFilterRelationalOperators | EntityFilterSetOperators | EntityFilterLogicalOperators | EntityFilterUnaryOperators | EntityFilterExistenceOperators;
+export type EntityFilterOperators =
+  | EntityFilterRelationalOperators
+  | EntityFilterSetOperators
+  | EntityFilterLogicalOperators
+  | EntityFilterUnaryOperators
+  | EntityFilterExistenceOperators;
 
-export type EntityFilterOptions = FindEntityRelationalFilterOptions | FindEntitySetFilterOptions | FindEntityLogicalFilterOptions | FindEntityUnaryFilterOptions | FindEntityExistenceFilterOptions;
+export type EntityFilterOptions =
+  | FindEntityRelationalFilterOptions
+  | FindEntitySetFilterOptions
+  | FindEntityLogicalFilterOptions
+  | FindEntityUnaryFilterOptions
+  | FindEntityExistenceFilterOptions;
 
 export type EntityNonRelationPropertyFilterOptions = FindEntityRelationalFilterOptions | FindEntitySetFilterOptions | FindEntityUnaryFilterOptions;
 
@@ -410,6 +448,8 @@ export interface FindEntityOptions {
   orderBy?: FindEntityOrderByOptions[];
   pagination?: FindEntityPaginationOptions;
   properties?: string[];
+  relations?: Record<string, FindEntitySelectRelationOptions>;
+  extraColumnsToSelect?: ColumnSelectOptions[];
   keepNonPropertyFields?: boolean;
 }
 
@@ -417,6 +457,7 @@ export interface FindEntityByIdOptions {
   routeContext?: RouteContext;
   id: any;
   properties?: string[];
+  relations?: Record<string, FindEntitySelectRelationOptions>;
   keepNonPropertyFields?: boolean;
 }
 
@@ -455,6 +496,13 @@ export interface FindEntityPaginationOptions {
   withoutTotal?: boolean;
 }
 
+export type FindEntitySelectRelationOptions =
+  | true
+  | {
+      properties?: string[];
+      relations?: Record<string, FindEntitySelectRelationOptions>;
+    };
+
 export interface FindEntityOrderByOptions {
   field: string;
   desc?: boolean;
@@ -514,7 +562,13 @@ export interface RemoveEntityRelationsOptions {
   relations: { id?: number; [k: string]: any }[];
 }
 
-export type EntityWatcherType = EntityWatcher<"entity.create"> | EntityWatcher<"entity.update"> | EntityWatcher<"entity.delete"> | EntityWatcher<"entity.addRelations"> | EntityWatcher<"entity.removeRelations"> | EntityWatcher<any>;
+export type EntityWatcherType =
+  | EntityWatcher<"entity.create">
+  | EntityWatcher<"entity.update">
+  | EntityWatcher<"entity.delete">
+  | EntityWatcher<"entity.addRelations">
+  | EntityWatcher<"entity.removeRelations">
+  | EntityWatcher<any>;
 
 export interface EntityWatcher<TEventName extends keyof RpdServerEventTypes = any> {
   eventName: TEventName;