itlab-internal-services 2.15.7 → 2.16.1

package/dist/classes/task-manager.class.js

@@ -0,0 +1,99 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskManager = void 0;
+/**
+ * TaskManager is a utility class that collects asynchronous tasks
+ * and executes them in parallel.
+ *
+ * This is especially useful for orchestrating optional async operations
+ * where not all tasks need to be executed every time.
+ *
+ * Example:
+ * ```ts
+ * const taskManager = new TaskManager();
+ * taskManager.add(async () => { ... });
+ * taskManager.add(async () => { ... });
+ * await taskManager.run();
+ * ```
+ */
+class TaskManager {
+    constructor() {
+        this.tasks = [];
+    }
+    /**
+     * Fetches all users for the given ID groups and returns a mapping.
+     * Ensures each user is fetched only once.
+     * @param userIdGroups Array of arrays of user IDs (e.g., authors, likedBy, viewedBy)
+     * @param accountsService Service responsible for fetching users
+     * @returns Map of userId -> user
+     */
+    static async fetchAndMapUsers(userIdGroups, accountsService) {
+        // Collect all unique user IDs across all groups
+        const uniqueUserIds = new Set(userIdGroups.flat());
+        // Fetch all users once
+        const userCollection = await accountsService.getUserCollection(Array.from(uniqueUserIds));
+        // Build a map for quick lookup
+        return new Map(userCollection.map((user) => [user.id, user]));
+    }
+    /**
+     * Fetches all users for the given ID groups and returns a mapping.
+     * Ensures each user is fetched only once.
+     * @param accountIdGroups Array of arrays of user IDs (e.g., authors, likedBy, viewedBy)
+     * @param accountsService Service responsible for fetching users
+     * @returns Map of userId -> user
+     */
+    static async fetchAndMapAccounts(accountIdGroups, accountsService) {
+        // Collect all unique user IDs across all groups
+        const uniqueAccountIds = new Set(accountIdGroups.flat());
+        // Fetch all users once
+        const accountCollection = await accountsService.getAccountCollection(Array.from(uniqueAccountIds));
+        // Build a map for quick lookup
+        return new Map(accountCollection.map((account) => [account.id, account]));
+    }
+    /**
+     * Maps an array of IDs to user objects using a userMap.
+     * Filters out any IDs that don’t have a corresponding user.
+     * @param userIds Array of user IDs to map
+     * @param userMap Map of userId -> user object
+     * @returns Array of user objects
+     */
+    static mapIdsToUsers(userIds, userMap) {
+        return userIds.map((userId) => userMap.get(userId)).filter(Boolean);
+    }
+    /**
+     * Maps an array of IDs to user objects using a userMap.
+     * Filters out any IDs that don’t have a corresponding user.
+     * @param accountIds Array of user IDs to map
+     * @param accountMap Map of userId -> user object
+     * @returns Array of user objects
+     */
+    static mapIdsToAccounts(accountIds, accountMap) {
+        return accountIds.map((accountId) => accountMap.get(accountId)).filter(Boolean);
+    }
+    /**
+     * Adds a new asynchronous task to the queue.
+     *
+     * @param task - A function that returns a Promise.
+     *               It should contain the actual async logic to be executed.
+     */
+    add(task) {
+        this.tasks.push(task);
+    }
+    /**
+     * Executes all queued tasks in parallel and waits for their completion.
+     *
+     * - Tasks are executed concurrently using `Promise.all`.
+     * - If one task fails, the error will propagate and stop execution.
+     */
+    async run() {
+        await Promise.all(this.tasks.map((task) => task()));
+    }
+    /**
+     * Clears all tasks from the queue without executing them.
+     * Useful if you want to reset and reuse the TaskManager instance.
+     */
+    clear() {
+        this.tasks = [];
+    }
+}
+exports.TaskManager = TaskManager;

package/dist/decorators/{account.decorator.d.ts → authenticated-account.decorator.d.ts}

@@ -1,4 +1,4 @@
-import { AccountEntity } from '../models';
+import { Account } from '../models';
 /**
  * Custom parameter decorator to extract the authenticated user's account
  * or a specific attribute from it within route handlers.
@@ -10,8 +10,8 @@ import { AccountEntity } from '../models';
  * If no user account is found on the request, it throws an UnprocessableEntityException,
  * signaling that the request is missing necessary authentication context.
  *
- * @param {keyof AccountEntity} [attribute] - Optional key of the AccountEntity to extract.
+ * @param {keyof Account} [attribute] - Optional key of the Account to extract.
  * @param {ExecutionContext} executionContext - The context of the current request.
- * @returns {AccountEntity[keyof AccountEntity] | AccountEntity} The requested account attribute or full account object.
+ * @returns {Account[keyof Account] | Account} The requested account attribute or full account object.
  */
-export declare const Account: (...dataOrPipes: (keyof AccountEntity | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const AuthenticatedAccount: (...dataOrPipes: (keyof Account | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;

package/dist/decorators/{account.decorator.js → authenticated-account.decorator.js}

@@ -1,7 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Account = void 0;
+exports.AuthenticatedAccount = void 0;
 const common_1 = require("@nestjs/common");
+const exceptions_1 = require("../exceptions");
 /**
  * Custom parameter decorator to extract the authenticated user's account
  * or a specific attribute from it within route handlers.
@@ -13,16 +14,13 @@ const common_1 = require("@nestjs/common");
  * If no user account is found on the request, it throws an UnprocessableEntityException,
  * signaling that the request is missing necessary authentication context.
  *
- * @param {keyof AccountEntity} [attribute] - Optional key of the AccountEntity to extract.
+ * @param {keyof Account} [attribute] - Optional key of the Account to extract.
  * @param {ExecutionContext} executionContext - The context of the current request.
- * @returns {AccountEntity[keyof AccountEntity] | AccountEntity} The requested account attribute or full account object.
+ * @returns {Account[keyof Account] | Account} The requested account attribute or full account object.
  */
-exports.Account = (0, common_1.createParamDecorator)((attribute, executionContext) => {
+exports.AuthenticatedAccount = (0, common_1.createParamDecorator)((attribute, executionContext) => {
     const request = executionContext.switchToHttp().getRequest();
-    const userAccount = request.user;
-    if (!userAccount) {
-        throw new common_1.UnprocessableEntityException('Authenticated user context is missing in the request.');
-    }
-    // Return the requested attribute if specified; otherwise, return the entire account object.
-    return attribute ? userAccount[attribute] : userAccount;
+    if (!request.account)
+        throw new exceptions_1.AuthenticatedAccountRequiredException();
+    return attribute ? request.account[attribute] : request.account;
 });

package/dist/decorators/index.d.ts

@@ -1,2 +1,2 @@
-export * from './account.decorator';
+export * from './authenticated-account.decorator';
 export * from './jwt.decorator';

package/dist/decorators/index.js

@@ -14,5 +14,5 @@ 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("./account.decorator"), exports);
+__exportStar(require("./authenticated-account.decorator"), exports);
 __exportStar(require("./jwt.decorator"), exports);

package/dist/exceptions/authenticated-user-required.exception.d.ts

@@ -0,0 +1,34 @@
+import { ForbiddenException } from '@nestjs/common';
+/**
+ * AuthenticatedAccountRequiredException
+ *
+ * Custom exception extending NestJS's `ForbiddenException`.
+ * This should be thrown when a request is made to an endpoint that
+ * explicitly requires a Bearer Token for authentication.
+ *
+ * By centralizing the exception here, we ensure consistent error
+ * messaging and simplify future changes (e.g., localization or
+ * error structure updates).
+ */
+export declare class AuthenticatedAccountRequiredException extends ForbiddenException {
+    /**
+     * Creates a new `AuthenticatedAccountRequiredException`.
+     *
+     * @param {string} [message] - Optional custom error message.
+     * Defaults to a standard message if none is provided.
+     */
+    constructor(message?: string);
+}
+/**
+ * ApiAuthenticatedAccountRequiredResponse
+ *
+ * Swagger documentation decorator for endpoints that return a `403 Forbidden`
+ * when accessed without authentication. Applying this makes the generated
+ * API docs clear about the requirement for a Bearer Token and communicates
+ * the error condition to consumers.
+ *
+ * @param {string} [description] - Optional custom description for the response.
+ * Defaults to the standard authentication error message.
+ * @returns {MethodDecorator} - Swagger decorator marking a 403 forbidden response.
+ */
+export declare function ApiAuthenticatedAccountRequiredResponse(description?: string): MethodDecorator;

package/dist/exceptions/authenticated-user-required.exception.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AuthenticatedAccountRequiredException = void 0;
+exports.ApiAuthenticatedAccountRequiredResponse = ApiAuthenticatedAccountRequiredResponse;
+const common_1 = require("@nestjs/common");
+const swagger_1 = require("@nestjs/swagger");
+/**
+ * Default error message used when an endpoint is accessed without authentication.
+ * This provides a consistent and descriptive response to unauthorized users.
+ */
+const defaultAuthenticatedAccountRequiredErrorMessage = 'Authenticated user context is missing in the request.';
+/**
+ * AuthenticatedAccountRequiredException
+ *
+ * Custom exception extending NestJS's `ForbiddenException`.
+ * This should be thrown when a request is made to an endpoint that
+ * explicitly requires a Bearer Token for authentication.
+ *
+ * By centralizing the exception here, we ensure consistent error
+ * messaging and simplify future changes (e.g., localization or
+ * error structure updates).
+ */
+class AuthenticatedAccountRequiredException extends common_1.ForbiddenException {
+    /**
+     * Creates a new `AuthenticatedAccountRequiredException`.
+     *
+     * @param {string} [message] - Optional custom error message.
+     * Defaults to a standard message if none is provided.
+     */
+    constructor(message) {
+        super(message || defaultAuthenticatedAccountRequiredErrorMessage);
+    }
+}
+exports.AuthenticatedAccountRequiredException = AuthenticatedAccountRequiredException;
+/**
+ * ApiAuthenticatedAccountRequiredResponse
+ *
+ * Swagger documentation decorator for endpoints that return a `403 Forbidden`
+ * when accessed without authentication. Applying this makes the generated
+ * API docs clear about the requirement for a Bearer Token and communicates
+ * the error condition to consumers.
+ *
+ * @param {string} [description] - Optional custom description for the response.
+ * Defaults to the standard authentication error message.
+ * @returns {MethodDecorator} - Swagger decorator marking a 403 forbidden response.
+ */
+function ApiAuthenticatedAccountRequiredResponse(description) {
+    return (0, swagger_1.ApiForbiddenResponse)({
+        description: description || defaultAuthenticatedAccountRequiredErrorMessage,
+    });
+}

package/dist/exceptions/bad-body.exception.d.ts

@@ -2,26 +2,37 @@ import { UnprocessableEntityException } from '@nestjs/common';
 /**
  * BadBodyException
  *
- * Thrown when an incoming request body is invalid or malformed.
- * Typical use cases include missing required fields, incorrect data types,
- * or values that violate schema or business validation rules.
+ * Custom exception extending NestJS's `UnprocessableEntityException`.
+ * This exception should be thrown when the request body fails validation
+ * or cannot be interpreted correctly by the server.
  *
- * Returns a standardized HTTP 422 Unprocessable Entity error.
+ * Typical scenarios include:
+ * - Missing required fields
+ * - Incorrect or unexpected data types
+ * - Values violating schema constraints or business rules
+ *
+ * By encapsulating this exception, we provide a clear and consistent
+ * mechanism for handling client input errors across the application.
  */
 export declare class BadBodyException extends UnprocessableEntityException {
     /**
-     * Creates a new BadBodyException with an optional custom message.
+     * Constructs a new `BadBodyException`.
      *
-     * @param {string} [message] - Optional error message describing the specific validation issue.
+     * @param {string} [message] - Optional custom error message for additional context.
+     * Defaults to a standardized message if not provided.
      */
     constructor(message?: string);
 }
 /**
  * ApiBadBodyResponse
  *
- * Swagger decorator for documenting 422 Unprocessable Entity responses due to invalid request bodies.
+ * Swagger documentation decorator for `422 Unprocessable Entity` responses.
+ * Apply this to routes that may reject invalid or malformed request bodies.
+ * This ensures the generated API documentation communicates the validation
+ * expectations and error conditions to API consumers.
  *
  * @param {string} [description] - Optional custom description for the response.
- * @returns {MethodDecorator} Swagger method decorator.
+ * Defaults to a standardized message if not provided.
+ * @returns {MethodDecorator} - Swagger method decorator marking the response.
  */
 export declare function ApiBadBodyResponse(description?: string): MethodDecorator;

package/dist/exceptions/bad-body.exception.js

@@ -4,36 +4,52 @@ exports.BadBodyException = void 0;
 exports.ApiBadBodyResponse = ApiBadBodyResponse;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
+/**
+ * Default error message returned when the request body cannot be processed.
+ * This ensures consistency across thrown exceptions and documented responses.
+ */
+const defaultBadBodyErrorMessage = 'The request body is invalid or malformed.';
 /**
  * BadBodyException
  *
- * Thrown when an incoming request body is invalid or malformed.
- * Typical use cases include missing required fields, incorrect data types,
- * or values that violate schema or business validation rules.
+ * Custom exception extending NestJS's `UnprocessableEntityException`.
+ * This exception should be thrown when the request body fails validation
+ * or cannot be interpreted correctly by the server.
+ *
+ * Typical scenarios include:
+ * - Missing required fields
+ * - Incorrect or unexpected data types
+ * - Values violating schema constraints or business rules
  *
- * Returns a standardized HTTP 422 Unprocessable Entity error.
+ * By encapsulating this exception, we provide a clear and consistent
+ * mechanism for handling client input errors across the application.
  */
 class BadBodyException extends common_1.UnprocessableEntityException {
     /**
-     * Creates a new BadBodyException with an optional custom message.
+     * Constructs a new `BadBodyException`.
      *
-     * @param {string} [message] - Optional error message describing the specific validation issue.
+     * @param {string} [message] - Optional custom error message for additional context.
+     * Defaults to a standardized message if not provided.
      */
     constructor(message) {
-        super(message || 'The request body is invalid or malformed.');
+        super(message || defaultBadBodyErrorMessage);
     }
 }
 exports.BadBodyException = BadBodyException;
 /**
  * ApiBadBodyResponse
  *
- * Swagger decorator for documenting 422 Unprocessable Entity responses due to invalid request bodies.
+ * Swagger documentation decorator for `422 Unprocessable Entity` responses.
+ * Apply this to routes that may reject invalid or malformed request bodies.
+ * This ensures the generated API documentation communicates the validation
+ * expectations and error conditions to API consumers.
  *
  * @param {string} [description] - Optional custom description for the response.
- * @returns {MethodDecorator} Swagger method decorator.
+ * Defaults to a standardized message if not provided.
+ * @returns {MethodDecorator} - Swagger method decorator marking the response.
  */
 function ApiBadBodyResponse(description) {
     return (0, swagger_1.ApiUnprocessableEntityResponse)({
-        description: description || 'The request body is invalid or malformed.',
+        description: description || defaultBadBodyErrorMessage,
     });
 }

package/dist/exceptions/bad-parameter.exception.d.ts

@@ -2,25 +2,40 @@ import { BadRequestException } from '@nestjs/common';
 /**
  * BadParameterException
  *
- * Thrown when one or more parameters (query, route, or body) are invalid.
- * Useful for early input validation or handling malformed inputs.
+ * Custom exception extending NestJS's `BadRequestException`.
+ * This exception is thrown when one or more request parameters (query,
+ * route, or body) are invalid or malformed.
  *
- * Returns a standardized HTTP 400 Bad Request error.
+ * Common scenarios:
+ * - Query string contains unexpected or invalid values
+ * - Route parameters fail validation
+ * - Request body includes fields that do not conform to expected types
+ *
+ * By encapsulating this exception, we standardize error responses for
+ * invalid parameters and provide consistent error messaging across the API.
  */
 export declare class BadParameterException extends BadRequestException {
     /**
-     * Constructs a BadParameterException with optional parameter name.
+     * Constructs a new `BadParameterException`.
      *
-     * @param {string} [parameter] - Name of the invalid parameter (optional).
+     * @param {string} [parameter] - Optional name of the invalid parameter.
+     * If provided, the message will reference that parameter directly.
      */
     constructor(parameter?: string);
 }
 /**
  * ApiBadParameterResponse
  *
- * Swagger decorator for documenting 400 Bad Request responses due to parameter issues.
+ * Swagger documentation decorator for `400 Bad Request` responses caused
+ * by invalid request parameters. This makes it explicit in API docs that
+ * certain routes may reject requests with malformed or unsupported input.
+ *
+ * The decorator dynamically adjusts the description based on the provided
+ * parameter names, making documentation precise and self-explanatory.
  *
- * @param {string[]} params - One or more invalid parameters to include in the description.
- * @returns {MethodDecorator} Swagger method decorator.
+ * @param {...string} params - One or more invalid parameter names to
+ * include in the response description. If none are provided, a generic
+ * description is used instead.
+ * @returns {MethodDecorator} - Swagger method decorator for a 400 response.
  */
 export declare function ApiBadParameterResponse(...params: string[]): MethodDecorator;

package/dist/exceptions/bad-parameter.exception.js

@@ -8,38 +8,61 @@ const itlab_functions_1 = require("itlab-functions");
 /**
  * BadParameterException
  *
- * Thrown when one or more parameters (query, route, or body) are invalid.
- * Useful for early input validation or handling malformed inputs.
+ * Custom exception extending NestJS's `BadRequestException`.
+ * This exception is thrown when one or more request parameters (query,
+ * route, or body) are invalid or malformed.
  *
- * Returns a standardized HTTP 400 Bad Request error.
+ * Common scenarios:
+ * - Query string contains unexpected or invalid values
+ * - Route parameters fail validation
+ * - Request body includes fields that do not conform to expected types
+ *
+ * By encapsulating this exception, we standardize error responses for
+ * invalid parameters and provide consistent error messaging across the API.
  */
 class BadParameterException extends common_1.BadRequestException {
     /**
-     * Constructs a BadParameterException with optional parameter name.
+     * Constructs a new `BadParameterException`.
      *
-     * @param {string} [parameter] - Name of the invalid parameter (optional).
+     * @param {string} [parameter] - Optional name of the invalid parameter.
+     * If provided, the message will reference that parameter directly.
      */
     constructor(parameter) {
-        super(parameter ? `Invalid parameter: ${parameter}` : 'One or more parameters are invalid.');
+        super(parameter ? `Invalid parameter: ${parameter}` : 'One or more request parameters are invalid.');
     }
 }
 exports.BadParameterException = BadParameterException;
 /**
  * ApiBadParameterResponse
  *
- * Swagger decorator for documenting 400 Bad Request responses due to parameter issues.
+ * Swagger documentation decorator for `400 Bad Request` responses caused
+ * by invalid request parameters. This makes it explicit in API docs that
+ * certain routes may reject requests with malformed or unsupported input.
+ *
+ * The decorator dynamically adjusts the description based on the provided
+ * parameter names, making documentation precise and self-explanatory.
  *
- * @param {string[]} params - One or more invalid parameters to include in the description.
- * @returns {MethodDecorator} Swagger method decorator.
+ * @param {...string} params - One or more invalid parameter names to
+ * include in the response description. If none are provided, a generic
+ * description is used instead.
+ * @returns {MethodDecorator} - Swagger method decorator for a 400 response.
  */
 function ApiBadParameterResponse(...params) {
-    let description = 'Invalid parameter';
-    if (params.length > 0) {
-        description += params.length > 1 ? 's' : '';
-        description += `: ${(0, itlab_functions_1.formatList)(params)}`;
-    }
-    else {
-        description = 'One or more parameters are invalid.';
-    }
-    return (0, swagger_1.ApiBadRequestResponse)({ description });
+    const decorator = (target, propertyKey, descriptor) => {
+        var _a, _b;
+        // Extract existing Swagger metadata for this method (if any).
+        const existingResponses = Reflect.getMetadata('swagger/apiResponse', (descriptor === null || descriptor === void 0 ? void 0 : descriptor.value) || target) || {};
+        // Collect any already-registered bad request description.
+        const existingDescription = (_b = (_a = existingResponses === null || existingResponses === void 0 ? void 0 : existingResponses[400]) === null || _a === void 0 ? void 0 : _a.description) !== null && _b !== void 0 ? _b : '';
+        // Format description with proper pluralization.
+        const pluralized = params.length > 1 ? 's' : '';
+        const newDescription = params.length
+            ? `Invalid parameter${pluralized}: ${(0, itlab_functions_1.formatList)(params, 'or')}`
+            : 'One or more request parameters are invalid.';
+        // Merge with existing description if needed.
+        const mergedDescription = existingDescription ? `${existingDescription}<br />${newDescription}` : newDescription;
+        // Apply merged Swagger metadata.
+        (0, swagger_1.ApiBadRequestResponse)({ description: mergedDescription })(target, propertyKey, descriptor);
+    };
+    return decorator;
 }

package/dist/exceptions/duplicate.exception.d.ts

@@ -2,25 +2,37 @@ import { ConflictException } from '@nestjs/common';
 /**
  * DuplicateException
  *
- * Thrown when an attempt is made to create or register an entity that already exists.
- * Common use cases include duplicate usernames, emails, or unique constraints.
+ * Custom exception extending NestJS's `ConflictException`.
+ * This should be thrown when an operation attempts to create or register
+ * an entity that violates a uniqueness constraint or already exists in the system.
  *
- * Returns a standardized HTTP 409 Conflict response.
+ * Typical scenarios include:
+ * - Attempting to register a username or email already in use
+ * - Inserting database records that violate unique constraints
+ * - Uploading or creating resources with duplicate identifiers
+ *
+ * Returning a standardized `409 Conflict` response helps API consumers
+ * distinguish duplication errors from other kinds of client-side mistakes.
  */
 export declare class DuplicateException extends ConflictException {
     /**
-     * Constructs a DuplicateException with optional custom message.
+     * Creates a new `DuplicateException`.
      *
-     * @param {string} [message] - Optional message explaining what entity is duplicated.
+     * @param {string} [message] - Optional custom error message describing
+     * the specific duplication issue. Defaults to a standardized message if omitted.
      */
     constructor(message?: string);
 }
 /**
  * ApiDuplicateResponse
  *
- * Swagger decorator for documenting 409 Conflict responses caused by duplicate entities.
+ * Swagger documentation decorator for `409 Conflict` responses caused
+ * by duplicate resource creation attempts. Applying this decorator
+ * ensures that the generated API docs communicate uniqueness constraints
+ * and possible error conditions clearly to consumers.
  *
- * @param {string} [description] - Optional description for the conflict error.
- * @returns {MethodDecorator} Swagger method decorator.
+ * @param {string} [description] - Optional custom description of the duplication error.
+ * Defaults to a standardized message if omitted.
+ * @returns {MethodDecorator} - Swagger method decorator for documenting conflict responses.
  */
 export declare function ApiDuplicateResponse(description?: string): MethodDecorator;

package/dist/exceptions/duplicate.exception.js

@@ -4,35 +4,52 @@ exports.DuplicateException = void 0;
 exports.ApiDuplicateResponse = ApiDuplicateResponse;
 const common_1 = require("@nestjs/common");
 const swagger_1 = require("@nestjs/swagger");
+/**
+ * Default error message used when a duplicate resource is encountered.
+ * This ensures consistent error responses and simplifies reuse across the app.
+ */
+const defaultDuplicateResourceMessage = 'A resource with the same value already exists.';
 /**
  * DuplicateException
  *
- * Thrown when an attempt is made to create or register an entity that already exists.
- * Common use cases include duplicate usernames, emails, or unique constraints.
+ * Custom exception extending NestJS's `ConflictException`.
+ * This should be thrown when an operation attempts to create or register
+ * an entity that violates a uniqueness constraint or already exists in the system.
+ *
+ * Typical scenarios include:
+ * - Attempting to register a username or email already in use
+ * - Inserting database records that violate unique constraints
+ * - Uploading or creating resources with duplicate identifiers
  *
- * Returns a standardized HTTP 409 Conflict response.
+ * Returning a standardized `409 Conflict` response helps API consumers
+ * distinguish duplication errors from other kinds of client-side mistakes.
  */
 class DuplicateException extends common_1.ConflictException {
     /**
-     * Constructs a DuplicateException with optional custom message.
+     * Creates a new `DuplicateException`.
      *
-     * @param {string} [message] - Optional message explaining what entity is duplicated.
+     * @param {string} [message] - Optional custom error message describing
+     * the specific duplication issue. Defaults to a standardized message if omitted.
      */
     constructor(message) {
-        super(message || 'A record with the same value already exists.');
+        super(message || defaultDuplicateResourceMessage);
     }
 }
 exports.DuplicateException = DuplicateException;
 /**
  * ApiDuplicateResponse
  *
- * Swagger decorator for documenting 409 Conflict responses caused by duplicate entities.
+ * Swagger documentation decorator for `409 Conflict` responses caused
+ * by duplicate resource creation attempts. Applying this decorator
+ * ensures that the generated API docs communicate uniqueness constraints
+ * and possible error conditions clearly to consumers.
  *
- * @param {string} [description] - Optional description for the conflict error.
- * @returns {MethodDecorator} Swagger method decorator.
+ * @param {string} [description] - Optional custom description of the duplication error.
+ * Defaults to a standardized message if omitted.
+ * @returns {MethodDecorator} - Swagger method decorator for documenting conflict responses.
  */
 function ApiDuplicateResponse(description) {
     return (0, swagger_1.ApiConflictResponse)({
-        description: description || 'A record with the same value already exists.',
+        description: description || defaultDuplicateResourceMessage,
     });
 }

package/dist/exceptions/index.d.ts

@@ -1,3 +1,4 @@
+export * from './authenticated-user-required.exception';
 export * from './bad-body.exception';
 export * from './bad-parameter.exception';
 export * from './duplicate.exception';

package/dist/exceptions/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("./authenticated-user-required.exception"), exports);
 __exportStar(require("./bad-body.exception"), exports);
 __exportStar(require("./bad-parameter.exception"), exports);
 __exportStar(require("./duplicate.exception"), exports);

package/dist/functions/add-views-likes-virtuals.function.d.ts

@@ -0,0 +1,15 @@
+import { Document, Schema } from 'mongoose';
+/**
+ * Enhances a Mongoose schema by adding virtual fields for computed values.
+ *
+ * This function inspects the schema's definition for special tracking arrays
+ * (such as `_viewedBy` or `_likedBy`). If those arrays exist, it adds
+ * corresponding virtual properties (`views` and `likes`) to the schema.
+ * These virtuals provide a clean way to access the number of views or likes
+ * without needing to calculate them manually each time.
+ *
+ * @template T - A type extending the Mongoose Document interface.
+ * @param {Schema<T>} schema - The Mongoose schema to augment with virtuals.
+ * @returns {void} - Modifies the schema in place; no return value.
+ */
+export declare function addViewsLikesVirtuals<T extends Document>(schema: Schema<T>): void;