@mondaydotcomorg/monday-authorization 3.5.3-feat-shaime-support-entity-attributes-in-authorization-sdk-a77c130 → 3.7.0-feat-shaime-support-entity-attributes-4-49e1de0

package/dist/utils/validation.d.ts

@@ -1,45 +1,45 @@
+import { Resource } from '../types/general';
 /**
- * Utility class for common validation operations using Zod
+ * Utility class for common validation operations using AJV
  */
 export declare class ValidationUtils {
+    private static ajv;
     /**
-     * Validates that a value is an integer
-     * @param value The value to validate
-     * @param fieldName The name of the field for error messages
-     * @throws ArgumentError if value is not an integer
+     * Validates that a value is an integer. Throws ArgumentError with a descriptive message on failure.
      */
-    static validateInteger(value: any, fieldName: string): void;
+    static validateInteger(value: number): void;
     /**
-     * Validates that a value is a non-empty string
-     * @param value The value to validate
-     * @param fieldName The name of the field for error messages
-     * @throws ArgumentError if value is not a string or is empty
+     * Validates that a value is a non-empty string. Throws ArgumentError on failure.
      */
-    static validateString(value: any, fieldName: string): void;
+    static validateString(value: string): void;
     /**
-     * Validates that a value is an array and optionally checks minimum length
-     * @param value The value to validate
-     * @param fieldName The name of the field for error messages
-     * @param minLength Minimum required length (default: 0)
-     * @returns The validated array
-     * @throws ArgumentError if value is not an array or doesn't meet minimum length
+     * Validates that a value is an array of non-empty strings. Throws ArgumentError on failure.
+     * Allows empty arrays - caller should handle early return.
      */
-    static validateArray<T>(value: any, fieldName: string, minLength?: number): T[];
+    static validateStringArray(value: string[]): void;
     /**
-     * Validates that a value is one of the allowed enum values
-     * @param value The value to validate
-     * @param validValues Array of valid values
-     * @param fieldName The name of the field for error messages
-     * @returns The validated value as the enum type
-     * @throws ArgumentError if value is not in validValues
+     * Validates an attribute assignment object using a single AJV schema.
+     * Preserves legacy error messages for each field.
      */
-    static validateEnum<T extends string>(value: string, validValues: readonly T[], fieldName: string): T;
+    static validateAssignment<TType extends string>(data: {
+        id: any;
+        type: string;
+        attributeKey: any;
+        attributeValue: any;
+    }, validTypes: readonly TType[], fieldNames: {
+        id: string;
+        type: string;
+    }): {
+        id: number;
+        type: TType;
+        attributeKey: string;
+        attributeValue: string;
+    };
     /**
-     * Validates that all items in an array are strings
-     * @param value Array to validate
-     * @param fieldName The name of the field for error messages
-     * @throws ArgumentError if any item is not a string
+     * Validates a Resource-like object shape: { id: number; type: string }.
+     * Throws ArgumentError with legacy-compatible messages.
      */
-    static validateStringArray(value: any[], fieldName: string): void;
+    static validateResource(resource: Resource): void;
+    static validateArrayTypeOf<T>(attributesMessages: T[], messageClass: abstract new (...args: any[]) => T): void;
 }
 //# sourceMappingURL=validation.d.ts.map

package/dist/utils/validation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/utils/validation.ts"],"names":[],"mappings":"AAGA;;GAEG;AACH,qBAAa,eAAe;IAC1B;;;;;OAKG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAY3D;;;;;OAKG;IACH,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;IAe1D;;;;;;;OAOG;IACH,MAAM,CAAC,aAAa,CAAC,CAAC,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,SAAI,GAAG,CAAC,EAAE;IAe1E;;;;;;;OAOG;IACH,MAAM,CAAC,YAAY,CAAC,CAAC,SAAS,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,WAAW,EAAE,SAAS,CAAC,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,CAAC;IAYrG;;;;;OAKG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI;CAkBlE"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/utils/validation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,GAAG,CAAgC;IAClD;;OAEG;IACH,MAAM,CAAC,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAS3C;;OAEG;IACH,MAAM,CAAC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IAa1C;;;OAGG;IACH,MAAM,CAAC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAkBjD;;;OAGG;IACH,MAAM,CAAC,kBAAkB,CAAC,KAAK,SAAS,MAAM,EAC5C,IAAI,EAAE;QAAE,EAAE,EAAE,GAAG,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,YAAY,EAAE,GAAG,CAAC;QAAC,cAAc,EAAE,GAAG,CAAA;KAAE,EACvE,UAAU,EAAE,SAAS,KAAK,EAAE,EAC5B,UAAU,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAE,GACvC;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,KAAK,CAAC;QAAC,YAAY,EAAE,MAAM,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAE;IA0D5E;;;OAGG;IACH,MAAM,CAAC,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI;IAqBjD,MAAM,CAAC,mBAAmB,CAAC,CAAC,EAAE,kBAAkB,EAAE,CAAC,EAAE,EAAE,YAAY,EAAE,QAAQ,MAAM,GAAG,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,GAAG,IAAI;CAoB/G"}

package/dist/utils/validation.js

@@ -1,117 +1,156 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const zod = require('zod');
+const Ajv = require('ajv');
 const errors_argumentError = require('../errors/argument-error.js');
 
+const _interopDefault = e => e && e.__esModule ? e : { default: e };
+
+const Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+
 /**
- * Utility class for common validation operations using Zod
+ * Utility class for common validation operations using AJV
  */
 class ValidationUtils {
+    static ajv = new Ajv__default.default({ allErrors: true });
     /**
-     * Validates that a value is an integer
-     * @param value The value to validate
-     * @param fieldName The name of the field for error messages
-     * @throws ArgumentError if value is not an integer
+     * Validates that a value is an integer. Throws ArgumentError with a descriptive message on failure.
      */
-    static validateInteger(value, fieldName) {
-        const schema = zod.z.number().int();
-        try {
-            schema.parse(value);
-        }
-        catch (error) {
-            if (error instanceof zod.z.ZodError) {
-                throw new errors_argumentError.ArgumentError(`${fieldName} must be an integer, got: ${value}`);
-            }
-            throw error;
+    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}`);
         }
     }
     /**
-     * Validates that a value is a non-empty string
-     * @param value The value to validate
-     * @param fieldName The name of the field for error messages
-     * @throws ArgumentError if value is not a string or is empty
+     * Validates that a value is a non-empty string. Throws ArgumentError on failure.
      */
-    static validateString(value, fieldName) {
-        const schema = zod.z.string().min(1);
-        try {
-            schema.parse(value);
-        }
-        catch (error) {
-            if (error instanceof zod.z.ZodError) {
-                if (typeof value !== 'string') {
-                    throw new errors_argumentError.ArgumentError(`${fieldName} must be a string, got: ${typeof value}`);
-                }
-                throw new errors_argumentError.ArgumentError(`${fieldName} must be a non-empty string`);
-            }
-            throw error;
+    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}`);
         }
     }
     /**
-     * Validates that a value is an array and optionally checks minimum length
-     * @param value The value to validate
-     * @param fieldName The name of the field for error messages
-     * @param minLength Minimum required length (default: 0)
-     * @returns The validated array
-     * @throws ArgumentError if value is not an array or doesn't meet minimum length
+     * Validates that a value is an array of non-empty strings. Throws ArgumentError on failure.
+     * Allows empty arrays - caller should handle early return.
      */
-    static validateArray(value, fieldName, minLength = 0) {
-        const schema = zod.z.array(zod.z.any()).min(minLength);
-        try {
-            return schema.parse(value);
-        }
-        catch (error) {
-            if (error instanceof zod.z.ZodError) {
-                if (!Array.isArray(value)) {
-                    throw new errors_argumentError.ArgumentError(`${fieldName} must be an array`);
-                }
-                throw new errors_argumentError.ArgumentError(`${fieldName} must have at least ${minLength} items`);
-            }
-            throw error;
+    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);
+        if (!isValid) {
+            throw new errors_argumentError.ArgumentError(`Value must be an array of non-empty strings, got: ${value}`);
         }
+        // Allow empty arrays to pass validation - caller should handle early return
+        // Non-empty arrays will be validated for string content above
     }
     /**
-     * Validates that a value is one of the allowed enum values
-     * @param value The value to validate
-     * @param validValues Array of valid values
-     * @param fieldName The name of the field for error messages
-     * @returns The validated value as the enum type
-     * @throws ArgumentError if value is not in validValues
+     * Validates an attribute assignment object using a single AJV schema.
+     * Preserves legacy error messages for each field.
      */
-    static validateEnum(value, validValues, fieldName) {
-        const schema = zod.z.enum(validValues);
-        try {
-            return schema.parse(value);
-        }
-        catch (error) {
-            if (error instanceof zod.z.ZodError) {
-                throw new errors_argumentError.ArgumentError(`${fieldName} must be one of [${validValues.join(', ')}], got: ${value}`);
+    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);
+        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}`);
             }
-            throw error;
+            // 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');
         }
+        return {
+            id: data.id,
+            type: data.type,
+            attributeKey: data.attributeKey,
+            attributeValue: data.attributeValue,
+        };
     }
     /**
-     * Validates that all items in an array are strings
-     * @param value Array to validate
-     * @param fieldName The name of the field for error messages
-     * @throws ArgumentError if any item is not a string
+     * Validates a Resource-like object shape: { id: number; type: string }.
+     * Throws ArgumentError with legacy-compatible messages.
      */
-    static validateStringArray(value, fieldName) {
-        const schema = zod.z.array(zod.z.string());
-        try {
-            schema.parse(value);
+    static validateResource(resource) {
+        if (!resource || typeof resource !== 'object') {
+            throw new errors_argumentError.ArgumentError('resource must be an object');
+        }
+        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 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`);
         }
-        catch (error) {
-            if (error instanceof zod.z.ZodError) {
-                const zodError = error;
-                const firstError = zodError.issues[0];
-                // Check if it's an array item validation error
-                if (firstError.path.length > 0 && typeof firstError.path[0] === 'number') {
-                    const index = firstError.path[0];
-                    throw new errors_argumentError.ArgumentError(`All ${fieldName} must be strings, but item at index ${index} is not`);
-                }
-                throw new errors_argumentError.ArgumentError(`${fieldName} must be an array`);
+        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}`);
             }
-            throw error;
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mondaydotcomorg/monday-authorization",
-  "version": "3.5.3-feat-shaime-support-entity-attributes-in-authorization-sdk-a77c130",
+  "version": "3.7.0-feat-shaime-support-entity-attributes-4-49e1de0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "BSD-3-Clause",
@@ -28,11 +28,12 @@
     "@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",
     "lodash": "^4.17.21",
     "node-fetch": "^2.6.7",
     "on-headers": "^1.0.2",
-    "ts-node": "^10.0.0",
-    "zod": "^4.1.13"
+    "ts-node": "^10.0.0"
   },
   "devDependencies": {
     "@mondaydotcomorg/trident-library": "^1.1.44",

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

@@ -1,20 +1,19 @@
 import { Api, HttpClient } from '@mondaydotcomorg/trident-backend-api';
 import { signAuthorizationHeader } from '@mondaydotcomorg/monday-jwt';
-import { z } from 'zod';
 import { ResourceAttributeAssignment } from './resource-attribute-assignment';
 import { EntityAttributeAssignment } from './entity-attribute-assignment';
 import {
   AttributeOperation,
-  EntityType,
   ResourceAttributeOperation,
   EntityAttributeOperation,
 } 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 { IAuthorizationAttributesService } from './types/authorization-attributes-service.interface';
+import { AuthorizationAttributesService } from './types/authorization-attributes-service.interface';
 import { Resource } from './types/general';
 const INTERNAL_APP_NAME = 'internal_ms';
 const UPSERT_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource';
@@ -30,9 +29,14 @@ 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 IAuthorizationAttributesService {
+export class AuthorizationAttributesMsService implements AuthorizationAttributesService {
   private static LOG_TAG = 'authorization_attributes_ms';
-  private static httpClient: HttpClient | undefined = Api.getPart('httpClient');
+  private static httpClient: HttpClient | null = Api.getPart('httpClient') ?? null;
+
+  public static destroyHttpClient(): void {
+    AuthorizationAttributesMsService.httpClient = null;
+  }
+
   /**
    * Creates or updates resource attributes synchronously.
    * @param accountId The account ID
@@ -70,22 +74,14 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
     _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');
-
+    ValidationUtils.validateResource(resource);
+    ValidationUtils.validateStringArray(attributeKeys);
     return AuthorizationAttributesMsService.executeDeleteRequest(
       accountId,
       DELETE_RESOURCE_ATTRIBUTES_PATH,
       {
         resourceType: resource.type,
-        resourceId: resource.id,
+        resourceId: resource.id as number,
       },
       attributeKeys,
       'resource',
@@ -127,7 +123,7 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
    */
   async deleteEntityAttributes(
     accountId: number,
-    entityType: EntityType | string,
+    entityType: EntityType,
     entityId: number,
     attributeKeys: string[],
     _appName?: string,
@@ -136,7 +132,7 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
     if (!entityType || typeof entityType !== 'string' || entityType.trim() === '') {
       throw new ArgumentError(`entityType must be a non-empty string, got: ${entityType}`);
     }
-    ValidationUtils.validateInteger(entityId, 'entityId');
+    ValidationUtils.validateInteger(entityId);
 
     return AuthorizationAttributesMsService.executeDeleteRequest(
       accountId,
@@ -262,21 +258,14 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
     context: Record<string, any> = {}
   ): Promise<void> {
     // Validate inputs
-    ValidationUtils.validateInteger(accountId, 'accountId');
-    ValidationUtils.validateArray(keys, 'attributeKeys');
+    ValidationUtils.validateInteger(accountId);
+    ValidationUtils.validateStringArray(keys);
 
     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,
-    };
+    const requestBody: DeleteRequestBody = { keys };
 
     if (!AuthorizationAttributesMsService.httpClient) {
       throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
@@ -306,7 +295,7 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
         }
       );
 
-      logger.info(
+      logger.debug(
         { tag: AuthorizationAttributesMsService.LOG_TAG, accountId, ...pathParams, keys },
         `Successfully deleted ${logPrefix} attributes`
       );
@@ -376,63 +365,6 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
     return headers;
   }
 
-  /**
-   * Validates that all messages are instances of the specified message class
-   */
-  private static validateMessages<T>(attributesMessages: T[], messageClass: abstract new (...args: any[]) => T): void {
-    // Validate messageClass is a function using Zod
-    const classSchema = z.custom<abstract new (...args: any[]) => T>(value => typeof value === 'function', {
-      message: 'messageClass must be a class/constructor function',
-    });
-
-    try {
-      classSchema.parse(messageClass);
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        const firstError = error.issues[0];
-        throw new ArgumentError(firstError.message);
-      }
-      throw error;
-    }
-
-    const className = messageClass.name || 'ResourceAttributeAssignment';
-
-    // First validate it's an array
-    ValidationUtils.validateArray(attributesMessages, 'attributesMessages');
-
-    // Then use Zod to validate each item is an instance of the class
-    const schema = z.array(z.any()).refine(
-      items => {
-        for (let i = 0; i < items.length; i++) {
-          if (!(items[i] instanceof messageClass)) {
-            return false;
-          }
-        }
-        return true;
-      },
-      {
-        message: `All attributesMessages must be instances of ${className}`,
-      }
-    );
-
-    try {
-      schema.parse(attributesMessages);
-    } catch (error) {
-      if (error instanceof z.ZodError) {
-        // Find the first invalid index for a more specific error message
-        const invalidIndex = attributesMessages.findIndex(item => !(item instanceof messageClass));
-        if (invalidIndex !== -1) {
-          throw new ArgumentError(
-            `All attributesMessages must be instances of ${className}, but item at index ${invalidIndex} is not`
-          );
-        }
-        const firstError = error.issues[0];
-        throw new ArgumentError(firstError.message);
-      }
-      throw error;
-    }
-  }
-
   /**
    * Generic helper for executing upsert requests
    */
@@ -445,20 +377,11 @@ export class AuthorizationAttributesMsService implements IAuthorizationAttribute
     logPrefix: string,
     methodName: string
   ): Promise<void> {
-    // Validate inputs
-    ValidationUtils.validateInteger(accountId, 'accountId');
-    ValidationUtils.validateArray(assignments, 'assignments');
-
+    ValidationUtils.validateInteger(accountId);
+    ValidationUtils.validateArrayTypeOf(assignments, assignmentClass);
     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 assignmentDto = assignments.map(assignment => assignment.toDataTransferObject());
 
     const requestBody =

package/src/authorization-attributes-service.ts

@@ -1,13 +1,12 @@
 import { AuthorizationAttributesMsService } from './authorization-attributes-ms-service';
 import { AuthorizationAttributesSnsService } from './authorization-attributes-sns-service';
-import { IAuthorizationAttributesService } from './types/authorization-attributes-service.interface';
+import { AuthorizationAttributesService as IAuthorizationAttributesService } from './types/authorization-attributes-service.interface';
 
 /**
  * Main service class for managing resource and entity attributes.
  * Provides access to both direct (MS) and SNS operations.
  *
  * @example
- * ```typescript
  * const service = new AuthorizationAttributesService();
  *
  * // Use direct operations

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

@@ -5,7 +5,6 @@ import {
   ResourceAttributeOperation,
   EntityAttributeOperation,
   AttributeOperation,
-  EntityType,
 } from './types/authorization-attributes-contracts';
 import { EntityAttributeAssignment } from './entity-attribute-assignment';
 import { Resource } from './types/general';
@@ -22,13 +21,14 @@ import {
   SnsTopicType,
 } from './constants/sns';
 import type { TopicAttributesMap } from 'aws-sdk/clients/sns';
-import { IAuthorizationAttributesService } from './types/authorization-attributes-service.interface';
+import { AuthorizationAttributesService } from './types/authorization-attributes-service.interface';
+import { EntityType } from './entity-attributes-constants';
 
 /**
  * Service class for managing resource attributes asynchronously via SNS.
  * Provides asynchronous operations to create/update and delete attributes on resources.
  */
-export class AuthorizationAttributesSnsService implements IAuthorizationAttributesService {
+export class AuthorizationAttributesSnsService implements AuthorizationAttributesService {
   private static LOG_TAG = 'authorization_attributes';
   private resourceSnsArn: string;
   private entitySnsArn: string;

package/src/authorization-middleware.ts

@@ -1,13 +1,13 @@
 import onHeaders from 'on-headers';
 import { AuthorizationInternalService } from './authorization-internal-service';
 import { AuthorizationService, createAuthorizationParams } from './authorization-service';
-import { BaseRequest, BaseResponse, Context, ContextGetter, ResourceGetter } from './types/general';
+import { Action, BaseRequest, BaseResponse, Context, ContextGetter, ResourceGetter } from './types/general';
 import type { NextFunction } from 'express';
 
 // getAuthorizationMiddleware is duplicated in testKit/index.ts
 // If you are making changes to this function, please make sure to update the other file as well
 export function getAuthorizationMiddleware(
-  action: string,
+  action: Action,
   resourceGetter: ResourceGetter,
   contextGetter?: ContextGetter
 ) {

package/src/authorization-service.ts

@@ -3,7 +3,7 @@ import { MondayFetchOptions } from '@mondaydotcomorg/monday-fetch';
 import { Api } from '@mondaydotcomorg/trident-backend-api';
 import { HttpFetcherError } from '@mondaydotcomorg/monday-fetch-api';
 import { getIgniteClient, IgniteClient } from '@mondaydotcomorg/ignite-sdk';
-import { AuthorizationObject, AuthorizationParams, Resource } from './types/general';
+import { Action, AuthorizationObject, AuthorizationParams, Resource } from './types/general';
 import { sendAuthorizationCheckResponseTimeMetric } from './prometheus-service';
 import { recordAuthorizationTiming } from './metrics-service';
 import {
@@ -74,7 +74,7 @@ export class AuthorizationService {
     accountId: number,
     userId: number,
     resources: Resource[],
-    action: string
+    action: Action
   ): Promise<AuthorizeResponse>;
 
   static async isAuthorized(
@@ -223,7 +223,7 @@ export class AuthorizationService {
     accountId: number,
     userId: number,
     resources: Resource[],
-    action: string
+    action: Action
   ): Promise<AuthorizeResponse> {
     const { authorizationObjects } = createAuthorizationParams(resources, action);
     return this.isAuthorizedMultiple(accountId, userId, authorizationObjects);
@@ -338,7 +338,7 @@ export async function setIgniteClient() {
   AuthorizationInternalService.setIgniteClient(igniteClient);
 }
 
-export function createAuthorizationParams(resources: Resource[], action: string): AuthorizationParams {
+export function createAuthorizationParams(resources: Resource[], action: Action): AuthorizationParams {
   const params = {
     authorizationObjects: resources.map((resource: Resource) => {
       const authorizationObject: AuthorizationObject = {