itlab-internal-services 2.16.5 → 2.16.7

package/dist/classes/fetch-options/liked-by-options.class.js

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LikedByOptions = LikedByOptions;
+exports.populateLikedBy = populateLikedBy;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const transform_1 = require("../../transform");
@@ -22,5 +23,28 @@ function LikedByOptions(Base) {
         (0, class_validator_1.IsOptional)(),
         __metadata("design:type", Boolean)
     ], LikedByOptions.prototype, "includeLikedBy", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({}),
+        (0, transform_1.BooleanTransform)(),
+        (0, class_validator_1.IsOptional)(),
+        __metadata("design:type", Boolean)
+    ], LikedByOptions.prototype, "includeLikedByIds", void 0);
     return LikedByOptions;
 }
+async function populateLikedBy(options, items, accountsService) {
+    if (options.includeLikedBy) {
+        const userMap = await accountsService.getUserMap(items.map((item) => item._likedBy));
+        items.forEach((item) => {
+            item.likedBy = userMap.getMultiple(item._likedBy);
+        });
+    }
+    items.forEach((item) => {
+        item.likes = Math.max(item._likedBy.length, item.likes); // TODO: Tmp Fix
+        if (!options.includeLikedBy)
+            item.likedBy = undefined;
+        if (!options.includeLikedByIds)
+            item._likedBy = undefined;
+        if (!(options.includeLikedBy || options.includeLikedByIds))
+            item.likes = undefined;
+    });
+}

package/dist/classes/fetch-options/timestamps-options.class.d.ts

@@ -0,0 +1,12 @@
+import { HasTimestamps } from '../../types';
+export declare function TimestampsOptions<TBase extends new (...args: any[]) => any>(Base: TBase, options: {
+    requiredPermissions: string[];
+}): {
+    new (...args: any[]): {
+        [x: string]: any;
+        includeTimestamps?: boolean;
+    };
+} & TBase;
+export declare function populateTimestamps<TOptions extends {
+    includeTimestamps?: boolean;
+}, TItems extends HasTimestamps>(options: TOptions, items: TItems[], additionalKeys?: (keyof TItems)[]): void;

package/dist/classes/fetch-options/timestamps-options.class.js

@@ -0,0 +1,40 @@
+"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);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimestampsOptions = TimestampsOptions;
+exports.populateTimestamps = populateTimestamps;
+const swagger_1 = require("@nestjs/swagger");
+const class_validator_1 = require("class-validator");
+const pipes_1 = require("../../pipes");
+const transform_1 = require("../../transform");
+function TimestampsOptions(Base, options) {
+    class TimestampsOptions extends Base {
+    }
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({}),
+        (0, transform_1.BooleanTransform)(),
+        (0, class_validator_1.IsOptional)(),
+        (0, pipes_1.Restricted)(options.requiredPermissions),
+        __metadata("design:type", Boolean)
+    ], TimestampsOptions.prototype, "includeTimestamps", void 0);
+    return TimestampsOptions;
+}
+function populateTimestamps(options, items, additionalKeys = []) {
+    if (!options.includeTimestamps) {
+        items.forEach((item) => {
+            item.createdAt = undefined;
+            item.updatedAt = undefined;
+            additionalKeys.forEach((key) => {
+                item[key] = undefined;
+            });
+        });
+    }
+}

package/dist/classes/fetch-options/viewed-by-options.class.d.ts

@@ -1,9 +1,17 @@
-export declare function ViewedByOptions<TBase extends new (...args: any[]) => any>(Base: TBase, options?: {
-    requiredPermissions?: string[];
+import { AccountsService } from '../../modules';
+import { IsViewable } from '../../types';
+export declare function ViewedByOptions<TBase extends new (...args: any[]) => any>(Base: TBase, options: {
+    requiredPermissions: string[];
 }): {
     new (...args: any[]): {
         [x: string]: any;
         includeViewedBy?: boolean;
+        includeViewedByIds?: boolean;
         viewedBy?: string;
     };
 } & TBase;
+export declare function populateViewedBy(options: {
+    includeViewedBy?: boolean;
+    includeViewedByIds?: boolean;
+    viewedBy?: string;
+}, items: IsViewable[], accountsService: AccountsService): Promise<void>;

package/dist/classes/fetch-options/viewed-by-options.class.js

@@ -10,8 +10,10 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ViewedByOptions = ViewedByOptions;
+exports.populateViewedBy = populateViewedBy;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
+const rxjs_1 = require("rxjs");
 const pipes_1 = require("../../pipes");
 const transform_1 = require("../../transform");
 function ViewedByOptions(Base, options) {
@@ -21,8 +23,37 @@ function ViewedByOptions(Base, options) {
         (0, swagger_1.ApiPropertyOptional)({}),
         (0, transform_1.BooleanTransform)(),
         (0, class_validator_1.IsOptional)(),
-        (0, pipes_1.Restricted)(options === null || options === void 0 ? void 0 : options.requiredPermissions),
+        (0, pipes_1.Restricted)(options.requiredPermissions),
         __metadata("design:type", Boolean)
     ], ViewedByOptions.prototype, "includeViewedBy", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({}),
+        (0, transform_1.BooleanTransform)(),
+        (0, class_validator_1.IsOptional)(),
+        (0, pipes_1.Restricted)(options.requiredPermissions),
+        __metadata("design:type", Boolean)
+    ], ViewedByOptions.prototype, "includeViewedByIds", void 0);
     return ViewedByOptions;
 }
+async function populateViewedBy(options, items, accountsService) {
+    if (options.viewedBy) {
+        items.forEach((item) => {
+            item.addView(options.viewedBy).then(rxjs_1.noop);
+        });
+    }
+    if (options.includeViewedBy) {
+        const userMap = await accountsService.getUserMap(items.map((item) => item._viewedBy));
+        items.forEach((item) => {
+            item.viewedBy = userMap.getMultiple(item._viewedBy);
+        });
+    }
+    items.forEach((item) => {
+        item.views = Math.max(item._viewedBy.length, item.views); // TODO: Tmp Fix
+        if (!options.includeViewedBy)
+            item.viewedBy = undefined;
+        if (!options.includeViewedByIds)
+            item._viewedBy = undefined;
+        if (!(options.includeViewedBy || options.includeViewedByIds))
+            item.views = undefined;
+    });
+}

package/dist/classes/index.d.ts

@@ -1,5 +1,6 @@
 export * from './document';
 export * from './fetch-options';
 export { DocumentMerger } from './document-merger.class';
+export { EntityMap } from './entity-map.class';
 export { ReportCategory } from './report-category.class';
 export { TaskManager } from './task-manager.class';

package/dist/classes/index.js

@@ -14,11 +14,13 @@ 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.TaskManager = exports.ReportCategory = exports.DocumentMerger = void 0;
+exports.TaskManager = exports.ReportCategory = exports.EntityMap = exports.DocumentMerger = void 0;
 __exportStar(require("./document"), exports);
 __exportStar(require("./fetch-options"), exports);
 var document_merger_class_1 = require("./document-merger.class");
 Object.defineProperty(exports, "DocumentMerger", { enumerable: true, get: function () { return document_merger_class_1.DocumentMerger; } });
+var entity_map_class_1 = require("./entity-map.class");
+Object.defineProperty(exports, "EntityMap", { enumerable: true, get: function () { return entity_map_class_1.EntityMap; } });
 var report_category_class_1 = require("./report-category.class");
 Object.defineProperty(exports, "ReportCategory", { enumerable: true, get: function () { return report_category_class_1.ReportCategory; } });
 var task_manager_class_1 = require("./task-manager.class");

package/dist/classes/task-manager.class.d.ts

@@ -1,5 +1,3 @@
-import { Account, User } from '../models';
-import { AccountsService } from '../modules';
 /**
  * TaskManager is a utility class that collects asynchronous tasks
  * and executes them in parallel.
@@ -17,22 +15,6 @@ import { AccountsService } from '../modules';
  */
 export declare class TaskManager {
     private 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 fetchAndMapUsers(userIdGroups: string[][], accountsService: AccountsService): Promise<FetchMap<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 fetchAndMapAccounts(accountIdGroups: string[][], accountsService: AccountsService): Promise<FetchMap<Account>>;
     /**
      * Adds a new asynchronous task to the queue.
      *
@@ -53,23 +35,3 @@ export declare class TaskManager {
      */
     clear(): void;
 }
-declare class FetchMap<T extends User | Account> {
-    private readonly map;
-    constructor(items?: T[]);
-    /**
-     * Maps a single ID to an user/account object using a user/account Map.
-     * @param id ID of user/account to map
-     * @param map Map of id -> user/account object
-     * @returns user/account object
-     */
-    get(id: string): T;
-    /**
-     * Maps an array of IDs to user/account objects using a user/account Map.
-     * Filters out any IDs that don’t have a corresponding entity.
-     * @param ids Array of user/account IDs to map
-     * @param map Map of id -> user/account object
-     * @returns Array of user/account objects
-     */
-    getMultiple(ids: string[]): T[];
-}
-export {};

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

@@ -20,40 +20,6 @@ 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());
-        if (uniqueUserIds.size === 0)
-            return new FetchMap();
-        // Fetch all users once
-        const userCollection = await accountsService.getUserCollection(Array.from(uniqueUserIds));
-        // Build a map for quick lookup
-        return new FetchMap(userCollection);
-    }
-    /**
-     * 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());
-        if (uniqueAccountIds.size === 0)
-            return new FetchMap();
-        // Fetch all users once
-        const accountCollection = await accountsService.getAccountCollection(Array.from(uniqueAccountIds));
-        // Build a map for quick lookup
-        return new FetchMap(accountCollection);
-    }
     /**
      * Adds a new asynchronous task to the queue.
      *
@@ -81,27 +47,3 @@ class TaskManager {
     }
 }
 exports.TaskManager = TaskManager;
-class FetchMap {
-    constructor(items = []) {
-        this.map = new Map(items.map((item) => [item.id, item]));
-    }
-    /**
-     * Maps a single ID to an user/account object using a user/account Map.
-     * @param id ID of user/account to map
-     * @param map Map of id -> user/account object
-     * @returns user/account object
-     */
-    get(id) {
-        return this.map.get(id);
-    }
-    /**
-     * Maps an array of IDs to user/account objects using a user/account Map.
-     * Filters out any IDs that don’t have a corresponding entity.
-     * @param ids Array of user/account IDs to map
-     * @param map Map of id -> user/account object
-     * @returns Array of user/account objects
-     */
-    getMultiple(ids) {
-        return ids.map((id) => this.map.get(id)).filter(Boolean);
-    }
-}

package/dist/decorators/authenticated-account.decorator.d.ts

@@ -14,4 +14,4 @@ import { Account } from '../models';
  * @param {ExecutionContext} executionContext - The context of the current request.
  * @returns {Account[keyof Account] | Account} The requested account attribute or full account object.
  */
-export declare const AuthenticatedAccount: (...dataOrPipes: (keyof Account | import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>>)[]) => ParameterDecorator;
+export declare const AuthenticatedAccount: (...dataOrPipes: (import("@nestjs/common").PipeTransform<any, any> | import("@nestjs/common").Type<import("@nestjs/common").PipeTransform<any, any>> | keyof Account)[]) => ParameterDecorator;

package/dist/index.d.ts

@@ -3,7 +3,6 @@ export * from './controllers';
 export * from './decorators';
 export * from './exceptions';
 export * from './functions';
-export * from './interceptors';
 export * from './middleware';
 export * from './models';
 export * from './modules';

package/dist/index.js

@@ -20,7 +20,6 @@ __exportStar(require("./controllers"), exports);
 __exportStar(require("./decorators"), exports);
 __exportStar(require("./exceptions"), exports);
 __exportStar(require("./functions"), exports);
-__exportStar(require("./interceptors"), exports);
 __exportStar(require("./middleware"), exports);
 __exportStar(require("./models"), exports);
 __exportStar(require("./modules"), exports);

package/dist/modules/services/providers/accounts.service.d.ts

@@ -1,4 +1,5 @@
 import { ConfigService } from '@nestjs/config';
+import { EntityMap } from '../../../classes';
 import { Account, User } from '../../../models';
 import { AuthenticationModuleOptions } from '../../authentication';
 import { BaseHttpService } from '../base-http.service';
@@ -35,6 +36,13 @@ export declare class AccountsService extends BaseHttpService {
      * @returns {Promise<Account[]>} Resolves to an array of account objects (empty if none found).
      */
     getAccountCollection(accountIds: string[]): Promise<Account[]>;
+    /**
+     * Fetches all accounts for the given ID groups and returns a mapping.
+     * Ensures each account is fetched only once.
+     * @param accountIdGroups Array of arrays of account IDs (e.g., authors, likedBy, viewedBy)
+     * @returns Map of accountId -> Account
+     */
+    getAccountMap(accountIdGroups: string[][]): Promise<EntityMap<Account>>;
     /**
      * Retrieves a single user entry derived from an account.
      *
@@ -49,4 +57,11 @@ export declare class AccountsService extends BaseHttpService {
      * @returns {Promise<User[]>} Resolves to a list of users (empty array if none found).
      */
     getUserCollection(userIds: string[]): Promise<User[]>;
+    /**
+     * 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)
+     * @returns Map of userId -> user
+     */
+    getUserMap(userIdGroups: string[][]): Promise<EntityMap<User>>;
 }

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

@@ -16,6 +16,7 @@ exports.AccountsService = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
 const itlab_functions_1 = require("itlab-functions");
+const classes_1 = require("../../../classes");
 const authentication_1 = require("../../authentication");
 const base_http_service_1 = require("../base-http.service");
 const base_urls_1 = require("../base-urls");
@@ -65,6 +66,22 @@ let AccountsService = class AccountsService extends base_http_service_1.BaseHttp
         });
         return (await Promise.all(chunkedAccounts)).flat();
     }
+    /**
+     * Fetches all accounts for the given ID groups and returns a mapping.
+     * Ensures each account is fetched only once.
+     * @param accountIdGroups Array of arrays of account IDs (e.g., authors, likedBy, viewedBy)
+     * @returns Map of accountId -> Account
+     */
+    async getAccountMap(accountIdGroups) {
+        // Collect all unique account IDs across all groups
+        const uniqueAccountIds = new Set(accountIdGroups.flat());
+        if (uniqueAccountIds.size === 0)
+            return new classes_1.EntityMap();
+        // Fetch all accounts once
+        const accountCollection = await this.getAccountCollection(Array.from(uniqueAccountIds));
+        // Build a map for quick lookup
+        return new classes_1.EntityMap(accountCollection);
+    }
     /**
      * Retrieves a single user entry derived from an account.
      *
@@ -89,6 +106,22 @@ let AccountsService = class AccountsService extends base_http_service_1.BaseHttp
         });
         return (await Promise.all(chunkedUsers)).flat();
     }
+    /**
+     * 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)
+     * @returns Map of userId -> user
+     */
+    async getUserMap(userIdGroups) {
+        // Collect all unique user IDs across all groups
+        const uniqueUserIds = new Set(userIdGroups.flat());
+        if (uniqueUserIds.size === 0)
+            return new classes_1.EntityMap();
+        // Fetch all users once
+        const userCollection = await this.getUserCollection(Array.from(uniqueUserIds));
+        // Build a map for quick lookup
+        return new classes_1.EntityMap(userCollection);
+    }
 };
 exports.AccountsService = AccountsService;
 exports.AccountsService = AccountsService = __decorate([

package/dist/modules/services/providers/mail/dtos/event-cancel-mail.dto.d.ts

@@ -4,6 +4,10 @@ import { MailRecipient } from '../models';
  */
 export type EventCancelMailDto = {
     recipient: MailRecipient;
+    /**
+     * Mode of participation (e.g., in person, online).
+     */
+    participation?: string;
     /**
      * Title of the event that has been cancelled.
      * @example "Meetup"

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

@@ -1,8 +1,3 @@
-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
  *
@@ -14,22 +9,4 @@ import { AuthenticationModuleOptions } from '../modules';
  * @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;
-}
+export declare function UseRestricted(): ClassDecorator;

package/dist/pipes/restricted-fields.pipe.js

@@ -12,8 +12,8 @@ var __param = (this && this.__param) || function (paramIndex, decorator) {
     return function (target, key) { decorator(target, key, paramIndex); }
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestrictedFieldsPipe = void 0;
 exports.Restricted = Restricted;
+exports.UseRestricted = UseRestricted;
 const common_1 = require("@nestjs/common");
 const core_1 = require("@nestjs/core");
 const class_validator_1 = require("class-validator");
@@ -21,23 +21,6 @@ const itlab_functions_1 = require("itlab-functions");
 const modules_1 = require("../modules");
 const service_auth_guard_1 = require("../modules/authentication/guards/service-auth.guard");
 const RESTRICTED_METADATA_KEY = Symbol('itlab-restricted-metadata');
-/**
- * @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.
- */
-function Restricted(perms) {
-    return (target, propertyKey) => {
-        // Store metadata without touching the property descriptor
-        const existingMetadata = Reflect.getMetadata(RESTRICTED_METADATA_KEY, target) || {};
-        Reflect.defineMetadata(RESTRICTED_METADATA_KEY, Object.assign(Object.assign({}, existingMetadata), { [propertyKey.toString()]: [perms !== null && perms !== void 0 ? perms : []].flat() }), target);
-    };
-}
 /**
  * RestrictedFieldsPipe
  *
@@ -70,16 +53,35 @@ let RestrictedFieldsPipe = class RestrictedFieldsPipe {
             return value;
         for (const [propertyKey, requiredPerms] of Object.entries(restrictions)) {
             if (requiredPerms.length && !(0, itlab_functions_1.hasSomePermission)(requiredPerms, grantedPerms)) {
-                delete value[propertyKey];
+                value[propertyKey] = undefined;
             }
         }
         return value;
     }
 };
-exports.RestrictedFieldsPipe = RestrictedFieldsPipe;
-exports.RestrictedFieldsPipe = RestrictedFieldsPipe = __decorate([
+RestrictedFieldsPipe = __decorate([
     (0, common_1.Injectable)({ scope: common_1.Scope.REQUEST }),
     __param(0, (0, common_1.Inject)(core_1.REQUEST)),
     __param(1, (0, modules_1.InjectAuthenticationOptions)()),
     __metadata("design:paramtypes", [Object, Object, core_1.Reflector])
 ], RestrictedFieldsPipe);
+/**
+ * @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.
+ */
+function Restricted(perms) {
+    return (target, propertyKey) => {
+        // Store metadata without touching the property descriptor
+        const existingMetadata = Reflect.getMetadata(RESTRICTED_METADATA_KEY, target) || {};
+        Reflect.defineMetadata(RESTRICTED_METADATA_KEY, Object.assign(Object.assign({}, existingMetadata), { [propertyKey.toString()]: [perms !== null && perms !== void 0 ? perms : []].flat() }), target);
+    };
+}
+function UseRestricted() {
+    return (0, common_1.applyDecorators)((0, common_1.UsePipes)(RestrictedFieldsPipe));
+}

package/dist/types/has-timestamps.type.d.ts

@@ -0,0 +1,4 @@
+export type HasTimestamps = {
+    createdAt: Date;
+    updatedAt: Date;
+};

package/dist/types/has-timestamps.type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -1,3 +1,4 @@
 export * from './duplicable-model.type';
+export * from './has-timestamps.type';
 export * from './likeable.type';
 export * from './viewable.type';

package/dist/types/index.js

@@ -15,5 +15,6 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./duplicable-model.type"), exports);
+__exportStar(require("./has-timestamps.type"), exports);
 __exportStar(require("./likeable.type"), exports);
 __exportStar(require("./viewable.type"), exports);

package/package.json

@@ -4,7 +4,7 @@
     "name": "Timo Scheuermann",
     "email": "timo.scheuermann@sv-informatik.de"
   },
-  "version": "2.16.5",
+  "version": "2.16.7",
   "type": "commonjs",
   "files": [
     "dist"

package/dist/interceptors/attribute-sanitizer.interceptor.d.ts

@@ -1,68 +0,0 @@
-import { CallHandler, ExecutionContext, NestInterceptor } from '@nestjs/common';
-import { Observable } from 'rxjs';
-/**
- * AttributeSanitizerInterceptor
- *
- * This interceptor removes specified attributes from response objects.
- * It works with plain objects, arrays, sets, maps and also with Mongoose
- * documents by normalizing them to plain objects before sanitization.
- *
- * This is especially useful for removing sensitive fields (e.g., passwords,
- * tokens, SSNs) consistently across deeply nested response structures.
- */
-export declare class AttributeSanitizerInterceptor implements NestInterceptor {
-    private readonly keys;
-    private readonly mongooseToObjectOptions;
-    /**
-     * @param keys - One or more property names to remove from every object.
-     * @param mongooseToObjectOptions - Options forwarded to Mongoose `.toObject()`
-     *                                  when normalizing documents.
-     */
-    constructor(keys: string | string[], mongooseToObjectOptions?: Record<string, unknown>);
-    /**
-     * Intercepts the response and removes the targeted attributes.
-     *
-     * @param _context - Execution context (unused here).
-     * @param next - Next handler in the pipeline.
-     * @returns Sanitized response data.
-     */
-    intercept(_context: ExecutionContext, next: CallHandler): Observable<unknown>;
-    /**
-     * Recursively removes targeted keys from objects, arrays, and nested structures.
-     *
-     * @param value - Any response value.
-     * @returns A sanitized value without the targeted attributes.
-     */
-    private sanitizeRecursively;
-    /**
-     * Converts a Mongoose document to a plain object if needed.
-     *
-     * @param value - Possible Mongoose document.
-     * @returns A plain object if conversion is possible, otherwise the value itself.
-     */
-    private normalizeIfMongooseDocument;
-    /**
-     * Checks whether a value is a plain object (and not a class instance, Date, etc.).
-     *
-     * @param value - Any value.
-     * @returns True if the value is a plain object.
-     */
-    private isPlainObject;
-    /**
-     * Converts the user-provided keys into a Set for O(1) lookup.
-     *
-     * @param keys - String or array of strings.
-     * @returns A Set of keys.
-     */
-    private ensureKeySet;
-}
-/**
- * @UseAttributeSanitizer
- *
- * Convenience decorator that applies the AttributeSanitizerInterceptor
- * to a route or controller.
- *
- * @param keys - One or more keys to remove from all response objects.
- * @param mongooseToObjectOptions - Options for Mongoose `.toObject()` normalization.
- */
-export declare function UseAttributeSanitizer(keys: string | string[], mongooseToObjectOptions?: Record<string, unknown>): MethodDecorator & ClassDecorator;