@autofleet/sadot 0.6.2 → 0.6.3-beta.1

package/dist/scopes/filter.js

@@ -1,10 +1,11 @@
 "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");
-const constants_1 = require("../utils/constants");
+const common_types_1 = require("@autofleet/common-types");
+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.
@@ -13,16 +14,27 @@ const constants_1 = require("../utils/constants");
  * @returns {Function} - A function that takes conditions and returns the Sequelize options object.
  */
 const customFieldsFilterScope = (name) => (conditions) => {
+    if (!conditions || Object.keys(conditions).length === 0) {
+        return {};
+    }
     // Build the WHERE clause for custom field filtering
-    const customFieldConditions = Object.entries(conditions)
+    const conditionsStrings = Object.entries(conditions)
         .map(([key, value]) => {
         if (Array.isArray(value)) {
+            if (value.length === 0) {
+                // if empty array, the condition is ignored
+                return false;
+            }
             const values = value.map((v) => `'${v}'`).join(',');
             return `custom_fields->>'${key}' IN (${values})`;
         }
         return `custom_fields->>'${key}' = '${value}'`;
     })
-        .join(' AND ');
+        .filter(Boolean);
+    if (conditionsStrings.length === 0) {
+        return {};
+    }
+    const customFieldConditions = conditionsStrings.join(' AND ');
     const subQuery = `${'SELECT model_id FROM ('
         + 'SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields '
         + 'FROM custom_field_values AS cv '
@@ -40,4 +52,24 @@ const customFieldsFilterScope = (name) => (conditions) => {
     };
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
-exports.scopeName = constants_1.CUSTOM_FIELDS_FILTER_SCOPE;
+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/functional/searching/index.d.ts

@@ -0,0 +1,8 @@
+interface CustomFieldsSearchTestFlowInput {
+    fieldType: string;
+    fieldValue: string | number;
+    searchTerm: string;
+    expectedNumberOfQueryResults: number;
+}
+declare const customFieldsSearchTestFlow: ({ fieldType, fieldValue, searchTerm, expectedNumberOfQueryResults, }: CustomFieldsSearchTestFlowInput) => Promise<void>;
+export default customFieldsSearchTestFlow;

package/dist/tests/functional/searching/index.js

@@ -0,0 +1,44 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_1 = require("../../../index");
+const DefinitionRepo = __importStar(require("../../../repository/definition"));
+const definition_mock_1 = require("../../mocks/definition.mock");
+const testModel_1 = require("../../mocks/testModel");
+const models_1 = require("../../../models");
+const customFieldsSearchTestFlow = async ({ fieldType, fieldValue, searchTerm, expectedNumberOfQueryResults, }) => {
+    const definition = (0, definition_mock_1.createDefinition)({ fieldType, name: 'coolDefinition' });
+    await DefinitionRepo.create({ ...definition });
+    const [testModel1] = await (0, testModel_1.createTestModels)(definition.entityId, 2);
+    await testModel1.update({ customFields: { [definition.name]: fieldValue } });
+    const models = await models_1.TestModel.findAndCountAll({
+        ...(0, index_1.generateCustomFieldSearchQueryPayload)(searchTerm, models_1.TestModel, definition.entityId),
+    });
+    expect(models.count).toBe(expectedNumberOfQueryResults);
+    if (expectedNumberOfQueryResults > 0) {
+        expect(models.rows[0].dataValues.id).toBe(testModel1.id);
+    }
+};
+exports.default = customFieldsSearchTestFlow;

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

@@ -4,6 +4,7 @@ declare const _default: {
         password: string;
         database: string;
         host: string;
+        port: string | number;
         dialect: string;
         define: {
             underscored: boolean;

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

@@ -6,6 +6,7 @@ exports.default = {
         password: process.env.DB_PASSWORD || null,
         database: process.env.DB_NAME || 'sadot_package_test',
         host: process.env.DB_HOST || '127.0.0.1',
+        port: process.env.DB_PORT || 5432,
         dialect: process.env.DB_TYPE || 'postgres',
         define: {
             underscored: true,

package/dist/tests/helpers/index.js

@@ -7,6 +7,8 @@ const cleanup = async () => {
     if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
         await models_1.CustomFieldDefinition.unscoped().destroy({ where: {} });
         await models_1.TestModel.destroy({ where: {} });
+        await models_1.ContextAwareTestModel.destroy({ where: {} });
+        await models_1.ContextTestModel.destroy({ where: {} });
     }
 };
 exports.cleanup = cleanup;

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

@@ -1,4 +1,10 @@
 import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+export declare const contextAwareFieldDefinition: {
+    name: string;
+    modelType: string;
+    fieldType: string;
+    entityType: string;
+};
 export declare const coolFieldDefinition: CreateCustomFieldDefinition;
 export declare const coolFieldDefinition2: {
     name: string;

package/dist/tests/mocks/definition.mock.js

@@ -1,7 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDefinitions = exports.createDefinition = exports.rangeField = exports.enumField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = 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',
+    modelType: 'ContextAwareTestModel',
+    fieldType: 'number',
+    entityType: 'fleetId',
+};
 exports.coolFieldDefinition = {
     name: 'cool field',
     modelType: 'TestModel',

package/dist/tests/mocks/testModel.d.ts

@@ -3,7 +3,7 @@ export declare const createTestModel: (payload?: {}) => Promise<TestModel>;
 export declare const createTestModels: (fleetId: any, total: number) => Promise<TestModel[]>;
 export declare const upsertTestModel: (payload: any) => Promise<[TestModel, boolean]>;
 export declare const destroyTestModels: () => Promise<number>;
-export declare const getTestModel: (id: string, options?: {}) => Promise<TestModel>;
+export declare const getTestModel: (id: string, options?: {}) => Promise<TestModel | null>;
 export declare const getSomeTestModels: (options?: {
     limit: number;
 }) => Promise<TestModel[]>;

package/dist/types/index.d.ts

@@ -1,13 +1,31 @@
+import { IncludeOptions } from 'sequelize';
+import { ModelCtor } from 'sequelize-typescript';
 export type ModelFetcher = (name: string) => any;
 export type ModelOptions = {
+    /**
+     * Include options for the model
+     */
+    include?: (entityIds: string[]) => IncludeOptions[];
+    /**
+      * Custom association for the model
+      * @param model - The model to associate with
+     */
+    customAssociation?: (model: ModelCtor) => void;
+    /**
+     * Whether to use the entity id  from the instance per scope attribute
+     */
+    useEntityIdFromInclude?: boolean;
+};
+export type Models = {
     name: string;
-    scopeAttributes: string[];
+    scopeAttributes: any[];
+    modelOptions?: ModelOptions;
     creationWebhookHandler?: (instance: any) => any;
     updateWebhookHandler?: (instance: any) => any;
     deletionWebhookHandler?: (instance: any) => any;
 };
 export type CustomFieldOptions = {
-    models: ModelOptions[];
+    models: Models[];
     databaseConfig: any;
     getUser: () => any;
 };

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

@@ -1,2 +1,5 @@
+declare const CUSTOM_FIELDS_FILTER_SCOPE: string;
 export declare const supportedEntities: string[];
-export declare const CUSTOM_FIELDS_FILTER_SCOPE = "filterByCustomFields";
+export { 
+/** @deprecated Use the value from `@autofleet/common-types` instead */
+CUSTOM_FIELDS_FILTER_SCOPE, };

package/dist/utils/constants/index.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 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'];
-exports.CUSTOM_FIELDS_FILTER_SCOPE = 'filterByCustomFields';

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

@@ -0,0 +1,25 @@
+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.
+ *
+ * This function constructs a WHERE clause and replacement bindings that allow searching
+ * for a given term within custom fields associated with a specific model type and entity ID.
+ * The WHERE clause and replacements are designed to be added to the main query.
+ *
+ * @param {string} searchTerm - The term to search for within custom fields.
+ * @param {ModelStatic} model - The Sequelize model representing the entity type to search for.
+ * @param {string} entityId - The entity ID to filter the custom fields by.
+ * @param {CustomFieldDefinitionType[]} excludedCustomFieldsTypes - An array of custom field types
+ * to exclude from the search
+ *
+ * @returns {CustomFieldsSearchPayload} - An object containing the WHERE clause and replacements
+ * for Sequelize.
+ */
+interface CustomFieldsSearchPayload {
+    where: WhereOptions;
+    replacements: BindOrReplacements;
+}
+export declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;
+export {};

package/dist/utils/helpers/index.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
+    type_1.CustomFieldDefinitionType.DATETIME,
+    type_1.CustomFieldDefinitionType.DATE,
+]) => {
+    const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(',');
+    const subQuery = 'EXISTS ('
+        + ' SELECT 1'
+        + ' FROM "custom_field_values" AS "cv"'
+        + ' INNER JOIN custom_field_definitions AS cd '
+        + ` ON cd.entity_id = '${entityId}'`
+        + ' AND cv.custom_field_definition_id = cd.id'
+        + ` AND cd.model_type = '${model.name}'`
+        + ` ${excludedTypesString ? `AND cd.field_type NOT IN (${excludedTypesString})` : ''}`
+        + ' WHERE'
+        + ' "cv"."deleted_at" IS NULL'
+        + ` AND "cv"."model_id" = "${model.name}"."id"`
+        + ' AND CAST("cv"."value" AS TEXT) ILIKE :searchTerm)';
+    return {
+        where: {
+            [sequelize_1.Op.or]: [
+                sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.literal(subQuery), true),
+            ],
+        },
+        replacements: { searchTerm: `%${searchTerm}%` },
+    };
+};
+exports.generateCustomFieldSearchQueryPayload = generateCustomFieldSearchQueryPayload;

package/dist/utils/init.d.ts

@@ -1,4 +1,5 @@
-import type { ModelFetcher, ModelOptions } from '../types';
-export declare const addHooks: (models: ModelOptions[], getModel: ModelFetcher) => void;
-export declare const removeHooks: (models: ModelOptions[], getModel: ModelFetcher) => void;
-export declare const addScopes: (models: ModelOptions[], getModel: ModelFetcher) => void;
+import type { ModelFetcher, Models } from '../types';
+export declare const addHooks: (models: Models[], getModel: ModelFetcher) => void;
+export declare const removeHooks: (models: Models[], getModel: ModelFetcher) => void;
+export declare const addScopes: (models: Models[], getModel: ModelFetcher) => void;
+export declare const applyCustomAssociation: (models: Models[]) => void;

package/dist/utils/init.js

@@ -3,15 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
+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 constants_1 = require("./constants");
+const filter_1 = require("../scopes/filter");
+const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
 const addHooks = (models, getModel) => {
-    models.forEach(async ({ name, scopeAttributes }) => {
+    models.forEach(async ({ name, scopeAttributes, modelOptions, }) => {
         try {
             const model = getModel(name);
             if (!model) {
@@ -30,11 +33,11 @@ const addHooks = (models, getModel) => {
             model.addHook('beforeFind', 'sadot-beforeFind', (0, hooks_1.beforeFind)(scopeAttributes));
             model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', hooks_1.beforeBulkCreate);
             model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', hooks_1.beforeBulkUpdate);
-            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes));
-            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes));
-            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes));
-            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes));
-            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes));
+            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes, modelOptions));
+            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes, modelOptions));
+            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes, 'afterFind', modelOptions));
+            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
+            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
         }
         catch (e) {
             logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
@@ -89,7 +92,8 @@ const addScopes = (models, getModel) => {
             // Necessary associations for the filtering scope
             addAssociations(model, name);
             // Add filter scope
-            model.addScope(constants_1.CUSTOM_FIELDS_FILTER_SCOPE, (0, scopes_1.customFieldsFilterScope)(name));
+            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);
@@ -97,3 +101,9 @@ const addScopes = (models, getModel) => {
     });
 };
 exports.addScopes = addScopes;
+const applyCustomAssociation = (models) => {
+    models.forEach(({ modelOptions }) => {
+        modelOptions?.customAssociation?.(models_1.CustomFieldDefinition);
+    });
+};
+exports.applyCustomAssociation = applyCustomAssociation;

package/dist/utils/scopeAttributes.d.ts

@@ -0,0 +1,2 @@
+declare const applyScopeToInstance: (instance: any, scopeAttributes: string[]) => any[];
+export default applyScopeToInstance;

package/dist/utils/scopeAttributes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapAttributeToInstance = (scopeAttributes, instance) => scopeAttributes.map((attr) => instance[attr]);
+const applyScopeToInstance = (instance, scopeAttributes) => {
+    const uniqueAttributes = Array.from(new Set(scopeAttributes));
+    if (Array.isArray(instance)) {
+        return instance.flatMap((ins) => mapAttributeToInstance(uniqueAttributes, ins));
+    }
+    return mapAttributeToInstance(uniqueAttributes, instance);
+};
+exports.default = applyScopeToInstance;

package/dist/utils/validations/custom-fields.d.ts

@@ -1,2 +1,3 @@
-declare const CustomFieldsSchema: any;
+import Joi from 'joi';
+declare const CustomFieldsSchema: Joi.ObjectSchema<any>;
 export { CustomFieldsSchema };

package/dist/utils/validations/custom-fields.js

@@ -5,6 +5,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("@hapi/joi"));
+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.js

@@ -4,7 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CustomFieldDefinitionType = void 0;
-const joi_1 = __importDefault(require("@hapi/joi"));
+const joi_1 = __importDefault(require("joi"));
 /**
  * Supported custom field types
  */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.6.2",
+  "version": "0.6.3-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/* ../$REPO/node_modules/$npm_package_name/dist",
+    "build-to-local-repo": "npm run build && cp -r dist/* ../task-ms/node_modules/$npm_package_name/dist",
     "dev": "nodemon",
     "watch": "npm-watch build-to-local-repo"
   },
@@ -45,16 +45,16 @@
     "@types/express": "^4.17.17",
     "@types/jest": "^27.0.9",
     "@types/uuid": "^9.0.2",
-    "@typescript-eslint/eslint-plugin": "^6.4.0",
-    "@typescript-eslint/parser": "^6.4.0",
-    "eslint": "^7.32.0",
+    "@typescript-eslint/eslint-plugin": "^4.8.1",
+    "@typescript-eslint/parser": "^4.33.0",
+    "eslint": "^7.13.0",
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
-    "jest": "^29.7.0",
-    "ts-jest": "^29.1.2",
+    "jest": "^27.0.5",
     "npm-watch": "^0.11.0",
+    "ts-jest": "^27.0.3",
     "ts-node": "^8.6.2",
-    "typescript": "^5.3.3",
+    "typescript": "^4.9.5",
     "typescript-eslint": "^0.0.1-alpha.0"
   },
   "author": "Autofleet",

package/src/api/v1/definition/index.ts

@@ -3,7 +3,7 @@ import { Router } from 'express';
 import type { Request, Response } from 'express';
 import handleError from '../errors';
 import * as DefinitionRepo from '../../../repository/definition';
-import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../../../types/definition';
+import { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../../../types/definition';
 import { validateCustomFieldDefinitionCreation, validateCustomFieldDefinitionUpdate } from './validations';
 import logger from '../../../utils/logger';
 

package/src/api/v1/definition/validations.ts

@@ -1,23 +1,10 @@
 import Joi from 'joi';
 import { CustomFieldDefinitionType } from '../../../utils/validations/type';
 
-/**
- * Schema for the validation of custom field definition
- * The only custom validation is for
- * {@link CustomFieldDefinitionType.SELECT SELECT}
- * and
- * {@link CustomFieldDefinitionType.STATUS STATUS}
- * field types.
- * The rest of the field types are validated by Joi
- */
 const ValidationSchema = Joi.when('fieldType', {
   is: CustomFieldDefinitionType.SELECT,
   then: Joi.array().items(Joi.string()).min(1).unique(),
   otherwise: Joi.any(),
-}).when('fieldType', {
-  is: CustomFieldDefinitionType.STATUS,
-  then: Joi.string().min(1).required(),
-  otherwise: Joi.any(),
 });
 
 const CustomFieldDefinitionCreationSchema = Joi.object({

package/src/hooks/create.ts

@@ -2,7 +2,7 @@ import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
 import { MissingRequiredCustomFieldError } from '../errors';
-import type { ModelOptions } from '../types';
+import { ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
 
 /**

package/src/hooks/enrich.ts

@@ -1,10 +1,10 @@
 /* eslint-disable no-param-reassign */
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
-import type CustomFieldValue from '../models/CustomFieldValue';
-import type CustomFieldDefinition from '../models/CustomFieldDefinition';
-import type { SerializedCustomFields } from '../types/definition';
-import type { ModelOptions } from '../types';
+import CustomFieldValue from '../models/CustomFieldValue';
+import CustomFieldDefinition from '../models/CustomFieldDefinition';
+import { SerializedCustomFields } from '../types/definition';
+import { ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
 
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';

package/src/hooks/update.ts

@@ -1,6 +1,6 @@
 import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
-import type { ModelOptions } from '../types';
+import { ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
 
 /**

package/src/index.ts

@@ -1,5 +1,5 @@
 import type { Application } from 'express';
-import type { Sequelize } from 'sequelize-typescript';
+import { Sequelize } from 'sequelize-typescript';
 import {
   initTables, initTestModels,
 } from './models';
@@ -11,7 +11,7 @@ import {
   addHooks, addScopes, applyCustomAssociation, removeHooks,
 } from './utils/init';
 
-export * from './utils/validations/schema/custom-fields';
+export * from './utils/validations/custom-fields';
 
 export * from './utils/constants';
 

package/src/models/CustomFieldDefinition.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -10,13 +12,11 @@ import {
   AfterSave,
   Is,
 } from 'sequelize-typescript';
-
+import { validateValidation } from '../utils/validations/custom';
 import { CustomFieldDefinitionType } from '../utils/validations/type';
-import { CustomValidationTypes } from '../utils/validations/validators';
 import { CustomFieldValue } from '.';
 import { sendDimEvent } from '../events';
 import { UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } from '../errors';
-import logger from '../utils/logger';
 
 @DefaultScope(() => ({ where: { disabled: false } }))
 @Table({
@@ -30,12 +30,8 @@ import logger from '../utils/logger';
   timestamps: true,
   validate: {
     validationByType(this: CustomFieldDefinition) {
-      // Verify the validation is provided if needed
-      if (!this.validation) {
-        if (CustomValidationTypes[this.fieldType]) {
-          logger.error(`No custom validation for custom field type ${this.fieldType} found`);
-          throw new UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
-        }
+      if (!validateValidation(this.fieldType, this.validation)) {
+        throw new UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
       }
     },
   },

package/src/models/CustomFieldValue.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -12,11 +14,13 @@ import {
   BeforeUpdate,
   BeforeBulkCreate,
   BeforeBulkUpdate,
+  Scopes,
 } from 'sequelize-typescript';
 import { sendDimEvent } from '../events';
 import { CustomFieldDefinition } from '.';
-import { validateValue } from '../utils/validations';
+import validateValue from '../utils/validations';
 import * as CustomFieldDefinitionRepo from '../repository/definition';
+import logger from '../utils/logger';
 import { InvalidValueError } from '../errors';
 
 @Table({

package/src/repository/definition.ts

@@ -1,7 +1,10 @@
-import { Op, type FindOptions, type WhereOptions } from 'sequelize';
+import {
+  FindOptions,
+  Op, WhereOptions,
+} from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
-import type { ModelOptions } from '../types';
+import { ModelOptions } from '../types';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);

package/src/repository/value.ts

@@ -2,10 +2,10 @@
 import type { FindOptions, WhereOptions } from 'sequelize';
 import { CustomFieldValue, CustomFieldDefinition } from '../models';
 import * as DefinitionRepo from './definition';
-import type { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
 import logger from '../utils/logger';
 import { MissingDefinitionError } from '../errors';
-import type { ModelOptions } from '../types';
+import { ModelOptions } from '../types';
 
 export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
   CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });