@autofleet/sadot 0.8.2-beta-65630a08.0 → 0.8.2

package/dist/api/v1/definition/validations.js

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

package/dist/errors/index.d.ts

@@ -1,4 +1,5 @@
 import { BadRequest } from '@autofleet/errors';
+import type { ValidationError } from 'joi';
 export declare class MissingRequiredCustomFieldError extends BadRequest {
     constructor(missingFields: string[]);
 }
@@ -8,8 +9,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, joiValidationError: ValidationError);
 }
 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,24 @@ 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, joiValidationError) {
+        const formattedErrorMessage = joiValidationError.message
+            .replace(/"/g, '')
+            .replace('value', `'${fieldDefinitionName}'`);
+        const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
+        const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
+        const err = new Error(invalidValueMessage);
         super([err], null, null);
-        this.message = 'INVALID_VALUE';
+        this.message = invalidValueMessage;
     }
 }
 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.name, isValid.error);
             }
         }
     }

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,21 @@ 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, name } = definition;
+        const isValidFieldType = (0, validations_1.validateFieldType)(fieldType);
+        if (!isValidFieldType) {
+            throw new errors_1.InvalidFieldTypeError(fieldType);
+        }
+        // Always allow null values
+        if (instance.value === null)
+            return;
+        const validateValueResponse = (0, validations_1.validateValue)(instance.value, fieldType, validation);
+        if (validateValueResponse.error) {
+            throw new errors_1.InvalidValueError(instance.value, name, validateValueResponse.error);
+        }
+    }
+    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 +61,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 +128,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 +136,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/scopes/filter.js

@@ -10,24 +10,25 @@ const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
 const isConditionStringArray = (input) => Array.isArray(input) && typeof input[0] === 'string';
 const isBooleanString = (input) => ['true', 'false'].includes(input.toString());
 const isDate = (input) => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
-const castIfNeeded = (conditionValue) => {
+const castValueToJsonb = (value, type) => `to_jsonb(${value}::${type})`;
+const castValueToJsonbText = (value) => castValueToJsonb(value, 'text');
+const castValueToJsonbBoolean = (value) => castValueToJsonb(value, 'boolean');
+const castValueToJsonbNumeric = (value) => castValueToJsonb(value, 'numeric');
+const castIfNeeded = (columnName, conditionValue) => {
     if (isDate(conditionValue)) {
-        return '::timestamp';
+        return castValueToJsonb(columnName, 'timestamp');
     }
     if (!Number.isNaN(Number(conditionValue))) {
-        return '::numeric';
+        return castValueToJsonbNumeric(columnName);
     }
-    return '';
+    return columnName;
 };
 const AND_DELIMITER = ' AND ';
 const OR_DELIMITER = ' OR ';
 const CD_TABLE_ALIAS = 'cd';
 const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
 const CV_TABLE_ALIAS = 'cv';
-const CV_VALUE_COLUMN = `(${CV_TABLE_ALIAS}.value)`;
-const castValueToJsonb = (value, type) => `to_jsonb(${value}::${type})`;
-const castValueToJsonbText = (value) => castValueToJsonb(value, 'text');
-const castValueToJsonbBoolean = (value) => castValueToJsonb(value, 'boolean');
+const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -57,6 +58,9 @@ const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scop
                     if (isBooleanString(v)) {
                         return [castValueToJsonbText(`:${valRandom}`), castValueToJsonbBoolean(`:${valRandom}`)];
                     }
+                    if (!Number.isNaN(Number(v))) {
+                        return castValueToJsonbNumeric(`:${valRandom}`);
+                    }
                     return castValueToJsonbText(`:${valRandom}`);
                 }).join(',');
                 return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN} IN (${values}))`;
@@ -64,19 +68,19 @@ const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scop
             return condition.map((c) => {
                 const valRep = reverseReplacementsMap.get(c.value);
                 const valueAsJsonb = castValueToJsonbText(`:${valRep}`);
-                return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} ${valueAsJsonb})`;
+                return `(${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, c.value)} ${c.operator} ${valueAsJsonb})`;
             }).join(AND_DELIMITER);
         }
         if (typeof condition === 'string' || typeof condition === 'number') {
             const conditionRep = reverseReplacementsMap.get(condition);
-            const valueAsJsonb = castValueToJsonbText(`:${conditionRep}`);
+            const valueAsJsonb = !Number.isNaN(Number(condition)) ? castValueToJsonbNumeric(`:${conditionRep}`) : castValueToJsonbText(`:${conditionRep}`);
             const valueAsJsonbBoolean = isBooleanString(condition) ? `${OR_DELIMITER}${CV_VALUE_COLUMN} = ${castValueToJsonbBoolean(`:${conditionRep}`)}` : '';
-            return `(${columnCondition}${AND_DELIMITER}(${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${valueAsJsonb}${valueAsJsonbBoolean}))`;
+            return `(${columnCondition}${AND_DELIMITER}(${castIfNeeded(CV_VALUE_COLUMN, condition)} = ${valueAsJsonb}${valueAsJsonbBoolean}))`;
         }
         if (condition?.operator) {
             const valueRep = reverseReplacementsMap.get(condition.value);
             const valueAsJsonb = castValueToJsonbText(`:${valueRep}`);
-            return `( ${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${valueAsJsonb})`;
+            return `( ${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, condition.value)} ${condition.operator} ${valueAsJsonb})`;
         }
         return false;
     }).filter(Boolean);

package/dist/tests/mocks/definition.mock.d.ts

@@ -43,5 +43,6 @@ export declare const coolFieldDefinition3: {
 export declare const booleanField: (modelType: string) => CreateCustomFieldDefinition;
 export declare const selectField: (modelType: string, options: any) => CreateCustomFieldDefinition;
 export declare const statusField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const fileField: (modelType: string) => CreateCustomFieldDefinition;
 export declare const createDefinition: (defaults: Partial<CustomFieldDefinitionDTO>) => CreateCustomFieldDefinition;
 export declare const createDefinitions: (defaults: Partial<CustomFieldDefinitionDTO>, length?: number) => CreateCustomFieldDefinition[];

package/dist/tests/mocks/definition.mock.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDefinitions = exports.createDefinition = exports.statusField = exports.selectField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
+exports.createDefinitions = exports.createDefinition = exports.fileField = exports.statusField = exports.selectField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
 const node_crypto_1 = require("node:crypto");
 exports.contextAwareFieldDefinition = {
     name: 'cool field',
@@ -49,6 +49,14 @@ const statusField = (modelType, options) => ({
     entityType: 'fleetId',
 });
 exports.statusField = statusField;
+const fileField = (modelType) => ({
+    name: 'file',
+    modelType,
+    fieldType: 'file',
+    entityId: (0, node_crypto_1.randomUUID)(),
+    entityType: 'fleetId',
+});
+exports.fileField = fileField;
 // eslint-disable-next-line max-len
 const createDefinition = (defaults) => ({
     name: defaults?.name || `def_${(0, node_crypto_1.randomUUID)()}`,

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

@@ -22,19 +22,19 @@ exports.CustomValidationTypes = {
 exports.validators = {
     [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().min(0).validate(value),
+    [constants_1.CustomFieldDefinitionType.NUMBER]: (value) => joi_1.default.number().strict(true).validate(value),
+    [constants_1.CustomFieldDefinitionType.BOOLEAN]: (value) => joi_1.default.boolean().strict().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,15 @@
 "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.8.2-beta-65630a08.0",
+  "version": "0.8.2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -50,8 +50,7 @@
     "npm-watch": "^0.11.0",
     "ts-jest": "^29.1.2",
     "ts-node": "^8.6.2",
-    "typescript": "^5.3.3",
-    "typescript-eslint": "^0.0.1-alpha.0"
+    "typescript": "^5.3.3"
   },
   "peerDependencies": {
     "@autofleet/sheilta": ">=1.4.0"

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,27 @@ 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 invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
+
+    const err = new Error(invalidValueMessage);
     super([err], null, null);
-    this.message = 'INVALID_VALUE';
+    this.message = invalidValueMessage;
   }
 }
 

package/src/models/CustomFieldDefinition.ts

@@ -143,8 +143,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, name } = 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, name, 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/scopes/filter.ts

@@ -36,24 +36,25 @@ const isConditionStringArray = (input: any): input is string[] => Array.isArray(
 const isBooleanString = (input: string): boolean => ['true', 'false'].includes(input.toString());
 const isDate = (input: any): input is Date => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
 
-const castIfNeeded = (conditionValue: string): string => {
+const castValueToJsonb = (value: string, type: string) => `to_jsonb(${value}::${type})`;
+const castValueToJsonbText = (value: string) => castValueToJsonb(value, 'text');
+const castValueToJsonbBoolean = (value: string) => castValueToJsonb(value, 'boolean');
+const castValueToJsonbNumeric = (value: string) => castValueToJsonb(value, 'numeric');
+const castIfNeeded = (columnName: string, conditionValue: string): string => {
   if (isDate(conditionValue)) {
-    return '::timestamp';
+    return castValueToJsonb(columnName, 'timestamp');
   }
   if (!Number.isNaN(Number(conditionValue))) {
-    return '::numeric';
+    return castValueToJsonbNumeric(columnName);
   }
-  return '';
+  return columnName;
 };
 const AND_DELIMITER = ' AND ';
 const OR_DELIMITER = ' OR ';
 const CD_TABLE_ALIAS = 'cd';
 const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
 const CV_TABLE_ALIAS = 'cv';
-const CV_VALUE_COLUMN = `(${CV_TABLE_ALIAS}.value)`;
-const castValueToJsonb = (value: string, type: string) => `to_jsonb(${value}::${type})`;
-const castValueToJsonbText = (value: string) => castValueToJsonb(value, 'text');
-const castValueToJsonbBoolean = (value: string) => castValueToJsonb(value, 'boolean');
+const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
 
 /**
  * A Sequelize scope for filtering models by custom fields.
@@ -86,6 +87,9 @@ export const customFieldsFilterScope = (
           if (isBooleanString(v)) {
             return [castValueToJsonbText(`:${valRandom}`), castValueToJsonbBoolean(`:${valRandom}`)];
           }
+          if (!Number.isNaN(Number(v))) {
+            return castValueToJsonbNumeric(`:${valRandom}`);
+          }
           return castValueToJsonbText(`:${valRandom}`);
         }).join(',');
         return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN} IN (${values}))`;
@@ -93,19 +97,19 @@ export const customFieldsFilterScope = (
       return condition.map((c) => {
         const valRep = reverseReplacementsMap.get(c.value);
         const valueAsJsonb = castValueToJsonbText(`:${valRep}`);
-        return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} ${valueAsJsonb})`;
+        return `(${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, c.value)} ${c.operator} ${valueAsJsonb})`;
       }).join(AND_DELIMITER);
     }
     if (typeof condition === 'string' || typeof condition === 'number') {
       const conditionRep = reverseReplacementsMap.get(condition);
-      const valueAsJsonb = castValueToJsonbText(`:${conditionRep}`);
+      const valueAsJsonb = !Number.isNaN(Number(condition)) ? castValueToJsonbNumeric(`:${conditionRep}`) : castValueToJsonbText(`:${conditionRep}`);
       const valueAsJsonbBoolean = isBooleanString(condition) ? `${OR_DELIMITER}${CV_VALUE_COLUMN} = ${castValueToJsonbBoolean(`:${conditionRep}`)}` : '';
-      return `(${columnCondition}${AND_DELIMITER}(${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${valueAsJsonb}${valueAsJsonbBoolean}))`;
+      return `(${columnCondition}${AND_DELIMITER}(${castIfNeeded(CV_VALUE_COLUMN, condition)} = ${valueAsJsonb}${valueAsJsonbBoolean}))`;
     }
     if (condition?.operator) {
       const valueRep = reverseReplacementsMap.get(condition.value);
       const valueAsJsonb = castValueToJsonbText(`:${valueRep}`);
-      return `( ${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${valueAsJsonb})`;
+      return `( ${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, condition.value)} ${condition.operator} ${valueAsJsonb})`;
     }
     return false;
   }).filter(Boolean);

package/src/tests/mocks/definition.mock.ts

@@ -52,6 +52,14 @@ export const statusField = (modelType: string, options): CreateCustomFieldDefini
   entityType: 'fleetId',
 });
 
+export const fileField = (modelType: string): CreateCustomFieldDefinition => ({
+  name: 'file',
+  modelType,
+  fieldType: 'file',
+  entityId: uuidv4(),
+  entityType: 'fleetId',
+});
+
 // eslint-disable-next-line max-len
 export const createDefinition = (defaults: Partial<CustomFieldDefinitionDTO>): CreateCustomFieldDefinition => ({
   name: defaults?.name || `def_${uuidv4()}`,

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().min(0).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)
 );

package/tsconfig.build.json

@@ -0,0 +1,7 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "src/**/*",
+  ],
+  "exclude": ["node_modules", "src/tests/**", "**/*.test.ts"]
+}

package/tsconfig.json

@@ -12,5 +12,5 @@
   "include": [
     "src/**/*",
   ],
-  "exclude": ["node_modules", "**/*.test.ts"]
+  "exclude": ["node_modules"]
 }