@punks/backend-entity-manager 0.0.99 → 0.0.101

package/dist/cjs/index.js

@@ -109,6 +109,14 @@ exports.EntitySerializationFormat = void 0;
     EntitySerializationFormat["Xlsx"] = "xlsx";
 })(exports.EntitySerializationFormat || (exports.EntitySerializationFormat = {}));
 
+exports.EntityVersionOperation = void 0;
+(function (EntityVersionOperation) {
+    EntityVersionOperation["Create"] = "create";
+    EntityVersionOperation["Update"] = "update";
+    EntityVersionOperation["Upsert"] = "upsert";
+    EntityVersionOperation["Delete"] = "delete";
+})(exports.EntityVersionOperation || (exports.EntityVersionOperation = {}));
+
 class EntitySeeder {
     constructor() {
         this.logger = backendCore.Log.getLogger(EntitySeeder.name);
@@ -458,9 +466,11 @@ class EntityCreateCommand {
         this.services = services;
     }
     async execute(input) {
-        var entity = this.adaptEntity(input);
+        const entity = this.adaptEntity(input);
         await this.authorize(entity);
-        var createdItem = await this.services.resolveRepository().create(entity);
+        const createdItem = await this.services.resolveRepository().create(entity);
+        // todo: parametrize id field
+        await this.versionEntity(createdItem.id, createdItem);
         await this.services
             .resolveEventsManager()
             .processEntityCreatedEvent(createdItem);
@@ -486,6 +496,27 @@ class EntityCreateCommand {
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), entity);
     }
+    async versionEntity(id, entity) {
+        if (!this.isVersioningEnabled()) {
+            return;
+        }
+        const versioning = this.services.resolveVersioningProvider();
+        if (!versioning) {
+            return;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        const context = await contextService?.getContext();
+        await versioning.versionEntity({
+            operationType: exports.EntityVersionOperation.Create,
+            entityId: id,
+            entityType: this.services.getEntityName(),
+            data: entity,
+            modifiedByUserId: context?.userId,
+        });
+    }
+    isVersioningEnabled() {
+        return (this.services.resolveEntityConfiguration().versioning?.enabled ?? false);
+    }
 }
 
 class EntityDeleteCommand {
@@ -498,6 +529,7 @@ class EntityDeleteCommand {
         }
         await this.authorize(id);
         await this.services.resolveRepository().delete(id);
+        await this.versionEntity(id);
         await this.services.resolveEventsManager().processEntityDeletedEvent(id);
     }
     async authorize(id) {
@@ -518,6 +550,26 @@ class EntityDeleteCommand {
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Delete, this.services.getEntityName(), entity);
     }
+    async versionEntity(id) {
+        if (!this.isVersioningEnabled()) {
+            return;
+        }
+        const versioning = this.services.resolveVersioningProvider();
+        if (!versioning) {
+            return;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        const context = await contextService?.getContext();
+        await versioning.versionEntity({
+            operationType: exports.EntityVersionOperation.Delete,
+            entityId: id,
+            entityType: this.services.getEntityName(),
+            modifiedByUserId: context?.userId,
+        });
+    }
+    isVersioningEnabled() {
+        return (this.services.resolveEntityConfiguration().versioning?.enabled ?? false);
+    }
 }
 
 class EntitiesDeleteCommand {
@@ -530,6 +582,7 @@ class EntitiesDeleteCommand {
         const deleteResult = await this.services
             .resolveQueryBuilder()
             .delete(params.filters, context);
+        // todo: version deleted entities
         // todo: add entities deleted event
         return deleteResult;
     }
@@ -710,6 +763,7 @@ class EntityUpdateCommand {
         const updatedEntity = await this.services
             .resolveRepository()
             .update(id, entity);
+        await this.versionEntity(id, updatedEntity);
         await this.services
             .resolveEventsManager()
             .processEntityUpdatedEvent(updatedEntity);
@@ -739,6 +793,27 @@ class EntityUpdateCommand {
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), currentEntity);
     }
+    async versionEntity(id, entity) {
+        if (!this.isVersioningEnabled()) {
+            return;
+        }
+        const versioning = this.services.resolveVersioningProvider();
+        if (!versioning) {
+            return;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        const context = await contextService?.getContext();
+        await versioning.versionEntity({
+            operationType: exports.EntityVersionOperation.Update,
+            entityId: id,
+            entityType: this.services.getEntityName(),
+            data: entity,
+            modifiedByUserId: context?.userId,
+        });
+    }
+    isVersioningEnabled() {
+        return (this.services.resolveEntityConfiguration().versioning?.enabled ?? false);
+    }
 }
 
 class EntityUpsertCommand {
@@ -749,6 +824,7 @@ class EntityUpsertCommand {
         const entity = this.adaptEntity(data);
         await this.authorize(id, entity);
         const updatedEntity = await this.upsertEntity(id, entity);
+        await this.versionEntity(id, updatedEntity);
         await this.services
             .resolveEventsManager()
             .processEntityUpdatedEvent(updatedEntity);
@@ -784,6 +860,27 @@ class EntityUpsertCommand {
         if (!authorizationResult.isAuthorized)
             throw new EntityOperationUnauthorizedException(exports.EntityOperationType.Create, this.services.getEntityName(), entity);
     }
+    async versionEntity(id, entity) {
+        if (!this.isVersioningEnabled()) {
+            return;
+        }
+        const versioning = this.services.resolveVersioningProvider();
+        if (!versioning) {
+            return;
+        }
+        const contextService = this.services.resolveAuthenticationContextProvider();
+        const context = await contextService?.getContext();
+        await versioning.versionEntity({
+            operationType: exports.EntityVersionOperation.Upsert,
+            entityId: id,
+            entityType: this.services.getEntityName(),
+            data: entity,
+            modifiedByUserId: context?.userId,
+        });
+    }
+    isVersioningEnabled() {
+        return (this.services.resolveEntityConfiguration().versioning?.enabled ?? false);
+    }
 }
 
 class EntityManager {
@@ -969,6 +1066,9 @@ const EntityServices = {
     Storage: {
         IEntityRepository: "IEntityRepository",
     },
+    Settings: {
+        IEntityConfiguration: "IEntityConfiguration",
+    },
 };
 const GlobalServices = {
     Events: {
@@ -986,6 +1086,9 @@ const GlobalServices = {
         IEmailTemplatesCollection: "IEmailTemplatesCollection",
         IBucketProvider: "IBucketProvider",
     },
+    Versioning: {
+        IEntityVersioningProvider: "IEntityVersioningProvider",
+    },
 };
 
 class EntityServiceLocator {
@@ -1011,6 +1114,12 @@ class EntityServiceLocator {
     resolveEventsManager() {
         return this.services.resolveEventsManager(this.entityName);
     }
+    resolveVersioningProvider() {
+        return this.services.resolveEntityVersioningProvider();
+    }
+    resolveEntityConfiguration() {
+        return this.services.resolveEntityConfiguration(this.entityName);
+    }
     resolveReplicaSyncManager() {
         return this.services.resolveReplicaSyncManager(this.entityName);
     }
@@ -1141,6 +1250,12 @@ class EntitiesServiceLocator {
     registerEmailProvider(instance) {
         this.provider.register(GlobalServices.Plugins.IEmailProvider, instance);
     }
+    resolveEntityVersioningProvider() {
+        return this.provider.resolve(GlobalServices.Versioning.IEntityVersioningProvider);
+    }
+    registerEntityVersioningProvider(instance) {
+        this.provider.register(GlobalServices.Versioning.IEntityVersioningProvider, instance);
+    }
     resolveBucketProvider() {
         return this.provider.resolve(GlobalServices.Plugins.IBucketProvider);
     }
@@ -1173,6 +1288,12 @@ class EntitiesServiceLocator {
     registerAuthenticationContextProvider(instance) {
         this.provider.register(GlobalServices.Authentication.IAuthenticationContextProvider, instance);
     }
+    resolveEntityConfiguration(entityName) {
+        return this.provider.resolveEntityService(EntityServices.Settings.IEntityConfiguration, entityName);
+    }
+    registerEntityConfiguration(entityName, instance) {
+        return this.provider.registerEntityService(EntityServices.Settings.IEntityConfiguration, entityName, instance);
+    }
     resolveEntityManager(entityName) {
         return this.provider.resolveEntityService(EntityServices.Services.IEntityManager, entityName);
     }
@@ -1771,11 +1892,13 @@ class EntityManagerServiceRoot {
     addAuthentication({ provider }) {
         this.getEntitiesServicesLocator().registerAuthenticationContextProvider(provider);
     }
-    registerEntity(entityName, repository) {
+    registerEntity(entity, repository) {
+        const { name: entityName } = entity;
         const collection = new EntityManagerServiceCollection(entityName, this.getEntitiesServicesLocator());
         const services = this.getEntityServicesLocator(entityName);
         collection.locator.registerEntityManager(entityName, new EntityManager(services));
         collection.locator.registerEntityActions(entityName, new EntityActions(services));
+        collection.locator.registerEntityConfiguration(entityName, entity);
         collection.locator.registerRepository(entityName, repository);
         const replicaManager = new EntityReplicaManager(services);
         collection.locator.registerReplicaSyncManager(entityName, replicaManager);
@@ -1957,6 +2080,7 @@ const EntityManagerSymbols = {
     EntityManager: Symbol.for("WP:ENTITY_MANAGER"),
     EntityQueryBuilder: Symbol.for("WP:ENTITY_QUERY_BUILDER"),
     EntitySeeder: Symbol.for("WP:ENTITY_SEEDER"),
+    EntityVersioningProvider: Symbol.for("WP:ENTITY_VERSIONING_PROVIDER"),
     EmailProvider: Symbol.for("WP:EMAIL_PROVIDER"),
     EmailTemplate: Symbol.for("WP:EMAIL_TEMPLATE"),
     BucketProvider: Symbol.for("WP:BUCKET_PROVIDER"),
@@ -2040,6 +2164,10 @@ const WpEventsTracker = (props = {}) => common.applyDecorators(common.Injectable
     ...props,
 }));
 
+const WpEntityVersioningProvider = (props = {}) => common.applyDecorators(common.Injectable(), common.SetMetadata(EntityManagerSymbols.EntityVersioningProvider, {
+    ...props,
+}));
+
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -2303,12 +2431,12 @@ exports.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}`);
         }
         const repositoryInstance = (await app.resolve(repository.discoveredClass.injectType));
-        const registration = this.container.registerEntity(entityName, repositoryInstance);
+        const registration = this.container.registerEntity(entity.meta, repositoryInstance);
         if (!serializer?.discoveredClass?.injectType) {
             throw new Error(`No inject type found for entity serializer: ${entityName}`);
         }
@@ -20867,6 +20995,7 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
         await this.registerEmailTemplates();
         await this.registerEmailProviders();
         await this.registerEventTrackingProviders();
+        await this.registerVersioningProviders();
         await this.registerBucketProviders();
         await this.executeInitializers(app);
         await this.executeSeeders();
@@ -20878,21 +21007,27 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
         });
     }
     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 = backendCore.toDict(repositories, (q) => q.meta.entityName);
         const queryBuilderDict = backendCore.toDict(queryBuilders, (q) => q.meta.entityName);
         const converterDict = backendCore.toDict(converters, (c) => c.meta.entityName);
         const serializerDict = backendCore.toDict(serializers, (s) => s.meta.entityName);
         const adapterDict = backendCore.toDict(adapters, (a) => a.meta.entityName);
         const authDict = backendCore.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}`);
@@ -20903,6 +21038,7 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             const serializer = serializerDict[entityName];
             await this.registry.registerDiscoveredEntity(app, {
                 entityName,
+                entity,
                 adapter,
                 repository,
                 queryBuilder,
@@ -20965,6 +21101,19 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             .registerEventsTracker(providers[0].discoveredClass.instance);
         this.logger.log(`Events tracker ${providers[0].discoveredClass.name} registered 🚜`);
     }
+    async registerVersioningProviders() {
+        const providers = await this.discoverVersioningProviders();
+        if (!providers.length) {
+            return;
+        }
+        for (const provider of providers) {
+            this.registry
+                .getContainer()
+                .getEntitiesServicesLocator()
+                .registerEntityVersioningProvider(provider.discoveredClass.instance);
+            this.logger.log(`Versioning provider ${provider.discoveredClass.name} registered 🚜`);
+        }
+    }
     async registerEmailProviders() {
         const providers = await this.discoverEmailProviders();
         if (!providers.length) {
@@ -21001,9 +21150,15 @@ exports.EntityManagerInitializer = EntityManagerInitializer_1 = class EntityMana
             .get(exports.ModulesContainerProvider)
             .setModulesContainer(staticProviders.modulesContainer);
     }
+    async discoverEntities() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.Entity);
+    }
     async discoverRepositories() {
         return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityRepository);
     }
+    async discoverVersioningProviders() {
+        return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityVersioningProvider);
+    }
     async discoverQueryBuilders() {
         return await this.discover.providersWithMetaAtKey(EntityManagerSymbols.EntityQueryBuilder);
     }
@@ -27453,6 +27608,7 @@ exports.WpEntityQueryBuilder = WpEntityQueryBuilder;
 exports.WpEntityRepository = WpEntityRepository;
 exports.WpEntitySeeder = WpEntitySeeder;
 exports.WpEntitySerializer = WpEntitySerializer;
+exports.WpEntityVersioningTracker = WpEntityVersioningProvider;
 exports.WpEventsTracker = WpEventsTracker;
 exports.WpPipeline = WpPipeline;
 exports.WpRolesService = WpRolesService;