itlab-internal-services 2.16.1 → 2.16.3

package/dist/modules/{comment/comment.service.d.ts → comments/comments.service.d.ts}

@@ -2,29 +2,33 @@ import { ConfigService } from '@nestjs/config';
 import { LabComment, LabContentRichtext } from 'itlab-functions';
 import { Connection } from 'mongoose';
 import { AuthenticationModuleOptions } from '../authentication';
+import { CacheService } from '../cache';
 import { BaseHttpService } from '../services/base-http.service';
-import { CommentModuleOptions } from './comment-module-options.interface';
+import { CommentsModuleOptions } from './comments-module-options.interface';
 /**
- * CommentService manages persistence and business logic
+ * CommentsService manages persistence and business logic
  * for adding, comments on resource entities.
  *
  * Why: Encapsulates MongoDB operations and ensures consistent handling
  * of comment-related behavior across all resources that support comments.
  */
-export declare class CommentService extends BaseHttpService {
-    private readonly moduleOptions;
-    private readonly connection;
-    private readonly commentModel;
+export declare class CommentsService extends BaseHttpService {
+    private readonly options;
+    private readonly connection?;
+    private readonly cacheService?;
     /**
-     * Constructs the CommentService with a configured model instance.
+     * Constructs the CommentsService with a configured model instance.
      *
      * Why: Using the provided Mongoose connection and model options ensures
      * that comments are tied to the correct resource collection dynamically.
      *
-     * @param {CommentModuleOptions} moduleOptions - Config for the commentable resource model.
+     * @param {CommentsModuleOptions} options - Config for the commentable resource model.
      * @param {Connection} connection - Mongoose database connection.
      */
-    constructor(moduleOptions: CommentModuleOptions<any>, connection: Connection, authenticationOptions: AuthenticationModuleOptions, configService: ConfigService);
+    constructor(authenticationOptions: AuthenticationModuleOptions, options: CommentsModuleOptions<any>, configService: ConfigService, connection?: Connection, cacheService?: CacheService);
+    private get commentModel();
+    private cacheKey;
+    private clearCache;
     /**
      * Posts a comment to a given resource, optionally attaching ownership metadata.
      *
@@ -41,4 +45,26 @@ export declare class CommentService extends BaseHttpService {
      * @throws {HttpException} If the internal service call fails.
      */
     postComment(resourceId: string, accountId: string, richtext: LabContentRichtext): Promise<LabComment>;
+    /**
+     * Deletes all comments for a given resource.
+     * Logs success or failure. Does not throw to avoid disrupting cleanup flows.
+     *
+     * @param resourceId Unique identifier of the resource whose comments will be deleted.
+     */
+    deleteComments(resourceId: string): void;
+    /**
+     * Retrieves comments from the backend.
+     * Provides default values if comments retrieval fails.
+     *
+     * @param resourceId Unique identifier of the resource.
+     * @returns Retrieved comments.
+     */
+    getPopulatedComments(resourceId: string): Promise<LabComment[]>;
+    /**
+     * Retrieves comments from the cache if available; otherwise fetches from the backend.
+     *
+     * @param resourceId Unique identifier of the resource.
+     * @returns Cached or freshly retrieved comments.
+     */
+    getCachedPopulatedComments(resourceId: string): Promise<LabComment[]>;
 }

package/dist/modules/comments/comments.service.js

@@ -0,0 +1,165 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommentsService = void 0;
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const mongoose_1 = require("@nestjs/mongoose");
+const mongoose_2 = require("mongoose");
+const authentication_1 = require("../authentication");
+const cache_1 = require("../cache");
+const base_http_service_1 = require("../services/base-http.service");
+const base_urls_1 = require("../services/base-urls");
+const comments_module_definition_1 = require("./comments.module-definition");
+/**
+ * CommentsService manages persistence and business logic
+ * for adding, comments on resource entities.
+ *
+ * Why: Encapsulates MongoDB operations and ensures consistent handling
+ * of comment-related behavior across all resources that support comments.
+ */
+let CommentsService = class CommentsService extends base_http_service_1.BaseHttpService {
+    /**
+     * Constructs the CommentsService with a configured model instance.
+     *
+     * Why: Using the provided Mongoose connection and model options ensures
+     * that comments are tied to the correct resource collection dynamically.
+     *
+     * @param {CommentsModuleOptions} options - Config for the commentable resource model.
+     * @param {Connection} connection - Mongoose database connection.
+     */
+    constructor(authenticationOptions, options, configService, connection, cacheService) {
+        super('Comment', base_urls_1.BaseUrls.CommentsService, authenticationOptions, configService);
+        this.options = options;
+        this.connection = connection;
+        this.cacheService = cacheService;
+        this.cacheKey = (resourceId) => {
+            return `${this.options.resource}.${resourceId}.populatedComments`;
+        };
+    }
+    get commentModel() {
+        if (!this.connection) {
+            this.logger.debug("Couldn't load comment Model... Not connected to the database");
+            return undefined;
+        }
+        return this.connection.model(this.options.model.name, this.options.model.schema);
+    }
+    clearCache(resourceId) {
+        if (this.cacheService) {
+            const cacheKey = this.cacheKey(resourceId);
+            this.cacheService.remove(cacheKey).then(() => {
+                this.logger.log(`Comments cache for ${this.options.resource} ${resourceId} cleared.`);
+            });
+        }
+    }
+    /**
+     * Posts a comment to a given resource, optionally attaching ownership metadata.
+     *
+     * Why:
+     * - Ensures that the resource exists before attempting to save a comment.
+     * - Optionally extracts `ownerId` or `ownerIds` for downstream authorization or notifications.
+     * - Wraps the internal HTTP call in a promise with proper error handling and logging.
+     *
+     * @param {string} resourceId - MongoDB ObjectId of the resource being commented on.
+     * @param {string} accountId - Authenticated user ID posting the comment.
+     * @param {LabContentRichtext} richtext - Comment content in rich-text format.
+     * @returns {Promise<LabComment>} Resolves with the saved comment or throws an HTTP exception.
+     * @throws {NotFoundException} If the resource does not exist.
+     * @throws {HttpException} If the internal service call fails.
+     */
+    async postComment(resourceId, accountId, richtext) {
+        var _a;
+        const resourceType = this.options.model.name.toLowerCase();
+        // Verify that the resource exists before posting a comment.
+        const resource = await ((_a = this.commentModel) === null || _a === void 0 ? void 0 : _a.findOne({ _id: resourceId }));
+        if (!resource) {
+            this.logger.error(`Cannot post comment: ${resourceType} ${resourceId} not found`);
+            throw new common_1.NotFoundException('Kommentar konnte nicht erstellt werden');
+        }
+        // Extract ownership metadata if configured for downstream use.
+        const ownerId = this.options.ownerIdField ? resource[this.options.ownerIdField] : undefined;
+        const ownerIds = this.options.ownerIdsField ? resource[this.options.ownerIdsField] : undefined;
+        const endpoint = `internal/${this.options.resource}/${resourceId}/${accountId}`;
+        this.logger.log(`Account ${accountId} is posting a comment on ${resourceType} resource ${resourceId}`);
+        try {
+            const { data } = await this.client.post(endpoint, richtext, {
+                params: { ownerId, ownerIds },
+            });
+            this.logger.log(`Account ${accountId} successfully posted a comment on ${resourceType} resource ${resourceId}`);
+            this.clearCache(resourceId);
+            return data;
+        }
+        catch (error) {
+            const { status, data, message } = this.parseError(error);
+            this.logger.error(`Account ${accountId} failed to post comment on ${resourceType} resource ${resourceId}: ${message}`);
+            throw new common_1.HttpException(data, status);
+        }
+    }
+    /**
+     * Deletes all comments for a given resource.
+     * Logs success or failure. Does not throw to avoid disrupting cleanup flows.
+     *
+     * @param resourceId Unique identifier of the resource whose comments will be deleted.
+     */
+    deleteComments(resourceId) {
+        const endpoint = `internal/${this.options.resource}/${resourceId}`;
+        this.logger.log(`Deleting all comments for ${this.options.resource} ${resourceId}...`);
+        this.client
+            .delete(endpoint)
+            .then(() => {
+            this.logger.log(`All comments for ${this.options.resource} ${resourceId} deleted successfully.`);
+            this.clearCache(resourceId);
+        })
+            .catch((error) => {
+            const { message } = this.parseError(error);
+            this.logger.error(`Failed to delete comments for ${this.options.resource} ${resourceId}: ${message}`);
+        });
+    }
+    /**
+     * Retrieves comments from the backend.
+     * Provides default values if comments retrieval fails.
+     *
+     * @param resourceId Unique identifier of the resource.
+     * @returns Retrieved comments.
+     */
+    async getPopulatedComments(resourceId) {
+        return this.fetchResourceCollection(`internal/${this.options.resource}/${resourceId}/populated`);
+    }
+    /**
+     * Retrieves comments from the cache if available; otherwise fetches from the backend.
+     *
+     * @param resourceId Unique identifier of the resource.
+     * @returns Cached or freshly retrieved comments.
+     */
+    async getCachedPopulatedComments(resourceId) {
+        const fetchPopulatedComments = () => this.getPopulatedComments(resourceId);
+        if (this.cacheService) {
+            const cacheKey = this.cacheKey(resourceId);
+            return this.cacheService.fetchOrStore(cacheKey, fetchPopulatedComments, 60000); // 1 Minute
+        }
+        return fetchPopulatedComments();
+    }
+};
+exports.CommentsService = CommentsService;
+exports.CommentsService = CommentsService = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, authentication_1.InjectAuthenticationOptions)()),
+    __param(1, (0, common_1.Inject)(comments_module_definition_1.COMMENTS_MODULE_OPTIONS_TOKEN)),
+    __param(3, (0, common_1.Optional)()),
+    __param(3, (0, mongoose_1.InjectConnection)()),
+    __param(4, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [Object, Object, config_1.ConfigService,
+        mongoose_2.Connection,
+        cache_1.CacheService])
+], CommentsService);

package/dist/modules/comments/index.d.ts

@@ -0,0 +1,3 @@
+export * from './comments-module-options.interface';
+export * from './comments.module';
+export * from './comments.service';

package/dist/modules/{services/providers/comments → comments}/index.js

@@ -14,4 +14,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./comments-module-options.interface"), exports);
+__exportStar(require("./comments.module"), exports);
 __exportStar(require("./comments.service"), exports);

package/dist/modules/index.d.ts

@@ -1,6 +1,6 @@
 export * from './authentication';
 export * from './cache';
-export * from './comment';
+export * from './comments';
 export * from './database';
 export * from './like';
 export * from './merge';

package/dist/modules/index.js

@@ -16,7 +16,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./authentication"), exports);
 __exportStar(require("./cache"), exports);
-__exportStar(require("./comment"), exports);
+__exportStar(require("./comments"), exports);
 __exportStar(require("./database"), exports);
 __exportStar(require("./like"), exports);
 __exportStar(require("./merge"), exports);

package/dist/modules/like/like-module-options.interface.d.ts

@@ -18,4 +18,5 @@ export type LikeModuleOptions = {
      * For example, setting this to "news" will expose routes like `/like/news/:id`.
      */
     routeSuffix: string;
+    version: string;
 };

package/dist/modules/like/like.controller.d.ts

@@ -1,3 +1,4 @@
+import { LikeModuleOptions } from './like-module-options.interface';
 import { LikeService } from './like.service';
 /**
  * Factory function for creating a LikeController bound to a specific route suffix.
@@ -6,10 +7,10 @@ import { LikeService } from './like.service';
  * we generate one dynamically. This ensures DRY principles while still
  * supporting custom routes (e.g. `/like/news` or `/like/event`).
  *
- * @param {string} [routeSuffix] - Suffix appended to the "like" route.
+ * @param {LikeModuleOptions} options -
  * @returns A dynamically generated controller class.
  */
-export declare function createLikeController(routeSuffix: string): {
+export declare function createLikeController(options: LikeModuleOptions): {
     new (likeService: LikeService): {
         readonly likeService: LikeService;
         /**

package/dist/modules/like/like.controller.js

@@ -26,12 +26,12 @@ const like_service_1 = require("./like.service");
  * we generate one dynamically. This ensures DRY principles while still
  * supporting custom routes (e.g. `/like/news` or `/like/event`).
  *
- * @param {string} [routeSuffix] - Suffix appended to the "like" route.
+ * @param {LikeModuleOptions} options -
  * @returns A dynamically generated controller class.
  */
-function createLikeController(routeSuffix) {
+function createLikeController(options) {
     // Normalize route path, removing duplicate/trailing slashes
-    const normalizedRoute = `like/${routeSuffix}`.replace(/\/{2,}/g, '/').replace(/\/$/, '');
+    const normalizedRoute = `like/${options.routeSuffix}`.replace(/\/{2,}/g, '/').replace(/\/$/, '');
     let LikeController = class LikeController {
         constructor(likeService) {
             this.likeService = likeService;
@@ -133,7 +133,7 @@ function createLikeController(routeSuffix) {
     LikeController = __decorate([
         (0, authentication_1.RequireJwtAuth)(),
         (0, swagger_1.ApiTags)('Like'),
-        (0, common_1.Controller)(normalizedRoute),
+        (0, common_1.Controller)({ path: normalizedRoute, version: options.version }),
         __metadata("design:paramtypes", [like_service_1.LikeService])
     ], LikeController);
     return LikeController;

package/dist/modules/like/like.module.js

@@ -30,7 +30,7 @@ let LikeModule = LikeModule_1 = class LikeModule {
      * @returns {DynamicModule} The dynamically created module definition.
      */
     static forFeature(options) {
-        const LikeController = (0, like_controller_1.createLikeController)(options.routeSuffix);
+        const LikeController = (0, like_controller_1.createLikeController)(options);
         return {
             module: LikeModule_1,
             providers: [like_service_1.LikeService, { provide: like_module_definition_1.LIKE_MODULE_OPTIONS_TOKEN, useValue: options }],

package/dist/modules/like/like.service.d.ts

@@ -22,19 +22,9 @@ export declare class LikeService {
      * @param {Connection} connection - Mongoose database connection.
      */
     constructor(moduleOptions: LikeModuleOptions, connection: Connection);
-    /**
-     * Safely retrieves the number of likes from a resource document.
-     *
-     * @param {Document & Likeable} [resource] - The resource document.
-     * @returns {number} Count of likes, or zero if not available.
-     */
-    private countLikes;
     /**
      * Adds a like from the specified account to a resource.
      *
-     * Why: `$addToSet` prevents duplicates, ensuring data integrity
-     * when users attempt to like a resource multiple times.
-     *
      * @param {string} resourceId - The resource’s ID.
      * @param {string} accountId - The account ID adding the like.
      * @returns {Promise<number>} The updated like count.
@@ -43,9 +33,6 @@ export declare class LikeService {
     /**
      * Removes a like from the specified account on a resource.
      *
-     * Why: `$pull` ensures the account is removed cleanly
-     * without affecting other users’ likes.
-     *
      * @param {string} resourceId - The resource’s ID.
      * @param {string} accountId - The account ID removing the like.
      * @returns {Promise<number>} The updated like count.
@@ -54,9 +41,6 @@ export declare class LikeService {
     /**
      * Verifies whether a given account has liked a resource.
      *
-     * Why: Checking directly with MongoDB avoids fetching the full document,
-     * making it efficient for large `_likedBy` arrays.
-     *
      * @param {string} resourceId - The resource ID.
      * @param {string} accountId - The account ID to check.
      * @returns {Promise<boolean>} True if the account has liked the resource.

package/dist/modules/like/like.service.js

@@ -42,63 +42,44 @@ let LikeService = LikeService_1 = class LikeService {
         const { name, schema } = this.moduleOptions.model;
         this.likeModel = this.connection.model(name, schema);
     }
-    /**
-     * Safely retrieves the number of likes from a resource document.
-     *
-     * @param {Document & Likeable} [resource] - The resource document.
-     * @returns {number} Count of likes, or zero if not available.
-     */
-    countLikes(resource) {
-        var _a, _b;
-        return (_b = (_a = resource === null || resource === void 0 ? void 0 : resource._likedBy) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
-    }
     /**
      * Adds a like from the specified account to a resource.
      *
-     * Why: `$addToSet` prevents duplicates, ensuring data integrity
-     * when users attempt to like a resource multiple times.
-     *
      * @param {string} resourceId - The resource’s ID.
      * @param {string} accountId - The account ID adding the like.
      * @returns {Promise<number>} The updated like count.
      */
     async addLike(resourceId, accountId) {
+        var _a;
         this.logger.debug(`Account ${accountId} liked ${this.likeModel.name.toLowerCase()} resource ${resourceId}`);
-        const updatedResource = await this.likeModel.findOneAndUpdate({ _id: resourceId }, { $addToSet: { _likedBy: accountId } }, { new: true, upsert: false, timestamps: false });
-        return this.countLikes(updatedResource);
+        const resource = await this.likeModel.findOne({ _id: resourceId });
+        return (_a = resource === null || resource === void 0 ? void 0 : resource.addLike(accountId)) !== null && _a !== void 0 ? _a : 0;
     }
     /**
      * Removes a like from the specified account on a resource.
      *
-     * Why: `$pull` ensures the account is removed cleanly
-     * without affecting other users’ likes.
-     *
      * @param {string} resourceId - The resource’s ID.
      * @param {string} accountId - The account ID removing the like.
      * @returns {Promise<number>} The updated like count.
      */
     async removeLike(resourceId, accountId) {
+        var _a;
         this.logger.debug(`Account ${accountId} unliked ${this.likeModel.name.toLowerCase()} resource ${resourceId}`);
-        const updatedResource = await this.likeModel.findOneAndUpdate({ _id: resourceId }, { $pull: { _likedBy: accountId } }, { new: true, upsert: false, timestamps: false });
-        return this.countLikes(updatedResource);
+        const resource = await this.likeModel.findOne({ _id: resourceId });
+        return (_a = resource === null || resource === void 0 ? void 0 : resource.removeLike(accountId)) !== null && _a !== void 0 ? _a : 0;
     }
     /**
      * Verifies whether a given account has liked a resource.
      *
-     * Why: Checking directly with MongoDB avoids fetching the full document,
-     * making it efficient for large `_likedBy` arrays.
-     *
      * @param {string} resourceId - The resource ID.
      * @param {string} accountId - The account ID to check.
      * @returns {Promise<boolean>} True if the account has liked the resource.
      */
     async hasLiked(resourceId, accountId) {
+        var _a;
         this.logger.log(`Checking like status for account ${accountId} on ${this.likeModel.name.toLowerCase()} resource ${resourceId}`);
-        const resource = await this.likeModel.findOne({
-            _id: resourceId,
-            _likedBy: { $in: [accountId] },
-        });
-        return !!resource;
+        const resource = await this.likeModel.findOne({ _id: resourceId });
+        return (_a = resource === null || resource === void 0 ? void 0 : resource.hasLiked(accountId)) !== null && _a !== void 0 ? _a : false;
     }
 };
 exports.LikeService = LikeService;

package/dist/modules/merge/merge-module-options.interface.d.ts

@@ -18,4 +18,5 @@ export interface MergeModuleOptions {
      * Defaults to just `/merge`.
      */
     routeSuffix?: string;
+    version: string;
 }

package/dist/modules/merge/merge.controller.d.ts

@@ -1,4 +1,5 @@
 import { InjectionToken } from '@nestjs/common';
+import { MergeModuleOptions } from './merge-module-options.interface';
 import { MergeModuleService } from './merge.service.interface';
 /**
  * Factory function for creating a MergeController bound to a specific route suffix.
@@ -8,10 +9,10 @@ import { MergeModuleService } from './merge.service.interface';
  * supporting custom routes (e.g. `/merge/news` or `/merge/event`).
  *
  * @param {InjectionToken} serviceToken - Token used for service injection.
- * @param {string} [routeSuffix] - Optional suffix appended to the "merge" route.
+ * @param {MergeModuleOptions} options -
  * @returns A dynamically generated controller class.
  */
-export declare function createMergeController(serviceToken: InjectionToken, routeSuffix?: string): {
+export declare function createMergeController(serviceToken: InjectionToken, options: MergeModuleOptions): {
     new (mergeService: MergeModuleService): {
         readonly mergeService: MergeModuleService;
         /**

package/dist/modules/merge/merge.controller.js

@@ -25,12 +25,12 @@ const authentication_1 = require("../authentication");
  * supporting custom routes (e.g. `/merge/news` or `/merge/event`).
  *
  * @param {InjectionToken} serviceToken - Token used for service injection.
- * @param {string} [routeSuffix] - Optional suffix appended to the "merge" route.
+ * @param {MergeModuleOptions} options -
  * @returns A dynamically generated controller class.
  */
-function createMergeController(serviceToken, routeSuffix) {
+function createMergeController(serviceToken, options) {
     // Normalize route path, removing duplicate/trailing slashes
-    const normalizedRoute = `merge/${routeSuffix || ''}`.replace(/\/{2,}/g, '/').replace(/\/$/, '');
+    const normalizedRoute = `merge/${options.routeSuffix || ''}`.replace(/\/{2,}/g, '/').replace(/\/$/, '');
     let MergeController = class MergeController {
         constructor(mergeService) {
             this.mergeService = mergeService;
@@ -68,7 +68,7 @@ function createMergeController(serviceToken, routeSuffix) {
     MergeController = __decorate([
         (0, authentication_1.RequireServiceAuth)(),
         (0, swagger_1.ApiTags)('Merge'),
-        (0, common_1.Controller)(normalizedRoute),
+        (0, common_1.Controller)({ path: normalizedRoute, version: options.version }),
         __param(0, (0, common_1.Inject)(serviceToken)),
         __metadata("design:paramtypes", [Object])
     ], MergeController);

package/dist/modules/merge/merge.module.js

@@ -26,7 +26,7 @@ let MergeModule = MergeModule_1 = class MergeModule {
      */
     static forFeature(options) {
         const serviceToken = Symbol('MERGE_MODULE_SERVICE_TOKEN');
-        const MergeController = (0, merge_controller_1.createMergeController)(serviceToken, options.routeSuffix);
+        const MergeController = (0, merge_controller_1.createMergeController)(serviceToken, options);
         return {
             module: MergeModule_1,
             imports: options.imports,

package/dist/modules/services/providers/accounts.service.js

@@ -55,6 +55,8 @@ let AccountsService = class AccountsService extends base_http_service_1.BaseHttp
      * @returns {Promise<Account[]>} Resolves to an array of account objects (empty if none found).
      */
     async getAccountCollection(accountIds) {
+        if (accountIds.length === 0)
+            return [];
         return this.fetchResourceCollection(`internal/accounts`, { params: { ids: accountIds } });
     }
     /**
@@ -73,6 +75,8 @@ let AccountsService = class AccountsService extends base_http_service_1.BaseHttp
      * @returns {Promise<User[]>} Resolves to a list of users (empty array if none found).
      */
     async getUserCollection(userIds) {
+        if (userIds.length === 0)
+            return [];
         return this.fetchResourceCollection(`internal/users`, { params: { ids: userIds } });
     }
 };

package/dist/modules/services/providers/index.d.ts

@@ -11,7 +11,6 @@ export * from './team.service';
 export * from './tech-radar.service';
 export * from './accounts.service';
 export * from './changelog.service';
-export * from './comments';
 export * from './mail';
 export * from './notification';
 export * from './search';

package/dist/modules/services/providers/index.js

@@ -27,7 +27,6 @@ __exportStar(require("./team.service"), exports);
 __exportStar(require("./tech-radar.service"), exports);
 __exportStar(require("./accounts.service"), exports);
 __exportStar(require("./changelog.service"), exports);
-__exportStar(require("./comments"), exports);
 __exportStar(require("./mail"), exports);
 __exportStar(require("./notification"), exports);
 __exportStar(require("./search"), exports);

package/dist/modules/services/services.module.js

@@ -26,7 +26,6 @@ const serviceProviders = [
     providers_1.LunchRouletteService,
     // Utils
     providers_1.AccountsService,
-    providers_1.CommentsService,
     providers_1.NotificationService,
     providers_1.MailService,
     providers_1.SearchService,

package/dist/pipes/index.d.ts

@@ -1,2 +1,3 @@
 export * from './params';
 export * from './queries';
+export * from './restricted-fields.pipe';

package/dist/pipes/index.js

@@ -16,3 +16,4 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./params"), exports);
 __exportStar(require("./queries"), exports);
+__exportStar(require("./restricted-fields.pipe"), exports);

package/dist/pipes/restricted-fields.pipe.d.ts

@@ -0,0 +1,35 @@
+import { ArgumentMetadata, PipeTransform } from '@nestjs/common';
+import { Reflector } from '@nestjs/core';
+import { Request } from 'express';
+import { Account } from '../models';
+import { AuthenticationModuleOptions } from '../modules';
+/**
+ * @Restricted Decorator
+ *
+ * Marks a DTO property as restricted to specific permissions.
+ * When a request passes through the global `RestrictedFieldsPipe`,
+ * these properties will be removed if the requesting account does not
+ * have all required permissions.
+ *
+ * @param {...string[]} perms - One or more permissions required to retain this field.
+ */
+export declare function Restricted(perms?: string | string[]): PropertyDecorator;
+/**
+ * RestrictedFieldsPipe
+ *
+ * Global pipe that inspects incoming DTOs for properties decorated with `@Restricted`.
+ * If the current request's account lacks the required permissions,
+ * the corresponding properties are stripped from the DTO.
+ *
+ * This ensures that sensitive fields are never accidentally
+ * processed further down the request lifecycle.
+ */
+export declare class RestrictedFieldsPipe implements PipeTransform {
+    private readonly request;
+    private readonly authenticationOptions;
+    private readonly reflector;
+    constructor(request: Request & {
+        account?: Account;
+    }, authenticationOptions: AuthenticationModuleOptions, reflector: Reflector);
+    transform(value: unknown, metadata: ArgumentMetadata): any;
+}