@punks/backend-entity-manager 0.0.1 → 0.0.3

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

@@ -5,12 +5,14 @@ import { IEntitySearchParameters } from "../../abstractions/searchParameters";
 import { EntitiesSearchResults } from "../../models";
 import { EntityServiceLocator } from "../../providers/services";
 import { InMemoryRepository } from "../../testing/mocks/repository";
+import { IEntityManager } from "../../abstractions";
 export interface FooEntity {
     id: string;
     name: string;
     age: number;
     updatedAt: Date;
 }
+export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooSearchParameters, FooSorting, FooCursor, FooFacets>;
 export declare class FooRepository extends InMemoryRepository<FooEntity> {
 }
 export interface FooSearchFilters {
@@ -21,9 +23,7 @@ export declare enum FooSorting {
     Name = "Name",
     Age = "Age"
 }
-export interface FooCursor {
-    nextPage?: string;
-}
+export type FooCursor = number;
 export interface FooSearchParameters extends IEntitySearchParameters<FooSorting, FooCursor> {
     filters?: FooSearchFilters;
 }
@@ -49,24 +49,24 @@ export interface FooListItemDto {
         age: number;
     };
 }
-export interface FooCreateData {
+export interface FooCreateDto {
     profile: {
         name: string;
         age: number;
     };
 }
-export interface FooUpdateData {
+export interface FooUpdateDto {
     profile: {
         name: string;
         age: number;
     };
 }
-export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateData, FooUpdateData> {
+export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateDto, FooUpdateDto> {
     toListItemDto(entity: FooEntity): FooListItemDto;
     toEntityDto(entity: FooEntity): FooDto;
-    createDtoToEntity(input: FooCreateData): Partial<FooEntity>;
-    updateDtoToEntity(input: FooUpdateData): Partial<FooEntity>;
+    createDtoToEntity(input: FooCreateDto): Partial<FooEntity>;
+    updateDtoToEntity(input: FooUpdateDto): Partial<FooEntity>;
 }
 export declare const registerFooEntity: (container: IEntityManagerServiceRoot, options?: {
     useConverter?: boolean;
-}) => import("../../abstractions/configuration").IEntityManagerServiceCollection<FooEntity, string>;
+}) => import("../../abstractions").IEntityManagerServiceCollection<FooEntity, string>;

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

@@ -1,14 +1,15 @@
-import { DataSource, Repository } from "typeorm";
-import { IEntitiesQueryBuilder, IEntityConverter, IEntityManagerServiceRoot, IEntitySearchParameters } from "../../../../abstractions";
+import { DataSource, Repository, FindOptionsWhere } from "typeorm";
+import { IEntityConverter, IEntityManager, IEntityManagerServiceRoot, IEntitySearchParameters } from "../../../../abstractions";
 import { TypeOrmRepository } from "../../../../integrations/repository/typeorm";
 import { EntityServiceLocator } from "../../../../providers/services";
-import { EntitiesSearchResults } from "../../../../models";
+import { TypeOrmQueryBuilder } from "../../../../integrations/repository/typeorm";
 export declare class FooEntity {
     id: string;
     name: string;
     age: number;
     updatedAt: Date;
 }
+export type FooEntityManager = IEntityManager<FooEntity, string, Partial<FooEntity>, Partial<FooEntity>, FooSearchParameters, FooSorting, FooCursor, FooFacets>;
 export declare class FooTypeOrmRepo extends TypeOrmRepository<FooEntity, string> {
     constructor(repository: Repository<FooEntity>);
 }
@@ -20,19 +21,17 @@ export declare enum FooSorting {
     Name = "Name",
     Age = "Age"
 }
-export interface FooCursor {
-    nextPage?: string;
-}
+export type FooCursor = number;
 export interface FooSearchParameters extends IEntitySearchParameters<FooSorting, FooCursor> {
     filters?: FooSearchFilters;
 }
 export interface FooFacets {
 }
-export declare class FooQueryBuilder implements IEntitiesQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooCursor, FooFacets> {
-    private readonly services;
-    private readonly repository;
+export declare class FooQueryBuilder extends TypeOrmQueryBuilder<FooEntity, FooSearchParameters, FooSorting, FooFacets> {
     constructor(services: EntityServiceLocator<FooEntity, string>);
-    search(request: FooSearchParameters): Promise<EntitiesSearchResults<FooSearchParameters, FooEntity, FooSorting, FooCursor, FooFacets>>;
+    protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
+    private buildAgeWhereClause;
+    protected calculateFacets(request: FooSearchParameters): Promise<FooFacets | undefined>;
 }
 export interface FooDto {
     id: string;

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

@@ -1,8 +1,8 @@
 import { EntitiesSearchResults } from "../models";
 import { SortingType } from "./common";
 import { IEntitySearchParameters } from "./searchParameters";
-export interface IEntityCreateAction<TEntity, TEntityCreateInput, TEntityDto> {
-    execute(input: TEntityCreateInput): Promise<TEntityDto>;
+export interface IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
+    execute(input: TEntityCreateDto): Promise<TEntityDto>;
 }
 export interface IEntityDeleteAction<TEntity, TEntityId> {
     execute(id: TEntityId): Promise<void>;
@@ -10,20 +10,20 @@ export interface IEntityDeleteAction<TEntity, TEntityId> {
 export interface IEntityGetAction<TEntity, TEntityId, TEntityDto> {
     execute(id: TEntityId): Promise<TEntityDto | undefined>;
 }
-export interface IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
-    execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntityDto>;
+export interface IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
+    execute(id: TEntityId, data: TEntityUpdateDto): Promise<TEntityDto>;
 }
-export interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
-    execute(id: TEntityId, input: TEntityUpdateData): Promise<TEntityDto>;
+export interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
+    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>>;
 }
-export interface IEntityActions<TEntity, TEntityId> {
-    get<TEntityDto>(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
-    search<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
-    create<TEntityCreateData, TEntityDto>(): IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>;
-    update<TEntityUpdateData, TEntityDto>(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
-    upsert<TEntityUpdateData, TEntityDto>(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
+export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
+    get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;
+    update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
+    upsert(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
     delete(): IEntityDeleteAction<TEntity, TEntityId>;
 }

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

@@ -0,0 +1,8 @@
+export interface IEntityCreateCommandAdapter<TEntity, TEntityCreateData> {
+    createDataToEntity(data: TEntityCreateData): Partial<TEntity>;
+}
+export interface IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
+    updateDataToEntity(input: TEntityUpdateData): Partial<TEntity>;
+}
+export interface IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> extends IEntityCreateCommandAdapter<TEntity, TEntityCreateData>, IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
+}

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

@@ -1,5 +1,5 @@
-export interface IEntityCreateCommand<TEntity, TEntityCreateInput> {
-    execute(input: TEntityCreateInput): Promise<TEntity>;
+export interface IEntityCreateCommand<TEntity, TEntityCreateData> {
+    execute(input: TEntityCreateData): Promise<TEntity>;
 }
 export interface IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData> {
     execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntity>;

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

@@ -1,4 +1,6 @@
-import { EntityServiceLocator } from "../providers/services";
+import { ServiceLocator } from "../ioc";
+import { EntitiesServiceLocator, EntityServiceLocator } from "../providers/services";
+import { IEntityAdapter } from "./adapters";
 import { IEntityAuthorizationMiddleware } from "./authorization";
 import { SortingType } from "./common";
 import { ConnectorOptions, IEntityConnector } from "./connectors";
@@ -9,6 +11,9 @@ import { ReplicaOptions } from "./replication";
 import { IEntityRepository } from "./repository";
 import { IEntitySearchParameters } from "./searchParameters";
 export interface IEntityManagerServiceRoot {
+    locator: ServiceLocator;
+    getEntitiesServicesLocator(): EntitiesServiceLocator;
+    getEntityServicesLocator<TEntity, TEntityId>(entityName: string): EntityServiceLocator<TEntity, TEntityId>;
     registerEntity<TEntity, TEntityId, TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(entityName: string, repository: TRepository): IEntityManagerServiceCollection<TEntity, TEntityId>;
 }
 export interface IEntityManagerServiceCollection<TEntity, TEntityId> {
@@ -17,6 +22,7 @@ export interface IEntityManagerServiceCollection<TEntity, TEntityId> {
         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, }: {
         middleware: TEntityAuthorizationMiddleware;
     }): IEntityManagerServiceCollection<TEntity, TEntityId>;

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

@@ -1,24 +1,16 @@
-export interface IEntitiesSearchConverter<TEntity, TListItemDto> {
+export interface IEntitiesSearchActionConverter<TEntity, TListItemDto> {
     toListItemDto(entity: TEntity): TListItemDto;
 }
-export interface IEntityCreateCommandConverter<TEntity, TEntityCreateInput> {
-    createDtoToEntity(input: TEntityCreateInput): Partial<TEntity>;
-}
-export interface IEntityCreateActionConverter<TEntity, TEntityDto> {
+export interface IEntityGetActionConverter<TEntity, TEntityDto> {
     toEntityDto(entity: TEntity): TEntityDto;
 }
-export interface IEntityCreateConverter<TEntity, TEntityCreateInput, TEntityDto> extends IEntityCreateCommandConverter<TEntity, TEntityCreateInput>, IEntityCreateActionConverter<TEntity, TEntityDto> {
-}
-export interface IEntityGetConverter<TEntity, TEntityDto> {
+export interface IEntityCreateActionConverter<TEntity, TEntityDto, TEntityCreateDto> {
+    createDtoToEntity(data: TEntityCreateDto): Partial<TEntity>;
     toEntityDto(entity: TEntity): TEntityDto;
 }
-export interface IEntityUpdateCommandConverter<TEntity, TEntityUpdateInput> {
-    updateDtoToEntity(input: TEntityUpdateInput): Partial<TEntity>;
-}
-export interface IEntityUpdateActionConverter<TEntity, TEntityDto> {
+export interface IEntityUpdateActionConverter<TEntity, TEntityDto, TEntityUpdateDto> {
     toEntityDto(entity: TEntity): TEntityDto;
+    updateDtoToEntity(data: TEntityUpdateDto): Partial<TEntity>;
 }
-export interface IEntityUpdateConverter<TEntity, TEntityUpdateInput, TEntityDto> extends IEntityUpdateCommandConverter<TEntity, TEntityUpdateInput>, IEntityUpdateActionConverter<TEntity, TEntityDto> {
-}
-export interface IEntityConverter<TEntity, TEntityDto = TEntity, TListItemDto = TEntity, TEntityCreateInput = TEntity, TEntityUpdateInput = TEntity> extends IEntitiesSearchConverter<TEntity, TListItemDto>, IEntityCreateCommandConverter<TEntity, TEntityCreateInput>, IEntityCreateActionConverter<TEntity, TEntityDto>, IEntityCreateConverter<TEntity, TEntityCreateInput, TEntityDto>, IEntityGetConverter<TEntity, TEntityDto>, IEntityUpdateCommandConverter<TEntity, TEntityUpdateInput>, IEntityUpdateActionConverter<TEntity, TEntityDto> {
+export interface IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> extends IEntitiesSearchActionConverter<TEntity, TListItemDto>, IEntityGetActionConverter<TEntity, TEntityDto>, IEntityCreateActionConverter<TEntity, TEntityDto, TEntityCreateDto>, IEntityUpdateActionConverter<TEntity, TEntityDto, TEntityUpdateDto> {
 }

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

@@ -1,8 +1,10 @@
 export { IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction, IEntitiesSearchAction, IEntityActions, } from "./actions";
+export { IEntityAdapter } from "./adapters";
 export * from "./authorization";
 export { IEntityCreateCommand, IEntityUpdateCommand, IEntityUpsertCommand, IEntityDeleteCommand, } from "./commands";
+export { SortingType } from "./common";
 export { IEntityManagerServiceRoot, IEntityManagerServiceCollection, } from "./configuration";
-export { IEntitiesSearchConverter, IEntityCreateCommandConverter, IEntityCreateActionConverter, IEntityCreateConverter, IEntityGetConverter, IEntityUpdateCommandConverter, IEntityUpdateActionConverter, IEntityUpdateConverter, IEntityConverter, } from "./converters";
+export { IEntityConverter } from "./converters";
 export * from "./errors";
 export { IEntityEventsManager } from "./events";
 export * from "./filters";

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

@@ -2,11 +2,11 @@ import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEnti
 import { SortingType } from "./common";
 import { IEntitiesSearchQuery, IEntityGetQuery } from "./queries";
 import { IEntitySearchParameters } from "./searchParameters";
-export interface IEntityManager<TEntity, TEntityId> {
+export interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
     get(): IEntityGetQuery<TEntity, TEntityId>;
-    search<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
-    create<TEntityCreateInput>(): IEntityCreateCommand<TEntity, TEntityCreateInput>;
-    update<TEntityUpdateData>(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
-    upsert<TEntityUpdateData>(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
+    search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    create(): IEntityCreateCommand<TEntity, TEntityCreateData>;
+    update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
+    upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
     delete(): IEntityDeleteCommand<TEntity, TEntityId>;
 }

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

@@ -6,6 +6,7 @@ export interface IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCond
     all(): Promise<TEntity[]>;
     find(condition: TFindCondition): Promise<TEntity[]>;
     findById(id: TEntityId[]): Promise<TEntity[]>;
+    count(condition: TFindCondition): Promise<number>;
     delete(id: TEntityId): Promise<void>;
     deleteBy(condition: TDeleteCondition): Promise<void>;
     create(entity: Partial<TEntity>): Promise<TEntity>;

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

@@ -10,7 +10,7 @@ export interface ISearchOptions {
     includeFacets?: boolean;
 }
 export interface ISearchRequestPaging<TCursor> {
-    cursor: TCursor;
+    cursor?: TCursor;
     pageSize: number;
 }
 export interface ISearchSortingField<TSorting> {

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

@@ -1,8 +1,8 @@
 import { IEntityCreateAction } from "../abstractions/actions";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityCreateAction<TEntity, TEntityId, TEntityCreateInput, TEntityDto> implements IEntityCreateAction<TEntity, TEntityCreateInput, TEntityDto> {
+export declare class EntityCreateAction<TEntity, TEntityId, TEntityCreateDto, TEntityDto> implements IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
     private readonly services;
     private readonly logger;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    execute(input: TEntityCreateInput): Promise<TEntityDto>;
+    execute(input: TEntityCreateDto): Promise<TEntityDto>;
 }

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

@@ -1,7 +1,7 @@
 import { IEntityUpsertAction } from "../abstractions/actions";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityUpsertAction<TEntity, TEntityId, TEntityUpdateInput, TEntityDto> implements IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateInput, TEntityDto> {
+export declare class EntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> implements IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    execute(id: TEntityId, input: TEntityUpdateInput): Promise<TEntityDto>;
+    execute(id: TEntityId, input: TEntityUpdateData): Promise<TEntityDto>;
 }

package/dist/cjs/types/commands/create.d.ts

@@ -1,9 +1,9 @@
 import { IEntityCreateCommand } from "../abstractions/commands";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityCreateCommand<TEntity, TEntityId, TEntityCreateInput> implements IEntityCreateCommand<TEntity, TEntityCreateInput> {
+export declare class EntityCreateCommand<TEntity, TEntityId, TEntityCreateData> implements IEntityCreateCommand<TEntity, TEntityCreateData> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    execute(input: TEntityCreateInput): Promise<TEntity>;
+    execute(input: TEntityCreateData): Promise<TEntity>;
     private adaptEntity;
     private authorize;
 }

package/dist/cjs/types/commands/update.d.ts

@@ -1,9 +1,9 @@
 import { IEntityUpdateCommand } from "../abstractions/commands";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityUpdateCommand<TEntity, TEntityId, TEntityUpdateInput> implements IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateInput> {
+export declare class EntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData> implements IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    execute(id: TEntityId, input: TEntityUpdateInput): Promise<TEntity>;
+    execute(id: TEntityId, input: TEntityUpdateData): Promise<TEntity>;
     private adaptEntity;
     private authorize;
 }

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

@@ -5,23 +5,23 @@ import { IEntityManager } from "../abstractions/manager";
 import { IEntitiesSearchQuery, IEntityGetQuery } from "../abstractions/queries";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityManager<TEntity, TEntityId> implements IEntityManager<TEntity, TEntityId> {
+export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> implements IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    get<TEntityId>(): IEntityGetQuery<TEntity, TEntityId>;
-    search<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
-    create<TEntityCreateInput>(): IEntityCreateCommand<TEntity, TEntityCreateInput>;
-    update<TEntityUpdateInput>(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateInput>;
-    upsert<TEntityUpdateInput>(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateInput>;
-    delete<TEntityId>(): IEntityDeleteCommand<TEntity, TEntityId>;
+    get(): IEntityGetQuery<TEntity, TEntityId>;
+    search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    create(): IEntityCreateCommand<TEntity, TEntityCreateData>;
+    update(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
+    upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
+    delete(): IEntityDeleteCommand<TEntity, TEntityId>;
 }
-export declare class EntityActions<TEntity, TEntityId> implements IEntityActions<TEntity, TEntityId> {
+export declare class EntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> implements IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
-    get<TEntityId, TEntityDto>(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
-    search<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
-    create<TEntityCreateInput, TEntityDto>(): IEntityCreateAction<TEntity, TEntityCreateInput, TEntityDto>;
-    update<TEntityUpdateInput, TEntityDto>(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateInput, TEntityDto>;
-    upsert<TEntityUpdateInput, TEntityDto>(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateInput, TEntityDto>;
+    get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;
+    update(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
+    upsert(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto>;
     delete(): IEntityDeleteAction<TEntity, TEntityId>;
 }

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

@@ -1,2 +1,3 @@
 export * from "./abstractions";
 export * from "./platforms";
+export * from "./templates";

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

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

package/dist/cjs/types/integrations/repository/index.d.ts

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

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

@@ -1 +1,2 @@
-export * from "./repository";
+export { TypeOrmQueryBuilder } from "./queryBuilder";
+export { TypeOrmRepository } from "./repository";

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

@@ -0,0 +1,22 @@
+import { FindOptionsRelations, FindOptionsWhere, ObjectLiteral } from "typeorm";
+import { IEntitySearchParameters, SortingType } from "../../../abstractions";
+import { EntitiesSearchResults } 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> {
+    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;
+    protected buildPagingParameters(request: TEntitySearchParameters): {
+        skip: number | undefined;
+        take: number | undefined;
+    };
+    protected countQueryResults(request: TEntitySearchParameters): Promise<number>;
+    protected abstract buildWhereClause(request: TEntitySearchParameters): FindOptionsWhere<TEntity>[] | FindOptionsWhere<TEntity>;
+    protected abstract calculateFacets(request: TEntitySearchParameters): Promise<TFacets | undefined>;
+    protected getRepository(): TypeOrmRepository<TEntity, unknown>;
+}

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

@@ -3,13 +3,14 @@ import { IEntityRepository } from "../../../abstractions";
 type UpdateCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
 type DeleteCriteria<TEntity extends ObjectLiteral> = string | string[] | number | number[] | Date | Date[] | ObjectId | ObjectId[] | FindOptionsWhere<TEntity>;
 export declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implements IEntityRepository<TEntity, TEntityId, FindOneOptions<TEntity>, FindManyOptions<TEntity>, UpdateCriteria<TEntity>, DeleteCriteria<TEntity>> {
-    private readonly innerRepository;
+    protected readonly innerRepository: Repository<TEntity>;
     constructor(innerRepository: Repository<TEntity>);
     exists(id: TEntityId): Promise<boolean>;
     existsBy(condition: FindOneOptions<TEntity>): Promise<boolean>;
     get(id: TEntityId): Promise<TEntity | undefined>;
     getBy(condition: FindOneOptions<TEntity>): Promise<TEntity | undefined>;
     all(): Promise<TEntity[]>;
+    count(condition: FindManyOptions<TEntity>): Promise<number>;
     find(condition: FindManyOptions<TEntity>): Promise<TEntity[]>;
     findById(id: TEntityId[]): Promise<TEntity[]>;
     delete(id: TEntityId): Promise<void>;

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

@@ -2,6 +2,9 @@ import { Type } from "../abstractions/common";
 import { IResolveServiceOptions, IServiceLocator } from "../abstractions/ioc";
 export declare class ServiceLocator implements IServiceLocator {
     private services;
+    all(): {
+        [key: string]: any;
+    };
     register<T>(name: string, service: T): void;
     registerEntityService<T>(serviceName: string, entityName: string, service: T): void;
     registerEntityServiceType<T>(serviceType: Type<T>, entityName: string, service: T): void;

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

@@ -3,6 +3,7 @@ import { IEntitySearchParameters } from "../abstractions/searchParameters";
 export type EntitiesSearchResultsPaging<TCursor> = {
     pageIndex: number;
     pageSize: number;
+    totPageItems: number;
     totPages: number;
     totItems: number;
     nextPageCursor?: TCursor;

package/dist/cjs/types/platforms/nest/__test__/server/entities/foo/actions.d.ts

@@ -0,0 +1,8 @@
+import { NestEntityActions } from "../../../../base/entityActions";
+import { EntityManagerRegistry } from "../../../../ioc/registry";
+import { FooCreateDto, FooDto, FooListItemDto, FooUpdateDto } from "./dto";
+import { FooEntity } from "./entity";
+import { FooCursor, FooEntityId, FooFacets, FooSearchParameters, FooSorting } from "./models";
+export declare class FooEntityActions extends NestEntityActions<FooEntity, FooEntityId, FooCreateDto, FooUpdateDto, FooDto, FooListItemDto, FooSearchParameters, FooSorting, FooCursor, FooFacets> {
+    constructor(registry: EntityManagerRegistry);
+}

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

@@ -0,0 +1,11 @@
+import { FooEntityActions } from "./actions";
+import { FooCreateDto, FooDto, FooListItemDto, FooUpdateDto } from "./dto";
+export declare class FooController {
+    private readonly actions;
+    constructor(actions: FooEntityActions);
+    item(id: string): Promise<FooDto | undefined>;
+    create(data: FooCreateDto): Promise<FooDto>;
+    update(id: string, item: FooUpdateDto): Promise<FooDto>;
+    delete(id: string): Promise<void>;
+    items(): Promise<FooListItemDto[]>;
+}

package/dist/cjs/types/platforms/nest/__test__/server/entities/foo/converter.d.ts

@@ -0,0 +1,9 @@
+import { IEntityConverter } from "../../../../../../abstractions";
+import { FooEntity } from "./entity";
+import { FooCreateDto, FooDto, FooListItemDto, FooUpdateDto } from "./dto";
+export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateDto, FooUpdateDto> {
+    toListItemDto(entity: FooEntity): FooListItemDto;
+    toEntityDto(entity: FooEntity): FooDto;
+    createDtoToEntity(input: FooCreateDto): Partial<FooEntity>;
+    updateDtoToEntity(input: FooUpdateDto): Partial<FooEntity>;
+}

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

@@ -0,0 +1,20 @@
+export declare class FooProfile {
+    name: string;
+    age: number;
+}
+export declare class FooDto {
+    id: string;
+    profile: FooProfile;
+    updatedAt: Date;
+}
+export declare class FooListItemDto {
+    id: string;
+    profile: FooProfile;
+}
+export declare class FooCreateDto {
+    profile: FooProfile;
+}
+export declare class FooUpdateDto {
+    id: string;
+    profile: FooProfile;
+}

package/dist/cjs/types/platforms/nest/__test__/server/entities/foo/entity.d.ts

@@ -0,0 +1,6 @@
+export declare class FooEntity {
+    id: string;
+    name: string;
+    age: number;
+    updatedAt: Date;
+}

package/dist/cjs/types/platforms/nest/__test__/server/entities/foo/index.d.ts

@@ -0,0 +1,8 @@
+import { FooEntityActions } from "./actions";
+import { FooController } from "./controller";
+import { FooConverter } from "./converter";
+import { FooEntityManager } from "./manager";
+import { FooQueryBuilder } from "./query";
+import { FooRepository } from "./repository";
+export declare const FooProviders: (typeof FooEntityActions | typeof FooConverter | typeof FooEntityManager | typeof FooQueryBuilder | typeof FooRepository)[];
+export declare const FooControllers: (typeof FooController)[];

package/dist/cjs/types/platforms/nest/__test__/server/entities/foo/manager.d.ts

@@ -0,0 +1,7 @@
+import { NestEntityManager } from "../../../../base";
+import { EntityManagerRegistry } from "../../../../ioc/registry";
+import { FooEntity } from "./entity";
+import { FooCreateData, FooCursor, FooFacets, FooSearchParameters, FooSorting, FooUpdateData } from "./models";
+export declare class FooEntityManager extends NestEntityManager<FooEntity, string, FooCreateData, FooUpdateData, FooSearchParameters, FooSorting, FooCursor, FooFacets> {
+    constructor(registry: EntityManagerRegistry);
+}

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

@@ -0,0 +1,19 @@
+import { IEntitySearchParameters } from "../../../../../../abstractions";
+import { FooEntity } from "./entity";
+export type FooEntityId = string;
+export type FooCreateData = Partial<FooEntity>;
+export type FooUpdateData = Partial<FooEntity>;
+export interface FooSearchParameters extends IEntitySearchParameters<FooSorting, FooCursor> {
+    filters?: FooSearchFilters;
+}
+export interface FooFacets {
+}
+export interface FooSearchFilters {
+    minAge?: number;
+    maxAge?: number;
+}
+export declare enum FooSorting {
+    Name = "Name",
+    Age = "Age"
+}
+export type FooCursor = number;

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

@@ -0,0 +1,11 @@
+import { FindOptionsWhere } from "typeorm";
+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> {
+    constructor(registry: EntityManagerRegistry);
+    protected buildWhereClause(request: FooSearchParameters): FindOptionsWhere<FooEntity> | FindOptionsWhere<FooEntity>[];
+    private buildAgeWhereClause;
+    protected calculateFacets(request: FooSearchParameters): Promise<FooFacets | undefined>;
+}

package/dist/cjs/types/platforms/nest/__test__/server/entities/foo/repository.d.ts

@@ -0,0 +1,6 @@
+import { Repository } from "typeorm";
+import { FooEntity } from "./entity";
+import { NestTypeOrmRepository } from "../../../../integrations";
+export declare class FooRepository extends NestTypeOrmRepository<FooEntity, string> {
+    constructor(repository: Repository<FooEntity>);
+}

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

@@ -0,0 +1,6 @@
+import { FooEntity } from "./foo/entity";
+import { DataSource } from "typeorm";
+export declare const mockDatabaseProviders: (dataSource: DataSource) => {
+    provide: string | Function;
+    useValue: import("typeorm").Repository<FooEntity>;
+}[];

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

@@ -0,0 +1,4 @@
+export declare const createTestServer: () => Promise<{
+    app: import("@nestjs/testing").TestingModule;
+    dataSource: import("typeorm").DataSource;
+}>;

package/dist/cjs/types/platforms/nest/__test__/tests/base/test_crud_actions.test.d.ts

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

package/dist/cjs/types/platforms/nest/__test__/tests/base/test_crud_api.test.d.ts

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

package/dist/cjs/types/platforms/nest/__test__/tests/base/test_crud_operations.test.d.ts

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

package/dist/cjs/types/platforms/nest/base/entityActions.d.ts

@@ -0,0 +1,9 @@
+import { IEntityActions, IEntitySearchParameters, SortingType } from "../../../abstractions";
+import { EntityServiceLocator } from "../../../providers/services";
+import { EntityManagerRegistry } from "../ioc/registry";
+export declare abstract class NestEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
+    protected readonly services: EntityServiceLocator<TEntity, TEntityId>;
+    private actionsInstance;
+    constructor(entityName: string, registry: EntityManagerRegistry);
+    get provider(): IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+}