@messaia/cdk 22.0.1-rc.7 → 22.0.1-rc.9

package/fesm2022/messaia-cdk.mjs

@@ -14903,8 +14903,15 @@ class GenericService {
      * @param observeResponse Whether to observe the full response (default: false)
      */
     get(id, params, headers, handleError = true, observeResponse = false) {
+        /* Normalize the 'projection' parameter in query parameters */
+        const parsedParams = this.normalizeProjectionParam(params);
+        /* Make the HTTP GET request */
         let request = this.http
-            .get(`${this.endpoint}/${id}`, { observe: (observeResponse ? 'response' : 'body'), params: Utils.toHttpParams(params), headers: this.toHttpHeaders(headers) });
+            .get(`${this.endpoint}/${id}`, {
+            observe: (observeResponse ? 'response' : 'body'),
+            params: parsedParams instanceof HttpParams ? parsedParams : Utils.toHttpParams(parsedParams),
+            headers: this.toHttpHeaders(headers)
+        });
         /* Handle error */
         if (handleError) {
             request = request.pipe(catchError(this.handleError('get')));
@@ -14928,6 +14935,7 @@ class GenericService {
      * @param handleError Whether to handle errors (default: true)
      */
     count(params, path, headers, handleError = true) {
+        /* Make the HTTP GET request to count entities */
         let request = this.http
             .get(`${this.endpoint}${path ? path : '/count'}`, { params: Utils.toHttpParams(params), headers: this.toHttpHeaders(headers) });
         /* Handle error */
@@ -14953,6 +14961,7 @@ class GenericService {
      * @returns Observable with the response data
      */
     getList(params, path, headers) {
+        /* Normalize the 'projection' parameter in query parameters */
         const parsedParams = this.normalizeProjectionParam(params);
         return this.http
             .get(`${this.endpoint}${path ? path : ''}`, {
@@ -15006,177 +15015,99 @@ class GenericService {
     getListAsObservable() {
         return this.list.asObservable();
     }
-    /**
-     * Creates a new entity
-     * @param entity The entity to create
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @param handleError Whether to handle errors (default: true)
-     */
-    create(entity, path, httpOptions, handleError = true) {
+    create(entity, path, optionsOrHttpOptions, handleError = true, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, handleError, showMessage);
+        const options = this.withShowMessage(resolved.httpOptions, resolved.showMessage);
         let request = this.http
-            .post(`${this.endpoint}${path ? path : ''}`, entity, httpOptions);
+            .post(`${this.endpoint}${path ? path : ''}`, entity, options);
         /* Handle error */
-        if (handleError) {
+        if (resolved.handleError) {
             request = request.pipe(catchError(this.handleError('create')));
         }
         return request;
     }
-    /**
-     * Asynchronously creates a new entity
-     * @param entity The entity to create
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @returns Promise resolving to the created entity
-     */
-    async createAsync(entity, path, httpOptions) {
-        return await firstValueFrom(this.create(entity, path, httpOptions));
+    async createAsync(entity, path, optionsOrHttpOptions, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, true, showMessage);
+        return await firstValueFrom(this.create(entity, path, resolved.httpOptions, resolved.handleError, resolved.showMessage));
     }
-    /**
-     * Updates an existing entity asynchronously
-     * @param id The ID of the entity to update
-     * @param entity The updated entity data
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @param handleError Whether to handle errors (default: true)
-     */
-    update(id, entity, path, httpOptions, handleError = true) {
+    update(id, entity, path, optionsOrHttpOptions, handleError = true, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, handleError, showMessage);
+        const options = this.withShowMessage(resolved.httpOptions, resolved.showMessage);
         let request = this.http
-            .put(`${this.endpoint}${path ? path : ''}/${id}`, entity, httpOptions);
+            .put(`${this.endpoint}${path ? path : ''}/${id}`, entity, options);
         /* Handle error */
-        if (handleError) {
+        if (resolved.handleError) {
             request = request.pipe(catchError(this.handleError('update')));
         }
         return request;
     }
-    /**
-     * Asynchronously updates an existing entity
-     * @param id The ID of the entity to update
-     * @param entity The updated entity data
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @returns Promise resolving to the updated entity
-     */
-    async updateAsync(id, entity, path, httpOptions) {
-        return await firstValueFrom(this.update(id, entity, path, httpOptions));
+    async updateAsync(id, entity, path, optionsOrHttpOptions, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, true, showMessage);
+        return await firstValueFrom(this.update(id, entity, path, resolved.httpOptions, resolved.handleError, resolved.showMessage));
     }
-    /**
-     * Applies a JSON Patch to an entity
-     * @param id The ID of the item to patch
-     * @param body The patch body
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @param handleError Whether to handle errors (default: true)
-     */
-    patch(id, body, path, httpOptions, handleError = true) {
+    patch(id, body, path, optionsOrHttpOptions, handleError = true, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, handleError, showMessage);
+        const options = this.withShowMessage(resolved.httpOptions, resolved.showMessage) || {};
         /* Ensure correct content-type for patch */
-        const headers = new HttpHeaders({
-            'Content-Type': 'application/json-patch+json'
-        });
-        /* Merge headers */
-        const options = {
-            ...httpOptions,
-            headers: httpOptions?.headers
-                ? httpOptions.headers.append('Content-Type', 'application/json-patch+json')
-                : headers
-        };
+        const mergedHeaders = options?.headers instanceof HttpHeaders
+            ? options.headers
+            : this.toHttpHeaders(options?.headers);
+        options.headers = mergedHeaders.set('Content-Type', 'application/json-patch+json');
         /* Create request */
         let request = this.http.patch(`${this.endpoint}${path ? path : ''}/${id}`, body, options);
         /* Handle error */
-        if (handleError) {
+        if (resolved.handleError) {
             request = request.pipe(catchError(this.handleError('patch')));
         }
         return request;
     }
-    /**
-     * Asynchronously applies a JSON Patch to an entity
-     * @param id The ID of the item to patch
-     * @param body The patch body
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @returns Promise resolving to the patched entity
-     */
-    async patchAsync(id, body, path, httpOptions) {
-        return await firstValueFrom(this.patch(id, body, path, httpOptions));
+    async patchAsync(id, body, path, optionsOrHttpOptions, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, true, showMessage);
+        return await firstValueFrom(this.patch(id, body, path, resolved.httpOptions, resolved.handleError, resolved.showMessage));
     }
-    /**
-     * Applies a JSON Patch to multiple entities
-     * @param ids The IDs of the items to patch
-     * @param body The patch body
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @param handleError Whether to handle errors (default: true)
-     */
-    patchList(ids, body, path, httpOptions, handleError = true) {
+    patchList(ids, body, path, optionsOrHttpOptions, handleError = true, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, handleError, showMessage);
+        const options = this.withShowMessage(resolved.httpOptions, resolved.showMessage);
         let request = this.http
-            .patch(`${this.endpoint}${path ? path : ''}`, body, Object.assign(httpOptions || {}, { params: Utils.toHttpParams({ ids: ids }) }));
+            .patch(`${this.endpoint}${path ? path : ''}`, body, Object.assign(options || {}, { params: Utils.toHttpParams({ ids: ids }) }));
         /* Handle error */
-        if (handleError) {
+        if (resolved.handleError) {
             request = request.pipe(catchError(this.handleError('patch')));
         }
         return request;
     }
-    /**
-     * Asynchronously applies a JSON Patch to multiple entities
-     * @param ids The IDs of the items to patch
-     * @param body The patch body
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @returns Promise resolving to the patched entities
-     */
-    async patchListAsync(ids, body, path, httpOptions) {
-        return await firstValueFrom(this.patchList(ids, body, path, httpOptions));
+    async patchListAsync(ids, body, path, optionsOrHttpOptions, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, true, showMessage);
+        return await firstValueFrom(this.patchList(ids, body, path, resolved.httpOptions, resolved.handleError, resolved.showMessage));
     }
-    /**
-     * Deletes an entity by ID
-     * @param id The ID of the item to delete
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @param handleError Whether to handle errors (default: true)
-     */
-    delete(id, path, httpOptions, handleError = true) {
+    delete(id, path, optionsOrHttpOptions, handleError = true, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, handleError, showMessage);
+        const options = this.withShowMessage(resolved.httpOptions, resolved.showMessage);
         let request = this.http
-            .delete(`${this.endpoint}${path ? path : ''}/${id}`, httpOptions);
+            .delete(`${this.endpoint}${path ? path : ''}/${id}`, options);
         /* Handle error */
-        if (handleError) {
+        if (resolved.handleError) {
             request = request.pipe(catchError(this.handleError('delete')));
         }
         return request;
     }
-    /**
-     * Asynchronously deletes an entity by ID
-     * @param id The ID of the item to delete
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @returns Promise resolving to the delete result
-     */
-    async deleteAsync(id, path, httpOptions) {
-        return await firstValueFrom(this.delete(id, path, httpOptions));
+    async deleteAsync(id, path, optionsOrHttpOptions, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, true, showMessage);
+        return await firstValueFrom(this.delete(id, path, resolved.httpOptions, resolved.handleError, resolved.showMessage));
     }
-    /**
-     * Deletes multiple entities by IDs
-     * @param ids The IDs of the items to delete
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @param handleError Whether to handle errors (default: true)
-     */
-    deleteList(ids, path, httpOptions, handleError = true) {
-        let request = this.http.delete(`${this.endpoint}${path ? path : ''}`, Object.assign(httpOptions || {}, { params: Utils.toHttpParams({ ids: ids }) }));
+    deleteList(ids, path, optionsOrHttpOptions, handleError = true, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, handleError, showMessage);
+        const options = this.withShowMessage(resolved.httpOptions, resolved.showMessage);
+        let request = this.http.delete(`${this.endpoint}${path ? path : ''}`, Object.assign(options || {}, { params: Utils.toHttpParams({ ids: ids }) }));
         /* Handle error */
-        if (handleError) {
+        if (resolved.handleError) {
             request = request.pipe(catchError(this.handleError('deleteList')));
         }
         return request;
     }
-    /**
-     * Asynchronously deletes multiple entities by IDs
-     * @param ids The IDs of the items to delete
-     * @param path Optional relative path to the action
-     * @param httpOptions Optional HTTP options (headers, etc.)
-     * @returns Promise resolving to the delete result
-     */
-    async deleteListAsync(ids, path, httpOptions) {
-        return await firstValueFrom(this.deleteList(ids, path, httpOptions));
+    async deleteListAsync(ids, path, optionsOrHttpOptions, showMessage = false) {
+        const resolved = this.resolveMutationOptions(optionsOrHttpOptions, true, showMessage);
+        return await firstValueFrom(this.deleteList(ids, path, resolved.httpOptions, resolved.handleError, resolved.showMessage));
     }
     /**
      * Downloads a file from the server
@@ -15214,16 +15145,16 @@ class GenericService {
      * Duplicates a record by ID
      * @param id The ID of the record to duplicate
      */
-    duplicate(id) {
-        return this.create(null, `/duplicate/${id}`);
+    duplicate(id, showMessage = false) {
+        return this.create(null, `/duplicate/${id}`, undefined, true, showMessage);
     }
     /**
      * Asynchronously duplicates a record by ID
      * @param id The ID of the record to duplicate
      * @returns Promise resolving to the duplicated record
      */
-    async duplicateAsync(id) {
-        return await firstValueFrom(this.duplicate(id));
+    async duplicateAsync(id, showMessage = false) {
+        return await firstValueFrom(this.duplicate(id, showMessage));
     }
     /**
      * Uploads a file to the server
@@ -15291,6 +15222,52 @@ class GenericService {
             .filter(key => body[key] != null && body[key] != '')
             .reduce((p, key) => p.set(key, body[key]), new HttpHeaders());
     }
+    /**
+     * Adds the Show-Message header to request options when enabled
+     * @param httpOptions Existing HTTP options
+     * @param showMessage Whether to add the Show-Message header
+     * @returns HTTP options with optional Show-Message header
+     */
+    withShowMessage(httpOptions, showMessage = false) {
+        if (!showMessage) {
+            return httpOptions;
+        }
+        /* Create a copy of the httpOptions to avoid mutating the original object */
+        const options = { ...(httpOptions || {}) };
+        const headers = options.headers instanceof HttpHeaders
+            ? options.headers
+            : this.toHttpHeaders(options.headers);
+        /* Set the Show-Message header to 'Yes' */
+        options.headers = headers.set('Show-Message', 'Yes');
+        return options;
+    }
+    /**
+     * Normalizes legacy mutation arguments and options-object overload arguments
+     * @param optionsOrHttpOptions Legacy httpOptions or options object
+     * @param handleError Legacy handleError value
+     * @param showMessage Legacy showMessage value
+     * @returns Normalized mutation options
+     */
+    resolveMutationOptions(optionsOrHttpOptions, handleError = true, showMessage = false) {
+        if (optionsOrHttpOptions && typeof optionsOrHttpOptions === 'object') {
+            const options = optionsOrHttpOptions;
+            /* Interpret as options-object overload only when one of its dedicated keys exists */
+            if (Object.prototype.hasOwnProperty.call(options, 'httpOptions') ||
+                Object.prototype.hasOwnProperty.call(options, 'handleError') ||
+                Object.prototype.hasOwnProperty.call(options, 'showMessage')) {
+                return {
+                    httpOptions: options.httpOptions ?? {},
+                    handleError: options.handleError ?? true,
+                    showMessage: options.showMessage ?? false
+                };
+            }
+        }
+        return {
+            httpOptions: optionsOrHttpOptions ?? {},
+            handleError,
+            showMessage
+        };
+    }
     /**
      * Normalizes the 'projection' parameter in query parameters
      * @param params The query parameters (HttpParams or object)