@solidxai/core 0.1.12 → 0.1.13-beta.10

package/dist/services/crud.service.js

@@ -41,6 +41,7 @@ const user_entity_1 = require("../entities/user.entity");
 const setting_service_1 = require("./setting.service");
 const error_messages_1 = require("../constants/error-messages");
 const success_messages_1 = require("../constants/success-messages");
+const user_constants_1 = require("../constants/user.constants");
 const typeorm_1 = require("typeorm");
 const create_field_metadata_dto_1 = require("../dtos/create-field-metadata.dto");
 const model_metadata_entity_1 = require("../entities/model-metadata.entity");
@@ -65,6 +66,8 @@ const SelectionStaticFieldCrudManager_1 = require("../helpers/field-crud-manager
 const ShortTextFieldCrudManager_1 = require("../helpers/field-crud-managers/ShortTextFieldCrudManager");
 const UUIDFieldCrudManager_1 = require("../helpers/field-crud-managers/UUIDFieldCrudManager");
 const model_metadata_helper_service_1 = require("../helpers/model-metadata-helper.service");
+const draft_publish_helper_service_1 = require("./draft-publish-helper.service");
+const internationalisation_helper_service_1 = require("./internationalisation-helper.service");
 const crud_helper_service_1 = require("./crud-helper.service");
 const hashing_service_1 = require("./hashing.service");
 const solid_registry_1 = require("../helpers/solid-registry");
@@ -87,12 +90,30 @@ class CRUDService {
     get crudHelperService() {
         return this._crudHelperService ??= this.moduleRef.get(crud_helper_service_1.CrudHelperService, { strict: false });
     }
+    get draftPublishHelperService() {
+        return this._draftPublishHelperService ??= this.moduleRef.get(draft_publish_helper_service_1.DraftPublishHelperService, { strict: false });
+    }
+    get internationalisationHelperService() {
+        return this._internationalisationHelperService ??= this.moduleRef.get(internationalisation_helper_service_1.InternationalisationHelperService, { strict: false });
+    }
     get discoveryService() {
         return this._discoveryService ??= this.moduleRef.get(core_1.DiscoveryService, { strict: false });
     }
     get settingService() {
         return this._settingService ??= this.moduleRef.get(setting_service_1.SettingService, { strict: false });
     }
+    getDraftPublishCrudContext() {
+        return {
+            repo: this.repo,
+            modelName: this.modelName,
+            moduleName: this.moduleName,
+            validateAndTransformDto: this.validateAndTransformDto.bind(this),
+            saveMedia: this.saveMedia.bind(this),
+            getDatasourceDefaultEntityManager: this.getDatasourceDefaultEntityManager.bind(this),
+            getColumnDatabaseName: this.getColumnDatabaseName.bind(this),
+            escapeDatabaseName: this.escapeDatabaseName.bind(this),
+        };
+    }
     async tryCreateAsExtensionUser(createDto) {
         if (this.repo.metadata?.parentEntityMetadata?.target !== user_entity_1.User)
             return null;
@@ -124,8 +145,11 @@ class CRUDService {
         }
         ;
         try {
+            this.draftPublishHelperService.applyCreateDefaults(model, createDto);
+            this.internationalisationHelperService.applyCreateDefaults(model, createDto, this.moduleRef.get(solid_registry_1.SolidRegistry, { strict: false }));
             const entity = this.repo.create(createDto);
-            const savedEntity = await this.repo.save(entity);
+            let savedEntity = await this.repo.save(entity);
+            savedEntity = await this.draftPublishHelperService.ensureInitialEntityVersionId(model, this.repo, savedEntity);
             if (hasMediaFields) {
                 await this.saveMedia(model, files, savedEntity);
             }
@@ -193,8 +217,9 @@ class CRUDService {
         if (!entity) {
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
-        if (model.draftPublishWorkflow === true && entity.publishedAt) {
-            throw new common_1.BadRequestException(`Cannot update a published record for model ${this.modelName}. Unpublish it first.`);
+        this.draftPublishHelperService.assertUpdateAllowed(model, entity, this.modelName);
+        if (this.draftPublishHelperService.shouldCopyPublishedVersionForUpdate(model, entity)) {
+            return this.draftPublishHelperService.copyPublishedVersionAndUpdate(this.getDraftPublishCrudContext(), id, updateDto, files, isPartialUpdate, model);
         }
         await this.prepareManyToManyAuditSnapshot(entity, id, model.singularName);
         let hasMediaFields = false;
@@ -212,6 +237,16 @@ class CRUDService {
         }
         return savedEntity;
     }
+    getColumnDatabaseName(propertyName) {
+        const column = this.repo.metadata.findColumnWithPropertyName(propertyName);
+        if (!column) {
+            throw new Error(`Column ${propertyName} not found in entity ${this.repo.metadata.name}`);
+        }
+        return column.databaseName;
+    }
+    escapeDatabaseName(databaseName) {
+        return this.repo.manager.connection.driver.escape(databaseName);
+    }
     async prepareManyToManyAuditSnapshot(entity, id, modelSingularName) {
         const modelMetadataHelperService = this.moduleRef.get(model_metadata_helper_service_1.ModelMetadataHelperService, { strict: false });
         const auditRelationFields = (await modelMetadataHelperService.loadFieldHierarchy(modelSingularName)).filter(field => field.enableAuditTracking &&
@@ -262,29 +297,32 @@ class CRUDService {
         if (!entity) {
             throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
         }
-        if (model.draftPublishWorkflow === true && entity.publishedAt) {
-            throw new common_1.BadRequestException(`Cannot update a published record for model ${this.modelName}, Unpublish it first.`);
-        }
-        if (model.internationalisation) {
-            const childEntities = await this.repo.find({
-                where: { defaultEntityLocaleId: id }
-            });
-            if (childEntities.length > 0) {
-                if (model.enableSoftDelete === true) {
-                    await this.repo.softRemove(childEntities);
-                }
-                else {
-                    await this.repo.remove(childEntities);
-                }
-            }
+        const entitiesToDelete = [entity];
+        if (this.draftPublishHelperService.isDraftPublishEnabled(model)) {
+            this.draftPublishHelperService.assertDraftPublishDeleteAllowed(this.modelName, entitiesToDelete);
         }
+        await this.internationalisationHelperService.deleteChildLocaleEntities(this.repo, model, [id]);
+        return this.deleteEntitiesAndPromote(model, entitiesToDelete);
+    }
+    async deleteEntitiesAndPromote(model, entitiesToDelete) {
+        const isDraftPublishEnabled = this.draftPublishHelperService.isDraftPublishEnabled(model);
+        const deletedLatestChainIds = isDraftPublishEnabled
+            ? this.draftPublishHelperService.getLatestDraftPublishChainIds(entitiesToDelete)
+            : [];
+        let deleteResult;
         if (model.enableSoftDelete === true) {
-            await this.repo.softRemove(entity);
-            return this.repo.save(entity);
+            this.draftPublishHelperService.markDeletedDraftPublishVersionsAsNotLatest(model, entitiesToDelete);
+            await this.repo.softRemove(entitiesToDelete);
+            deleteResult = await this.repo.save(entitiesToDelete);
         }
         else {
-            return this.repo.remove(entity);
+            deleteResult = await this.repo.remove(entitiesToDelete);
         }
+        if (isDraftPublishEnabled) {
+            const deletedEntityIds = this.draftPublishHelperService.getEntityIds(entitiesToDelete);
+            await this.draftPublishHelperService.promoteLatestDraftPublishVersionAfterDelete(this.repo, deletedLatestChainIds, deletedEntityIds);
+        }
+        return deleteResult;
     }
     async fieldCrudManager(fieldMetadata, entityManager, isPartialUpdate = false, isUpdate = false, entityId) {
         const commonOptions = { required: fieldMetadata.required && !isPartialUpdate, fieldName: fieldMetadata.name, isUpdate };
@@ -441,9 +479,7 @@ class CRUDService {
         requestContextService.setRequestFilter(basicFilterDto);
         var qb = await this.repo.createSecurityRuleAwareQueryBuilder(alias);
         if (basicFilterDto.groupBy?.length) {
-            const groupFilterQb = (internationalisation && draftPublishWorkflow)
-                ? this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef, crud_helper_service_1.FilterCombinator.AND, false, false)
-                : this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, undefined, undefined, undefined, crud_helper_service_1.FilterCombinator.AND, false, false);
+            const groupFilterQb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef, crud_helper_service_1.FilterCombinator.AND, false, false);
             return this.crudHelperService.executeGroupPipeline(groupFilterQb, basicFilterDto, alias, () => this.repo.createSecurityRuleAwareQueryBuilder(alias), async (entities) => {
                 if (populateUserIdFields?.length)
                     await this.handlePopulateUserIdFields(populateUserIdFields, entities);
@@ -452,9 +488,7 @@ class CRUDService {
             });
         }
         else {
-            qb = (internationalisation && draftPublishWorkflow)
-                ? this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef)
-                : this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias);
+            qb = this.crudHelperService.buildFilterQuery(qb, basicFilterDto, alias, internationalisation, draftPublishWorkflow, this.moduleRef);
             const { meta, records } = await this.handleNonGroupFind(qb, populateUserIdFields, populateMedia, offset, limit, alias);
             return {
                 meta,
@@ -475,6 +509,16 @@ class CRUDService {
     wrapFindResponse(offset, limit, count, entities) {
         return this.crudHelperService.pagedResponse(offset, limit, count, entities);
     }
+    toUserSummary(user) {
+        if (!user) {
+            return null;
+        }
+        const summary = {};
+        for (const field of user_constants_1.USER_SUMMARY_FIELDS) {
+            summary[field] = user[field];
+        }
+        return summary;
+    }
     async handlePopulateUserIdFields(userIdFields, entities) {
         const userRepository = this.entityManager.getRepository(user_entity_1.User);
         for (const entity of entities) {
@@ -483,8 +527,9 @@ class CRUDService {
                 if (userId) {
                     const user = await userRepository.findOne({
                         where: { id: userId },
+                        select: user_constants_1.USER_SUMMARY_FIELDS,
                     });
-                    entity[userFieldPath] = user;
+                    entity[userFieldPath] = this.toUserSummary(user);
                 }
             }
         }
@@ -571,6 +616,7 @@ class CRUDService {
                 throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.FORBIDDEN);
             }
         }
+        this.validateFindOneQueryFields(normalizedPopulate, this.crudHelperService.normalize(fields));
         let entity = await this.repo.findOne({
             where: {
                 id: id,
@@ -587,6 +633,20 @@ class CRUDService {
         }
         return entity;
     }
+    validateFindOneQueryFields(populate, fields) {
+        const metadata = this.repo.metadata;
+        if (!metadata)
+            return;
+        for (const relationPath of populate) {
+            const resolved = this.crudHelperService.resolveFieldPathFromMetadata(metadata, relationPath.split('.'), { allowRelationLeaf: true });
+            if (!resolved.leafIsRelation) {
+                throw new common_1.BadRequestException(`'${relationPath}' is not a relation and cannot be populated.`);
+            }
+        }
+        for (const field of fields) {
+            this.crudHelperService.resolveFieldPathFromMetadata(metadata, field.split('.'));
+        }
+    }
     async createMany(createDtos, solidRequestContext = {}) {
         const loadedmodel = await this.loadModel();
         if (solidRequestContext.activeUser) {
@@ -602,6 +662,7 @@ class CRUDService {
             },
             module: true,
         });
+        const solidRegistry = this.moduleRef.get(solid_registry_1.SolidRegistry, { strict: false });
         const entitiesForSave = [];
         for (const createDto of createDtos) {
             let transformedDto = createDto;
@@ -613,6 +674,7 @@ class CRUDService {
                 }
                 transformedDto = await fieldManager.transformForCreate(createDto);
             }
+            this.internationalisationHelperService.applyCreateDefaults(model, transformedDto, solidRegistry);
             const entity = this.repo.create(transformedDto);
             entitiesForSave.push(entity);
         }
@@ -649,24 +711,16 @@ class CRUDService {
                     id: id,
                 },
             });
+            if (!entity) {
+                throw new Error(`Entity [${this.moduleName}.${this.modelName}] with id ${id} not found`);
+            }
             removedEntities.push(entity);
         }
-        const isDraftPublishEnabled = model?.draftPublishWorkflow === true;
-        let publishedEntitiesExists = [];
-        if (isDraftPublishEnabled) {
-            publishedEntitiesExists = removedEntities.filter((x) => !!x?.publishedAt);
-        }
-        if (publishedEntitiesExists.length > 0) {
-            const publishedEntitiesExistsID = publishedEntitiesExists.map(x => x.id);
-            throw new common_1.BadRequestException(`Cannot delete published record(s) for model ${this.modelName} with Ids ${publishedEntitiesExistsID.join(', ')}. Unpublish them first.`);
-        }
-        if (model.enableSoftDelete === true) {
-            await this.repo.softRemove(removedEntities);
-            return this.repo.save(removedEntities);
-        }
-        else {
-            return this.repo.remove(removedEntities);
+        if (this.draftPublishHelperService.isDraftPublishEnabled(model)) {
+            this.draftPublishHelperService.assertDraftPublishDeleteAllowed(this.modelName, removedEntities);
         }
+        await this.internationalisationHelperService.deleteChildLocaleEntities(this.repo, model, ids);
+        return this.deleteEntitiesAndPromote(model, removedEntities);
     }
     async recover(id, solidRequestContext = {}) {
         try {
@@ -689,6 +743,9 @@ class CRUDService {
             await this.repo.update(id, {
                 deletedAt: null, deletedTracker: "not-deleted"
             });
+            if (this.draftPublishHelperService.isDraftPublishEnabled(loadedmodel)) {
+                await this.draftPublishHelperService.promoteRecoveredDraftPublishVersion(this.repo, softDeletedRows);
+            }
             return { message: success_messages_1.SUCCESS_MESSAGES.RECORD_RECOVERED, data: softDeletedRows };
         }
         catch (error) {
@@ -724,6 +781,11 @@ class CRUDService {
                 throw new common_1.NotFoundException(error_messages_1.ERROR_MESSAGES.NO_SOFT_DELETED_RECORDS_FOUND);
             }
             await this.repo.update({ id: (0, typeorm_1.In)(ids) }, { deletedAt: null, deletedTracker: "not-deleted" });
+            if (this.draftPublishHelperService.isDraftPublishEnabled(loadedmodel)) {
+                for (const entity of softDeletedRows) {
+                    await this.draftPublishHelperService.promoteRecoveredDraftPublishVersion(this.repo, entity);
+                }
+            }
             return { message: success_messages_1.SUCCESS_MESSAGES.SELECTED_RECORDS_RECOVERED, recoveredIds: ids };
         }
         catch (error) {
@@ -769,45 +831,23 @@ class CRUDService {
     }
     async publishRecord(id, solidRequestContext = {}) {
         const model = await this.loadModel();
-        if (!model.draftPublishWorkflow) {
-            throw new common_1.BadRequestException(`Publish workflow is not enabled for ${this.modelName}`);
-        }
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasPublishPermissionOnModel(solidRequestContext.activeUser, model.singularName);
             if (!hasPermission) {
                 throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.FORBIDDEN);
             }
         }
-        const entity = await this.repo.findOne({ where: { id } });
-        if (!entity) {
-            throw new common_1.NotFoundException(`${this.modelName} with id ${id} not found`);
-        }
-        if (entity.publishedAt) {
-            throw new common_1.BadRequestException(`${this.modelName} with id ${id} is already published`);
-        }
-        const updatedEntity = await this.repo.save({ ...entity, publishedAt: new Date() });
-        return updatedEntity;
+        return this.draftPublishHelperService.publishRecord(this.repo, model, this.modelName, id, solidRequestContext.activeUser);
     }
     async unpublishRecord(id, solidRequestContext = {}) {
         const model = await this.loadModel();
-        if (!model.draftPublishWorkflow) {
-            throw new common_1.BadRequestException(`Publish workflow is not enabled for ${this.modelName}`);
-        }
         if (solidRequestContext.activeUser) {
             const hasPermission = this.crudHelperService.hasUnpublishPermissionOnModel(solidRequestContext.activeUser, model.singularName);
             if (!hasPermission) {
                 throw new common_1.BadRequestException(error_messages_1.ERROR_MESSAGES.FORBIDDEN);
             }
         }
-        const entity = await this.repo.findOne({ where: { id } });
-        if (!entity) {
-            throw new common_1.NotFoundException(`${this.modelName} with id ${id} not found`);
-        }
-        if (!entity.publishedAt) {
-            throw new common_1.BadRequestException(`${this.modelName} with id ${id} is already unpublished`);
-        }
-        const updatedEntity = await this.repo.save({ ...entity, publishedAt: null });
-        return updatedEntity;
+        return this.draftPublishHelperService.unpublishRecord(this.repo, model, this.modelName, id, solidRequestContext.activeUser);
     }
     getDatasourceDefaultEntityManager() {
         return this.defaultDatasourceEntityManager ?? this.entityManager;