@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-ms-service.ts

@@ -2,6 +2,11 @@ import { Api } from '@mondaydotcomorg/trident-backend-api';
 import { signAuthorizationHeader } from '@mondaydotcomorg/monday-jwt';
 import { HttpFetcherError } from '@mondaydotcomorg/monday-fetch-api';
 import { ResourceAttributeAssignment } from './resource-attribute-assignment';
+import {
+  EntityAttributeAssignment,
+  EntityType,
+  EntityAttributeKeyType,
+} from './types/authorization-attributes-contracts';
 import { ArgumentError } from './errors/argument-error';
 import { AuthorizationInternalService, logger } from './authorization-internal-service';
 import { getAttributionsFromApi } from './attributions-service';
@@ -10,6 +15,8 @@ import { APP_NAME } from './constants';
 const INTERNAL_APP_NAME = 'internal_ms';
 const UPSERT_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource';
 const DELETE_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource/{resourceType}/{resourceId}';
+const UPSERT_ENTITY_ATTRIBUTES_PATH = '/attributes/{accountId}/entity';
+const DELETE_ENTITY_ATTRIBUTES_PATH = '/attributes/{accountId}/entity/{entityType}/{entityId}';
 
 interface Resource {
   resourceType: string;
@@ -25,6 +32,15 @@ interface UpsertRequestBody {
   }[];
 }
 
+interface UpsertEntityRequestBody {
+  entityAttributeAssignments: {
+    entityId: number;
+    entityType: string;
+    key: string;
+    value: string;
+  }[];
+}
+
 interface DeleteRequestBody {
   keys: string[];
 }
@@ -319,4 +335,234 @@ export class AuthorizationAttributesMsService {
       throw err;
     }
   }
+
+  /**
+   * Creates or updates entity attributes synchronously.
+   * @param accountId The account ID
+   * @param entityAttributeAssignments Array of EntityAttributeAssignment objects
+   * @returns Promise<void>
+   */
+  static async upsertEntityAttributesSync(
+    accountId: number,
+    entityAttributeAssignments: EntityAttributeAssignment[]
+  ): Promise<void> {
+    // Skip HTTP requests in test environment
+    if (process.env.NODE_ENV === 'test') {
+      logger.debug(
+        { tag: this.LOG_TAG, accountId, count: entityAttributeAssignments.length },
+        'Skipping upsertEntityAttributesSync in test environment'
+      );
+      return;
+    }
+
+    // Validate inputs
+    if (!Number.isInteger(accountId)) {
+      throw new ArgumentError(`accountId must be an integer, got: ${accountId}`);
+    }
+
+    if (!Array.isArray(entityAttributeAssignments)) {
+      throw new ArgumentError('entityAttributeAssignments must be an array');
+    }
+
+    if (entityAttributeAssignments.length === 0) {
+      logger.warn({ tag: this.LOG_TAG, accountId }, 'upsertEntityAttributesSync called with empty array');
+      return;
+    }
+
+    // Validate each assignment
+    for (let i = 0; i < entityAttributeAssignments.length; i++) {
+      const assignment = entityAttributeAssignments[i];
+      if (!assignment.entityId || typeof assignment.entityId !== 'number') {
+        throw new ArgumentError(`entityAttributeAssignments[${i}].entityId is required and must be a number`);
+      }
+      if (!assignment.entityType || typeof assignment.entityType !== 'string') {
+        throw new ArgumentError(`entityAttributeAssignments[${i}].entityType is required and must be a string`);
+      }
+      if (!assignment.key || typeof assignment.key !== 'string') {
+        throw new ArgumentError(`entityAttributeAssignments[${i}].key is required and must be a string`);
+      }
+      if (assignment.value === undefined || typeof assignment.value !== 'string') {
+        throw new ArgumentError(`entityAttributeAssignments[${i}].value is required and must be a string`);
+      }
+    }
+
+    // Build request body
+    const requestBody: UpsertEntityRequestBody = {
+      entityAttributeAssignments: entityAttributeAssignments.map(assignment => ({
+        entityId: assignment.entityId,
+        entityType: assignment.entityType,
+        key: assignment.key,
+        value: assignment.value,
+      })),
+    };
+
+    const httpClient = Api.getPart('httpClient');
+    if (!httpClient) {
+      throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
+    }
+    const path = UPSERT_ENTITY_ATTRIBUTES_PATH.replace('{accountId}', accountId.toString());
+    const headers = this.getRequestHeaders(accountId);
+
+    try {
+      logger.info(
+        { tag: this.LOG_TAG, accountId, count: entityAttributeAssignments.length },
+        'Upserting entity attributes'
+      );
+
+      await httpClient.fetch(
+        {
+          url: {
+            appName: APP_NAME,
+            path,
+          },
+          method: 'POST',
+          headers,
+          body: JSON.stringify(requestBody),
+        },
+        {
+          timeout: AuthorizationInternalService.getRequestTimeout(),
+          retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
+        }
+      );
+
+      logger.info(
+        { tag: this.LOG_TAG, accountId, count: entityAttributeAssignments.length },
+        'Successfully upserted entity attributes'
+      );
+    } catch (err) {
+      logger.error(
+        {
+          tag: this.LOG_TAG,
+          accountId,
+          method: 'upsertEntityAttributesSync',
+          error: err instanceof Error ? err.message : String(err),
+        },
+        'Failed to upsert entity attributes'
+      );
+
+      if (err instanceof HttpFetcherError) {
+        throw new Error(
+          `AuthorizationAttributesMsService: [upsertEntityAttributesSync] request failed with status ${err.status}: ${err.message}`
+        );
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * 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>
+   */
+  static async deleteEntityAttributesSync(
+    accountId: number,
+    entityType: EntityType,
+    entityId: number,
+    attributeKeys: EntityAttributeKeyType[]
+  ): Promise<void> {
+    // Skip HTTP requests in test environment
+    if (process.env.NODE_ENV === 'test') {
+      logger.debug(
+        { tag: this.LOG_TAG, accountId, entityType, entityId, attributeKeys },
+        'Skipping deleteEntityAttributesSync in test environment'
+      );
+      return;
+    }
+
+    // Validate inputs
+    if (!Number.isInteger(accountId)) {
+      throw new ArgumentError(`accountId must be an integer, got: ${accountId}`);
+    }
+
+    if (!entityType || typeof entityType !== 'string') {
+      throw new ArgumentError(`entityType must be a string, got: ${typeof entityType}`);
+    }
+
+    if (!Number.isInteger(entityId)) {
+      throw new ArgumentError(`entityId must be an integer, got: ${entityId}`);
+    }
+
+    if (!Array.isArray(attributeKeys)) {
+      throw new ArgumentError('attributeKeys must be an array');
+    }
+
+    if (attributeKeys.length === 0) {
+      logger.warn(
+        { tag: this.LOG_TAG, accountId, entityType, entityId },
+        'deleteEntityAttributesSync called with empty keys array'
+      );
+      return;
+    }
+
+    // Validate all keys are strings
+    for (let i = 0; i < attributeKeys.length; i++) {
+      if (typeof attributeKeys[i] !== 'string') {
+        throw new ArgumentError(`All attributeKeys must be strings, but item at index ${i} is not`);
+      }
+    }
+
+    // Build request body
+    const requestBody: DeleteRequestBody = {
+      keys: attributeKeys,
+    };
+
+    const httpClient = Api.getPart('httpClient');
+    if (!httpClient) {
+      throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
+    }
+    const path = DELETE_ENTITY_ATTRIBUTES_PATH.replace('{accountId}', accountId.toString())
+      .replace('{entityType}', entityType)
+      .replace('{entityId}', entityId.toString());
+    const headers = this.getRequestHeaders(accountId);
+
+    try {
+      logger.info(
+        { tag: this.LOG_TAG, accountId, entityType, entityId, keys: attributeKeys },
+        'Deleting entity attributes'
+      );
+
+      await httpClient.fetch(
+        {
+          url: {
+            appName: APP_NAME,
+            path,
+          },
+          method: 'DELETE',
+          headers,
+          body: JSON.stringify(requestBody),
+        },
+        {
+          timeout: AuthorizationInternalService.getRequestTimeout(),
+          retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
+        }
+      );
+
+      logger.info(
+        { tag: this.LOG_TAG, accountId, entityType, entityId, keys: attributeKeys },
+        'Successfully deleted entity attributes'
+      );
+    } catch (err) {
+      logger.error(
+        {
+          tag: this.LOG_TAG,
+          accountId,
+          method: 'deleteEntityAttributesSync',
+          entityType,
+          entityId,
+          error: err instanceof Error ? err.message : String(err),
+        },
+        'Failed to delete entity attributes'
+      );
+
+      if (err instanceof HttpFetcherError) {
+        throw new Error(
+          `AuthorizationAttributesMsService: [deleteEntityAttributesSync] request failed with status ${err.status}: ${err.message}`
+        );
+      }
+      throw err;
+    }
+  }
 }