@punks/backend-entity-manager 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,431 @@
+import { OnModuleInit } from '@nestjs/common';
+
+type EnumType = string | number | symbol;
+type SortingType = EnumType;
+interface ClassType {
+    new (...args: any[]): any;
+    constructor: {
+        name: string;
+    };
+}
+interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}
+
+interface IEntitySearchParameters<TSorting, TCursor> {
+    filters?: ISearchFilters;
+    sorting?: ISearchSorting<TSorting>;
+    paging?: ISearchRequestPaging<TCursor>;
+    options?: ISearchOptions;
+}
+interface ISearchFilters {
+}
+interface ISearchOptions {
+    includeFacets?: boolean;
+}
+interface ISearchRequestPaging<TCursor> {
+    cursor: TCursor;
+    pageSize: number;
+}
+interface ISearchSortingField<TSorting> {
+    field: TSorting;
+    direction: SortDirection;
+}
+interface ISearchSorting<TSorting> {
+    fields: ISearchSortingField<TSorting>[];
+}
+declare enum SortDirection {
+    Asc = 0,
+    Desc = 1
+}
+
+type EntitiesSearchResultsPaging<TCursor> = {
+    pageIndex: number;
+    pageSize: number;
+    totPages: number;
+    totItems: number;
+    nextPageCursor?: TCursor;
+    currentPageCursor?: TCursor;
+    prevPageCursor?: TCursor;
+};
+type EntitiesSearchResults<TSearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TResult, TSorting extends SortingType, TCursor, TFacets> = {
+    request: TSearchParameters;
+    items: TResult[];
+    facets?: TFacets;
+    paging?: EntitiesSearchResultsPaging<TCursor>;
+};
+
+interface IEntityCreateAction<TEntity, TEntityCreateInput, TEntityDto> {
+    execute(input: TEntityCreateInput): Promise<TEntityDto>;
+}
+interface IEntityDeleteAction<TEntity, TEntityId> {
+    execute(id: TEntityId): Promise<void>;
+}
+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 IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
+    execute(id: TEntityId, input: TEntityUpdateData): 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>;
+    delete(): IEntityDeleteAction<TEntity, TEntityId>;
+}
+
+interface IAuthorizationResult {
+    isAuthorized: boolean;
+}
+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>;
+}
+
+interface IEntityCreateCommand<TEntity, TEntityCreateInput> {
+    execute(input: TEntityCreateInput): Promise<TEntity>;
+}
+interface IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData> {
+    execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntity>;
+}
+interface IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData> {
+    execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntity>;
+}
+interface IEntityDeleteCommand<TEntity, TEntityId> {
+    execute(id: TEntityId): Promise<void>;
+}
+
+interface IEntityMapper<TEntity, TMappedEntity> {
+    mapEntity(entity: TEntity): Promise<TMappedEntity>;
+}
+
+interface IEntityConnector<TEntity, TMappedType> {
+    syncEntity(entity: TMappedType): Promise<void>;
+    deleteEntity<TEntityId>(id: TEntityId): Promise<void>;
+}
+interface IConnectorsConfiguration<TEntity> {
+    configureConnector<TEntityConnector extends IEntityConnector<TEntity, TMappedType>, TMappedType, TMapper extends IEntityMapper<TEntity, TMappedType>>(name: string, options: ConnectorOptions, connector: TEntityConnector, mapper: TMapper): void;
+    getConnector(name: string): ConnectorConfiguration<TEntity>;
+    getConnectors(): ConnectorConfiguration<TEntity>[];
+}
+declare enum ConnectorMode {
+    Sync = 0,
+    Async = 1
+}
+type ConnectorOptions = {
+    mode: ConnectorMode;
+    enabled?: boolean;
+};
+type ConnectorConfiguration<TEntity> = {
+    name: string;
+    options: ConnectorOptions;
+    connector: IEntityConnector<TEntity, unknown>;
+    mapper: IEntityMapper<TEntity, unknown>;
+};
+interface IEntityConnectorSyncManager<TEntity> {
+    syncEntity(entity: TEntity): Promise<void>;
+}
+interface IEntityConnectorDeleteManager<TEntity, TEntityId> {
+    deleteEntity(entityId: TEntityId): Promise<void>;
+}
+
+interface IEntitiesSearchConverter<TEntity, TListItemDto> {
+    toListItemDto(entity: TEntity): TListItemDto;
+}
+interface IEntityCreateCommandConverter<TEntity, TEntityCreateInput> {
+    createDtoToEntity(input: TEntityCreateInput): Partial<TEntity>;
+}
+interface IEntityCreateActionConverter<TEntity, TEntityDto> {
+    toEntityDto(entity: TEntity): TEntityDto;
+}
+interface IEntityCreateConverter<TEntity, TEntityCreateInput, TEntityDto> extends IEntityCreateCommandConverter<TEntity, TEntityCreateInput>, IEntityCreateActionConverter<TEntity, TEntityDto> {
+}
+interface IEntityGetConverter<TEntity, TEntityDto> {
+    toEntityDto(entity: TEntity): TEntityDto;
+}
+interface IEntityUpdateCommandConverter<TEntity, TEntityUpdateInput> {
+    updateDtoToEntity(input: TEntityUpdateInput): Partial<TEntity>;
+}
+interface IEntityUpdateActionConverter<TEntity, TEntityDto> {
+    toEntityDto(entity: TEntity): TEntityDto;
+}
+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 IEntityEventsManager<TEntity, TEntityId> {
+    processEntityCreatedEvent(entity: TEntity): Promise<void>;
+    processEntityUpdatedEvent(entity: TEntity): Promise<void>;
+    processEntityDeletedEvent(id: TEntityId): Promise<void>;
+}
+
+interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
+    execute(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+}
+interface IEntityGetQuery<TEntity, TEntityId> {
+    execute(id: TEntityId): Promise<TEntity | undefined>;
+}
+interface IEntitiesQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
+    search(request: TEntitySearchParameters): Promise<EntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
+}
+
+interface IEntityManager<TEntity, TEntityId> {
+    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>;
+    delete(): IEntityDeleteCommand<TEntity, TEntityId>;
+}
+
+interface IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition> {
+    exists(id: TEntityId): Promise<boolean>;
+    existsBy(condition: TGetConditions): Promise<boolean>;
+    get(id: TEntityId): Promise<TEntity | undefined>;
+    getBy(condition: TGetConditions): Promise<TEntity | undefined>;
+    all(): Promise<TEntity[]>;
+    find(condition: TFindCondition): Promise<TEntity[]>;
+    findById(id: TEntityId[]): Promise<TEntity[]>;
+    delete(id: TEntityId): Promise<void>;
+    deleteBy(condition: TDeleteCondition): Promise<void>;
+    create(entity: Partial<TEntity>): Promise<TEntity>;
+    update(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
+    updateBy(entity: Partial<TEntity>, condition: TUpdateCondition): Promise<TEntity[]>;
+    upsert(id: TEntityId, entity: Partial<TEntity>): Promise<TEntity>;
+}
+
+interface IReplicasConfiguration<TEntity, TEntityId> {
+    configureReplica<TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(name: string, options: ReplicaOptions, repository: TRepository): void;
+    getReplica(name: string): ReplicaConfiguration<TEntity, TEntityId>;
+    getReplicas(): ReplicaConfiguration<TEntity, TEntityId>[];
+}
+declare enum ReplicationMode {
+    Sync = 0,
+    Async = 1
+}
+type ReplicaOptions = {
+    mode: ReplicationMode;
+    enabled?: boolean;
+};
+type ReplicaConfiguration<TEntity, TEntityId> = {
+    name: string;
+    options: ReplicaOptions;
+    repository: IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>;
+};
+interface IEntityReplicaDeleteManager<TEntity, TEntityId> {
+    deleteReplicas(entityId: TEntityId): Promise<void>;
+}
+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>;
+    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;
+    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>;
+    resolveCreateCommand<TEntityCreateData>(): IEntityCreateCommand<TEntity, TEntityCreateData>;
+    resolveUpdateCommand<TEntityUpdateData>(): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
+    resolveUpsertCommand<TEntityUpdateData>(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
+    resolveDeleteCommand<TEntityId>(): IEntityDeleteCommand<TEntity, TEntityId>;
+    resolveGetAction<TEntityId, TEntityDto>(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    resolveSearchAction<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    resolveCreateAction<TEntityCreateData, TEntityDto>(): IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>;
+    resolveUpdateAction<TEntityUpdateData, TEntityDto>(): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
+    resolveUpsertAction<TEntityUpdateData, TEntityDto>(): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
+    resolveDeleteAction(): IEntityDeleteAction<TEntity, TEntityId>;
+    resolveQueryBuilder<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    getEntityName(): string;
+}
+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;
+    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>;
+    registerEventsManager<TEntity, TEntityId>(entityName: string, instance: IEntityEventsManager<TEntity, TEntityId>): void;
+    resolveReplicaSyncManager<TEntity>(entityName: string): IEntityReplicaSyncManager<TEntity>;
+    registerReplicaSyncManager<TEntity>(entityName: string, instance: IEntityReplicaSyncManager<TEntity>): void;
+    resolveReplicaConfiguration<TEntity, TEntityId>(entityName: string): IReplicasConfiguration<TEntity, TEntityId>;
+    registerReplicaConfiguration<TEntity, TEntityId>(entityName: string, instance: IReplicasConfiguration<TEntity, TEntityId>): void;
+    resolveReplicaDeleteManager<TEntity, TEntityId>(entityName: string): IEntityReplicaDeleteManager<TEntity, TEntityId>;
+    registerReplicaDeleteManager<TEntity, TEntityId>(entityName: string, instance: IEntityReplicaDeleteManager<TEntity, TEntityId>): void;
+    resolveConnectorSyncManager<TEntity>(entityName: string): IEntityConnectorSyncManager<TEntity>;
+    registerConnectorSyncManager<TEntity>(entityName: string, instance: IEntityConnectorSyncManager<TEntity>): void;
+    resolveConnectorDeleteManager<TEntity, TEntityId>(entityName: string): IEntityConnectorDeleteManager<TEntity, TEntityId>;
+    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;
+    resolveAuthorizationMiddleware<TEntity>(entityName: string): IEntityAuthorizationMiddleware<TEntity> | undefined;
+    registerAuthorizationMiddleware<TEntity>(entityName: string, instance: IEntityAuthorizationMiddleware<TEntity>): void;
+    resolveGetQuery<TEntity, TEntityId>(entityName: string): IEntityGetQuery<TEntity, TEntityId>;
+    registerGetQuery<TEntity, TEntityId>(entityName: string, instance: IEntityGetQuery<TEntity, TEntityId>): void;
+    resolveSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(entityName: string): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    registerSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(entityName: string, instance: IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>): void;
+    resolveCreateCommand<TEntity, TEntityCreateData>(entityName: string): IEntityCreateCommand<TEntity, TEntityCreateData>;
+    registerCreateCommand<TEntity, TEntityCreateData>(entityName: string, instance: IEntityCreateCommand<TEntity, TEntityCreateData>): void;
+    resolveUpdateCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string): IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>;
+    registerUpdateCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string, instance: IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData>): void;
+    resolveUpsertCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
+    registerUpsertCommand<TEntity, TEntityId, TEntityUpdateData>(entityName: string, instance: IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>): void;
+    resolveDeleteCommand<TEntity, TEntityId>(entityName: string): IEntityDeleteCommand<TEntity, TEntityId>;
+    registerDeleteCommand<TEntity, TEntityId>(entityName: string, instance: IEntityDeleteCommand<TEntity, TEntityId>): void;
+    resolveGetAction<TEntity, TEntityId, TEntityDto>(entityName: string): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
+    registerGetAction<TEntity, TEntityId, TEntityDto>(entityName: string, instance: IEntityGetAction<TEntity, TEntityId, TEntityDto>): void;
+    resolveSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(entityName: string): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    registerSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets>(entityName: string, instance: IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>): void;
+    resolveCreateAction<TEntity, TEntityCreateData, TEntityDto>(entityName: string): IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>;
+    registerCreateAction<TEntity, TEntityCreateData, TEntityDto>(entityName: string, instance: IEntityCreateAction<TEntity, TEntityCreateData, TEntityDto>): void;
+    resolveUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string): IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
+    registerUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string, instance: IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>): void;
+    resolveUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string): IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>;
+    registerUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>(entityName: string, instance: IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto>): void;
+    resolveDeleteAction<TEntity, TEntityId>(entityName: string): IEntityDeleteAction<TEntity, TEntityId>;
+    registerDeleteAction<TEntity, TEntityId>(entityName: string, instance: IEntityDeleteAction<TEntity, TEntityId>): void;
+    resolveQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(entityName: string): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    registerQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(entityName: string, instance: IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>): void;
+}
+
+interface IEntityManagerServiceRoot {
+    registerEntity<TEntity, TEntityId, TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(entityName: string, repository: TRepository): IEntityManagerServiceCollection<TEntity, TEntityId>;
+}
+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, }: {
+        queryBuilder: TEntitiesQueryBuilder;
+    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addConverter<TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput, TEntityConverter extends IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput>>(converter: TEntityConverter): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    addAuthorization<TEntityAuthorizationMiddleware extends IEntityAuthorizationMiddleware<TEntity>>({ middleware, }: {
+        middleware: TEntityAuthorizationMiddleware;
+    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    withReplica<TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>({ name, options, repository, }: {
+        name: string;
+        options: ReplicaOptions;
+        repository: TRepository;
+    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
+    withSynchronization<TMappedType, TMapper extends IEntityMapper<TEntity, TMappedType>, TEntityConnector extends IEntityConnector<TEntity, TMappedType>>({ name, options, connector, mapper, }: {
+        name: string;
+        options: ConnectorOptions;
+        connector: TEntityConnector;
+        mapper: TMapper;
+    }): IEntityManagerServiceCollection<TEntity, TEntityId>;
+}
+
+declare class EntityManagerException extends Error {
+    constructor(message: string);
+}
+declare enum EntityOperationType {
+    Create = 0,
+    Update = 1,
+    Delete = 2,
+    Read = 3
+}
+declare class EntityOperationUnauthorizedException<TEntity> extends EntityManagerException {
+    private readonly entity;
+    private readonly operation;
+    constructor(operationType: EntityOperationType, entity: Partial<TEntity>, entityName: string);
+    get getEntity(): Partial<TEntity>;
+    get getOperation(): EntityOperationType;
+}
+declare class EntityNotFoundException<TEntityId> extends EntityManagerException {
+    private readonly entityId;
+    constructor(id?: TEntityId);
+    getEntityId(): TEntityId | undefined;
+}
+declare class MultipleEntitiesFoundException extends EntityManagerException {
+    constructor();
+}
+
+type FilterExpression<TEntity> = (entity: TEntity) => boolean;
+
+interface IEntitySearchResults<TSearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TResult, TSorting extends SortingType, TCursor, TFacets> {
+    request: TSearchParameters;
+    items: TResult[];
+    Facets?: TFacets;
+    paging?: ISearchResultsPaging<TCursor>;
+}
+interface ISearchResultsPaging<TCursor> {
+    pageIndex: number;
+    pageSize: number;
+    totPages: number;
+    nextPageCursor?: TCursor;
+    currentPageCursor?: TCursor;
+    prevPageCursor?: TCursor;
+}
+
+declare class EntityManagerModule implements OnModuleInit {
+    private readonly logger;
+    onModuleInit(): void;
+}
+
+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 };

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@punks/backend-entity-manager",
+  "version": "0.0.1",
+  "description": "",
+  "main": "dist/cjs/index.js",
+  "module": "dist/esm/index.js",
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=16"
+  },
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "test": "jest test --passWithNoTests",
+    "clean": "rimraf dist",
+    "build": "yarn clean && rollup -c",
+    "deploy:npm": "yarn build && npm publish --access public",
+    "type-check": "tsc --noEmit --skipLibCheck"
+  },
+  "keywords": [],
+  "author": "WebPunks",
+  "license": "ISC",
+  "devDependencies": {
+    "@babel/core": "^7.21.0",
+    "@nestjs/common": "^10.0.5",
+    "@nestjs/core": "^10.0.5",
+    "@punks/backend-core": "0.0.5",
+    "@rollup/plugin-commonjs": "^21.0.1",
+    "@rollup/plugin-node-resolve": "^13.0.6",
+    "@rollup/plugin-typescript": "^11.0.0",
+    "@types/jest": "^29.5.2",
+    "jest": "^29.4.3",
+    "pg": "^8.11.1",
+    "pg-mem": "^2.6.13",
+    "reflect-metadata": "^0.1.13",
+    "rimraf": "^3.0.2",
+    "rollup": "^2.60.0",
+    "rollup-plugin-dts": "^4.0.1",
+    "rollup-plugin-peer-deps-external": "^2.2.4",
+    "rollup-plugin-postcss": "^4.0.2",
+    "ts-jest": "^29.1.1",
+    "tslib": "^2.5.0",
+    "typeorm": "^0.3.17",
+    "typescript": "^5.1.6"
+  },
+  "peerDependencies": {
+    "@punks/backend-core": "0.0.5"
+  },
+  "dependencies": {},
+  "jest": {
+    "transform": {
+      ".(ts|tsx)": "ts-jest"
+    },
+    "testRegex": "(/__tests__/.*|\\.(test|spec))\\.(ts|tsx|js)$",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js"
+    ]
+  }
+}

package/readme.md

@@ -0,0 +1,17 @@
+# Punks Entity Manager package
+
+This library contains the entity manager of the Punks backend.
+
+## Installation
+
+```bash
+npm install @punks/backend-entity-manager @punks/backend-core
+```
+
+## Supported ORMs:
+
+- [TypeORM](https://typeorm.io/)
+
+```bash
+npm install typeorm
+```