@punks/backend-entity-manager 0.0.98 → 0.0.100

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

@@ -1,4 +1,5 @@
 export interface IEntitySearchParameters<TSorting, TCursor> {
+    query?: IFullTextQuery;
     filters?: ISearchFilters;
     sorting?: ISearchSorting<TSorting>;
     paging?: ISearchRequestPaging<TCursor>;
@@ -24,3 +25,7 @@ export declare enum SortDirection {
     Asc = "asc",
     Desc = "desc"
 }
+export interface IFullTextQuery {
+    term: string;
+    fields?: string[];
+}

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

@@ -1,4 +1,8 @@
+export type EntityVersioningOptions = {
+    enabled: boolean;
+};
 export interface EntityProps {
     name: string;
+    versioning?: EntityVersioningOptions;
 }
 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/ioc/registry/index.d.ts

@@ -1,5 +1,5 @@
 import { INestApplicationContext } from "@nestjs/common";
-import { EntityAuthMiddlewareProps, EntityConverterProps, EntityQueryBuilderProps, EntityRepositoryProps, EntitySerializerProps } from "../../decorators";
+import { EntityAuthMiddlewareProps, EntityConverterProps, EntityProps, EntityQueryBuilderProps, EntityRepositoryProps, EntitySerializerProps } from "../../decorators";
 import { EntityManagerSettings } from "../../../../abstractions";
 import { EntityServiceLocator } from "../../../../providers/services";
 import { DiscoveredClassWithMeta } from "../discovery";
@@ -11,8 +11,9 @@ export declare class EntityManagerRegistry {
     registerGlobalServices({ eventEmitter, }: {
         eventEmitter?: IEventEmitter;
     }): Promise<void>;
-    registerDiscoveredEntity(app: INestApplicationContext, { adapter, entityName, converter, queryBuilder, repository, authMiddleware, serializer, settings, }: {
+    registerDiscoveredEntity(app: INestApplicationContext, { adapter, entityName, entity, converter, queryBuilder, repository, authMiddleware, serializer, settings, }: {
         entityName: string;
+        entity: DiscoveredClassWithMeta<EntityProps>;
         repository: DiscoveredClassWithMeta<EntityRepositoryProps>;
         converter: DiscoveredClassWithMeta<EntityConverterProps>;
         adapter: DiscoveredClassWithMeta<EntityAdapterProps>;

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

@@ -26,6 +26,7 @@ export declare class EntityManagerInitializer {
     private registerEmailTemplates;
     private registerPipelinesServices;
     private initializeProviders;
+    private discoverEntities;
     private discoverRepositories;
     private discoverQueryBuilders;
     private discoverConverters;

package/dist/esm/index.js

@@ -2295,7 +2295,7 @@ let EntityManagerRegistry = class EntityManagerRegistry {
                 .registerEventEmitter(eventEmitter);
         }
     }
-    async registerDiscoveredEntity(app, { adapter, entityName, converter, queryBuilder, repository, authMiddleware, serializer, settings, }) {
+    async registerDiscoveredEntity(app, { adapter, entityName, entity, converter, queryBuilder, repository, authMiddleware, serializer, settings, }) {
         if (!repository.discoveredClass.injectType) {
             throw new Error(`No inject type found for entity repository: ${entityName}`);
         }
@@ -20870,21 +20870,27 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
         });
     }
     async registerEntities(app, staticProviders) {
+        const entities = await this.discoverEntities();
         const repositories = await this.discoverRepositories();
         const queryBuilders = await this.discoverQueryBuilders();
         const converters = await this.discoverConverters();
         const serializers = await this.discoverSerializers();
         const adapters = await this.discoverAdapters();
         const auth = await this.discoverAuthMiddlewares();
+        const repositoriesDict = toDict(repositories, (q) => q.meta.entityName);
         const queryBuilderDict = toDict(queryBuilders, (q) => q.meta.entityName);
         const converterDict = toDict(converters, (c) => c.meta.entityName);
         const serializerDict = toDict(serializers, (s) => s.meta.entityName);
         const adapterDict = toDict(adapters, (a) => a.meta.entityName);
         const authDict = toDict(auth, (a) => a.meta.entityName);
-        const sortedRepositories = lodash.exports.orderBy(repositories, (x) => x.meta.entityName);
-        this.logger.log(`Discovered repositories: \n${sortedRepositories.join(" \n")}`);
-        for (const repository of sortedRepositories) {
-            const entityName = repository.meta.entityName;
+        const sortedEntities = lodash.exports.orderBy(entities, (x) => x.meta.name);
+        this.logger.log(`Discovered entities: \n${sortedEntities.join(" \n")}`);
+        for (const entity of sortedEntities) {
+            const entityName = entity.meta.name;
+            const repository = repositoriesDict[entityName];
+            if (!repository) {
+                throw new Error(`No repository found for entity: ${entityName}`);
+            }
             const queryBuilder = queryBuilderDict[entityName];
             if (!queryBuilder) {
                 throw new Error(`No query builder found for entity: ${entityName}`);
@@ -20895,6 +20901,7 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
             const serializer = serializerDict[entityName];
             await this.registry.registerDiscoveredEntity(app, {
                 entityName,
+                entity,
                 adapter,
                 repository,
                 queryBuilder,
@@ -20993,6 +21000,9 @@ let EntityManagerInitializer = EntityManagerInitializer_1 = class EntityManagerI
             .get(ModulesContainerProvider)
             .setModulesContainer(staticProviders.modulesContainer);
     }
+    async discoverEntities() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.Entity);
+    }
     async discoverRepositories() {
         return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityRepository);
     }