@punks/backend-entity-manager 0.0.22 → 0.0.24

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

@@ -2,7 +2,7 @@ import { IEntityManagerServiceRoot } from "../../abstractions/configuration";
 import { IEntityConverter } from "../../abstractions/converters";
 import { IEntitiesQueryBuilder } from "../../abstractions/queries";
 import { IEntitySearchParameters } from "../../abstractions/searchParameters";
-import { EntitiesSearchResults } from "../../models";
+import { IEntitiesSearchResults } from "../../models";
 import { EntityServiceLocator } from "../../providers/services";
 import { InMemoryRepository } from "../../testing/mocks/repository";
 import { IEntityManager } from "../../abstractions";
@@ -29,10 +29,10 @@ export interface FooSearchParameters extends IEntitySearchParameters<FooSorting,
 }
 export interface FooFacets {
 }
-export declare class FooQueryBuilder implements IEntitiesQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooCursor, FooFacets> {
+export declare class FooQueryBuilder implements IEntitiesQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooCursor, FooFacets, unknown> {
     private readonly repository;
     constructor(services: EntityServiceLocator<FooEntity, string>);
-    search(request: FooSearchParameters): Promise<EntitiesSearchResults<FooSearchParameters, FooEntity, FooSorting, FooCursor, FooFacets>>;
+    search(request: FooSearchParameters): Promise<IEntitiesSearchResults<FooSearchParameters, FooEntity, FooSorting, FooCursor, FooFacets>>;
 }
 export interface FooDto {
     id: string;

package/dist/esm/types/__test__/providers/typeorm/entity/foo.d.ts

@@ -1,5 +1,5 @@
 import { DataSource, Repository, FindOptionsWhere } from "typeorm";
-import { IEntityConverter, IEntityManager, IEntityManagerServiceRoot, IEntitySearchParameters } from "../../../../abstractions";
+import { IAuthenticationContext, IEntityConverter, IEntityManager, IEntityManagerServiceRoot, IEntitySearchParameters } from "../../../../abstractions";
 import { TypeOrmRepository } from "../../../../integrations/repository/typeorm";
 import { EntityServiceLocator } from "../../../../providers/services";
 import { TypeOrmQueryBuilder } from "../../../../integrations/repository/typeorm";
@@ -27,8 +27,9 @@ export interface FooSearchParameters extends IEntitySearchParameters<FooSorting,
 }
 export interface FooFacets {
 }
-export declare class FooQueryBuilder extends TypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets> {
+export declare class FooQueryBuilder extends TypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets, unknown> {
     constructor(services: EntityServiceLocator<FooEntity, string>);
+    protected buildContextFilter(context?: IAuthenticationContext<unknown> | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     private buildAgeWhereClause;
     protected calculateFacets(request: FooSearchParameters): Promise<FooFacets | undefined>;

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

@@ -1,4 +1,4 @@
-import { EntitiesSearchResults } from "../models";
+import { IEntitiesSearchResults } from "../models";
 import { SortingType } from "./common";
 import { IEntitySearchParameters } from "./searchParameters";
 export interface IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
@@ -17,7 +17,7 @@ export interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEnti
     execute(id: TEntityId, input: TEntityUpdateDto): Promise<TEntityDto>;
 }
 export interface IEntitiesSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets> {
-    execute(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
+    execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
 }
 export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
     get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;

package/dist/esm/types/abstractions/authentication.d.ts

@@ -0,0 +1,9 @@
+export interface IAuthenticationContext<TUserContext> {
+    isAuthenticated: boolean;
+    isAnonymous: boolean;
+    userId?: string;
+    userContext?: TUserContext;
+}
+export interface IAuthenticationContextProvider<TUserContext> {
+    getContext(): Promise<IAuthenticationContext<TUserContext>>;
+}

package/dist/esm/types/abstractions/authorization.d.ts

@@ -1,9 +1,10 @@
+import { IAuthenticationContext } from "./authentication";
 export interface IAuthorizationResult {
     isAuthorized: boolean;
 }
-export interface IEntityAuthorizationMiddleware<TEntity> {
-    canRead(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
-    canCreate(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
-    canUpdate(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
-    canDelete(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
+export interface IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext> {
+    canRead(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    canCreate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    canUpdate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    canDelete(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
 }

package/dist/esm/types/abstractions/configuration.d.ts

@@ -1,6 +1,7 @@
 import { ServiceLocator } from "../ioc";
 import { EntitiesServiceLocator, EntityServiceLocator } from "../providers/services";
 import { IEntityAdapter } from "./adapters";
+import { IAuthenticationContext, IAuthenticationContextProvider } from "./authentication";
 import { IEntityAuthorizationMiddleware } from "./authorization";
 import { SortingType } from "./common";
 import { ConnectorOptions, IEntityConnector } from "./connectors";
@@ -14,16 +15,19 @@ export interface IEntityManagerServiceRoot {
     locator: ServiceLocator;
     getEntitiesServicesLocator(): EntitiesServiceLocator;
     getEntityServicesLocator<TEntity, TEntityId>(entityName: string): EntityServiceLocator<TEntity, TEntityId>;
+    addAuthentication<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>({ provider, }: {
+        provider: TAuthenticationContextProvider;
+    }): void;
     registerEntity<TEntity, TEntityId, TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(entityName: string, repository: TRepository): IEntityManagerServiceCollection<TEntity, TEntityId>;
 }
 export interface IEntityManagerServiceCollection<TEntity, TEntityId> {
     getServiceLocator(): EntityServiceLocator<TEntity, TEntityId>;
-    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>>({ queryBuilder, }: {
+    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>({ queryBuilder, }: {
         queryBuilder: TEntitiesQueryBuilder;
     }): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addConverter<TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput, TEntityConverter extends IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput>>(converter: TEntityConverter): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addAdapter<TEntityCreateData, TEntityUpdateData, TEntityAdapter extends IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData>>(adapter: TEntityAdapter): IEntityManagerServiceCollection<TEntity, TEntityId>;
-    addAuthorization<TEntityAuthorizationMiddleware extends IEntityAuthorizationMiddleware<TEntity>>({ middleware, }: {
+    addAuthorization<TEntityAuthorizationMiddleware extends IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext>, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>({ middleware, }: {
         middleware: TEntityAuthorizationMiddleware;
     }): IEntityManagerServiceCollection<TEntity, TEntityId>;
     withReplica<TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>({ name, options, repository, }: {

package/dist/esm/types/abstractions/index.d.ts

@@ -1,6 +1,7 @@
 export { IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction, IEntitiesSearchAction, IEntityActions, } from "./actions";
 export { IEntityAdapter } from "./adapters";
-export * from "./authorization";
+export * from "./authentication";
+export { IAuthorizationResult, IEntityAuthorizationMiddleware, } from "./authorization";
 export { IEntityCreateCommand, IEntityUpdateCommand, IEntityUpsertCommand, IEntityDeleteCommand, } from "./commands";
 export { SortingType } from "./common";
 export { IEntityManagerServiceRoot, IEntityManagerServiceCollection, } from "./configuration";

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

@@ -1,12 +1,13 @@
-import { EntitiesSearchResults } from "../models";
+import { IEntitiesSearchResults } from "../models";
+import { IAuthenticationContext } from "./authentication";
 import { SortingType } from "./common";
 import { IEntitySearchParameters } from "./searchParameters";
 export interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
-    execute(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+    execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
 }
 export interface IEntityGetQuery<TEntity, TEntityId> {
     execute(id: TEntityId): Promise<TEntity | undefined>;
 }
-export interface IEntitiesQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
-    search(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+export interface IEntitiesQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets, TUserContext> {
+    search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
 }

package/dist/esm/types/actions/search.d.ts

@@ -1,10 +1,10 @@
 import { IEntitiesSearchAction } from "../abstractions/actions";
 import { SortingType } from "../abstractions/common";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
-import { EntitiesSearchResults } from "../models";
+import { IEntitiesSearchResults } from "../models";
 import { EntityServiceLocator } from "../providers/services";
 export declare class EntitiesSearchAction<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TListItemDto, TSorting extends SortingType, TCursor, TFacets> implements IEntitiesSearchAction<TEntity, TEntitySearchParameters, TListItemDto, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    execute(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TListItemDto, TSorting, TCursor, TFacets>>;
+    execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TListItemDto, TSorting, TCursor, TFacets>>;
 }

package/dist/esm/types/authorization/allowAll.d.ts

@@ -1,5 +1,5 @@
 import { IAuthorizationResult, IEntityAuthorizationMiddleware } from "../abstractions/authorization";
-export declare class AllowAllAuthorizationMiddleware<TEntity> implements IEntityAuthorizationMiddleware<TEntity> {
+export declare class AllowAllAuthorizationMiddleware<TEntity> implements IEntityAuthorizationMiddleware<TEntity, any, unknown> {
     canRead(entity: TEntity): Promise<IAuthorizationResult>;
     canCreate(entity: TEntity): Promise<{
         isAuthorized: boolean;

package/dist/esm/types/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./abstractions";
+export * from "./models";
 export * from "./platforms";
 export * from "./templates";
 export * from "./utils";

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

@@ -1,22 +1,23 @@
 import { FindOptionsRelations, FindOptionsWhere, ObjectLiteral } from "typeorm";
-import { IEntitySearchParameters, SortingType } from "../../../abstractions";
-import { EntitiesSearchResults } from "../../../models";
+import { IAuthenticationContext, IEntitySearchParameters, SortingType } from "../../../abstractions";
+import { IEntitiesSearchResults } from "../../../models";
 import { QueryBuilderBase } from "../../../templates";
 import { TypeOrmRepository } from "./repository";
 import { EntityServiceLocator } from "../../../providers/services";
-export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets> extends QueryBuilderBase<TEntity, TEntitySearchParameters, TSorting, number, TFacets> {
+export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
     private readonly services;
     private repository;
     constructor(services: EntityServiceLocator<TEntity, unknown>);
-    search(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, number, TFacets>>;
-    protected findPagedQueryResults(request: TEntitySearchParameters): Promise<TEntity[]>;
-    protected getRelationsToLoad(request: TEntitySearchParameters): FindOptionsRelations<TEntity> | undefined;
+    search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, number, TFacets>>;
+    protected findPagedQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<TEntity[]>;
+    protected getRelationsToLoad(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): FindOptionsRelations<TEntity> | undefined;
     protected buildPagingParameters(request: TEntitySearchParameters): {
         skip: number | undefined;
         take: number | undefined;
     };
-    protected countQueryResults(request: TEntitySearchParameters): Promise<number>;
+    protected countQueryResults(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<number>;
     protected abstract buildWhereClause(request: TEntitySearchParameters): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
-    protected abstract calculateFacets(request: TEntitySearchParameters): Promise<TFacets | undefined>;
+    protected abstract buildContextFilter(context?: IAuthenticationContext<TUserContext>): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
+    protected abstract calculateFacets(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<TFacets | undefined>;
     protected getRepository(): TypeOrmRepository<TEntity, unknown>;
 }

package/dist/esm/types/models/index.d.ts

@@ -1 +1 @@
-export { IEntitiesSearchResultsPaging as EntitiesSearchResultsPaging, IEntitiesSearchResults as EntitiesSearchResults, } from "./search";
+export { IEntitiesSearchResultsPaging, IEntitiesSearchResults } from "./search";

package/dist/esm/types/platforms/nest/__test__/server/authentication/index.d.ts

@@ -0,0 +1,13 @@
+import { IAuthenticationContext, IAuthenticationContextProvider } from "../../../../../abstractions";
+export type AppUserContext = {
+    email: string;
+};
+export declare class AppAuthContext implements IAuthenticationContext<AppUserContext> {
+    isAuthenticated: boolean;
+    isAnonymous: boolean;
+    userId?: string;
+    userContext?: AppUserContext;
+}
+export declare class AppAuthContextProvider implements IAuthenticationContextProvider<AppUserContext> {
+    getContext(): Promise<IAuthenticationContext<AppUserContext>>;
+}

package/dist/esm/types/platforms/nest/__test__/server/entities/foo/authentication.d.ts

@@ -0,0 +1,10 @@
+import { IAuthorizationResult } from "../../../../../../abstractions";
+import { NestEntityAuthorizationMiddleware } from "../../../../authentication";
+import { AppAuthContext, AppUserContext } from "../../authentication";
+import { FooEntity } from "./entity";
+export declare class FooAuthMiddleware extends NestEntityAuthorizationMiddleware<FooEntity, AppAuthContext, AppUserContext> {
+    canRead(entity: Partial<FooEntity>, context: AppAuthContext): Promise<IAuthorizationResult>;
+    canCreate(entity: Partial<FooEntity>, context: AppAuthContext): Promise<IAuthorizationResult>;
+    canUpdate(entity: Partial<FooEntity>, context: AppAuthContext): Promise<IAuthorizationResult>;
+    canDelete(entity: Partial<FooEntity>, context: AppAuthContext): Promise<IAuthorizationResult>;
+}

package/dist/esm/types/platforms/nest/__test__/server/entities/foo/controller.d.ts

@@ -1,5 +1,5 @@
 import { FooEntityActions } from "./actions";
-import { FooCreateDto, FooDto, FooListItemDto, FooUpdateDto } from "./dto";
+import { FooCreateDto, FooDto, FooListItemDto, FooSearchRequest, FooSearchResponse, FooUpdateDto } from "./dto";
 export declare class FooController {
     private readonly actions;
     constructor(actions: FooEntityActions);
@@ -8,4 +8,5 @@ export declare class FooController {
     update(id: string, item: FooUpdateDto): Promise<FooDto>;
     delete(id: string): Promise<void>;
     items(): Promise<FooListItemDto[]>;
+    search(request: FooSearchRequest): Promise<FooSearchResponse>;
 }

package/dist/esm/types/platforms/nest/__test__/server/entities/foo/dto.d.ts

@@ -1,3 +1,4 @@
+import { FooSearchParameters, FooSearchResults } from "./models";
 export declare class FooProfile {
     name: string;
     age: number;
@@ -18,3 +19,9 @@ export declare class FooUpdateDto {
     id: string;
     profile: FooProfile;
 }
+export declare class FooSearchRequest {
+    params: FooSearchParameters;
+}
+export declare class FooSearchResponse extends FooSearchResults<FooListItemDto> {
+    items: FooListItemDto[];
+}

package/dist/esm/types/platforms/nest/__test__/server/entities/foo/models.d.ts

@@ -1,4 +1,5 @@
 import { IEntitySearchParameters } from "../../../../../../abstractions";
+import { IEntitiesSearchResults, IEntitiesSearchResultsPaging } from "../../../../../../models";
 import { FooEntity } from "./entity";
 export type FooEntityId = string;
 export type FooCreateData = Partial<FooEntity>;
@@ -17,3 +18,19 @@ export declare enum FooSorting {
     Age = "Age"
 }
 export type FooCursor = number;
+export declare class FooSearchResultsPaging implements IEntitiesSearchResultsPaging<FooCursor> {
+    pageIndex: number;
+    pageSize: number;
+    totPageItems: number;
+    totPages: number;
+    totItems: number;
+    nextPageCursor?: FooCursor;
+    currentPageCursor?: FooCursor;
+    prevPageCursor?: FooCursor;
+}
+export declare class FooSearchResults<TResult> implements IEntitiesSearchResults<FooSearchParameters, TResult, FooSorting, FooCursor, FooFacets> {
+    request: FooSearchParameters;
+    facets?: FooFacets;
+    paging?: FooSearchResultsPaging;
+    items: TResult[];
+}

package/dist/esm/types/platforms/nest/__test__/server/entities/foo/query.d.ts

@@ -3,9 +3,12 @@ import { FooEntity } from "./entity";
 import { FooFacets, FooSearchParameters, FooSorting } from "./models";
 import { NestTypeOrmQueryBuilder } from "../../../../integrations/typeorm";
 import { EntityManagerRegistry } from "../../../../ioc/registry";
-export declare class FooQueryBuilder extends NestTypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets> {
+import { AppAuthContext } from "../../authentication";
+import { IAuthenticationContext } from "../../../../../../abstractions";
+export declare class FooQueryBuilder extends NestTypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets, AppAuthContext> {
     constructor(registry: EntityManagerRegistry);
+    protected buildContextFilter(context?: IAuthenticationContext<AppAuthContext> | undefined): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
     private buildAgeWhereClause;
-    protected calculateFacets(request: FooSearchParameters): Promise<FooFacets | undefined>;
+    protected calculateFacets(request: FooSearchParameters, context?: IAuthenticationContext<AppAuthContext>): Promise<FooFacets | undefined>;
 }

package/dist/esm/types/platforms/nest/__test__/server/index.d.ts

@@ -1,4 +1,12 @@
-export declare const createTestServer: () => Promise<{
-    app: import("@nestjs/testing").TestingModule;
+export declare const createTestServer: (options?: {
+    createWebServer?: boolean;
+    serverStartPort?: number;
+    useAuthentication?: boolean;
+    extraControllers?: any[];
+    extraProviders?: any[];
+}) => Promise<{
+    app: import("@nestjs/common").INestApplication<any>;
+    server: import("@nestjs/testing").TestingModule;
     dataSource: import("typeorm").DataSource;
+    terminate: () => Promise<void>;
 }>;

package/dist/esm/types/platforms/nest/__test__/server/middlewares/index.d.ts

@@ -0,0 +1,6 @@
+import { AppExceptionsFilterBase } from "../../../middlewares";
+import { RuntimeErrorInformation } from "../../../middlewares/errors-handler";
+export declare class AppExceptionsFilter extends AppExceptionsFilterBase {
+    protected logError(info: RuntimeErrorInformation): Promise<void>;
+    protected getCustomErrorStatusCode(exception: any): number | undefined;
+}

package/dist/esm/types/platforms/nest/__test__/server/session/session.controller.d.ts

@@ -0,0 +1,9 @@
+import { AppSessionService } from "../../../services";
+export declare class SessionController {
+    private readonly session;
+    constructor(session: AppSessionService);
+    getAndSetUserSessionDataFromService(data: any): Promise<unknown>;
+    getAndSetUserSessionData(data: any): Promise<any>;
+    private runWithContext;
+    private getContext;
+}

package/dist/esm/types/platforms/nest/__test__/tests/base/test_server_session.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/platforms/nest/authentication/entityAuthorizationMiddleware.d.ts

@@ -0,0 +1,7 @@
+import { IAuthenticationContext, IAuthorizationResult, IEntityAuthorizationMiddleware } from "../../../abstractions";
+export declare abstract class NestEntityAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext> implements IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> {
+    abstract canRead(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    abstract canCreate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    abstract canUpdate(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+    abstract canDelete(entity: Partial<TEntity>, context: TAuthenticationContext): Promise<IAuthorizationResult>;
+}

package/dist/esm/types/platforms/nest/authentication/index.d.ts

@@ -0,0 +1 @@
+export { NestEntityAuthorizationMiddleware } from "./entityAuthorizationMiddleware";

package/dist/esm/types/platforms/nest/extensions/authentication/abstractions/index.d.ts

@@ -0,0 +1,2 @@
+export interface IAuthenticationService {
+}

package/dist/esm/types/platforms/nest/extensions/authentication/index.d.ts

@@ -0,0 +1 @@
+export { AuthenticationModule } from "./module";

package/dist/esm/types/platforms/nest/extensions/authentication/module.d.ts

@@ -0,0 +1,2 @@
+export declare class AuthenticationModule {
+}

package/dist/esm/types/platforms/nest/extensions/authentication/services/authentication/index.d.ts

@@ -0,0 +1,3 @@
+import { IAuthenticationService } from "../../abstractions";
+export declare class AuthenticationService implements IAuthenticationService {
+}

package/dist/esm/types/platforms/nest/extensions/authentication/services/index.d.ts

@@ -0,0 +1 @@
+export { AuthenticationService } from "./authentication";

package/dist/esm/types/platforms/nest/extensions/authentication/services/providers.d.ts

@@ -0,0 +1,2 @@
+import { AuthenticationService } from "./authentication";
+export declare const Services: (typeof AuthenticationService)[];

package/dist/esm/types/platforms/nest/extensions/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./authentication";
+export * from "./multi-tenancy";

package/dist/esm/types/platforms/nest/extensions/multi-tenancy/abstractions/index.d.ts

@@ -0,0 +1,39 @@
+export interface ICompany {
+    id: string;
+    uid: string;
+    name: string;
+}
+export interface IDivision {
+    id: string;
+    uid: string;
+    name: string;
+}
+export interface IUser {
+    id: string;
+    uid: string;
+}
+export interface IModule {
+    id: string;
+    uid: string;
+    name: string;
+}
+export interface IOrganization {
+    id: string;
+    uid: string;
+    name: string;
+}
+export interface ISubscription {
+    id: string;
+    uid: string;
+    name: string;
+}
+export interface ITenant {
+    id: string;
+    uid: string;
+    name: string;
+}
+export interface IUserGroup {
+    id: string;
+    uid: string;
+    name: string;
+}

package/dist/esm/types/platforms/nest/extensions/multi-tenancy/index.d.ts

@@ -0,0 +1 @@
+export { MultiTenancyModule } from "./module";

package/dist/esm/types/platforms/nest/extensions/multi-tenancy/module.d.ts

@@ -0,0 +1,2 @@
+export declare class MultiTenancyModule {
+}

package/dist/esm/types/platforms/nest/index.d.ts

@@ -1,6 +1,12 @@
+export * from "./authentication";
 export * from "./base";
 export * from "./decorators";
+export * from "./extensions";
 export * from "./integrations";
 export * from "./ioc";
+export * from "./middlewares";
+export * from "./plugins";
 export * from "./processors";
+export * from "./session";
+export * from "./services";
 export { EntityManagerModule } from "./module";

package/dist/esm/types/platforms/nest/integrations/typeorm/queryBuilder.d.ts

@@ -2,6 +2,6 @@ import { ObjectLiteral } from "typeorm";
 import { TypeOrmQueryBuilder } from "../../../../integrations";
 import { IEntitySearchParameters, SortingType } from "../../../../abstractions";
 import { EntityManagerRegistry } from "../../ioc/registry";
-export declare abstract class NestTypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets> extends TypeOrmQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TFacets> {
+export declare abstract class NestTypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets, TUserContext> extends TypeOrmQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TFacets, TUserContext> {
     constructor(entityName: string, registry: EntityManagerRegistry);
 }

package/dist/esm/types/platforms/nest/ioc/registry/index.d.ts

@@ -7,7 +7,7 @@ import { IEventEmitter } from "../../../../abstractions/events";
 export declare class EntityManagerRegistry {
     private readonly container;
     getContainer(): import("../../../../abstractions").IEntityManagerServiceRoot;
-    resisterGlobalServices({ eventEmitter, }: {
+    registerGlobalServices({ eventEmitter, }: {
         eventEmitter?: IEventEmitter;
     }): Promise<void>;
     registerDiscoveredEntity(app: INestApplicationContext, { adapter, entityName, converter, queryBuilder, repository, authMiddleware, }: {

package/dist/esm/types/platforms/nest/middlewares/errors-handler/index.d.ts

@@ -0,0 +1,12 @@
+import { ExceptionFilter, ArgumentsHost } from "@nestjs/common";
+export interface RuntimeErrorInformation {
+    exception: any;
+    request: any;
+    response: any;
+}
+export declare abstract class AppExceptionsFilterBase implements ExceptionFilter {
+    catch(exception: unknown, host: ArgumentsHost): void;
+    protected getErrorStatusCode(exception: any): number;
+    protected abstract logError(info: RuntimeErrorInformation): Promise<void>;
+    protected abstract getCustomErrorStatusCode(exception: any): number | undefined;
+}

package/dist/esm/types/platforms/nest/middlewares/index.d.ts

@@ -0,0 +1 @@
+export { AppExceptionsFilterBase } from "./errors-handler";

package/dist/esm/types/platforms/nest/plugins/email/index.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/types/platforms/nest/plugins/index.d.ts

@@ -0,0 +1 @@
+export * from "./email";

package/dist/esm/types/platforms/nest/processors/initializer/index.d.ts

@@ -4,9 +4,11 @@ import { EntityManagerRegistry } from "../../ioc/registry";
 import { CustomDiscoveryService } from "../../ioc/discovery";
 import { NestEventEmitter } from "../../providers/events";
 import { ModulesContainer } from "@nestjs/core";
+import { IAuthenticationContextProvider } from "../../../../abstractions";
 export interface EntityManagerStaticProviders {
     eventEmitter: EventEmitter2;
     modulesContainer: ModulesContainer;
+    authenticationProvider?: IAuthenticationContextProvider<unknown>;
 }
 export declare class EntityManagerInitializer {
     private readonly discover;

package/dist/esm/types/platforms/nest/services/index.d.ts

@@ -1 +1 @@
-export declare const Services: never[];
+export { AppSessionService } from "./session";

package/dist/esm/types/platforms/nest/services/providers.d.ts

@@ -0,0 +1,2 @@
+import { AppSessionService } from "./session";
+export declare const Services: (typeof AppSessionService)[];

package/dist/esm/types/platforms/nest/services/session/index.d.ts

@@ -0,0 +1,9 @@
+/// <reference types="qs" />
+/// <reference types="express" />
+export declare class AppSessionService {
+    getValue<T>(key: string): T;
+    setValue<T>(key: string, value: T): void;
+    clearValue(key: string): void;
+    getRequest(): import("express").Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>;
+    private getSession;
+}

package/dist/esm/types/platforms/nest/session/index.d.ts

@@ -0,0 +1 @@
+export { AppSessionMiddleware } from "./middleware";

package/dist/esm/types/platforms/nest/session/middleware.d.ts

@@ -0,0 +1,6 @@
+import { Request, Response, NextFunction } from "express";
+import { NestMiddleware } from "@nestjs/common";
+export declare class AppSessionMiddleware implements NestMiddleware {
+    use(req: Request, res: Response, next: NextFunction): void;
+}
+export declare function appSessionMiddleware(req: Request, res: Response, next: NextFunction): void;

package/dist/esm/types/platforms/nest/session/session.d.ts

@@ -0,0 +1,12 @@
+export declare class AppSession<TRequest, TResponse> {
+    private readonly _request;
+    private readonly _response;
+    private readonly _map;
+    constructor(request: TRequest, response: TResponse);
+    get<T>(key: string): T;
+    set<T>(key: string, value: T): void;
+    delete(key: string): void;
+    clear(): void;
+    get request(): TRequest;
+    get response(): TResponse;
+}

package/dist/esm/types/platforms/nest/session/storage.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="qs" />
+/// <reference types="node" />
+import { AsyncLocalStorage } from "async_hooks";
+import { Request, Response } from "express";
+import { AppSession } from "./session";
+export declare const asyncLocalStorage: AsyncLocalStorage<AppSession<Request<import("express-serve-static-core").ParamsDictionary, any, any, import("qs").ParsedQs, Record<string, any>>, Response<any, Record<string, any>>>>;