@autofleet/sadot 0.6.7-beta.1 → 0.6.8-beta.1

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

@@ -5,17 +5,34 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCustomFieldDefinitionUpdate = exports.validateCustomFieldDefinitionCreation = void 0;
 const joi_1 = __importDefault(require("joi"));
-const type_1 = require("../../../utils/validations/type");
+const constants_1 = require("../../../utils/constants");
+const statusValidationObjectSchema = joi_1.default.array().items(joi_1.default.object({
+    value: joi_1.default.string().required(),
+    color: joi_1.default.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_1.default.when('fieldType', {
-    is: type_1.CustomFieldDefinitionType.SELECT,
+    is: constants_1.CustomFieldDefinitionType.SELECT,
     then: joi_1.default.array().items(joi_1.default.string()).min(1).unique(),
     otherwise: joi_1.default.any(),
+}).when('fieldType', {
+    is: constants_1.CustomFieldDefinitionType.STATUS,
+    then: statusValidationObjectSchema,
+    otherwise: joi_1.default.any(),
 });
 const CustomFieldDefinitionCreationSchema = joi_1.default.object({
     name: joi_1.default.string().required(),
     displayName: joi_1.default.string().required(),
     validation: ValidationSchema,
-    fieldType: joi_1.default.string().valid(...Object.values(type_1.CustomFieldDefinitionType)).required(),
+    fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)).required(),
     entityId: joi_1.default.string().guid().required(),
     entityType: joi_1.default.string().required(),
     description: joi_1.default.string(),
@@ -25,7 +42,7 @@ const CustomFieldDefinitionCreationSchema = joi_1.default.object({
 const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
     displayName: joi_1.default.string(),
     validation: ValidationSchema,
-    fieldType: joi_1.default.string().valid(...Object.values(type_1.CustomFieldDefinitionType)),
+    fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)),
     description: joi_1.default.string().allow(null),
     required: joi_1.default.boolean(),
     disabled: joi_1.default.boolean(),

package/dist/hooks/create.d.ts

@@ -1,4 +1,4 @@
-import { ModelOptions } from '../types';
+import type { ModelOptions } from '../types';
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
  */

package/dist/hooks/enrich.d.ts

@@ -1,4 +1,4 @@
-import { ModelOptions } from '../types';
+import type { ModelOptions } from '../types';
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
 /**
  * A hook to attach the custom fields when fetching a model instances.

package/dist/hooks/update.d.ts

@@ -1,4 +1,4 @@
-import { ModelOptions } from '../types';
+import type { ModelOptions } from '../types';
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
  */

package/dist/index.d.ts

@@ -1,10 +1,9 @@
 import type { Application } from 'express';
-import { Sequelize } from 'sequelize-typescript';
+import type { Sequelize } from 'sequelize-typescript';
 import type { CustomFieldOptions, ModelFetcher } from './types';
-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/dist/index.js

@@ -17,17 +17,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.disableCustomFields = exports.CustomFieldDefinitionType = void 0;
+exports.disableCustomFields = void 0;
 const models_1 = require("./models");
 const api_1 = __importDefault(require("./api"));
 const db_1 = __importDefault(require("./utils/db"));
 const logger_1 = __importDefault(require("./utils/logger"));
 const init_1 = require("./utils/init");
-__exportStar(require("./utils/validations/custom-fields"), exports);
+__exportStar(require("./utils/validations/schema/custom-fields"), exports);
 __exportStar(require("./utils/constants"), exports);
 __exportStar(require("./utils/helpers"), exports);
-var type_1 = require("./utils/validations/type");
-Object.defineProperty(exports, "CustomFieldDefinitionType", { enumerable: true, get: function () { return type_1.CustomFieldDefinitionType; } });
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
  * @see {@link 'custom-fields/config'} for configurations

package/dist/models/CustomFieldDefinition.d.ts

@@ -1,5 +1,5 @@
 import { Model } from 'sequelize-typescript';
-import { CustomFieldDefinitionType } from '../utils/validations/type';
+import { CustomFieldDefinitionType } from '../utils/constants';
 import { CustomFieldValue } from '.';
 declare class CustomFieldDefinition extends Model {
     id: string;

package/dist/models/CustomFieldDefinition.js

@@ -8,15 +8,17 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable indent */
 const sequelize_typescript_1 = require("sequelize-typescript");
-const custom_1 = require("../utils/validations/custom");
-const type_1 = require("../utils/validations/type");
+const constants_1 = require("../utils/constants");
+const validators_1 = require("../utils/validations/validators");
 const _1 = require(".");
 const events_1 = require("../events");
 const errors_1 = require("../errors");
+const logger_1 = __importDefault(require("../utils/logger"));
 let CustomFieldDefinition = class CustomFieldDefinition extends sequelize_typescript_1.Model {
     static displayNameDefaultValue(instance) {
         if (!instance?.displayName) {
@@ -57,7 +59,7 @@ __decorate([
 ], CustomFieldDefinition.prototype, "displayName", void 0);
 __decorate([
     (0, sequelize_typescript_1.Is)('SupportedType', (value) => {
-        if (!Object.values(type_1.CustomFieldDefinitionType).includes(value)) {
+        if (!Object.values(constants_1.CustomFieldDefinitionType).includes(value)) {
             throw new errors_1.UnsupportedCustomFieldTypeError(`"${value}" is not a supported type.`);
         }
     }),
@@ -155,7 +157,10 @@ CustomFieldDefinition = __decorate([
         timestamps: true,
         validate: {
             validationByType() {
-                if (!(0, custom_1.validateValidation)(this.fieldType, this.validation)) {
+                // Verify the validation is provided if needed
+                if (!this.validation && validators_1.CustomValidationTypes[this.fieldType]) {
+                    // TODO: enforce the validation-object schema based on the fieldType
+                    logger_1.default.error(`No custom validation for custom field type ${this.fieldType} found`);
                     throw new errors_1.UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
                 }
             },

package/dist/models/CustomFieldValue.js

@@ -31,16 +31,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable indent */
 const sequelize_typescript_1 = require("sequelize-typescript");
 const events_1 = require("../events");
 const _1 = require(".");
-const validations_1 = __importDefault(require("../utils/validations"));
+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 {
@@ -54,7 +49,7 @@ let CustomFieldValue = class CustomFieldValue extends sequelize_typescript_1.Mod
         instances.forEach((instance) => {
             const { validation, fieldType, } = definitions
                 .find((definition) => definition.id === instance.customFieldDefinitionId);
-            const isValid = (0, validations_1.default)(instance.value, fieldType, validation);
+            const isValid = (0, validations_1.validateValue)(instance.value, fieldType, validation);
             if (!isValid) {
                 throw new errors_1.InvalidValueError(instance.value, fieldType);
             }
@@ -65,7 +60,7 @@ let CustomFieldValue = class CustomFieldValue extends sequelize_typescript_1.Mod
         // eslint-disable-next-line max-len
         const cfd = await CustomFieldDefinitionRepo.findById(customFieldDefinitionId, { withDisabled: true });
         const { validation, fieldType } = cfd;
-        const isValid = (0, validations_1.default)(instance.value, fieldType, validation);
+        const isValid = (0, validations_1.validateValue)(instance.value, fieldType, validation);
         if (!isValid) {
             throw new errors_1.InvalidValueError(instance.value, fieldType);
         }

package/dist/repository/definition.d.ts

@@ -1,7 +1,7 @@
-import { FindOptions, WhereOptions } from 'sequelize';
+import { 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 declare const create: (data: CreateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
 export declare const findAll: (where: WhereOptions, options?: any) => Promise<CustomFieldDefinition[]>;
 export declare const findByIds: (ids: string[], options?: any) => Promise<CustomFieldDefinition[]>;

package/dist/repository/value.d.ts

@@ -1,7 +1,7 @@
 import type { FindOptions } from 'sequelize';
 import { CustomFieldValue } from '../models';
-import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
-import { ModelOptions } from '../types';
+import type { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+import type { ModelOptions } from '../types';
 export declare const findByModelIdAndDefinition: (modelId: string, customFieldDefinitionId: string) => Promise<CustomFieldValue[]>;
 export declare const create: (data: CreateCustomFieldValue, withAssociations?: boolean) => Promise<CustomFieldValue>;
 export declare const findAllValues: () => Promise<CustomFieldValue[]>;

package/dist/scopes/filter.d.ts

@@ -1,32 +1,33 @@
-import { WhereOptions } from 'sequelize';
+import { type WhereOptions } from 'sequelize';
 /**
  * Type representing possible condition values.
  * 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;
     direction: 'ASC' | 'DESC';
 };
 export type CustomFieldFilterOptions = {
     where?: WhereOptions;
+    replacements?: Record<string, string>;
 };
-/**
- * A Sequelize scope for filtering models by custom fields.
- * This scope builds a WHERE clause to be applied on the main query.
- *
- * @param {string} name - The model type name used to join custom_field_definitions.
- * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
- */
 export declare const customFieldsFilterScope: (name: string) => (conditions: Record<string, ConditionValue>) => CustomFieldFilterOptions;
 export declare const scopeName = "filterByCustomFields";
 export declare const customFieldsSortScope: (name: string) => (sort: CustomFieldSort[]) => {
     attributes?: undefined;
     order?: undefined;
+    replacements?: undefined;
 } | {
     attributes: {
         include: (string | import("sequelize/types/utils").Literal)[][];
     };
     order: import("sequelize/types/utils").Literal[];
+    replacements: Record<string, string>;
 };
+export {};

package/dist/scopes/filter.js

@@ -1,54 +1,90 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.customFieldsSortScope = exports.scopeName = exports.customFieldsFilterScope = void 0;
 /* eslint-disable import/prefer-default-export */
 const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const common_types_1 = require("@autofleet/common-types");
+const moment_1 = __importDefault(require("moment"));
+const helpers_1 = require("../utils/helpers");
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
-/**
- * A Sequelize scope for filtering models by custom fields.
- * This scope builds a WHERE clause to be applied on the main query.
- *
- * @param {string} name - The model type name used to join custom_field_definitions.
- * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
- */
+const castIfNeeded = (conditionValue) => {
+    if (moment_1.default.isDate(conditionValue)) {
+        return '::timestamp';
+    }
+    if (!Number.isNaN(Number(conditionValue))) {
+        return '::numeric';
+    }
+    return '';
+};
+const AND_DELIMETER = ' AND ';
 const customFieldsFilterScope = (name) => (conditions) => {
     if (!conditions || Object.keys(conditions).length === 0) {
         return {};
     }
+    const randomStr = (0, helpers_1.generateRandomString)();
+    const replacementMapPrefix = `customFieldsFilterScopeConditionMap_${randomStr}`;
+    const replacements = {};
+    replacements[`customFieldsFilterScopeConditionName_${randomStr}`] = `${name}`;
     // Build the WHERE clause for custom field filtering
     const conditionsStrings = Object.entries(conditions)
-        .map(([key, value]) => {
-        if (Array.isArray(value)) {
-            if (value.length === 0) {
+        .map(([key, condition], index) => {
+        const replacemetKey = `${replacementMapPrefix}Key${index}`;
+        replacements[replacemetKey] = `${key}`;
+        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) => {
+                    const valRandom = (0, helpers_1.generateRandomString)();
+                    replacements[`${valRandom}`] = `${v}`;
+                    return ` :${valRandom} `;
+                }).join(',');
+                return `(custom_fields->> :${replacemetKey} ) IN ( ${values} )`;
+            }
+            return condition
+                .map((c, cIndex) => {
+                const valRep = `${replacementMapPrefix}Values${index}${cIndex}`;
+                replacements[valRep] = `${c.value}`;
+                return `(custom_fields->> :${replacemetKey} )${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
+            }).join(AND_DELIMETER);
+        }
+        if (typeof condition === 'string') {
+            const conditionRep = `${replacementMapPrefix}Condition${index}`;
+            replacements[conditionRep] = `${condition}`;
+            return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition)} = :${conditionRep}`;
+        }
+        if (condition?.operator) {
+            const valueRep = `${replacementMapPrefix}Values${index}`;
+            replacements[valueRep] = `${condition.value}`;
+            return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
         }
-        return `custom_fields->>'${key}' = '${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 '
         + '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}' `
+        + `AND cd.model_type = :${`customFieldsFilterScopeConditionName_${randomStr}`} `
         + 'GROUP BY cv.model_id'
-        + ') AS CustomFieldAggregation '
-        + 'WHERE '}${customFieldConditions}`;
+        + ') AS CustomFieldAggregation WHERE '} ${customFieldConditions}`;
     return {
         where: {
             id: {
                 [sequelize_1.Op.in]: sequelize_typescript_1.Sequelize.literal(`(${subQuery})`),
             },
         },
+        replacements,
     };
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
@@ -57,26 +93,33 @@ const customFieldsSortScope = (name) => (sort) => {
     if (!sort || sort.length === 0) {
         return {};
     }
-    const includes = Object.entries(sort).map(([key]) => ([
-        sequelize_typescript_1.Sequelize.literal(`(
+    const randomStr = (0, helpers_1.generateRandomString)();
+    const replacements = {};
+    const includes = Object.entries(sort).map(([key], index) => {
+        const keyReplacement = `key_${randomStr}_${index}`;
+        replacements[`keyCustomFields_${randomStr}_${index}`] = `customFields_${key}`;
+        replacements[keyReplacement] = `${key}`;
+        return ([
+            sequelize_typescript_1.Sequelize.literal(`(
             SELECT value
             FROM (SELECT cv.model_id, cv.value
                   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"
-                          AND cd.name = '${key}'
+                          AND cd.name = :${keyReplacement}
                           ) AS CustomFieldAggregation
             )
-          `),
-        `customFields_${key}`,
-    ]));
-    const orders = Object.entries(sort).map(([key, value]) => sequelize_typescript_1.Sequelize.literal(`"customFields_${key}" ${value}`));
+          `), randomStr,
+        ]);
+    });
+    const orders = Object.entries(sort).map(([, value]) => sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${value}`));
     return {
         attributes: {
             include: includes,
         },
         order: orders,
+        replacements,
     };
 };
 exports.customFieldsSortScope = customFieldsSortScope;

package/dist/tests/helpers/database-config.d.ts

@@ -10,7 +10,10 @@ declare const _default: {
             underscored: boolean;
             underscoredAll: boolean;
         };
-        logging: boolean;
+        logging: {
+            (...data: any[]): void;
+            (message?: any, ...optionalParams: any[]): void;
+        };
     };
 };
 export default _default;

package/dist/tests/helpers/database-config.js

@@ -12,6 +12,6 @@ exports.default = {
             underscored: true,
             underscoredAll: true,
         },
-        logging: false,
+        logging: console.log,
     },
 };

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

@@ -1,4 +1,4 @@
-import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+import type { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
 export declare const contextAwareFieldDefinition: {
     name: string;
     modelType: string;
@@ -37,7 +37,7 @@ export declare const coolFieldDefinition3: {
     modelType: string;
 };
 export declare const booleanField: (modelType: string) => CreateCustomFieldDefinition;
-export declare const enumField: (modelType: string, options: any) => CreateCustomFieldDefinition;
-export declare const rangeField: (modelType: string) => CreateCustomFieldDefinition;
+export declare const selectField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const statusField: (modelType: string, options: any) => 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.rangeField = exports.enumField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
+exports.createDefinitions = exports.createDefinition = exports.statusField = exports.selectField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
 const uuid_1 = require("uuid");
 exports.contextAwareFieldDefinition = {
     name: 'cool field',
@@ -31,7 +31,7 @@ const booleanField = (modelType) => ({
     entityType: 'fleetId',
 });
 exports.booleanField = booleanField;
-const enumField = (modelType, options) => ({
+const selectField = (modelType, options) => ({
     name: 'choices',
     modelType,
     fieldType: 'select',
@@ -39,18 +39,16 @@ const enumField = (modelType, options) => ({
     entityId: (0, uuid_1.v4)(),
     entityType: 'fleetId',
 });
-exports.enumField = enumField;
-const rangeField = (modelType) => ({
-    name: 'ranges',
+exports.selectField = selectField;
+const statusField = (modelType, options) => ({
+    name: 'lifecycle',
     modelType,
-    fieldType: 'number',
-    validation: {
-        between: [10, 12],
-    },
+    fieldType: 'status',
+    validation: options,
     entityId: (0, uuid_1.v4)(),
     entityType: 'fleetId',
 });
-exports.rangeField = rangeField;
+exports.statusField = statusField;
 // eslint-disable-next-line max-len
 const createDefinition = (defaults) => ({
     name: defaults?.name || `def_${(0, uuid_1.v4)()}`,

package/dist/types/index.d.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;
 export type ModelOptions = {
     /**

package/dist/utils/constants/index.d.ts

@@ -1,5 +1,19 @@
 declare const CUSTOM_FIELDS_FILTER_SCOPE: string;
 export declare const supportedEntities: string[];
+/**
+ * Supported custom field types
+ */
+export declare 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/dist/utils/constants/index.js

@@ -1,8 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CUSTOM_FIELDS_FILTER_SCOPE = exports.supportedEntities = void 0;
+exports.CUSTOM_FIELDS_FILTER_SCOPE = exports.CustomFieldDefinitionType = exports.supportedEntities = void 0;
 const common_types_1 = require("@autofleet/common-types");
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
 exports.CUSTOM_FIELDS_FILTER_SCOPE = CUSTOM_FIELDS_FILTER_SCOPE;
-// eslint-disable-next-line import/prefer-default-export
 exports.supportedEntities = ['businessModelId', 'fleetId', 'demandSourceId'];
+/**
+ * Supported custom field types
+ */
+var CustomFieldDefinitionType;
+(function (CustomFieldDefinitionType) {
+    CustomFieldDefinitionType["NUMBER"] = "number";
+    CustomFieldDefinitionType["BOOLEAN"] = "boolean";
+    CustomFieldDefinitionType["DATE"] = "date";
+    CustomFieldDefinitionType["DATETIME"] = "datetime";
+    CustomFieldDefinitionType["TEXT"] = "text";
+    CustomFieldDefinitionType["IMAGE"] = "image";
+    CustomFieldDefinitionType["SELECT"] = "select";
+    CustomFieldDefinitionType["STATUS"] = "status";
+    CustomFieldDefinitionType["FILE"] = "file";
+})(CustomFieldDefinitionType || (exports.CustomFieldDefinitionType = CustomFieldDefinitionType = {}));

package/dist/utils/helpers/index.d.ts

@@ -1,6 +1,6 @@
-import { WhereOptions, BindOrReplacements } from 'sequelize';
-import { ModelStatic } from 'sequelize-typescript';
-import { CustomFieldDefinitionType } from '../validations/type';
+import { type WhereOptions, type BindOrReplacements } from 'sequelize';
+import { type ModelStatic } from 'sequelize-typescript';
+import { CustomFieldDefinitionType } from '../constants';
 /**
  * Builds a WHERE clause and replacements for free-text search by custom fields.
  *
@@ -21,5 +21,6 @@ interface CustomFieldsSearchPayload {
     where: WhereOptions;
     replacements: BindOrReplacements;
 }
+export declare const generateRandomString: (length?: number) => string;
 export declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;
 export {};

package/dist/utils/helpers/index.js

@@ -1,13 +1,18 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateCustomFieldSearchQueryPayload = void 0;
+exports.generateCustomFieldSearchQueryPayload = exports.generateRandomString = void 0;
 /* eslint-disable import/prefer-default-export */
 const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
-const type_1 = require("../validations/type");
+const constants_1 = require("../constants");
+const generateRandomString = (length = 5) => {
+    const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+};
+exports.generateRandomString = generateRandomString;
 const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
-    type_1.CustomFieldDefinitionType.DATETIME,
-    type_1.CustomFieldDefinitionType.DATE,
+    constants_1.CustomFieldDefinitionType.DATETIME,
+    constants_1.CustomFieldDefinitionType.DATE,
 ]) => {
     const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(',');
     const subQuery = 'EXISTS ('

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

@@ -1,2 +1,2 @@
-declare const validateValue: (value: any, valueType: any, customValidations: any) => boolean;
-export default validateValue;
+import type { CustomFieldDefinitionType } from '../constants';
+export declare const validateValue: (value: unknown, valueType: CustomFieldDefinitionType, validation?: unknown) => boolean;

package/dist/utils/validations/index.js

@@ -1,20 +1,20 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const custom_1 = __importDefault(require("./custom"));
-const type_1 = __importDefault(require("./type"));
-const validateValue = (value, valueType, customValidations) => {
-    if (!(0, type_1.default)(value, valueType)) {
+exports.validateValue = void 0;
+const validators_1 = require("./validators");
+const validateValue = (value, valueType, validation) => {
+    const validator = validators_1.validators[valueType];
+    if (!validator) {
+        // Unsupported field type
         return false;
     }
-    if (customValidations) {
-        return (0, custom_1.default)(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;
+     * }
+     */
 };
-exports.default = validateValue;
+exports.validateValue = validateValue;

package/dist/utils/validations/{custom-fields.js → schema/custom-fields.js}

@@ -4,7 +4,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomFieldsSchema = void 0;
-/* eslint-disable import/prefer-default-export */
 const joi_1 = __importDefault(require("joi"));
 const CustomFieldsSchema = joi_1.default.object().pattern(joi_1.default.string(), joi_1.default.any());
 exports.CustomFieldsSchema = CustomFieldsSchema;

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

@@ -1,18 +1,14 @@
+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.
  */
-export declare 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.
  */
-declare const validateValueType: (value: unknown, valueType: CustomFieldDefinitionType) => boolean;
-export default validateValueType;
+export type Validators = {
+    [K in CustomFieldDefinitionType]: Validator<unknown, unknown>;
+};

package/dist/utils/validations/type.js

@@ -1,50 +1,2 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CustomFieldDefinitionType = void 0;
-const joi_1 = __importDefault(require("joi"));
-/**
- * Supported custom field types
- */
-// eslint-disable-next-line no-shadow
-var CustomFieldDefinitionType;
-(function (CustomFieldDefinitionType) {
-    CustomFieldDefinitionType["NUMBER"] = "number";
-    CustomFieldDefinitionType["BOOLEAN"] = "boolean";
-    CustomFieldDefinitionType["DATE"] = "date";
-    CustomFieldDefinitionType["DATETIME"] = "datetime";
-    CustomFieldDefinitionType["TEXT"] = "text";
-    CustomFieldDefinitionType["IMAGE"] = "image";
-    CustomFieldDefinitionType["SELECT"] = "select";
-})(CustomFieldDefinitionType || (exports.CustomFieldDefinitionType = CustomFieldDefinitionType = {}));
-/**
- * Validate that the given value is really of type "valueType"
- * TODO: verify that required field not set to null
- */
-const validateValueType = (value, valueType) => {
-    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_1.default.date().validate(value).error;
-        case CustomFieldDefinitionType.SELECT:
-            return true; // custom validation
-        case CustomFieldDefinitionType.IMAGE:
-            return !joi_1.default.array().min(1).unique().items(joi_1.default.string().uri())
-                .validate(value).error;
-        default:
-            return false;
-    }
-};
-exports.default = validateValueType;

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

@@ -0,0 +1,14 @@
+import { CustomFieldDefinitionType } from '../../constants';
+import type { Validators } from '../type';
+/**
+ * Custom field types that must have custom validation.
+ * TODO: remove this after moving to schema-based validation
+ */
+export declare const CustomValidationTypes: {
+    readonly select: CustomFieldDefinitionType.SELECT;
+    readonly status: CustomFieldDefinitionType.STATUS;
+};
+/**
+ * Validators for custom fields
+ */
+export declare const validators: Validators;

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

@@ -0,0 +1,40 @@
+"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),
+    [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),
+};

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.7-beta.1",
+  "version": "0.6.8-beta.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -9,7 +9,7 @@
     "linter": "./node_modules/.bin/eslint .",
     "test": "jest --forceExit --runInBand",
     "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
-    "build-to-local-repo": "npm run build && cp -r dist/* ../task-ms/node_modules/@autofleet/sadot/dist",
+    "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",
     "publish-dev": "npm run build && npm publish --tag dev"
@@ -36,6 +36,7 @@
     "@autofleet/logger": "^2.0.5",
     "express": "^4.18.2",
     "joi": "^17.7.0",
+    "moment": "^2.30.1",
     "pg": "^8.10.0",
     "reflect-metadata": "^0.1.13",
     "sequelize": "^6.31.1",
@@ -52,8 +53,8 @@
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
     "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
     "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"

package/src/scopes/filter.ts

@@ -2,6 +2,8 @@
 import { Op, type WhereOptions } from 'sequelize';
 import { Sequelize } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
+import moment from 'moment';
+import { generateRandomString } from '../utils/helpers';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
 
@@ -22,51 +24,68 @@ export type CustomFieldSort = {
 }
 
 export type CustomFieldFilterOptions = {
-  where?: WhereOptions;
+    where?: WhereOptions;
+    replacements?: Record<string, string>;
 }
 
 const castIfNeeded = (conditionValue: string): string => {
-  if (!Number.isNaN(Date.parse(conditionValue))) {
+  if (moment.isDate(conditionValue)) {
     return '::timestamp';
+  } if (!Number.isNaN(Number(conditionValue))) {
+    return '::numeric';
   }
   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.
- *
- * @param {string} name - The model type name used to join custom_field_definitions.
- * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
- */
+
 export const customFieldsFilterScope = (
   name: string,
 ) => (conditions: Record<string, ConditionValue>): CustomFieldFilterOptions => {
   if (!conditions || Object.keys(conditions).length === 0) {
     return {};
   }
+  const randomStr = generateRandomString();
+  const replacementMapPrefix = `customFieldsFilterScopeConditionMap_${randomStr}`;
+  const replacements: Record<string, string> = {};
+  replacements[`customFieldsFilterScopeConditionName_${randomStr}`] = `${name}`;
+
   // Build the WHERE clause for custom field filtering
   const conditionsStrings = Object.entries(conditions)
     .map(
-      ([key, condition]) => {
+      ([key, condition], index) => {
+        const replacemetKey = `${replacementMapPrefix}Key${index}`;
+        replacements[replacemetKey] = `${key}`;
         if (Array.isArray(condition)) {
           if (condition.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})`;
+            const values = condition.map((v) => {
+              const valRandom = generateRandomString();
+              replacements[`${valRandom}`] = `${v}`;
+              return ` :${valRandom} `;
+            }).join(',');
+            return `(custom_fields->> :${replacemetKey} ) IN ( ${values} )`;
           }
           return condition
-            .map((c) => `(custom_fields->>'${key}')${castIfNeeded(c.value)} ${c.operator} '${c.value}'`).join(AND_DELIMETER);
+            .map((c, cIndex) => {
+              const valRep = `${replacementMapPrefix}Values${index}${cIndex}`;
+              replacements[valRep] = `${c.value}`;
+              return `(custom_fields->> :${replacemetKey} )${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
+            }).join(AND_DELIMETER);
         }
         if (typeof condition === 'string') {
-          return `(custom_fields->>'${key}')${castIfNeeded(condition)} = '${condition}'`;
+          const conditionRep = `${replacementMapPrefix}Condition${index}`;
+          replacements[conditionRep] = `${condition}`;
+          return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition)} = :${conditionRep}`;
         }
         if (condition?.operator) {
-          return `(custom_fields->>'${key}')${castIfNeeded(condition.value)} ${condition.operator} '${condition.value}'`;
+          const valueRep = `${replacementMapPrefix}Values${index}`;
+          replacements[valueRep] = `${condition.value}`;
+          return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
         }
+
         return false;
       },
     )
@@ -75,21 +94,20 @@ export const customFieldsFilterScope = (
     return {};
   }
   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 '
     + '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}' `
+    + `AND cd.model_type = :${`customFieldsFilterScopeConditionName_${randomStr}`} `
     + 'GROUP BY cv.model_id'
-    + ') AS CustomFieldAggregation WHERE '}${customFieldConditions}`;
-
+    + ') AS CustomFieldAggregation WHERE '} ${customFieldConditions}`;
   return {
     where: {
       id: {
         [Op.in]: Sequelize.literal(`(${subQuery})`),
       },
     },
+    replacements,
   };
 };
 
@@ -101,8 +119,13 @@ export const customFieldsSortScope = (
   if (!sort || sort.length === 0) {
     return {};
   }
-  const includes = Object.entries(sort).map(([key]) =>
-    ([
+  const randomStr = generateRandomString();
+  const replacements: Record<string, string> = {};
+  const includes = Object.entries(sort).map(([key], index) => {
+    const keyReplacement = `key_${randomStr}_${index}`;
+    replacements[`keyCustomFields_${randomStr}_${index}`] = `customFields_${key}`;
+    replacements[keyReplacement] = `${key}`;
+    return ([
       Sequelize.literal(`(
             SELECT value
             FROM (SELECT cv.model_id, cv.value
@@ -110,18 +133,19 @@ export const customFieldsSortScope = (
                     ON cv.custom_field_definition_id = cd.id
                     AND cd.model_type = '${name}'
                     WHERE cv.model_id = "${name}"."id"
-                          AND cd.name = '${key}'
+                          AND cd.name = :${keyReplacement}
                           ) AS CustomFieldAggregation
             )
-          `),
-      `customFields_${key}`,
-    ]));
+          `), randomStr,
+    ]);
+  });
 
-  const orders = Object.entries(sort).map(([key, value]) => Sequelize.literal(`"customFields_${key}" ${value}`));
+  const orders = Object.entries(sort).map(([, value]) => Sequelize.literal(`"${randomStr}" ${value}`));
   return {
     attributes: {
       include: includes,
     },
     order: orders,
+    replacements,
   };
 };

package/src/tests/helpers/database-config.ts

@@ -10,6 +10,6 @@ export default {
       underscored: true,
       underscoredAll: true,
     },
-    logging: false,
+    logging: console.log,
   },
 };

package/src/utils/constants/index.ts

@@ -16,6 +16,7 @@ export enum CustomFieldDefinitionType {
   IMAGE = 'image',
   SELECT = 'select',
   STATUS = 'status',
+  FILE = 'file',
 }
 
 export {

package/src/utils/helpers/index.ts

@@ -25,6 +25,11 @@ interface CustomFieldsSearchPayload {
   replacements: BindOrReplacements;
 }
 
+export const generateRandomString = (length = 5): string => {
+  const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+  return Array.from({ length }, () => characters.charAt(Math.floor(Math.random() * characters.length))).join('');
+};
+
 export const generateCustomFieldSearchQueryPayload = (
   searchTerm: string,
   model: ModelStatic,

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

@@ -28,4 +28,11 @@ export const validators: Validators = {
   [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({
+    name: Joi.string().required(),
+    type: Joi.string(),
+    size: Joi.string(),
+    addedBy: Joi.string().uuid(),
+  }))
+    .validate(value).error),
 };

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