itlab-internal-services 2.16.4 → 2.16.6

package/dist/classes/document/index.d.ts

@@ -1,4 +1,5 @@
 export { CommentableDocument } from './commentable-document.class';
 export { ContentDocument } from './content-document.class';
 export { LikeableDocument } from './likeable-document.class';
+export { TimestampsDocument } from './timestamps-document.class';
 export { ViewableDocument } from './viewable-document.class';

package/dist/classes/document/index.js

@@ -1,11 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ViewableDocument = exports.LikeableDocument = exports.ContentDocument = exports.CommentableDocument = void 0;
+exports.ViewableDocument = exports.TimestampsDocument = exports.LikeableDocument = exports.ContentDocument = exports.CommentableDocument = void 0;
 var commentable_document_class_1 = require("./commentable-document.class");
 Object.defineProperty(exports, "CommentableDocument", { enumerable: true, get: function () { return commentable_document_class_1.CommentableDocument; } });
 var content_document_class_1 = require("./content-document.class");
 Object.defineProperty(exports, "ContentDocument", { enumerable: true, get: function () { return content_document_class_1.ContentDocument; } });
 var likeable_document_class_1 = require("./likeable-document.class");
 Object.defineProperty(exports, "LikeableDocument", { enumerable: true, get: function () { return likeable_document_class_1.LikeableDocument; } });
+var timestamps_document_class_1 = require("./timestamps-document.class");
+Object.defineProperty(exports, "TimestampsDocument", { enumerable: true, get: function () { return timestamps_document_class_1.TimestampsDocument; } });
 var viewable_document_class_1 = require("./viewable-document.class");
 Object.defineProperty(exports, "ViewableDocument", { enumerable: true, get: function () { return viewable_document_class_1.ViewableDocument; } });

package/dist/classes/document/likeable-document.class.d.ts

@@ -1,6 +1,8 @@
 import { Document } from 'mongoose';
 import { User } from '../../models';
-export declare function LikeableDocument<TBase extends new (...args: any[]) => Document>(Base: TBase): {
+export declare function LikeableDocument<TBase extends new (...args: any[]) => Document>(Base: TBase, options?: {
+    requiredPermissions?: string[];
+}): {
     new (...args: any[]): {
         _likedBy: string[];
         likes: number;

package/dist/classes/document/likeable-document.class.js

@@ -14,7 +14,8 @@ const mongoose_1 = require("@nestjs/mongoose");
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const models_1 = require("../../models");
-function LikeableDocument(Base) {
+const pipes_1 = require("../../pipes");
+function LikeableDocument(Base, options) {
     class LikeableDocument extends Base {
         hasLiked(accountId) {
             return this._likedBy.includes(accountId);
@@ -44,6 +45,7 @@ function LikeableDocument(Base) {
             default: [],
         }),
         (0, mongoose_1.Prop)({ type: [String], default: [] }),
+        (0, pipes_1.Restricted)(options === null || options === void 0 ? void 0 : options.requiredPermissions),
         __metadata("design:type", Array)
     ], LikeableDocument.prototype, "_likedBy", void 0);
     __decorate([
@@ -54,6 +56,7 @@ function LikeableDocument(Base) {
             default: 0,
         }),
         (0, mongoose_1.Prop)({ type: Number, default: 0 }),
+        (0, pipes_1.Restricted)(options === null || options === void 0 ? void 0 : options.requiredPermissions),
         __metadata("design:type", Number)
     ], LikeableDocument.prototype, "likes", void 0);
     __decorate([
@@ -64,6 +67,7 @@ function LikeableDocument(Base) {
             default: [],
         }),
         (0, mongoose_1.Virtual)(),
+        (0, pipes_1.Restricted)(options === null || options === void 0 ? void 0 : options.requiredPermissions),
         __metadata("design:type", Array)
     ], LikeableDocument.prototype, "likedBy", void 0);
     return LikeableDocument;

package/dist/classes/document/timestamps-document.class.d.ts

@@ -0,0 +1,200 @@
+import { Document } from 'mongoose';
+export declare function TimestampsDocument<TBase extends new (...args: any[]) => Document>(Base: TBase): {
+    new (...args: any[]): {
+        createdAt: Date;
+        updatedAt: Date;
+        _id: unknown;
+        $assertPopulated<Paths = {}>(path: string | string[], values?: Partial<Paths>): Omit</*elided*/ any, keyof Paths> & Paths;
+        $clearModifiedPaths(): /*elided*/ any;
+        $clone(): /*elided*/ any;
+        $createModifiedPathsSnapshot(): import("mongoose").ModifiedPathsSnapshot;
+        $getAllSubdocs(): Document[];
+        $ignore(path: string): void;
+        $isDefault(path?: string): boolean;
+        $isDeleted(val?: boolean): boolean;
+        $getPopulatedDocs(): Document[];
+        $inc(path: string | string[], val?: number): /*elided*/ any;
+        $isEmpty(path: string): boolean;
+        $isValid(path: string): boolean;
+        $locals: Record<string, unknown>;
+        $markValid(path: string): void;
+        $model<ModelType = import("mongoose").Model<unknown, {}, {}, {}, Document<unknown, {}, unknown, {}, {}> & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        }, any>>(name: string): ModelType;
+        $model<ModelType = import("mongoose").Model<any, {}, {}, {}, any, any>>(): ModelType;
+        $op: "save" | "validate" | "remove" | null;
+        $restoreModifiedPathsSnapshot(snapshot: import("mongoose").ModifiedPathsSnapshot): /*elided*/ any;
+        $session(session?: import("mongoose").ClientSession | null): import("mongoose").ClientSession | null;
+        $set(path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions): /*elided*/ any;
+        $set(path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions): /*elided*/ any;
+        $set(value: string | Record<string, any>): /*elided*/ any;
+        $where: Record<string, unknown>;
+        baseModelName?: string;
+        collection: import("mongoose").Collection;
+        db: import("mongoose").Connection;
+        deleteOne(options?: import("mongoose").QueryOptions): any;
+        depopulate<Paths = {}>(path?: string | string[]): import("mongoose").MergeType</*elided*/ any, Paths>;
+        directModifiedPaths(): Array<string>;
+        equals(doc: Document<unknown, any, any, Record<string, any>, {}>): boolean;
+        errors?: import("mongoose").Error.ValidationError;
+        get<T extends string | number | symbol>(path: T, type?: any, options?: any): any;
+        get(path: string, type?: any, options?: any): any;
+        getChanges(): import("mongoose").UpdateQuery</*elided*/ any>;
+        id?: any;
+        increment(): /*elided*/ any;
+        init(obj: import("mongoose").AnyObject, opts?: import("mongoose").AnyObject): /*elided*/ any;
+        invalidate<T extends string | number | symbol>(path: T, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
+        invalidate(path: string, errorMsg: string | NativeError, value?: any, kind?: string): NativeError | null;
+        isDirectModified<T extends string | number | symbol>(path: T | T[]): boolean;
+        isDirectModified(path: string | Array<string>): boolean;
+        isDirectSelected<T extends string | number | symbol>(path: T): boolean;
+        isDirectSelected(path: string): boolean;
+        isInit<T extends string | number | symbol>(path: T): boolean;
+        isInit(path: string): boolean;
+        isModified<T extends string | number | symbol>(path?: T | T[], options?: {
+            ignoreAtomics?: boolean;
+        } | null): boolean;
+        isModified(path?: string | Array<string>, options?: {
+            ignoreAtomics?: boolean;
+        } | null): boolean;
+        isNew: boolean;
+        isSelected<T extends string | number | symbol>(path: T): boolean;
+        isSelected(path: string): boolean;
+        markModified<T extends string | number | symbol>(path: T, scope?: any): void;
+        markModified(path: string, scope?: any): void;
+        model<ModelType = import("mongoose").Model<unknown, {}, {}, {}, Document<unknown, {}, unknown, {}, {}> & Required<{
+            _id: unknown;
+        }> & {
+            __v: number;
+        }, any>>(name: string): ModelType;
+        model<ModelType = import("mongoose").Model<any, {}, {}, {}, any, any>>(): ModelType;
+        modifiedPaths(options?: {
+            includeChildren?: boolean;
+        }): Array<string>;
+        overwrite(obj: import("mongoose").AnyObject): /*elided*/ any;
+        $parent(): Document | undefined;
+        populate<Paths = {}>(path: string | import("mongoose").PopulateOptions | (string | import("mongoose").PopulateOptions)[]): Promise<import("mongoose").MergeType</*elided*/ any, Paths>>;
+        populate<Paths = {}>(path: string, select?: string | import("mongoose").AnyObject, model?: import("mongoose").Model<any>, match?: import("mongoose").AnyObject, options?: import("mongoose").PopulateOptions): Promise<import("mongoose").MergeType</*elided*/ any, Paths>>;
+        populated(path: string): any;
+        replaceOne(replacement?: import("mongoose").AnyObject, options?: import("mongoose").QueryOptions | null): import("mongoose").Query<any, /*elided*/ any, {}, unknown, "find", Record<string, never>>;
+        save(options?: import("mongoose").SaveOptions): Promise</*elided*/ any>;
+        schema: import("mongoose").Schema;
+        set<T extends string | number | symbol>(path: T, val: any, type: any, options?: import("mongoose").DocumentSetOptions): /*elided*/ any;
+        set(path: string | Record<string, any>, val: any, type: any, options?: import("mongoose").DocumentSetOptions): /*elided*/ any;
+        set(path: string | Record<string, any>, val: any, options?: import("mongoose").DocumentSetOptions): /*elided*/ any;
+        set(value: string | Record<string, any>): /*elided*/ any;
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            versionKey: false;
+            virtuals: true;
+            flattenObjectIds: true;
+        }): Omit<{
+            [x: string]: any;
+        }, "__v">;
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            virtuals: true;
+            flattenObjectIds: true;
+        }): {
+            [x: string]: any;
+        };
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            versionKey: false;
+            virtuals: true;
+        }): Omit<any, "__v">;
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            versionKey: false;
+            flattenObjectIds: true;
+        }): {
+            [x: string]: any;
+            [x: number]: any;
+            [x: symbol]: any;
+        };
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            virtuals: true;
+        }): any;
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            versionKey: false;
+        }): Omit<any, "__v">;
+        toJSON(options?: import("mongoose").ToObjectOptions & {
+            flattenMaps?: true;
+            flattenObjectIds?: false;
+        }): import("mongoose").FlattenMaps<any>;
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            flattenObjectIds: false;
+        }): import("mongoose").FlattenMaps<any>;
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            flattenObjectIds: true;
+        }): {
+            [x: string]: any;
+        };
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            flattenMaps: false;
+        }): any;
+        toJSON(options: import("mongoose").ToObjectOptions & {
+            flattenMaps: false;
+            flattenObjectIds: true;
+        }): any;
+        toJSON<T = any>(options?: import("mongoose").ToObjectOptions & {
+            flattenMaps?: true;
+            flattenObjectIds?: false;
+        }): import("mongoose").FlattenMaps<T>;
+        toJSON<T = any>(options: import("mongoose").ToObjectOptions & {
+            flattenObjectIds: false;
+        }): import("mongoose").FlattenMaps<T>;
+        toJSON<T = any>(options: import("mongoose").ToObjectOptions & {
+            flattenObjectIds: true;
+        }): import("mongoose").ObjectIdToString<import("mongoose").FlattenMaps<T>>;
+        toJSON<T = any>(options: import("mongoose").ToObjectOptions & {
+            flattenMaps: false;
+        }): T;
+        toJSON<T = any>(options: import("mongoose").ToObjectOptions & {
+            flattenMaps: false;
+            flattenObjectIds: true;
+        }): import("mongoose").ObjectIdToString<T>;
+        toObject(options: import("mongoose").ToObjectOptions & {
+            versionKey: false;
+            virtuals: true;
+            flattenObjectIds: true;
+        }): Omit<any, "__v">;
+        toObject(options: import("mongoose").ToObjectOptions & {
+            virtuals: true;
+            flattenObjectIds: true;
+        }): any;
+        toObject(options: import("mongoose").ToObjectOptions & {
+            versionKey: false;
+            flattenObjectIds: true;
+        }): Omit<any, "__v">;
+        toObject(options: import("mongoose").ToObjectOptions & {
+            versionKey: false;
+            virtuals: true;
+        }): Omit<any, "__v">;
+        toObject(options: import("mongoose").ToObjectOptions & {
+            virtuals: true;
+        }): any;
+        toObject(options: import("mongoose").ToObjectOptions & {
+            versionKey: false;
+        }): Omit<any, "__v">;
+        toObject(options: import("mongoose").ToObjectOptions & {
+            flattenObjectIds: true;
+        }): any;
+        toObject(options?: import("mongoose").ToObjectOptions): any;
+        toObject<T>(options?: import("mongoose").ToObjectOptions): import("mongoose").Require_id<T> & {
+            __v: number;
+        };
+        unmarkModified<T extends string | number | symbol>(path: T): void;
+        unmarkModified(path: string): void;
+        updateOne(update?: import("mongoose").UpdateWithAggregationPipeline | import("mongoose").UpdateQuery</*elided*/ any>, options?: import("mongoose").QueryOptions | null): import("mongoose").Query<any, /*elided*/ any, {}, unknown, "find", Record<string, never>>;
+        validate<T extends string | number | symbol>(pathsToValidate?: T | T[], options?: import("mongoose").AnyObject): Promise<void>;
+        validate(pathsToValidate?: import("mongoose").pathsToValidate, options?: import("mongoose").AnyObject): Promise<void>;
+        validate(options: {
+            pathsToSkip?: import("mongoose").pathsToSkip;
+        }): Promise<void>;
+        validateSync(options: {
+            pathsToSkip?: import("mongoose").pathsToSkip;
+            [k: string]: any;
+        }): import("mongoose").Error.ValidationError | null;
+        validateSync<T extends string | number | symbol>(pathsToValidate?: T | T[], options?: import("mongoose").AnyObject): import("mongoose").Error.ValidationError | null;
+        validateSync(pathsToValidate?: import("mongoose").pathsToValidate, options?: import("mongoose").AnyObject): import("mongoose").Error.ValidationError | null;
+    };
+} & TBase;

package/dist/classes/document/timestamps-document.class.js

@@ -0,0 +1,27 @@
+"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.TimestampsDocument = TimestampsDocument;
+const swagger_1 = require("@nestjs/swagger");
+function TimestampsDocument(Base) {
+    class TimestampsDocument extends Base {
+    }
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)({ description: 'Timestamps' }),
+        (0, swagger_1.ApiPropertyOptional)(),
+        __metadata("design:type", Date)
+    ], TimestampsDocument.prototype, "createdAt", void 0);
+    __decorate([
+        (0, swagger_1.ApiPropertyOptional)(),
+        __metadata("design:type", Date)
+    ], TimestampsDocument.prototype, "updatedAt", void 0);
+    return TimestampsDocument;
+}

package/dist/classes/document/viewable-document.class.d.ts

@@ -1,6 +1,8 @@
 import { Document } from 'mongoose';
 import { User } from '../../models';
-export declare function ViewableDocument<TBase extends new (...args: any[]) => Document>(Base: TBase): {
+export declare function ViewableDocument<TBase extends new (...args: any[]) => Document>(Base: TBase, options?: {
+    requiredPermissions?: string[];
+}): {
     new (...args: any[]): {
         _viewedBy: string[];
         views: number;

package/dist/classes/document/viewable-document.class.js

@@ -14,7 +14,8 @@ const mongoose_1 = require("@nestjs/mongoose");
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const models_1 = require("../../models");
-function ViewableDocument(Base) {
+const pipes_1 = require("../../pipes");
+function ViewableDocument(Base, options) {
     class ViewableDocument extends Base {
         hasViewed(accountId) {
             return this._viewedBy.includes(accountId);
@@ -43,6 +44,7 @@ function ViewableDocument(Base) {
             default: [],
         }),
         (0, mongoose_1.Prop)({ type: [String], default: [] }),
+        (0, pipes_1.Restricted)(options === null || options === void 0 ? void 0 : options.requiredPermissions),
         __metadata("design:type", Array)
     ], ViewableDocument.prototype, "_viewedBy", void 0);
     __decorate([
@@ -52,6 +54,7 @@ function ViewableDocument(Base) {
             default: 0,
         }),
         (0, mongoose_1.Prop)({ type: Number, default: 0 }),
+        (0, pipes_1.Restricted)(options === null || options === void 0 ? void 0 : options.requiredPermissions),
         __metadata("design:type", Number)
     ], ViewableDocument.prototype, "views", void 0);
     __decorate([
@@ -61,6 +64,7 @@ function ViewableDocument(Base) {
             default: [],
         }),
         (0, mongoose_1.Virtual)(),
+        (0, pipes_1.Restricted)(options === null || options === void 0 ? void 0 : options.requiredPermissions),
         __metadata("design:type", Array)
     ], ViewableDocument.prototype, "viewedBy", void 0);
     return ViewableDocument;

package/dist/classes/entity-map.class.d.ts

@@ -0,0 +1,21 @@
+export declare class EntityMap<T extends {
+    id: string;
+}> {
+    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[];
+}

package/dist/classes/entity-map.class.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EntityMap = void 0;
+class EntityMap {
+    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);
+    }
+}
+exports.EntityMap = EntityMap;

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

@@ -1,3 +1,4 @@
+import { Document, FilterQuery, QueryOptions } from 'mongoose';
 export declare class BaseOptions {
     /**
      * Basic
@@ -16,3 +17,4 @@ export declare class BaseOptions {
     skip?: number;
     limit?: number;
 }
+export declare function parseBaseOptions<TOptions extends BaseOptions, TDocument extends Document>(options: TOptions, filterQuery: FilterQuery<TDocument>, queryOptions: QueryOptions<TDocument>): void;

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

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseOptions = void 0;
+exports.parseBaseOptions = parseBaseOptions;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const transform_1 = require("../../transform");
@@ -79,3 +80,19 @@ __decorate([
     (0, class_validator_1.IsOptional)(),
     __metadata("design:type", Number)
 ], BaseOptions.prototype, "limit", void 0);
+function parseBaseOptions(options, filterQuery, queryOptions) {
+    var _a, _b, _c, _d, _e, _f;
+    // Handle IDs: Combine single and multiple document IDs into a single $in filter.
+    const idSet = new Set([...(options.id ? [options.id] : []), ...((_a = options.ids) !== null && _a !== void 0 ? _a : [])]);
+    if (idSet.size > 0)
+        filterQuery._id = { $in: Array.from(idSet) };
+    // Sorting: Default sort by _id descending unless overridden in filterQuery.
+    const sortField = (_b = options.sortField) !== null && _b !== void 0 ? _b : '_id';
+    const sortDirection = (_c = options.sortDirection) !== null && _c !== void 0 ? _c : -1;
+    (_d = queryOptions.sort) !== null && _d !== void 0 ? _d : (queryOptions.sort = { [sortField]: sortDirection });
+    // Pagination: Respect limit and skip if explicitly set in filterQuery.
+    if (options.limit !== undefined)
+        (_e = queryOptions.limit) !== null && _e !== void 0 ? _e : (queryOptions.limit = options.limit);
+    if (options.skip !== undefined)
+        (_f = queryOptions.skip) !== null && _f !== void 0 ? _f : (queryOptions.skip = options.skip);
+}

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

@@ -1,6 +1,14 @@
+import { LabComment } from 'itlab-functions';
+import { CommentsService } from '../../modules';
 export declare function CommentsOptions<TBase extends new (...args: any[]) => any>(Base: TBase): {
     new (...args: any[]): {
         [x: string]: any;
         includeComments?: boolean;
     };
 } & TBase;
+export declare function populateComments(options: {
+    includeComments?: boolean;
+}, items: {
+    _id: unknown;
+    comments?: LabComment[];
+}[], commentsService: CommentsService): Promise<void>;

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

@@ -10,9 +10,11 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CommentsOptions = CommentsOptions;
+exports.populateComments = populateComments;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const transform_1 = require("../../transform");
+const task_manager_class_1 = require("../task-manager.class");
 function CommentsOptions(Base) {
     class CommentsOptions extends Base {
     }
@@ -24,3 +26,15 @@ function CommentsOptions(Base) {
     ], CommentsOptions.prototype, "includeComments", void 0);
     return CommentsOptions;
 }
+async function populateComments(options, items, commentsService) {
+    if (options.includeComments) {
+        const taskManager = new task_manager_class_1.TaskManager();
+        items.forEach((item) => {
+            const itemId = item._id.toString();
+            taskManager.add(async () => {
+                item.comments = await commentsService.getCachedPopulatedComments(itemId);
+            });
+        });
+        return taskManager.run();
+    }
+}

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

@@ -1,7 +1,14 @@
-import { ContentReturnType } from '../../modules';
+import { LabContent, LabContentPopulated } from 'itlab-functions';
+import { ContentReturnType, ContentService } from '../../modules';
 export declare function ContentOptions<TBase extends new (...args: any[]) => any>(Base: TBase): {
     new (...args: any[]): {
         [x: string]: any;
         includeContent?: ContentReturnType;
     };
 } & TBase;
+export declare function populateContent(options: {
+    includeContent?: ContentReturnType;
+}, items: {
+    _id: unknown;
+    content?: LabContent | LabContentPopulated | string;
+}[], contentService: ContentService): Promise<void>;

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

@@ -10,11 +10,13 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ContentOptions = ContentOptions;
+exports.populateContent = populateContent;
 const swagger_1 = require("@nestjs/swagger");
 const class_transformer_1 = require("class-transformer");
 const class_validator_1 = require("class-validator");
 const content_return_types_1 = require("../../modules/services/providers/content/content-return-types");
 const properties_1 = require("../../properties");
+const task_manager_class_1 = require("../task-manager.class");
 function ContentOptions(Base) {
     class ContentOptions extends Base {
     }
@@ -30,3 +32,15 @@ function ContentOptions(Base) {
     ], ContentOptions.prototype, "includeContent", void 0);
     return ContentOptions;
 }
+async function populateContent(options, items, contentService) {
+    if (options.includeContent) {
+        const taskManager = new task_manager_class_1.TaskManager();
+        items.forEach((item) => {
+            const itemId = item._id.toString();
+            taskManager.add(async () => {
+                item.content = await contentService.getCachedContent(itemId, options.includeContent);
+            });
+        });
+        return taskManager.run();
+    }
+}

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

@@ -1,5 +1,6 @@
-export declare function DraftedOptions<TBase extends new (...args: any[]) => any>(Base: TBase, options?: {
-    requiredPermissions?: string[];
+import { Document, FilterQuery } from 'mongoose';
+export declare function DraftedOptions<TBase extends new (...args: any[]) => any>(Base: TBase, options: {
+    requiredPermissions: string[];
 }): {
     new (...args: any[]): {
         [x: string]: any;
@@ -7,3 +8,7 @@ export declare function DraftedOptions<TBase extends new (...args: any[]) => any
         isDraft?: boolean;
     };
 } & TBase;
+export declare function parseDraftedOptions<TOptions extends {
+    includeDrafted?: boolean;
+    isDraft?: boolean;
+}>(options: TOptions, filterQuery: FilterQuery<Document>, onDraftsExcluded?: VoidFunction): void;

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

@@ -10,6 +10,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DraftedOptions = DraftedOptions;
+exports.parseDraftedOptions = parseDraftedOptions;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const pipes_1 = require("../../pipes");
@@ -21,14 +22,24 @@ function DraftedOptions(Base, options) {
         (0, swagger_1.ApiPropertyOptional)({ example: true }),
         (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)
     ], DraftedOptions.prototype, "includeDrafted", 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)
     ], DraftedOptions.prototype, "isDraft", void 0);
     return DraftedOptions;
 }
+function parseDraftedOptions(options, filterQuery, onDraftsExcluded) {
+    // Include draft status in filter if explicitly set
+    if (options.isDraft !== undefined)
+        filterQuery.draft = options.isDraft;
+    if (options.includeDrafted === undefined && options.isDraft === undefined) {
+        filterQuery.draft = false;
+        onDraftsExcluded === null || onDraftsExcluded === void 0 ? void 0 : onDraftsExcluded();
+    }
+}

package/dist/classes/fetch-options/index.d.ts

@@ -1,6 +1,7 @@
-export { BaseOptions } from './base-options.class';
-export { CommentsOptions } from './comments-options.class';
-export { ContentOptions } from './content-options.class';
-export { DraftedOptions } from './drafted-options.class';
-export { LikedByOptions } from './liked-by-options.class';
-export { ViewedByOptions } from './viewed-by-options.class';
+export * from './base-options.class';
+export * from './comments-options.class';
+export * from './content-options.class';
+export * from './drafted-options.class';
+export * from './liked-by-options.class';
+export * from './timestamps-options.class';
+export * from './viewed-by-options.class';

package/dist/classes/fetch-options/index.js

@@ -1,15 +1,23 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+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.ViewedByOptions = exports.LikedByOptions = exports.DraftedOptions = exports.ContentOptions = exports.CommentsOptions = exports.BaseOptions = void 0;
-var base_options_class_1 = require("./base-options.class");
-Object.defineProperty(exports, "BaseOptions", { enumerable: true, get: function () { return base_options_class_1.BaseOptions; } });
-var comments_options_class_1 = require("./comments-options.class");
-Object.defineProperty(exports, "CommentsOptions", { enumerable: true, get: function () { return comments_options_class_1.CommentsOptions; } });
-var content_options_class_1 = require("./content-options.class");
-Object.defineProperty(exports, "ContentOptions", { enumerable: true, get: function () { return content_options_class_1.ContentOptions; } });
-var drafted_options_class_1 = require("./drafted-options.class");
-Object.defineProperty(exports, "DraftedOptions", { enumerable: true, get: function () { return drafted_options_class_1.DraftedOptions; } });
-var liked_by_options_class_1 = require("./liked-by-options.class");
-Object.defineProperty(exports, "LikedByOptions", { enumerable: true, get: function () { return liked_by_options_class_1.LikedByOptions; } });
-var viewed_by_options_class_1 = require("./viewed-by-options.class");
-Object.defineProperty(exports, "ViewedByOptions", { enumerable: true, get: function () { return viewed_by_options_class_1.ViewedByOptions; } });
+__exportStar(require("./base-options.class"), exports);
+__exportStar(require("./comments-options.class"), exports);
+__exportStar(require("./content-options.class"), exports);
+__exportStar(require("./drafted-options.class"), exports);
+__exportStar(require("./liked-by-options.class"), exports);
+__exportStar(require("./timestamps-options.class"), exports);
+__exportStar(require("./viewed-by-options.class"), exports);

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

@@ -1,6 +1,13 @@
+import { AccountsService } from '../../modules';
+import { IsLikeable } from '../../types';
 export declare function LikedByOptions<TBase extends new (...args: any[]) => any>(Base: TBase): {
     new (...args: any[]): {
         [x: string]: any;
         includeLikedBy?: boolean;
+        includeLikedByIds?: boolean;
     };
 } & TBase;
+export declare function populateLikedBy(options: {
+    includeLikedBy?: boolean;
+    includeLikedByIds?: boolean;
+}, items: IsLikeable[], accountsService: AccountsService): Promise<void>;