@autofleet/sadot 0.6.2-beta.0 → 0.6.2-temp-file-2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.6.2-beta.0",
+  "version": "0.6.2-temp-file-2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -45,18 +45,18 @@
     "@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",
   "license": "ISC"
-}
+}

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,23 @@
 import Joi from 'joi';
-import { CustomFieldDefinitionType } from '../../../utils/validations/type';
+import { CustomFieldDefinitionType } from '../../../utils/constants';
 
+/**
+ * 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: Joi.string().min(1).required(),
+  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,11 +10,7 @@ const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
  * Currently supporting strings and arrays of strings.
  * More types to be added (TBA).
  */
-type ConditionWithOperator = {
-    operator: string;
-    value: string;
-};
-export type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
+export type ConditionValue = string | string[];
 
 export type CustomFieldSort = {
     field: string;
@@ -25,13 +21,6 @@ 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.
@@ -48,33 +37,24 @@ export const customFieldsFilterScope = (
   // Build the WHERE clause for custom field filtering
   const conditionsStrings = Object.entries(conditions)
     .map(
-      ([key, condition]) => {
-        if (Array.isArray(condition)) {
-          if (condition.length === 0) {
+      ([key, value]) => {
+        if (Array.isArray(value)) {
+          if (value.length === 0) {
             // if empty array, the condition is ignored
             return false;
           }
-          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);
+          const values = value.map((v) => `'${v}'`).join(',');
+          return `custom_fields->>'${key}' IN (${values})`;
         }
-        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;
+        return `custom_fields->>'${key}' = '${value}'`;
       },
     )
     .filter(Boolean);
+
   if (conditionsStrings.length === 0) {
     return {};
   }
-  const customFieldConditions = conditionsStrings.join(AND_DELIMETER);
+  const customFieldConditions = conditionsStrings.join(' AND ');
 
   const subQuery = `${'SELECT model_id FROM ('
     + 'SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields '
@@ -82,7 +62,8 @@ 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: {

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,23 @@ 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',
+  FILE = 'file',
+}
+
 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 {
   CustomFieldDefinition,

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,39 @@
+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),
+  [CustomFieldDefinitionType.FILE]: (value) => (!Joi.array().min(1).unique().items(Joi.object({
+    id: Joi.string().uuid().required(),
+    name: Joi.string().required(),
+    link: Joi.string().required(),
+    createdAt: Joi.date(),
+    addedBy: Joi.string().uuid(),
+  }))
+    .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/api/index.d.ts

@@ -1,2 +0,0 @@
-declare const router: import("express-serve-static-core").Router;
-export default router;

package/dist/api/index.js

@@ -1,11 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-// export the api object
-const express_1 = require("express");
-const v1_1 = __importDefault(require("./v1"));
-const router = (0, express_1.Router)({ mergeParams: true });
-router.use('/v1', v1_1.default);
-exports.default = router;

package/dist/api/v1/definition/index.d.ts

@@ -1,2 +0,0 @@
-declare const router: import("express-serve-static-core").Router;
-export default router;