@sync-in/server 1.10.1 → 2.0.0

package/server/applications/spaces/services/spaces-manager.service.js

@@ -1,8 +1,4 @@
-/*
- * Copyright (C) 2012-2025 Johan Legrand <johan.legrand@sync-in.com>
- * This file is part of Sync-in | The open source file sync and share solution
- * See the LICENSE file for licensing details
- */ "use strict";
+"use strict";
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
@@ -116,7 +112,10 @@ let SpacesManager = class SpacesManager {
             await this.setQuotaExceeded(user, space);
             return space;
         } catch (e) {
-            this.logger.warn(`${this.spaceEnv.name} - *${space.alias}* : ${e}`);
+            this.logger.warn({
+                tag: this.spaceEnv.name,
+                msg: `*${space.alias}* : ${e}`
+            });
             throw new _common.HttpException(e.message, e instanceof _fileerror.FileError ? e.httpCode : _common.HttpStatus.BAD_REQUEST);
         }
     }
@@ -167,7 +166,10 @@ let SpacesManager = class SpacesManager {
                     trashes.push(space);
                 }
             } catch (e) {
-                this.logger.error(`${this.listTrashes.name} - ${e}`);
+                this.logger.error({
+                    tag: this.listTrashes.name,
+                    msg: `${e}`
+                });
             }
         }
         return trashes;
@@ -196,7 +198,10 @@ let SpacesManager = class SpacesManager {
         try {
             space.id = await this.spacesQueries.createSpace(space);
         } catch (e) {
-            this.logger.error(`${this.createSpace.name} - unable to create space *${space.alias}* : ${e}`);
+            this.logger.error({
+                tag: this.createSpace.name,
+                msg: `unable to create space *${space.alias}* : ${e}`
+            });
             throw new _common.HttpException('Unable to create space', e);
         }
         // create space paths
@@ -241,7 +246,10 @@ let SpacesManager = class SpacesManager {
             }
         }
         // updates in db
-        this.spacesQueries.updateSpace(spaceId, spaceDiffProps).catch((e)=>this.logger.error(`${this.updateSpace.name} - ${e}`));
+        this.spacesQueries.updateSpace(spaceId, spaceDiffProps).catch((e)=>this.logger.error({
+                tag: this.updateSpace.name,
+                msg: `${e}`
+            }));
         // checks & updates members
         const linkMembers = await this.sharesManager.createOrUpdateLinksAsMembers(user, space, _links.LINK_TYPE.SPACE, createOrUpdateSpaceDto.links);
         const rootOwnerIds = await this.updateMembers(user, space, [
@@ -276,9 +284,15 @@ let SpacesManager = class SpacesManager {
                 await this.sharesManager.deleteAllLinkMembers(spaceId, _links.LINK_TYPE.SPACE);
             }
             await this.deleteOrDisableSpace(space, deleteNow);
-            this.logger.log(`${this.deleteSpace.name} - *${space.alias}* (${space.id}) was ${deleteNow ? 'deleted' : 'disabled'}`);
+            this.logger.log({
+                tag: this.deleteSpace.name,
+                msg: `*${space.alias}* (${space.id}) was ${deleteNow ? 'deleted' : 'disabled'}`
+            });
         } catch (e) {
-            this.logger.error(`${this.deleteSpace.name} - *${space.alias}* (${space.id}) was not ${deleteNow ? 'deleted' : 'disabled'} : ${e}`);
+            this.logger.error({
+                tag: this.deleteSpace.name,
+                msg: `*${space.alias}* (${space.id}) was not ${deleteNow ? 'deleted' : 'disabled'} : ${e}`
+            });
             throw new _common.HttpException('Unable to delete space', _common.HttpStatus.INTERNAL_SERVER_ERROR);
         }
     }
@@ -288,7 +302,10 @@ let SpacesManager = class SpacesManager {
     async updateUserRoots(user, spaceId, userRoots, addOnly = false) {
         const space = await this.userCanAccessSpace(user.id, spaceId);
         if (space.role !== _spaces.SPACE_ROLE.IS_MANAGER && !(0, _permissions.haveSpacePermission)(space, _spaces.SPACE_OPERATION.SHARE_INSIDE)) {
-            this.logger.warn(`is not allowed to share inside on this space : *${space.alias}* (${space.id})`);
+            this.logger.warn({
+                tag: this.updateUserRoots.name,
+                msg: `is not allowed to share inside on this space : *${space.alias}* (${space.id})`
+            });
             throw new _common.HttpException('You are not allowed to do this action', _common.HttpStatus.FORBIDDEN);
         }
         // current states
@@ -307,7 +324,10 @@ let SpacesManager = class SpacesManager {
             // we need to provide all space roots to avoid collisions on aliases and names for new user roots
             const toAdd = await this.validateNewRoots(user, space, spaceRoots, userRoots, aliases, names);
             const status = await this.spacesQueries.updateSpaceRoots(user.id, space.id, toAdd, [], []);
-            Object.entries(status).forEach(([action, roots])=>this.clearCachePermissionsAndOrNotify(space, action, user, null, roots).catch((e)=>this.logger.error(`${this.updateUserRoots.name} - ${e}`)));
+            Object.entries(status).forEach(([action, roots])=>this.clearCachePermissionsAndOrNotify(space, action, user, null, roots).catch((e)=>this.logger.error({
+                        tag: this.updateUserRoots.name,
+                        msg: `${e}`
+                    })));
             return this.getUserRoots(user, spaceId);
         } else {
             const currentUserRoots = spaceRoots.filter((r)=>r.owner?.id === user.id);
@@ -346,22 +366,34 @@ let SpacesManager = class SpacesManager {
         ]))){
             const userPath = _usermodel.UserModel.getHomePath(user.login);
             if (!await (0, _files.isPathExists)(userPath)) {
-                this.logger.warn(`${this.updatePersonalSpacesQuota.name} - *${user.login}* home path does not exist`);
+                this.logger.warn({
+                    tag: this.updatePersonalSpacesQuota.name,
+                    msg: `*${user.login}* home path does not exist`
+                });
                 continue;
             }
             const [size, errors] = await (0, _files.dirSize)(userPath);
             for (const [path, error] of Object.entries(errors)){
-                this.logger.warn(`${this.updatePersonalSpacesQuota.name} - unable to get size for *${user.login}* on ${path} : ${error}`);
+                this.logger.warn({
+                    tag: this.updatePersonalSpacesQuota.name,
+                    msg: `unable to get size for *${user.login}* on ${path} : ${error}`
+                });
             }
             const spaceQuota = {
                 storageUsage: size,
                 storageQuota: user.storageQuota
             };
-            this.spacesQueries.cache.set(`${_cache.CACHE_QUOTA_USER_PREFIX}-${user.id}`, spaceQuota, _cache.CACHE_QUOTA_TTL).catch((e)=>this.logger.error(`${this.updatePersonalSpacesQuota.name} - user *${user.login}* (${user.id}) : ${e}`));
+            this.spacesQueries.cache.set(`${_cache.CACHE_QUOTA_USER_PREFIX}-${user.id}`, spaceQuota, _cache.CACHE_QUOTA_TTL).catch((e)=>this.logger.error({
+                    tag: this.updatePersonalSpacesQuota.name,
+                    msg: `user *${user.login}* (${user.id}) : ${e}`
+                }));
             if (user.storageUsage !== spaceQuota.storageUsage) {
                 this.usersQueries.updateUserOrGuest(user.id, {
                     storageUsage: spaceQuota.storageUsage
-                }).then((updated)=>updated && this.logger.log(`${this.updatePersonalSpacesQuota.name} - user *${user.login}* (${user.id}) - storage usage updated: ${spaceQuota.storageUsage}`));
+                }).then((updated)=>updated && this.logger.log({
+                        tag: this.updatePersonalSpacesQuota.name,
+                        msg: `user *${user.login}* (${user.id}) - storage usage updated: ${spaceQuota.storageUsage}`
+                    }));
             }
             if (forUser) {
                 return spaceQuota;
@@ -372,7 +404,10 @@ let SpacesManager = class SpacesManager {
         for (const space of (await this.spacesQueries.spacesQuotaPaths(spaceId))){
             const spacePath = _spacemodel.SpaceModel.getHomePath(space.alias);
             if (!await (0, _files.isPathExists)(spacePath)) {
-                this.logger.warn(`${this.updateSpacesQuota.name} - *${space.alias}* home path does not exist`);
+                this.logger.warn({
+                    tag: this.updateSpacesQuota.name,
+                    msg: `*${space.alias}* home path does not exist`
+                });
                 continue;
             }
             let size = 0;
@@ -383,18 +418,27 @@ let SpacesManager = class SpacesManager {
                 const [rPathSize, errors] = await (0, _files.dirSize)(rPath);
                 size += rPathSize;
                 for (const [path, error] of Object.entries(errors)){
-                    this.logger.warn(`${this.updateSpacesQuota.name} - unable to get size for *${space.alias}* on ${path} : ${error}`);
+                    this.logger.warn({
+                        tag: this.updateSpacesQuota.name,
+                        msg: `unable to get size for *${space.alias}* on ${path} : ${error}`
+                    });
                 }
             }
             const spaceQuota = {
                 storageUsage: size,
                 storageQuota: space.storageQuota
             };
-            this.spacesQueries.cache.set(`${_cache.CACHE_QUOTA_SPACE_PREFIX}-${space.id}`, spaceQuota, _cache.CACHE_QUOTA_TTL).catch((e)=>this.logger.error(`${this.updateSpacesQuota.name} - space *${space.alias}* (${space.id}) : ${e}`));
+            this.spacesQueries.cache.set(`${_cache.CACHE_QUOTA_SPACE_PREFIX}-${space.id}`, spaceQuota, _cache.CACHE_QUOTA_TTL).catch((e)=>this.logger.error({
+                    tag: this.updateSpacesQuota.name,
+                    msg: `space *${space.alias}* (${space.id}) : ${e}`
+                }));
             if (space.storageUsage !== spaceQuota.storageUsage) {
                 this.spacesQueries.updateSpace(space.id, {
                     storageUsage: spaceQuota.storageUsage
-                }).then((updated)=>updated && this.logger.log(`${this.updateSpacesQuota.name} - space *${space.alias}* (${space.id}) - storage usage updated : ${spaceQuota.storageUsage}`));
+                }).then((updated)=>updated && this.logger.log({
+                        tag: this.updateSpacesQuota.name,
+                        msg: `space *${space.alias}* (${space.id}) - storage usage updated : ${spaceQuota.storageUsage}`
+                    }));
             }
             if (spaceId) {
                 return spaceQuota;
@@ -418,9 +462,15 @@ let SpacesManager = class SpacesManager {
                 try {
                     await this.sharesManager.deleteAllLinkMembers(space.id, _links.LINK_TYPE.SPACE);
                     await this.deleteOrDisableSpace(space, true);
-                    this.logger.log(`${this.deleteExpiredSpaces.name} - space *${space.alias}* (${space.id}) was deleted`);
+                    this.logger.log({
+                        tag: this.deleteExpiredSpaces.name,
+                        msg: `space *${space.alias}* (${space.id}) was deleted`
+                    });
                 } catch (e) {
-                    this.logger.error(`${this.deleteExpiredSpaces.name} - space *${space.alias}* (${space.id}) was not deleted : ${e}`);
+                    this.logger.error({
+                        tag: this.deleteExpiredSpaces.name,
+                        msg: `space *${space.alias}* (${space.id}) was not deleted : ${e}`
+                    });
                 }
             }
         }
@@ -471,7 +521,10 @@ let SpacesManager = class SpacesManager {
             ]);
             toAdd = add.filter((m)=>{
                 if ((m.type === _member.MEMBER_TYPE.USER || m.type === _member.MEMBER_TYPE.GUEST) && !m.linkId && userIdsWhitelist.indexOf(m.id) === -1 || (m.type === _member.MEMBER_TYPE.GROUP || m.type === _member.MEMBER_TYPE.PGROUP) && groupIdsWhitelist.indexOf(m.id) === -1) {
-                    this.logger.warn(`${this.updateMembers.name} - cannot add ${m.type} (${m.id}) to space *${space.alias}* (${space.id}) : not in the members whitelist`);
+                    this.logger.warn({
+                        tag: this.updateMembers.name,
+                        msg: `cannot add ${m.type} (${m.id}) to space *${space.alias}* (${space.id}) : not in the members whitelist`
+                    });
                     return false;
                 }
                 return true;
@@ -480,7 +533,10 @@ let SpacesManager = class SpacesManager {
         // filter links
         const toRemove = remove.filter((m)=>!m.linkId);
         // do remove links
-        this.sharesManager.deleteLinkMembers(remove.filter((m)=>!!m.linkId)).catch((e)=>this.logger.error(`${this.updateMembers.name} - ${e}`));
+        this.sharesManager.deleteLinkMembers(remove.filter((m)=>!!m.linkId)).catch((e)=>this.logger.error({
+                tag: this.updateMembers.name,
+                msg: `${e}`
+            }));
         // do update members
         const status = await this.spacesQueries.updateMembers(space.id, toAdd, (0, _functions.convertDiffUpdate)(update), toRemove);
         // lists deleted and updated members as potential share or space roots owners
@@ -520,11 +576,17 @@ let SpacesManager = class SpacesManager {
                 }
             }
             // clear cache &|| notify
-            this.onSpaceActionForMembers(space, action, members, user).catch((e)=>this.logger.error(`${this.updateMembers.name} - ${e}`));
+            this.onSpaceActionForMembers(space, action, members, user).catch((e)=>this.logger.error({
+                    tag: this.updateMembers.name,
+                    msg: `${e}`
+                }));
         }
         // do updates
         // remove or update potential shares
-        this.sharesManager.updateSharesFromSpace(space.id, currentMembers, rmShareOwners, upShareOwners).catch((e)=>this.logger.error(`${this.updateMembers.name} - ${e}`));
+        this.sharesManager.updateSharesFromSpace(space.id, currentMembers, rmShareOwners, upShareOwners).catch((e)=>this.logger.error({
+                tag: this.updateMembers.name,
+                msg: `${e}`
+            }));
         // return potential root owner ids
         return rmRootOwners;
     }
@@ -543,7 +605,10 @@ let SpacesManager = class SpacesManager {
                 this.spacesQueries.clearCachePermissions(space.alias, [
                     props.alias.old,
                     props.alias.new
-                ]).catch((e)=>this.logger.error(`${this.updateRoots.name} - ${e}`));
+                ]).catch((e)=>this.logger.error({
+                        tag: this.updateRoots.name,
+                        msg: `${e}`
+                    }));
                 // update aliases list for next roots
                 aliases.push(props.alias.new);
             }
@@ -577,18 +642,27 @@ let SpacesManager = class SpacesManager {
         await this.sharesManager.updateSharesFromSpaceRoots(space.id, rmRoots, rmRootPermissions);
         // do root updates
         const status = await this.spacesQueries.updateSpaceRoots(user.id, space.id, toAdd, (0, _functions.convertDiffUpdate)(toUpdate), toRemove);
-        Object.entries(status).forEach(([action, roots])=>this.clearCachePermissionsAndOrNotify(space, action, user, null, roots).catch((e)=>this.logger.error(`${this.updateRoots.name} - ${e}`)));
+        Object.entries(status).forEach(([action, roots])=>this.clearCachePermissionsAndOrNotify(space, action, user, null, roots).catch((e)=>this.logger.error({
+                    tag: this.updateRoots.name,
+                    msg: `${e}`
+                })));
     }
     async validateNewRoots(user, space, curRoots, newRoots, aliases, names) {
         const toAdd = [];
         for (const r of newRoots){
             if (r.externalPath && !user.isAdmin) {
-                this.logger.warn(`ignore new root *${r.alias}* (${r.externalPath}) : adding an external path requires the admin role`);
+                this.logger.warn({
+                    tag: this.validateNewRoots.name,
+                    msg: `ignore new root *${r.alias}* (${r.externalPath}) : adding an external path requires the admin role`
+                });
                 continue;
             }
             const rPath = r.externalPath || _nodepath.default.join(user.filesPath, r.file.path);
             if (!await (0, _files.isPathExists)(rPath)) {
-                this.logger.warn(`ignore new root *${r.alias}* (${r.file.path}) : *${rPath}* does not exist`);
+                this.logger.warn({
+                    tag: this.validateNewRoots.name,
+                    msg: `ignore new root *${r.alias}* (${r.file.path}) : *${rPath}* does not exist`
+                });
                 continue;
             }
             // check if a parent exists for an externalPath or if the file (or parent) is already anchored
@@ -599,7 +673,10 @@ let SpacesManager = class SpacesManager {
                 rExists = curRoots.find((cr)=>cr.file?.id === r.file.id || cr.owner?.id === r.owner.id && cr.file?.path && r.file.path.startsWith(cr.file.path));
             }
             if (rExists) {
-                this.logger.warn(`ignore new root *${r.alias}* (${r.externalPath || r.file.path}) (${r.file?.id}) : parent or file already exists in roots`);
+                this.logger.warn({
+                    tag: this.validateNewRoots.name,
+                    msg: `ignore new root *${r.alias}* (${r.externalPath || r.file.path}) (${r.file?.id}) : parent or file already exists in roots`
+                });
                 continue;
             }
             // keep the file id (maybe already in db)
@@ -625,13 +702,19 @@ let SpacesManager = class SpacesManager {
         if (deleteNow) {
             // clear cache &|| notify
             const memberIds = await this.spacesQueries.getSpaceMemberIds(space.id);
-            this.onSpaceActionForMembers(space, _constants.ACTION.DELETE_PERMANENTLY, memberIds).catch((e)=>this.logger.error(`${this.deleteOrDisableSpace.name} - ${e}`));
+            this.onSpaceActionForMembers(space, _constants.ACTION.DELETE_PERMANENTLY, memberIds).catch((e)=>this.logger.error({
+                    tag: this.deleteOrDisableSpace.name,
+                    msg: `${e}`
+                }));
             // remove all shares related to the space
             await this.sharesManager.removeSharesFromSpace(space.id);
         }
         await this.spacesQueries.deleteSpace(space.id, deleteNow);
         if (deleteNow) {
-            this.spacesQueries.cache.del(`${_cache.CACHE_QUOTA_SPACE_PREFIX}-${space.id}`).catch((e)=>this.logger.error(`${this.deleteOrDisableSpace.name} - ${e}`));
+            this.spacesQueries.cache.del(`${_cache.CACHE_QUOTA_SPACE_PREFIX}-${space.id}`).catch((e)=>this.logger.error({
+                    tag: this.deleteOrDisableSpace.name,
+                    msg: `${e}`
+                }));
             await this.deleteSpaceLocation(space.alias);
         }
     }
@@ -639,9 +722,15 @@ let SpacesManager = class SpacesManager {
         const spaceLocation = _spacemodel.SpaceModel.getHomePath(spaceAlias);
         if (await (0, _files.isPathExists)(spaceLocation)) {
             await (0, _files.removeFiles)(spaceLocation);
-            this.logger.warn(`${this.deleteSpaceLocation.name} - space *${spaceAlias}* location was deleted`);
+            this.logger.warn({
+                tag: this.deleteSpaceLocation.name,
+                msg: `space *${spaceAlias}* location was deleted`
+            });
         } else {
-            this.logger.warn(`${this.deleteSpaceLocation.name} - space *${spaceAlias}* location does not exist : ${spaceLocation}`);
+            this.logger.warn({
+                tag: this.deleteSpaceLocation.name,
+                msg: `space *${spaceAlias}* location does not exist : ${spaceLocation}`
+            });
         }
     }
     async renameSpaceLocation(oldSpaceAlias, newSpaceAlias) {
@@ -649,7 +738,10 @@ let SpacesManager = class SpacesManager {
         if (await (0, _files.isPathExists)(currentSpaceLocation)) {
             const newSpaceLocation = _spacemodel.SpaceModel.getHomePath(newSpaceAlias);
             if (await (0, _files.isPathExists)(newSpaceLocation)) {
-                this.logger.warn(`${this.renameSpaceLocation.name} - *${newSpaceAlias}* home path already exists : ${newSpaceLocation}`);
+                this.logger.warn({
+                    tag: this.renameSpaceLocation.name,
+                    msg: `*${newSpaceAlias}* home path already exists : ${newSpaceLocation}`
+                });
                 return false;
             } else {
                 try {
@@ -658,12 +750,18 @@ let SpacesManager = class SpacesManager {
                 } catch (e) {
                     // try to restore
                     await (0, _files.moveFiles)(newSpaceLocation, currentSpaceLocation, true);
-                    this.logger.error(`${this.renameSpaceLocation.name} - unable to rename space location from *${currentSpaceLocation}* to *${newSpaceLocation}* : ${e}`);
+                    this.logger.error({
+                        tag: this.renameSpaceLocation.name,
+                        msg: `unable to rename space location from *${currentSpaceLocation}* to *${newSpaceLocation}* : ${e}`
+                    });
                     return false;
                 }
             }
         } else {
-            this.logger.warn(`${this.renameSpaceLocation.name} - *${oldSpaceAlias}* space location does not exist : ${currentSpaceLocation}`);
+            this.logger.warn({
+                tag: this.renameSpaceLocation.name,
+                msg: `*${oldSpaceAlias}* space location does not exist : ${currentSpaceLocation}`
+            });
             return false;
         }
     }
@@ -686,14 +784,20 @@ let SpacesManager = class SpacesManager {
             // Get all space details if user is a manager
             const space = await this.spacesQueries.getSpaceAsManager(userId, spaceId);
             if (!space) {
-                this.logger.warn(`space (${spaceId}) not found or not authorized for user (${userId})`);
+                this.logger.warn({
+                    tag: this.userCanAccessSpace.name,
+                    msg: `space (${spaceId}) not found or not authorized for user (${userId})`
+                });
                 throw new _common.HttpException('Not authorized', _common.HttpStatus.FORBIDDEN);
             }
             return space;
         } else {
             const [space] = await this.spacesQueries.spaces(userId, true, spaceId);
             if (!space) {
-                this.logger.warn(`space (${spaceId}) not found or not authorized for user (${userId})`);
+                this.logger.warn({
+                    tag: this.userCanAccessSpace.name,
+                    msg: `space (${spaceId}) not found or not authorized for user (${userId})`
+                });
                 throw new _common.HttpException('Space not found', _common.HttpStatus.NOT_FOUND);
             }
             return space;
@@ -701,7 +805,10 @@ let SpacesManager = class SpacesManager {
     }
     async userIsSpaceManager(user, spaceId, shareId) {
         if (!await this.spacesQueries.userIsSpaceManager(user.id, spaceId, shareId)) {
-            this.logger.warn(`space (${spaceId}) not found or not authorized for user (${user.id})`);
+            this.logger.warn({
+                tag: this.userIsSpaceManager.name,
+                msg: `space (${spaceId}) not found or not authorized for user (${user.id})`
+            });
             throw new _common.HttpException('Not authorized', _common.HttpStatus.FORBIDDEN);
         }
         return true;
@@ -712,7 +819,10 @@ let SpacesManager = class SpacesManager {
         }
         const cacheQuotaKey = (0, _paths.quotaKeyFromSpace)(user.id, space);
         if (!cacheQuotaKey) {
-            this.logger.verbose(`${this.setQuotaExceeded.name} - quota was ignored for space : *${space.alias}* (${space.id})`);
+            this.logger.verbose({
+                tag: this.setQuotaExceeded.name,
+                msg: `quota was ignored for space : *${space.alias}* (${space.id})`
+            });
             return;
         }
         let quota = await this.spacesQueries.cache.get(cacheQuotaKey);
@@ -732,25 +842,43 @@ let SpacesManager = class SpacesManager {
             space.storageQuota = quota.storageQuota;
             space.quotaIsExceeded = quota.storageQuota !== null && quota.storageUsage >= quota.storageQuota;
         } else {
-            this.logger.verbose(`${this.setQuotaExceeded.name} - quota not found for space : *${space.alias}* (${space.id})`);
+            this.logger.verbose({
+                tag: this.setQuotaExceeded.name,
+                msg: `quota not found for space : *${space.alias}* (${space.id})`
+            });
         }
     }
     async onSpaceActionForMembers(space, action, members, user) {
         this.clearCachePermissionsAndOrNotify(space, action, user, Array.from(new Set([
             ...await this.usersQueries.allUserIdsFromGroupsAndSubGroups(members.groupIds),
             ...members.userIds
-        ])).filter((uid)=>uid !== user?.id)).catch((e)=>this.logger.error(`${this.onSpaceActionForMembers.name} - ${e}`));
+        ])).filter((uid)=>uid !== user?.id)).catch((e)=>this.logger.error({
+                tag: this.onSpaceActionForMembers.name,
+                msg: `${e}`
+            }));
     }
     async clearCachePermissionsAndOrNotify(space, action, user, memberIds, roots) {
         if (memberIds?.length) {
             // clear permissions for space members
             if (action === _constants.ACTION.DELETE_PERMANENTLY) {
-                this.logger.verbose(`${this.clearCachePermissionsAndOrNotify.name} - space:${space.alias} ${action}`);
-                this.spacesQueries.clearCachePermissions(space.alias).catch((e)=>this.logger.error(`${this.clearCachePermissionsAndOrNotify.name} - ${e}`));
+                this.logger.verbose({
+                    tag: this.clearCachePermissionsAndOrNotify.name,
+                    msg: `space:${space.alias} ${action}`
+                });
+                this.spacesQueries.clearCachePermissions(space.alias).catch((e)=>this.logger.error({
+                        tag: this.clearCachePermissionsAndOrNotify.name,
+                        msg: `${e}`
+                    }));
             } else {
                 // update space members cache
-                this.logger.verbose(`${this.clearCachePermissionsAndOrNotify.name} - space:${space.alias} ${action} members:${JSON.stringify(memberIds)}`);
-                this.spacesQueries.clearCachePermissions(space.alias, undefined, memberIds).catch((e)=>this.logger.error(`${this.clearCachePermissionsAndOrNotify.name} - ${e}`));
+                this.logger.verbose({
+                    tag: this.clearCachePermissionsAndOrNotify.name,
+                    msg: `space:${space.alias} ${action} members:${JSON.stringify(memberIds)}`
+                });
+                this.spacesQueries.clearCachePermissions(space.alias, undefined, memberIds).catch((e)=>this.logger.error({
+                        tag: this.clearCachePermissionsAndOrNotify.name,
+                        msg: `${e}`
+                    }));
             }
             // notify
             if (action !== _constants.ACTION.UPDATE) {
@@ -764,14 +892,23 @@ let SpacesManager = class SpacesManager {
                 this.notificationsManager.create(memberIds, notification, {
                     currentUrl: this.contextManager.headerOriginUrl(),
                     action: action
-                }).catch((e)=>this.logger.error(`${this.clearCachePermissionsAndOrNotify.name} - ${e}`));
+                }).catch((e)=>this.logger.error({
+                        tag: this.clearCachePermissionsAndOrNotify.name,
+                        msg: `${e}`
+                    }));
             }
         } else if (roots?.length) {
             // clear permissions for space roots
             const rootAliases = roots.map((r)=>r.alias);
-            this.logger.verbose(`${this.clearCachePermissionsAndOrNotify.name} - space:${space.alias} ${action} roots:${JSON.stringify(rootAliases)}`);
+            this.logger.verbose({
+                tag: this.clearCachePermissionsAndOrNotify.name,
+                msg: `space:${space.alias} ${action} roots:${JSON.stringify(rootAliases)}`
+            });
             if (action !== _constants.ACTION.ADD) {
-                this.spacesQueries.clearCachePermissions(space.alias, rootAliases).catch((e)=>this.logger.error(`${this.clearCachePermissionsAndOrNotify.name} - ${e}`));
+                this.spacesQueries.clearCachePermissions(space.alias, rootAliases).catch((e)=>this.logger.error({
+                        tag: this.clearCachePermissionsAndOrNotify.name,
+                        msg: `${e}`
+                    }));
             }
             // notify
             if (action !== _constants.ACTION.UPDATE) {
@@ -795,7 +932,10 @@ let SpacesManager = class SpacesManager {
                         currentUrl: this.contextManager.headerOriginUrl(),
                         author: user,
                         action: action
-                    }).catch((e)=>this.logger.error(`${this.clearCachePermissionsAndOrNotify.name} - ${e}`));
+                    }).catch((e)=>this.logger.error({
+                            tag: this.clearCachePermissionsAndOrNotify.name,
+                            msg: `${e}`
+                        }));
                 }
             }
         }