@punks/backend-entity-manager 0.0.1 → 0.0.4

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-import { OnModuleInit } from '@nestjs/common';
+import { Type as Type$1, INestApplicationContext } from '@nestjs/common';
+import { ObjectLiteral, FindOneOptions, FindManyOptions, Repository, ObjectId, FindOptionsWhere, FindOptionsRelations } from 'typeorm';
 
 type EnumType = string | number | symbol;
 type SortingType = EnumType;
@@ -24,7 +25,7 @@ interface ISearchOptions {
     includeFacets?: boolean;
 }
 interface ISearchRequestPaging<TCursor> {
-    cursor: TCursor;
+    cursor?: TCursor;
     pageSize: number;
 }
 interface ISearchSortingField<TSorting> {
@@ -42,6 +43,7 @@ declare enum SortDirection {
 type EntitiesSearchResultsPaging<TCursor> = {
     pageIndex: number;
     pageSize: number;
+    totPageItems: number;
     totPages: number;
     totItems: number;
     nextPageCursor?: TCursor;
@@ -55,8 +57,8 @@ type EntitiesSearchResults<TSearchParameters extends IEntitySearchParameters<TSo
     paging?: EntitiesSearchResultsPaging<TCursor>;
 };
 
-interface IEntityCreateAction<TEntity, TEntityCreateInput, TEntityDto> {
-    execute(input: TEntityCreateInput): Promise<TEntityDto>;
+interface IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
+    execute(input: TEntityCreateDto): Promise<TEntityDto>;
 }
 interface IEntityDeleteAction<TEntity, TEntityId> {
     execute(id: TEntityId): Promise<void>;
@@ -64,24 +66,33 @@ interface IEntityDeleteAction<TEntity, TEntityId> {
 interface IEntityGetAction<TEntity, TEntityId, TEntityDto> {
     execute(id: TEntityId): Promise<TEntityDto | undefined>;
 }
-interface IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
-    execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntityDto>;
+interface IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
+    execute(id: TEntityId, data: TEntityUpdateDto): Promise<TEntityDto>;
 }
-interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
-    execute(id: TEntityId, input: TEntityUpdateData): Promise<TEntityDto>;
+interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
+    execute(id: TEntityId, input: TEntityUpdateDto): Promise<TEntityDto>;
 }
 interface IEntitiesSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets> {
     execute(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
 }
-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>;
+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>;
 }
 
+interface IEntityCreateCommandAdapter<TEntity, TEntityCreateData> {
+    createDataToEntity(data: TEntityCreateData): Partial<TEntity>;
+}
+interface IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
+    updateDataToEntity(input: TEntityUpdateData): Partial<TEntity>;
+}
+interface IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> extends IEntityCreateCommandAdapter<TEntity, TEntityCreateData>, IEntityUpdateCommandAdapter<TEntity, TEntityUpdateData> {
+}
+
 interface IAuthorizationResult {
     isAuthorized: boolean;
 }
@@ -92,8 +103,8 @@ interface IEntityAuthorizationMiddleware<TEntity> {
     canDelete(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
 }
 
-interface IEntityCreateCommand<TEntity, TEntityCreateInput> {
-    execute(input: TEntityCreateInput): Promise<TEntity>;
+interface IEntityCreateCommand<TEntity, TEntityCreateData> {
+    execute(input: TEntityCreateData): Promise<TEntity>;
 }
 interface IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData> {
     execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntity>;
@@ -105,6 +116,33 @@ interface IEntityDeleteCommand<TEntity, TEntityId> {
     execute(id: TEntityId): Promise<void>;
 }
 
+interface IResolveServiceOptions {
+    optional?: boolean;
+}
+interface IServiceLocator {
+    register<T extends ClassType>(name: string, service: Type<T>): void;
+    registerEntityService<T>(serviceName: string, entityName: string, service: T): void;
+    registerEntityServiceType<T>(serviceType: Type<T>, entityName: string, service: T): void;
+    resolve<T extends ClassType>(name: string, options?: IResolveServiceOptions): T;
+    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
+    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
+}
+
+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;
+    resolve<T>(name: string, options?: IResolveServiceOptions): T;
+    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
+    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
+    private buildServiceTypeName;
+    private buildServiceName;
+}
+
 interface IEntityMapper<TEntity, TMappedEntity> {
     mapEntity(entity: TEntity): Promise<TMappedEntity>;
 }
@@ -139,29 +177,21 @@ interface IEntityConnectorDeleteManager<TEntity, TEntityId> {
     deleteEntity(entityId: TEntityId): Promise<void>;
 }
 
-interface IEntitiesSearchConverter<TEntity, TListItemDto> {
+interface IEntitiesSearchActionConverter<TEntity, TListItemDto> {
     toListItemDto(entity: TEntity): TListItemDto;
 }
-interface IEntityCreateCommandConverter<TEntity, TEntityCreateInput> {
-    createDtoToEntity(input: TEntityCreateInput): Partial<TEntity>;
-}
-interface IEntityCreateActionConverter<TEntity, TEntityDto> {
+interface IEntityGetActionConverter<TEntity, TEntityDto> {
     toEntityDto(entity: TEntity): TEntityDto;
 }
-interface IEntityCreateConverter<TEntity, TEntityCreateInput, TEntityDto> extends IEntityCreateCommandConverter<TEntity, TEntityCreateInput>, IEntityCreateActionConverter<TEntity, TEntityDto> {
-}
-interface IEntityGetConverter<TEntity, TEntityDto> {
+interface IEntityCreateActionConverter<TEntity, TEntityDto, TEntityCreateDto> {
+    createDtoToEntity(data: TEntityCreateDto): Partial<TEntity>;
     toEntityDto(entity: TEntity): TEntityDto;
 }
-interface IEntityUpdateCommandConverter<TEntity, TEntityUpdateInput> {
-    updateDtoToEntity(input: TEntityUpdateInput): Partial<TEntity>;
-}
-interface IEntityUpdateActionConverter<TEntity, TEntityDto> {
+interface IEntityUpdateActionConverter<TEntity, TEntityDto, TEntityUpdateDto> {
     toEntityDto(entity: TEntity): TEntityDto;
+    updateDtoToEntity(data: TEntityUpdateDto): Partial<TEntity>;
 }
-interface IEntityUpdateConverter<TEntity, TEntityUpdateInput, TEntityDto> extends IEntityUpdateCommandConverter<TEntity, TEntityUpdateInput>, IEntityUpdateActionConverter<TEntity, TEntityDto> {
-}
-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> {
+interface IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> extends IEntitiesSearchActionConverter<TEntity, TListItemDto>, IEntityGetActionConverter<TEntity, TEntityDto>, IEntityCreateActionConverter<TEntity, TEntityDto, TEntityCreateDto>, IEntityUpdateActionConverter<TEntity, TEntityDto, TEntityUpdateDto> {
 }
 
 interface IEntityEventsManager<TEntity, TEntityId> {
@@ -180,12 +210,12 @@ interface IEntitiesQueryBuilder<TEntity, TEntitySearchParameters extends IEntity
     search(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
 }
 
-interface IEntityManager<TEntity, TEntityId> {
+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>;
 }
 
@@ -197,6 +227,7 @@ interface IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition,
     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>;
@@ -230,50 +261,22 @@ interface IEntityReplicaSyncManager<TEntity> {
     syncReplicas(entity: TEntity): Promise<void>;
 }
 
-interface IResolveServiceOptions {
-    optional?: boolean;
-}
-interface IServiceLocator {
-    register<T extends ClassType>(name: string, service: Type<T>): void;
-    registerEntityService<T>(serviceName: string, entityName: string, service: T): void;
-    registerEntityServiceType<T>(serviceType: Type<T>, entityName: string, service: T): void;
-    resolve<T extends ClassType>(name: string, options?: IResolveServiceOptions): T;
-    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
-    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
-}
-
-declare class ServiceLocator implements IServiceLocator {
-    private services;
-    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;
-    resolve<T>(name: string, options?: IResolveServiceOptions): T;
-    resolveEntityService<T>(serviceName: string, entityName: string, options?: IResolveServiceOptions): T;
-    resolveEntityServiceType<T>(serviceType: Type<T>, entityName: string, options?: IResolveServiceOptions): T;
-    private buildServiceTypeName;
-    private buildServiceName;
-}
-
 declare class EntityServiceLocator<TEntity, TEntityId> {
     private readonly services;
     private readonly entityName;
     constructor(services: EntitiesServiceLocator, entityName: string);
-    resolveEntityManager(): IEntityManager<TEntity, TEntityId>;
-    resolveEntityActions(): IEntityActions<TEntity, TEntityId>;
+    resolveEntityManager(): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, unknown>;
+    resolveEntityActions(): IEntityActions<TEntity, TEntityId, unknown, unknown, unknown, unknown, any, any, unknown, unknown>;
     resolveRepository<TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(): IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>;
     resolveEventsManager(): IEntityEventsManager<TEntity, TEntityId>;
-    resolveReplicaSyncManager<TEntity>(): IEntityReplicaSyncManager<TEntity>;
-    resolveReplicaConfiguration<TEntity>(): IReplicasConfiguration<TEntity, TEntityId>;
-    resolveReplicaDeleteManager<TEntity, TEntityId>(): IEntityReplicaDeleteManager<TEntity, TEntityId>;
-    resolveConnectorSyncManager<TEntity>(): IEntityConnectorSyncManager<TEntity>;
-    resolveConnectorDeleteManager<TEntity, TEntityId>(): IEntityConnectorDeleteManager<TEntity, TEntityId>;
-    resolveConnectorsConfiguration<TEntity>(): IConnectorsConfiguration<TEntity>;
-    resolveCreateCommandConverter<TEntityCreateData>(): IEntityCreateCommandConverter<TEntity, TEntityCreateData> | undefined;
-    resolveUpdateCommandConverter<TEntityUpdateData>(): IEntityUpdateCommandConverter<TEntity, TEntityUpdateData>;
-    resolveSearchConverter<TListItemDto>(): IEntitiesSearchConverter<TEntity, TListItemDto> | undefined;
-    resolveGetConverter<TEntityDto>(): IEntityGetConverter<TEntity, TEntityDto> | undefined;
-    resolveCreateConverter<TEntityCreateData, TEntityDto>(): IEntityCreateConverter<TEntity, TEntityCreateData, TEntityDto> | undefined;
-    resolveUpdateActionConverter<TEntityDto>(): IEntityUpdateActionConverter<TEntity, TEntityDto> | undefined;
+    resolveReplicaSyncManager(): IEntityReplicaSyncManager<TEntity>;
+    resolveReplicaConfiguration(): IReplicasConfiguration<TEntity, TEntityId>;
+    resolveReplicaDeleteManager<TEntityId>(): IEntityReplicaDeleteManager<TEntity, TEntityId>;
+    resolveConnectorSyncManager(): IEntityConnectorSyncManager<TEntity>;
+    resolveConnectorDeleteManager<TEntityId>(): IEntityConnectorDeleteManager<TEntity, TEntityId>;
+    resolveConnectorsConfiguration(): IConnectorsConfiguration<TEntity>;
+    resolveConverter<TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(): IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> | undefined;
+    resolveAdapter<TEntityCreateData, TEntityUpdateData>(): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
     resolveAuthorizationMiddleware(): IEntityAuthorizationMiddleware<TEntity> | undefined;
     resolveGetQuery<TEntityId>(): IEntityGetQuery<TEntity, TEntityId>;
     resolveSearchQuery<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
@@ -294,10 +297,10 @@ declare class EntitiesServiceLocator {
     private readonly provider;
     constructor(provider: ServiceLocator);
     getProvider(): ServiceLocator;
-    resolveEntityManager<TEntity, TEntityId>(entityName: string): IEntityManager<TEntity, TEntityId>;
-    registerEntityManager<TEntity, TEntityId>(entityName: string, instance: IEntityManager<TEntity, TEntityId>): void;
-    resolveEntityActions<TEntity, TEntityId>(entityName: string): IEntityActions<TEntity, TEntityId>;
-    registerEntityActions<TEntity, TEntityId>(entityName: string, instance: IEntityActions<TEntity, TEntityId>): void;
+    resolveEntityManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, unknown>;
+    registerEntityManager<TEntity>(entityName: string, instance: IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, unknown>): void;
+    resolveEntityActions<TEntity>(entityName: string): IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, unknown>;
+    registerEntityActions<TEntity>(entityName: string, instance: IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, unknown>): void;
     resolveRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(entityName: string): IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>;
     registerRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(entityName: string, instance: IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>): void;
     resolveEventsManager<TEntity, TEntityId>(entityName: string): IEntityEventsManager<TEntity, TEntityId>;
@@ -314,18 +317,10 @@ declare class EntitiesServiceLocator {
     registerConnectorDeleteManager<TEntity, TEntityId>(entityName: string, instance: IEntityConnectorDeleteManager<TEntity, TEntityId>): void;
     resolveConnectorsConfiguration<TEntity>(entityName: string): IConnectorsConfiguration<TEntity>;
     registerConnectorsConfiguration<TEntity>(entityName: string, instance: IConnectorsConfiguration<TEntity>): void;
-    resolveCreateCommandConverter<TEntity, TEntityCreateData>(entityName: string): IEntityCreateCommandConverter<TEntity, TEntityCreateData> | undefined;
-    registerCreateCommandConverter<TEntity, TEntityCreateData>(entityName: string, instance: IEntityCreateCommandConverter<TEntity, TEntityCreateData>): void;
-    resolveUpdateCommandConverter<TEntity, TEntityUpdateData>(entityName: string): IEntityUpdateCommandConverter<TEntity, TEntityUpdateData>;
-    registerUpdateCommandConverter<TEntity, TEntityUpdateData>(entityName: string, instance: IEntityUpdateCommandConverter<TEntity, TEntityUpdateData>): void;
-    resolveSearchConverter<TEntity, TListItemDto>(entityName: string): IEntitiesSearchConverter<TEntity, TListItemDto> | undefined;
-    registerSearchConverter<TEntity, TListItemDto>(entityName: string, instance: IEntitiesSearchConverter<TEntity, TListItemDto>): void;
-    resolveGetConverter<TEntity, TEntityDto>(entityName: string): IEntityGetConverter<TEntity, TEntityDto> | undefined;
-    registerGetConverter<TEntity, TEntityDto>(entityName: string, instance: IEntityGetConverter<TEntity, TEntityDto>): void;
-    resolveCreateConverter<TEntity, TEntityCreateData, TEntityDto>(entityName: string): IEntityCreateConverter<TEntity, TEntityCreateData, TEntityDto> | undefined;
-    registerCreateActionConverter<TEntity, TEntityCreateData, TEntityDto>(entityName: string, instance: IEntityCreateConverter<TEntity, TEntityCreateData, TEntityDto>): void;
-    resolveUpdateActionConverter<TEntity, TEntityDto>(entityName: string): IEntityUpdateActionConverter<TEntity, TEntityDto> | undefined;
-    registerUpdateActionConverter<TEntity, TEntityDto>(entityName: string, instance: IEntityUpdateActionConverter<TEntity, TEntityDto>): void;
+    registerAdapter<TEntity, TEntityCreateData, TEntityUpdateData>(entityName: string, instance: IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData>): void;
+    resolveAdapter<TEntity, TEntityCreateData, TEntityUpdateData>(entityName: string): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
+    registerConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(entityName: string, instance: IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>): void;
+    resolveConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto>(entityName: string): IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateDto, TEntityUpdateDto> | undefined;
     resolveAuthorizationMiddleware<TEntity>(entityName: string): IEntityAuthorizationMiddleware<TEntity> | undefined;
     registerAuthorizationMiddleware<TEntity>(entityName: string, instance: IEntityAuthorizationMiddleware<TEntity>): void;
     resolveGetQuery<TEntity, TEntityId>(entityName: string): IEntityGetQuery<TEntity, TEntityId>;
@@ -357,6 +352,9 @@ declare class EntitiesServiceLocator {
 }
 
 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>;
 }
 interface IEntityManagerServiceCollection<TEntity, TEntityId> {
@@ -365,6 +363,7 @@ 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>;
@@ -423,9 +422,153 @@ interface ISearchResultsPaging<TCursor> {
     prevPageCursor?: TCursor;
 }
 
-declare class EntityManagerModule implements OnModuleInit {
-    private readonly logger;
-    onModuleInit(): void;
+interface EntityAuthMiddlewareProps {
+    entityName: string;
+}
+declare const WpEntityAuthMiddleware: (entityName: string, props?: Omit<EntityAuthMiddlewareProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityActionsProps {
+    entityName: string;
+}
+declare const WpEntityActions: (entityName: string, props?: Omit<EntityActionsProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityConnectorProps {
+    entityName: string;
+}
+declare const WpEntityConnector: (entityName: string, props?: Omit<EntityConnectorProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityConverterProps {
+    entityName: string;
+}
+declare const WpEntityConverter: (entityName: string, props?: Omit<EntityConverterProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityProps {
+    name: string;
+}
+declare const WpEntity: (name: string, props?: Omit<EntityProps, "name">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityRepositoryProps {
+    entityName: string;
+}
+declare const WpEntityRepository: (entityName: string, props?: Omit<EntityRepositoryProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityManagerProps {
+    entityName: string;
+}
+declare const WpEntityManager: (entityName: string, props?: Omit<EntityManagerProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+interface EntityQueryBuilderProps {
+    entityName: string;
+}
+declare const WpEntityQueryBuilder: (entityName: string, props?: Omit<EntityQueryBuilderProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;
+
+declare const EntityManagerSymbols: {
+    Entity: symbol;
+    EntityActions: symbol;
+    EntityAdapter: symbol;
+    EntityAuthMiddleware: symbol;
+    EntityRepository: symbol;
+    EntityConnector: symbol;
+    EntityConverter: symbol;
+    EntityManager: symbol;
+    EntityQueryBuilder: symbol;
+};
+
+interface DiscoveredModule<T = object> {
+    name: string;
+    instance: T;
+    injectType?: Function | Type$1<any>;
+    dependencyType: Type$1<T>;
+}
+interface DiscoveredClass extends DiscoveredModule {
+    parentModule: DiscoveredModule;
+}
+interface DiscoveredClassWithMeta<T> {
+    discoveredClass: DiscoveredClass;
+    meta: T;
+}
+
+interface EntityAdapterProps {
+    entityName: string;
+}
+
+declare class EntityManagerRegistry {
+    private readonly container;
+    getContainer(): IEntityManagerServiceRoot;
+    registerDiscoveredEntity(app: INestApplicationContext, { adapter, entityName, converter, queryBuilder, repository, authMiddleware, }: {
+        entityName: string;
+        repository: DiscoveredClassWithMeta<EntityRepositoryProps>;
+        converter: DiscoveredClassWithMeta<EntityConverterProps>;
+        adapter: DiscoveredClassWithMeta<EntityAdapterProps>;
+        queryBuilder: DiscoveredClassWithMeta<EntityQueryBuilderProps>;
+        authMiddleware?: DiscoveredClassWithMeta<EntityAuthMiddlewareProps>;
+    }): Promise<void>;
+    resolveEntityServicesCollection<TEntity>(entityName: string): EntityServiceLocator<TEntity, unknown>;
+}
+
+declare abstract class NestEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
+    protected readonly services: EntityServiceLocator<TEntity, TEntityId>;
+    private managerInstance;
+    constructor(entityName: string, registry: EntityManagerRegistry);
+    get provider(): IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+}
+
+declare abstract class QueryBuilderBase<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> implements IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets> {
+    abstract search(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+    protected getIndexBasedPagingResult({ paging, totResults, currentPageResults, }: {
+        paging?: ISearchRequestPaging<number>;
+        totResults: number;
+        currentPageResults: number;
+    }): EntitiesSearchResultsPaging<number> | undefined;
+}
+
+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>;
+declare class TypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> implements IEntityRepository<TEntity, TEntityId, FindOneOptions<TEntity>, FindManyOptions<TEntity>, UpdateCriteria<TEntity>, DeleteCriteria<TEntity>> {
+    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>;
+    deleteBy(condition: DeleteCriteria<TEntity>): Promise<void>;
+    create(entity: Partial<TEntity>): Promise<TEntity>;
+    update(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
+    updateBy(entity: Partial<TEntity>, condition: UpdateCriteria<TEntity>): Promise<TEntity[]>;
+    upsert(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
+}
+
+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>;
+}
+
+declare abstract class NestTypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets> extends TypeOrmQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TFacets> {
+    constructor(entityName: string, registry: EntityManagerRegistry);
+}
+
+declare class NestTypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> extends TypeOrmRepository<TEntity, TEntityId> {
+    constructor(repository: Repository<TEntity>);
+}
+
+declare class EntityManagerModule {
 }
 
-export { EntityManagerException, EntityManagerModule, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, FilterExpression, IAuthorizationResult, IEntitiesQueryBuilder, IEntitiesSearchAction, IEntitiesSearchConverter, IEntitiesSearchQuery, IEntityActions, IEntityAuthorizationMiddleware, IEntityConverter, IEntityCreateAction, IEntityCreateActionConverter, IEntityCreateCommand, IEntityCreateCommandConverter, IEntityCreateConverter, IEntityDeleteAction, IEntityDeleteCommand, IEntityEventsManager, IEntityGetAction, IEntityGetConverter, IEntityGetQuery, IEntityManager, IEntityManagerServiceCollection, IEntityManagerServiceRoot, IEntityMapper, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IEntityRepository, IEntitySearchParameters, IEntitySearchResults, IEntityUpdateAction, IEntityUpdateActionConverter, IEntityUpdateCommand, IEntityUpdateCommandConverter, IEntityUpdateConverter, IEntityUpsertAction, IEntityUpsertCommand, IReplicasConfiguration, ISearchFilters, ISearchOptions, ISearchRequestPaging, ISearchResultsPaging, ISearchSorting, ISearchSortingField, MultipleEntitiesFoundException, ReplicaConfiguration, ReplicaOptions, ReplicationMode, SortDirection };
+export { EntityActionsProps, EntityAuthMiddlewareProps, EntityConnectorProps, EntityConverterProps, EntityManagerException, EntityManagerModule, EntityManagerProps, EntityManagerRegistry, EntityManagerSymbols, EntityNotFoundException, EntityOperationType, EntityOperationUnauthorizedException, EntityProps, EntityQueryBuilderProps, EntityRepositoryProps, FilterExpression, IAuthorizationResult, IEntitiesQueryBuilder, IEntitiesSearchAction, IEntitiesSearchQuery, IEntityActions, IEntityAdapter, IEntityAuthorizationMiddleware, IEntityConverter, IEntityCreateAction, IEntityCreateCommand, IEntityDeleteAction, IEntityDeleteCommand, IEntityEventsManager, IEntityGetAction, IEntityGetQuery, IEntityManager, IEntityManagerServiceCollection, IEntityManagerServiceRoot, IEntityMapper, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IEntityRepository, IEntitySearchParameters, IEntitySearchResults, IEntityUpdateAction, IEntityUpdateCommand, IEntityUpsertAction, IEntityUpsertCommand, IReplicasConfiguration, ISearchFilters, ISearchOptions, ISearchRequestPaging, ISearchResultsPaging, ISearchSorting, ISearchSortingField, MultipleEntitiesFoundException, NestEntityManager, NestTypeOrmQueryBuilder, NestTypeOrmRepository, QueryBuilderBase, ReplicaConfiguration, ReplicaOptions, ReplicationMode, SortDirection, SortingType, WpEntity, WpEntityActions, WpEntityAuthMiddleware, WpEntityConnector, WpEntityConverter, WpEntityManager, WpEntityQueryBuilder, WpEntityRepository };

package/package.json

@@ -1,9 +1,12 @@
 {
   "name": "@punks/backend-entity-manager",
-  "version": "0.0.1",
+  "version": "0.0.4",
   "description": "",
   "main": "dist/cjs/index.js",
   "module": "dist/esm/index.js",
+  "bin": {
+    "punks": "dist/run.js"
+  },
   "files": [
     "dist"
   ],
@@ -25,12 +28,18 @@
     "@babel/core": "^7.21.0",
     "@nestjs/common": "^10.0.5",
     "@nestjs/core": "^10.0.5",
-    "@punks/backend-core": "0.0.5",
+    "@nestjs/swagger": "^7.1.1",
+    "@nestjs/testing": "^10.0.5",
+    "@nestjs/typeorm": "^10.0.0",
     "@rollup/plugin-commonjs": "^21.0.1",
     "@rollup/plugin-node-resolve": "^13.0.6",
     "@rollup/plugin-typescript": "^11.0.0",
     "@types/jest": "^29.5.2",
+    "@types/lodash": "^4.14.195",
+    "class-transformer": "^0.5.1",
+    "class-validator": "^0.14.0",
     "jest": "^29.4.3",
+    "lodash": "^4.17.21",
     "pg": "^8.11.1",
     "pg-mem": "^2.6.13",
     "reflect-metadata": "^0.1.13",
@@ -44,10 +53,10 @@
     "typeorm": "^0.3.17",
     "typescript": "^5.1.6"
   },
-  "peerDependencies": {
-    "@punks/backend-core": "0.0.5"
+  "peerDependencies": {},
+  "dependencies": {
+    "@punks/backend-core": "0.0.8"
   },
-  "dependencies": {},
   "jest": {
     "transform": {
       ".(ts|tsx)": "ts-jest"

package/readme.md

@@ -5,7 +5,7 @@ This library contains the entity manager of the Punks backend.
 ## Installation
 
 ```bash
-npm install @punks/backend-entity-manager @punks/backend-core
+npm install @punks/backend-entity-manager @punks/backend-core class-transformer class-validator
 ```
 
 ## Supported ORMs:
@@ -15,3 +15,12 @@ npm install @punks/backend-entity-manager @punks/backend-core
 ```bash
 npm install typeorm
 ```
+
+## Supported platforms:
+
+- [NestJS](https://nestjs.com/)
+
+```bash
+# NestJS with TypeORM
+npm install @nestjs/core @nestjs/common @nestjs/typeorm @nestjs/swagger
+```

package/dist/cjs/types/platforms/nest/ioc/container/index.d.ts

@@ -1,3 +0,0 @@
-export declare class EntityManagerContainerProvider {
-    private readonly container;
-}

package/dist/cjs/types/platforms/nest/services/manager/index.d.ts

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

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

@@ -1,3 +0,0 @@
-export declare class EntityManagerContainerProvider {
-    private readonly container;
-}

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

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