@punks/backend-entity-manager 0.0.460 → 0.0.461

package/dist/cjs/types/abstractions/actions.d.ts

@@ -5,6 +5,7 @@ import { SortingType } from "./common";
 import { EntitiesExportInput, EntitiesExportResult, EntitiesSampleDownloadOptions, EntitiesSampleDownloadResult } from "./export";
 import { EntitiesImportInput, EntitiesImportResult } from "./import";
 import { EntitiesParseInput, EntitiesParseResult } from "./parse";
+import { IEntitiesSearchQueryOptions, IEntityGetQueryOptions } from "./queries";
 import { IEntitySearchParameters, ISearchFilters } from "./searchParameters";
 import { IEntityFacets } from "./searchResults";
 export interface IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
@@ -16,13 +17,10 @@ export interface IEntityDeleteAction<TEntity, TEntityId> {
 export interface IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TSorting> {
     execute(params: TEntitiesDeleteParameters): Promise<void>;
 }
-export interface IEntityGetAction<TEntity, TEntityId, TEntityDto> {
-    execute(id: TEntityId): Promise<TEntityDto | undefined>;
+export interface IEntityGetActionOptions<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> extends IEntityGetQueryOptions<TEntity, TEntitySearchParameters> {
 }
-export interface IEntityGetAction<TEntity, TEntityId, TEntityDto> {
-    execute(id: TEntityId, options?: {
-        relations?: string[];
-    }): Promise<TEntityDto | undefined>;
+export interface IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> {
+    execute(id: TEntityId, options?: IEntityGetActionOptions<TEntity, TEntitySearchParameters>): Promise<TEntityDto | undefined>;
 }
 export interface IEntityExistsAction<TEntity, TEntityFilters extends ISearchFilters> {
     execute(filters: TEntityFilters): Promise<boolean>;
@@ -36,8 +34,10 @@ export interface IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEnti
 export interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
     execute(id: TEntityId, input: TEntityUpdateDto): Promise<TEntityDto>;
 }
+export interface IEntitiesSearchActionOptions<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> extends IEntitiesSearchQueryOptions<TEntity, TEntitySearchParameters> {
+}
 export interface IEntitiesSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
+    execute(request: TEntitySearchParameters, options?: IEntitiesSearchActionOptions<TEntity, TEntitySearchParameters>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
 }
 export interface IEntitiesExportAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor> {
     execute<TPayload = unknown>(input: EntitiesExportInput<TEntity, TEntitySearchParameters, TSorting, TCursor, TPayload>): Promise<EntitiesExportResult>;
@@ -55,7 +55,7 @@ export interface IEntityVersionsSearchAction<TEntity, TEntityVersionDto, TCursor
     execute(request: IEntityVersionsSearchRequest<TCursor>): Promise<IEntityVersionsSearchResponse<TEntityVersionDto, TCursor>>;
 }
 export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    get get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    get get(): IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>;
     get search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
     get exists(): IEntityExistsAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
     get count(): IEntitiesCountAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;

package/dist/cjs/types/abstractions/manager.d.ts

@@ -4,7 +4,7 @@ import { IEntitiesCountQuery, IEntitiesFindQuery, IEntitiesSearchQuery, IEntityE
 import { IEntitySearchParameters } from "./searchParameters";
 import { IEntityFacets } from "./searchResults";
 export interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitiesDeleteParameters extends IEntitiesDeleteParameters<TSorting>, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    get get(): IEntityGetQuery<TEntity, TEntityId>;
+    get get(): IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>;
     get search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
     get find(): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
     get exists(): IEntityExistsQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;

package/dist/cjs/types/abstractions/queries.d.ts

@@ -4,11 +4,17 @@ import { SortingType } from "./common";
 import { IEntitiesDeleteResult } from "./repository";
 import { IEntitySearchParameters, ISearchFilters } from "./searchParameters";
 import { IEntityFacets } from "./searchResults";
+export interface IEntitiesSearchQueryOptions<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> {
+    relations?: TEntitySearchParameters["relations"];
+}
 export interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
-    execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+    execute(request: TEntitySearchParameters, options?: IEntitiesSearchQueryOptions<TEntity, TEntitySearchParameters>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+}
+export interface IEntityGetQueryOptions<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> {
+    relations?: TEntitySearchParameters["relations"];
 }
-export interface IEntityGetQuery<TEntity, TEntityId> {
-    execute(id: TEntityId): Promise<TEntity | undefined>;
+export interface IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> {
+    execute(id: TEntityId, options?: IEntityGetQueryOptions<TEntity, TEntitySearchParameters>): Promise<TEntity | undefined>;
 }
 export interface IEntitiesFindQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor> {
     execute(request: {
@@ -27,7 +33,7 @@ export interface IEntityVersionsSearchQuery<TEntity, TCursor> {
     execute(params: IEntityVersionsSearchParameters<TCursor>): Promise<IEntityVersionsSearchResults<TEntity, TCursor>>;
 }
 export interface IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> {
-    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>): Promise<TEntity | undefined>;
+    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>, options?: IEntityGetQueryOptions<TEntity, TEntitySearchParameters>): Promise<TEntity | undefined>;
     find(request?: {
         filters?: TEntitySearchParameters["filters"];
         sorting?: TEntitySearchParameters["sorting"];

package/dist/cjs/types/actions/get.d.ts

@@ -1,6 +1,7 @@
 import { IEntityGetAction } from "../abstractions/actions";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityGetAction<TEntity, TEntityId, TEntityDto> implements IEntityGetAction<TEntity, TEntityId, TEntityDto> {
+export declare class EntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> implements IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     execute(id: TEntityId): Promise<TEntityDto | undefined>;

package/dist/cjs/types/concrete/index.d.ts

@@ -12,7 +12,7 @@ export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntit
     get exists(): IEntityExistsQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
     get count(): IEntitiesCountQuery<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
     get deleteItems(): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
-    get get(): IEntityGetQuery<TEntity, TEntityId>;
+    get get(): IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>;
     get search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
     get find(): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
     get version(): IEntityVersionCommand<TEntity, TEntityId>;
@@ -33,7 +33,7 @@ export declare class EntityActions<TEntity, TEntityId, TEntityCreateDto, TEntity
     get exists(): IEntityExistsAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
     get count(): IEntitiesCountAction<TEntity, NonNullable<TEntitySearchParameters["filters"]>>;
     get deleteItems(): IEntitiesDeleteAction<TEntity, TEntitiesDeleteParameters, TSorting>;
-    get get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    get get(): IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>;
     get search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
     get create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;
     get update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;

package/dist/cjs/types/integrations/repository/typeorm/queryBuilder.d.ts

@@ -10,13 +10,14 @@ import { BooleanFacetsType, FacetType, NumberFacetsType, FacetBuilderInput, Stri
 import { QueryBuilderOperation } from "../../../templates/queryBuilder";
 import { ChildrenMap } from "./traverse";
 import { PermissionsChecker } from "./permissionsChecker";
+import { IEntityGetQueryOptions } from "../../../abstractions/queries";
 export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntityId, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
     private readonly services;
     private repository;
     protected clause: QueryClauseBuilder;
     protected permissions: PermissionsChecker<TUserContext>;
     constructor(services: EntityServiceLocator<TEntity, unknown>);
-    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>): Promise<TEntity | undefined>;
+    get(id: TEntityId, context?: IAuthenticationContext<TUserContext>, options?: IEntityGetQueryOptions<TEntity, TEntitySearchParameters>): Promise<TEntity | undefined>;
     exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<boolean>;
     count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;
     delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<IEntitiesDeleteResult>;

package/dist/cjs/types/providers/services/entities-locator.d.ts

@@ -107,8 +107,8 @@ export declare class EntitiesServiceLocator {
     resolveSnapshotService<TEntity, TEntityId>(entityName: string): IEntitySnapshotService<TEntityId, unknown> | undefined;
     resolveAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(entityName: string): IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> | undefined;
     registerAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(entityName: string, instance: IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext>): void;
-    resolveGetQuery<TEntity, TEntityId>(entityName: string): IEntityGetQuery<TEntity, TEntityId>;
-    registerGetQuery<TEntity, TEntityId>(entityName: string, instance: IEntityGetQuery<TEntity, TEntityId>): void;
+    resolveGetQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(entityName: string): IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>;
+    registerGetQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(entityName: string, instance: IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>): void;
     resolveSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
     registerSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string, instance: IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>): void;
     resolveFindQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
@@ -141,8 +141,8 @@ export declare class EntitiesServiceLocator {
     registerParseCommand<TEntity>(entityName: string, instance: IEntitiesParseCommand<TEntity>): void;
     resolveSampleDownloadCommand<TEntity>(entityName: string): IEntitiesSampleDownloadCommand<TEntity>;
     registerSampleDownloadCommand<TEntity>(entityName: string, instance: IEntitiesSampleDownloadCommand<TEntity>): void;
-    resolveGetAction<TEntity, TEntityId, TEntityDto>(entityName: string): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
-    registerGetAction<TEntity, TEntityId, TEntityDto>(entityName: string, instance: IEntityGetAction<TEntity, TEntityId, TEntityDto>): void;
+    resolveGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(entityName: string): IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>;
+    registerGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(entityName: string, instance: IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>): void;
     resolveExistsAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntityExistsAction<TEntity, TEntityFilters>;
     registerExistsAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntityExistsAction<TEntity, TEntityFilters>): void;
     resolveCountAction<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntitiesCountAction<TEntity, TEntityFilters>;

package/dist/cjs/types/providers/services/entity-locator.d.ts

@@ -37,7 +37,7 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     resolveSnapshotService<TEntity, TEntityId>(): IEntitySnapshotService<TEntityId, unknown> | undefined;
     resolveAdapter<TEntityCreateData, TEntityUpdateData>(): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
     resolveAuthorizationMiddleware<TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(): IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> | undefined;
-    resolveGetQuery<TEntityId>(): IEntityGetQuery<TEntity, TEntityId>;
+    resolveGetQuery<TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(): IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters>;
     resolveExistsQuery<TEntityFilters extends ISearchFilters>(): IEntityExistsQuery<TEntity, TEntityFilters>;
     resolveCountQuery<TEntityFilters extends ISearchFilters>(): IEntitiesCountQuery<TEntity, TEntityFilters>;
     resolveVersionsSearchQuery<TCursor>(): IEntityVersionsSearchQuery<TEntity, TCursor>;
@@ -54,7 +54,7 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     resolveImportCommand(): IEntitiesImportCommand<TEntity>;
     resolveParseCommand(): IEntitiesParseCommand<TEntity>;
     resolveExportCommand<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor>(): IEntitiesExportCommand<TEntity, TEntitySearchParameters, TSorting, TCursor>;
-    resolveGetAction<TEntityId, TEntityDto>(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    resolveGetAction<TEntityId, TEntityDto, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>>(): IEntityGetAction<TEntity, TEntityId, TEntityDto, TEntitySearchParameters>;
     resolveExistsAction<TEntityFilters extends ISearchFilters>(): IEntityExistsAction<TEntity, TEntityFilters>;
     resolveCountAction<TEntityFilters extends ISearchFilters>(): IEntitiesCountAction<TEntity, TEntityFilters>;
     resolveSearchAction<TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;

package/dist/cjs/types/queries/get.d.ts

@@ -1,9 +1,10 @@
-import { IEntityGetQuery } from "../abstractions/queries";
+import { IEntityGetQuery, IEntityGetQueryOptions } from "../abstractions/queries";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityGetQuery<TEntity, TEntityId> implements IEntityGetQuery<TEntity, TEntityId> {
+export declare class EntityGetQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, unknown, unknown>> implements IEntityGetQuery<TEntity, TEntityId, TEntitySearchParameters> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    execute(id: TEntityId): Promise<TEntity | undefined>;
+    execute(id: TEntityId, options?: IEntityGetQueryOptions<TEntity, TEntitySearchParameters>): Promise<TEntity | undefined>;
     private authorize;
     private getContext;
 }

package/dist/cjs/types/queries/search.d.ts

@@ -1,13 +1,13 @@
 import { IEntityFacets } from "../abstractions";
 import { SortingType } from "../abstractions/common";
-import { IEntitiesSearchQuery } from "../abstractions/queries";
+import { IEntitiesSearchQuery, IEntitiesSearchQueryOptions } from "../abstractions/queries";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { IEntitiesSearchResults } from "../models";
 import { EntityServiceLocator } from "../providers/services";
 export declare class EntitiesSearchQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TEntity, TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> implements IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+    execute(request: TEntitySearchParameters, options?: IEntitiesSearchQueryOptions<TEntity, TEntitySearchParameters>): Promise<IEntitiesSearchResults<TEntity, TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
     private getContext;
     private filterAllowedEntities;
     private authorizeSearch;

package/dist/esm/index.js

@@ -674,7 +674,9 @@ class EntityUpdateAction {
         await this.services
             .resolveUpdateCommand()
             .execute(id, updateInput);
-        const entity = await this.services.resolveGetQuery().execute(id);
+        const entity = await this.services
+            .resolveGetQuery()
+            .execute(id);
         if (!entity) {
             throw new Error(`Newly created entity not found with id ${id}`);
         }
@@ -706,7 +708,9 @@ class EntityUpsertAction {
         await this.services
             .resolveUpsertCommand()
             .execute(id, updateInput);
-        const entity = await this.services.resolveGetQuery().execute(id);
+        const entity = await this.services
+            .resolveGetQuery()
+            .execute(id);
         if (!entity) {
             throw new Error(`Newly created entity not found with id ${id}`);
         }
@@ -2293,11 +2297,11 @@ class EntityGetQuery {
     constructor(services) {
         this.services = services;
     }
-    async execute(id) {
+    async execute(id, options) {
         const context = await this.getContext();
         const entity = await this.services
             .resolveQueryBuilder()
-            .get(id, context);
+            .get(id, context, options);
         if (entity) {
             await this.authorize(entity);
         }
@@ -2331,11 +2335,14 @@ class EntitiesSearchQuery {
     constructor(services) {
         this.services = services;
     }
-    async execute(request) {
+    async execute(request, options) {
         const context = await this.getContext();
         await this.authorizeSearch(context);
         const queryBuilder = this.services.resolveQueryBuilder();
-        const result = await queryBuilder.search(request, context);
+        const result = await queryBuilder.search({
+            ...request,
+            relations: options?.relations ?? request.relations,
+        }, context);
         const filteredEntities = await this.filterAllowedEntities(result.items, context);
         return {
             ...result,
@@ -3815,9 +3822,10 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
         this.clause = new QueryClauseBuilder();
         this.permissions = new PermissionsChecker();
     }
-    async get(id, context) {
+    async get(id, context, options) {
         return await this.getRepository().get(id, {
-            relations: this.getRelationsToLoad(undefined, context, QueryBuilderOperation.Get),
+            relations: options?.relations ??
+                this.getRelationsToLoad(undefined, context, QueryBuilderOperation.Get),
         });
     }
     async exists(filters, context) {