@autofleet/sadot 0.6.4 → 0.6.5

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';
 

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;

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

@@ -0,0 +1,31 @@
+import Joi from 'joi';
+import { CustomFieldDefinitionType } from '../../constants';
+import type { Validators } from '../type';
+import { validateSelect } from './select.validator';
+import { validateStatus } from './status.validator';
+
+type CustomValidationTypes = Extract<CustomFieldDefinitionType, 'select' | 'status'>;
+/**
+ * Custom field types that must have custom validation.
+ * TODO: remove this after moving to schema-based validation
+ */
+export const CustomValidationTypes = {
+  [CustomFieldDefinitionType.SELECT]: CustomFieldDefinitionType.SELECT,
+  [CustomFieldDefinitionType.STATUS]: CustomFieldDefinitionType.STATUS,
+} as const;
+
+/**
+ * Validators for custom fields
+ */
+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()
+    .items(Joi.string().uri())
+    .validate(value).error),
+};

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

@@ -0,0 +1,11 @@
+import type { Validator } from '../type';
+
+/**
+ * Validate that the value is one of the select values
+ */
+export const validateSelect: Validator<string, string[]> = (
+  value,
+  selectValues,
+) => (Array.isArray(selectValues)
+      && selectValues.includes(value)
+);

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

@@ -0,0 +1,18 @@
+import type { Validator } from '../type';
+
+type StatusColor = string | null; // TODO: Takes from @autofleet/colors ?
+type StatusValue = string;
+type StatusOption = {
+  value: StatusValue;
+  color: StatusColor;
+}
+
+/**
+* Validate that the value is one of the status values
+*/
+export const validateStatus: Validator<StatusValue, StatusOption[]> = (
+  value,
+  statusValues,
+) => (Array.isArray(statusValues)
+   && statusValues.some((status) => status.value === value)
+);

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

@@ -1,15 +0,0 @@
-export declare const mustHaveCustomValidation: {
-    select: boolean;
-};
-/**
- * Validates the given validations object against the supported field types and their validators.
- * @return true if the validation is valid, false otherwise.
- */
-export declare const validateValidation: (valueType: any, validation: any) => boolean;
-/**
- * Validates the given value against the custom validation rules for the specified field type.
- * If no custom validation rules are provided, it falls back to the default validation.
- * @returns true if the value is valid according to the validation rules, false otherwise.
- */
-declare const customValidation: (value: any, valueType: any, validation: any) => boolean;
-export default customValidation;

package/dist/utils/validations/custom.js

@@ -1,42 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateValidation = exports.mustHaveCustomValidation = void 0;
-/* eslint-disable no-shadow */
-const logger_1 = __importDefault(require("../logger"));
-const type_1 = require("./type");
-const validators_1 = __importDefault(require("./validators"));
-exports.mustHaveCustomValidation = {
-    [type_1.CustomFieldDefinitionType.SELECT]: true,
-};
-/**
- * Validates the given validations object against the supported field types and their validators.
- * @return true if the validation is valid, false otherwise.
- */
-const validateValidation = (valueType, validation) => {
-    if (!validation) {
-        if (exports.mustHaveCustomValidation[valueType]) {
-            logger_1.default.error(`No custom validation for custom field type ${valueType} found`);
-            return false;
-        }
-        return true;
-    }
-    return true;
-};
-exports.validateValidation = validateValidation;
-/**
- * Validates the given value against the custom validation rules for the specified field type.
- * If no custom validation rules are provided, it falls back to the default validation.
- * @returns true if the value is valid according to the validation rules, false otherwise.
- */
-const customValidation = (value, valueType, validation) => {
-    const validator = validators_1.default?.[valueType];
-    if (!validation || !validator) {
-        return (0, exports.validateValidation)(valueType, validation);
-    }
-    // Always allow null values
-    return value === null || validator(value, validation);
-};
-exports.default = customValidation;

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

@@ -1,12 +0,0 @@
-export declare enum CustomValidations {
-    SELECT = "select",
-    RANGE = "between"
-}
-type Validator = (value: any, validation: any) => boolean;
-/**
- * Validators for custom fields
- */
-declare const validators: {
-    [key: string]: Validator;
-};
-export default validators;

package/dist/utils/validations/validators.js

@@ -1,33 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomValidations = void 0;
-// eslint-disable-next-line no-shadow
-var CustomValidations;
-(function (CustomValidations) {
-    CustomValidations["SELECT"] = "select";
-    CustomValidations["RANGE"] = "between";
-})(CustomValidations = exports.CustomValidations || (exports.CustomValidations = {}));
-/**
- * Validate {@link CustomValidations.ENUM Enum}
- */
-const validateEnum = (value, enumValues) => (Array.isArray(enumValues)
-    && enumValues.length > 0
-    && enumValues.includes(value));
-/**
- * Validate {@link CustomValidations.RANGE Range}
- */
-const validateRange = (value, range) => {
-    const [min, max] = range;
-    if (min === undefined || max === undefined) {
-        return false;
-    }
-    return value >= range.min && value <= range.max;
-};
-/**
- * Validators for custom fields
- */
-const validators = {
-    [CustomValidations.SELECT]: validateEnum,
-    [CustomValidations.RANGE]: validateRange,
-};
-exports.default = validators;

package/src/utils/validations/custom.ts

@@ -1,39 +0,0 @@
-/* eslint-disable no-shadow */
-import logger from '../logger';
-import { CustomFieldDefinitionType } from './type';
-import validators from './validators';
-
-export const mustHaveCustomValidation = {
-  [CustomFieldDefinitionType.SELECT]: true,
-};
-
-/**
- * Validates the given validations object against the supported field types and their validators.
- * @return true if the validation is valid, false otherwise.
- */
-export const validateValidation = (valueType, validation) => {
-  if (!validation) {
-    if (mustHaveCustomValidation[valueType]) {
-      logger.error(`No custom validation for custom field type ${valueType} found`);
-      return false;
-    }
-    return true;
-  }
-  return true;
-};
-
-/**
- * Validates the given value against the custom validation rules for the specified field type.
- * If no custom validation rules are provided, it falls back to the default validation.
- * @returns true if the value is valid according to the validation rules, false otherwise.
- */
-const customValidation = (value, valueType, validation) => {
-  const validator = validators?.[valueType];
-  if (!validation || !validator) {
-    return validateValidation(valueType, validation);
-  }
-  // Always allow null values
-  return value === null || validator(value, validation);
-};
-
-export default customValidation;

package/src/utils/validations/validators.ts

@@ -1,34 +0,0 @@
-// eslint-disable-next-line no-shadow
-export enum CustomValidations {
-    SELECT = 'select',
-    RANGE = 'between'
-}
-
-type Validator = (value, validation) => boolean;
-/**
- * Validate {@link CustomValidations.ENUM Enum}
- */
-const validateEnum: Validator = (value, enumValues) => (Array.isArray(enumValues)
-    && enumValues.length > 0
-    && enumValues.includes(value)
-);
-/**
- * Validate {@link CustomValidations.RANGE Range}
- */
-const validateRange: Validator = (value, range) => {
-  const [min, max] = range;
-  if (min === undefined || max === undefined) {
-    return false;
-  }
-  return value >= range.min && value <= range.max;
-};
-
-/**
- * Validators for custom fields
- */
-const validators: { [key: string]: Validator } = {
-  [CustomValidations.SELECT]: validateEnum,
-  [CustomValidations.RANGE]: validateRange,
-};
-
-export default validators;