itlab-internal-services 2.16.16 → 2.16.18

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

@@ -17,12 +17,12 @@ function TimestampsDocument(Base) {
     }
     __decorate([
         (0, swagger_1.ApiPropertyOptional)({ description: 'Date the item was created at' }),
-        (0, mongoose_1.Prop)({ type: Date, default: () => new Date() }),
+        (0, mongoose_1.Prop)({ type: Date }),
         __metadata("design:type", Date)
     ], TimestampsDocument.prototype, "createdAt", void 0);
     __decorate([
         (0, swagger_1.ApiPropertyOptional)({ description: 'Date the item was last updated at' }),
-        (0, mongoose_1.Prop)({ type: Date, default: () => new Date() }),
+        (0, mongoose_1.Prop)({ type: Date }),
         __metadata("design:type", Date)
     ], TimestampsDocument.prototype, "updatedAt", void 0);
     return TimestampsDocument;

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

@@ -14,6 +14,7 @@ exports.parseBaseOptions = parseBaseOptions;
 const swagger_1 = require("@nestjs/swagger");
 const class_validator_1 = require("class-validator");
 const transform_1 = require("../../transform");
+const optional_filter_class_1 = require("./optional-filter.class");
 class BaseOptions {
 }
 exports.BaseOptions = BaseOptions;
@@ -81,18 +82,18 @@ __decorate([
     __metadata("design:type", Number)
 ], BaseOptions.prototype, "limit", void 0);
 function parseBaseOptions(options, filterQuery, queryOptions) {
-    var _a, _b, _c, _d, _e, _f;
+    var _a, _b, _c, _d, _e;
     // 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) };
+    const idFilter = new optional_filter_class_1.OptionalFilter(options.id, options.ids);
+    if (idFilter.isActive)
+        filterQuery._id = { $in: idFilter.values };
     // 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 });
+    const sortField = (_a = options.sortField) !== null && _a !== void 0 ? _a : '_id';
+    const sortDirection = (_b = options.sortDirection) !== null && _b !== void 0 ? _b : -1;
+    (_c = queryOptions.sort) !== null && _c !== void 0 ? _c : (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);
+        (_d = queryOptions.limit) !== null && _d !== void 0 ? _d : (queryOptions.limit = options.limit);
     if (options.skip !== undefined)
-        (_f = queryOptions.skip) !== null && _f !== void 0 ? _f : (queryOptions.skip = options.skip);
+        (_e = queryOptions.skip) !== null && _e !== void 0 ? _e : (queryOptions.skip = options.skip);
 }

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

@@ -3,5 +3,7 @@ export * from './comments-options.class';
 export * from './content-options.class';
 export * from './drafted-options.class';
 export * from './liked-by-options.class';
+export * from './optional-filter.class';
+export * from './optional-time-range-filter.class';
 export * from './timestamps-options.class';
 export * from './viewed-by-options.class';

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

@@ -19,5 +19,7 @@ __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("./optional-filter.class"), exports);
+__exportStar(require("./optional-time-range-filter.class"), exports);
 __exportStar(require("./timestamps-options.class"), exports);
 __exportStar(require("./viewed-by-options.class"), exports);

package/dist/classes/fetch-options/optional-filter.class.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Represents an optional filter that may be provided as either a single value
+ * or multiple values. Normalizes all inputs into a deduplicated array for
+ * consistent downstream query usage.
+ *
+ * This abstraction separates filter presence from stored values, allowing
+ * consumers to detect whether filtering logic should be applied at all.
+ */
+export declare class OptionalFilter<T> {
+    private readonly singleValue;
+    private readonly multipleValues;
+    /**
+     * Internal storage for deduplicated filter values.
+     */
+    private readonly valueSet;
+    /**
+     * Creates an optional filter from either a single value or an array of values.
+     *
+     * @param singleValue - Optional single filter value.
+     * @param multipleValues - Optional array of filter values.
+     */
+    constructor(singleValue: T | undefined, multipleValues: T[] | undefined);
+    /**
+     * Whether this filter was explicitly provided by the caller.
+     *
+     * True if at least one value was supplied, even if the array is empty.
+     */
+    get isActive(): boolean;
+    /**
+     * Returns all deduplicated filter values as an array.
+     *
+     * Downstream logic can use this to build queries without worrying about
+     * whether the original input was a single value or multiple values.
+     */
+    get values(): T[];
+    /**
+     * Checks whether a specific value is included in this filter.
+     *
+     * @param value - The value to test for inclusion.
+     * @returns True if the value is present in the filter.
+     */
+    contains(value: T): boolean;
+}

package/dist/classes/fetch-options/optional-filter.class.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalFilter = void 0;
+/**
+ * Represents an optional filter that may be provided as either a single value
+ * or multiple values. Normalizes all inputs into a deduplicated array for
+ * consistent downstream query usage.
+ *
+ * This abstraction separates filter presence from stored values, allowing
+ * consumers to detect whether filtering logic should be applied at all.
+ */
+class OptionalFilter {
+    /**
+     * Creates an optional filter from either a single value or an array of values.
+     *
+     * @param singleValue - Optional single filter value.
+     * @param multipleValues - Optional array of filter values.
+     */
+    constructor(singleValue, multipleValues) {
+        this.singleValue = singleValue;
+        this.multipleValues = multipleValues;
+        // Normalize both inputs into a single iterable; deduplicate via Set
+        this.valueSet = new Set([...(singleValue !== undefined ? [singleValue] : []), ...(multipleValues !== null && multipleValues !== void 0 ? multipleValues : [])]);
+    }
+    /**
+     * Whether this filter was explicitly provided by the caller.
+     *
+     * True if at least one value was supplied, even if the array is empty.
+     */
+    get isActive() {
+        return this.singleValue !== undefined || this.multipleValues !== undefined;
+    }
+    /**
+     * Returns all deduplicated filter values as an array.
+     *
+     * Downstream logic can use this to build queries without worrying about
+     * whether the original input was a single value or multiple values.
+     */
+    get values() {
+        return Array.from(this.valueSet);
+    }
+    /**
+     * Checks whether a specific value is included in this filter.
+     *
+     * @param value - The value to test for inclusion.
+     * @returns True if the value is present in the filter.
+     */
+    contains(value) {
+        return this.valueSet.has(value);
+    }
+}
+exports.OptionalFilter = OptionalFilter;

package/dist/classes/fetch-options/optional-time-range-filter.class.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Represents an optional timestamp range filter that may or may not be
+ * provided by the caller.
+ *
+ * This abstraction separates filter presence from filter content, allowing
+ * query-building logic to reliably determine whether a range constraint
+ * should be applied.
+ */
+export declare class OptionalTimeRangeFilter {
+    private readonly minTimestamp;
+    private readonly maxTimestamp;
+    /**
+     * Creates an optional timestamp range filter.
+     *
+     * @param minTimestamp - Optional lower bound (inclusive).
+     * @param maxTimestamp - Optional upper bound (inclusive).
+     */
+    constructor(minTimestamp: number | undefined, maxTimestamp: number | undefined);
+    /**
+     * Whether this filter was explicitly provided by the caller.
+     *
+     * @returns True if at least one bound is defined.
+     */
+    get isActive(): boolean;
+    /**
+     * The MongoDB-compatible range query for this filter.
+     *
+     * Only defined bounds are included to avoid unintentionally constraining
+     * the query.
+     *
+     * @returns A range query object suitable for use in a filter expression.
+     */
+    get query(): {
+        $gte?: number;
+        $lte?: number;
+    };
+}

package/dist/classes/fetch-options/optional-time-range-filter.class.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OptionalTimeRangeFilter = void 0;
+/**
+ * Represents an optional timestamp range filter that may or may not be
+ * provided by the caller.
+ *
+ * This abstraction separates filter presence from filter content, allowing
+ * query-building logic to reliably determine whether a range constraint
+ * should be applied.
+ */
+class OptionalTimeRangeFilter {
+    /**
+     * Creates an optional timestamp range filter.
+     *
+     * @param minTimestamp - Optional lower bound (inclusive).
+     * @param maxTimestamp - Optional upper bound (inclusive).
+     */
+    constructor(minTimestamp, maxTimestamp) {
+        this.minTimestamp = minTimestamp;
+        this.maxTimestamp = maxTimestamp;
+    }
+    /**
+     * Whether this filter was explicitly provided by the caller.
+     *
+     * @returns True if at least one bound is defined.
+     */
+    get isActive() {
+        return this.minTimestamp !== undefined || this.maxTimestamp !== undefined;
+    }
+    /**
+     * The MongoDB-compatible range query for this filter.
+     *
+     * Only defined bounds are included to avoid unintentionally constraining
+     * the query.
+     *
+     * @returns A range query object suitable for use in a filter expression.
+     */
+    get query() {
+        const rangeQuery = {};
+        if (this.minTimestamp !== undefined)
+            rangeQuery.$gte = this.minTimestamp;
+        if (this.maxTimestamp !== undefined)
+            rangeQuery.$lte = this.maxTimestamp;
+        return rangeQuery;
+    }
+}
+exports.OptionalTimeRangeFilter = OptionalTimeRangeFilter;

package/dist/modules/services/base-http.service.js

@@ -110,18 +110,16 @@ class BaseHttpService {
     async fetchResourceCollection(endpoint, config = {}) {
         var _a;
         const ids = (_a = config.params) === null || _a === void 0 ? void 0 : _a.ids;
-        if (!(ids && (0, class_validator_1.isArray)(ids) && ids.length > 50)) {
-            return this.fetchResourceCollectionBatch(endpoint, config);
+        if (ids && Array.isArray(ids) && ids.length > 50) {
+            // Parallelize requests for each chunk; flatten the results into one array.
+            const batchPromises = (0, itlab_functions_1.createChunks)(ids, 50).map((chunk) => {
+                config.params.ids = chunk;
+                return this.fetchResourceCollectionBatch(endpoint, config);
+            });
+            const results = await Promise.all(batchPromises);
+            return results.flat();
         }
-        // Deduplicate and chunk IDs to avoid overloading downstream query limits.
-        const uniqueIds = Array.from(new Set(ids));
-        const idChunks = (0, itlab_functions_1.createChunks)(uniqueIds, 50);
-        // Parallelize requests for each chunk; flatten the results into one array.
-        const batchPromises = idChunks.map((chunk) => {
-            config.params.ids = chunk;
-            return this.fetchResourceCollectionBatch(endpoint, config);
-        });
-        return (await Promise.all(batchPromises)).flat();
+        return this.fetchResourceCollectionBatch(endpoint, config);
     }
     /**
      * Helper for fetching a batch (or full collection) of resources in a single request.

package/package.json

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