@autofleet/sadot 0.6.4-beta.1 → 0.6.5

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

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validators = exports.CustomValidationTypes = void 0;
+const joi_1 = __importDefault(require("joi"));
+const constants_1 = require("../../constants");
+const select_validator_1 = require("./select.validator");
+const status_validator_1 = require("./status.validator");
+/**
+ * Custom field types that must have custom validation.
+ * TODO: remove this after moving to schema-based validation
+ */
+exports.CustomValidationTypes = {
+    [constants_1.CustomFieldDefinitionType.SELECT]: constants_1.CustomFieldDefinitionType.SELECT,
+    [constants_1.CustomFieldDefinitionType.STATUS]: constants_1.CustomFieldDefinitionType.STATUS,
+};
+/**
+ * Validators for custom fields
+ */
+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()
+        .items(joi_1.default.string().uri())
+        .validate(value).error),
+};

package/dist/utils/validations/validators/select.validator.d.ts

@@ -0,0 +1,5 @@
+import type { Validator } from '../type';
+/**
+ * Validate that the value is one of the select values
+ */
+export declare const validateSelect: Validator<string, string[]>;

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSelect = void 0;
+/**
+ * Validate that the value is one of the select values
+ */
+const validateSelect = (value, selectValues) => (Array.isArray(selectValues)
+    && selectValues.includes(value));
+exports.validateSelect = validateSelect;

package/dist/utils/validations/validators/status.validator.d.ts

@@ -0,0 +1,12 @@
+import type { Validator } from '../type';
+type StatusColor = string | null;
+type StatusValue = string;
+type StatusOption = {
+    value: StatusValue;
+    color: StatusColor;
+};
+/**
+* Validate that the value is one of the status values
+*/
+export declare const validateStatus: Validator<StatusValue, StatusOption[]>;
+export {};

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

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateStatus = void 0;
+/**
+* Validate that the value is one of the status values
+*/
+const validateStatus = (value, statusValues) => (Array.isArray(statusValues)
+    && statusValues.some((status) => status.value === value));
+exports.validateStatus = validateStatus;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.6.4-beta.1",
+  "version": "0.6.5",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -11,7 +11,8 @@
     "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
     "build-to-local-repo": "npm run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
     "dev": "nodemon",
-    "watch": "npm-watch build-to-local-repo"
+    "watch": "npm-watch build-to-local-repo",
+    "publish-dev": "npm run build && npm publish --tag dev"
   },
   "watch": {
     "build-to-local-repo": {
@@ -45,16 +46,16 @@
     "@types/express": "^4.17.17",
     "@types/jest": "^27.0.9",
     "@types/uuid": "^9.0.2",
-    "@typescript-eslint/eslint-plugin": "^4.8.1",
-    "@typescript-eslint/parser": "^4.33.0",
-    "eslint": "^7.13.0",
+    "@typescript-eslint/eslint-plugin": "^6.4.0",
+    "@typescript-eslint/parser": "^6.4.0",
+    "eslint": "^7.32.0",
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
-    "jest": "^27.0.5",
+    "jest": "^29.7.0",
+    "ts-jest": "^29.1.2",
     "npm-watch": "^0.11.0",
-    "ts-jest": "^27.0.3",
     "ts-node": "^8.6.2",
-    "typescript": "^4.9.5",
+    "typescript": "^5.3.3",
     "typescript-eslint": "^0.0.1-alpha.0"
   },
   "author": "Autofleet",

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

@@ -3,7 +3,7 @@ import { Router } from 'express';
 import type { Request, Response } from 'express';
 import handleError from '../errors';
 import * as DefinitionRepo from '../../../repository/definition';
-import { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../../../types/definition';
+import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../../../types/definition';
 import { validateCustomFieldDefinitionCreation, validateCustomFieldDefinitionUpdate } from './validations';
 import logger from '../../../utils/logger';
 

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

@@ -1,10 +1,29 @@
 import Joi from 'joi';
-import { CustomFieldDefinitionType } from '../../../utils/validations/type';
+import { CustomFieldDefinitionType } from '../../../utils/constants';
 
+const statusValidationObjectSchema = Joi.array().items(
+  Joi.object({
+    value: Joi.string().required(),
+    color: Joi.string().required(),
+  }),
+).min(1).unique('value');
+/**
+ * Schema for the validation of custom field definition
+ * The only custom validation is for
+ * {@link CustomFieldDefinitionType.SELECT SELECT}
+ * and
+ * {@link CustomFieldDefinitionType.STATUS STATUS}
+ * field types.
+ * The rest of the field types are validated by Joi
+ */
 const ValidationSchema = Joi.when('fieldType', {
   is: CustomFieldDefinitionType.SELECT,
   then: Joi.array().items(Joi.string()).min(1).unique(),
   otherwise: Joi.any(),
+}).when('fieldType', {
+  is: CustomFieldDefinitionType.STATUS,
+  then: statusValidationObjectSchema,
+  otherwise: Joi.any(),
 });
 
 const CustomFieldDefinitionCreationSchema = Joi.object({

package/src/hooks/create.ts

@@ -2,7 +2,7 @@ import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
 import { MissingRequiredCustomFieldError } from '../errors';
-import { ModelOptions } from '../types';
+import type { ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
 
 /**

package/src/hooks/enrich.ts

@@ -1,10 +1,10 @@
 /* eslint-disable no-param-reassign */
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
-import CustomFieldValue from '../models/CustomFieldValue';
-import CustomFieldDefinition from '../models/CustomFieldDefinition';
-import { SerializedCustomFields } from '../types/definition';
-import { ModelOptions } from '../types';
+import type CustomFieldValue from '../models/CustomFieldValue';
+import type CustomFieldDefinition from '../models/CustomFieldDefinition';
+import type { SerializedCustomFields } from '../types/definition';
+import type { ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
 
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';

package/src/hooks/update.ts

@@ -1,6 +1,6 @@
 import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
-import { ModelOptions } from '../types';
+import type { ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
 
 /**

package/src/index.ts

@@ -1,5 +1,5 @@
 import type { Application } from 'express';
-import { Sequelize } from 'sequelize-typescript';
+import type { Sequelize } from 'sequelize-typescript';
 import {
   initTables, initTestModels,
 } from './models';
@@ -11,13 +11,12 @@ import {
   addHooks, addScopes, applyCustomAssociation, removeHooks,
 } from './utils/init';
 
-export * from './utils/validations/custom-fields';
+export * from './utils/validations/schema/custom-fields';
 
 export * from './utils/constants';
 
 export * from './utils/helpers';
 
-export { CustomFieldDefinitionType } from './utils/validations/type';
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
  * @see {@link 'custom-fields/config'} for configurations

package/src/models/CustomFieldDefinition.ts

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -12,11 +10,12 @@ import {
   AfterSave,
   Is,
 } from 'sequelize-typescript';
-import { validateValidation } from '../utils/validations/custom';
-import { CustomFieldDefinitionType } from '../utils/validations/type';
+import { CustomFieldDefinitionType } from '../utils/constants';
+import { CustomValidationTypes } from '../utils/validations/validators';
 import { CustomFieldValue } from '.';
 import { sendDimEvent } from '../events';
 import { UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } from '../errors';
+import logger from '../utils/logger';
 
 @DefaultScope(() => ({ where: { disabled: false } }))
 @Table({
@@ -30,7 +29,10 @@ import { UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } fro
   timestamps: true,
   validate: {
     validationByType(this: CustomFieldDefinition) {
-      if (!validateValidation(this.fieldType, this.validation)) {
+      // Verify the validation is provided if needed
+      if (!this.validation && CustomValidationTypes[this.fieldType]) {
+        // TODO: enforce the validation-object schema based on the fieldType
+        logger.error(`No custom validation for custom field type ${this.fieldType} found`);
         throw new UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
       }
     },

package/src/models/CustomFieldValue.ts

@@ -1,5 +1,3 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -14,13 +12,11 @@ import {
   BeforeUpdate,
   BeforeBulkCreate,
   BeforeBulkUpdate,
-  Scopes,
 } from 'sequelize-typescript';
 import { sendDimEvent } from '../events';
 import { CustomFieldDefinition } from '.';
-import validateValue from '../utils/validations';
+import { validateValue } from '../utils/validations';
 import * as CustomFieldDefinitionRepo from '../repository/definition';
-import logger from '../utils/logger';
 import { InvalidValueError } from '../errors';
 
 @Table({

package/src/repository/definition.ts

@@ -1,10 +1,7 @@
-import {
-  FindOptions,
-  Op, WhereOptions,
-} from 'sequelize';
+import { Op, type FindOptions, type WhereOptions } from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
-import { ModelOptions } from '../types';
+import type { ModelOptions } from '../types';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);

package/src/repository/value.ts

@@ -2,10 +2,10 @@
 import type { FindOptions, WhereOptions } from 'sequelize';
 import { CustomFieldValue, CustomFieldDefinition } from '../models';
 import * as DefinitionRepo from './definition';
-import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+import type { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
 import logger from '../utils/logger';
 import { MissingDefinitionError } from '../errors';
-import { ModelOptions } from '../types';
+import type { ModelOptions } from '../types';
 
 export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
   CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });

package/src/scopes/filter.ts

@@ -1,5 +1,5 @@
 /* eslint-disable import/prefer-default-export */
-import { Op, WhereOptions } from 'sequelize';
+import { Op, type WhereOptions } from 'sequelize';
 import { Sequelize } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
 
@@ -10,7 +10,11 @@ const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
  * Currently supporting strings and arrays of strings.
  * More types to be added (TBA).
  */
-export type ConditionValue = string | string[];
+type ConditionWithOperator = {
+    operator: string;
+    value: string;
+};
+export type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
 
 export type CustomFieldSort = {
     field: string;
@@ -21,6 +25,13 @@ export type CustomFieldFilterOptions = {
   where?: WhereOptions;
 }
 
+const castIfNeeded = (conditionValue: string): string => {
+  if (!Number.isNaN(Date.parse(conditionValue))) {
+    return '::timestamp';
+  }
+  return '';
+};
+const AND_DELIMETER = ' AND ';
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -37,24 +48,33 @@ export const customFieldsFilterScope = (
   // Build the WHERE clause for custom field filtering
   const conditionsStrings = Object.entries(conditions)
     .map(
-      ([key, value]) => {
-        if (Array.isArray(value)) {
-          if (value.length === 0) {
+      ([key, condition]) => {
+        if (Array.isArray(condition)) {
+          if (condition.length === 0) {
             // if empty array, the condition is ignored
             return false;
           }
-          const values = value.map((v) => `'${v}'`).join(',');
-          return `custom_fields->>'${key}' IN (${values})`;
+          if (typeof condition[0] === 'string') {
+            const values = condition.map((v) => `'${v}'`).join(',');
+            return `(custom_fields->>'${key}') IN (${values})`;
+          }
+          return condition
+            .map((c) => `(custom_fields->>'${key}')${castIfNeeded(c.value)} ${c.operator} '${c.value}'`).join(AND_DELIMETER);
         }
-        return `custom_fields->>'${key}' = '${value}'`;
+        if (typeof condition === 'string') {
+          return `(custom_fields->>'${key}')${castIfNeeded(condition)} = '${condition}'`;
+        }
+        if (condition?.operator) {
+          return `(custom_fields->>'${key}')${castIfNeeded(condition.value)} ${condition.operator} '${condition.value}'`;
+        }
+        return false;
       },
     )
     .filter(Boolean);
-
   if (conditionsStrings.length === 0) {
     return {};
   }
-  const customFieldConditions = conditionsStrings.join(' AND ');
+  const customFieldConditions = conditionsStrings.join(AND_DELIMETER);
 
   const subQuery = `${'SELECT model_id FROM ('
     + 'SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields '
@@ -62,8 +82,7 @@ export const customFieldsFilterScope = (
     + 'INNER JOIN custom_field_definitions AS cd ON cv.custom_field_definition_id = cd.id '
     + `AND cd.model_type = '${name}' `
     + 'GROUP BY cv.model_id'
-    + ') AS CustomFieldAggregation '
-    + 'WHERE '}${customFieldConditions}`;
+    + ') AS CustomFieldAggregation WHERE '}${customFieldConditions}`;
 
   return {
     where: {
@@ -82,26 +101,20 @@ export const customFieldsSortScope = (
   if (!sort || sort.length === 0) {
     return {};
   }
+
+  console.log('sort', sort);
+  console.log('name', name);
+  console.log('Object.entries(sort)', Object.entries(sort));
   const includes = Object.entries(sort).map(([key]) =>
-    ([
-      Sequelize.literal(`(
-        SELECT custom_fields->>'${key}'
-        FROM (
-          SELECT
-            cv.model_id,
-            jsonb_object_agg(cd.name, cv.value) AS custom_fields
-          FROM custom_field_values AS cv
-          INNER JOIN custom_field_definitions AS cd
-          ON cv.custom_field_definition_id = cd.id
-          AND cd.model_type = '${name}'
-          WHERE cv.model_id = "${name}"."id"
-          GROUP BY cv.model_id
-        ) AS CustomFieldAggregation
-      )`),
-      `customFields_${key}`,
-    ]));
+    Sequelize.literal(`(select CustomFieldAggregation.custom_fields->>'${key}'
+                                  from (SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields
+                                         FROM custom_field_values AS cv
+                                                  INNER JOIN custom_field_definitions AS cd
+                                                             ON cv.custom_field_definition_id = cd.id AND cd.model_type = '${name}'
+                                         where cv.model_id = "${name}"."id"
+                                         GROUP BY cv.model_id) AS CustomFieldAggregation) as "customFields.${key}"`));
+  const orders = Object.entries(sort).map(([key, value]) => Sequelize.literal(`"customFields.${key}" ${value}`));
 
-  const orders = Object.entries(sort).map(([key, value]) => Sequelize.literal(`"customFields_${key}" ${value}`));
   return {
     attributes: {
       include: includes,

package/src/tests/functional/searching/index.ts

@@ -16,7 +16,7 @@ const customFieldsSearchTestFlow = async ({
   fieldValue,
   searchTerm,
   expectedNumberOfQueryResults,
-}: CustomFieldsSearchTestFlowInput) : Promise<void> => {
+}: CustomFieldsSearchTestFlowInput): Promise<void> => {
   const definition = createDefinition({ fieldType, name: 'coolDefinition' });
   await DefinitionRepo.create({ ...definition });
   const [testModel1] = await createTestModels(definition.entityId, 2);

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

@@ -1,5 +1,5 @@
 import { v4 as uuidv4 } from 'uuid';
-import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+import type { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
 
 export const contextAwareFieldDefinition = {
   name: 'cool field',
@@ -34,7 +34,7 @@ export const booleanField = (modelType: string): CreateCustomFieldDefinition =>
   entityType: 'fleetId',
 });
 
-export const enumField = (modelType: string, options): CreateCustomFieldDefinition => ({
+export const selectField = (modelType: string, options): CreateCustomFieldDefinition => ({
   name: 'choices',
   modelType,
   fieldType: 'select',
@@ -43,13 +43,11 @@ export const enumField = (modelType: string, options): CreateCustomFieldDefiniti
   entityType: 'fleetId',
 });
 
-export const rangeField = (modelType: string): CreateCustomFieldDefinition => ({
-  name: 'ranges',
+export const statusField = (modelType: string, options): CreateCustomFieldDefinition => ({
+  name: 'lifecycle',
   modelType,
-  fieldType: 'number',
-  validation: {
-    between: [10, 12],
-  },
+  fieldType: 'status',
+  validation: options,
   entityId: uuidv4(),
   entityType: 'fleetId',
 });

package/src/types/index.ts

@@ -1,5 +1,5 @@
-import { IncludeOptions } from 'sequelize';
-import { ModelCtor } from 'sequelize-typescript';
+import type { IncludeOptions } from 'sequelize';
+import type { ModelCtor } from 'sequelize-typescript';
 
 export type ModelFetcher = (name: string) => any;
 

package/src/utils/constants/index.ts

@@ -2,9 +2,22 @@ import { customFields } from '@autofleet/common-types';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
 
-// eslint-disable-next-line import/prefer-default-export
 export const supportedEntities = ['businessModelId', 'fleetId', 'demandSourceId'];
 
+/**
+ * Supported custom field types
+ */
+export enum CustomFieldDefinitionType {
+  NUMBER = 'number',
+  BOOLEAN = 'boolean',
+  DATE = 'date',
+  DATETIME = 'datetime',
+  TEXT = 'text',
+  IMAGE = 'image',
+  SELECT = 'select',
+  STATUS = 'status',
+}
+
 export {
   /** @deprecated Use the value from `@autofleet/common-types` instead */
   CUSTOM_FIELDS_FILTER_SCOPE,

package/src/utils/helpers/index.ts

@@ -1,7 +1,7 @@
 /* eslint-disable import/prefer-default-export */
-import { WhereOptions, Op, BindOrReplacements } from 'sequelize';
-import { ModelStatic, Sequelize } from 'sequelize-typescript';
-import { CustomFieldDefinitionType } from '../validations/type';
+import { type WhereOptions, Op, type BindOrReplacements } from 'sequelize';
+import { type ModelStatic, Sequelize } from 'sequelize-typescript';
+import { CustomFieldDefinitionType } from '../constants';
 
 /**
  * Builds a WHERE clause and replacements for free-text search by custom fields.
@@ -28,8 +28,8 @@ interface CustomFieldsSearchPayload {
 export const generateCustomFieldSearchQueryPayload = (
   searchTerm: string,
   model: ModelStatic,
-  entityId : string,
-  customFieldsTypesToExclude : CustomFieldDefinitionType[] = [
+  entityId: string,
+  customFieldsTypesToExclude: CustomFieldDefinitionType[] = [
     CustomFieldDefinitionType.DATETIME,
     CustomFieldDefinitionType.DATE,
   ],

package/src/utils/init.ts

@@ -1,5 +1,5 @@
 import { DataTypes } from 'sequelize';
-import { ModelCtor } from 'sequelize-typescript';
+import type { ModelCtor } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
 import { CUSTOM_FIELDS_SORT_SCOPE } from '@autofleet/common-types/lib/custom-fields';
 import {

package/src/utils/validations/index.ts

@@ -1,19 +1,22 @@
-import customValidation from './custom';
-import validateValueType from './type';
+import type { CustomFieldDefinitionType } from '../constants';
+import { validators } from './validators';
 
-const validateValue = (value, valueType, customValidations) => {
-  if (!validateValueType(value, valueType)) {
+export const validateValue = (
+  value: unknown,
+  valueType: CustomFieldDefinitionType,
+  validation?: unknown,
+) => {
+  const validator = validators[valueType];
+  if (!validator) {
+    // Unsupported field type
     return false;
   }
-  if (customValidations) {
-    return customValidation(value, valueType, customValidations);
-  }
-
-  // if (validations.required && !value) {
-  //   return false;
-  // }
-
-  return true;
+  // Always allow null values
+  return value === null || validator(value, validation);
+  /** TODO: Add validation for required fields
+   * @example
+   * if (validations.required && !value) {
+   *  return false;
+   * }
+   */
 };
-
-export default validateValue;

package/src/utils/validations/{custom-fields.ts → schema/custom-fields.ts}

@@ -1,4 +1,3 @@
-/* eslint-disable import/prefer-default-export */
 import Joi from 'joi';
 
 const CustomFieldsSchema = Joi.object().pattern(

package/src/utils/validations/type.ts

@@ -1,45 +1,19 @@
-import Joi from 'joi';
+import type { CustomFieldDefinitionType } from '../constants';
+
 /**
- * Supported custom field types
+ * 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.
  */
-// eslint-disable-next-line no-shadow
-export enum CustomFieldDefinitionType {
-  NUMBER = 'number',
-  BOOLEAN = 'boolean',
-  DATE = 'date',
-  DATETIME = 'datetime',
-  TEXT = 'text',
-  IMAGE = 'image',
-  SELECT = 'select',
-}
+export type Validator<Value, DefinitionValidationObject> = (
+   value: Value,
+   validation?: DefinitionValidationObject
+  ) => boolean;
+
 /**
- * Validate that the given value is really of type "valueType"
- * TODO: verify that required field not set to null
+ * 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.
  */
-const validateValueType = (value: unknown, valueType: CustomFieldDefinitionType): boolean => {
-  if (value === null) {
-    // Null is always allowed
-    return true;
-  }
-
-  switch (valueType) {
-    case CustomFieldDefinitionType.TEXT:
-      return typeof value === 'string';
-    case CustomFieldDefinitionType.NUMBER:
-      return typeof value === 'number';
-    case CustomFieldDefinitionType.BOOLEAN:
-      return typeof value === 'boolean';
-    case CustomFieldDefinitionType.DATE:
-    case CustomFieldDefinitionType.DATETIME:
-      return !Joi.date().validate(value).error;
-    case CustomFieldDefinitionType.SELECT:
-      return true; // custom validation
-    case CustomFieldDefinitionType.IMAGE:
-      return !Joi.array().min(1).unique().items(Joi.string().uri())
-        .validate(value).error;
-    default:
-      return false;
-  }
+export type Validators = {
+  [K in CustomFieldDefinitionType]: Validator<unknown, unknown>;
 };
-
-export default validateValueType;