@punks/backend-entity-manager 0.0.1 → 0.0.3

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

@@ -0,0 +1,9 @@
+import { IEntityManager, IEntitySearchParameters, SortingType } from "../../../abstractions";
+import { EntityServiceLocator } from "../../../providers/services";
+import { EntityManagerRegistry } from "../ioc/registry";
+export 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>;
+}

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

@@ -0,0 +1 @@
+export { NestEntityManager } from "./entityManager";

package/dist/cjs/types/platforms/nest/decorators/actions.d.ts

@@ -0,0 +1,4 @@
+export interface EntityActionsProps {
+    entityName: string;
+}
+export 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;

package/dist/cjs/types/platforms/nest/decorators/adapter.d.ts

@@ -0,0 +1,4 @@
+export interface EntityAdapterProps {
+    entityName: string;
+}
+export declare const WpEntityAdapter: (entityName: string, props?: Omit<EntityAdapterProps, "entityName">) => <TFunction extends Function, Y>(target: object | TFunction, propertyKey?: string | symbol | undefined, descriptor?: TypedPropertyDescriptor<Y> | undefined) => void;

package/dist/cjs/types/platforms/nest/decorators/authorization.d.ts

@@ -0,0 +1,4 @@
+export interface EntityAuthMiddlewareProps {
+    entityName: string;
+}
+export 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;

package/dist/cjs/types/platforms/nest/decorators/connector.d.ts

@@ -0,0 +1,4 @@
+export interface EntityConnectorProps {
+    entityName: string;
+}
+export 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;

package/dist/cjs/types/platforms/nest/decorators/converter.d.ts

@@ -0,0 +1,4 @@
+export interface EntityConverterProps {
+    entityName: string;
+}
+export 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;

package/dist/cjs/types/platforms/nest/decorators/entity.d.ts

@@ -0,0 +1,4 @@
+export interface EntityProps {
+    name: string;
+}
+export 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;

package/dist/cjs/types/platforms/nest/decorators/index.d.ts

@@ -0,0 +1,9 @@
+export { WpEntityAuthMiddleware, EntityAuthMiddlewareProps, } from "./authorization";
+export { WpEntityActions, EntityActionsProps } from "./actions";
+export { WpEntityConnector, EntityConnectorProps } from "./connector";
+export { WpEntityConverter, EntityConverterProps } from "./converter";
+export { WpEntity, EntityProps } from "./entity";
+export { WpEntityRepository, EntityRepositoryProps } from "./repository";
+export { WpEntityManager, EntityManagerProps } from "./manager";
+export { WpEntityQueryBuilder, EntityQueryBuilderProps } from "./queryBuilder";
+export { EntityManagerSymbols } from "./symbols";

package/dist/cjs/types/platforms/nest/decorators/manager.d.ts

@@ -0,0 +1,4 @@
+export interface EntityManagerProps {
+    entityName: string;
+}
+export 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;

package/dist/cjs/types/platforms/nest/decorators/queryBuilder.d.ts

@@ -0,0 +1,4 @@
+export interface EntityQueryBuilderProps {
+    entityName: string;
+}
+export 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;

package/dist/cjs/types/platforms/nest/decorators/repository.d.ts

@@ -0,0 +1,4 @@
+export interface EntityRepositoryProps {
+    entityName: string;
+}
+export 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;

package/dist/cjs/types/platforms/nest/decorators/symbols.d.ts

@@ -0,0 +1,11 @@
+export declare const EntityManagerSymbols: {
+    Entity: symbol;
+    EntityActions: symbol;
+    EntityAdapter: symbol;
+    EntityAuthMiddleware: symbol;
+    EntityRepository: symbol;
+    EntityConnector: symbol;
+    EntityConverter: symbol;
+    EntityManager: symbol;
+    EntityQueryBuilder: symbol;
+};

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

@@ -1 +1,4 @@
+export * from "./base";
+export * from "./decorators";
+export * from "./integrations";
 export { EntityManagerModule } from "./module";

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

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

package/dist/cjs/types/platforms/nest/integrations/typeorm/index.d.ts

@@ -0,0 +1,2 @@
+export { NestTypeOrmQueryBuilder } from "./queryBuilder";
+export { NestTypeOrmRepository } from "./repository";

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

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

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

@@ -0,0 +1,5 @@
+import { ObjectLiteral, Repository } from "typeorm";
+import { TypeOrmRepository } from "../../../../integrations";
+export declare class NestTypeOrmRepository<TEntity extends ObjectLiteral, TEntityId> extends TypeOrmRepository<TEntity, TEntityId> {
+    constructor(repository: Repository<TEntity>);
+}

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

@@ -0,0 +1,102 @@
+import { Type } from "@nestjs/common";
+import { ModulesContainer } from "@nestjs/core/injector/modules-container";
+import { MetadataScanner } from "@nestjs/core/metadata-scanner";
+export interface DiscoveredModule<T = object> {
+    name: string;
+    instance: T;
+    injectType?: Function | Type<any>;
+    dependencyType: Type<T>;
+}
+export interface DiscoveredClass extends DiscoveredModule {
+    parentModule: DiscoveredModule;
+}
+export interface DiscoveredMethod {
+    handler: (...args: any[]) => any;
+    methodName: string;
+    parentClass: DiscoveredClass;
+}
+export interface DiscoveredMethodWithMeta<T> {
+    discoveredMethod: DiscoveredMethod;
+    meta: T;
+}
+export interface DiscoveredClassWithMeta<T> {
+    discoveredClass: DiscoveredClass;
+    meta: T;
+}
+export type MetaKey = string | number | symbol;
+export type Filter<T> = (item: T) => boolean;
+/**
+ * Attempts to retrieve meta information from a Nest DiscoveredClass component
+ * @param key The meta key to retrieve data from
+ * @param component The discovered component to retrieve meta from
+ */
+export declare function getComponentMetaAtKey<T>(key: MetaKey, component: DiscoveredClass): T | undefined;
+/**
+ * A filter that can be used to search for DiscoveredClasses in an App that contain meta attached to a
+ * certain key
+ * @param key The meta key to search for
+ */
+export declare const withMetaAtKey: (key: MetaKey) => Filter<DiscoveredClass>;
+export declare class DiscoveryService {
+    private readonly modulesContainer;
+    private readonly metadataScanner;
+    private discoveredControllers?;
+    private discoveredProviders?;
+    constructor(modulesContainer: ModulesContainer, metadataScanner: MetadataScanner);
+    /**
+     * Discovers all providers in a Nest App that match a filter
+     * @param filter
+     */
+    providers(filter: Filter<DiscoveredClass>): Promise<DiscoveredClass[]>;
+    /**
+     * Discovers all controller methods that either directly have a certain meta key attached to them
+     * or belong to a controller that has the same meta key attached to them
+     * @param metaKey The meta key to scan for
+     * @param metaFilter An optional filter for the contents of the meta object
+     */
+    methodsAndControllerMethodsWithMetaAtKey<T>(metaKey: MetaKey, metaFilter?: Filter<T>): Promise<DiscoveredMethodWithMeta<T>[]>;
+    /**
+     * Discovers all providers in an App that have meta at a specific key and returns the provider(s) and associated meta
+     * @param metaKey The metakey to scan for
+     */
+    providersWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T>[]>;
+    /**
+     * Discovers all controllers in a Nest App that match a filter
+     * @param filter
+     */
+    controllers(filter: Filter<DiscoveredClass>): Promise<DiscoveredClass[]>;
+    /**
+     * Discovers all controllers in an App that have meta at a specific key and returns the controller(s) and associated meta
+     * @param metaKey The metakey to scan for
+     */
+    controllersWithMetaAtKey<T>(metaKey: MetaKey): Promise<DiscoveredClassWithMeta<T>[]>;
+    /**
+     * Discovers all method handlers matching a particular metakey from a Provider or Controller
+     * @param component
+     * @param metaKey
+     */
+    classMethodsWithMetaAtKey<T>(component: DiscoveredClass, metaKey: MetaKey): DiscoveredMethodWithMeta<T>[];
+    /**
+     * Discovers all the methods that exist on providers in a Nest App that contain metadata under a specific key
+     * @param metaKey The metakey to scan for
+     * @param providerFilter A predicate used to limit the providers being scanned. Defaults to all providers in the app module
+     */
+    providerMethodsWithMetaAtKey<T>(metaKey: MetaKey, providerFilter?: Filter<DiscoveredClass>): Promise<DiscoveredMethodWithMeta<T>[]>;
+    /**
+     * Discovers all the methods that exist on controllers in a Nest App that contain metadata under a specific key
+     * @param metaKey The metakey to scan for
+     * @param controllerFilter A predicate used to limit the controllers being scanned. Defaults to all providers in the app module
+     */
+    controllerMethodsWithMetaAtKey<T>(metaKey: MetaKey, controllerFilter?: Filter<DiscoveredClass>): Promise<DiscoveredMethodWithMeta<T>[]>;
+    private toDiscoveredClass;
+    private extractMethodMetaAtKey;
+    private discover;
+}
+/**
+ * Exposes a query API over top of the NestJS Module container
+ *
+ * @export
+ * @class DiscoveryModule
+ */
+export declare class DiscoveryModule {
+}

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

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

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

@@ -0,0 +1,18 @@
+import { INestApplicationContext } from "@nestjs/common";
+import { EntityAuthMiddlewareProps, EntityConverterProps, EntityQueryBuilderProps, EntityRepositoryProps } from "../../decorators";
+import { EntityServiceLocator } from "../../../../providers/services";
+import { DiscoveredClassWithMeta } from "../discovery";
+import { EntityAdapterProps } from "../../decorators/adapter";
+export declare class EntityManagerRegistry {
+    private readonly container;
+    getContainer(): import("../../../../abstractions").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>;
+}

package/dist/cjs/types/platforms/nest/module.d.ts

@@ -1,5 +1,2 @@
-import { OnModuleInit } from "@nestjs/common";
-export declare class EntityManagerModule implements OnModuleInit {
-    private readonly logger;
-    onModuleInit(): void;
+export declare class EntityManagerModule {
 }

package/dist/cjs/types/platforms/nest/processors/index.d.ts

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

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

@@ -0,0 +1,16 @@
+import { INestApplicationContext } from "@nestjs/common";
+import { EntityManagerRegistry } from "../../ioc/registry";
+import { DiscoveryService } from "../../ioc/discovery";
+export declare class EntityManagerInitializer {
+    private readonly discover;
+    private readonly registry;
+    private readonly logger;
+    constructor(discover: DiscoveryService, registry: EntityManagerRegistry);
+    initialize(app: INestApplicationContext): Promise<void>;
+    private discoverEntities;
+    private discoverRepositories;
+    private discoverQueryBuilders;
+    private discoverConverters;
+    private discoverAdapters;
+    private discoverAuthMiddlewares;
+}

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

@@ -0,0 +1 @@
+export declare const Services: never[];

package/dist/cjs/types/providers/services.d.ts

@@ -1,9 +1,10 @@
 import { IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDeleteAction, IEntityGetAction, IEntityUpdateAction, IEntityUpsertAction } from "../abstractions/actions";
+import { IEntityAdapter } from "../abstractions/adapters";
 import { IEntityAuthorizationMiddleware } from "../abstractions/authorization";
 import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
 import { SortingType } from "../abstractions/common";
 import { IConnectorsConfiguration, IEntityConnectorDeleteManager, IEntityConnectorSyncManager } from "../abstractions/connectors";
-import { IEntitiesSearchConverter, IEntityCreateCommandConverter, IEntityCreateConverter, IEntityGetConverter, IEntityUpdateActionConverter, IEntityUpdateCommandConverter } from "../abstractions/converters";
+import { IEntityConverter } from "../abstractions/converters";
 import { IEntityEventsManager } from "../abstractions/events";
 import { IEntityManager } from "../abstractions/manager";
 import { IEntitiesQueryBuilder, IEntitiesSearchQuery, IEntityGetQuery } from "../abstractions/queries";
@@ -15,22 +16,18 @@ export 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>;
@@ -51,10 +48,10 @@ export 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>;
@@ -71,18 +68,10 @@ export 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>;

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

@@ -19,12 +19,8 @@ export declare const Services: {
         IEntityDeleteCommand: string;
     };
     Converters: {
-        IEntityCreateCommandConverter: string;
-        IEntityUpdateCommandConverter: string;
-        IEntitiesSearchConverter: string;
-        IEntityGetConverter: string;
-        IEntityCreateActionConverter: string;
-        IEntityUpdateActionConverter: string;
+        IEntityAdapter: string;
+        IEntityConverter: string;
     };
     Connectors: {
         IConnectorsConfiguration: string;

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

@@ -0,0 +1 @@
+export { QueryBuilderBase } from "./queryBuilder";

package/dist/cjs/types/templates/queryBuilder.d.ts

@@ -0,0 +1,11 @@
+import { IEntitiesQueryBuilder, IEntitySearchParameters, ISearchRequestPaging } from "../abstractions";
+import { SortingType } from "../abstractions/common";
+import { EntitiesSearchResults, EntitiesSearchResultsPaging } from "../models";
+export 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;
+}

package/dist/cjs/types/testing/mocks/repository.d.ts

@@ -8,6 +8,7 @@ export declare class InMemoryRepository<TEntity> implements IEntityRepository<TE
     getBy(condition: FilterExpression<TEntity>): Promise<TEntity | undefined>;
     all(): Promise<TEntity[]>;
     find(condition: FilterExpression<TEntity>): Promise<TEntity[]>;
+    count(condition: FilterExpression<TEntity>): Promise<number>;
     findById(id: string[]): Promise<TEntity[]>;
     delete(id: string): Promise<void>;
     deleteBy(condition: FilterExpression<TEntity>): Promise<void>;