@mondaydotcomorg/monday-authorization 3.5.0-feat-shaime-support-entity-attributes-in-authorization-sdk-a98616f → 3.5.0-feat-shaime-support-entity-attributes-in-authorization-sdk-8d846f1

package/src/authorization-attributes-service.ts

@@ -1,150 +1,132 @@
 import chunk from 'lodash/chunk.js';
-import { Api, FetcherConfig, HttpClient } from '@mondaydotcomorg/trident-backend-api';
 import { getTopicAttributes, sendToSns } from '@mondaydotcomorg/monday-sns';
-import { HttpFetcherError, RecursivePartial } from '@mondaydotcomorg/monday-fetch-api';
 import {
   ResourceAttributeAssignment,
-  ResourceAttributeResponse,
   ResourceAttributesOperation,
   EntityAttributeAssignment,
-  EntityAttributeResponse,
-  ResourceType,
-  EntityType,
-  ResourceAttributeKeyType,
-  EntityAttributeKeyType,
+  EntityAttributesOperation,
+  ResourceAttributeOperationEnum,
+  EntityAttributeOperationEnum,
 } from './types/authorization-attributes-contracts';
-import { AuthorizationInternalService, logger } from './authorization-internal-service';
 import { Resource } from './types/general';
-import { getAttributionsFromApi } from './attributions-service';
+import { logger } from './authorization-internal-service';
 import {
   ASYNC_RESOURCE_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE,
+  ASYNC_ENTITY_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE,
   RESOURCE_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND,
+  ENTITY_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND,
   SNS_ARN_ENV_VAR_NAME,
   SNS_DEV_TEST_NAME,
 } from './constants/sns';
-import { APP_NAME, DEFAULT_FETCH_OPTIONS, ERROR_MESSAGES } from './constants';
 import type { TopicAttributesMap } from 'aws-sdk/clients/sns';
 
 export class AuthorizationAttributesService {
   private static LOG_TAG = 'authorization_attributes';
-  private static API_PATHS = {
-    UPSERT_RESOURCE_ATTRIBUTES: '/attributes/{accountId}/resource',
-    DELETE_RESOURCE_ATTRIBUTES: '/attributes/{accountId}/resource/{resourceType}/{resourceId}',
-    UPSERT_ENTITY_ATTRIBUTES: '/attributes/{accountId}/entity',
-    DELETE_ENTITY_ATTRIBUTES: '/attributes/{accountId}/entity/{entityType}/{entityId}',
-  } as const;
-  private httpClient: HttpClient;
-  private fetchOptions: RecursivePartial<FetcherConfig>;
   private snsArn: string;
 
   /**
    * Public constructor to create the AuthorizationAttributesService instance.
-   * @param httpClient The HTTP client to use for API requests, if not provided, the default HTTP client from Api will be used.
-   * @param fetchOptions The fetch options to use for API requests, if not provided, the default fetch options will be used.
    */
-  constructor(httpClient?: HttpClient, fetchOptions?: RecursivePartial<FetcherConfig>) {
-    if (!httpClient) {
-      httpClient = Api.getPart('httpClient');
-      if (!httpClient) {
-        throw new Error(ERROR_MESSAGES.HTTP_CLIENT_NOT_INITIALIZED);
-      }
-    }
-
-    if (!fetchOptions) {
-      fetchOptions = DEFAULT_FETCH_OPTIONS;
-    } else {
-      fetchOptions = {
-        ...DEFAULT_FETCH_OPTIONS,
-        ...fetchOptions,
-      };
-    }
-    this.httpClient = httpClient;
-    this.fetchOptions = fetchOptions;
+  constructor() {
     this.snsArn = AuthorizationAttributesService.getSnsTopicArn();
   }
 
   /**
-   * Upsert resource attributes synchronously, performing http call to the authorization MS to assign the given attributes to the given resource.
-   * @param accountId
-   * @param resourceAttributeAssignments - Array of resource (resourceType, resourceId) and attribute (key, value) pairs to upsert in the authorization MS.
-   * e.g. [{ resourceType: 'board', resourceId: 123, key: 'board_kind', value: 'private' }]
-   * @returns ResourceAttributeResponse - The affected (created and updated_ resource attributes assignments in the `attributes` field.
+   * Async function to upsert resource attributes using SNS.
+   * Sends the updates request to SNS and returns before the change actually took place.
+   * @param accountId The account ID
+   * @param appName App name of the calling app
+   * @param callerActionIdentifier Action identifier
+   * @param resourceAttributeAssignments Array of resource attribute assignments to upsert
+   * @return Promise with array of sent operations
    */
-  async upsertResourceAttributes(
+  async upsertResourceAttributesAsync(
     accountId: number,
+    appName: string,
+    callerActionIdentifier: string,
     resourceAttributeAssignments: ResourceAttributeAssignment[]
-  ): Promise<ResourceAttributeResponse> {
-    const attributionHeaders = getAttributionsFromApi();
-    try {
-      return await this.httpClient.fetch<ResourceAttributeResponse>(
-        {
-          url: {
-            appName: APP_NAME,
-            path: AuthorizationAttributesService.API_PATHS.UPSERT_RESOURCE_ATTRIBUTES.replace(
-              '{accountId}',
-              accountId.toString()
-            ),
-          },
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            ...attributionHeaders,
-          },
-          body: JSON.stringify({ resourceAttributeAssignments }),
-        },
-        this.fetchOptions
-      );
-    } catch (err) {
-      if (err instanceof HttpFetcherError) {
-        throw new Error(ERROR_MESSAGES.REQUEST_FAILED('upsertResourceAttributes', err.status, err.message));
-      }
-      throw err;
-    }
+  ): Promise<ResourceAttributesOperation[]> {
+    const operations: ResourceAttributesOperation[] = resourceAttributeAssignments.map(assignment => ({
+      ...assignment,
+      operationType: ResourceAttributeOperationEnum.UPSERT,
+    }));
+    return this.updateResourceAttributesAsync(accountId, appName, callerActionIdentifier, operations);
   }
 
   /**
-   * Delete resource attributes assignments synchronously, performing http call to the authorization MS to delete the given attributes from the given singular resource.
-   * @param accountId
-   * @param resource - The resource (resourceType, resourceId) to delete the attributes for.
-   * @param attributeKeys - Array of attribute keys to delete for the resource.
-   * @returns ResourceAttributeResponse - The affected (deleted) resource attributes assignments in the `attributes` field.
+   * Async function to delete resource attributes using SNS.
+   * Sends the updates request to SNS and returns before the change actually took place.
+   * @param accountId The account ID
+   * @param appName App name of the calling app
+   * @param callerActionIdentifier Action identifier
+   * @param resource The resource (resourceType, resourceId)
+   * @param attributeKeys Array of attribute keys to delete
+   * @return Promise with array of sent operations
    */
-  async deleteResourceAttributes(
+  async deleteResourceAttributesAsync(
     accountId: number,
+    appName: string,
+    callerActionIdentifier: string,
     resource: Resource,
     attributeKeys: string[]
-  ): Promise<ResourceAttributeResponse> {
-    const attributionHeaders = getAttributionsFromApi();
-    if (!resource.id) {
-      throw new Error('Resource ID is required');
-    }
-    try {
-      return await this.httpClient.fetch<ResourceAttributeResponse>(
-        {
-          url: {
-            appName: APP_NAME,
-            path: AuthorizationAttributesService.API_PATHS.DELETE_RESOURCE_ATTRIBUTES.replace(
-              '{accountId}',
-              accountId.toString()
-            )
-              .replace('{resourceType}', resource.type)
-              .replace('{resourceId}', resource.id.toString()),
-          },
-          method: 'DELETE',
-          headers: {
-            'Content-Type': 'application/json',
-            ...attributionHeaders,
-          },
-          body: JSON.stringify({ keys: attributeKeys }),
-        },
-        this.fetchOptions
-      );
-    } catch (err) {
-      if (err instanceof HttpFetcherError) {
-        throw new Error(ERROR_MESSAGES.REQUEST_FAILED('deleteResourceAttributes', err.status, err.message));
-      }
-      throw err;
-    }
+  ): Promise<ResourceAttributesOperation[]> {
+    const operations: ResourceAttributesOperation[] = attributeKeys.map(key => ({
+      resourceType: resource.type,
+      resourceId: resource.id!,
+      key,
+      operationType: ResourceAttributeOperationEnum.DELETE,
+    }));
+    return this.updateResourceAttributesAsync(accountId, appName, callerActionIdentifier, operations);
+  }
+
+  /**
+   * Async function to upsert entity attributes using SNS.
+   * Sends the updates request to SNS and returns before the change actually took place.
+   * @param accountId The account ID
+   * @param appName App name of the calling app
+   * @param callerActionIdentifier Action identifier
+   * @param entityAttributeAssignments Array of entity attribute assignments to upsert
+   * @return Promise with array of sent operations
+   */
+  async upsertEntityAttributesAsync(
+    accountId: number,
+    appName: string,
+    callerActionIdentifier: string,
+    entityAttributeAssignments: EntityAttributeAssignment[]
+  ): Promise<EntityAttributesOperation[]> {
+    const operations: EntityAttributesOperation[] = entityAttributeAssignments.map(assignment => ({
+      ...assignment,
+      operationType: EntityAttributeOperationEnum.UPSERT,
+    }));
+    return this.updateEntityAttributesAsync(accountId, appName, callerActionIdentifier, operations);
+  }
+
+  /**
+   * Async function to delete entity attributes using SNS.
+   * Sends the updates request to SNS and returns before the change actually took place.
+   * @param accountId The account ID
+   * @param appName App name of the calling app
+   * @param callerActionIdentifier Action identifier
+   * @param entityType The entity type
+   * @param entityId The entity ID
+   * @param attributeKeys Array of attribute keys to delete
+   * @return Promise with array of sent operations
+   */
+  async deleteEntityAttributesAsync(
+    accountId: number,
+    appName: string,
+    callerActionIdentifier: string,
+    entityType: string,
+    entityId: number,
+    attributeKeys: string[]
+  ): Promise<EntityAttributesOperation[]> {
+    const operations: EntityAttributesOperation[] = attributeKeys.map(key => ({
+      entityType: entityType as any,
+      entityId,
+      key,
+      operationType: EntityAttributeOperationEnum.DELETE,
+    }));
+    return this.updateEntityAttributesAsync(accountId, appName, callerActionIdentifier, operations);
   }
 
   /**
@@ -166,13 +148,38 @@ export class AuthorizationAttributesService {
     const operationChucks = chunk(resourceAttributeOperations, ASYNC_RESOURCE_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE);
     for (const operationsChunk of operationChucks) {
       sendToSnsPromises.push(
-        this.sendSingleSnsMessage(topicArn, accountId, appName, callerActionIdentifier, operationsChunk)
+        this.sendSingleResourceSnsMessage(topicArn, accountId, appName, callerActionIdentifier, operationsChunk)
       );
     }
     return (await Promise.all(sendToSnsPromises)).flat();
   }
 
-  private async sendSingleSnsMessage(
+  /**
+   *  Async function, this function only send the updates request to SNS and return before the change actually took place
+   * @param accountId
+   * @param appName - App name of the calling app
+   * @param callerActionIdentifier - action identifier
+   * @param entityAttributeOperations - Array of operations to do on entity attributes.
+   * @return {Promise<EntityAttributesOperation[]>} Array of sent operations
+   *  */
+  async updateEntityAttributesAsync(
+    accountId: number,
+    appName: string,
+    callerActionIdentifier: string,
+    entityAttributeOperations: EntityAttributesOperation[]
+  ): Promise<EntityAttributesOperation[]> {
+    const topicArn: string = this.snsArn;
+    const sendToSnsPromises: Promise<EntityAttributesOperation[]>[] = [];
+    const operationChucks = chunk(entityAttributeOperations, ASYNC_ENTITY_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE);
+    for (const operationsChunk of operationChucks) {
+      sendToSnsPromises.push(
+        this.sendSingleEntitySnsMessage(topicArn, accountId, appName, callerActionIdentifier, operationsChunk)
+      );
+    }
+    return (await Promise.all(sendToSnsPromises)).flat();
+  }
+
+  private async sendSingleResourceSnsMessage(
     topicArn: string,
     accountId: number,
     appName: string,
@@ -200,6 +207,34 @@ export class AuthorizationAttributesService {
     }
   }
 
+  private async sendSingleEntitySnsMessage(
+    topicArn: string,
+    accountId: number,
+    appName: string,
+    callerActionIdentifier: string,
+    operations: EntityAttributesOperation[]
+  ): Promise<EntityAttributesOperation[]> {
+    const payload = {
+      kind: ENTITY_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND,
+      payload: {
+        accountId: accountId,
+        callerAppName: appName,
+        callerActionIdentifier: callerActionIdentifier,
+        operations: operations,
+      },
+    };
+    try {
+      await sendToSns(payload, topicArn);
+      return operations;
+    } catch (error) {
+      logger.error(
+        { error, tag: AuthorizationAttributesService.LOG_TAG },
+        'Authorization entity attributes async update: failed to send operations to SNS'
+      );
+      return [];
+    }
+  }
+
   private static getSnsTopicArn(): string {
     const arnFromEnv: string | undefined = process.env[SNS_ARN_ENV_VAR_NAME];
     if (arnFromEnv) {
@@ -239,318 +274,4 @@ export class AuthorizationAttributesService {
       return false;
     }
   }
-
-  /**
-   * Validates resource attribute assignments array
-   */
-  private static validateResourceAttributeAssignments(assignments: ResourceAttributeAssignment[]): void {
-    if (!Array.isArray(assignments)) {
-      throw new Error('resourceAttributeAssignments must be an array');
-    }
-    if (assignments.length === 0) {
-      throw new Error('resourceAttributeAssignments must contain at least 1 item');
-    }
-    if (assignments.length > 100) {
-      throw new Error('resourceAttributeAssignments must contain at most 100 items');
-    }
-    for (let i = 0; i < assignments.length; i++) {
-      const assignment = assignments[i];
-      if (!assignment.resourceId || typeof assignment.resourceId !== 'number') {
-        throw new Error(`resourceAttributeAssignments[${i}].resourceId is required and must be a number`);
-      }
-      if (!assignment.resourceType || typeof assignment.resourceType !== 'string') {
-        throw new Error(`resourceAttributeAssignments[${i}].resourceType is required and must be a string`);
-      }
-      if (!assignment.key || typeof assignment.key !== 'string') {
-        throw new Error(`resourceAttributeAssignments[${i}].key is required and must be a string`);
-      }
-      if (assignment.value === undefined || typeof assignment.value !== 'string') {
-        throw new Error(`resourceAttributeAssignments[${i}].value is required and must be a string`);
-      }
-    }
-  }
-
-  /**
-   * Validates entity attribute assignments array
-   */
-  private static validateEntityAttributeAssignments(assignments: EntityAttributeAssignment[]): void {
-    if (!Array.isArray(assignments)) {
-      throw new Error('entityAttributeAssignments must be an array');
-    }
-    if (assignments.length === 0) {
-      throw new Error('entityAttributeAssignments must contain at least 1 item');
-    }
-    if (assignments.length > 100) {
-      throw new Error('entityAttributeAssignments must contain at most 100 items');
-    }
-    for (let i = 0; i < assignments.length; i++) {
-      const assignment = assignments[i];
-      if (!assignment.entityId || typeof assignment.entityId !== 'number') {
-        throw new Error(`entityAttributeAssignments[${i}].entityId is required and must be a number`);
-      }
-      if (!assignment.entityType || typeof assignment.entityType !== 'string') {
-        throw new Error(`entityAttributeAssignments[${i}].entityType is required and must be a string`);
-      }
-      if (!assignment.key || typeof assignment.key !== 'string') {
-        throw new Error(`entityAttributeAssignments[${i}].key is required and must be a string`);
-      }
-      if (assignment.value === undefined || typeof assignment.value !== 'string') {
-        throw new Error(`entityAttributeAssignments[${i}].value is required and must be a string`);
-      }
-    }
-  }
-
-  /**
-   * Upsert resource attributes synchronously.
-   * Matches API endpoint: POST /attributes/:accountId/resource
-   * @param accountId The account ID
-   * @param resourceAttributeAssignments Array of ResourceAttributeAssignment objects (1-100 items)
-   * @returns Promise with response containing affected attributes
-   */
-  static async upsertResourceAttributesSync(
-    accountId: number,
-    resourceAttributeAssignments: ResourceAttributeAssignment[]
-  ): Promise<ResourceAttributeResponse> {
-    // Validate inputs
-    if (!Number.isInteger(accountId)) {
-      throw new Error(`accountId must be an integer, got: ${accountId}`);
-    }
-    AuthorizationAttributesService.validateResourceAttributeAssignments(resourceAttributeAssignments);
-
-    const httpClient = Api.getPart('httpClient');
-    if (!httpClient) {
-      throw new Error(ERROR_MESSAGES.HTTP_CLIENT_NOT_INITIALIZED);
-    }
-
-    const attributionHeaders = getAttributionsFromApi();
-    const path = AuthorizationAttributesService.API_PATHS.UPSERT_RESOURCE_ATTRIBUTES.replace(
-      '{accountId}',
-      accountId.toString()
-    );
-
-    try {
-      return await httpClient.fetch<ResourceAttributeResponse>(
-        {
-          url: {
-            appName: APP_NAME,
-            path,
-          },
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            ...attributionHeaders,
-          },
-          body: JSON.stringify({ resourceAttributeAssignments }),
-        },
-        {
-          timeout: AuthorizationInternalService.getRequestTimeout(),
-          retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
-        }
-      );
-    } catch (err) {
-      if (err instanceof HttpFetcherError) {
-        throw new Error(ERROR_MESSAGES.REQUEST_FAILED('upsertResourceAttributesSync', err.status, err.message));
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Delete resource attributes synchronously.
-   * Matches API endpoint: DELETE /attributes/:accountId/resource/:resourceType/:resourceId
-   * @param accountId The account ID
-   * @param resourceType The resource type
-   * @param resourceId The resource ID
-   * @param keys Array of attribute keys to delete
-   * @returns Promise with response containing affected attributes
-   */
-  static async deleteResourceAttributesSync(
-    accountId: number,
-    resourceType: ResourceType,
-    resourceId: number,
-    keys: ResourceAttributeKeyType[]
-  ): Promise<ResourceAttributeResponse> {
-    // Validate inputs
-    if (!Number.isInteger(accountId)) {
-      throw new Error(`accountId must be an integer, got: ${accountId}`);
-    }
-    if (!resourceType || typeof resourceType !== 'string') {
-      throw new Error(`resourceType must be a string, got: ${typeof resourceType}`);
-    }
-    if (!Number.isInteger(resourceId)) {
-      throw new Error(`resourceId must be an integer, got: ${resourceId}`);
-    }
-    if (!Array.isArray(keys)) {
-      throw new Error('keys must be an array');
-    }
-    if (keys.length === 0) {
-      throw new Error('keys must contain at least 1 item');
-    }
-
-    const httpClient = Api.getPart('httpClient');
-    if (!httpClient) {
-      throw new Error(ERROR_MESSAGES.HTTP_CLIENT_NOT_INITIALIZED);
-    }
-
-    const attributionHeaders = getAttributionsFromApi();
-    const path = AuthorizationAttributesService.API_PATHS.DELETE_RESOURCE_ATTRIBUTES.replace(
-      '{accountId}',
-      accountId.toString()
-    )
-      .replace('{resourceType}', resourceType)
-      .replace('{resourceId}', resourceId.toString());
-
-    try {
-      return await httpClient.fetch<ResourceAttributeResponse>(
-        {
-          url: {
-            appName: APP_NAME,
-            path,
-          },
-          method: 'DELETE',
-          headers: {
-            'Content-Type': 'application/json',
-            ...attributionHeaders,
-          },
-          body: JSON.stringify({ keys }),
-        },
-        {
-          timeout: AuthorizationInternalService.getRequestTimeout(),
-          retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
-        }
-      );
-    } catch (err) {
-      if (err instanceof HttpFetcherError) {
-        throw new Error(ERROR_MESSAGES.REQUEST_FAILED('deleteResourceAttributesSync', err.status, err.message));
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Upsert entity attributes synchronously.
-   * Matches API endpoint: POST /attributes/:accountId/entity
-   * @param accountId The account ID
-   * @param entityAttributeAssignments Array of EntityAttributeAssignment objects (1-100 items)
-   * @returns Promise with response containing affected attributes
-   */
-  static async upsertEntityAttributesSync(
-    accountId: number,
-    entityAttributeAssignments: EntityAttributeAssignment[]
-  ): Promise<EntityAttributeResponse> {
-    // Validate inputs
-    if (!Number.isInteger(accountId)) {
-      throw new Error(`accountId must be an integer, got: ${accountId}`);
-    }
-    AuthorizationAttributesService.validateEntityAttributeAssignments(entityAttributeAssignments);
-
-    const httpClient = Api.getPart('httpClient');
-    if (!httpClient) {
-      throw new Error(ERROR_MESSAGES.HTTP_CLIENT_NOT_INITIALIZED);
-    }
-
-    const attributionHeaders = getAttributionsFromApi();
-    const path = AuthorizationAttributesService.API_PATHS.UPSERT_ENTITY_ATTRIBUTES.replace(
-      '{accountId}',
-      accountId.toString()
-    );
-
-    try {
-      return await httpClient.fetch<EntityAttributeResponse>(
-        {
-          url: {
-            appName: APP_NAME,
-            path,
-          },
-          method: 'POST',
-          headers: {
-            'Content-Type': 'application/json',
-            ...attributionHeaders,
-          },
-          body: JSON.stringify({ entityAttributeAssignments }),
-        },
-        {
-          timeout: AuthorizationInternalService.getRequestTimeout(),
-          retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
-        }
-      );
-    } catch (err) {
-      if (err instanceof HttpFetcherError) {
-        throw new Error(ERROR_MESSAGES.REQUEST_FAILED('upsertEntityAttributesSync', err.status, err.message));
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Delete entity attributes synchronously.
-   * Matches API endpoint: DELETE /attributes/:accountId/entity/:entityType/:entityId
-   * @param accountId The account ID
-   * @param entityType The entity type
-   * @param entityId The entity ID
-   * @param keys Array of attribute keys to delete
-   * @returns Promise with response containing affected attributes
-   */
-  static async deleteEntityAttributesSync(
-    accountId: number,
-    entityType: EntityType,
-    entityId: number,
-    keys: EntityAttributeKeyType[]
-  ): Promise<EntityAttributeResponse> {
-    // Validate inputs
-    if (!Number.isInteger(accountId)) {
-      throw new Error(`accountId must be an integer, got: ${accountId}`);
-    }
-    if (!entityType || typeof entityType !== 'string') {
-      throw new Error(`entityType must be a string, got: ${typeof entityType}`);
-    }
-    if (!Number.isInteger(entityId)) {
-      throw new Error(`entityId must be an integer, got: ${entityId}`);
-    }
-    if (!Array.isArray(keys)) {
-      throw new Error('keys must be an array');
-    }
-    if (keys.length === 0) {
-      throw new Error('keys must contain at least 1 item');
-    }
-
-    const httpClient = Api.getPart('httpClient');
-    if (!httpClient) {
-      throw new Error(ERROR_MESSAGES.HTTP_CLIENT_NOT_INITIALIZED);
-    }
-
-    const attributionHeaders = getAttributionsFromApi();
-    const path = AuthorizationAttributesService.API_PATHS.DELETE_ENTITY_ATTRIBUTES.replace(
-      '{accountId}',
-      accountId.toString()
-    )
-      .replace('{entityType}', entityType)
-      .replace('{entityId}', entityId.toString());
-
-    try {
-      return await httpClient.fetch<EntityAttributeResponse>(
-        {
-          url: {
-            appName: APP_NAME,
-            path,
-          },
-          method: 'DELETE',
-          headers: {
-            'Content-Type': 'application/json',
-            ...attributionHeaders,
-          },
-          body: JSON.stringify({ keys }),
-        },
-        {
-          timeout: AuthorizationInternalService.getRequestTimeout(),
-          retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
-        }
-      );
-    } catch (err) {
-      if (err instanceof HttpFetcherError) {
-        throw new Error(ERROR_MESSAGES.REQUEST_FAILED('deleteEntityAttributesSync', err.status, err.message));
-      }
-      throw err;
-    }
-  }
 }

package/src/constants/sns.ts

@@ -2,4 +2,6 @@ export const SNS_ARN_ENV_VAR_NAME = 'SHARED_AUTHORIZATION_SNS_ENDPOINT_RESOURCE_
 export const SNS_DEV_TEST_NAME =
   'arn:aws:sns:us-east-1:000000000000:monday-authorization-resource-attributes-sns-local';
 export const RESOURCE_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND = 'resourceAttributeModification';
+export const ENTITY_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND = 'entityAttributeModification';
 export const ASYNC_RESOURCE_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE = 100;
+export const ASYNC_ENTITY_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE = 100;

package/src/types/authorization-attributes-contracts.ts

@@ -60,11 +60,22 @@ export interface ResourceAttributeDelete {
   key: string;
 }
 
+export interface EntityAttributeDelete {
+  entityType: EntityType;
+  entityId: number;
+  key: string;
+}
+
 export enum ResourceAttributeOperationEnum {
   UPSERT = 'upsert',
   DELETE = 'delete',
 }
 
+export enum EntityAttributeOperationEnum {
+  UPSERT = 'upsert',
+  DELETE = 'delete',
+}
+
 interface UpsertResourceAttributeOperation extends ResourceAttributeAssignment {
   operationType: ResourceAttributeOperationEnum.UPSERT;
 }
@@ -73,4 +84,13 @@ interface DeleteResourceAttributeOperation extends ResourceAttributeDelete {
   operationType: ResourceAttributeOperationEnum.DELETE;
 }
 
+interface UpsertEntityAttributeOperation extends EntityAttributeAssignment {
+  operationType: EntityAttributeOperationEnum.UPSERT;
+}
+
+interface DeleteEntityAttributeOperation extends EntityAttributeDelete {
+  operationType: EntityAttributeOperationEnum.DELETE;
+}
+
 export type ResourceAttributesOperation = UpsertResourceAttributeOperation | DeleteResourceAttributeOperation;
+export type EntityAttributesOperation = UpsertEntityAttributeOperation | DeleteEntityAttributeOperation;