@mondaydotcomorg/monday-authorization 3.5.0-feat-use-profile-for-graph-can-action-in-scope-f1451ab → 3.5.0-feat-shaime-support-entity-attributes-in-authorization-sdk-397ce54

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

@@ -0,0 +1,327 @@
+import { Api, HttpClient } 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 { ArgumentError } from './errors/argument-error';
+import { logger } from './authorization-internal-service';
+import { getAttributionsFromApi } from './attributions-service';
+import { AuthorizationInternalService } from './authorization-internal-service';
+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}';
+
+interface Resource {
+  resourceType: string;
+  resourceId: number;
+}
+
+interface UpsertRequestBody {
+  resourceAttributeAssignments: Array<{
+    resourceId: number;
+    resourceType: string;
+    key: string;
+    value: string;
+  }>;
+}
+
+interface DeleteRequestBody {
+  keys: string[];
+}
+
+/**
+ * Service class for managing resource attributes in the authorization microservice.
+ * Provides synchronous HTTP operations to create/update and delete attributes on resources.
+ */
+export class AuthorizationAttributesMsService {
+  private static LOG_TAG = 'authorization_attributes_ms';
+
+  /**
+   * Gets request headers including Authorization, Content-Type, and optional attribution headers
+   */
+  private static getRequestHeaders(accountId: number, userId?: number): Record<string, string> {
+    const headers: Record<string, string> = {
+      'Content-Type': 'application/json',
+    };
+
+    // Generate Authorization token
+    const authToken = signAuthorizationHeader({
+      appName: INTERNAL_APP_NAME,
+      accountId,
+      userId,
+    });
+    headers.Authorization = authToken;
+
+    // Add attribution headers if available
+    const attributionHeaders = getAttributionsFromApi();
+    for (const key in attributionHeaders) {
+      if (attributionHeaders.hasOwnProperty(key)) {
+        headers[key] = attributionHeaders[key];
+      }
+    }
+
+    // Add X-REQUEST-ID if available from context
+    try {
+      const tridentContext = Api.getPart('context');
+      if (tridentContext?.runtimeAttributions) {
+        const outgoingHeaders = tridentContext.runtimeAttributions.buildOutgoingHeaders('HTTP_INTERNAL');
+        if (outgoingHeaders) {
+          const attributionHeadersMap: Record<string, string> = {};
+          for (const [key, value] of outgoingHeaders) {
+            attributionHeadersMap[key] = value;
+          }
+          if (attributionHeadersMap['x-request-id']) {
+            headers['X-REQUEST-ID'] = attributionHeadersMap['x-request-id'];
+          }
+        }
+      }
+    } catch (error) {
+      // Silently fail if context is not available
+      logger.debug({ tag: this.LOG_TAG, error }, 'Failed to get request ID from context');
+    }
+
+    // Add X-REQUEST-START timestamp
+    headers['X-REQUEST-START'] = Math.floor(Date.now() / 1000).toString();
+
+    return headers;
+  }
+
+  /**
+   * Validates that all messages are instances of the specified message class
+   */
+  private static validateMessages<T>(
+    attributesMessages: T[],
+    messageClass: new (...args: any[]) => T
+  ): void {
+    if (typeof messageClass !== 'function') {
+      throw new ArgumentError('messageClass must be a class/constructor function');
+    }
+
+    if (!Array.isArray(attributesMessages)) {
+      throw new ArgumentError('attributesMessages must be an array');
+    }
+
+    for (let i = 0; i < attributesMessages.length; i++) {
+      if (!(attributesMessages[i] instanceof messageClass)) {
+        const className = (messageClass as any).name || 'ResourceAttributeAssignment';
+        throw new ArgumentError(
+          `All attributesMessages must be instances of ${className}, but item at index ${i} is not`
+        );
+      }
+    }
+  }
+
+  /**
+   * Creates or updates resource attributes synchronously.
+   * @param accountId The account ID
+   * @param resourceAttributeAssignments Array of ResourceAttributeAssignment objects
+   * @returns Promise<void>
+   */
+  static async upsertResourceAttributesSync(
+    accountId: number,
+    resourceAttributeAssignments: ResourceAttributeAssignment[]
+  ): Promise<void> {
+    // Skip HTTP requests in test environment
+    if (process.env.NODE_ENV === 'test') {
+      logger.debug(
+        { tag: this.LOG_TAG, accountId, count: resourceAttributeAssignments.length },
+        'Skipping upsertResourceAttributesSync in test environment'
+      );
+      return;
+    }
+
+    // Validate inputs
+    if (!Number.isInteger(accountId)) {
+      throw new ArgumentError(`accountId must be an integer, got: ${accountId}`);
+    }
+
+    if (!Array.isArray(resourceAttributeAssignments)) {
+      throw new ArgumentError('resourceAttributeAssignments must be an array');
+    }
+
+    if (resourceAttributeAssignments.length === 0) {
+      logger.warn({ tag: this.LOG_TAG, accountId }, 'upsertResourceAttributesSync called with empty array');
+      return;
+    }
+
+    // Validate all assignments are instances of ResourceAttributeAssignment
+    this.validateMessages(resourceAttributeAssignments, ResourceAttributeAssignment);
+
+    // Convert assignments to hash format
+    const assignmentsHash = resourceAttributeAssignments.map(assignment => assignment.toH());
+
+    // Build request body
+    const requestBody: UpsertRequestBody = {
+      resourceAttributeAssignments: assignmentsHash,
+    };
+
+    const httpClient = Api.getPart('httpClient');
+    if (!httpClient) {
+      throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
+    }
+    const path = UPSERT_RESOURCE_ATTRIBUTES_PATH.replace('{accountId}', accountId.toString());
+    const headers = this.getRequestHeaders(accountId);
+
+    try {
+      logger.info(
+        { tag: this.LOG_TAG, accountId, count: resourceAttributeAssignments.length },
+        'Upserting resource 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: resourceAttributeAssignments.length },
+        'Successfully upserted resource attributes'
+      );
+    } catch (err) {
+      logger.error(
+        {
+          tag: this.LOG_TAG,
+          accountId,
+          method: 'upsertResourceAttributesSync',
+          error: err instanceof Error ? err.message : String(err),
+        },
+        'Failed to upsert resource attributes'
+      );
+
+      if (err instanceof HttpFetcherError) {
+        throw new Error(
+          `AuthorizationAttributesMsService: [upsertResourceAttributesSync] request failed with status ${err.status}: ${err.message}`
+        );
+      }
+      throw err;
+    }
+  }
+
+  /**
+   * 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>
+   */
+  static async deleteResourceAttributesSync(
+    accountId: number,
+    resource: Resource,
+    attributeKeys: string[]
+  ): Promise<void> {
+    // Skip HTTP requests in test environment
+    if (process.env.NODE_ENV === 'test') {
+      logger.debug(
+        { tag: this.LOG_TAG, accountId, resource, attributeKeys },
+        'Skipping deleteResourceAttributesSync in test environment'
+      );
+      return;
+    }
+
+    // Validate inputs
+    if (!Number.isInteger(accountId)) {
+      throw new ArgumentError(`accountId must be an integer, got: ${accountId}`);
+    }
+
+    if (!resource || typeof resource !== 'object') {
+      throw new ArgumentError('resource must be an object');
+    }
+
+    if (!Number.isInteger(resource.resourceId)) {
+      throw new ArgumentError(`resource.resourceId must be an integer, got: ${resource.resourceId}`);
+    }
+
+    if (typeof resource.resourceType !== 'string') {
+      throw new ArgumentError(`resource.resourceType must be a string, got: ${typeof resource.resourceType}`);
+    }
+
+    if (!Array.isArray(attributeKeys)) {
+      throw new ArgumentError('attributeKeys must be an array');
+    }
+
+    if (attributeKeys.length === 0) {
+      logger.warn({ tag: this.LOG_TAG, accountId, resource }, 'deleteResourceAttributesSync 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_RESOURCE_ATTRIBUTES_PATH.replace('{accountId}', accountId.toString())
+      .replace('{resourceType}', resource.resourceType)
+      .replace('{resourceId}', resource.resourceId.toString());
+    const headers = this.getRequestHeaders(accountId);
+
+    try {
+      logger.info(
+        { tag: this.LOG_TAG, accountId, resource, keys: attributeKeys },
+        'Deleting resource 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, resource, keys: attributeKeys },
+        'Successfully deleted resource attributes'
+      );
+    } catch (err) {
+      logger.error(
+        {
+          tag: this.LOG_TAG,
+          accountId,
+          method: 'deleteResourceAttributesSync',
+          resource,
+          error: err instanceof Error ? err.message : String(err),
+        },
+        'Failed to delete resource attributes'
+      );
+
+      if (err instanceof HttpFetcherError) {
+        throw new Error(
+          `AuthorizationAttributesMsService: [deleteResourceAttributesSync] request failed with status ${err.status}: ${err.message}`
+        );
+      }
+      throw err;
+    }
+  }
+}
+

package/src/authorization-attributes-service.ts

@@ -6,7 +6,14 @@ import {
   ResourceAttributeAssignment,
   ResourceAttributeResponse,
   ResourceAttributesOperation,
+  EntityAttributeAssignment,
+  EntityAttributeResponse,
+  ResourceType,
+  EntityType,
+  ResourceAttributeKeyType,
+  EntityAttributeKeyType,
 } from './types/authorization-attributes-contracts';
+import { AuthorizationInternalService } from './authorization-internal-service';
 import { Resource } from './types/general';
 import { logger } from './authorization-internal-service';
 import { getAttributionsFromApi } from './attributions-service';
@@ -24,6 +31,8 @@ export class AuthorizationAttributesService {
   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>;
@@ -231,4 +240,320 @@ 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/clients/graph-api.ts

@@ -18,7 +18,7 @@ import {
   GraphPermissionReason,
 } from '../types/graph-api.types';
 import { scopeToResource } from '../utils/authorization.utils';
-import { GRAPH_APP_NAME, GraphProfile } from '../constants';
+import { GRAPH_APP_NAME } from '../constants';
 import { handleApiError } from '../utils/api-error-handler';
 
 const CAN_ACTION_IN_SCOPE_GRAPH_PATH = '/permissions/is-allowed';
@@ -85,7 +85,6 @@ export class GraphApi {
           url: {
             appName: GRAPH_APP_NAME,
             path: CAN_ACTION_IN_SCOPE_GRAPH_PATH,
-            profile: GraphProfile.PERMISSION,
           },
           method: 'POST',
           headers: {

package/src/constants.ts

@@ -4,10 +4,6 @@ import { FetcherConfig } from '@mondaydotcomorg/trident-backend-api';
 export const APP_NAME = 'authorization';
 export const GRAPH_APP_NAME = 'authorization-graph';
 
-export enum GraphProfile {
-  PERMISSION = 'authorization-graph-permission',
-}
-
 export const ERROR_MESSAGES = {
   HTTP_CLIENT_NOT_INITIALIZED: 'MondayAuthorization: HTTP client is not initialized',
   REQUEST_FAILED: (method: string, status: number, reason: string) =>