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

package/fesm2022/messaia-cdk.mjs

@@ -15015,72 +15015,39 @@ 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, showMessage = false) {
-        const options = this.withShowMessage(httpOptions, showMessage);
+    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, 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, showMessage = false) {
-        return await firstValueFrom(this.create(entity, path, httpOptions, true, showMessage));
+    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, showMessage = false) {
-        const options = this.withShowMessage(httpOptions, showMessage);
+    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, 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, showMessage = false) {
-        return await firstValueFrom(this.update(id, entity, path, httpOptions, true, showMessage));
+    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, showMessage = false) {
-        const options = this.withShowMessage(httpOptions, showMessage);
+    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 mergedHeaders = options?.headers instanceof HttpHeaders
             ? options.headers
@@ -15089,103 +15056,58 @@ class GenericService {
         /* 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, showMessage = false) {
-        return await firstValueFrom(this.patch(id, body, path, httpOptions, true, showMessage));
+    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, showMessage = false) {
-        const options = this.withShowMessage(httpOptions, showMessage);
+    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(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, showMessage = false) {
-        return await firstValueFrom(this.patchList(ids, body, path, httpOptions, true, showMessage));
+    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, showMessage = false) {
-        const options = this.withShowMessage(httpOptions, showMessage);
+    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}`, 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, showMessage = false) {
-        return await firstValueFrom(this.delete(id, path, httpOptions, true, showMessage));
+    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, showMessage = false) {
-        const options = this.withShowMessage(httpOptions, showMessage);
+    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, showMessage = false) {
-        return await firstValueFrom(this.deleteList(ids, path, httpOptions, true, showMessage));
+    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
@@ -15319,6 +15241,33 @@ class GenericService {
         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)