itlab-internal-services 2.15.7 → 2.16.0

package/dist/modules/authentication/guards/service-auth.guard.js

@@ -0,0 +1,65 @@
+"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.ServiceAuthGuard = exports.SERVICE_AUTH_HEADER_KEY = void 0;
+exports.isServiceRequest = isServiceRequest;
+exports.RequireServiceAuth = RequireServiceAuth;
+const common_1 = require("@nestjs/common");
+const core_1 = require("@nestjs/core");
+const swagger_1 = require("@nestjs/swagger");
+const authentication_options_parameter_1 = require("../authentication-options.parameter");
+const public_guard_1 = require("./public.guard");
+/** Header key used for internal Kubernetes service authentication */
+exports.SERVICE_AUTH_HEADER_KEY = 'X-itlab-k8s-auth';
+/**
+ * Guard validating service-to-service requests using a shared token.
+ */
+let ServiceAuthGuard = class ServiceAuthGuard {
+    constructor(authenticationOptions, reflector) {
+        this.authenticationOptions = authenticationOptions;
+        this.reflector = reflector;
+    }
+    canActivate(context) {
+        if ((0, public_guard_1.isPublicRoute)(context, this.reflector))
+            return true;
+        if (isServiceRequest(context, this.authenticationOptions.k8sToken))
+            return true;
+        throw new common_1.UnauthorizedException('Application unauthorized');
+    }
+};
+exports.ServiceAuthGuard = ServiceAuthGuard;
+exports.ServiceAuthGuard = ServiceAuthGuard = __decorate([
+    (0, common_1.Injectable)(),
+    __param(0, (0, authentication_options_parameter_1.InjectAuthenticationOptions)()),
+    __metadata("design:paramtypes", [Object, core_1.Reflector])
+], ServiceAuthGuard);
+/**
+ * Check if request contains the required internal service token.
+ */
+function isServiceRequest(context, requiredk8sToken) {
+    const request = context.switchToHttp().getRequest();
+    const token = request.header(exports.SERVICE_AUTH_HEADER_KEY);
+    return token && token === requiredk8sToken;
+}
+/**
+ * Decorator for routes/controllers accessible only by internal services.
+ */
+function RequireServiceAuth() {
+    return (0, common_1.applyDecorators)((0, common_1.UseGuards)(ServiceAuthGuard), (0, swagger_1.ApiTags)('Internal'), (0, swagger_1.ApiSecurity)('Service Token'), (0, swagger_1.ApiHeader)({
+        name: exports.SERVICE_AUTH_HEADER_KEY,
+        description: 'Token for service authentication',
+        allowEmptyValue: true,
+        required: true,
+    }), (0, swagger_1.ApiUnauthorizedResponse)({ description: 'Application unauthorized' }));
+}

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

@@ -1,4 +1,4 @@
+export * from './authentication-module-options.interface';
+export * from './authentication-options.parameter';
+export * from './authentication.module';
 export * from './guards';
-export { AuthenticationModuleOptions } from './authentication-module-options.interface';
-export { AuthenticationModule } from './authentication.module';
-export { InjectAuthOptions } from './inject-auth-options.decorator';

package/dist/modules/authentication/index.js

@@ -14,9 +14,7 @@ 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 });
-exports.InjectAuthOptions = exports.AuthenticationModule = void 0;
+__exportStar(require("./authentication-module-options.interface"), exports);
+__exportStar(require("./authentication-options.parameter"), exports);
+__exportStar(require("./authentication.module"), exports);
 __exportStar(require("./guards"), exports);
-var authentication_module_1 = require("./authentication.module");
-Object.defineProperty(exports, "AuthenticationModule", { enumerable: true, get: function () { return authentication_module_1.AuthenticationModule; } });
-var inject_auth_options_decorator_1 = require("./inject-auth-options.decorator");
-Object.defineProperty(exports, "InjectAuthOptions", { enumerable: true, get: function () { return inject_auth_options_decorator_1.InjectAuthOptions; } });

package/dist/modules/cache/cache-response.interceptor.d.ts

@@ -4,9 +4,9 @@
  * Custom decorator to enable response caching for a controller method using NestJS CacheInterceptor.
  * This improves performance by avoiding repeated execution for identical requests.
  *
- * If a TTL (Time-To-Live) is provided, the cached result will expire after the given duration (in seconds).
+ * If a TTL (Time-To-Live) is provided, the cached result will expire after the given duration (in milliseconds).
  *
- * @param {number} [ttl] - Optional time-to-live for the cached response in seconds.
+ * @param {number} [ttl] - Optional time-to-live for the cached response in milliseconds.
  * @returns {MethodDecorator} A method decorator that applies caching logic to the handler.
  */
 export declare function CacheResponse(ttl?: number): MethodDecorator;

package/dist/modules/cache/cache-response.interceptor.js

@@ -9,9 +9,9 @@ const common_1 = require("@nestjs/common");
  * Custom decorator to enable response caching for a controller method using NestJS CacheInterceptor.
  * This improves performance by avoiding repeated execution for identical requests.
  *
- * If a TTL (Time-To-Live) is provided, the cached result will expire after the given duration (in seconds).
+ * If a TTL (Time-To-Live) is provided, the cached result will expire after the given duration (in milliseconds).
  *
- * @param {number} [ttl] - Optional time-to-live for the cached response in seconds.
+ * @param {number} [ttl] - Optional time-to-live for the cached response in milliseconds.
  * @returns {MethodDecorator} A method decorator that applies caching logic to the handler.
  */
 function CacheResponse(ttl) {

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

@@ -1,3 +1,4 @@
+export * from './cache-module-options.interface';
 export * from './cache-response.interceptor';
 export * from './cache.module';
 export * from './cache.service';

package/dist/modules/cache/index.js

@@ -14,6 +14,7 @@ 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("./cache-module-options.interface"), exports);
 __exportStar(require("./cache-response.interceptor"), exports);
 __exportStar(require("./cache.module"), exports);
 __exportStar(require("./cache.service"), exports);

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

@@ -0,0 +1,38 @@
+import { ModelDefinition } from '@nestjs/mongoose';
+import { Document } from 'mongoose';
+import { HubResource } from '../../hub-resource.enum';
+/**
+ * Module options for configuring and dynamically registering the CommentModule.
+ *
+ * This allows developers to specify the resource model that supports "commenting"
+ * and optionally provide a custom route suffix. The modular design ensures
+ * consistent, reusable comment functionality across multiple resource types
+ * (e.g. News, Events, Demos).
+ */
+export type CommentModuleOptions<T extends Document> = {
+    /**
+     * The enum value identifying the resource type this comment module relates to.
+     * Used internally for routing and tagging.
+     */
+    resource: HubResource;
+    /**
+     * Mongoose model definition representing the resource type
+     * that can receive comments.
+     */
+    model: ModelDefinition;
+    /**
+     * Optional suffix used to customize the controller route.
+     * For example, setting this to "news" will expose routes comment `/comment/news/:id`.
+     */
+    routeSuffix?: string;
+    /**
+     * Field name on the resource document representing a single owner's ID.
+     * Enables access control and filtering of comments by ownership.
+     */
+    ownerIdField?: keyof Omit<T, keyof Document>;
+    /**
+     * Field name on the resource document representing multiple owner IDs.
+     * Useful for shared or collaborative resource ownership models.
+     */
+    ownerIdsField?: keyof Omit<T, keyof Document>;
+};

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

@@ -1,35 +1,29 @@
-import { LabContentRichtext } from 'itlab-functions';
-import { Comment } from './comment.model';
+import { LabCommentPopulated, LabContentRichtext } from 'itlab-functions';
 import { CommentService } from './comment.service';
 /**
- * @class CommentController
- * @description
- * Handles HTTP endpoints for adding comments to a resource.
- * Requires authenticated users and validates the resource ID using a MongoDB ObjectId format.
- * Delegates comment logic to CommentService.
+ * Factory function for creating a CommentController bound to a specific route suffix.
  *
- * Routes are mounted dynamically and scoped by module configuration (via CommentModule).
+ * Why: Instead of writing separate controllers for each resource type,
+ * we generate one dynamically. This ensures DRY principles while still
+ * supporting custom routes (e.g. `/comment/news` or `/comment/event`).
  *
- * Example route: POST /comment/posts/:resourceId
+ * @param {string} [routeSuffix] - Optional suffix appended to the "comment" route.
+ * @returns A dynamically generated controller class.
  */
-export declare class CommentController {
-    private readonly commentService;
-    /**
-     * Injects CommentService for handling comment logic.
-     *
-     * @param {CommentService} commentService - Service that handles comment creation and deletion logic
-     */
-    constructor(commentService: CommentService);
-    /**
-     * Adds a comment to a specific resource.
-     *
-     * This endpoint is authenticated. It verifies the resource exists (if a model is provided),
-     * and forwards the comment to the internal comments service with optional owner metadata.
-     *
-     * @param {string} resourceId - MongoDB ObjectId of the resource to comment on
-     * @param {string} accountId - Authenticated user ID from the JWT
-     * @param {LabContentRichtext} comment - The comment content (rich text format)
-     * @returns {Promise<Comment>} - The saved comment returned by the comment service
-     */
-    postComment(resourceId: string, accountId: string, comment: LabContentRichtext): Promise<Comment>;
-}
+export declare function createCommentController(routeSuffix?: string): {
+    new (commentService: CommentService): {
+        readonly commentService: CommentService;
+        /**
+         * Creates a new comment on a specific resource.
+         *
+         * Why: Centralizes comment creation logic in the service while ensuring
+         * authentication, resource validation, and proper rich text handling.
+         *
+         * @param {string} resourceId - MongoDB ObjectId of the resource being commented on.
+         * @param {string} accountId - Authenticated user's account ID.
+         * @param {LabContentRichtext} comment - Rich text content of the comment.
+         * @returns {Promise<LabCommentPopulated>} The saved comment object.
+         */
+        postComment(resourceId: string, accountId: string, comment: LabContentRichtext): Promise<LabCommentPopulated>;
+    };
+};

package/dist/modules/comment/comment.controller.js

@@ -12,75 +12,73 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CommentController = void 0;
+exports.createCommentController = createCommentController;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
 const decorators_1 = require("../../decorators");
 const exceptions_1 = require("../../exceptions");
 const pipes_1 = require("../../pipes");
 const authentication_1 = require("../authentication");
-const comment_model_1 = require("./comment.model");
 const comment_service_1 = require("./comment.service");
 /**
- * @class CommentController
- * @description
- * Handles HTTP endpoints for adding comments to a resource.
- * Requires authenticated users and validates the resource ID using a MongoDB ObjectId format.
- * Delegates comment logic to CommentService.
+ * Factory function for creating a CommentController bound to a specific route suffix.
  *
- * Routes are mounted dynamically and scoped by module configuration (via CommentModule).
+ * Why: Instead of writing separate controllers for each resource type,
+ * we generate one dynamically. This ensures DRY principles while still
+ * supporting custom routes (e.g. `/comment/news` or `/comment/event`).
  *
- * Example route: POST /comment/posts/:resourceId
+ * @param {string} [routeSuffix] - Optional suffix appended to the "comment" route.
+ * @returns A dynamically generated controller class.
  */
-let CommentController = class CommentController {
-    /**
-     * Injects CommentService for handling comment logic.
-     *
-     * @param {CommentService} commentService - Service that handles comment creation and deletion logic
-     */
-    constructor(commentService) {
-        this.commentService = commentService;
-    }
-    /**
-     * Adds a comment to a specific resource.
-     *
-     * This endpoint is authenticated. It verifies the resource exists (if a model is provided),
-     * and forwards the comment to the internal comments service with optional owner metadata.
-     *
-     * @param {string} resourceId - MongoDB ObjectId of the resource to comment on
-     * @param {string} accountId - Authenticated user ID from the JWT
-     * @param {LabContentRichtext} comment - The comment content (rich text format)
-     * @returns {Promise<Comment>} - The saved comment returned by the comment service
-     */
-    async postComment(resourceId, accountId, comment) {
-        return this.commentService.postComment(resourceId, accountId, comment);
-    }
-};
-exports.CommentController = CommentController;
-__decorate([
-    (0, swagger_1.ApiOperation)({
-        summary: 'Kommentar speichern',
-        description: 'Speichert ein Kommentar zur angegebenen Ressource.',
-    }),
-    (0, swagger_1.ApiOkResponse)({
-        description: 'Der erfolgreich gespeicherte Kommentar',
-        type: comment_model_1.Comment,
-    }),
-    (0, exceptions_1.ApiBadBodyResponse)('Validierung des Kommentars fehlgeschlagen'),
-    (0, swagger_1.ApiBody)({
-        description: 'Der Kommentar-Inhalt im Richtext-Format',
-    }),
-    (0, pipes_1.ApiMongoId)('resourceId'),
-    (0, common_1.Post)(':resourceId'),
-    __param(0, (0, pipes_1.MongoIdParam)('resourceId')),
-    __param(1, (0, decorators_1.Account)('id')),
-    __param(2, (0, common_1.Body)()),
-    __metadata("design:type", Function),
-    __metadata("design:paramtypes", [String, String, Object]),
-    __metadata("design:returntype", Promise)
-], CommentController.prototype, "postComment", null);
-exports.CommentController = CommentController = __decorate([
-    (0, authentication_1.RequireJwtAuth)(),
-    (0, common_1.Controller)(),
-    __metadata("design:paramtypes", [comment_service_1.CommentService])
-], CommentController);
+function createCommentController(routeSuffix) {
+    // Normalize route path, removing duplicate/trailing slashes
+    const normalizedRoute = `comment/${routeSuffix || ''}`.replace(/\/{2,}/g, '/').replace(/\/$/, '');
+    let CommentController = class CommentController {
+        constructor(commentService) {
+            this.commentService = commentService;
+        }
+        /**
+         * Creates a new comment on a specific resource.
+         *
+         * Why: Centralizes comment creation logic in the service while ensuring
+         * authentication, resource validation, and proper rich text handling.
+         *
+         * @param {string} resourceId - MongoDB ObjectId of the resource being commented on.
+         * @param {string} accountId - Authenticated user's account ID.
+         * @param {LabContentRichtext} comment - Rich text content of the comment.
+         * @returns {Promise<LabCommentPopulated>} The saved comment object.
+         */
+        async postComment(resourceId, accountId, comment) {
+            return this.commentService.postComment(resourceId, accountId, comment);
+        }
+    };
+    __decorate([
+        (0, swagger_1.ApiOperation)({
+            summary: 'Create a comment',
+            description: 'Adds a new comment to the specified resource. ' +
+                'The request is authenticated, and the comment is validated before saving. ' +
+                'Rich text content is supported.',
+        }),
+        (0, swagger_1.ApiOkResponse)({
+            description: 'The comment has been successfully saved.',
+        }),
+        (0, exceptions_1.ApiBadBodyResponse)('Invalid comment payload. Please check the content format.'),
+        (0, swagger_1.ApiNotFoundResponse)({ description: 'Resource not found. Cannot add comment to non-existent resource.' }),
+        (0, swagger_1.ApiBody)({ description: 'Comment content in rich text format.' }),
+        (0, pipes_1.ApiMongoIdParam)('resourceId'),
+        (0, common_1.Post)(':resourceId'),
+        __param(0, (0, pipes_1.MongoIdParam)('resourceId')),
+        __param(1, (0, decorators_1.AuthenticatedAccount)('id')),
+        __param(2, (0, common_1.Body)()),
+        __metadata("design:type", Function),
+        __metadata("design:paramtypes", [String, String, Object]),
+        __metadata("design:returntype", Promise)
+    ], CommentController.prototype, "postComment", null);
+    CommentController = __decorate([
+        (0, authentication_1.RequireJwtAuth)(),
+        (0, swagger_1.ApiTags)('Comment'),
+        (0, common_1.Controller)(normalizedRoute),
+        __metadata("design:paramtypes", [comment_service_1.CommentService])
+    ], CommentController);
+    return CommentController;
+}

package/dist/modules/comment/comment.module-definition.d.ts

@@ -1,45 +1,4 @@
-import { ModelDefinition } from '@nestjs/mongoose';
-import { Document } from 'mongoose';
-import { HubResource } from '../../hub-resource.enum';
 /**
- * Options for configuring a dynamically scoped CommentModule.
- *
- * This structure allows customization of routes, Swagger tags, and field-level ownership logic
- * for different resource types (e.g., posts, articles, media).
- *
- * @template T - The type of the resource document.
- */
-export type CommentModuleOptions<T extends Document = any> = {
-    /**
-     * The enum value identifying the resource type this comment module relates to.
-     * Used internally for routing and tagging.
-     */
-    resource: HubResource;
-    /**
-     * Optional array of path segments used to define the controller route and Swagger tag suffix.
-     * Enables modular comment endpoints for different resource domains.
-     *
-     * Example: ['posts', 'featured'] → route: /comment/posts/featured
-     */
-    routeScope?: string[];
-    /**
-     * Optional Mongoose model definition for the resource to which comments are attached.
-     * If not provided, the module will skip controller registration.
-     */
-    model?: ModelDefinition;
-    /**
-     * Field name on the resource document representing a single owner's ID.
-     * Enables access control and filtering of comments by ownership.
-     */
-    ownerIdField?: keyof Omit<T, keyof Document>;
-    /**
-     * Field name on the resource document representing multiple owner IDs.
-     * Useful for shared or collaborative resource ownership models.
-     */
-    ownerIdsField?: keyof Omit<T, keyof Document>;
-};
-/**
- * Token used to inject CommentModule options into services or controllers if needed.
- * Symbol is used to avoid accidental naming collisions across modules.
+ * Dependency injection token for CommentModule options.
  */
 export declare const COMMENT_MODULE_OPTIONS_TOKEN: unique symbol;

package/dist/modules/comment/comment.module-definition.js

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.COMMENT_MODULE_OPTIONS_TOKEN = void 0;
 /**
- * Token used to inject CommentModule options into services or controllers if needed.
- * Symbol is used to avoid accidental naming collisions across modules.
+ * Dependency injection token for CommentModule options.
  */
 exports.COMMENT_MODULE_OPTIONS_TOKEN = Symbol('COMMENT_MODULE_OPTIONS_TOKEN');

package/dist/modules/comment/comment.module.d.ts

@@ -1,22 +1,22 @@
 import { DynamicModule } from '@nestjs/common';
 import { Document } from 'mongoose';
-import { CommentModuleOptions } from './comment.module-definition';
+import { CommentModuleOptions } from './comment-module-options.interface';
 /**
- * @class CommentModule
- * @description
- * A dynamic NestJS module that registers a comment controller and service scoped
- * to a specific resource type, route, and ownership model.
+ * CommentModule dynamically registers controllers and services
+ * to handle "commenting" functionality for a given resource model.
+ *
+ * Why: Many resources (e.g. blogposts, events, demos) can be commented,
+ * but duplicating controller/service logic for each would be error-prone.
+ * Instead, this module centralizes the commenting-related logic, keeping it
+ * consistent while still allowing customization via options.
  */
 export declare class CommentModule {
     /**
-     * Registers a dynamically scoped comment controller based on the provided options.
+     * Dynamically registers a CommentController bound to the provided model
+     * and optional route suffix.
      *
-     * - Generates a custom route path and Swagger tag based on `routeScope`.
-     * - If no model is provided, no controller will be registered (service-only mode).
-     *
-     * @template T - The resource document type the comment module is tied to.
-     * @param options - Configuration values for routing, model binding, and ownership strategy.
-     * @returns A fully configured NestJS DynamicModule.
+     * @param {CommentModuleOptions} options - Configuration for the resource model and route.
+     * @returns {DynamicModule} The dynamically created module definition.
      */
-    static register<T extends Document = any>(options: CommentModuleOptions<T>): DynamicModule;
+    static forFeature<T extends Document>(options: CommentModuleOptions<T>): DynamicModule;
 }

package/dist/modules/comment/comment.module.js

@@ -9,63 +9,36 @@ var CommentModule_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommentModule = void 0;
 const common_1 = require("@nestjs/common");
-const swagger_1 = require("@nestjs/swagger");
-const itlab_functions_1 = require("itlab-functions");
 const comment_controller_1 = require("./comment.controller");
 const comment_module_definition_1 = require("./comment.module-definition");
 const comment_service_1 = require("./comment.service");
 /**
- * @class CommentModule
- * @description
- * A dynamic NestJS module that registers a comment controller and service scoped
- * to a specific resource type, route, and ownership model.
+ * CommentModule dynamically registers controllers and services
+ * to handle "commenting" functionality for a given resource model.
+ *
+ * Why: Many resources (e.g. blogposts, events, demos) can be commented,
+ * but duplicating controller/service logic for each would be error-prone.
+ * Instead, this module centralizes the commenting-related logic, keeping it
+ * consistent while still allowing customization via options.
  */
 let CommentModule = CommentModule_1 = class CommentModule {
     /**
-     * Registers a dynamically scoped comment controller based on the provided options.
+     * Dynamically registers a CommentController bound to the provided model
+     * and optional route suffix.
      *
-     * - Generates a custom route path and Swagger tag based on `routeScope`.
-     * - If no model is provided, no controller will be registered (service-only mode).
-     *
-     * @template T - The resource document type the comment module is tied to.
-     * @param options - Configuration values for routing, model binding, and ownership strategy.
-     * @returns A fully configured NestJS DynamicModule.
+     * @param {CommentModuleOptions} options - Configuration for the resource model and route.
+     * @returns {DynamicModule} The dynamically created module definition.
      */
-    static register(options) {
-        const controllers = [];
-        if (options.model) {
-            const { routeScope = [] } = options;
-            // Transform suffixes into a readable Swagger tag (e.g., "Comment Module - Posts")
-            const swaggerTag = ['Comment Module', ...routeScope.map((scope) => (0, itlab_functions_1.capitalize)(scope))].join(' -');
-            // Build the controller route path (e.g., "/comment/posts")
-            const controllerRoutePath = ['comment', ...routeScope].join('/');
-            /**
-             * A dynamically scoped CommentController for a specific resource.
-             *
-             * This controller uses a generated route path and custom Swagger tag,
-             * but otherwise inherits all base CommentController behavior.
-             */
-            let CommentController = class CommentController extends comment_controller_1.CommentController {
-            };
-            CommentController = __decorate([
-                (0, swagger_1.ApiTags)(swaggerTag),
-                (0, common_1.Controller)(controllerRoutePath)
-            ], CommentController);
-            controllers.push(CommentController);
-        }
+    static forFeature(options) {
+        const CommentController = (0, comment_controller_1.createCommentController)(options.routeSuffix);
         return {
             module: CommentModule_1,
-            controllers: controllers,
             providers: [comment_service_1.CommentService, { provide: comment_module_definition_1.COMMENT_MODULE_OPTIONS_TOKEN, useValue: options }],
-            exports: [comment_service_1.CommentService],
+            controllers: [CommentController],
         };
     }
 };
 exports.CommentModule = CommentModule;
 exports.CommentModule = CommentModule = CommentModule_1 = __decorate([
-    (0, common_1.Module)({
-        controllers: [comment_controller_1.CommentController],
-        providers: [comment_service_1.CommentService],
-        exports: [comment_service_1.CommentService],
-    })
+    (0, common_1.Module)({})
 ], CommentModule);

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

@@ -1,54 +1,44 @@
 import { ConfigService } from '@nestjs/config';
-import { LabContentRichtext } from 'itlab-functions';
+import { LabCommentPopulated, LabContentRichtext } from 'itlab-functions';
 import { Connection } from 'mongoose';
 import { AuthenticationModuleOptions } from '../authentication';
-import { Comment } from './comment.model';
-import { CommentModuleOptions } from './comment.module-definition';
+import { BaseHttpService } from '../services/base-http.service';
+import { CommentModuleOptions } from './comment-module-options.interface';
 /**
- * @class CommentService
- * @description
- * Handles business logic for posting and deleting comments associated with a resource.
- * Integrates with external/internal comment services and supports resource ownership validation.
+ * CommentService 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 {
+export declare class CommentService extends BaseHttpService {
     private readonly moduleOptions;
     private readonly connection;
-    private readonly authOptions;
-    private readonly configService;
-    private readonly logger;
-    private readonly axiosInstance;
-    private readonly resource;
     private readonly commentModel;
     /**
-     * Initializes the CommentService with injected dependencies and constructs
-     * an axios client for internal comment service communication.
+     * Constructs the CommentService with a configured model instance.
      *
-     * @param moduleOptions - Configuration for comment handling (resource, model, ownership fields)
-     * @param connection - Optional Mongoose connection for fetching resource documents
-     * @param authOptions - Auth options including Kubernetes token for service calls
-     * @param configService - Global config service for environment settings
-     */
-    constructor(moduleOptions: CommentModuleOptions, connection: Connection | undefined, authOptions: AuthenticationModuleOptions, configService: ConfigService);
-    /**
-     * Posts a comment to a given resource, with optional ownership metadata attached.
-     *
-     * - Validates that the resource exists if a model is defined.
-     * - Looks up `ownerId` or `ownerIds` for authorization use by downstream services.
+     * Why: Using the provided Mongoose connection and model options ensures
+     * that comments are tied to the correct resource collection dynamically.
      *
-     * @param {string} resourceId - ID of the resource being commented on
-     * @param {string} accountId - ID of the user posting the comment
-     * @param {LabContentRichtext} comment - Comment content in rich-text format
-     * @returns {Promise<Comment>} - Resolves with the saved comment or throws an HTTP exception
+     * @param {CommentModuleOptions} moduleOptions - Config for the commentable resource model.
+     * @param {Connection} connection - Mongoose database connection.
      */
-    postComment(resourceId: string, accountId: string, comment: LabContentRichtext): Promise<Comment>;
+    constructor(moduleOptions: CommentModuleOptions<any>, connection: Connection, authenticationOptions: AuthenticationModuleOptions, configService: ConfigService);
     /**
-     * Deletes all comments associated with the specified resource.
+     * Posts a comment to a given resource, optionally attaching ownership metadata.
      *
-     * - Primarily used for cleanup during resource deletion.
-     * - Logs success or failure, but does not throw exceptions on error.
+     * 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 - ID of the resource whose comments should be deleted
-     * @returns {void}
+     * @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<LabCommentPopulated>} 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.
      */
-    delete(resourceId: string): void;
+    postComment(resourceId: string, accountId: string, richtext: LabContentRichtext): Promise<LabCommentPopulated>;
 }