@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/types/authorization-attributes-service.interface.ts

@@ -1,13 +1,6 @@
-import {
-  ResourceAttributeAssignment as ResourceAttributeAssignmentContract,
-  EntityAttributeAssignment as EntityAttributeAssignmentContract,
-  ResourceAttributeOperation,
-  EntityAttributeOperation,
-} from './authorization-attributes-contracts';
-import { ResourceAttributeAssignment } from '../resource-attribute-assignment';
-import { EntityAttributeAssignment } from '../entity-attribute-assignment';
-import { Resource } from './general';
 import { EntityType } from '../entity-attributes-constants';
+import { ResourceAttributeOperation, EntityAttributeOperation } from './authorization-attributes-contracts';
+import { Resource } from './general';
 
 /**
  * Resource type compatible with both MS and SNS services
@@ -24,18 +17,6 @@ export interface CompatibleResource {
  * Both MS (direct) and SNS (async) services implement this interface.
  */
 export interface AuthorizationAttributesService {
-  /**authorization-attributes-service.ts
-   * Upserts resource attributes.
-   * For MS service: returns Promise<void>
-   * For SNS service: requires appName and callerActionIdentifier, returns Promise<ResourceAttributesOperation[]>
-   */
-  upsertResourceAttributes(
-    accountId: number,
-    resourceAttributeAssignments: ResourceAttributeAssignment[] | ResourceAttributeAssignmentContract[],
-    appName?: string,
-    callerActionIdentifier?: string
-  ): Promise<void | ResourceAttributeOperation[]>;
-
   /**
    * Deletes resource attributes.
    * For MS service: returns Promise<void>
@@ -49,18 +30,6 @@ export interface AuthorizationAttributesService {
     callerActionIdentifier?: string
   ): Promise<void | ResourceAttributeOperation[]>;
 
-  /**
-   * Upserts entity attributes.
-   * For MS service: returns Promise<void>
-   * For SNS service: requires appName and callerActionIdentifier, returns Promise<EntityAttributesOperation[]>
-   */
-  upsertEntityAttributes(
-    accountId: number,
-    entityAttributeAssignments: EntityAttributeAssignment[] | EntityAttributeAssignmentContract[],
-    appName?: string,
-    callerActionIdentifier?: string
-  ): Promise<void | EntityAttributeOperation[]>;
-
   /**
    * Deletes entity attributes.
    * For MS service: returns Promise<void>

package/src/types/general.ts

@@ -1,7 +1,7 @@
 import type { Request, Response } from 'express';
 
 export interface Resource {
-  id?: number;
+  id: number;
   type: string;
   wrapperData?: object;
 }

package/src/utils/assigment-schema.ts

@@ -0,0 +1,29 @@
+import Ajv from 'ajv';
+import { EntityType } from '../entity-attributes-constants';
+import { ResourceType } from '../resource-attributes-constants';
+
+const ajv = new Ajv({ allErrors: true });
+
+export const entityAssignmentSchema = ajv.compile({
+  type: 'object',
+  properties: {
+    entityId: { type: 'number', multipleOf: 1 },
+    entityType: { type: 'string', enum: Object.values(EntityType) },
+    key: { type: 'string', minLength: 1 },
+    value: { type: 'string' },
+  },
+  required: ['entityId', 'entityType', 'key'],
+  additionalProperties: false,
+});
+
+export const resourceAssignmentSchema = ajv.compile({
+  type: 'object',
+  properties: {
+    id: { type: 'number', multipleOf: 1 },
+    type: { type: 'string', enum: Object.values(ResourceType) },
+    key: { type: 'string', minLength: 1 },
+    value: { type: 'string' },
+  },
+  required: ['id', 'type', 'key'],
+  additionalProperties: false,
+});

package/src/utils/resource-schema.ts

@@ -0,0 +1,21 @@
+import Ajv from 'ajv';
+import { RESOURCE_TYPES } from '../resource-attributes-constants';
+
+const ajv = new Ajv({ allErrors: true });
+
+export interface Resource {
+  id?: number;
+  type: string;
+  wrapperData?: object;
+}
+
+export const resourceSchema = ajv.compile({
+  type: 'object',
+  properties: {
+    id: { type: 'number', multipleOf: 1 },
+    type: { type: 'string', enum: RESOURCE_TYPES },
+    wrapperData: { type: 'string', minLength: 1 },
+  },
+  required: ['id', 'type', 'wrapperData'],
+  additionalProperties: false,
+});

package/src/utils/validation.ts

@@ -1,171 +1,93 @@
-import Ajv from 'ajv';
+import Ajv, { ValidateFunction, ErrorObject } from 'ajv';
 import { ArgumentError } from '../errors/argument-error';
+import { ResourceAttributeAssignment, EntityAttributeAssignment } from '../types/authorization-attributes-contracts';
 import { Resource } from '../types/general';
+import { entityAssignmentSchema, resourceAssignmentSchema } from './assigment-schema';
+import { resourceSchema } from './resource-schema';
 
 /**
  * Utility class for common validation operations using AJV
  */
 export class ValidationUtils {
   private static ajv = new Ajv({ allErrors: true });
-  /**
-   * Validates that a value is an integer. Throws ArgumentError with a descriptive message on failure.
-   */
-  static validateInteger(value: number): void {
-    const numberSchema = { type: 'number', multipleOf: 1 };
-    const validate = ValidationUtils.ajv.compile(numberSchema);
-    const isValid = validate(value);
-    if (!isValid) {
-      throw new ArgumentError(`Value must be an integer, got: ${value}`);
+
+  private static integerValidator: ValidateFunction = this.ajv.compile({ type: 'number', multipleOf: 1 });
+  private static stringValidator: ValidateFunction = this.ajv.compile({ type: 'string', minLength: 1 });
+  private static stringArrayValidator: ValidateFunction = this.ajv.compile({
+    type: 'array',
+    items: { type: 'string' },
+  });
+
+  public static validateInteger(value: number): void {
+    const valid = this.integerValidator(value);
+    if (!valid) {
+      throw new ArgumentError('Invalid integer');
     }
   }
 
-  /**
-   * Validates that a value is a non-empty string. Throws ArgumentError on failure.
-   */
-  static validateString(value: string): void {
-    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 ArgumentError(`Value must be a non-empty string, got: ${value}`);
+  public static validateString(value: string): void {
+    const valid = this.stringValidator(value);
+    if (!valid) {
+      throw new 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: string[]): void {
-    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);
+  public static validateStringArray(value: string[]): void {
+    const valid = this.stringArrayValidator(value);
+    if (!valid) {
+      throw new ArgumentError('Invalid string array');
+    }
+  }
+
+  public static validateResource(resource: Resource) {
+    const isValid = resourceSchema(resource);
     if (!isValid) {
-      throw new ArgumentError(`Value must be an array of non-empty strings, got: ${value}`);
+      const errorMessage = this.formatValidationErrors(resourceSchema.errors);
+      throw new 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<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 } {
-    const schema = {
-      type: 'object',
-      properties: {
-        id: { type: 'number', multipleOf: 1 },
-        type: { type: 'string', enum: validTypes as TType[] },
-        attributeKey: { type: 'string', minLength: 1 },
-        attributeValue: { type: 'string', minLength: 1 },
-      },
-      required: ['id', 'type', 'attributeKey', 'attributeValue'],
-      additionalProperties: false,
-    } as const;
-
-    const validate = this.ajv.compile(schema);
-    const valid = validate(data);
+  static validateResourceAssignment(resource: ResourceAttributeAssignment): void {
+    const valid = resourceAssignmentSchema(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 ArgumentError(`${fieldNames.id} must be an integer, got: ${id}`);
-      }
-
-      // type must be within enum
-      if (typeof type !== 'string' || !validTypes.includes(type as TType)) {
-        throw new ArgumentError(`${fieldNames.type} must be one of [${validTypes.join(', ')}], got: ${type}`);
-      }
-
-      // attributeKey
-      if (typeof attributeKey !== 'string') {
-        throw new ArgumentError(`attributeKey must be a string, got: ${typeof attributeKey}`);
-      }
-      if (!attributeKey) {
-        throw new ArgumentError('attributeKey must be a non-empty string');
-      }
-
-      // attributeValue
-      if (typeof attributeValue !== 'string') {
-        throw new ArgumentError(`attributeValue must be a string, got: ${typeof attributeValue}`);
-      }
-      if (!attributeValue) {
-        throw new ArgumentError('attributeValue must be a non-empty string');
-      }
-
-      // Fallback
-      throw new ArgumentError('Invalid attribute assignment');
+      const errorMessage = this.formatValidationErrors(resourceAssignmentSchema.errors);
+      throw new ArgumentError(
+        errorMessage
+          ? `Invalid resource attribute assignment: ${errorMessage}`
+          : 'Invalid resource attribute assignment'
+      );
     }
+  }
 
-    return {
-      id: data.id as number,
-      type: data.type as TType,
-      attributeKey: data.attributeKey as string,
-      attributeValue: data.attributeValue as string,
-    };
+  static validateEntityAssignment(entity: EntityAttributeAssignment): void {
+    const valid = entityAssignmentSchema(entity);
+    if (!valid) {
+      const errorMessage = this.formatValidationErrors(entityAssignmentSchema.errors);
+      throw new ArgumentError(
+        errorMessage ? `Invalid entity attribute assignment: ${errorMessage}` : 'Invalid entity attribute assignment'
+      );
+    }
   }
 
   /**
-   * Validates a Resource-like object shape: { id: number; type: string }.
-   * Throws ArgumentError with legacy-compatible messages.
+   * Formats AJV validation errors into a readable error message
    */
-  static validateResource(resource: Resource): void {
-    if (!resource || typeof resource !== 'object') {
-      throw new 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,
-    } as const;
-    const validate = this.ajv.compile(schema);
-    const isValid = validate(resource);
-    if (!isValid) {
-      throw new ArgumentError('Invalid resource');
+  private static formatValidationErrors(errors: ErrorObject[] | null | undefined): string {
+    if (!errors || errors.length === 0) {
+      return '';
     }
-  }
 
-  static validateArrayTypeOf<T>(attributesMessages: T[], messageClass: abstract new (...args: any[]) => T): void {
-    const arraySchema = {
-      type: 'array',
-    };
-    const validateArray = ValidationUtils.ajv.compile(arraySchema);
-    const isArrayValid = validateArray(attributesMessages);
-    if (!isArrayValid) {
-      throw new ArgumentError(`attributesMessages must be an array`);
-    }
-    for (let i = 0; i < attributesMessages.length; i++) {
-      const item = attributesMessages[i];
-      if (!(item instanceof messageClass)) {
-        throw new ArgumentError(
-          `attributesMessages[${i}] must be an instance of ${messageClass.name}, got: ${
-            item?.constructor?.name || typeof item
-          }`
-        );
-      }
-    }
+    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('; ');
   }
 }