@punks/backend-entity-manager 0.0.61 → 0.0.63

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

@@ -1,5 +1,6 @@
 import { IEntitiesSearchResults } from "../models";
 import { SortingType } from "./common";
+import { IEntityFacets } from "./queries";
 import { IEntitySearchParameters } from "./searchParameters";
 export interface IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto> {
     execute(input: TEntityCreateDto): Promise<TEntityDto>;
@@ -16,10 +17,10 @@ export interface IEntityUpdateAction<TEntity, TEntityId, TEntityUpdateDto, TEnti
 export interface IEntityUpsertAction<TEntity, TEntityId, TEntityUpdateDto, TEntityDto> {
     execute(id: TEntityId, input: TEntityUpdateDto): Promise<TEntityDto>;
 }
-export interface IEntitiesSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets> {
+export interface IEntitiesSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>>;
 }
-export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
+export interface IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;
     search(): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
     create(): IEntityCreateAction<TEntity, TEntityCreateDto, TEntityDto>;

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

@@ -7,7 +7,7 @@ import { SortingType } from "./common";
 import { ConnectorOptions, IEntityConnector } from "./connectors";
 import { IEntityConverter } from "./converters";
 import { IEntityMapper } from "./mappers";
-import { IEntitiesQueryBuilder } from "./queries";
+import { IEntitiesQueryBuilder, IEntityFacets } from "./queries";
 import { ReplicaOptions } from "./replication";
 import { IEntityRepository } from "./repository";
 import { IEntitySearchParameters } from "./searchParameters";
@@ -22,7 +22,7 @@ export interface IEntityManagerServiceRoot {
 }
 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, unknown>>({ queryBuilder, }: {
+    mapCrudOperations<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TEntitiesQueryBuilder extends IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, unknown>>({ queryBuilder, }: {
         queryBuilder: TEntitiesQueryBuilder;
     }): IEntityManagerServiceCollection<TEntity, TEntityId>;
     addConverter<TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput, TEntityConverter extends IEntityConverter<TEntity, TEntityDto, TListItemDto, TEntityCreateInput, TEntityUpdateInput>>(converter: TEntityConverter): IEntityManagerServiceCollection<TEntity, TEntityId>;

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

@@ -13,7 +13,7 @@ export * from "./filters";
 export * from "./localization";
 export { IEntityManager } from "./manager";
 export { IEntityMapper } from "./mappers";
-export { IEntitiesSearchQuery, IEntityGetQuery, IEntitiesQueryBuilder, } from "./queries";
+export { IEntitiesSearchQuery, IEntityGetQuery, IEntitiesQueryBuilder, IEntityFacet, IEntityFacets, } from "./queries";
 export { IReplicasConfiguration, ReplicationMode, ReplicaOptions, ReplicaConfiguration, IEntityReplicaDeleteManager, IEntityReplicaSyncManager, } from "./replication";
 export { IEntityRepository } from "./repository";
 export * from "./searchParameters";

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

@@ -1,8 +1,8 @@
 import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "./commands";
 import { SortingType } from "./common";
-import { IEntitiesSearchQuery, IEntityGetQuery } from "./queries";
+import { IEntitiesSearchQuery, IEntityFacets, IEntityGetQuery } from "./queries";
 import { IEntitySearchParameters } from "./searchParameters";
-export interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
+export interface IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     get(): IEntityGetQuery<TEntity, TEntityId>;
     search(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
     create(): IEntityCreateCommand<TEntity, TEntityCreateData>;

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

@@ -2,12 +2,18 @@ import { IEntitiesSearchResults } from "../models";
 import { IAuthenticationContext } from "./authentication";
 import { SortingType } from "./common";
 import { IEntitySearchParameters } from "./searchParameters";
-export interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> {
+export interface IEntityFacet<T> {
+    value: T;
+    name?: string;
+}
+export interface IEntityFacets {
+}
+export interface IEntitiesSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<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, TUserContext> {
+export interface IEntitiesQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> {
     search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
 }

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

@@ -0,0 +1,8 @@
+export interface IEntitySeedEntry<TEntity, TFindCondition> {
+    identifier: TFindCondition;
+    data: () => Partial<TEntity>;
+}
+export interface IEntitySeeder {
+    execute(): Promise<void>;
+    get priority(): number | undefined;
+}

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

@@ -1,9 +1,10 @@
+import { IEntityFacets } from "../abstractions";
 import { IEntitiesSearchAction } from "../abstractions/actions";
 import { SortingType } from "../abstractions/common";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { IEntitiesSearchResults } 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> {
+export declare class EntitiesSearchAction<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntitiesSearchAction<TEntity, TEntitySearchParameters, TListItemDto, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TListItemDto, TSorting, TCursor, TFacets>>;

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

@@ -0,0 +1 @@
+export { EntitySeeder } from "./seed";

package/dist/cjs/types/base/seed.d.ts

@@ -0,0 +1,9 @@
+import { IEntitySeedEntry, IEntitySeeder } from "../abstractions/seed";
+export declare abstract class EntitySeeder<TEntity, TFindCondition> implements IEntitySeeder {
+    protected readonly logger: import("@punks/backend-core").ILogger;
+    execute(): Promise<void>;
+    protected abstract getEntries(): Promise<IEntitySeedEntry<TEntity, TFindCondition>[]>;
+    protected abstract exists(condition: TFindCondition): Promise<boolean>;
+    protected abstract create(entity: Partial<TEntity>): Promise<void>;
+    abstract get priority(): number | undefined;
+}

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

@@ -2,10 +2,10 @@ import { IEntitiesSearchAction, IEntityActions, IEntityCreateAction, IEntityDele
 import { IEntityCreateCommand, IEntityDeleteCommand, IEntityUpdateCommand, IEntityUpsertCommand } from "../abstractions/commands";
 import { SortingType } from "../abstractions/common";
 import { IEntityManager } from "../abstractions/manager";
-import { IEntitiesSearchQuery, IEntityGetQuery } from "../abstractions/queries";
+import { IEntitiesSearchQuery, IEntityFacets, IEntityGetQuery } from "../abstractions/queries";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> implements IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters, TSorting, TCursor, TFacets> {
+export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     get(): IEntityGetQuery<TEntity, TEntityId>;
@@ -15,7 +15,7 @@ export declare class EntityManager<TEntity, TEntityId, TEntityCreateData, TEntit
     upsert(): IEntityUpsertCommand<TEntity, TEntityId, TEntityUpdateData>;
     delete(): IEntityDeleteCommand<TEntity, TEntityId>;
 }
-export declare class EntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets> implements IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters, TSorting, TCursor, TFacets> {
+export declare class EntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> implements IEntityActions<TEntity, TEntityId, TEntityCreateDto, TEntityUpdateDto, TEntityDto, TEntityListItemDto, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     get(): IEntityGetAction<TEntity, TEntityId, TEntityDto>;

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

@@ -1,4 +1,5 @@
 export * from "./abstractions";
+export * from "./base";
 export * from "./models";
 export * from "./events";
 export * from "./platforms";

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

@@ -1,10 +1,10 @@
 import { FindOptionsRelations, FindOptionsWhere, ObjectLiteral } from "typeorm";
-import { IAuthenticationContext, IEntitySearchParameters, SortingType } from "../../../abstractions";
+import { IAuthenticationContext, IEntityFacets, IEntitySearchParameters, SortingType } from "../../../abstractions";
 import { IEntitiesSearchResults } from "../../../models";
 import { QueryBuilderBase } from "../../../templates";
 import { TypeOrmRepository } from "./repository";
 import { EntityServiceLocator } from "../../../providers/services";
-export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
+export declare abstract class TypeOrmQueryBuilder<TEntity extends ObjectLiteral, TEntitySearchParameters extends IEntitySearchParameters<TSorting, number>, TSorting extends SortingType, TFacets extends IEntityFacets, TUserContext> extends QueryBuilderBase<TEntity, TEntitySearchParameters, TSorting, number, TFacets, TUserContext> {
     private readonly services;
     private repository;
     constructor(services: EntityServiceLocator<TEntity, unknown>);

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

@@ -5,6 +5,7 @@ type DeleteCriteria<TEntity extends ObjectLiteral> = string | string[] | number
 export 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>);
+    getInnerRepository(): Repository<TEntity>;
     exists(id: TEntityId): Promise<boolean>;
     existsBy(condition: FindOneOptions<TEntity>): Promise<boolean>;
     get(id: TEntityId): Promise<TEntity | undefined>;

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

@@ -0,0 +1,7 @@
+import { FindOneOptions, ObjectLiteral, Repository } from "typeorm";
+import { EntitySeeder } from "../../../base";
+export declare abstract class TypeOrmEntitySeeder<TEntity extends ObjectLiteral> extends EntitySeeder<TEntity, FindOneOptions<TEntity>> {
+    protected exists(condition: FindOneOptions<TEntity>): Promise<boolean>;
+    protected create(entity: TEntity): Promise<void>;
+    protected abstract getRepository(): Repository<TEntity>;
+}

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

@@ -0,0 +1,9 @@
+import { FindOneOptions } from "typeorm";
+import { IEntitySeedEntry } from "../../../../../../abstractions/seed";
+import { FooEntity } from "../../database/core/entities/foo.entity";
+import { NestTypeOrmEntitySeeder } from "../../../../integrations";
+import { EntityManagerRegistry } from "../../../../ioc";
+export declare class FooSeeder extends NestTypeOrmEntitySeeder<FooEntity> {
+    constructor(registry: EntityManagerRegistry);
+    protected getEntries(): Promise<IEntitySeedEntry<FooEntity, FindOneOptions<FooEntity>>[]>;
+}

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

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

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

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

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

@@ -1,7 +1,7 @@
-import { IEntityManager, IEntitySearchParameters, SortingType } from "../../../abstractions";
+import { IEntityFacets, 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> {
+export declare abstract class NestEntityManager<TEntity, TEntityId, TEntityCreateData, TEntityUpdateData, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets> {
     protected readonly services: EntityServiceLocator<TEntity, TEntityId>;
     private managerInstance;
     constructor(entityName: string, registry: EntityManagerRegistry);

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

@@ -9,5 +9,6 @@ export { WpAppInitializer } from "./initializer";
 export { WpEntityRepository, EntityRepositoryProps } from "./repository";
 export { WpEntityManager, EntityManagerProps } from "./manager";
 export { WpEntityQueryBuilder, EntityQueryBuilderProps } from "./queryBuilder";
+export { WpEntitySeeder, EntitySeederProps } from "./seed";
 export { EntityManagerSymbols } from "./symbols";
 export { WpEventsTracker, EventsTrackerProps } from "./tracking";

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

@@ -0,0 +1,5 @@
+export interface EntitySeederProps {
+    entityName: string;
+    priority?: number;
+}
+export declare const WpEntitySeeder: (entityName: string, props?: Omit<EntitySeederProps, "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

@@ -10,6 +10,7 @@ export declare const EntityManagerSymbols: {
     EntityConverter: symbol;
     EntityManager: symbol;
     EntityQueryBuilder: symbol;
+    EntitySeeder: symbol;
     EmailProvider: symbol;
     EmailTemplate: symbol;
 };

package/dist/cjs/types/platforms/nest/dto/facets.d.ts

@@ -0,0 +1,13 @@
+import { IEntityFacet } from "../../../abstractions";
+export declare class StringFacet implements IEntityFacet<string> {
+    value: string;
+    name?: string;
+}
+export declare class NumericFacet implements IEntityFacet<number> {
+    value: number;
+    name?: string;
+}
+export declare class BooleanFacet implements IEntityFacet<boolean> {
+    value: boolean;
+    name?: string;
+}

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

@@ -0,0 +1 @@
+export { StringFacet, BooleanFacet, NumericFacet } from "./facets";

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

@@ -1,6 +1,7 @@
 export * from "./authentication";
 export * from "./base";
 export * from "./decorators";
+export * from "./dto";
 export * from "./extensions";
 export * from "./integrations";
 export * from "./ioc";

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

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

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

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

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

@@ -0,0 +1,11 @@
+import { ObjectLiteral, Repository } from "typeorm";
+import { TypeOrmEntitySeeder } from "../../../../integrations/repository/typeorm/seed";
+import { EntitySeederProps } from "../../decorators";
+import { EntityManagerRegistry } from "../../ioc";
+export declare abstract class NestTypeOrmEntitySeeder<TEntity extends ObjectLiteral> extends TypeOrmEntitySeeder<TEntity> {
+    private readonly registry;
+    protected readonly metadata: EntitySeederProps;
+    constructor(registry: EntityManagerRegistry);
+    get priority(): number | undefined;
+    protected getRepository(): Repository<TEntity>;
+}

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

@@ -18,6 +18,7 @@ export declare class EntityManagerInitializer {
     private registerAuthentication;
     private registerEntities;
     private executeInitializers;
+    private executeSeeders;
     private registerEventTrackingProviders;
     private registerEmailProviders;
     private registerEmailTemplates;
@@ -28,6 +29,7 @@ export declare class EntityManagerInitializer {
     private discoverAdapters;
     private discoverAuthMiddlewares;
     private discoverAppInitializers;
+    private discoverEntitySeeders;
     private discoverEmailTemplates;
     private discoverEmailProviders;
     private discoverEventTrackingProviders;

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

@@ -0,0 +1 @@
+export declare const orderByPriority: <T>(items: T[], priorityFieldSelector: (item: T) => number | undefined, nameFieldSelector: (item: T) => string) => T[];

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

@@ -3,7 +3,7 @@ import { IEntityManager } from "../../../../abstractions";
 export declare class EntityManagerService {
     private readonly registry;
     constructor(registry: EntityManagerRegistry);
-    getManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, unknown>;
-    getActions<TEntity>(entityName: string): import("../../../../abstractions").IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, unknown>;
+    getManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, any>;
+    getActions<TEntity>(entityName: string): import("../../../../abstractions").IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, any>;
     getRepository<TEntity>(entityName: string): import("../../../../abstractions").IEntityRepository<TEntity, unknown, unknown, unknown, unknown, unknown>;
 }

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

@@ -8,7 +8,7 @@ import { IConnectorsConfiguration, IEntityConnectorDeleteManager, IEntityConnect
 import { IEntityConverter } from "../abstractions/converters";
 import { IEntityEventsManager, IEventEmitter } from "../abstractions/events";
 import { IEntityManager } from "../abstractions/manager";
-import { IEntitiesQueryBuilder, IEntitiesSearchQuery, IEntityGetQuery } from "../abstractions/queries";
+import { IEntitiesQueryBuilder, IEntitiesSearchQuery, IEntityFacets, IEntityGetQuery } from "../abstractions/queries";
 import { IEntityReplicaDeleteManager, IEntityReplicaSyncManager, IReplicasConfiguration } from "../abstractions/replication";
 import { IEntityRepository } from "../abstractions/repository";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
@@ -19,8 +19,8 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     constructor(services: EntitiesServiceLocator, entityName: string);
     getRootServices(): EntitiesServiceLocator;
     resolveAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(): TAuthenticationContextProvider;
-    resolveEntityManager(): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, unknown>;
-    resolveEntityActions(): IEntityActions<TEntity, TEntityId, unknown, unknown, unknown, unknown, any, any, unknown, unknown>;
+    resolveEntityManager(): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, any>;
+    resolveEntityActions(): IEntityActions<TEntity, TEntityId, unknown, unknown, unknown, unknown, any, any, unknown, any>;
     resolveRepository<TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>(): IEntityRepository<TEntity, TEntityId, TGetConditions, TFindCondition, TUpdateCondition, TDeleteCondition>;
     resolveEventsManager(): IEntityEventsManager<TEntity, TEntityId>;
     resolveReplicaSyncManager(): IEntityReplicaSyncManager<TEntity>;
@@ -33,18 +33,18 @@ export declare class EntityServiceLocator<TEntity, TEntityId> {
     resolveAdapter<TEntityCreateData, TEntityUpdateData>(): IEntityAdapter<TEntity, TEntityCreateData, TEntityUpdateData> | undefined;
     resolveAuthorizationMiddleware<TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(): IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext> | undefined;
     resolveGetQuery<TEntityId>(): IEntityGetQuery<TEntity, TEntityId>;
-    resolveSearchQuery<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets>(): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    resolveSearchQuery<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(): 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>;
+    resolveSearchAction<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(): 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, TUserContext>(): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
+    resolveQueryBuilder<TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
     getEntityName(): string;
 }
 export declare class EntitiesServiceLocator {
@@ -61,10 +61,10 @@ export declare class EntitiesServiceLocator {
     registerEmailTemplatesCollection(instance: IEmailTemplatesCollection): void;
     resolveAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(): TAuthenticationContextProvider;
     registerAuthenticationContextProvider<TAuthenticationContextProvider extends IAuthenticationContextProvider<TUserContext>, TUserContext>(instance: TAuthenticationContextProvider): 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;
+    resolveEntityManager<TEntity>(entityName: string): IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, any>;
+    registerEntityManager<TEntity>(entityName: string, instance: IEntityManager<TEntity, unknown, unknown, unknown, any, any, unknown, any>): void;
+    resolveEntityActions<TEntity>(entityName: string): IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, any>;
+    registerEntityActions<TEntity>(entityName: string, instance: IEntityActions<TEntity, unknown, unknown, unknown, unknown, unknown, any, any, unknown, any>): 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>;
@@ -89,8 +89,8 @@ export declare class EntitiesServiceLocator {
     registerAuthorizationMiddleware<TEntity, TAuthenticationContext extends IAuthenticationContext<TUserContext>, TUserContext>(entityName: string, instance: IEntityAuthorizationMiddleware<TEntity, TAuthenticationContext, TUserContext>): 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;
+    resolveSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string): IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets>;
+    registerSearchQuery<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(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>;
@@ -101,8 +101,8 @@ export declare class EntitiesServiceLocator {
     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;
+    resolveSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(entityName: string): IEntitiesSearchAction<TEntity, TEntitySearchParameters, TEntityListItemDto, TSorting, TCursor, TFacets>;
+    registerSearchAction<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TEntityListItemDto, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets>(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>;
@@ -111,6 +111,6 @@ export declare class EntitiesServiceLocator {
     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, TUserContext>(entityName: string): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
-    registerQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets, TUserContext>(entityName: string, instance: IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>): void;
+    resolveQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(entityName: string): IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>;
+    registerQueryBuilder<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext>(entityName: string, instance: IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext>): void;
 }

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

@@ -1,9 +1,9 @@
 import { SortingType } from "../abstractions/common";
-import { IEntitiesSearchQuery } from "../abstractions/queries";
+import { IEntitiesSearchQuery, IEntityFacets } from "../abstractions/queries";
 import { IEntitySearchParameters } from "../abstractions/searchParameters";
 import { IEntitiesSearchResults } from "../models";
 import { EntityServiceLocator } from "../providers/services";
-export declare class EntitiesSearchQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets, TUserContext> implements IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets> {
+export declare class EntitiesSearchQuery<TEntity, TEntityId, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> implements IEntitiesSearchQuery<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets> {
     private readonly services;
     constructor(services: EntityServiceLocator<TEntity, TEntityId>);
     execute(request: TEntitySearchParameters): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;

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

@@ -1 +1 @@
-export declare const getInstanceDecoratorData: <T>(metadataKey: any, instance: Object) => any;
+export declare const getInstanceDecoratorData: <T>(metadataKey: any, instance: Object) => T;

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

@@ -1,7 +1,7 @@
-import { IAuthenticationContext, IEntitiesQueryBuilder, IEntitySearchParameters, ISearchRequestPaging } from "../abstractions";
+import { IAuthenticationContext, IEntitiesQueryBuilder, IEntityFacets, IEntitySearchParameters, ISearchRequestPaging } from "../abstractions";
 import { SortingType } from "../abstractions/common";
 import { IEntitiesSearchResults, IEntitiesSearchResultsPaging } from "../models";
-export declare abstract class QueryBuilderBase<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets, TUserContext> implements IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext> {
+export declare abstract class QueryBuilderBase<TEntity, TEntitySearchParameters extends IEntitySearchParameters<TSorting, TCursor>, TSorting extends SortingType, TCursor, TFacets extends IEntityFacets, TUserContext> implements IEntitiesQueryBuilder<TEntity, TEntitySearchParameters, TSorting, TCursor, TFacets, TUserContext> {
     abstract search(request: TEntitySearchParameters, context?: IAuthenticationContext<TUserContext>): Promise<IEntitiesSearchResults<TEntitySearchParameters, TEntity, TSorting, TCursor, TFacets>>;
     protected getIndexBasedPagingResult({ paging, totResults, currentPageResults, }: {
         paging?: ISearchRequestPaging<number>;