@autofleet/sadot 0.6.2 → 0.6.3-beta.1

package/src/scopes/filter.ts

@@ -1,5 +1,5 @@
 /* eslint-disable import/prefer-default-export */
-import { Op, type WhereOptions } from 'sequelize';
+import { Op, WhereOptions } from 'sequelize';
 import { Sequelize } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
 
@@ -75,3 +75,28 @@ export const customFieldsFilterScope = (
 };
 
 export const scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
+
+export const customFieldsSortScope = (
+  name: string,
+) => (sort: CustomFieldSort[]) => {
+  if (!sort || sort.length === 0) {
+    return {};
+  }
+
+  const incluedes = Object.entries(sort).map(([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 = 'Task'
+                                         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}`));
+
+  return {
+    attributes: {
+      include: incluedes,
+    },
+    order: orders,
+  };
+};

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 type { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+import { 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 selectField = (modelType: string, options): CreateCustomFieldDefinition => ({
+export const enumField = (modelType: string, options): CreateCustomFieldDefinition => ({
   name: 'choices',
   modelType,
   fieldType: 'select',
@@ -43,11 +43,13 @@ export const selectField = (modelType: string, options): CreateCustomFieldDefini
   entityType: 'fleetId',
 });
 
-export const statusField = (modelType: string, options): CreateCustomFieldDefinition => ({
-  name: 'lifecycle',
+export const rangeField = (modelType: string): CreateCustomFieldDefinition => ({
+  name: 'ranges',
   modelType,
-  fieldType: 'status',
-  validation: options,
+  fieldType: 'number',
+  validation: {
+    between: [10, 12],
+  },
   entityId: uuidv4(),
   entityType: 'fleetId',
 });

package/src/types/index.ts

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

package/src/utils/helpers/index.ts

@@ -1,6 +1,6 @@
 /* eslint-disable import/prefer-default-export */
-import { type WhereOptions, Op, type BindOrReplacements } from 'sequelize';
-import { type ModelStatic, Sequelize } from 'sequelize-typescript';
+import { WhereOptions, Op, BindOrReplacements } from 'sequelize';
+import { ModelStatic, Sequelize } from 'sequelize-typescript';
 import { CustomFieldDefinitionType } from '../validations/type';
 
 /**
@@ -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,6 +1,7 @@
 import { DataTypes } from 'sequelize';
-import type { ModelCtor } from 'sequelize-typescript';
+import { ModelCtor } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
+import { CUSTOM_FIELDS_SORT_SCOPE } from '@autofleet/common-types/lib/custom-fields';
 import {
   CustomFieldDefinition,
   CustomFieldValue,
@@ -16,6 +17,7 @@ import {
 import { customFieldsFilterScope } from '../scopes';
 import logger from './logger';
 import type { ModelFetcher, Models } from '../types';
+import { customFieldsSortScope } from '../scopes/filter';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
 
@@ -99,6 +101,7 @@ export const addScopes = (models: Models[], getModel: ModelFetcher): void => {
       addAssociations(model, name);
       // Add filter scope
       model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, customFieldsFilterScope(name));
+      model.addScope(CUSTOM_FIELDS_SORT_SCOPE, customFieldsSortScope(name));
     } catch (e) {
       logger.error(`Could not add custom fields scopes to model ${name}. `, e);
     }

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

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

package/src/utils/validations/custom.ts

@@ -0,0 +1,39 @@
+/* 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/index.ts

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

package/src/utils/validations/type.ts

@@ -1,6 +1,8 @@
+import Joi from 'joi';
 /**
- * Supported custom field types enum
+ * Supported custom field types
  */
+// eslint-disable-next-line no-shadow
 export enum CustomFieldDefinitionType {
   NUMBER = 'number',
   BOOLEAN = 'boolean',
@@ -9,10 +11,35 @@ export enum CustomFieldDefinitionType {
   TEXT = 'text',
   IMAGE = 'image',
   SELECT = 'select',
-  STATUS = 'status',
 }
+/**
+ * Validate that the given value is really of type "valueType"
+ * TODO: verify that required field not set to null
+ */
+const validateValueType = (value: unknown, valueType: CustomFieldDefinitionType): boolean => {
+  if (value === null) {
+    // Null is always allowed
+    return true;
+  }
 
-export type Validator<Value, Validation> = (value: Value, validation?: Validation) => boolean;
-export type Validators = {
-  [K in CustomFieldDefinitionType]: Validator<unknown, unknown>;
+  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 default validateValueType;

package/src/utils/validations/validators.ts

@@ -0,0 +1,34 @@
+// 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;

package/.env

@@ -1,3 +0,0 @@
-NODE_ENV=test
-# LOG_LEVEL=debug
-# SADOT_DEBUG=true

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

@@ -1,29 +0,0 @@
-import Joi from 'joi';
-import { CustomFieldDefinitionType, 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.
- */
-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

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

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

@@ -1,20 +0,0 @@
-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,
-) => (statusValues
-   && Array.isArray(statusValues)
-   && statusValues.length > 0
-   && statusValues.map((status) => status.value).includes(value)
-);