@punks/backend-entity-manager 0.0.1

package/dist/esm/types/__test__/base/test-actions-plain.test.d.ts

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

package/dist/esm/types/__test__/base/test-actions-with-converters.test.d.ts

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

package/dist/esm/types/__test__/base/test-default-entity-manager.test.d.ts

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

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

@@ -0,0 +1,72 @@
+import { IEntityManagerServiceRoot } from "../../abstractions/configuration";
+import { IEntityConverter } from "../../abstractions/converters";
+import { IEntitiesQueryBuilder } from "../../abstractions/queries";
+import { IEntitySearchParameters } from "../../abstractions/searchParameters";
+import { EntitiesSearchResults } from "../../models";
+import { EntityServiceLocator } from "../../providers/services";
+import { InMemoryRepository } from "../../testing/mocks/repository";
+export interface FooEntity {
+    id: string;
+    name: string;
+    age: number;
+    updatedAt: Date;
+}
+export declare class FooRepository extends InMemoryRepository<FooEntity> {
+}
+export interface FooSearchFilters {
+    minAge?: number;
+    maxAge?: number;
+}
+export declare enum FooSorting {
+    Name = "Name",
+    Age = "Age"
+}
+export interface FooCursor {
+    nextPage?: string;
+}
+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 repository;
+    constructor(services: EntityServiceLocator<FooEntity, string>);
+    search(request: FooSearchParameters): Promise<EntitiesSearchResults<FooSearchParameters, FooEntity, FooSorting, FooCursor, FooFacets>>;
+}
+export interface FooDto {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+    updatedAt: Date;
+}
+export interface FooListItemDto {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export interface FooCreateData {
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export interface FooUpdateData {
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateData, FooUpdateData> {
+    toListItemDto(entity: FooEntity): FooListItemDto;
+    toEntityDto(entity: FooEntity): FooDto;
+    createDtoToEntity(input: FooCreateData): Partial<FooEntity>;
+    updateDtoToEntity(input: FooUpdateData): Partial<FooEntity>;
+}
+export declare const registerFooEntity: (container: IEntityManagerServiceRoot, options?: {
+    useConverter?: boolean;
+}) => import("../../abstractions/configuration").IEntityManagerServiceCollection<FooEntity, string>;

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

@@ -0,0 +1,73 @@
+import { DataSource, Repository } from "typeorm";
+import { IEntitiesQueryBuilder, IEntityConverter, IEntityManagerServiceRoot, IEntitySearchParameters } from "../../../../abstractions";
+import { TypeOrmRepository } from "../../../../integrations/repository/typeorm";
+import { EntityServiceLocator } from "../../../../providers/services";
+import { EntitiesSearchResults } from "../../../../models";
+export declare class FooEntity {
+    id: string;
+    name: string;
+    age: number;
+    updatedAt: Date;
+}
+export declare class FooTypeOrmRepo extends TypeOrmRepository<FooEntity, string> {
+    constructor(repository: Repository<FooEntity>);
+}
+export interface FooSearchFilters {
+    minAge?: number;
+    maxAge?: number;
+}
+export declare enum FooSorting {
+    Name = "Name",
+    Age = "Age"
+}
+export interface FooCursor {
+    nextPage?: string;
+}
+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;
+    constructor(services: EntityServiceLocator<FooEntity, string>);
+    search(request: FooSearchParameters): Promise<EntitiesSearchResults<FooSearchParameters, FooEntity, FooSorting, FooCursor, FooFacets>>;
+}
+export interface FooDto {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+    updatedAt: Date;
+}
+export interface FooListItemDto {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export interface FooCreateInput {
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export interface FooUpdateInput {
+    id: string;
+    profile: {
+        name: string;
+        age: number;
+    };
+}
+export declare class FooConverter implements IEntityConverter<FooEntity, FooDto, FooListItemDto, FooCreateInput, FooUpdateInput> {
+    toListItemDto(entity: FooEntity): FooListItemDto;
+    toEntityDto(entity: FooEntity): FooDto;
+    createDtoToEntity(input: FooCreateInput): Partial<FooEntity>;
+    updateDtoToEntity(input: FooUpdateInput): Partial<FooEntity>;
+}
+export declare const registerFooTypeOrmEntity: (container: IEntityManagerServiceRoot, dataSource: DataSource, options?: {
+    useConverter?: boolean;
+}) => import("../../../../abstractions").IEntityManagerServiceCollection<FooEntity, string>;

package/dist/esm/types/__test__/providers/typeorm/mock/index.d.ts

@@ -0,0 +1,7 @@
+import { DataSource } from "typeorm";
+export declare const mockPosrgresDatabase: ({ entities, }: {
+    entities: any[];
+}) => Promise<{
+    db: import("pg-mem").IMemoryDb;
+    dataSource: DataSource;
+}>;

package/dist/esm/types/__test__/providers/typeorm/test-typeorm-actions.test.d.ts

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

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

@@ -0,0 +1,29 @@
+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 IEntityDeleteAction<TEntity, TEntityId> {
+    execute(id: TEntityId): Promise<void>;
+}
+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 IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateData, TEntityDto> {
+    execute(id: TEntityId, input: TEntityUpdateData): 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>;
+    delete(): IEntityDeleteAction<TEntity, TEntityId>;
+}

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

@@ -0,0 +1,9 @@
+export interface IAuthorizationResult {
+    isAuthorized: boolean;
+}
+export interface IEntityAuthorizationMiddleware<TEntity> {
+    canRead(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
+    canCreate(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
+    canUpdate(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
+    canDelete(entity: Partial<TEntity>): Promise<IAuthorizationResult>;
+}

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

@@ -0,0 +1,12 @@
+export interface IEntityCreateCommand<TEntity, TEntityCreateInput> {
+    execute(input: TEntityCreateInput): Promise<TEntity>;
+}
+export interface IEntityUpdateCommand<TEntity, TEntityId, TEntityUpdateData> {
+    execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntity>;
+}
+export interface IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData> {
+    execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntity>;
+}
+export interface IEntityDeleteCommand<TEntity, TEntityId> {
+    execute(id: TEntityId): Promise<void>;
+}

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

@@ -0,0 +1,11 @@
+export type EnumType = string | number | symbol;
+export type SortingType = EnumType;
+export interface ClassType {
+    new (...args: any[]): any;
+    constructor: {
+        name: string;
+    };
+}
+export interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}

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

@@ -0,0 +1,34 @@
+import { EntityServiceLocator } from "../providers/services";
+import { IEntityAuthorizationMiddleware } from "./authorization";
+import { SortingType } from "./common";
+import { ConnectorOptions, IEntityConnector } from "./connectors";
+import { IEntityConverter } from "./converters";
+import { IEntityMapper } from "./mappers";
+import { IEntitiesQueryBuilder } from "./queries";
+import { ReplicaOptions } from "./replication";
+import { IEntityRepository } from "./repository";
+import { IEntitySearchParameters } from "./searchParameters";
+export interface IEntityManagerServiceRoot {
+    registerEntity<TEntity, TEntityId, TRepository extends IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>>(entityName: string, repository: TRepository): IEntityManagerServiceCollection<TEntity, TEntityId>;
+}
+export interface IEntityManagerServiceCollection<TEntity, TEntityId> {
+    getServiceLocator(): EntityServiceLocator<TEntity, TEntityId>;
+    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>>({ queryBuilder, }: {
+        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>;
+}

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

@@ -0,0 +1,30 @@
+import { IEntityMapper } from "./mappers";
+export interface IEntityConnector<TEntity, TMappedType> {
+    syncEntity(entity: TMappedType): Promise<void>;
+    deleteEntity<TEntityId>(id: TEntityId): Promise<void>;
+}
+export 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>[];
+}
+export declare enum ConnectorMode {
+    Sync = 0,
+    Async = 1
+}
+export type ConnectorOptions = {
+    mode: ConnectorMode;
+    enabled?: boolean;
+};
+export type ConnectorConfiguration<TEntity> = {
+    name: string;
+    options: ConnectorOptions;
+    connector: IEntityConnector<TEntity, unknown>;
+    mapper: IEntityMapper<TEntity, unknown>;
+};
+export interface IEntityConnectorSyncManager<TEntity> {
+    syncEntity(entity: TEntity): Promise<void>;
+}
+export interface IEntityConnectorDeleteManager<TEntity, TEntityId> {
+    deleteEntity(entityId: TEntityId): Promise<void>;
+}

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

@@ -0,0 +1,24 @@
+export interface IEntitiesSearchConverter<TEntity, TListItemDto> {
+    toListItemDto(entity: TEntity): TListItemDto;
+}
+export interface IEntityCreateCommandConverter<TEntity, TEntityCreateInput> {
+    createDtoToEntity(input: TEntityCreateInput): Partial<TEntity>;
+}
+export interface IEntityCreateActionConverter<TEntity, TEntityDto> {
+    toEntityDto(entity: TEntity): TEntityDto;
+}
+export interface IEntityCreateConverter<TEntity, TEntityCreateInput, TEntityDto> extends IEntityCreateCommandConverter<TEntity, TEntityCreateInput>, IEntityCreateActionConverter<TEntity, TEntityDto> {
+}
+export interface IEntityGetConverter<TEntity, TEntityDto> {
+    toEntityDto(entity: TEntity): TEntityDto;
+}
+export interface IEntityUpdateCommandConverter<TEntity, TEntityUpdateInput> {
+    updateDtoToEntity(input: TEntityUpdateInput): Partial<TEntity>;
+}
+export interface IEntityUpdateActionConverter<TEntity, TEntityDto> {
+    toEntityDto(entity: TEntity): TEntityDto;
+}
+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> {
+}

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

@@ -0,0 +1,24 @@
+export declare class EntityManagerException extends Error {
+    constructor(message: string);
+}
+export declare enum EntityOperationType {
+    Create = 0,
+    Update = 1,
+    Delete = 2,
+    Read = 3
+}
+export 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;
+}
+export declare class EntityNotFoundException<TEntityId> extends EntityManagerException {
+    private readonly entityId;
+    constructor(id?: TEntityId);
+    getEntityId(): TEntityId | undefined;
+}
+export declare class MultipleEntitiesFoundException extends EntityManagerException {
+    constructor();
+}

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

@@ -0,0 +1,5 @@
+export interface IEntityEventsManager<TEntity, TEntityId> {
+    processEntityCreatedEvent(entity: TEntity): Promise<void>;
+    processEntityUpdatedEvent(entity: TEntity): Promise<void>;
+    processEntityDeletedEvent(id: TEntityId): Promise<void>;
+}

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

@@ -0,0 +1 @@
+export type FilterExpression<TEntity> = (entity: TEntity) => boolean;

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

@@ -0,0 +1,15 @@
+export { IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction, IEntitiesSearchAction, IEntityActions, } from "./actions";
+export * from "./authorization";
+export { IEntityCreateCommand, IEntityUpdateCommand, IEntityUpsertCommand, IEntityDeleteCommand, } from "./commands";
+export { IEntityManagerServiceRoot, IEntityManagerServiceCollection, } from "./configuration";
+export { IEntitiesSearchConverter, IEntityCreateCommandConverter, IEntityCreateActionConverter, IEntityCreateConverter, IEntityGetConverter, IEntityUpdateCommandConverter, IEntityUpdateActionConverter, IEntityUpdateConverter, IEntityConverter, } from "./converters";
+export * from "./errors";
+export { IEntityEventsManager } from "./events";
+export * from "./filters";
+export { IEntityManager } from "./manager";
+export { IEntityMapper } from "./mappers";
+export { IEntitiesSearchQuery, IEntityGetQuery, IEntitiesQueryBuilder, } from "./queries";
+export { IReplicasConfiguration, ReplicationMode, ReplicaOptions, ReplicaConfiguration, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, } from "./replication";
+export { IEntityRepository } from "./repository";
+export * from "./searchParameters";
+export { IEntitySearchResults, ISearchResultsPaging } from "./searchResults";

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

@@ -0,0 +1,12 @@
+import { ClassType, Type } from "./common";
+export interface IResolveServiceOptions {
+    optional?: boolean;
+}
+export 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;
+}

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

@@ -0,0 +1,12 @@
+import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "./commands";
+import { SortingType } from "./common";
+import { IEntitiesSearchQuery, IEntityGetQuery } from "./queries";
+import { IEntitySearchParameters } from "./searchParameters";
+export 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>;
+}

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

@@ -0,0 +1,3 @@
+export interface IEntityMapper<TEntity, TMappedEntity> {
+    mapEntity(entity: TEntity): Promise<TMappedEntity>;
+}

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

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

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

@@ -0,0 +1,25 @@
+import { IEntityRepository } from "./repository";
+export 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>[];
+}
+export declare enum ReplicationMode {
+    Sync = 0,
+    Async = 1
+}
+export type ReplicaOptions = {
+    mode: ReplicationMode;
+    enabled?: boolean;
+};
+export type ReplicaConfiguration<TEntity, TEntityId> = {
+    name: string;
+    options: ReplicaOptions;
+    repository: IEntityRepository<TEntity, TEntityId, unknown, unknown, unknown, unknown>;
+};
+export interface IEntityReplicaDeleteManager<TEntity, TEntityId> {
+    deleteReplicas(entityId: TEntityId): Promise<void>;
+}
+export interface IEntityReplicaSyncManager<TEntity> {
+    syncReplicas(entity: TEntity): Promise<void>;
+}

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

@@ -0,0 +1,15 @@
+export 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>;
+}

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

@@ -0,0 +1,26 @@
+export interface IEntitySearchParameters<TSorting, TCursor> {
+    filters?: ISearchFilters;
+    sorting?: ISearchSorting<TSorting>;
+    paging?: ISearchRequestPaging<TCursor>;
+    options?: ISearchOptions;
+}
+export interface ISearchFilters {
+}
+export interface ISearchOptions {
+    includeFacets?: boolean;
+}
+export interface ISearchRequestPaging<TCursor> {
+    cursor: TCursor;
+    pageSize: number;
+}
+export interface ISearchSortingField<TSorting> {
+    field: TSorting;
+    direction: SortDirection;
+}
+export interface ISearchSorting<TSorting> {
+    fields: ISearchSortingField<TSorting>[];
+}
+export declare enum SortDirection {
+    Asc = 0,
+    Desc = 1
+}

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

@@ -0,0 +1,16 @@
+import { SortingType } from "./common";
+import { IEntitySearchParameters } from "./searchParameters";
+export interface IEntitySearchResults<TSearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TResult, TSorting extends SortingType, TCursor, TFacets> {
+    request: TSearchParameters;
+    items: TResult[];
+    Facets?: TFacets;
+    paging?: ISearchResultsPaging<TCursor>;
+}
+export interface ISearchResultsPaging<TCursor> {
+    pageIndex: number;
+    pageSize: number;
+    totPages: number;
+    nextPageCursor?: TCursor;
+    currentPageCursor?: TCursor;
+    prevPageCursor?: TCursor;
+}

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

@@ -0,0 +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> {
+    private readonly services;
+    private readonly logger;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(input: TEntityCreateInput): Promise<TEntityDto>;
+}

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

@@ -0,0 +1,7 @@
+import { IEntityDeleteAction } from "../abstractions/actions";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityDeleteAction<TEntity, TEntityId> implements IEntityDeleteAction<TEntity, TEntityId> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(id: TEntityId): Promise<void>;
+}

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

@@ -0,0 +1,7 @@
+import { IEntityGetAction } from "../abstractions/actions";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityGetAction<TEntity, TEntityId, TEntityDto> implements IEntityGetAction<TEntity, TEntityId, TEntityDto> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(id: TEntityId): Promise<TEntityDto | undefined>;
+}

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

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

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

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

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

@@ -0,0 +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> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(id: TEntityId, input: TEntityUpdateInput): Promise<TEntityDto>;
+}

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

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

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

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

package/dist/esm/types/commands/delete.d.ts

@@ -0,0 +1,8 @@
+import { IEntityDeleteCommand } from "../abstractions/commands";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityDeleteCommand<TEntity, TEntityId> implements IEntityDeleteCommand<TEntity, TEntityId> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(id: TEntityId): Promise<void>;
+    private authorize;
+}

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

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

package/dist/esm/types/commands/upsert.d.ts

@@ -0,0 +1,10 @@
+import { IEntityUpsertCommand } from "../abstractions/commands";
+import { EntityServiceLocator } from "../providers/services";
+export declare class EntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData> implements IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData> {
+    private readonly services;
+    constructor(services: EntityServiceLocator<TEntity, TEntityId>);
+    execute(id: TEntityId, data: TEntityUpdateData): Promise<TEntity>;
+    private upsertEntity;
+    private adaptEntity;
+    private authorize;
+}