@autofleet/sadot 0.6.4-beta.1 → 0.6.5

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,10 +1,14 @@
-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';
@@ -26,7 +30,8 @@ export declare const customFieldsSortScope: (name: string) => (sort: CustomField
     order?: undefined;
 } | {
     attributes: {
-        include: (string | import("sequelize/types/utils").Literal)[][];
+        include: import("sequelize/types/utils").Literal[];
     };
     order: import("sequelize/types/utils").Literal[];
 };
+export {};

package/dist/scopes/filter.js

@@ -6,6 +6,13 @@ const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const common_types_1 = require("@autofleet/common-types");
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
+const castIfNeeded = (conditionValue) => {
+    if (!Number.isNaN(Date.parse(conditionValue))) {
+        return '::timestamp';
+    }
+    return '';
+};
+const AND_DELIMETER = ' AND ';
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -19,30 +26,39 @@ const customFieldsFilterScope = (name) => (conditions) => {
     }
     // 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]) => {
+        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) => `'${v}'`).join(',');
+                return `(custom_fields->>'${key}') IN (${values})`;
+            }
+            return condition
+                .map((c) => `(custom_fields->>'${key}')${castIfNeeded(c.value)} ${c.operator} '${c.value}'`).join(AND_DELIMETER);
+        }
+        if (typeof condition === 'string') {
+            return `(custom_fields->>'${key}')${castIfNeeded(condition)} = '${condition}'`;
+        }
+        if (condition?.operator) {
+            return `(custom_fields->>'${key}')${castIfNeeded(condition.value)} ${condition.operator} '${condition.value}'`;
         }
-        return `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}' `
         + 'GROUP BY cv.model_id'
-        + ') AS CustomFieldAggregation '
-        + 'WHERE '}${customFieldConditions}`;
+        + ') AS CustomFieldAggregation WHERE '}${customFieldConditions}`;
     return {
         where: {
             id: {
@@ -57,24 +73,17 @@ const customFieldsSortScope = (name) => (sort) => {
     if (!sort || sort.length === 0) {
         return {};
     }
-    const includes = Object.entries(sort).map(([key]) => ([
-        sequelize_typescript_1.Sequelize.literal(`(
-        SELECT 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 = '${name}'
-          WHERE cv.model_id = "${name}"."id"
-          GROUP BY cv.model_id
-        ) AS CustomFieldAggregation
-      )`),
-        `customFields_${key}`,
-    ]));
-    const orders = Object.entries(sort).map(([key, value]) => sequelize_typescript_1.Sequelize.literal(`"customFields_${key}" ${value}`));
+    console.log('sort', sort);
+    console.log('name', name);
+    console.log('Object.entries(sort)', Object.entries(sort));
+    const includes = 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 = '${name}'
+                                         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: includes,

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,18 @@
 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"
+}
 export { 
 /** @deprecated Use the value from `@autofleet/common-types` instead */
 CUSTOM_FIELDS_FILTER_SCOPE, };

package/dist/utils/constants/index.js

@@ -1,8 +1,21 @@
 "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 || (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.
  *

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 type_1 = require("../validations/type");
+const constants_1 = require("../constants");
 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 || (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/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;