@autofleet/sadot 0.6.2-temp-file-6 → 0.6.3-beta.1

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

@@ -5,30 +5,17 @@ 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 constants_1 = require("../../../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 type_1 = require("../../../utils/validations/type");
 const ValidationSchema = joi_1.default.when('fieldType', {
-    is: constants_1.CustomFieldDefinitionType.SELECT,
+    is: type_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: joi_1.default.string().min(1).required(),
-    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(constants_1.CustomFieldDefinitionType)).required(),
+    fieldType: joi_1.default.string().valid(...Object.values(type_1.CustomFieldDefinitionType)).required(),
     entityId: joi_1.default.string().guid().required(),
     entityType: joi_1.default.string().required(),
     description: joi_1.default.string(),
@@ -38,7 +25,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(constants_1.CustomFieldDefinitionType)),
+    fieldType: joi_1.default.string().valid(...Object.values(type_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 type { ModelOptions } from '../types';
+import { 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 type { ModelOptions } from '../types';
+import { 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 type { ModelOptions } from '../types';
+import { ModelOptions } from '../types';
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
  */

package/dist/index.d.ts

@@ -1,9 +1,10 @@
 import type { Application } from 'express';
-import type { Sequelize } from 'sequelize-typescript';
+import { Sequelize } from 'sequelize-typescript';
 import type { CustomFieldOptions, ModelFetcher } from './types';
-export * from './utils/validations/schema/custom-fields';
+export * from './utils/validations/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,15 +17,17 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.disableCustomFields = void 0;
+exports.disableCustomFields = exports.CustomFieldDefinitionType = 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/schema/custom-fields"), exports);
+__exportStar(require("./utils/validations/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/constants';
+import { CustomFieldDefinitionType } from '../utils/validations/type';
 import { CustomFieldValue } from '.';
 declare class CustomFieldDefinition extends Model {
     id: string;

package/dist/models/CustomFieldDefinition.js

@@ -8,17 +8,15 @@ 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 constants_1 = require("../utils/constants");
-const validators_1 = require("../utils/validations/validators");
+const custom_1 = require("../utils/validations/custom");
+const type_1 = require("../utils/validations/type");
 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) {
@@ -59,7 +57,7 @@ __decorate([
 ], CustomFieldDefinition.prototype, "displayName", void 0);
 __decorate([
     (0, sequelize_typescript_1.Is)('SupportedType', (value) => {
-        if (!Object.values(constants_1.CustomFieldDefinitionType).includes(value)) {
+        if (!Object.values(type_1.CustomFieldDefinitionType).includes(value)) {
             throw new errors_1.UnsupportedCustomFieldTypeError(`"${value}" is not a supported type.`);
         }
     }),
@@ -157,10 +155,7 @@ CustomFieldDefinition = __decorate([
         timestamps: true,
         validate: {
             validationByType() {
-                // 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`);
+                if (!(0, custom_1.validateValidation)(this.fieldType, this.validation)) {
                     throw new errors_1.UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
                 }
             },

package/dist/models/CustomFieldValue.js

@@ -31,11 +31,16 @@ 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 = require("../utils/validations");
+const validations_1 = __importDefault(require("../utils/validations"));
 const CustomFieldDefinitionRepo = __importStar(require("../repository/definition"));
 const errors_1 = require("../errors");
 let CustomFieldValue = class CustomFieldValue extends sequelize_typescript_1.Model {
@@ -49,7 +54,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.validateValue)(instance.value, fieldType, validation);
+            const isValid = (0, validations_1.default)(instance.value, fieldType, validation);
             if (!isValid) {
                 throw new errors_1.InvalidValueError(instance.value, fieldType);
             }
@@ -60,7 +65,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.validateValue)(instance.value, fieldType, validation);
+        const isValid = (0, validations_1.default)(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 { type FindOptions, type WhereOptions } from 'sequelize';
+import { FindOptions, WhereOptions } from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
-import type { ModelOptions } from '../types';
+import { 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 type { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
-import type { ModelOptions } from '../types';
+import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+import { 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,4 +1,4 @@
-import { type WhereOptions } from 'sequelize';
+import { WhereOptions } from 'sequelize';
 /**
  * Type representing possible condition values.
  * Currently supporting strings and arrays of strings.
@@ -21,3 +21,12 @@ export type CustomFieldFilterOptions = {
  */
 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;
+} | {
+    attributes: {
+        include: import("sequelize/types/utils").Literal[];
+    };
+    order: import("sequelize/types/utils").Literal[];
+};

package/dist/scopes/filter.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.scopeName = exports.customFieldsFilterScope = void 0;
+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");
@@ -53,3 +53,23 @@ const customFieldsFilterScope = (name) => (conditions) => {
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
 exports.scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
+const customFieldsSortScope = (name) => (sort) => {
+    if (!sort || sort.length === 0) {
+        return {};
+    }
+    const incluedes = Object.entries(sort).map(([key]) => sequelize_typescript_1.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_typescript_1.Sequelize.literal(`"customFields.${key}" ${value}`));
+    return {
+        attributes: {
+            include: incluedes,
+        },
+        order: orders,
+    };
+};
+exports.customFieldsSortScope = customFieldsSortScope;

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

@@ -1,4 +1,4 @@
-import type { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+import { 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 selectField: (modelType: string, options: any) => CreateCustomFieldDefinition;
-export declare const statusField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const enumField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const rangeField: (modelType: string) => 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.statusField = exports.selectField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
+exports.createDefinitions = exports.createDefinition = exports.rangeField = exports.enumField = 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 selectField = (modelType, options) => ({
+const enumField = (modelType, options) => ({
     name: 'choices',
     modelType,
     fieldType: 'select',
@@ -39,16 +39,18 @@ const selectField = (modelType, options) => ({
     entityId: (0, uuid_1.v4)(),
     entityType: 'fleetId',
 });
-exports.selectField = selectField;
-const statusField = (modelType, options) => ({
-    name: 'lifecycle',
+exports.enumField = enumField;
+const rangeField = (modelType) => ({
+    name: 'ranges',
     modelType,
-    fieldType: 'status',
-    validation: options,
+    fieldType: 'number',
+    validation: {
+        between: [10, 12],
+    },
     entityId: (0, uuid_1.v4)(),
     entityType: 'fleetId',
 });
-exports.statusField = statusField;
+exports.rangeField = rangeField;
 // 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 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;
 export type ModelOptions = {
     /**

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

@@ -1,19 +1,5 @@
 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,22 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.CUSTOM_FIELDS_FILTER_SCOPE = exports.CustomFieldDefinitionType = exports.supportedEntities = void 0;
+exports.CUSTOM_FIELDS_FILTER_SCOPE = 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 { type WhereOptions, type BindOrReplacements } from 'sequelize';
-import { type ModelStatic } from 'sequelize-typescript';
-import { CustomFieldDefinitionType } from '../constants';
+import { WhereOptions, BindOrReplacements } from 'sequelize';
+import { ModelStatic } from 'sequelize-typescript';
+import { CustomFieldDefinitionType } from '../validations/type';
 /**
  * Builds a WHERE clause and replacements for free-text search by custom fields.
  *

package/dist/utils/helpers/index.js

@@ -4,10 +4,10 @@ exports.generateCustomFieldSearchQueryPayload = void 0;
 /* eslint-disable import/prefer-default-export */
 const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
-const constants_1 = require("../constants");
+const type_1 = require("../validations/type");
 const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
-    constants_1.CustomFieldDefinitionType.DATETIME,
-    constants_1.CustomFieldDefinitionType.DATE,
+    type_1.CustomFieldDefinitionType.DATETIME,
+    type_1.CustomFieldDefinitionType.DATE,
 ]) => {
     const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(',');
     const subQuery = 'EXISTS ('

package/dist/utils/init.js

@@ -6,10 +6,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.applyCustomAssociation = exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
 const sequelize_1 = require("sequelize");
 const common_types_1 = require("@autofleet/common-types");
+const custom_fields_1 = require("@autofleet/common-types/lib/custom-fields");
 const models_1 = require("../models");
 const hooks_1 = require("../hooks");
 const scopes_1 = require("../scopes");
 const logger_1 = __importDefault(require("./logger"));
+const filter_1 = require("../scopes/filter");
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
 const addHooks = (models, getModel) => {
     models.forEach(async ({ name, scopeAttributes, modelOptions, }) => {
@@ -91,6 +93,7 @@ const addScopes = (models, getModel) => {
             addAssociations(model, name);
             // Add filter scope
             model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, (0, scopes_1.customFieldsFilterScope)(name));
+            model.addScope(custom_fields_1.CUSTOM_FIELDS_SORT_SCOPE, (0, filter_1.customFieldsSortScope)(name));
         }
         catch (e) {
             logger_1.default.error(`Could not add custom fields scopes to model ${name}. `, e);

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

@@ -4,6 +4,7 @@ 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/custom.d.ts

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,42 @@
+"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/index.d.ts

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

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 });
-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
+const custom_1 = __importDefault(require("./custom"));
+const type_1 = __importDefault(require("./type"));
+const validateValue = (value, valueType, customValidations) => {
+    if (!(0, type_1.default)(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 (0, custom_1.default)(value, valueType, customValidations);
+    }
+    // if (validations.required && !value) {
+    //   return false;
+    // }
+    return true;
 };
-exports.validateValue = validateValue;
+exports.default = validateValue;

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

@@ -1,14 +1,18 @@
-import type { CustomFieldDefinitionType } from '../constants';
 /**
- * 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.
+ * Supported custom field types
  */
-export type Validator<Value, DefinitionValidationObject> = (value: Value, validation?: DefinitionValidationObject) => boolean;
+export declare enum CustomFieldDefinitionType {
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    DATE = "date",
+    DATETIME = "datetime",
+    TEXT = "text",
+    IMAGE = "image",
+    SELECT = "select"
+}
 /**
- * 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.
+ * Validate that the given value is really of type "valueType"
+ * TODO: verify that required field not set to null
  */
-export type Validators = {
-    [K in CustomFieldDefinitionType]: Validator<unknown, unknown>;
-};
+declare const validateValueType: (value: unknown, valueType: CustomFieldDefinitionType) => boolean;
+export default validateValueType;

package/dist/utils/validations/type.js

@@ -1,2 +1,50 @@
 "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 || (exports.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.d.ts

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