@punks/backend-entity-manager 0.0.131 → 0.0.133

package/dist/cjs/types/__test__/entity/foo.d.ts

@@ -1,7 +1,7 @@
 import { IEntityManagerServiceRoot } from "../../abstractions/configuration";
 import { IEntityConverter } from "../../abstractions/converters";
 import { IEntitiesQueryBuilder } from "../../abstractions/queries";
-import { IEntitySearchParameters } from "../../abstractions/searchParameters";
+import { IEntitySearchParameters, ISearchSorting } from "../../abstractions/searchParameters";
 import { IEntitiesSearchResults } from "../../models";
 import { EntityServiceLocator } from "../../providers/services";
 import { InMemoryRepository } from "../../testing/mocks/repository";
@@ -35,6 +35,10 @@ export interface FooFacets {
 export declare class FooQueryBuilder implements IEntitiesQueryBuilder<FooEntity, string, FooSearchParameters, FooSorting, FooCursor, FooFacets, unknown> {
     private readonly repository;
     constructor(services: EntityServiceLocator<FooEntity, string>);
+    find(request?: {
+        filters?: FooSearchFilters | undefined;
+        sorting?: ISearchSorting<FooSorting> | undefined;
+    } | undefined, context?: IAuthenticationContext<unknown> | undefined): Promise<FooEntity>;
     get(id: string): Promise<FooEntity | undefined>;
     exists(filters: FooSearchFilters, context?: IAuthenticationContext<unknown> | undefined): Promise<boolean>;
     count(filters: FooSearchFilters, context?: IAuthenticationContext<unknown> | undefined): Promise<number>;

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

@@ -7,7 +7,8 @@ export declare enum EntityOperationType {
     Update = 1,
     Delete = 2,
     Read = 3,
-    Search = 4
+    Search = 4,
+    Find = 5
 }
 export declare abstract class EntityManagerUnauthorizedException extends EntityManagerException {
     constructor(message: string);

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

@@ -10,6 +10,12 @@ export interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends I
 export interface IEntityGetQuery<TEntity, TEntityId> {
     execute(id: TEntityId): Promise<TEntity | undefined>;
 }
+export interface IEntitiesFindQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor> {
+    execute(request: {
+        filters?: TEntitySearchParameters["filters"];
+        sorting?: TEntitySearchParameters["sorting"];
+    }): Promise<TEntity>;
+}
 export interface IEntityExistsQuery<TEntity, TEntityFilters extends ISearchFilters> {
     execute(filters: TEntityFilters): Promise<boolean>;
 }
@@ -21,6 +27,10 @@ export interface IEntityVersionsSearchQuery<TEntity, TCursor> {
 }
 export interface IEntitiesQueryBuilder<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> {
     get(id: TEntityId, context?: IAuthenticationContext<TUserContext>): Promise<TEntity | undefined>;
+    find(request?: {
+        filters?: TEntitySearchParameters["filters"];
+        sorting?: TEntitySearchParameters["sorting"];
+    }, context?: IAuthenticationContext<TUserContext>): Promise<TEntity>;
     search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
     exists(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext>): Promise<boolean>;
     count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext>): Promise<number>;

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

@@ -2,7 +2,7 @@ import { IEntitiesCountAction, IEntitiesDeleteAction, IEntitiesExportAction, IEn
 import { IEntitiesDeleteCommand, IEntitiesDeleteParameters, IEntitiesExportCommand, IEntitiesImportCommand, IEntitiesSampleDownloadCommand, IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
 import { SortingType } from "../abstractions/common";
 import { IEntityManager } from "../abstractions/manager";
-import { IEntitiesCountQuery, IEntitiesSearchQuery, IEntityExistsQuery, IEntityGetQuery, IEntityVersionsSearchQuery } from "../abstractions/queries";
+import { IEntitiesCountQuery, IEntitiesFindQuery, IEntitiesSearchQuery, IEntityExistsQuery, IEntityGetQuery, IEntityVersionsSearchQuery } from "../abstractions/queries";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { IEntityFacets } from "../abstractions/searchResults";
 import { EntityServiceLocator } from "../providers/services";
@@ -14,6 +14,7 @@ export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntit
     get deleteItems(): IEntitiesDeleteCommand<TEntity, TEntitiesDeleteParameters, TSorting>;
     get get(): IEntityGetQuery<TEntity, TEntityId>;
     get search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    get find(): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
     get create(): IEntityCreateCommand<TEntity, TEntityCreateData>;
     get update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
     get upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;

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

@@ -17,6 +17,10 @@ export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral,
     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>;
+    find(request: {
+        filters?: TEntitySearchParameters["filters"];
+        sorting?: TEntitySearchParameters["sorting"];
+    }, context?: IAuthenticationContext<TUserContext>): Promise<TEntity>;
     search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, number, TFacets>>;
     protected getFieldFacet(): Promise<void>;
     protected findPagedQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<TEntity[]>;

package/dist/cjs/types/providers/services.d.ts

@@ -9,7 +9,7 @@ import { IEntityConverter } from "../abstractions/converters";
 import { IEntityEventsManager, IEventEmitter } from "../abstractions/events";
 import { IEntityManager } from "../abstractions/manager";
 import { IPipelinesController } from "../abstractions/pipelines";
-import { IEntitiesCountQuery, IEntitiesQueryBuilder, IEntitiesSearchQuery, IEntityExistsQuery, IEntityGetQuery, IEntityVersionsSearchQuery } from "../abstractions/queries";
+import { IEntitiesCountQuery, IEntitiesFindQuery, IEntitiesQueryBuilder, IEntitiesSearchQuery, IEntityExistsQuery, IEntityGetQuery, IEntityVersionsSearchQuery } from "../abstractions/queries";
 import { IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IReplicasConfiguration } from "../abstractions/replication";
 import { IEntityRepository } from "../abstractions/repository";
 import { IEntitySearchParameters, ISearchFilters } from "../abstractions/searchParameters";
@@ -42,6 +42,7 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     resolveCountQuery<TEntityFilters extends ISearchFilters>(): IEntitiesCountQuery<TEntity, TEntityFilters>;
     resolveVersionsSearchQuery<TCursor>(): IEntityVersionsSearchQuery<TEntity, TCursor>;
     resolveSearchQuery<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    resolveFindQuery<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor>(): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
     resolveCreateCommand<TEntityCreateData>(): IEntityCreateCommand<TEntity, TEntityCreateData>;
     resolveUpdateCommand<TEntityUpdateData>(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
     resolveUpsertCommand<TEntityUpdateData>(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
@@ -128,6 +129,8 @@ export declare class EntitiesServiceLocator {
     registerGetQuery<TEntity, TEntityId>(entityName: string, instance: IEntityGetQuery<TEntity, TEntityId>): void;
     resolveSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
     registerSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string, instance: IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>): void;
+    resolveFindQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string): IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>;
+    registerFindQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor>(entityName: string, instance: IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor>): void;
     resolveExistsQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntityExistsQuery<TEntity, TEntityFilters>;
     registerExistsQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string, instance: IEntityExistsQuery<TEntity, TEntityFilters>): void;
     resolveCountQuery<TEntity, TEntityFilters extends ISearchFilters>(entityName: string): IEntitiesCountQuery<TEntity, TEntityFilters>;

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

@@ -0,0 +1,12 @@
+import { SortingType } from "../abstractions/common";
+import { IEntitiesFindQuery } from "../abstractions/queries";
+import { IEntitySearchParameters } from "../abstractions/searchParameters";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntitiesFindQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TUserContext> implements IEntitiesFindQuery<TEntity, TEntitySearchParameters, TSorting, TCursor> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(request: TEntitySearchParameters): Promise<TEntity>;
+    private getContext;
+    private filterAllowedEntities;
+    private authorizeSearch;
+}

package/dist/cjs/types/symbols/ioc.d.ts

@@ -46,6 +46,7 @@ export declare const EntityServices: {
         IEntityCountQuery: string;
         IEntityExistsQuery: string;
         IEntityGetQuery: string;
+        IEntitiesFindQuery: string;
         IEntitiesSearchQuery: string;
         IEntitiesQueryBuilder: string;
         IEntityVersionsSearchQuery: string;

package/dist/cjs/types/templates/queryBuilder/index.d.ts

@@ -12,6 +12,10 @@ export declare abstract class QueryBuilderBase<TEntity, TEntityId, TEntitySearch
     abstract count(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<number>;
     abstract delete(filters: NonNullable<TEntitySearchParameters["filters"]>, context?: IAuthenticationContext<TUserContext> | undefined): Promise<IEntitiesDeleteResult>;
     abstract search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+    abstract find(request: {
+        filters?: TEntitySearchParameters["filters"];
+        sorting?: TEntitySearchParameters["sorting"];
+    }, context?: IAuthenticationContext<TUserContext>): Promise<TEntity>;
     protected getIndexBasedPagingResult({ paging, totResults, currentPageResults, }: {
         paging?: ISearchRequestPaging<number>;
         totResults: number;

package/dist/esm/index.js

@@ -35,6 +35,7 @@ var EntityOperationType;
     EntityOperationType[EntityOperationType["Delete"] = 2] = "Delete";
     EntityOperationType[EntityOperationType["Read"] = 3] = "Read";
     EntityOperationType[EntityOperationType["Search"] = 4] = "Search";
+    EntityOperationType[EntityOperationType["Find"] = 5] = "Find";
 })(EntityOperationType || (EntityOperationType = {}));
 class EntityManagerUnauthorizedException extends EntityManagerException {
     constructor(message) {
@@ -911,6 +912,9 @@ class EntityManager {
     get search() {
         return this.services.resolveSearchQuery();
     }
+    get find() {
+        return this.services.resolveFindQuery();
+    }
     get create() {
         return this.services.resolveCreateCommand();
     }
@@ -1095,6 +1099,7 @@ const EntityServices = {
         IEntityCountQuery: "IEntityCountQuery",
         IEntityExistsQuery: "IEntityExistsQuery",
         IEntityGetQuery: "IEntityGetQuery",
+        IEntitiesFindQuery: "IEntitiesFindQuery",
         IEntitiesSearchQuery: "IEntitiesSearchQuery",
         IEntitiesQueryBuilder: "IEntitiesQueryBuilder",
         IEntityVersionsSearchQuery: "IEntityVersionsSearchQuery",
@@ -1217,6 +1222,9 @@ class EntityServiceLocator {
     resolveSearchQuery() {
         return this.services.resolveSearchQuery(this.entityName);
     }
+    resolveFindQuery() {
+        return this.services.resolveFindQuery(this.entityName);
+    }
     resolveCreateCommand() {
         return this.services.resolveCreateCommand(this.entityName);
     }
@@ -1483,6 +1491,12 @@ class EntitiesServiceLocator {
     registerSearchQuery(entityName, instance) {
         this.provider.registerEntityService(EntityServices.Queries.IEntitiesSearchQuery, entityName, instance);
     }
+    resolveFindQuery(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Queries.IEntitiesSearchQuery, entityName);
+    }
+    registerFindQuery(entityName, instance) {
+        this.provider.registerEntityService(EntityServices.Queries.IEntitiesFindQuery, entityName, instance);
+    }
     resolveExistsQuery(entityName) {
         return this.provider.resolveEntityService(EntityServices.Queries.IEntityExistsQuery, entityName);
     }
@@ -1697,6 +1711,53 @@ class EntityExistsQuery {
     }
 }
 
+class EntitiesFindQuery {
+    constructor(services) {
+        this.services = services;
+    }
+    async execute(request) {
+        const context = await this.getContext();
+        await this.authorizeSearch(context);
+        const result = await this.services
+            .resolveQueryBuilder()
+            .find(request, context);
+        const filteredEntities = await this.filterAllowedEntities([result], context);
+        return filteredEntities[0];
+    }
+    async getContext() {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return undefined;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        return await contextService?.getContext();
+    }
+    async filterAllowedEntities(entities, context) {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return entities;
+        }
+        const filteredEntities = await Promise.all(entities.map(async (entity) => {
+            const authorizationResult = await authorization.canRead(entity, context);
+            if (!authorizationResult.isAuthorized) {
+                return null;
+            }
+            return entity;
+        }));
+        return filteredEntities.filter((entity) => entity !== null);
+    }
+    async authorizeSearch(context) {
+        const authorization = this.services.resolveAuthorizationMiddleware();
+        if (!authorization) {
+            return;
+        }
+        const { isAuthorized } = await authorization.canSearch(context);
+        if (!isAuthorized) {
+            throw new EntityOperationUnauthorizedException(EntityOperationType.Find, this.services.getEntityName());
+        }
+    }
+}
+
 class EntityGetQuery {
     constructor(services) {
         this.services = services;
@@ -2096,6 +2157,7 @@ class EntityManagerServiceCollection {
         return this;
     }
     mapSearch({ queryBuilder, }) {
+        this.locator.registerFindQuery(this.entityName, new EntitiesFindQuery(this.resolver));
         this.locator.registerSearchQuery(this.entityName, new EntitiesSearchQuery(this.resolver));
         this.locator.registerSearchAction(this.entityName, new EntitiesSearchAction(this.resolver));
         this.locator.registerQueryBuilder(this.entityName, queryBuilder);
@@ -22055,6 +22117,16 @@ class TypeOrmQueryBuilder extends QueryBuilderBase {
             ...this.buildWhereClause(request),
         });
     }
+    async find(request, context) {
+        const results = await this.findPagedQueryResults({
+            filters: request.filters,
+            sorting: request.sorting,
+            paging: {
+                pageSize: 1,
+            },
+        }, context);
+        return results[0];
+    }
     async search(request, context) {
         // todo: execute inside read transaction in order to perform the three queries on the same dataset
         const queryResults = await this.countQueryResults(request, context);