@mondaydotcomorg/monday-authorization 3.5.2-feat-shaime-support-entity-attributes-4-ddec1d3 → 3.5.2-feat-shaime-support-entity-attributes-3-00b45ac

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

@@ -6,16 +6,16 @@ import {
   AttributeOperation,
   ResourceAttributeOperation,
   EntityAttributeOperation,
+  ResourceAttributeResponse,
 } 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 { Resource } from './types/general';
-import { StringNullableChain } from 'lodash';
+
 const INTERNAL_APP_NAME = 'internal_ms';
 const UPSERT_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource';
 const DELETE_RESOURCE_ATTRIBUTES_PATH = '/attributes/{accountId}/resource/{resourceType}/{resourceId}';
@@ -32,34 +32,7 @@ interface DeleteRequestBody {
  */
 export class AuthorizationAttributesMsService implements AuthorizationAttributesService {
   private static LOG_TAG = 'authorization_attributes_ms';
-  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
-   * @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'
-    );
-  }
+  private static httpClient: HttpClient | undefined = Api.getPart('httpClient');
 
   /**
    * Deletes specific attributes from a resource synchronously.
@@ -76,41 +49,16 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
     _callerActionIdentifier?: string
   ): Promise<void> {
     ValidationUtils.validateResource(resource);
-    ValidationUtils.validateStringArray(attributeKeys);
     return AuthorizationAttributesMsService.executeDeleteRequest(
       accountId,
       DELETE_RESOURCE_ATTRIBUTES_PATH,
       {
         resourceType: resource.type,
-        resourceId: resource.id as number,
+        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: number,
-    entityAttributeAssignments: EntityAttributeAssignment[],
-    _appName?: string,
-    _callerActionIdentifier?: string
-  ): Promise<void> {
-    return AuthorizationAttributesMsService.executeUpsertRequest(
-      accountId,
-      entityAttributeAssignments,
-      UPSERT_ENTITY_ATTRIBUTES_PATH,
-      'entityAttributeAssignments',
-      EntityAttributeAssignment,
-      'entity',
-      'upsertEntityAttributesSync'
+      'deleteResourceAttributesSync'
     );
   }
 
@@ -130,11 +78,7 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
     _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);
-
+    ValidationUtils.validateInteger(accountId);
     return AuthorizationAttributesMsService.executeDeleteRequest(
       accountId,
       DELETE_ENTITY_ATTRIBUTES_PATH,
@@ -144,8 +88,7 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
       },
       attributeKeys,
       'entity',
-      'deleteEntityAttributesSync',
-      { entityType, entityId }
+      'deleteEntityAttributesSync'
     );
   }
 
@@ -165,39 +108,38 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
     _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');
+    // Process all operations in parallel using Promise.all
+    await Promise.all(
+      resourceAttributeOperations.map(async operation => {
+        ValidationUtils.validateResourceAssignment({
+          resourceId: operation.resourceId,
+          resourceType: operation.resourceType,
+          key: operation.key,
+          value: operation.value || '',
+        });
+        if (operation.operationType === AttributeOperation.UPSERT) {
+          await this.upsertResourceAttributes(accountId, [
+            new ResourceAttributeAssignment(
+              operation.resourceId,
+              operation.resourceType,
+              operation.key,
+              operation.value || ''
+            ),
+          ]);
+        } else if (operation.operationType === AttributeOperation.DELETE) {
+          await this.deleteResourceAttributes(
+            accountId,
+            {
+              type: operation.resourceType,
+              id: operation.resourceId,
+            },
+            [operation.key]
+          );
         }
-        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;
+    return resourceAttributeOperations;
   }
 
   /**
@@ -216,20 +158,40 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
     _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);
-      }
-    }
+    // Process all operations in parallel using Promise.all
+    await Promise.all(
+      entityAttributeOperations.map(async operation => {
+        // Validate before processing
+        ValidationUtils.validateEntityAssignment({
+          entityId: operation.entityId,
+          entityType: operation.entityType,
+          key: operation.key,
+          value: operation.value || '',
+        });
+
+        if (operation.operationType === 'upsert') {
+          await AuthorizationAttributesMsService.executeUpsertRequest(
+            accountId,
+            [
+              new EntityAttributeAssignment(
+                operation.entityId,
+                operation.entityType,
+                operation.key,
+                operation.value || ''
+              ),
+            ],
+            UPSERT_ENTITY_ATTRIBUTES_PATH,
+            'entityAttributeAssignments',
+            'entity',
+            'upsertEntityAttributesSync'
+          );
+        } else if (operation.operationType === 'delete') {
+          await this.deleteEntityAttributes(accountId, operation.entityType, operation.entityId, [operation.key]);
+        }
+      })
+    );
 
-    return processedOperations;
+    return entityAttributeOperations;
   }
 
   /**
@@ -255,8 +217,7 @@ 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);
@@ -307,7 +268,6 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
           method: methodName,
           accountId,
           ...pathParams,
-          ...context,
           error: err instanceof Error ? err.message : String(err),
         },
         `Failed in ${methodName}`
@@ -374,15 +334,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 =
@@ -435,4 +389,26 @@ export class AuthorizationAttributesMsService implements AuthorizationAttributes
       throw err;
     }
   }
+
+  private async upsertResourceAttributes(
+    accountId: number,
+    resourceAttributeAssignments: ResourceAttributeAssignment[]
+  ): Promise<ResourceAttributeResponse> {
+    const attributionHeaders = getAttributionsFromApi();
+    if (!AuthorizationAttributesMsService.httpClient) {
+      throw new Error('AuthorizationAttributesMsService: HTTP client is not initialized');
+    }
+    return await AuthorizationAttributesMsService.httpClient.fetch<ResourceAttributeResponse>({
+      url: {
+        appName: APP_NAME,
+        path: UPSERT_RESOURCE_ATTRIBUTES_PATH.replace('{accountId}', accountId.toString()),
+      },
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        ...attributionHeaders,
+      },
+      body: JSON.stringify({ resourceAttributeAssignments }),
+    });
+  }
 }

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

@@ -1,12 +1,10 @@
 import chunk from 'lodash/chunk.js';
 import { getTopicAttributes, sendToSns } from '@mondaydotcomorg/monday-sns';
 import {
-  ResourceAttributeAssignment,
   ResourceAttributeOperation,
   EntityAttributeOperation,
   AttributeOperation,
 } from './types/authorization-attributes-contracts';
-import { EntityAttributeAssignment } from './entity-attribute-assignment';
 import { Resource } from './types/general';
 import { logger } from './authorization-internal-service';
 import {
@@ -20,9 +18,10 @@ import {
   ENTITY_SNS_DEV_TEST_NAME,
   SnsTopicType,
 } from './constants/sns';
-import type { TopicAttributesMap } from 'aws-sdk/clients/sns';
 import { AuthorizationAttributesService } from './types/authorization-attributes-service.interface';
 import { EntityType } from './entity-attributes-constants';
+import { ValidationUtils } from './utils/validation';
+import type { TopicAttributesMap } from 'aws-sdk/clients/sns';
 
 /**
  * Service class for managing resource attributes asynchronously via SNS.
@@ -41,31 +40,6 @@ export class AuthorizationAttributesSnsService implements AuthorizationAttribute
     this.entitySnsArn = AuthorizationAttributesSnsService.getSnsTopicArn(SnsTopicType.ENTITY);
   }
 
-  /**
-   * Async function to upsert resource attributes using SNS.
-   * Sends the updates request to SNS and returns before the change actually took place.
-   * @param accountId The account ID
-   * @param appName App name of the calling app
-   * @param callerActionIdentifier Action identifier
-   * @param resourceAttributeAssignments Array of resource attribute assignments to upsert
-   * @return Promise with array of sent operations
-   */
-  async upsertResourceAttributes(
-    accountId: number,
-    resourceAttributeAssignments: ResourceAttributeAssignment[],
-    appName?: string,
-    callerActionIdentifier?: string
-  ): Promise<ResourceAttributeOperation[]> {
-    if (!appName || !callerActionIdentifier) {
-      throw new Error('appName and callerActionIdentifier are required for SNS service');
-    }
-    const operations: ResourceAttributeOperation[] = resourceAttributeAssignments.map(assignment => ({
-      ...assignment,
-      operationType: AttributeOperation.UPSERT,
-    }));
-    return this.updateResourceAttributes(accountId, appName, callerActionIdentifier, operations);
-  }
-
   /**
    * Async function to delete resource attributes using SNS.
    * Sends the updates request to SNS and returns before the change actually took place.
@@ -90,7 +64,7 @@ export class AuthorizationAttributesSnsService implements AuthorizationAttribute
       key =>
         ({
           resourceType: resource.type,
-          resourceId: resource.id!,
+          resourceId: resource.id,
           key,
           operationType: AttributeOperation.DELETE,
         } as ResourceAttributeOperation)
@@ -98,36 +72,6 @@ export class AuthorizationAttributesSnsService implements AuthorizationAttribute
     return this.updateResourceAttributes(accountId, appName, callerActionIdentifier, operations);
   }
 
-  /**
-   * Async function to upsert entity attributes using SNS.
-   * Sends the updates request to SNS and returns before the change actually took place.
-   * @param accountId The account ID
-   * @param appName App name of the calling app
-   * @param callerActionIdentifier Action identifier
-   * @param entityAttributeAssignments Array of entity attribute assignments to upsert
-   * @return Promise with array of sent operations
-   */
-  async upsertEntityAttributes(
-    accountId: number,
-    entityAttributeAssignments: EntityAttributeAssignment[],
-    appName?: string,
-    callerActionIdentifier?: string
-  ): Promise<EntityAttributeOperation[]> {
-    if (!appName || !callerActionIdentifier) {
-      throw new Error('appName and callerActionIdentifier are required for SNS service');
-    }
-    const operations: EntityAttributeOperation[] = entityAttributeAssignments.map(assignment => {
-      return {
-        entityId: assignment.entityId,
-        entityType: assignment.entityType,
-        key: assignment.attributeKey,
-        value: assignment.attributeValue,
-        operationType: AttributeOperation.UPSERT,
-      };
-    });
-    return this.updateEntityAttributes(accountId, appName, callerActionIdentifier, operations);
-  }
-
   /**
    * Async function to delete entity attributes using SNS.
    * Sends the updates request to SNS and returns before the change actually took place.
@@ -141,7 +85,7 @@ export class AuthorizationAttributesSnsService implements AuthorizationAttribute
    */
   async deleteEntityAttributes(
     accountId: number,
-    entityType: EntityType | string,
+    entityType: EntityType,
     entityId: number,
     attributeKeys: string[],
     appName?: string,
@@ -150,15 +94,16 @@ export class AuthorizationAttributesSnsService implements AuthorizationAttribute
     if (!appName || !callerActionIdentifier) {
       throw new Error('appName and callerActionIdentifier are required for SNS service');
     }
-    const operations: EntityAttributeOperation[] = attributeKeys.map(
-      key =>
-        ({
-          entityType: entityType,
-          entityId,
-          key,
-          operationType: AttributeOperation.DELETE,
-        } as EntityAttributeOperation)
-    );
+    const operations: EntityAttributeOperation[] = attributeKeys.map(key => {
+      ValidationUtils.validateEntityAssignment({ entityId, entityType, key, value: '' });
+      return {
+        entityType: entityType,
+        entityId,
+        key,
+        operationType: AttributeOperation.DELETE,
+        value: '',
+      };
+    });
     return this.updateEntityAttributes(accountId, appName, callerActionIdentifier, operations);
   }
 

package/src/base-attribute-assignment.ts

@@ -1,36 +1,20 @@
-import { ValidationUtils } from './utils/validation';
 import isEqual from 'lodash/isEqual.js';
-import { EntityAttributeAssignment, ResourceAttributeDelete } from './types/authorization-attributes-contracts';
 
 /**
  * Base class for attribute assignments (Resource or Entity)
  * Provides common validation and functionality
  */
-export abstract class BaseAttributeAssignment<TId extends number, TType extends string> {
-  public readonly id: TId;
-  public readonly type: TType;
+export abstract class BaseAttributeAssignment<T, R> {
+  public readonly id: number;
+  public readonly type: T;
   public readonly attributeKey: string;
   public readonly attributeValue: string;
 
-  constructor(
-    id: TId,
-    type: string,
-    attributeKey: string,
-    attributeValue: string,
-    validTypes: readonly string[],
-    idFieldName: string,
-    typeFieldName: string
-  ) {
-    const validated = ValidationUtils.validateAssignment<TType>(
-      { id, type, attributeKey, attributeValue },
-      validTypes as readonly TType[],
-      { id: idFieldName, type: typeFieldName }
-    );
-
-    this.id = validated.id as TId;
-    this.type = validated.type as TType;
-    this.attributeKey = validated.attributeKey;
-    this.attributeValue = validated.attributeValue;
+  constructor(id: number, type: T, attributeKey: string, attributeValue: string) {
+    this.id = id;
+    this.type = type;
+    this.attributeKey = attributeKey;
+    this.attributeValue = attributeValue;
   }
 
   /**
@@ -38,9 +22,9 @@ export abstract class BaseAttributeAssignment<TId extends number, TType extends
    * @param other Another assignment instance
    * @returns true if all properties are equal
    */
-  equals(other: BaseAttributeAssignment<TId, TType>): boolean {
+  equals(other: BaseAttributeAssignment<T, R>): boolean {
     return isEqual(this, other);
   }
 
-  abstract toDataTransferObject(): EntityAttributeAssignment | ResourceAttributeDelete;
+  abstract toDataTransferObject(): R;
 }

package/src/entity-attribute-assignment.ts

@@ -1,17 +1,20 @@
-import { ENTITY_TYPES, EntityType } from './entity-attributes-constants';
+import { EntityType } from './entity-attributes-constants';
 import { BaseAttributeAssignment } from './base-attribute-assignment';
+import { EntityAttributeAssignment as EntityAttributeAssignmentContract } from './types/authorization-attributes-contracts';
+import { ValidationUtils } from './utils/validation';
 
-export class EntityAttributeAssignment extends BaseAttributeAssignment<number, EntityType> {
+export class EntityAttributeAssignment extends BaseAttributeAssignment<EntityType, EntityAttributeAssignmentContract> {
   public readonly entityId: number;
   public readonly entityType: EntityType;
 
-  constructor(entityId: number, entityType: string, attributeKey: string, attributeValue: string) {
-    super(entityId, entityType, attributeKey, attributeValue, ENTITY_TYPES, 'entityId', 'entityType');
+  constructor(entityId: number, entityType: EntityType, attributeKey: string, attributeValue: string) {
+    ValidationUtils.validateEntityAssignment({ entityId, entityType, key: attributeKey, value: attributeValue });
+    super(entityId, entityType, attributeKey, attributeValue);
     this.entityId = entityId;
-    this.entityType = this.type;
+    this.entityType = entityType;
   }
 
-  toDataTransferObject() {
+  toDataTransferObject(): EntityAttributeAssignmentContract {
     return {
       entityId: this.entityId,
       entityType: this.entityType,

package/src/errors/argument-error.ts

@@ -2,6 +2,5 @@ export class ArgumentError extends Error {
   constructor(message: string) {
     super(message);
     this.name = 'ArgumentError';
-    Object.setPrototypeOf(this, ArgumentError.prototype);
   }
 }

package/src/resource-attribute-assignment.ts

@@ -1,25 +1,23 @@
-import { RESOURCE_TYPES, ResourceType } from './resource-attributes-constants';
+import { ResourceType } from './resource-attributes-constants';
 import { BaseAttributeAssignment } from './base-attribute-assignment';
+import { ResourceAttributeAssignment as ResourceAttributeAssignmentContract } from './types/authorization-attributes-contracts';
+import { ValidationUtils } from './utils/validation';
 
-export class ResourceAttributeAssignment extends BaseAttributeAssignment<number, ResourceType> {
+export class ResourceAttributeAssignment extends BaseAttributeAssignment<
+  ResourceType,
+  ResourceAttributeAssignmentContract
+> {
   public readonly resourceId: number;
   public readonly resourceType: ResourceType;
 
   constructor(resourceId: number, resourceType: ResourceType, attributeKey: string, attributeValue: string) {
-    super(
-      resourceId,
-      resourceType,
-      attributeKey,
-      attributeValue,
-      Object.values(RESOURCE_TYPES),
-      'resourceId',
-      'resourceType'
-    );
+    ValidationUtils.validateResourceAssignment({ resourceId, resourceType, key: attributeKey, value: attributeValue });
+    super(resourceId, resourceType, attributeKey, attributeValue);
     this.resourceId = resourceId;
     this.resourceType = this.type;
   }
 
-  toDataTransferObject() {
+  toDataTransferObject(): ResourceAttributeAssignmentContract {
     return {
       resourceId: this.resourceId,
       resourceType: this.resourceType,

package/src/resource-attributes-constants.ts

@@ -1,4 +1,4 @@
-export const RESOURCE_ATTRIBUTES_CONSTANTS = {
+export const RESOURCE_ATTRIBUTES_CONSTANTS = Object.freeze({
   ACCOUNT_RESOURCE_ATTRIBUTES: {
     ENABLE_MEMBERS_INVITE_FROM_NON_AUTH_DOMAIN: 'enable_members_invite_from_non_auth_domain',
   },
@@ -9,7 +9,7 @@ export const RESOURCE_ATTRIBUTES_CONSTANTS = {
     IS_SYNCABLE_CHILD_ENTITY: 'is_syncable_child_entity',
     SYSTEM_ENTITY_TYPE: 'system_entity_type',
   },
-} as const;
+});
 
 export enum ResourceType {
   Account = 'account',

package/src/testKit/index.ts

@@ -1,4 +1,4 @@
-import { BaseRequest, BaseResponse, ContextGetter, Resource, ResourceGetter } from '../types/general';
+import { Action, BaseRequest, BaseResponse, ContextGetter, Resource, ResourceGetter } from '../types/general';
 import { defaultContextGetter } from '../authorization-middleware';
 import { AuthorizationInternalService } from '../authorization-internal-service';
 import type { NextFunction } from 'express';
@@ -7,11 +7,11 @@ export type TestPermittedAction = {
   accountId: number;
   userId: number;
   resources: Resource[];
-  action: string;
+  action: Action;
 };
 
 let testPermittedActions: TestPermittedAction[] = [];
-export const addTestPermittedAction = (accountId: number, userId: number, resources: Resource[], action: string) => {
+export const addTestPermittedAction = (accountId: number, userId: number, resources: Resource[], action: Action) => {
   testPermittedActions.push({ accountId, userId, resources, action });
 };
 
@@ -19,7 +19,7 @@ export const clearTestPermittedActions = () => {
   testPermittedActions = [];
 };
 
-const isActionAuthorized = (accountId: number, userId: number, resources: Resource[], action: string) => {
+const isActionAuthorized = (accountId: number, userId: number, resources: Resource[], action: Action) => {
   // If no resources to check, deny access
   if (resources.length === 0) {
     return { isAuthorized: false };
@@ -46,7 +46,7 @@ const isActionAuthorized = (accountId: number, userId: number, resources: Resour
 };
 
 export const getTestAuthorizationMiddleware = (
-  action: string,
+  action: Action,
   resourceGetter: ResourceGetter,
   contextGetter?: ContextGetter
 ) => {

package/src/types/authorization-attributes-contracts.ts

@@ -2,7 +2,7 @@ import { Resource } from './general';
 import type { EntityType } from '../entity-attributes-constants';
 import type { ResourceType } from '../resource-attributes-constants';
 
-interface AttributeAssignment {
+export interface AttributeAssignment {
   key: string;
   value: string;
 }