@mondaydotcomorg/monday-authorization 3.5.3-feat-shaime-support-entity-attributes-in-authorization-sdk-e355942 → 3.5.3-feat-shaime-support-entity-attributes-in-authorization-sdk-ade64f6

package/src/authorization-attributes-ms-service.ts

@@ -1,10 +1,14 @@
 import { Api, HttpClient } from '@mondaydotcomorg/trident-backend-api';
 import { signAuthorizationHeader } from '@mondaydotcomorg/monday-jwt';
-import { HttpFetcherError } from '@mondaydotcomorg/monday-fetch-api';
 import { z } from 'zod';
 import { ResourceAttributeAssignment } from './resource-attribute-assignment';
 import { EntityAttributeAssignment } from './entity-attribute-assignment';
-import { AttributeOperation, EntityType } from './types/authorization-attributes-contracts';
+import {
+  AttributeOperation,
+  EntityType,
+  ResourceAttributeOperation,
+  EntityAttributeOperation,
+} from './types/authorization-attributes-contracts';
 import { ArgumentError } from './errors/argument-error';
 import { AuthorizationInternalService, logger } from './authorization-internal-service';
 import { getAttributionsFromApi } from './attributions-service';
@@ -12,7 +16,6 @@ import { APP_NAME } from './constants';
 import { ValidationUtils } from './utils/validation';
 import { IAuthorizationAttributesService } from './types/authorization-attributes-service.interface';
 import { Resource } from './types/general';
-import { ResourceAttributeOperation, EntityAttributeOperation } from './types/authorization-attributes-contracts';
 const INTERNAL_APP_NAME = 'internal_ms';
 const UPSERT_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource';
 const DELETE_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource/{resourceType}/{resourceId}';
@@ -30,12 +33,297 @@ interface DeleteRequestBody {
 export class AuthorizationAttributesMsService implements IAuthorizationAttributesService {
   private static LOG_TAG = 'authorization_attributes_ms';
   private static httpClient: HttpClient | undefined = Api.getPart('httpClient');
+  /**
+   * Creates or updates resource attributes synchronously.
+   * @param accountId The account ID
+   * @param resourceAttributeAssignments Array of ResourceAttributeAssignment objects
+   * @returns Promise<void>
+   */
+  async upsertResourceAttributes(
+    accountId: number,
+    resourceAttributeAssignments: ResourceAttributeAssignment[],
+    _appName?: string,
+    _callerActionIdentifier?: string
+  ): Promise<void> {
+    return AuthorizationAttributesMsService.executeUpsertRequest(
+      accountId,
+      resourceAttributeAssignments,
+      UPSERT_RESOURCE_ATTRIBUTES_PATH,
+      'resourceAttributeAssignments',
+      ResourceAttributeAssignment,
+      'resource',
+      'upsertResourceAttributes'
+    );
+  }
+
+  /**
+   * Deletes specific attributes from a resource synchronously.
+   * @param accountId The account ID
+   * @param resource Object with resourceType (string) and resourceId (number)
+   * @param attributeKeys Array of attribute key strings to delete
+   * @returns Promise<void>
+   */
+  async deleteResourceAttributes(
+    accountId: number,
+    resource: Resource,
+    attributeKeys: string[],
+    _appName?: string,
+    _callerActionIdentifier?: string
+  ): Promise<void> {
+    // Validate resource object
+    if (!resource || typeof resource !== 'object') {
+      throw new ArgumentError('resource must be an object');
+    }
+    if (!resource.id) {
+      throw new ArgumentError('resource.id is required');
+    }
+    ValidationUtils.validateInteger(resource.id, 'resource.id');
+    ValidationUtils.validateString(resource.type, 'resource.type');
+
+    return AuthorizationAttributesMsService.executeDeleteRequest(
+      accountId,
+      DELETE_RESOURCE_ATTRIBUTES_PATH,
+      {
+        resourceType: resource.type,
+        resourceId: resource.id,
+      },
+      attributeKeys,
+      'resource',
+      'deleteResourceAttributesSync',
+      { resource }
+    );
+  }
+
+  /**
+   * Creates or updates entity attributes synchronously.
+   * @param accountId The account ID
+   * @param entityAttributeAssignments Array of EntityAttributeAssignment objects
+   * @returns Promise<void>
+   */
+  async upsertEntityAttributes(
+    accountId: number,
+    entityAttributeAssignments: EntityAttributeAssignment[],
+    _appName?: string,
+    _callerActionIdentifier?: string
+  ): Promise<void> {
+    return AuthorizationAttributesMsService.executeUpsertRequest(
+      accountId,
+      entityAttributeAssignments,
+      UPSERT_ENTITY_ATTRIBUTES_PATH,
+      'entityAttributeAssignments',
+      EntityAttributeAssignment,
+      'entity',
+      'upsertEntityAttributesSync'
+    );
+  }
+
+  /**
+   * Deletes specific attributes from an entity synchronously.
+   * @param accountId The account ID
+   * @param entityType The entity type
+   * @param entityId The entity ID
+   * @param attributeKeys Array of attribute key strings to delete
+   * @returns Promise<void>
+   */
+  async deleteEntityAttributes(
+    accountId: number,
+    entityType: EntityType | string,
+    entityId: number,
+    attributeKeys: string[],
+    _appName?: string,
+    _callerActionIdentifier?: string
+  ): Promise<void> {
+    if (!entityType || typeof entityType !== 'string' || entityType.trim() === '') {
+      throw new ArgumentError(`entityType must be a non-empty string, got: ${entityType}`);
+    }
+    ValidationUtils.validateInteger(entityId, 'entityId');
+
+    return AuthorizationAttributesMsService.executeDeleteRequest(
+      accountId,
+      DELETE_ENTITY_ATTRIBUTES_PATH,
+      {
+        entityType,
+        entityId,
+      },
+      attributeKeys,
+      'entity',
+      'deleteEntityAttributesSync',
+      { entityType, entityId }
+    );
+  }
+
+  /**
+   * Updates resource attributes (batch operations).
+   * Note: MS service does not support batch operations directly.
+   * This method processes operations sequentially using upsert/delete methods.
+   * @param accountId The account ID
+   * @param appName App name (required for interface compatibility, but not used in MS service)
+   * @param callerActionIdentifier Action identifier (required for interface compatibility, but not used in MS service)
+   * @param resourceAttributeOperations Array of operations to perform
+   * @returns Promise<ResourceAttributesOperation[]> Array of processed operations
+   */
+  async updateResourceAttributes(
+    accountId: number,
+    _appName: string,
+    _callerActionIdentifier: string,
+    resourceAttributeOperations: ResourceAttributeOperation[]
+  ): Promise<ResourceAttributeOperation[]> {
+    const processedOperations: ResourceAttributeOperation[] = [];
+
+    for (const operation of resourceAttributeOperations) {
+      if (operation.operationType === AttributeOperation.UPSERT) {
+        if (!operation.resourceId) {
+          throw new ArgumentError('resourceId is required for upsert operation');
+        }
+        await this.upsertResourceAttributes(accountId, [
+          new ResourceAttributeAssignment(
+            operation.resourceId,
+            operation.resourceType,
+            operation.key,
+            operation.value || ''
+          ),
+        ]);
+        processedOperations.push(operation);
+      } else if (operation.operationType === AttributeOperation.DELETE) {
+        if (!operation.resourceId) {
+          throw new ArgumentError('resourceId is required for delete operation');
+        }
+        await this.deleteResourceAttributes(
+          accountId,
+          {
+            type: operation.resourceType,
+            id: operation.resourceId,
+          },
+          [operation.key]
+        );
+        processedOperations.push(operation);
+      }
+    }
+
+    return processedOperations;
+  }
+
+  /**
+   * Updates entity attributes (batch operations).
+   * Note: MS service does not support batch operations directly.
+   * This method processes operations sequentially using upsert/delete methods.
+   * @param accountId The account ID
+   * @param appName App name (required for interface compatibility, but not used in MS service)
+   * @param callerActionIdentifier Action identifier (required for interface compatibility, but not used in MS service)
+   * @param entityAttributeOperations Array of operations to perform
+   * @returns Promise<EntityAttributesOperation[]> Array of processed operations
+   */
+  async updateEntityAttributes(
+    accountId: number,
+    _appName: string,
+    _callerActionIdentifier: string,
+    entityAttributeOperations: EntityAttributeOperation[]
+  ): Promise<EntityAttributeOperation[]> {
+    const processedOperations: EntityAttributeOperation[] = [];
+    for (const operation of entityAttributeOperations) {
+      if (operation.operationType === 'upsert') {
+        await this.upsertEntityAttributes(accountId, [
+          new EntityAttributeAssignment(operation.entityId, operation.entityType, operation.key, operation.value || ''),
+        ]);
+        processedOperations.push(operation);
+      } else if (operation.operationType === 'delete') {
+        await this.deleteEntityAttributes(accountId, operation.entityType, operation.entityId, [operation.key]);
+        processedOperations.push(operation);
+      }
+    }
+
+    return processedOperations;
+  }
 
   /**
-   * Resets the cached HTTP client (useful for testing)
+   * Replaces path template parameters with actual values
+   * @param template Path template with placeholders like {accountId}
+   * @param params Object with parameter names and values
+   * @returns Path with all placeholders replaced
    */
-  private static resetHttpClient(): void {
-    AuthorizationAttributesMsService.httpClient = undefined;
+  private static replacePathParams(template: string, params: Record<string, string | number>): string {
+    let path = template;
+    for (const [key, value] of Object.entries(params)) {
+      path = path.replace(`{${key}}`, String(value));
+    }
+    return path;
+  }
+
+  /**
+   * Generic helper for executing delete requests
+   */
+  private static async executeDeleteRequest(
+    accountId: number,
+    pathTemplate: string,
+    pathParams: Record<string, string | number>,
+    keys: string[],
+    logPrefix: string,
+    methodName: string,
+    context: Record<string, any> = {}
+  ): Promise<void> {
+    // Validate inputs
+    ValidationUtils.validateInteger(accountId, 'accountId');
+    ValidationUtils.validateArray(keys, 'attributeKeys');
+
+    if (!keys.length) {
+      logger.warn({ tag: this.LOG_TAG, accountId, ...pathParams }, `${methodName} called with empty keys array`);
+      return;
+    }
+
+    // Validate all keys are strings
+    ValidationUtils.validateStringArray(keys, 'attributeKeys');
+
+    // Build request body
+    const requestBody: DeleteRequestBody = {
+      keys,
+    };
+
+    if (!AuthorizationAttributesMsService.httpClient) {
+      throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
+    }
+    const path = AuthorizationAttributesMsService.replacePathParams(pathTemplate, { accountId, ...pathParams });
+    const headers = AuthorizationAttributesMsService.getRequestHeaders(accountId);
+
+    try {
+      logger.info(
+        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, ...pathParams, keys },
+        `Deleting ${logPrefix} attributes`
+      );
+
+      await AuthorizationAttributesMsService.httpClient.fetch(
+        {
+          url: {
+            appName: APP_NAME,
+            path,
+          },
+          method: 'DELETE',
+          headers,
+          body: JSON.stringify(requestBody),
+        },
+        {
+          timeout: AuthorizationInternalService.getRequestTimeout(),
+          retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
+        }
+      );
+
+      logger.info(
+        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, ...pathParams, keys },
+        `Successfully deleted ${logPrefix} attributes`
+      );
+    } catch (err) {
+      logger.error(
+        {
+          tag: AuthorizationAttributesMsService.LOG_TAG,
+          method: methodName,
+          accountId,
+          ...pathParams,
+          ...context,
+          error: err instanceof Error ? err.message : String(err),
+        },
+        `Failed in ${methodName}`
+      );
+      throw err;
+    }
   }
 
   /**
@@ -154,115 +442,57 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
     pathTemplate: string,
     requestBodyKey: 'resourceAttributeAssignments' | 'entityAttributeAssignments',
     assignmentClass: abstract new (...args: any[]) => T,
-    logPrefix: string,
-    methodName: string
-  ): Promise<void> {
-    // Validate inputs
-    ValidationUtils.validateInteger(accountId, 'accountId');
-    ValidationUtils.validateArray(assignments, 'assignments');
-
-    if (!assignments.length) {
-      logger.warn(
-        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId },
-        `${methodName} called with empty array`
-      );
-      return;
-    }
-
-    // Validate all assignments are instances of the correct class
-    AuthorizationAttributesMsService.validateMessages(assignments, assignmentClass);
-
-    const requestBody =
-      requestBodyKey === 'resourceAttributeAssignments'
-        ? { resourceAttributeAssignments: assignments }
-        : { entityAttributeAssignments: assignments };
-
-    if (!AuthorizationAttributesMsService.httpClient) {
-      throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
-    }
-    const path = AuthorizationAttributesMsService.replacePathParams(pathTemplate, { accountId });
-    const headers = AuthorizationAttributesMsService.getRequestHeaders(accountId);
-
-    try {
-      logger.info(
-        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, count: assignments.length },
-        `Upserting ${logPrefix} attributes`
-      );
-
-      await AuthorizationAttributesMsService.httpClient.fetch(
-        {
-          url: {
-            appName: APP_NAME,
-            path,
-          },
-          method: 'POST',
-          headers,
-          body: JSON.stringify(requestBody),
-        },
-        {
-          timeout: AuthorizationInternalService.getRequestTimeout(),
-          retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
-        }
-      );
-
-      logger.debug(
-        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, count: assignments.length },
-        `Successfully upserted ${logPrefix} attributes`
-      );
-    } catch (err) {
-      const error = err as Error;
-      logger.error(
-        {
-          tag: AuthorizationAttributesMsService.LOG_TAG,
-          method: methodName,
-          accountId,
-          error: error instanceof Error ? error.message : String(error),
-        },
-        `Failed in ${methodName}`
-      );
-      throw error;
-    }
-  }
-
-  /**
-   * Generic helper for executing delete requests
-   */
-  private static async executeDeleteRequest(
-    accountId: number,
-    pathTemplate: string,
-    pathParams: Record<string, string | number>,
-    keys: string[],
-    logPrefix: string,
-    methodName: string,
-    context: Record<string, any> = {}
+    logPrefix: string,
+    methodName: string
   ): Promise<void> {
     // Validate inputs
     ValidationUtils.validateInteger(accountId, 'accountId');
-    ValidationUtils.validateArray(keys, 'attributeKeys');
+    ValidationUtils.validateArray(assignments, 'assignments');
 
-    if (!keys.length) {
-      logger.warn({ tag: this.LOG_TAG, accountId, ...pathParams }, `${methodName} called with empty keys array`);
+    if (!assignments.length) {
+      logger.warn(
+        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId },
+        `${methodName} called with empty array`
+      );
       return;
     }
 
-    // Validate all keys are strings
-    ValidationUtils.validateStringArray(keys, 'attributeKeys');
+    // Validate all assignments are instances of the correct class
+    AuthorizationAttributesMsService.validateMessages(assignments, assignmentClass);
+    const compatibileAssignments = assignments.map(assignment => {
+      if (assignment instanceof ResourceAttributeAssignment) {
+        return {
+          resourceId: assignment.resourceId,
+          resourceType: assignment.resourceType,
+          key: assignment.attributeKey,
+          value: assignment.attributeValue,
+        };
+      } else {
+        return {
+          entityId: assignment.entityId,
+          entityType: assignment.entityType,
+          key: assignment.attributeKey,
+          value: assignment.attributeValue,
+        };
+      }
+      return assignment;
+    });
 
-    // Build request body
-    const requestBody: DeleteRequestBody = {
-      keys,
-    };
+    const requestBody =
+      requestBodyKey === 'resourceAttributeAssignments'
+        ? { resourceAttributeAssignments: compatibileAssignments }
+        : { entityAttributeAssignments: compatibileAssignments };
 
     if (!AuthorizationAttributesMsService.httpClient) {
       throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
     }
-    const path = AuthorizationAttributesMsService.replacePathParams(pathTemplate, { accountId, ...pathParams });
+    const path = AuthorizationAttributesMsService.replacePathParams(pathTemplate, { accountId });
     const headers = AuthorizationAttributesMsService.getRequestHeaders(accountId);
 
     try {
       logger.info(
-        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, ...pathParams, keys },
-        `Deleting ${logPrefix} attributes`
+        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, count: assignments.length },
+        `Upserting ${logPrefix} attributes`
       );
 
       await AuthorizationAttributesMsService.httpClient.fetch(
@@ -271,7 +501,7 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
             appName: APP_NAME,
             path,
           },
-          method: 'DELETE',
+          method: 'POST',
           headers,
           body: JSON.stringify(requestBody),
         },
@@ -281,248 +511,21 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
         }
       );
 
-      logger.info(
-        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, ...pathParams, keys },
-        `Successfully deleted ${logPrefix} attributes`
+      logger.debug(
+        { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, count: assignments.length },
+        `Successfully upserted ${logPrefix} attributes`
       );
     } catch (err) {
-      const error = err as Error;
       logger.error(
         {
           tag: AuthorizationAttributesMsService.LOG_TAG,
           method: methodName,
           accountId,
-          ...pathParams,
-          ...context,
-          error: error instanceof Error ? error.message : String(error),
+          error: err instanceof Error ? err.message : String(err),
         },
         `Failed in ${methodName}`
       );
-      throw error;
-    }
-  }
-
-  /**
-   * Creates or updates resource attributes synchronously.
-   * @param accountId The account ID
-   * @param resourceAttributeAssignments Array of ResourceAttributeAssignment objects
-   * @returns Promise<void>
-   */
-  async upsertResourceAttributes(
-    accountId: number,
-    resourceAttributeAssignments: ResourceAttributeAssignment[],
-    _appName?: string,
-    _callerActionIdentifier?: string
-  ): Promise<void> {
-    return AuthorizationAttributesMsService.executeUpsertRequest(
-      accountId,
-      resourceAttributeAssignments,
-      UPSERT_RESOURCE_ATTRIBUTES_PATH,
-      'resourceAttributeAssignments',
-      ResourceAttributeAssignment,
-      'resource',
-      'upsertResourceAttributesSync'
-    );
-  }
-
-  /**
-   * Deletes specific attributes from a resource synchronously.
-   * @param accountId The account ID
-   * @param resource Object with resourceType (string) and resourceId (number)
-   * @param attributeKeys Array of attribute key strings to delete
-   * @returns Promise<void>
-   */
-  async deleteResourceAttributes(
-    accountId: number,
-    resource: Resource,
-    attributeKeys: string[],
-    _appName?: string,
-    _callerActionIdentifier?: string
-  ): Promise<void> {
-    // Validate resource object
-    if (!resource || typeof resource !== 'object') {
-      throw new ArgumentError('resource must be an object');
-    }
-    if (!resource.id) {
-      throw new ArgumentError('resource.id is required');
-    }
-    ValidationUtils.validateInteger(resource.id, 'resource.id');
-    ValidationUtils.validateString(resource.type, 'resource.type');
-
-    return AuthorizationAttributesMsService.executeDeleteRequest(
-      accountId,
-      DELETE_RESOURCE_ATTRIBUTES_PATH,
-      {
-        resourceType: resource.type,
-        resourceId: resource.id,
-      },
-      attributeKeys,
-      'resource',
-      'deleteResourceAttributesSync',
-      { resource }
-    );
-  }
-
-  /**
-   * Creates or updates entity attributes synchronously.
-   * @param accountId The account ID
-   * @param entityAttributeAssignments Array of EntityAttributeAssignment objects
-   * @returns Promise<void>
-   */
-  async upsertEntityAttributes(
-    accountId: number,
-    entityAttributeAssignments: EntityAttributeAssignment[],
-    _appName?: string,
-    _callerActionIdentifier?: string
-  ): Promise<void> {
-    return AuthorizationAttributesMsService.executeUpsertRequest(
-      accountId,
-      entityAttributeAssignments,
-      UPSERT_ENTITY_ATTRIBUTES_PATH,
-      'entityAttributeAssignments',
-      EntityAttributeAssignment,
-      'entity',
-      'upsertEntityAttributesSync'
-    );
-  }
-
-  /**
-   * Deletes specific attributes from an entity synchronously.
-   * @param accountId The account ID
-   * @param entityType The entity type
-   * @param entityId The entity ID
-   * @param attributeKeys Array of attribute key strings to delete
-   * @returns Promise<void>
-   */
-  async deleteEntityAttributes(
-    accountId: number,
-    entityType: EntityType | string,
-    entityId: number,
-    attributeKeys: string[],
-    _appName?: string,
-    _callerActionIdentifier?: string
-  ): Promise<void> {
-    if (!entityType || typeof entityType !== 'string' || entityType.trim() === '') {
-      throw new ArgumentError(`entityType must be a non-empty string, got: ${entityType}`);
-    }
-    ValidationUtils.validateInteger(entityId, 'entityId');
-
-    return AuthorizationAttributesMsService.executeDeleteRequest(
-      accountId,
-      DELETE_ENTITY_ATTRIBUTES_PATH,
-      {
-        entityType,
-        entityId,
-      },
-      attributeKeys,
-      'entity',
-      'deleteEntityAttributesSync',
-      { entityType, entityId }
-    );
-  }
-
-  /**
-   * Updates resource attributes (batch operations).
-   * Note: MS service does not support batch operations directly.
-   * This method processes operations sequentially using upsert/delete methods.
-   * @param accountId The account ID
-   * @param appName App name (required for interface compatibility, but not used in MS service)
-   * @param callerActionIdentifier Action identifier (required for interface compatibility, but not used in MS service)
-   * @param resourceAttributeOperations Array of operations to perform
-   * @returns Promise<ResourceAttributesOperation[]> Array of processed operations
-   */
-  async updateResourceAttributes(
-    accountId: number,
-    _appName: string,
-    _callerActionIdentifier: string,
-    resourceAttributeOperations: ResourceAttributeOperation[]
-  ): Promise<ResourceAttributeOperation[]> {
-    const processedOperations: ResourceAttributeOperation[] = [];
-
-    for (const operation of resourceAttributeOperations) {
-      if (operation.operationType === AttributeOperation.UPSERT) {
-        if (!operation.resourceId) {
-          throw new ArgumentError('resourceId is required for upsert operation');
-        }
-        await this.upsertResourceAttributes(accountId, [
-          new ResourceAttributeAssignment(
-            operation.resourceId,
-            operation.resourceType,
-            operation.key,
-            operation.value || ''
-          ),
-        ]);
-        processedOperations.push(operation);
-      } else if (operation.operationType === AttributeOperation.DELETE) {
-        if (!operation.resourceId) {
-          throw new ArgumentError('resourceId is required for delete operation');
-        }
-        await this.deleteResourceAttributes(
-          accountId,
-          {
-            type: operation.resourceType,
-            id: operation.resourceId,
-          },
-          [operation.key]
-        );
-        processedOperations.push(operation);
-      }
-    }
-
-    return processedOperations;
-  }
-
-  /**
-   * Updates entity attributes (batch operations).
-   * Note: MS service does not support batch operations directly.
-   * This method processes operations sequentially using upsert/delete methods.
-   * @param accountId The account ID
-   * @param appName App name (required for interface compatibility, but not used in MS service)
-   * @param callerActionIdentifier Action identifier (required for interface compatibility, but not used in MS service)
-   * @param entityAttributeOperations Array of operations to perform
-   * @returns Promise<EntityAttributesOperation[]> Array of processed operations
-   */
-  async updateEntityAttributes(
-    accountId: number,
-    _appName: string,
-    _callerActionIdentifier: string,
-    entityAttributeOperations: EntityAttributeOperation[]
-  ): Promise<EntityAttributeOperation[]> {
-    const processedOperations: EntityAttributeOperation[] = [];
-    for (const operation of entityAttributeOperations) {
-      if (operation.operationType === 'upsert') {
-        const upsertOp = operation as any;
-        await this.upsertEntityAttributes(accountId, [
-          new EntityAttributeAssignment(
-            operation.entityId,
-            operation.entityType as string,
-            operation.key,
-            upsertOp.value || ''
-          ),
-        ]);
-        processedOperations.push(operation);
-      } else if (operation.operationType === 'delete') {
-        await this.deleteEntityAttributes(accountId, operation.entityType as EntityType, operation.entityId, [
-          operation.key,
-        ]);
-        processedOperations.push(operation);
-      }
+      throw err;
     }
-
-    return processedOperations;
-  }
-
-  /**
-   * Replaces path template parameters with actual values
-   * @param template Path template with placeholders like {accountId}
-   * @param params Object with parameter names and values
-   * @returns Path with all placeholders replaced
-   */
-  private static replacePathParams(template: string, params: Record<string, string | number>): string {
-    let path = template;
-    for (const [key, value] of Object.entries(params)) {
-      path = path.replace(`{${key}}`, String(value));
-    }
-    return path;
   }
 }