@mondaydotcomorg/monday-authorization 3.5.1 → 3.5.3-feat-shaime-support-entity-attributes-in-authorization-sdk-e355942

package/dist/constants/sns.d.ts

@@ -1,5 +1,15 @@
-export declare const SNS_ARN_ENV_VAR_NAME = "SHARED_AUTHORIZATION_SNS_ENDPOINT_RESOURCE_ATTRIBUTES";
-export declare const SNS_DEV_TEST_NAME = "arn:aws:sns:us-east-1:000000000000:monday-authorization-resource-attributes-sns-local";
+export declare enum SnsTopicType {
+    RESOURCE = "resource",
+    ENTITY = "entity"
+}
+export declare const RESOURCE_SNS_ARN_ENV_VAR_NAME = "SHARED_AUTHORIZATION_SNS_ENDPOINT_RESOURCE_ATTRIBUTES";
+export declare const RESOURCE_SNS_DEV_TEST_NAME = "arn:aws:sns:us-east-1:000000000000:monday-authorization-resource-attributes-sns-local";
+export declare const ENTITY_SNS_ARN_ENV_VAR_NAME = "SHARED_AUTHORIZATION_SNS_ENDPOINT_ENTITY_ATTRIBUTES";
+export declare const ENTITY_SNS_DEV_TEST_NAME = "arn:aws:sns:us-east-1:000000000000:monday-authorization-entity-attributes-sns-local";
 export declare const RESOURCE_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND = "resourceAttributeModification";
+export declare const ENTITY_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND = "entityAttributeModification";
 export declare const ASYNC_RESOURCE_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE = 100;
+export declare const ASYNC_ENTITY_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE = 100;
+export declare const SNS_ARN_ENV_VAR_NAME = "SHARED_AUTHORIZATION_SNS_ENDPOINT_RESOURCE_ATTRIBUTES";
+export declare const SNS_DEV_TEST_NAME = "arn:aws:sns:us-east-1:000000000000:monday-authorization-resource-attributes-sns-local";
 //# sourceMappingURL=sns.d.ts.map

package/dist/constants/sns.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sns.d.ts","sourceRoot":"","sources":["../../src/constants/sns.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,oBAAoB,0DAA0D,CAAC;AAC5F,eAAO,MAAM,iBAAiB,0FAC2D,CAAC;AAC1F,eAAO,MAAM,qDAAqD,kCAAkC,CAAC;AACrG,eAAO,MAAM,oDAAoD,MAAM,CAAC"}
+{"version":3,"file":"sns.d.ts","sourceRoot":"","sources":["../../src/constants/sns.ts"],"names":[],"mappings":"AAAA,oBAAY,YAAY;IACtB,QAAQ,aAAa;IACrB,MAAM,WAAW;CAClB;AAGD,eAAO,MAAM,6BAA6B,0DAA0D,CAAC;AACrG,eAAO,MAAM,0BAA0B,0FACkD,CAAC;AAG1F,eAAO,MAAM,2BAA2B,wDAAwD,CAAC;AACjG,eAAO,MAAM,wBAAwB,wFACkD,CAAC;AACxF,eAAO,MAAM,qDAAqD,kCAAkC,CAAC;AACrG,eAAO,MAAM,mDAAmD,gCAAgC,CAAC;AACjG,eAAO,MAAM,oDAAoD,MAAM,CAAC;AACxE,eAAO,MAAM,kDAAkD,MAAM,CAAC;AAGtE,eAAO,MAAM,oBAAoB,0DAAgC,CAAC;AAClE,eAAO,MAAM,iBAAiB,0FAA6B,CAAC"}

package/dist/constants/sns.js

@@ -1,11 +1,31 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
-const SNS_ARN_ENV_VAR_NAME = 'SHARED_AUTHORIZATION_SNS_ENDPOINT_RESOURCE_ATTRIBUTES';
-const SNS_DEV_TEST_NAME = 'arn:aws:sns:us-east-1:000000000000:monday-authorization-resource-attributes-sns-local';
+exports.SnsTopicType = void 0;
+(function (SnsTopicType) {
+    SnsTopicType["RESOURCE"] = "resource";
+    SnsTopicType["ENTITY"] = "entity";
+})(exports.SnsTopicType || (exports.SnsTopicType = {}));
+// Resource SNS constants
+const RESOURCE_SNS_ARN_ENV_VAR_NAME = 'SHARED_AUTHORIZATION_SNS_ENDPOINT_RESOURCE_ATTRIBUTES';
+const RESOURCE_SNS_DEV_TEST_NAME = 'arn:aws:sns:us-east-1:000000000000:monday-authorization-resource-attributes-sns-local';
+// Entity SNS constants
+const ENTITY_SNS_ARN_ENV_VAR_NAME = 'SHARED_AUTHORIZATION_SNS_ENDPOINT_ENTITY_ATTRIBUTES';
+const ENTITY_SNS_DEV_TEST_NAME = 'arn:aws:sns:us-east-1:000000000000:monday-authorization-entity-attributes-sns-local';
 const RESOURCE_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND = 'resourceAttributeModification';
+const ENTITY_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND = 'entityAttributeModification';
 const ASYNC_RESOURCE_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE = 100;
+const ASYNC_ENTITY_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE = 100;
+// Legacy exports for backward compatibility
+const SNS_ARN_ENV_VAR_NAME = RESOURCE_SNS_ARN_ENV_VAR_NAME;
+const SNS_DEV_TEST_NAME = RESOURCE_SNS_DEV_TEST_NAME;
 
+exports.ASYNC_ENTITY_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE = ASYNC_ENTITY_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE;
 exports.ASYNC_RESOURCE_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE = ASYNC_RESOURCE_ATTRIBUTES_MAX_OPERATIONS_PER_MESSAGE;
+exports.ENTITY_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND = ENTITY_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND;
+exports.ENTITY_SNS_ARN_ENV_VAR_NAME = ENTITY_SNS_ARN_ENV_VAR_NAME;
+exports.ENTITY_SNS_DEV_TEST_NAME = ENTITY_SNS_DEV_TEST_NAME;
 exports.RESOURCE_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND = RESOURCE_ATTRIBUTES_SNS_UPDATE_OPERATION_MESSAGE_KIND;
+exports.RESOURCE_SNS_ARN_ENV_VAR_NAME = RESOURCE_SNS_ARN_ENV_VAR_NAME;
+exports.RESOURCE_SNS_DEV_TEST_NAME = RESOURCE_SNS_DEV_TEST_NAME;
 exports.SNS_ARN_ENV_VAR_NAME = SNS_ARN_ENV_VAR_NAME;
 exports.SNS_DEV_TEST_NAME = SNS_DEV_TEST_NAME;

package/dist/entity-attribute-assignment.d.ts

@@ -0,0 +1,14 @@
+import { EntityType } from './entity-attributes-constants';
+import { BaseAttributeAssignment } from './base-attribute-assignment';
+export declare class EntityAttributeAssignment extends BaseAttributeAssignment<number, EntityType> {
+    readonly entityId: number;
+    readonly entityType: EntityType;
+    constructor(entityId: number, entityType: string, attributeKey: string, attributeValue: string);
+    /**
+     * Compares two assignments for equality
+     * @param other Another EntityAttributeAssignment instance
+     * @returns true if all properties are equal
+     */
+    equals(other: EntityAttributeAssignment): boolean;
+}
+//# sourceMappingURL=entity-attribute-assignment.d.ts.map

package/dist/entity-attribute-assignment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-attribute-assignment.d.ts","sourceRoot":"","sources":["../src/entity-attribute-assignment.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,UAAU,EAAE,MAAM,+BAA+B,CAAC;AACzE,OAAO,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAEtE,qBAAa,yBAA0B,SAAQ,uBAAuB,CAAC,MAAM,EAAE,UAAU,CAAC;IACxF,SAAgB,QAAQ,EAAE,MAAM,CAAC;IACjC,SAAgB,UAAU,EAAE,UAAU,CAAC;gBAE3B,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;IAK9F;;;;OAIG;IACH,MAAM,CAAC,KAAK,EAAE,yBAAyB,GAAG,OAAO;CAGlD"}

package/dist/entity-attribute-assignment.js

@@ -0,0 +1,24 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const entityAttributesConstants = require('./entity-attributes-constants.js');
+const baseAttributeAssignment = require('./base-attribute-assignment.js');
+
+class EntityAttributeAssignment extends baseAttributeAssignment.BaseAttributeAssignment {
+    entityId;
+    entityType;
+    constructor(entityId, entityType, attributeKey, attributeValue) {
+        super(entityId, entityType, attributeKey, attributeValue, Object.values(entityAttributesConstants.ENTITY_TYPES), 'entityId', 'entityType');
+        this.entityId = entityId;
+        this.entityType = this.type;
+    }
+    /**
+     * Compares two assignments for equality
+     * @param other Another EntityAttributeAssignment instance
+     * @returns true if all properties are equal
+     */
+    equals(other) {
+        return super.equals(other);
+    }
+}
+
+exports.EntityAttributeAssignment = EntityAttributeAssignment;

package/dist/entity-attributes-constants.d.ts

@@ -0,0 +1,7 @@
+export declare const ENTITY_TYPES: {
+    readonly USER: "user";
+    readonly TEAM: "team";
+    readonly ACCOUNT: "account";
+};
+export type EntityType = (typeof ENTITY_TYPES)[keyof typeof ENTITY_TYPES];
+//# sourceMappingURL=entity-attributes-constants.d.ts.map

package/dist/entity-attributes-constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"entity-attributes-constants.d.ts","sourceRoot":"","sources":["../src/entity-attributes-constants.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,YAAY;;;;CAIf,CAAC;AAEX,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,YAAY,CAAC,CAAC,MAAM,OAAO,YAAY,CAAC,CAAC"}

package/dist/entity-attributes-constants.js

@@ -0,0 +1,9 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const ENTITY_TYPES = {
+    USER: 'user',
+    TEAM: 'team',
+    ACCOUNT: 'account',
+};
+
+exports.ENTITY_TYPES = ENTITY_TYPES;

package/dist/errors/argument-error.d.ts

@@ -0,0 +1,4 @@
+export declare class ArgumentError extends Error {
+    constructor(message: string);
+}
+//# sourceMappingURL=argument-error.d.ts.map

package/dist/errors/argument-error.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"argument-error.d.ts","sourceRoot":"","sources":["../../src/errors/argument-error.ts"],"names":[],"mappings":"AAAA,qBAAa,aAAc,SAAQ,KAAK;gBAC1B,OAAO,EAAE,MAAM;CAK5B"}

package/dist/errors/argument-error.js

@@ -0,0 +1,11 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+class ArgumentError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ArgumentError';
+        Object.setPrototypeOf(this, ArgumentError.prototype);
+    }
+}
+
+exports.ArgumentError = ArgumentError;

package/dist/esm/authorization-attributes-ms-service.d.ts

@@ -0,0 +1,95 @@
+import { ResourceAttributeAssignment } from './resource-attribute-assignment';
+import { EntityAttributeAssignment } from './entity-attribute-assignment';
+import { EntityType } from './types/authorization-attributes-contracts';
+import { IAuthorizationAttributesService } from './types/authorization-attributes-service.interface';
+import { Resource } from './types/general';
+import { ResourceAttributeOperation, EntityAttributeOperation } from './types/authorization-attributes-contracts';
+/**
+ * Service class for managing resource attributes in the authorization microservice.
+ * Provides synchronous HTTP operations to create/update and delete attributes on resources.
+ */
+export declare class AuthorizationAttributesMsService implements IAuthorizationAttributesService {
+    private static LOG_TAG;
+    private static httpClient;
+    /**
+     * Resets the cached HTTP client (useful for testing)
+     */
+    private static resetHttpClient;
+    /**
+     * Gets request headers including Authorization, Content-Type, and optional attribution headers
+     */
+    private static getRequestHeaders;
+    /**
+     * Validates that all messages are instances of the specified message class
+     */
+    private static validateMessages;
+    /**
+     * Generic helper for executing upsert requests
+     */
+    private static executeUpsertRequest;
+    /**
+     * Generic helper for executing delete requests
+     */
+    private static executeDeleteRequest;
+    /**
+     * Creates or updates resource attributes synchronously.
+     * @param accountId The account ID
+     * @param resourceAttributeAssignments Array of ResourceAttributeAssignment objects
+     * @returns Promise<void>
+     */
+    upsertResourceAttributes(accountId: number, resourceAttributeAssignments: ResourceAttributeAssignment[], _appName?: string, _callerActionIdentifier?: string): Promise<void>;
+    /**
+     * 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>
+     */
+    deleteResourceAttributes(accountId: number, resource: Resource, attributeKeys: string[], _appName?: string, _callerActionIdentifier?: string): Promise<void>;
+    /**
+     * Creates or updates entity attributes synchronously.
+     * @param accountId The account ID
+     * @param entityAttributeAssignments Array of EntityAttributeAssignment objects
+     * @returns Promise<void>
+     */
+    upsertEntityAttributes(accountId: number, entityAttributeAssignments: EntityAttributeAssignment[], _appName?: string, _callerActionIdentifier?: string): Promise<void>;
+    /**
+     * 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>
+     */
+    deleteEntityAttributes(accountId: number, entityType: EntityType | string, entityId: number, attributeKeys: string[], _appName?: string, _callerActionIdentifier?: string): Promise<void>;
+    /**
+     * Updates resource attributes (batch operations).
+     * Note: MS service does not support batch operations directly.
+     * This method processes operations sequentially using upsert/delete methods.
+     * @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
+     */
+    updateResourceAttributes(accountId: number, _appName: string, _callerActionIdentifier: string, resourceAttributeOperations: ResourceAttributeOperation[]): Promise<ResourceAttributeOperation[]>;
+    /**
+     * Updates entity attributes (batch operations).
+     * Note: MS service does not support batch operations directly.
+     * This method processes operations sequentially using upsert/delete methods.
+     * @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
+     */
+    updateEntityAttributes(accountId: number, _appName: string, _callerActionIdentifier: string, entityAttributeOperations: EntityAttributeOperation[]): Promise<EntityAttributeOperation[]>;
+    /**
+     * Replaces path template parameters with actual values
+     * @param template Path template with placeholders like {accountId}
+     * @param params Object with parameter names and values
+     * @returns Path with all placeholders replaced
+     */
+    private static replacePathParams;
+}
+//# sourceMappingURL=authorization-attributes-ms-service.d.ts.map

package/dist/esm/authorization-attributes-ms-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"authorization-attributes-ms-service.d.ts","sourceRoot":"","sources":["../../src/authorization-attributes-ms-service.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,2BAA2B,EAAE,MAAM,iCAAiC,CAAC;AAC9E,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AAC1E,OAAO,EAAsB,UAAU,EAAE,MAAM,4CAA4C,CAAC;AAM5F,OAAO,EAAE,+BAA+B,EAAE,MAAM,oDAAoD,CAAC;AACrG,OAAO,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAC3C,OAAO,EAAE,0BAA0B,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AAWlH;;;GAGG;AACH,qBAAa,gCAAiC,YAAW,+BAA+B;IACtF,OAAO,CAAC,MAAM,CAAC,OAAO,CAAiC;IACvD,OAAO,CAAC,MAAM,CAAC,UAAU,CAAqD;IAE9E;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,eAAe;IAI9B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;IA+ChC;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,gBAAgB;IAsD/B;;OAEG;mBACkB,oBAAoB;IA4EzC;;OAEG;mBACkB,oBAAoB;IA2EzC;;;;;OAKG;IACG,wBAAwB,CAC5B,SAAS,EAAE,MAAM,EACjB,4BAA4B,EAAE,2BAA2B,EAAE,EAC3D,QAAQ,CAAC,EAAE,MAAM,EACjB,uBAAuB,CAAC,EAAE,MAAM,GAC/B,OAAO,CAAC,IAAI,CAAC;IAYhB;;;;;;OAMG;IACG,wBAAwB,CAC5B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,QAAQ,EAClB,aAAa,EAAE,MAAM,EAAE,EACvB,QAAQ,CAAC,EAAE,MAAM,EACjB,uBAAuB,CAAC,EAAE,MAAM,GAC/B,OAAO,CAAC,IAAI,CAAC;IAyBhB;;;;;OAKG;IACG,sBAAsB,CAC1B,SAAS,EAAE,MAAM,EACjB,0BAA0B,EAAE,yBAAyB,EAAE,EACvD,QAAQ,CAAC,EAAE,MAAM,EACjB,uBAAuB,CAAC,EAAE,MAAM,GAC/B,OAAO,CAAC,IAAI,CAAC;IAYhB;;;;;;;OAOG;IACG,sBAAsB,CAC1B,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,UAAU,GAAG,MAAM,EAC/B,QAAQ,EAAE,MAAM,EAChB,aAAa,EAAE,MAAM,EAAE,EACvB,QAAQ,CAAC,EAAE,MAAM,EACjB,uBAAuB,CAAC,EAAE,MAAM,GAC/B,OAAO,CAAC,IAAI,CAAC;IAoBhB;;;;;;;;;OASG;IACG,wBAAwB,CAC5B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,uBAAuB,EAAE,MAAM,EAC/B,2BAA2B,EAAE,0BAA0B,EAAE,GACxD,OAAO,CAAC,0BAA0B,EAAE,CAAC;IAoCxC;;;;;;;;;OASG;IACG,sBAAsB,CAC1B,SAAS,EAAE,MAAM,EACjB,QAAQ,EAAE,MAAM,EAChB,uBAAuB,EAAE,MAAM,EAC/B,yBAAyB,EAAE,wBAAwB,EAAE,GACpD,OAAO,CAAC,wBAAwB,EAAE,CAAC;IAyBtC;;;;;OAKG;IACH,OAAO,CAAC,MAAM,CAAC,iBAAiB;CAOjC"}

package/dist/esm/authorization-attributes-ms-service.mjs

@@ -0,0 +1,360 @@
+import { Api } from '@mondaydotcomorg/trident-backend-api';
+import { signAuthorizationHeader } from '@mondaydotcomorg/monday-jwt';
+import { z } from 'zod';
+import { ResourceAttributeAssignment } from './resource-attribute-assignment.mjs';
+import { EntityAttributeAssignment } from './entity-attribute-assignment.mjs';
+import { AttributeOperation } from './types/authorization-attributes-contracts.mjs';
+import { ArgumentError } from './errors/argument-error.mjs';
+import { logger, AuthorizationInternalService } from './authorization-internal-service.mjs';
+import { getAttributionsFromApi } from './attributions-service.mjs';
+import { APP_NAME } from './constants.mjs';
+import { ValidationUtils } from './utils/validation.mjs';
+
+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}';
+/**
+ * Service class for managing resource attributes in the authorization microservice.
+ * Provides synchronous HTTP operations to create/update and delete attributes on resources.
+ */
+class AuthorizationAttributesMsService {
+    static LOG_TAG = 'authorization_attributes_ms';
+    static httpClient = Api.getPart('httpClient');
+    /**
+     * Resets the cached HTTP client (useful for testing)
+     */
+    static resetHttpClient() {
+        AuthorizationAttributesMsService.httpClient = undefined;
+    }
+    /**
+     * Gets request headers including Authorization, Content-Type, and optional attribution headers
+     */
+    static getRequestHeaders(accountId, userId) {
+        const headers = {
+            '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 (Object.prototype.hasOwnProperty.call(attributionHeaders, 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 = {};
+                    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: AuthorizationAttributesMsService.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
+     */
+    static validateMessages(attributesMessages, messageClass) {
+        // Validate messageClass is a function using Zod
+        const classSchema = z.custom(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
+     */
+    static async executeUpsertRequest(accountId, assignments, pathTemplate, requestBodyKey, assignmentClass, logPrefix, methodName) {
+        // Validate inputs
+        ValidationUtils.validateInteger(accountId, 'accountId');
+        ValidationUtils.validateArray(assignments, 'assignments');
+        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 requestBody = requestBodyKey === 'resourceAttributeAssignments'
+            ? { resourceAttributeAssignments: assignments }
+            : { entityAttributeAssignments: assignments };
+        if (!AuthorizationAttributesMsService.httpClient) {
+            throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
+        }
+        const path = AuthorizationAttributesMsService.replacePathParams(pathTemplate, { accountId });
+        const headers = AuthorizationAttributesMsService.getRequestHeaders(accountId);
+        try {
+            logger.info({ tag: AuthorizationAttributesMsService.LOG_TAG, accountId, count: assignments.length }, `Upserting ${logPrefix} attributes`);
+            await AuthorizationAttributesMsService.httpClient.fetch({
+                url: {
+                    appName: APP_NAME,
+                    path,
+                },
+                method: 'POST',
+                headers,
+                body: JSON.stringify(requestBody),
+            }, {
+                timeout: AuthorizationInternalService.getRequestTimeout(),
+                retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
+            });
+            logger.debug({ tag: AuthorizationAttributesMsService.LOG_TAG, accountId, count: assignments.length }, `Successfully upserted ${logPrefix} attributes`);
+        }
+        catch (err) {
+            const error = err;
+            logger.error({
+                tag: AuthorizationAttributesMsService.LOG_TAG,
+                method: methodName,
+                accountId,
+                error: error instanceof Error ? error.message : String(error),
+            }, `Failed in ${methodName}`);
+            throw error;
+        }
+    }
+    /**
+     * Generic helper for executing delete requests
+     */
+    static async executeDeleteRequest(accountId, pathTemplate, pathParams, keys, logPrefix, methodName, context = {}) {
+        // Validate inputs
+        ValidationUtils.validateInteger(accountId, 'accountId');
+        ValidationUtils.validateArray(keys, 'attributeKeys');
+        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 = {
+            keys,
+        };
+        if (!AuthorizationAttributesMsService.httpClient) {
+            throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
+        }
+        const path = AuthorizationAttributesMsService.replacePathParams(pathTemplate, { accountId, ...pathParams });
+        const headers = AuthorizationAttributesMsService.getRequestHeaders(accountId);
+        try {
+            logger.info({ tag: AuthorizationAttributesMsService.LOG_TAG, accountId, ...pathParams, keys }, `Deleting ${logPrefix} attributes`);
+            await AuthorizationAttributesMsService.httpClient.fetch({
+                url: {
+                    appName: APP_NAME,
+                    path,
+                },
+                method: 'DELETE',
+                headers,
+                body: JSON.stringify(requestBody),
+            }, {
+                timeout: AuthorizationInternalService.getRequestTimeout(),
+                retryPolicy: AuthorizationInternalService.getRetriesPolicy(),
+            });
+            logger.info({ tag: AuthorizationAttributesMsService.LOG_TAG, accountId, ...pathParams, keys }, `Successfully deleted ${logPrefix} attributes`);
+        }
+        catch (err) {
+            const error = err;
+            logger.error({
+                tag: AuthorizationAttributesMsService.LOG_TAG,
+                method: methodName,
+                accountId,
+                ...pathParams,
+                ...context,
+                error: error instanceof Error ? error.message : String(error),
+            }, `Failed in ${methodName}`);
+            throw error;
+        }
+    }
+    /**
+     * Creates or updates resource attributes synchronously.
+     * @param accountId The account ID
+     * @param resourceAttributeAssignments Array of ResourceAttributeAssignment objects
+     * @returns Promise<void>
+     */
+    async upsertResourceAttributes(accountId, resourceAttributeAssignments, _appName, _callerActionIdentifier) {
+        return AuthorizationAttributesMsService.executeUpsertRequest(accountId, resourceAttributeAssignments, UPSERT_RESOURCE_ATTRIBUTES_PATH, 'resourceAttributeAssignments', ResourceAttributeAssignment, 'resource', 'upsertResourceAttributesSync');
+    }
+    /**
+     * 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>
+     */
+    async deleteResourceAttributes(accountId, resource, attributeKeys, _appName, _callerActionIdentifier) {
+        // 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');
+        return AuthorizationAttributesMsService.executeDeleteRequest(accountId, DELETE_RESOURCE_ATTRIBUTES_PATH, {
+            resourceType: resource.type,
+            resourceId: resource.id,
+        }, attributeKeys, 'resource', 'deleteResourceAttributesSync', { resource });
+    }
+    /**
+     * Creates or updates entity attributes synchronously.
+     * @param accountId The account ID
+     * @param entityAttributeAssignments Array of EntityAttributeAssignment objects
+     * @returns Promise<void>
+     */
+    async upsertEntityAttributes(accountId, entityAttributeAssignments, _appName, _callerActionIdentifier) {
+        return AuthorizationAttributesMsService.executeUpsertRequest(accountId, entityAttributeAssignments, UPSERT_ENTITY_ATTRIBUTES_PATH, 'entityAttributeAssignments', EntityAttributeAssignment, 'entity', 'upsertEntityAttributesSync');
+    }
+    /**
+     * 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>
+     */
+    async deleteEntityAttributes(accountId, entityType, entityId, attributeKeys, _appName, _callerActionIdentifier) {
+        if (!entityType || typeof entityType !== 'string' || entityType.trim() === '') {
+            throw new ArgumentError(`entityType must be a non-empty string, got: ${entityType}`);
+        }
+        ValidationUtils.validateInteger(entityId, 'entityId');
+        return AuthorizationAttributesMsService.executeDeleteRequest(accountId, DELETE_ENTITY_ATTRIBUTES_PATH, {
+            entityType,
+            entityId,
+        }, attributeKeys, 'entity', 'deleteEntityAttributesSync', { entityType, entityId });
+    }
+    /**
+     * Updates resource attributes (batch operations).
+     * Note: MS service does not support batch operations directly.
+     * This method processes operations sequentially using upsert/delete methods.
+     * @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
+     */
+    async updateResourceAttributes(accountId, _appName, _callerActionIdentifier, resourceAttributeOperations) {
+        const processedOperations = [];
+        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);
+            }
+        }
+        return processedOperations;
+    }
+    /**
+     * Updates entity attributes (batch operations).
+     * Note: MS service does not support batch operations directly.
+     * This method processes operations sequentially using upsert/delete methods.
+     * @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
+     */
+    async updateEntityAttributes(accountId, _appName, _callerActionIdentifier, entityAttributeOperations) {
+        const processedOperations = [];
+        for (const operation of entityAttributeOperations) {
+            if (operation.operationType === 'upsert') {
+                const upsertOp = operation;
+                await this.upsertEntityAttributes(accountId, [
+                    new EntityAttributeAssignment(operation.entityId, operation.entityType, operation.key, upsertOp.value || ''),
+                ]);
+                processedOperations.push(operation);
+            }
+            else if (operation.operationType === 'delete') {
+                await this.deleteEntityAttributes(accountId, operation.entityType, operation.entityId, [
+                    operation.key,
+                ]);
+                processedOperations.push(operation);
+            }
+        }
+        return processedOperations;
+    }
+    /**
+     * Replaces path template parameters with actual values
+     * @param template Path template with placeholders like {accountId}
+     * @param params Object with parameter names and values
+     * @returns Path with all placeholders replaced
+     */
+    static replacePathParams(template, params) {
+        let path = template;
+        for (const [key, value] of Object.entries(params)) {
+            path = path.replace(`{${key}}`, String(value));
+        }
+        return path;
+    }
+}
+
+export { AuthorizationAttributesMsService };