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

package/dist/utils/assigment-schema.d.ts

@@ -0,0 +1,23 @@
+export declare const entityAssignmentSchema: import("ajv").ValidateFunction<{
+    entityId: any;
+    entityType: any;
+    key: any;
+} & {
+    entityId: any;
+} & {
+    entityType: any;
+} & {
+    key: any;
+}>;
+export declare const resourceAssignmentSchema: import("ajv").ValidateFunction<{
+    id: any;
+    type: any;
+    key: any;
+} & {
+    id: any;
+} & {
+    type: any;
+} & {
+    key: any;
+}>;
+//# sourceMappingURL=assigment-schema.d.ts.map

package/dist/utils/assigment-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"assigment-schema.d.ts","sourceRoot":"","sources":["../../src/utils/assigment-schema.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,sBAAsB;;;;;;;;;;EAUjC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;;;;;;;EAUnC,CAAC"}

package/dist/utils/assigment-schema.js

@@ -0,0 +1,36 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Ajv = require('ajv');
+const entityAttributesConstants = require('../entity-attributes-constants.js');
+const resourceAttributesConstants = require('../resource-attributes-constants.js');
+
+const _interopDefault = e => e && e.__esModule ? e : { default: e };
+
+const Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+
+const ajv = new Ajv__default.default({ allErrors: true });
+const entityAssignmentSchema = ajv.compile({
+    type: 'object',
+    properties: {
+        entityId: { type: 'number', multipleOf: 1 },
+        entityType: { type: 'string', enum: Object.values(entityAttributesConstants.EntityType) },
+        key: { type: 'string', minLength: 1 },
+        value: { type: 'string' },
+    },
+    required: ['entityId', 'entityType', 'key'],
+    additionalProperties: false,
+});
+const resourceAssignmentSchema = ajv.compile({
+    type: 'object',
+    properties: {
+        id: { type: 'number', multipleOf: 1 },
+        type: { type: 'string', enum: Object.values(resourceAttributesConstants.ResourceType) },
+        key: { type: 'string', minLength: 1 },
+        value: { type: 'string' },
+    },
+    required: ['id', 'type', 'key'],
+    additionalProperties: false,
+});
+
+exports.entityAssignmentSchema = entityAssignmentSchema;
+exports.resourceAssignmentSchema = resourceAssignmentSchema;

package/dist/utils/resource-schema.d.ts

@@ -0,0 +1,17 @@
+export interface Resource {
+    id?: number;
+    type: string;
+    wrapperData?: object;
+}
+export declare const resourceSchema: import("ajv").ValidateFunction<{
+    id: any;
+    type: any;
+    wrapperData: any;
+} & {
+    id: any;
+} & {
+    type: any;
+} & {
+    wrapperData: any;
+}>;
+//# sourceMappingURL=resource-schema.d.ts.map

package/dist/utils/resource-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"resource-schema.d.ts","sourceRoot":"","sources":["../../src/utils/resource-schema.ts"],"names":[],"mappings":"AAKA,MAAM,WAAW,QAAQ;IACvB,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,CAAC;IACb,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,eAAO,MAAM,cAAc;;;;;;;;;;EASzB,CAAC"}

package/dist/utils/resource-schema.js

@@ -0,0 +1,22 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const Ajv = require('ajv');
+const resourceAttributesConstants = require('../resource-attributes-constants.js');
+
+const _interopDefault = e => e && e.__esModule ? e : { default: e };
+
+const Ajv__default = /*#__PURE__*/_interopDefault(Ajv);
+
+const ajv = new Ajv__default.default({ allErrors: true });
+const resourceSchema = ajv.compile({
+    type: 'object',
+    properties: {
+        id: { type: 'number', multipleOf: 1 },
+        type: { type: 'string', enum: resourceAttributesConstants.RESOURCE_TYPES },
+        wrapperData: { type: 'string', minLength: 1 },
+    },
+    required: ['id', 'type', 'wrapperData'],
+    additionalProperties: false,
+});
+
+exports.resourceSchema = resourceSchema;

package/dist/utils/validation.d.ts

@@ -1,45 +1,26 @@
+import { ResourceAttributeAssignment, EntityAttributeAssignment } from '../types/authorization-attributes-contracts';
 import { Resource } from '../types/general';
 /**
  * Utility class for common validation operations using AJV
  */
 export declare class ValidationUtils {
     private static ajv;
-    /**
-     * Validates that a value is an integer. Throws ArgumentError with a descriptive message on failure.
-     */
+    private static integerValidator;
+    private static stringValidator;
+    private static stringArrayValidator;
     static validateInteger(value: number): void;
-    /**
-     * Validates that a value is a non-empty string. Throws ArgumentError on failure.
-     */
     static validateString(value: string): void;
-    /**
-     * 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;
+    static validateResource(resource: Resource): void;
     /**
      * 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;
-    };
+    static validateResourceAssignment(resource: ResourceAttributeAssignment): void;
+    static validateEntityAssignment(entity: EntityAttributeAssignment): void;
     /**
-     * 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;
-    static validateArrayTypeOf<T>(attributesMessages: T[], messageClass: abstract new (...args: any[]) => T): void;
+    private static formatValidationErrors;
 }
 //# 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":"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"}
+{"version":3,"file":"validation.d.ts","sourceRoot":"","sources":["../../src/utils/validation.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,2BAA2B,EAAE,yBAAyB,EAAE,MAAM,6CAA6C,CAAC;AACrH,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAI5C;;GAEG;AACH,qBAAa,eAAe;IAC1B,OAAO,CAAC,MAAM,CAAC,GAAG,CAAgC;IAElD,OAAO,CAAC,MAAM,CAAC,gBAAgB,CAAyE;IACxG,OAAO,CAAC,MAAM,CAAC,eAAe,CAAwE;IACtG,OAAO,CAAC,MAAM,CAAC,oBAAoB,CAGhC;WAEW,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;WAOpC,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;WAOnC,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;WAO1C,gBAAgB,CAAC,QAAQ,EAAE,QAAQ;IAQjD;;;OAGG;IACH,MAAM,CAAC,0BAA0B,CAAC,QAAQ,EAAE,2BAA2B,GAAG,IAAI;IAY9E,MAAM,CAAC,wBAAwB,CAAC,MAAM,EAAE,yBAAyB,GAAG,IAAI;IAUxE;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,sBAAsB;CAGtC"}

package/dist/utils/validation.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mondaydotcomorg/monday-authorization",
-  "version": "3.5.2-feat-shaime-support-entity-attributes-4-ddec1d3",
+  "version": "3.5.2-feat-shaime-support-entity-attributes-3-6202ab7",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "license": "BSD-3-Clause",