@mondaydotcomorg/monday-authorization 3.7.0-feat-shaime-support-entity-attributes-4-49e1de0 → 3.7.1

package/dist/utils/validation.js

@@ -2,6 +2,8 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const Ajv = require('ajv');
 const errors_argumentError = require('../errors/argument-error.js');
+const utils_assignmentSchema = require('./assignment-schema.js');
+const utils_resourceSchema = require('./resource-schema.js');
 
 const _interopDefault = e => e && e.__esModule ? e : { default: e };
 
@@ -12,146 +14,87 @@ const Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
  */
 class ValidationUtils {
     static ajv = new Ajv__default.default({ allErrors: true });
-    /**
-     * Validates that a value is an integer. Throws ArgumentError with a descriptive message on failure.
-     */
+    static integerValidator = this.ajv.compile({ type: 'number', multipleOf: 1 });
+    static stringValidator = this.ajv.compile({ type: 'string', minLength: 1 });
+    static stringArrayValidator = this.ajv.compile({
+        type: 'array',
+        items: { type: 'string' },
+    });
     static validateInteger(value) {
-        const numberSchema = { type: 'number', multipleOf: 1 };
-        const validate = ValidationUtils.ajv.compile(numberSchema);
-        const isValid = validate(value);
-        if (!isValid) {
-            throw new errors_argumentError.ArgumentError(`Value must be an integer, got: ${value}`);
+        const valid = this.integerValidator(value);
+        if (!valid) {
+            throw new errors_argumentError.ArgumentError('Invalid integer');
         }
     }
-    /**
-     * Validates that a value is a non-empty string. Throws ArgumentError on failure.
-     */
     static validateString(value) {
-        const non_empty_string_schema = {
-            type: 'string',
-            minLength: 1,
-            pattern: '\\S',
-        };
-        const validate = ValidationUtils.ajv.compile(non_empty_string_schema);
-        const isValid = validate(value);
-        if (!isValid) {
-            throw new errors_argumentError.ArgumentError(`Value must be a non-empty string, got: ${value}`);
+        const valid = this.stringValidator(value);
+        if (!valid) {
+            throw new errors_argumentError.ArgumentError('Invalid string');
         }
     }
-    /**
-     * Validates that a value is an array of non-empty strings. Throws ArgumentError on failure.
-     * Allows empty arrays - caller should handle early return.
-     */
     static validateStringArray(value) {
-        const string_array_schema = {
-            type: 'array',
-            items: {
-                type: 'string',
-                minLength: 1,
-                pattern: '\\S',
-            },
-        };
-        const validateStringArray = ValidationUtils.ajv.compile(string_array_schema);
-        const isValid = validateStringArray(value);
+        const valid = this.stringArrayValidator(value);
+        if (!valid) {
+            throw new errors_argumentError.ArgumentError('Invalid string array');
+        }
+    }
+    static validateResource(resource) {
+        const isValid = utils_resourceSchema.resourceSchema(resource);
         if (!isValid) {
-            throw new errors_argumentError.ArgumentError(`Value must be an array of non-empty strings, got: ${value}`);
+            const errorMessage = this.formatValidationErrors(utils_resourceSchema.resourceSchema.errors);
+            throw new errors_argumentError.ArgumentError(errorMessage ? `Invalid resource: ${errorMessage}` : 'Invalid resource');
         }
-        // Allow empty arrays to pass validation - caller should handle early return
-        // Non-empty arrays will be validated for string content above
     }
     /**
      * Validates an attribute assignment object using a single AJV schema.
      * Preserves legacy error messages for each field.
      */
-    static validateAssignment(data, validTypes, fieldNames) {
-        const schema = {
-            type: 'object',
-            properties: {
-                id: { type: 'number', multipleOf: 1 },
-                type: { type: 'string', enum: validTypes },
-                attributeKey: { type: 'string', minLength: 1 },
-                attributeValue: { type: 'string', minLength: 1 },
-            },
-            required: ['id', 'type', 'attributeKey', 'attributeValue'],
-            additionalProperties: false,
-        };
-        const validate = this.ajv.compile(schema);
-        const valid = validate(data);
+    static validatUpsertResourceAssignment(resource) {
+        const valid = utils_assignmentSchema.resourceUpsertAssignmentSchema(resource);
         if (!valid) {
-            // Map to legacy error messages deterministically
-            const { id, type, attributeKey, attributeValue } = data;
-            // id must be integer
-            const isInteger = typeof id === 'number' && Number.isFinite(id) && Math.floor(id) === id;
-            if (!isInteger) {
-                throw new errors_argumentError.ArgumentError(`${fieldNames.id} must be an integer, got: ${id}`);
-            }
-            // type must be within enum
-            if (typeof type !== 'string' || !validTypes.includes(type)) {
-                throw new errors_argumentError.ArgumentError(`${fieldNames.type} must be one of [${validTypes.join(', ')}], got: ${type}`);
-            }
-            // attributeKey
-            if (typeof attributeKey !== 'string') {
-                throw new errors_argumentError.ArgumentError(`attributeKey must be a string, got: ${typeof attributeKey}`);
-            }
-            if (!attributeKey) {
-                throw new errors_argumentError.ArgumentError('attributeKey must be a non-empty string');
-            }
-            // attributeValue
-            if (typeof attributeValue !== 'string') {
-                throw new errors_argumentError.ArgumentError(`attributeValue must be a string, got: ${typeof attributeValue}`);
-            }
-            if (!attributeValue) {
-                throw new errors_argumentError.ArgumentError('attributeValue must be a non-empty string');
-            }
-            // Fallback
-            throw new errors_argumentError.ArgumentError('Invalid attribute assignment');
+            const errorMessage = this.formatValidationErrors(utils_assignmentSchema.resourceUpsertAssignmentSchema.errors);
+            throw new errors_argumentError.ArgumentError(errorMessage
+                ? `Invalid resource attribute assignment: ${errorMessage}`
+                : 'Invalid resource attribute assignment');
         }
-        return {
-            id: data.id,
-            type: data.type,
-            attributeKey: data.attributeKey,
-            attributeValue: data.attributeValue,
-        };
     }
-    /**
-     * Validates a Resource-like object shape: { id: number; type: string }.
-     * Throws ArgumentError with legacy-compatible messages.
-     */
-    static validateResource(resource) {
-        if (!resource || typeof resource !== 'object') {
-            throw new errors_argumentError.ArgumentError('resource must be an object');
+    static validatDeleteResourceAssignment(resource) {
+        const valid = utils_assignmentSchema.resourceDeleteAssignmentSchema(resource);
+        if (!valid) {
+            const errorMessage = this.formatValidationErrors(utils_assignmentSchema.resourceDeleteAssignmentSchema.errors);
+            throw new errors_argumentError.ArgumentError(errorMessage
+                ? `Invalid resource attribute assignment: ${errorMessage}`
+                : 'Invalid resource attribute assignment');
         }
-        const schema = {
-            type: 'object',
-            properties: {
-                id: { type: 'number', multipleOf: 1 },
-                type: { type: 'string', minLength: 1 },
-                wrapperData: { type: 'string' },
-            },
-            required: ['type', 'id'],
-            additionalProperties: false,
-        };
-        const validate = this.ajv.compile(schema);
-        const isValid = validate(resource);
-        if (!isValid) {
-            throw new errors_argumentError.ArgumentError('Invalid resource');
+    }
+    static validatUpsertEntityAssignment(entity) {
+        const valid = utils_assignmentSchema.entityUpsertAssignmentSchema(entity);
+        if (!valid) {
+            const errorMessage = this.formatValidationErrors(utils_assignmentSchema.entityUpsertAssignmentSchema.errors);
+            throw new errors_argumentError.ArgumentError(errorMessage ? `Invalid entity attribute assignment: ${errorMessage}` : 'Invalid entity attribute assignment');
         }
     }
-    static validateArrayTypeOf(attributesMessages, messageClass) {
-        const arraySchema = {
-            type: 'array',
-        };
-        const validateArray = ValidationUtils.ajv.compile(arraySchema);
-        const isArrayValid = validateArray(attributesMessages);
-        if (!isArrayValid) {
-            throw new errors_argumentError.ArgumentError(`attributesMessages must be an array`);
+    static validatDeleteEntityAssignment(entity) {
+        const valid = utils_assignmentSchema.entityDeleteAssignmentSchema(entity);
+        if (!valid) {
+            const errorMessage = this.formatValidationErrors(utils_assignmentSchema.entityDeleteAssignmentSchema.errors);
+            throw new errors_argumentError.ArgumentError(errorMessage ? `Invalid entity attribute assignment: ${errorMessage}` : 'Invalid entity attribute assignment');
         }
-        for (let i = 0; i < attributesMessages.length; i++) {
-            const item = attributesMessages[i];
-            if (!(item instanceof messageClass)) {
-                throw new errors_argumentError.ArgumentError(`attributesMessages[${i}] must be an instance of ${messageClass.name}, got: ${item?.constructor?.name || typeof item}`);
-            }
+    }
+    /**
+     * Formats AJV validation errors into a readable error message
+     */
+    static formatValidationErrors(errors) {
+        if (!errors || !errors.length) {
+            return '';
         }
+        return errors
+            .map(err => {
+            const path = err.instancePath || (err.params && 'missingProperty' in err.params ? `/${err.params.missingProperty}` : '');
+            const message = err.message || 'validation failed';
+            return path ? `${path}: ${message}` : message;
+        })
+            .join('; ');
     }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mondaydotcomorg/monday-authorization",
-  "version": "3.7.0-feat-shaime-support-entity-attributes-4-49e1de0",
+  "version": "3.7.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "BSD-3-Clause",
@@ -28,8 +28,7 @@
     "@mondaydotcomorg/monday-observability-kit": "^1.5.3",
     "@mondaydotcomorg/monday-sns": "^1.2.1",
     "@mondaydotcomorg/trident-backend-api": "^0.24.3",
-    "ajv": "^8.17.1",
-    "ajv-keywords": "^5.1.0",
+    "ajv": "^8.12.0",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
     "on-headers": "^1.0.2",

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

@@ -3,18 +3,18 @@ import { signAuthorizationHeader } from '@mondaydotcomorg/monday-jwt';
 import { ResourceAttributeAssignment } from './resource-attribute-assignment';
 import { EntityAttributeAssignment } from './entity-attribute-assignment';
 import {
-  AttributeOperation,
-  ResourceAttributeOperation,
-  EntityAttributeOperation,
+  ResourceAttributeUpsertOperation,
+  ResourceAttributeDeleteOperation,
+  EntityAttributeUpsertOperation,
+  EntityAttributeDeleteOperation,
 } from './types/authorization-attributes-contracts';
 import { EntityType } from './entity-attributes-constants';
-import { ArgumentError } from './errors/argument-error';
 import { AuthorizationInternalService, logger } from './authorization-internal-service';
 import { getAttributionsFromApi } from './attributions-service';
 import { APP_NAME } from './constants';
-import { ValidationUtils } from './utils/validation';
-import { AuthorizationAttributesService } from './types/authorization-attributes-service.interface';
+import { BaseAuthorizationAttributesService } from './base-authorization-attributes-service';
 import { Resource } from './types/general';
+
 const INTERNAL_APP_NAME = 'internal_ms';
 const UPSERT_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource';
 const DELETE_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource/{resourceType}/{resourceId}';
@@ -29,206 +29,156 @@ interface DeleteRequestBody {
  * 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 implements AuthorizationAttributesService {
+export class AuthorizationAttributesMsService extends BaseAuthorizationAttributesService {
   private static LOG_TAG = 'authorization_attributes_ms';
-  private static httpClient: HttpClient | null = Api.getPart('httpClient') ?? null;
-
-  public static destroyHttpClient(): void {
-    AuthorizationAttributesMsService.httpClient = null;
-  }
+  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'
-    );
+  constructor() {
+    super();
+    if (!AuthorizationAttributesMsService.httpClient) {
+      AuthorizationAttributesMsService.httpClient = Api.getPart('httpClient');
+      if (!AuthorizationAttributesMsService.httpClient) {
+        throw new Error('HTTP client is not initialized');
+      }
+    }
   }
 
   /**
-   * Deletes specific attributes from a resource synchronously.
+   * Deletes a specific attribute 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>
+   * @param attributeKey Attribute key string to delete
+   * @returns Promise<ResourceAttributeDeleteOperation>
    */
   async deleteResourceAttributes(
     accountId: number,
     resource: Resource,
-    attributeKeys: string[],
+    attributeKey: string,
     _appName?: string,
     _callerActionIdentifier?: string
-  ): Promise<void> {
-    ValidationUtils.validateResource(resource);
-    ValidationUtils.validateStringArray(attributeKeys);
-    return AuthorizationAttributesMsService.executeDeleteRequest(
+  ): Promise<ResourceAttributeDeleteOperation> {
+    const operation: ResourceAttributeDeleteOperation = await super.deleteResourceAttributes(
+      accountId,
+      resource,
+      attributeKey
+    );
+    await AuthorizationAttributesMsService.executeDeleteRequest(
       accountId,
       DELETE_RESOURCE_ATTRIBUTES_PATH,
       {
         resourceType: resource.type,
-        resourceId: resource.id as number,
+        resourceId: resource.id,
       },
-      attributeKeys,
+      [attributeKey],
       'resource',
-      'deleteResourceAttributesSync',
-      { resource }
+      'deleteResourceAttributesSync'
     );
+    return operation;
   }
 
   /**
-   * 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.
+   * Deletes a specific attribute 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>
+   * @param attributeKey Attribute key string to delete
+   * @returns Promise<EntityAttributeDeleteOperation>
    */
   async deleteEntityAttributes(
     accountId: number,
     entityType: EntityType,
     entityId: number,
-    attributeKeys: string[],
+    attributeKey: 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);
-
-    return AuthorizationAttributesMsService.executeDeleteRequest(
+  ): Promise<EntityAttributeDeleteOperation> {
+    const operation: EntityAttributeDeleteOperation = await super.deleteEntityAttributes(
+      accountId,
+      entityType,
+      entityId,
+      attributeKey
+    );
+    await AuthorizationAttributesMsService.executeDeleteRequest(
       accountId,
       DELETE_ENTITY_ATTRIBUTES_PATH,
       {
         entityType,
         entityId,
       },
-      attributeKeys,
+      [attributeKey],
       'entity',
-      'deleteEntityAttributesSync',
-      { entityType, entityId }
+      'deleteEntityAttributesSync'
     );
+    return operation;
   }
 
   /**
-   * Updates resource attributes (batch operations).
-   * Note: MS service does not support batch operations directly.
-   * This method processes operations sequentially using upsert/delete methods.
+   * Updates a resource attribute (single operation - upsert only).
    * @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
+   * @param resourceAttributeOperation Operation to perform (must be UPSERT)
+   * @returns Promise<ResourceAttributeUpsertOperation> Processed operation
    */
   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);
-      }
-    }
+    resourceAttributeOperation: ResourceAttributeUpsertOperation
+  ): Promise<ResourceAttributeUpsertOperation> {
+    await super.updateResourceAttributes(accountId, _appName, _callerActionIdentifier, resourceAttributeOperation);
+    await AuthorizationAttributesMsService.executeUpsertRequest(
+      accountId,
+      [
+        new ResourceAttributeAssignment(
+          resourceAttributeOperation.resourceId,
+          resourceAttributeOperation.resourceType,
+          resourceAttributeOperation.key,
+          resourceAttributeOperation.value
+        ),
+      ],
+      UPSERT_RESOURCE_ATTRIBUTES_PATH,
+      'resourceAttributeAssignments',
+      'resource',
+      'updateResourceAttributesSync'
+    );
 
-    return processedOperations;
+    return resourceAttributeOperation;
   }
 
   /**
-   * Updates entity attributes (batch operations).
-   * Note: MS service does not support batch operations directly.
-   * This method processes operations sequentially using upsert/delete methods.
+   * Updates an entity attribute (single operation - upsert only).
    * @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
+   * @param entityAttributeOperation Operation to perform (must be UPSERT)
+   * @returns Promise<EntityAttributeUpsertOperation> Processed operation
    */
   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);
-      }
-    }
+    entityAttributeOperation: EntityAttributeUpsertOperation
+  ): Promise<EntityAttributeUpsertOperation> {
+    // Validate before processing
+    await super.updateEntityAttributes(accountId, _appName, _callerActionIdentifier, entityAttributeOperation);
+    await AuthorizationAttributesMsService.executeUpsertRequest(
+      accountId,
+      [
+        new EntityAttributeAssignment(
+          entityAttributeOperation.entityId,
+          entityAttributeOperation.entityType,
+          entityAttributeOperation.key,
+          entityAttributeOperation.value
+        ),
+      ],
+      UPSERT_ENTITY_ATTRIBUTES_PATH,
+      'entityAttributeAssignments',
+      'entity',
+      'upsertEntityAttributesSync'
+    );
 
-    return processedOperations;
+    return entityAttributeOperation;
   }
 
   /**
@@ -254,13 +204,8 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
     pathParams: Record<string, string | number>,
     keys: string[],
     logPrefix: string,
-    methodName: string,
-    context: Record<string, any> = {}
+    methodName: string
   ): Promise<void> {
-    // Validate inputs
-    ValidationUtils.validateInteger(accountId);
-    ValidationUtils.validateStringArray(keys);
-
     if (!keys.length) {
       logger.warn({ tag: this.LOG_TAG, accountId, ...pathParams }, `${methodName} called with empty keys array`);
       return;
@@ -306,7 +251,6 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
           method: methodName,
           accountId,
           ...pathParams,
-          ...context,
           error: err instanceof Error ? err.message : String(err),
         },
         `Failed in ${methodName}`
@@ -373,15 +317,9 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
     assignments: T[],
     pathTemplate: string,
     requestBodyKey: 'resourceAttributeAssignments' | 'entityAttributeAssignments',
-    assignmentClass: abstract new (...args: any[]) => T,
     logPrefix: string,
     methodName: string
   ): Promise<void> {
-    ValidationUtils.validateInteger(accountId);
-    ValidationUtils.validateArrayTypeOf(assignments, assignmentClass);
-    if (!assignments.length) {
-      return;
-    }
     const assignmentDto = assignments.map(assignment => assignment.toDataTransferObject());
 
     const requestBody =

package/src/authorization-attributes-service.ts

@@ -1,46 +1,48 @@
 import { AuthorizationAttributesMsService } from './authorization-attributes-ms-service';
 import { AuthorizationAttributesSnsService } from './authorization-attributes-sns-service';
-import { AuthorizationAttributesService as IAuthorizationAttributesService } from './types/authorization-attributes-service.interface';
+import { BaseAuthorizationAttributesService as IAuthorizationAttributesService } from './base-authorization-attributes-service';
 
 /**
  * Main service class for managing resource and entity attributes.
- * Provides access to both direct (MS) and SNS operations.
+ * Provides access to both HTTP (direct microservice) and SNS (async messaging) operations.
  *
  * @example
  * const service = new AuthorizationAttributesService();
  *
- * // Use direct operations
- * await service.direct().upsertResourceAttributes(accountId, assignments);
+ * // Use HTTP operations (direct calls to microservice)
+ * await service.http().updateResourceAttributes(accountId, appName, actionId, operation);
  *
- * // Use SNS operations
- * await service.sns().upsertResourceAttributes(accountId, assignments, appName, actionId);
+ * // Use SNS operations (async messaging, then to microservice)
+ * await service.sns().updateResourceAttributes(accountId, appName, actionId, operation);
  * ```
  */
 export class AuthorizationAttributesService {
-  private _directService: AuthorizationAttributesMsService | null = null;
-  private _snsService: AuthorizationAttributesSnsService | null = null;
+  private httpService: AuthorizationAttributesMsService | null = null;
+  private snsService: AuthorizationAttributesSnsService | null = null;
 
   /**
-   * Gets the direct (MS) service instance.
+   * Gets the HTTP service instance.
+   * Performs direct HTTP calls to the authorization microservice.
    * Initializes the service on first access (lazy initialization).
    * @returns IAuthorizationAttributesService instance
    */
-  direct(): IAuthorizationAttributesService {
-    if (this._directService === null) {
-      this._directService = new AuthorizationAttributesMsService();
+  http(): IAuthorizationAttributesService {
+    if (this.httpService === null) {
+      this.httpService = new AuthorizationAttributesMsService();
     }
-    return this._directService;
+    return this.httpService;
   }
 
   /**
    * Gets the SNS service instance.
+   * Sends operations via SNS messaging, which are then processed by the microservice asynchronously.
    * Initializes the service on first access (lazy initialization).
    * @returns IAuthorizationAttributesService instance
    */
   sns(): IAuthorizationAttributesService {
-    if (this._snsService === null) {
-      this._snsService = new AuthorizationAttributesSnsService();
+    if (this.snsService === null) {
+      this.snsService = new AuthorizationAttributesSnsService();
     }
-    return this._snsService;
+    return this.snsService;
   }
 }