@autofleet/sadot 0.7.9 → 0.7.10-beta.1

package/.env

@@ -0,0 +1,3 @@
+NODE_ENV=test
+DB_USERNAME=postgres
+DB_PASSWORD=postgres

package/dist/errors/index.d.ts

@@ -8,8 +8,11 @@ export declare class UnsupportedCustomFieldTypeError extends BadRequest {
 export declare class UnsupportedCustomValidationError extends BadRequest {
     constructor(fieldType: string);
 }
+export declare class InvalidFieldTypeError extends BadRequest {
+    constructor(fieldType: string);
+}
 export declare class InvalidValueError extends BadRequest {
-    constructor(value: any, fieldType: string);
+    constructor(value: any, fieldDefinitionName: string, validationErrorMessage: string);
 }
 export declare class MissingDefinitionError extends BadRequest {
     constructor(fieldNames: string[]);

package/dist/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MissingDefinitionError = exports.InvalidValueError = exports.UnsupportedCustomValidationError = exports.UnsupportedCustomFieldTypeError = exports.MissingRequiredCustomFieldError = void 0;
+exports.MissingDefinitionError = exports.InvalidValueError = exports.InvalidFieldTypeError = exports.UnsupportedCustomValidationError = exports.UnsupportedCustomFieldTypeError = exports.MissingRequiredCustomFieldError = void 0;
 /* eslint-disable max-classes-per-file */
 const errors_1 = require("@autofleet/errors");
 class MissingRequiredCustomFieldError extends errors_1.BadRequest {
@@ -27,11 +27,19 @@ class UnsupportedCustomValidationError extends errors_1.BadRequest {
     }
 }
 exports.UnsupportedCustomValidationError = UnsupportedCustomValidationError;
+class InvalidFieldTypeError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Invalid field type ${fieldType}`);
+        super([err], null, null);
+        this.message = 'INVALID_FIELD_TYPE';
+    }
+}
+exports.InvalidFieldTypeError = InvalidFieldTypeError;
 class InvalidValueError extends errors_1.BadRequest {
-    constructor(value, fieldType) {
-        const err = new Error(`Invalid "${fieldType}" value ${JSON.stringify(value)}`);
+    constructor(value, fieldDefinitionName, validationErrorMessage) {
+        const err = new Error(`Invalid value ${value} for field ${fieldDefinitionName} - ${validationErrorMessage}`);
         super([err], null, null);
-        this.message = 'INVALID_VALUE';
+        this.message = err.message;
     }
 }
 exports.InvalidValueError = InvalidValueError;

package/dist/models/CustomFieldDefinition.js

@@ -28,8 +28,8 @@ let CustomFieldDefinition = class CustomFieldDefinition extends sequelize_typesc
         }
         if (![null, undefined].includes(instance.defaultValue)) {
             const isValid = (0, validations_1.validateValue)(instance.defaultValue, instance.fieldType, instance.validation);
-            if (!isValid) {
-                throw new errors_1.InvalidValueError(instance.defaultValue, instance.fieldType);
+            if (isValid.error) {
+                throw new errors_1.InvalidValueError(instance.defaultValue, instance.fieldType, isValid.error.details[0].message);
             }
         }
     }

package/dist/models/CustomFieldValue.d.ts

@@ -8,8 +8,9 @@ declare class CustomFieldValue extends Model {
     updatedAt?: Date;
     deletedAt?: Date;
     customFieldDefinition: CustomFieldDefinition;
-    static validateValues(instances: CustomFieldValue[]): Promise<void>;
-    static validateValue(instance: CustomFieldValue): Promise<void>;
+    private static validateValueAgainstDefinition;
+    static validateCustomFieldValues(instances: CustomFieldValue[]): Promise<void>;
+    static validateCustomFieldValue(instance: CustomFieldValue): Promise<void>;
     static afterSaveHandler(instance: CustomFieldValue, options: any): void;
 }
 export default CustomFieldValue;

package/dist/models/CustomFieldValue.js

@@ -39,7 +39,22 @@ const validations_1 = require("../utils/validations");
 const CustomFieldDefinitionRepo = __importStar(require("../repository/definition"));
 const errors_1 = require("../errors");
 let CustomFieldValue = class CustomFieldValue extends sequelize_typescript_1.Model {
-    static async validateValues(instances) {
+    static validateValueAgainstDefinition(instance, definition) {
+        const { validation, fieldType, displayName } = definition;
+        const isValidFieldType = (0, validations_1.validateFieldType)(fieldType); // check if can be removed for value
+        if (!isValidFieldType) {
+            throw new errors_1.InvalidFieldTypeError(fieldType);
+        }
+        // Always allow null values
+        if (instance.value === null)
+            return; // check if can be used in Joi
+        const validateValueResponse = (0, validations_1.validateValue)(instance.value, fieldType, validation);
+        if (validateValueResponse.error) {
+            const validationErrorMessage = validateValueResponse.error.details[0].message;
+            throw new errors_1.InvalidValueError(instance.value, displayName, validationErrorMessage);
+        }
+    }
+    static async validateCustomFieldValues(instances) {
         const ids = instances.map((instance) => instance.customFieldDefinitionId);
         const uniqueIds = [...new Set(ids)];
         const definitions = await CustomFieldDefinitionRepo.findByIds(uniqueIds, { withDisabled: true });
@@ -47,23 +62,17 @@ let CustomFieldValue = class CustomFieldValue extends sequelize_typescript_1.Mod
             throw new Error('Definitions not found');
         }
         instances.forEach((instance) => {
-            const { validation, fieldType, } = definitions
-                .find((definition) => definition.id === instance.customFieldDefinitionId);
-            const isValid = (0, validations_1.validateValue)(instance.value, fieldType, validation);
-            if (!isValid) {
-                throw new errors_1.InvalidValueError(instance.value, fieldType);
+            const definition = definitions.find((d) => d.id === instance.customFieldDefinitionId);
+            if (definition) {
+                this.validateValueAgainstDefinition(instance, definition);
             }
         });
     }
-    static async validateValue(instance) {
+    static async validateCustomFieldValue(instance) {
         const { customFieldDefinitionId } = instance;
         // eslint-disable-next-line max-len
         const cfd = await CustomFieldDefinitionRepo.findById(customFieldDefinitionId, { withDisabled: true });
-        const { validation, fieldType } = cfd;
-        const isValid = (0, validations_1.validateValue)(instance.value, fieldType, validation);
-        if (!isValid) {
-            throw new errors_1.InvalidValueError(instance.value, fieldType);
-        }
+        this.validateValueAgainstDefinition(instance, cfd);
     }
     static afterSaveHandler(instance, options) {
         if (options.transaction) {
@@ -120,7 +129,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Array]),
     __metadata("design:returntype", Promise)
-], CustomFieldValue, "validateValues", null);
+], CustomFieldValue, "validateCustomFieldValues", null);
 __decorate([
     sequelize_typescript_1.BeforeUpdate,
     sequelize_typescript_1.BeforeCreate,
@@ -128,7 +137,7 @@ __decorate([
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [CustomFieldValue]),
     __metadata("design:returntype", Promise)
-], CustomFieldValue, "validateValue", null);
+], CustomFieldValue, "validateCustomFieldValue", null);
 __decorate([
     sequelize_typescript_1.AfterUpsert,
     __metadata("design:type", Function),

package/dist/utils/validations/index.d.ts

@@ -1,2 +1,3 @@
 import type { CustomFieldDefinitionType } from '../constants';
-export declare const validateValue: (value: unknown, valueType: CustomFieldDefinitionType, validation?: unknown) => boolean;
+export declare const validateFieldType: (type: CustomFieldDefinitionType) => boolean;
+export declare const validateValue: (value: unknown, valueType: CustomFieldDefinitionType, validation?: unknown) => import("joi").ValidationResult;

package/dist/utils/validations/index.js

@@ -1,15 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateValue = void 0;
+exports.validateValue = exports.validateFieldType = void 0;
 const validators_1 = require("./validators");
+const validateFieldType = (type) => Object.keys(validators_1.validators).includes(type);
+exports.validateFieldType = validateFieldType;
 const validateValue = (value, valueType, validation) => {
     const validator = validators_1.validators[valueType];
-    if (!validator) {
-        // Unsupported field type
-        return false;
-    }
-    // Always allow null values
-    return value === null || validator(value, validation);
+    return validator(value, validation);
     /** TODO: Add validation for required fields
      * @example
      * if (validations.required && !value) {

package/dist/utils/validations/type.d.ts

@@ -1,10 +1,11 @@
+import type { ValidationResult } from 'joi';
 import type { CustomFieldDefinitionType } from '../constants';
 /**
  * Validator is a function that validates a custom-field `value`,
  * against a custom-field definition `validation object`.
  * @returns `true` if the value is valid, `false` otherwise.
  */
-export type Validator<Value, DefinitionValidationObject> = (value: Value, validation?: DefinitionValidationObject) => boolean;
+export type Validator<Value, DefinitionValidationObject> = (value: Value, validation?: DefinitionValidationObject) => ValidationResult;
 /**
  * Validators is a map of custom-field types to their respective validators.
  * The key is the custom-field type, and the value is the validator function.

package/dist/utils/validations/validators/index.js

@@ -20,21 +20,22 @@ exports.CustomValidationTypes = {
  * Validators for custom fields
  */
 exports.validators = {
+    // currently the name shows up as "value", i want to change it to be based on the type
     [constants_1.CustomFieldDefinitionType.SELECT]: select_validator_1.validateSelect,
     [constants_1.CustomFieldDefinitionType.STATUS]: status_validator_1.validateStatus,
-    [constants_1.CustomFieldDefinitionType.TEXT]: (value) => (typeof value === 'string'),
-    [constants_1.CustomFieldDefinitionType.NUMBER]: (value) => (typeof value === 'number'),
-    [constants_1.CustomFieldDefinitionType.BOOLEAN]: (value) => (typeof value === 'boolean'),
-    [constants_1.CustomFieldDefinitionType.DATE]: (value) => (!joi_1.default.date().validate(value).error),
-    [constants_1.CustomFieldDefinitionType.DATETIME]: (value) => (!joi_1.default.date().validate(value).error),
-    [constants_1.CustomFieldDefinitionType.IMAGE]: (value) => (!joi_1.default.array().min(1).unique()
+    [constants_1.CustomFieldDefinitionType.TEXT]: (value) => joi_1.default.string().validate(value),
+    [constants_1.CustomFieldDefinitionType.NUMBER]: (value) => joi_1.default.number().strict(true).validate(value),
+    [constants_1.CustomFieldDefinitionType.BOOLEAN]: (value) => joi_1.default.boolean().validate(value),
+    [constants_1.CustomFieldDefinitionType.DATE]: (value) => joi_1.default.date().validate(value),
+    [constants_1.CustomFieldDefinitionType.DATETIME]: (value) => joi_1.default.date().validate(value),
+    [constants_1.CustomFieldDefinitionType.IMAGE]: (value) => joi_1.default.array().min(1).unique()
         .items(joi_1.default.string().uri())
-        .validate(value).error),
-    [constants_1.CustomFieldDefinitionType.FILE]: (value) => (!joi_1.default.array().min(1).unique().items(joi_1.default.object({
+        .validate(value),
+    [constants_1.CustomFieldDefinitionType.FILE]: (value) => joi_1.default.array().min(1).unique().items(joi_1.default.object({
         name: joi_1.default.string().required(),
         type: joi_1.default.string(),
         size: joi_1.default.string(),
         addedBy: joi_1.default.string().uuid(),
     }))
-        .validate(value).error),
+        .validate(value),
 };

package/dist/utils/validations/validators/select.validator.js

@@ -1,9 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateSelect = void 0;
+const joi_1 = __importDefault(require("joi"));
 /**
  * Validate that the value is one of the select values
  */
-const validateSelect = (value, selectValues) => (Array.isArray(selectValues)
-    && selectValues.includes(value));
+const validateSelect = (value, selectValues) => (joi_1.default.string().allow(null).valid(...selectValues).validate(value));
 exports.validateSelect = validateSelect;

package/dist/utils/validations/validators/status.validator.js

@@ -1,9 +1,12 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateStatus = void 0;
+const joi_1 = __importDefault(require("joi"));
 /**
 * Validate that the value is one of the status values
 */
-const validateStatus = (value, statusValues) => (Array.isArray(statusValues)
-    && statusValues.some((status) => status.value === value));
+const validateStatus = (value, statusValues) => (joi_1.default.string().allow(null).valid(...statusValues.map((statusValue) => statusValue.value)).validate(value));
 exports.validateStatus = validateStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.7.9",
+  "version": "0.7.10-beta.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/api/v1/definition/validations.ts

@@ -36,11 +36,11 @@ const DefaultValueSchema = Joi.when('fieldType', {
     { is: CustomFieldDefinitionType.BOOLEAN, then: Joi.boolean().allow(null) },
     { is: CustomFieldDefinitionType.DATE, then: Joi.date().allow(null) },
     { is: CustomFieldDefinitionType.DATETIME, then: Joi.date().allow(null) },
-    { is: CustomFieldDefinitionType.FILE, then: FileValidationSchema },
-    { is: CustomFieldDefinitionType.IMAGE, then: Joi.string().uri().allow(null) },
+    { is: CustomFieldDefinitionType.FILE, then: Joi.array().items(FileValidationSchema).allow(null) },
+    { is: CustomFieldDefinitionType.IMAGE, then: Joi.array().items(Joi.string().uri()).allow(null) },
     { is: CustomFieldDefinitionType.NUMBER, then: Joi.number().allow(null) },
     { is: CustomFieldDefinitionType.SELECT, then: Joi.string().allow(null) },
-    { is: CustomFieldDefinitionType.STATUS, then: statusValidationObject.allow(null) },
+    { is: CustomFieldDefinitionType.STATUS, then: Joi.string().allow(null) },
     { is: CustomFieldDefinitionType.TEXT, then: Joi.string().allow(null) },
   ],
 });

package/src/errors/index.ts

@@ -1,5 +1,6 @@
 /* eslint-disable max-classes-per-file */
 import { BadRequest } from '@autofleet/errors';
+import type { ValidationError } from 'joi';
 
 export class MissingRequiredCustomFieldError extends BadRequest {
   constructor(missingFields: string[]) {
@@ -25,11 +26,31 @@ export class UnsupportedCustomValidationError extends BadRequest {
   }
 }
 
+export class InvalidFieldTypeError extends BadRequest {
+  constructor(fieldType: string) {
+    const err = new Error(`Invalid field type ${fieldType}`);
+    super([err], null, null);
+    this.message = 'INVALID_FIELD_TYPE';
+  }
+}
+
 export class InvalidValueError extends BadRequest {
-  constructor(value: any, fieldType: string) {
-    const err = new Error(`Invalid "${fieldType}" value ${JSON.stringify(value)}`);
+  constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError) {
+    const formattedErrorMessage = joiValidationError.message
+      .replace(/"/g, '')
+      .replace('value', fieldDefinitionName);
+
+    const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
+
+    const detailedMessage = `
+      Invalid value for field ${fieldDefinitionName}
+      Received: ${formattedValue}
+      Error: ${formattedErrorMessage}
+      `.trim();
+
+    const err = new Error(detailedMessage);
     super([err], null, null);
-    this.message = 'INVALID_VALUE';
+    this.message = err.message;
   }
 }
 

package/src/models/CustomFieldDefinition.ts

@@ -136,8 +136,8 @@ class CustomFieldDefinition extends Model {
     }
     if (![null, undefined].includes(instance.defaultValue)) {
       const isValid = validateValue(instance.defaultValue, instance.fieldType, instance.validation);
-      if (!isValid) {
-        throw new InvalidValueError(instance.defaultValue, instance.fieldType);
+      if (isValid.error) {
+        throw new InvalidValueError(instance.defaultValue, instance.name, isValid.error);
       }
     }
   }

package/src/models/CustomFieldValue.ts

@@ -15,9 +15,9 @@ import {
 } from 'sequelize-typescript';
 import { sendDimEvent } from '../events';
 import { CustomFieldDefinition } from '.';
-import { validateValue } from '../utils/validations';
+import { validateFieldType, validateValue } from '../utils/validations';
 import * as CustomFieldDefinitionRepo from '../repository/definition';
-import { InvalidValueError } from '../errors';
+import { InvalidFieldTypeError, InvalidValueError } from '../errors';
 
 @Table({
   timestamps: true,
@@ -56,9 +56,26 @@ class CustomFieldValue extends Model {
   @BelongsTo(() => CustomFieldDefinition, { scope: { disabled: false } })
     customFieldDefinition: CustomFieldDefinition;
 
+  private static validateValueAgainstDefinition(
+    instance: CustomFieldValue,
+    definition: CustomFieldDefinition,
+  ): void {
+    const { validation, fieldType, displayName } = definition;
+    const isValidFieldType = validateFieldType(fieldType);
+    if (!isValidFieldType) {
+      throw new InvalidFieldTypeError(fieldType);
+    }
+    // Always allow null values
+    if (instance.value === null) return;
+    const validateValueResponse = validateValue(instance.value, fieldType, validation);
+    if (validateValueResponse.error) {
+      throw new InvalidValueError(instance.value, displayName, validateValueResponse.error);
+    }
+  }
+
   @BeforeBulkCreate
   @BeforeBulkUpdate
-  static async validateValues(instances: CustomFieldValue[]): Promise<void> {
+  static async validateCustomFieldValues(instances: CustomFieldValue[]): Promise<void> {
     const ids = instances.map((instance) => instance.customFieldDefinitionId);
     const uniqueIds = [...new Set(ids)];
     const definitions = await CustomFieldDefinitionRepo.findByIds(
@@ -71,14 +88,9 @@ class CustomFieldValue extends Model {
     }
 
     instances.forEach((instance) => {
-      const {
-        validation,
-        fieldType,
-      } = definitions
-        .find((definition) => definition.id === instance.customFieldDefinitionId);
-      const isValid = validateValue(instance.value, fieldType, validation);
-      if (!isValid) {
-        throw new InvalidValueError(instance.value, fieldType);
+      const definition = definitions.find((d) => d.id === instance.customFieldDefinitionId);
+      if (definition) {
+        this.validateValueAgainstDefinition(instance, definition);
       }
     });
   }
@@ -86,15 +98,11 @@ class CustomFieldValue extends Model {
   @BeforeUpdate
   @BeforeCreate
   @BeforeUpsert
-  static async validateValue(instance: CustomFieldValue): Promise<void> {
+  static async validateCustomFieldValue(instance: CustomFieldValue): Promise<void> {
     const { customFieldDefinitionId } = instance;
     // eslint-disable-next-line max-len
     const cfd = await CustomFieldDefinitionRepo.findById(customFieldDefinitionId, { withDisabled: true });
-    const { validation, fieldType } = cfd;
-    const isValid = validateValue(instance.value, fieldType, validation);
-    if (!isValid) {
-      throw new InvalidValueError(instance.value, fieldType);
-    }
+    this.validateValueAgainstDefinition(instance, cfd);
   }
 
   @AfterUpsert

package/src/utils/validations/index.ts

@@ -1,18 +1,15 @@
 import type { CustomFieldDefinitionType } from '../constants';
 import { validators } from './validators';
 
+export const validateFieldType = (type: CustomFieldDefinitionType): boolean => Object.keys(validators).includes(type);
+
 export const validateValue = (
   value: unknown,
   valueType: CustomFieldDefinitionType,
   validation?: unknown,
 ) => {
   const validator = validators[valueType];
-  if (!validator) {
-    // Unsupported field type
-    return false;
-  }
-  // Always allow null values
-  return value === null || validator(value, validation);
+  return validator(value, validation);
   /** TODO: Add validation for required fields
    * @example
    * if (validations.required && !value) {

package/src/utils/validations/type.ts

@@ -1,3 +1,4 @@
+import type { ValidationResult } from 'joi';
 import type { CustomFieldDefinitionType } from '../constants';
 
 /**
@@ -8,7 +9,7 @@ import type { CustomFieldDefinitionType } from '../constants';
 export type Validator<Value, DefinitionValidationObject> = (
    value: Value,
    validation?: DefinitionValidationObject
-  ) => boolean;
+  ) => ValidationResult;
 
 /**
  * Validators is a map of custom-field types to their respective validators.

package/src/utils/validations/validators/index.ts

@@ -20,19 +20,19 @@ export const CustomValidationTypes = {
 export const validators: Validators = {
   [CustomFieldDefinitionType.SELECT]: validateSelect,
   [CustomFieldDefinitionType.STATUS]: validateStatus,
-  [CustomFieldDefinitionType.TEXT]: (value) => (typeof value === 'string'),
-  [CustomFieldDefinitionType.NUMBER]: (value) => (typeof value === 'number'),
-  [CustomFieldDefinitionType.BOOLEAN]: (value) => (typeof value === 'boolean'),
-  [CustomFieldDefinitionType.DATE]: (value) => (!Joi.date().validate(value).error),
-  [CustomFieldDefinitionType.DATETIME]: (value) => (!Joi.date().validate(value).error),
-  [CustomFieldDefinitionType.IMAGE]: (value) => (!Joi.array().min(1).unique()
+  [CustomFieldDefinitionType.TEXT]: (value) => Joi.string().validate(value),
+  [CustomFieldDefinitionType.NUMBER]: (value) => Joi.number().strict(true).validate(value),
+  [CustomFieldDefinitionType.BOOLEAN]: (value) => Joi.boolean().strict().validate(value),
+  [CustomFieldDefinitionType.DATE]: (value) => Joi.date().validate(value),
+  [CustomFieldDefinitionType.DATETIME]: (value) => Joi.date().validate(value),
+  [CustomFieldDefinitionType.IMAGE]: (value) => Joi.array().min(1).unique()
     .items(Joi.string().uri())
-    .validate(value).error),
-  [CustomFieldDefinitionType.FILE]: (value) => (!Joi.array().min(1).unique().items(Joi.object({
+    .validate(value),
+  [CustomFieldDefinitionType.FILE]: (value) => Joi.array().min(1).unique().items(Joi.object({
     name: Joi.string().required(),
     type: Joi.string(),
     size: Joi.string(),
     addedBy: Joi.string().uuid(),
   }))
-    .validate(value).error),
+    .validate(value),
 };

package/src/utils/validations/validators/select.validator.ts

@@ -1,3 +1,4 @@
+import Joi from 'joi';
 import type { Validator } from '../type';
 
 /**
@@ -6,6 +7,6 @@ import type { Validator } from '../type';
 export const validateSelect: Validator<string, string[]> = (
   value,
   selectValues,
-) => (Array.isArray(selectValues)
-      && selectValues.includes(value)
+) => (
+  Joi.string().allow(null).valid(...selectValues).validate(value)
 );

package/src/utils/validations/validators/status.validator.ts

@@ -1,3 +1,4 @@
+import Joi from 'joi';
 import type { Validator } from '../type';
 
 type StatusColor = string | null; // TODO: Takes from @autofleet/colors ?
@@ -13,6 +14,9 @@ type StatusOption = {
 export const validateStatus: Validator<StatusValue, StatusOption[]> = (
   value,
   statusValues,
-) => (Array.isArray(statusValues)
-   && statusValues.some((status) => status.value === value)
+) => (
+  Joi.string()
+    .allow(null)
+    .valid(...statusValues.map((statusValue) => statusValue.value))
+    .validate(value)
 );