@autofleet/sadot 0.13.0-beta.9 → 0.13.2-beta.0

package/dist/api/v1/validator/index.js

@@ -80,8 +80,9 @@ router.get('/', async (req, res) => {
  */
 router.get('/:validatorId', async (req, res) => {
     try {
-        const { validatorId } = req.params;
-        const validators = await ValidatorRepo.findAll({ id: validatorId });
+        const { validatorId, modelName } = req.params;
+        // Include disabled validators when fetching by ID
+        const validators = await ValidatorRepo.findAll({ id: validatorId, modelType: modelName }, { withDisabled: true });
         if (!validators.length) {
             throw new errors_1.ResourceNotFoundError('Validator not found');
         }
@@ -103,6 +104,11 @@ router.patch('/:validatorId', async (req, res) => {
         if (validatedPayload.schema) {
             (0, validator_schema_1.validateValidatorSchema)(validatedPayload.schema);
         }
+        // First verify the validator exists, including disabled ones
+        const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+        if (!existingValidators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
         const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
         if (!count) {
             throw new errors_1.ResourceNotFoundError('Validator not found');
@@ -119,9 +125,14 @@ router.patch('/:validatorId', async (req, res) => {
 router.delete('/:validatorId', async (req, res) => {
     try {
         const { validatorId } = req.params;
+        // First verify the validator exists, including disabled ones
+        const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+        if (!existingValidators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
         const [count] = await ValidatorRepo.disable(validatorId);
         if (!count) {
-            throw new errors_1.ResourceNotFoundError('Validator not found');
+            throw new errors_1.ResourceNotFoundError('Validator failed to be disabled');
         }
         return res.status(http_status_codes_1.StatusCodes.NO_CONTENT).send();
     }

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

@@ -23,6 +23,7 @@ const validationSchemas = {
     }),
     update: joi_1.default.object({
         entityId: joi_1.default.string().uuid(),
+        entityType: joi_1.default.string(),
         schema: joi_1.default.object({
             type: joi_1.default.string().valid('object'),
             properties: joi_1.default.object({

package/dist/hooks/hooks.js

@@ -36,6 +36,7 @@ const DefinitionRepo = __importStar(require("../repository/definition"));
 const errors_2 = require("../errors");
 const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
 const updateInstanceValues_1 = __importDefault(require("./utils/updateInstanceValues"));
+const constants_1 = require("../utils/constants");
 // Initialize Ajv with relaxed settings to avoid warnings
 const ajv = new ajv_1.default({
     allErrors: true,
@@ -44,6 +45,46 @@ const ajv = new ajv_1.default({
     $data: true, // Enable $data references
 });
 (0, ajv_formats_1.default)(ajv);
+/**
+ * Helper function to manually copy object properties
+ * This is more efficient for large objects and avoids excessive object creation
+ */
+// eslint-disable-next-line prefer-object-spread
+const manualObjectCopy = (sourceObj, additionalProps) => ({ __proto__: null, ...sourceObj, ...additionalProps });
+/**
+ * Fetches complete custom fields for an instance by merging DB values with update values
+ * This is needed for partial updates to ensure all related fields are available for validation
+ */
+const getCompleteCustomFields = async (instance, options) => {
+    // If we don't have an instance id or no custom fields being updated, return original fields
+    if (!instance.id || !instance.customFields || Object.keys(instance.customFields).length === 0) {
+        return instance.customFields || {};
+    }
+    try {
+        const ModelClass = instance.constructor;
+        // Only select the customFields column to minimize data transfer
+        const currentCustomFields = await ModelClass.findOne({
+            where: { id: instance.id },
+            attributes: ['customFields'],
+            transaction: options.transaction,
+            raw: true, // Get plain object instead of model instance for better performance
+        });
+        if (currentCustomFields?.customFields) {
+            // Merge existing fields with update fields using our helper function
+            const completeFields = manualObjectCopy(currentCustomFields.customFields, instance.customFields);
+            logger_1.default.debug('sadot - fetched complete custom fields for validation', {
+                fieldsCount: Object.keys(completeFields).length,
+                updateFieldsCount: Object.keys(instance.customFields).length,
+            });
+            return completeFields;
+        }
+    }
+    catch (error) {
+        logger_1.default.error('sadot - error fetching complete model for validation', { error });
+        // Continue with partial data if we can't fetch the complete model
+    }
+    return instance.customFields || {};
+};
 /**
  * Validates the model using custom validators
  */
@@ -71,21 +112,26 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
         return;
     }
     // For updates, get the previous values
-    const originalValues = isCreate
-        ? null
-        : {
-            ...instance.previous(),
-            customFields: instance.previous('customFields') || {},
-        };
-    // For debugging in case of update
+    let originalValues = null;
     if (!isCreate) {
+        // Create originalValues with our helper function
+        originalValues = manualObjectCopy(instance.previous());
+        // Add customFields separately
+        originalValues.customFields = instance.previous('customFields') || {};
+    }
+    // Get complete custom fields by merging DB values with update values
+    // This is especially important for partial updates to ensure all related fields are available
+    const completeCustomFields = !isCreate
+        ? await getCompleteCustomFields(instance, options)
+        : instance.customFields || {};
+    // For debugging in case of update
+    if (!isCreate && process.env.NODE_ENV !== 'production') {
+        // Create after object for logging
+        const logAfterObj = manualObjectCopy(instance.dataValues, { customFields: completeCustomFields });
         logger_1.default.debug('sadot - validate with values', {
             before: originalValues,
-            after: {
-                ...instance.dataValues,
-                ...instance.customFields,
-            },
-            schema: JSON.stringify(validators[0].schema),
+            after: logAfterObj,
+            schema: validators[0].schema,
         });
     }
     // eslint-disable-next-line no-restricted-syntax
@@ -93,7 +139,7 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
         const { schema } = validator;
         const typedSchema = schema;
         logger_1.default.debug('sadot - validating with schema', {
-            schema: JSON.stringify(schema),
+            schema,
             hasAfterProps: !!typedSchema.properties?.after,
             hasBeforeProps: !!typedSchema.properties?.before,
         });
@@ -107,12 +153,12 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
                         after: typedSchema.properties.after,
                     },
                 });
-                const isValid = validateSchema({
+                const isValid = validateSchema(JSON.parse(JSON.stringify({
                     after: {
                         ...instance.dataValues,
-                        customFields: instance.customFields,
+                        customFields: completeCustomFields,
                     },
-                });
+                })));
                 if (!isValid) {
                     const errorDetails = validateSchema.errors?.map((err) => `${err.instancePath || ''} ${err.message || 'Invalid value'}`).join(', ');
                     throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
@@ -122,40 +168,36 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
         else {
             // For update operations, we need both before and after
             const validateSchema = ajv.compile(typedSchema);
-            const isValid = validateSchema({
+            // Create after object with our helper function
+            const afterObj = manualObjectCopy(instance.dataValues);
+            // Add complete custom fields
+            afterObj.customFields = completeCustomFields;
+            // Create validation payload
+            const payload = {
                 before: originalValues,
-                after: {
-                    ...instance.dataValues,
-                    customFields: instance.customFields,
-                },
-            });
+                after: afterObj,
+            };
+            // Validate
+            const isValid = validateSchema(JSON.parse(JSON.stringify(payload)));
             logger_1.default.info('sadot - validation result', {
                 isValid,
                 test: {
                     before: originalValues,
-                    after: {
-                        ...instance.dataValues,
-                        ...instance.customFields,
-                    },
+                    after: afterObj,
                 },
             });
             if (!isValid) {
-                const errorDetails = validateSchema.errors?.map((err) => `${err.instancePath || ''} ${err.message || 'Invalid value'}`).join(', ');
+                const errorDetails = validateSchema.errors?.map((err) => {
+                    logger_1.default.info('dor', err);
+                    return `${err.instancePath || ''} ${err.message || 'Invalid value'}`;
+                }).join(', ');
                 throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
             }
         }
     }
 };
-/**
- * Hook to handle validation and custom fields during creation
- */
-const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
-    logger_1.default.debug('sadot - before create hook');
-    const { fields } = options;
+const getFieldDefinitions = async ({ modelType, modelOptions, identifiers, options }) => {
     const { include, useEntityIdFromInclude } = modelOptions;
-    const modelType = instance.constructor.name;
-    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
-    // Step 1: Handle custom fields default values and required fields
     const where = {
         modelType,
         disabled: false,
@@ -166,7 +208,32 @@ const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
         transaction: options.transaction,
         include: include?.(identifiers),
     });
-    const requiredFieldsNames = Array.from(new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)));
+    return fieldDefinitions;
+};
+const formatDates = (fieldDefinitions = [], instance) => {
+    fieldDefinitions.forEach((fieldDefinition) => {
+        const { fieldType, name } = fieldDefinition;
+        if ([constants_1.CustomFieldDefinitionType.DATE, constants_1.CustomFieldDefinitionType.DATETIME].includes(fieldType)) {
+            const value = instance.customFields?.[name];
+            if (value) {
+                // eslint-disable-next-line no-param-reassign
+                instance.customFields[name] = new Date(value).toISOString();
+            }
+        }
+    });
+};
+/**
+ * Hook to handle validation and custom fields during creation
+ */
+const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
+    logger_1.default.debug('sadot - before create hook');
+    const { fields } = options;
+    const modelType = instance.constructor.name;
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
+    // Step 1: Handle custom fields default values and required fields
+    const fieldDefinitions = await getFieldDefinitions({
+        modelType, modelOptions, identifiers, options
+    });
     // Apply default values
     const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
     if (fieldsWithDefaultValue.length) {
@@ -180,6 +247,7 @@ const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
         });
     }
     // Check for required fields
+    const requiredFieldsNames = Array.from(new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)));
     const { customFields } = instance;
     const fieldsNames = Object.keys(customFields ?? {});
     const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
@@ -188,6 +256,8 @@ const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
     }
     // Step 2: Validate the model data (including custom fields)
     await validateModel(instance, options, scopeAttributes, true);
+    // format date and datetime fields
+    formatDates(fieldDefinitions, instance);
     // Step 3: Save custom field values if they exist
     const customFieldsIdx = fields.indexOf('customFields');
     if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
@@ -219,8 +289,13 @@ const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
     const { fields } = options;
     const modelType = instance.constructor.name;
     const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
+    const fieldDefinitions = await getFieldDefinitions({
+        modelType, modelOptions, identifiers, options
+    });
     // Step 1: Validate the model data (including custom fields)
     await validateModel(instance, options, scopeAttributes, false);
+    // format date and datetime fields
+    formatDates(fieldDefinitions, instance);
     // Step 2: Update custom field values if they exist
     const customFieldsIdx = fields.indexOf('customFields');
     if (customFieldsIdx > -1) {

package/dist/index.d.ts

@@ -4,9 +4,6 @@ import type { CustomFieldOptions, ModelFetcher, Models } from './types';
 export * from './utils/validations/schema/custom-fields';
 export * from './utils/constants';
 export * from './utils/helpers';
-export * as DefinitionRepo from './repository/definition';
-export * as ValueRepo from './repository/value';
-export * as ValidatorRepo from './repository/validator';
 /**
  * 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

@@ -29,7 +29,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.disableCustomFields = exports.ValidatorRepo = exports.ValueRepo = exports.DefinitionRepo = void 0;
+exports.disableCustomFields = void 0;
 const models_1 = require("./models");
 const api_1 = __importDefault(require("./api"));
 const db_1 = __importDefault(require("./utils/db"));
@@ -38,10 +38,6 @@ const init_1 = require("./utils/init");
 __exportStar(require("./utils/validations/schema/custom-fields"), exports);
 __exportStar(require("./utils/constants"), exports);
 __exportStar(require("./utils/helpers"), exports);
-// Export repositories
-exports.DefinitionRepo = __importStar(require("./repository/definition"));
-exports.ValueRepo = __importStar(require("./repository/value"));
-exports.ValidatorRepo = __importStar(require("./repository/validator"));
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
  * @see {@link 'custom-fields/config'} for configurations

package/dist/models/CustomValidator.js

@@ -90,6 +90,7 @@ __decorate([
     __metadata("design:returntype", void 0)
 ], CustomValidator, "afterSaveHandler", null);
 CustomValidator = __decorate([
+    (0, sequelize_typescript_1.DefaultScope)(() => ({ where: { disabled: false } })),
     (0, sequelize_typescript_1.Table)({
         timestamps: true,
     })

package/dist/models/index.js

@@ -58,6 +58,21 @@ const initTables = async (sequelize, getUser, { schemaPrefix, schemaVersion, use
             },
         };
     });
+    CustomValidator_1.default.addScope('userScope', () => {
+        const user = getUser();
+        if (!user?.permissions) {
+            return {};
+        }
+        return {
+            where: {
+                entityId: [
+                    ...Object.keys(user.permissions.fleets),
+                    ...Object.keys(user.permissions.businessModels),
+                    ...Object.keys(user.permissions.demandSources),
+                ],
+            },
+        };
+    });
     logger_1.default.info('custom-fields: models added');
     const SequelizeMeta = sequelize.define('SequelizeMeta', {
         name: {

package/dist/repository/validator.d.ts

@@ -7,7 +7,7 @@ export interface ValidatorAttributes {
     entityId: string;
     entityType: string;
     modelType: string;
-    schema: Record<string, unknown>;
+    schema: CustomValidator['schema'];
     disabled?: boolean;
     [key: string]: unknown;
 }

package/dist/repository/validator.js

@@ -16,13 +16,23 @@ exports.create = create;
 const findAll = async (where = {}, options = { withDisabled: false }) => {
     logger_1.default.debug('custom-validator - find all validators');
     const { transaction, withDisabled } = options;
-    const fullWhere = withDisabled
-        ? where
-        : { ...where, disabled: false };
-    const validators = await models_1.CustomValidator.findAll({
-        where: fullWhere,
-        transaction,
-    });
+    let validators;
+    if (withDisabled) {
+        // If withDisabled is true, use unscoped to ignore the default scope that filters disabled items
+        // Apply the userScope separately to maintain permission filtering
+        validators = await models_1.CustomValidator.unscoped().scope('userScope').findAll({
+            where,
+            transaction,
+        });
+    }
+    else {
+        // Use defaultScope and userScope to filter both disabled and by permissions
+        // The defaultScope keeps only non-disabled validators
+        validators = await models_1.CustomValidator.scope(['defaultScope', 'userScope']).findAll({
+            where,
+            transaction,
+        });
+    }
     return validators;
 };
 exports.findAll = findAll;

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

@@ -4,7 +4,7 @@ exports.default = {
     test: {
         username: process.env.DB_USERNAME || '',
         password: process.env.DB_PASSWORD || null,
-        database: process.env.DB_NAME || 'sadot_package_test',
+        database: process.env.DB_NAME || 'postgres',
         host: process.env.DB_HOST || '127.0.0.1',
         port: process.env.DB_PORT || 5432,
         dialect: process.env.DB_TYPE || 'postgres',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.13.0-beta.9",
+  "version": "0.13.2-beta.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -8,6 +8,7 @@
     "build": "rm -rf dist && tsc",
     "linter": "eslint .",
     "test": "jest --runInBand",
+    "test-debug": "node --inspect-brk node_modules/.bin/jest --testTimeout=10000000",
     "coverage": "jest --coverage --runInBand",
     "build-to-local-repo": "node --run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
     "dev": "nodemon",

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

@@ -66,8 +66,9 @@ router.get<
  */
 router.get<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
   try {
-    const { validatorId } = req.params;
-    const validators = await ValidatorRepo.findAll({ id: validatorId });
+    const { validatorId, modelName } = req.params;
+    // Include disabled validators when fetching by ID
+    const validators = await ValidatorRepo.findAll({ id: validatorId, modelType: modelName }, { withDisabled: true });
 
     if (!validators.length) {
       throw new ResourceNotFoundError('Validator not found');
@@ -94,6 +95,12 @@ router.patch<{ modelName: string; validatorId: string }, CustomValidator>('/:val
       validateValidatorSchema(validatedPayload.schema);
     }
 
+    // First verify the validator exists, including disabled ones
+    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+    if (!existingValidators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
     const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
 
     if (!count) {
@@ -112,10 +119,17 @@ router.patch<{ modelName: string; validatorId: string }, CustomValidator>('/:val
 router.delete<{ modelName: string; validatorId: string }>('/:validatorId', async (req, res) => {
   try {
     const { validatorId } = req.params;
+
+    // First verify the validator exists, including disabled ones
+    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+    if (!existingValidators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
     const [count] = await ValidatorRepo.disable(validatorId);
 
     if (!count) {
-      throw new ResourceNotFoundError('Validator not found');
+      throw new ResourceNotFoundError('Validator failed to be disabled');
     }
 
     return res.status(StatusCodes.NO_CONTENT).send();

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

@@ -21,6 +21,7 @@ const validationSchemas = {
 
   update: Joi.object({
     entityId: Joi.string().uuid(),
+    entityType: Joi.string(),
     schema: Joi.object({
       type: Joi.string().valid('object'),
       properties: Joi.object({

package/src/hooks/hooks.ts

@@ -1,14 +1,17 @@
 import type { WhereOptions } from 'sequelize';
 import Ajv from 'ajv';
+import Joi from 'joi';
 import addFormats from 'ajv-formats';
 import { BadRequest } from '@autofleet/errors';
 import logger from '../utils/logger';
 import * as ValidatorRepo from '../repository/validator';
 import * as DefinitionRepo from '../repository/definition';
-import { MissingRequiredCustomFieldError } from '../errors';
+import { InvalidValueError, MissingRequiredCustomFieldError } from '../errors';
 import type { CustomFieldOptions, ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
 import updateInstanceValues from './utils/updateInstanceValues';
+import { CustomFieldDefinitionType } from '../utils/constants';
+import type { CustomFieldDefinition } from '../models';
 
 // Initialize Ajv with relaxed settings to avoid warnings
 const ajv = new Ajv({
@@ -20,6 +23,56 @@ const ajv = new Ajv({
 
 addFormats(ajv);
 
+/**
+ * Helper function to manually copy object properties
+ * This is more efficient for large objects and avoids excessive object creation
+ */
+// eslint-disable-next-line prefer-object-spread
+const manualObjectCopy = (sourceObj: Record<string, any>, additionalProps?: Record<string, any>): Record<string, any> =>
+  ({ __proto__: null, ...sourceObj, ...additionalProps });
+
+/**
+ * Fetches complete custom fields for an instance by merging DB values with update values
+ * This is needed for partial updates to ensure all related fields are available for validation
+ */
+const getCompleteCustomFields = async (instance, options): Promise<Record<string, any>> => {
+  // If we don't have an instance id or no custom fields being updated, return original fields
+  if (!instance.id || !instance.customFields || Object.keys(instance.customFields).length === 0) {
+    return instance.customFields || {};
+  }
+
+  try {
+    const ModelClass = instance.constructor;
+    // Only select the customFields column to minimize data transfer
+    const currentCustomFields = await ModelClass.findOne({
+      where: { id: instance.id },
+      attributes: ['customFields'],
+      transaction: options.transaction,
+      raw: true, // Get plain object instead of model instance for better performance
+    });
+
+    if (currentCustomFields?.customFields) {
+      // Merge existing fields with update fields using our helper function
+      const completeFields = manualObjectCopy(
+        currentCustomFields.customFields,
+        instance.customFields,
+      );
+
+      logger.debug('sadot - fetched complete custom fields for validation', {
+        fieldsCount: Object.keys(completeFields).length,
+        updateFieldsCount: Object.keys(instance.customFields).length,
+      });
+
+      return completeFields;
+    }
+  } catch (error) {
+    logger.error('sadot - error fetching complete model for validation', { error });
+    // Continue with partial data if we can't fetch the complete model
+  }
+
+  return instance.customFields || {};
+};
+
 /**
  * Validates the model using custom validators
  */
@@ -66,22 +119,30 @@ const validateModel = async (
   }
 
   // For updates, get the previous values
-  const originalValues = isCreate
-    ? null
-    : {
-      ...instance.previous(),
-      customFields: instance.previous('customFields') || {},
-    };
+  let originalValues = null;
+  if (!isCreate) {
+    // Create originalValues with our helper function
+    originalValues = manualObjectCopy(instance.previous());
+
+    // Add customFields separately
+    originalValues.customFields = instance.previous('customFields') || {};
+  }
+
+  // Get complete custom fields by merging DB values with update values
+  // This is especially important for partial updates to ensure all related fields are available
+  const completeCustomFields = !isCreate
+    ? await getCompleteCustomFields(instance, options)
+    : instance.customFields || {};
 
   // For debugging in case of update
-  if (!isCreate) {
+  if (!isCreate && process.env.NODE_ENV !== 'production') {
+    // Create after object for logging
+    const logAfterObj = manualObjectCopy(instance.dataValues, { customFields: completeCustomFields });
+
     logger.debug('sadot - validate with values', {
       before: originalValues,
-      after: {
-        ...instance.dataValues,
-        ...instance.customFields,
-      },
-      schema: JSON.stringify(validators[0].schema),
+      after: logAfterObj,
+      schema: validators[0].schema,
     });
   }
 
@@ -91,7 +152,7 @@ const validateModel = async (
     const typedSchema = schema as Record<string, any>;
 
     logger.debug('sadot - validating with schema', {
-      schema: JSON.stringify(schema),
+      schema,
       hasAfterProps: !!typedSchema.properties?.after,
       hasBeforeProps: !!typedSchema.properties?.before,
     });
@@ -107,12 +168,12 @@ const validateModel = async (
           },
         });
 
-        const isValid = validateSchema({
+        const isValid = validateSchema(JSON.parse(JSON.stringify({
           after: {
             ...instance.dataValues,
-            customFields: instance.customFields,
+            customFields: completeCustomFields,
           },
-        });
+        })));
 
         if (!isValid) {
           const errorDetails = validateSchema.errors?.map((err) =>
@@ -125,28 +186,34 @@ const validateModel = async (
       // For update operations, we need both before and after
       const validateSchema = ajv.compile(typedSchema);
 
-      const isValid = validateSchema({
+      // Create after object with our helper function
+      const afterObj = manualObjectCopy(instance.dataValues);
+
+      // Add complete custom fields
+      afterObj.customFields = completeCustomFields;
+
+      // Create validation payload
+      const payload = {
         before: originalValues,
-        after: {
-          ...instance.dataValues,
-          customFields: instance.customFields,
-        },
-      });
+        after: afterObj,
+      };
+
+      // Validate
+      const isValid = validateSchema(JSON.parse(JSON.stringify(payload)));
 
       logger.info('sadot - validation result', {
         isValid,
         test: {
           before: originalValues,
-          after: {
-            ...instance.dataValues,
-            ...instance.customFields,
-          },
+          after: afterObj,
         },
       });
 
       if (!isValid) {
-        const errorDetails = validateSchema.errors?.map((err) =>
-          `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
+        const errorDetails = validateSchema.errors?.map((err) => {
+          logger.info('dor', err);
+          return `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`;
+        }).join(', ');
 
         throw new BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
       }
@@ -154,6 +221,49 @@ const validateModel = async (
   }
 };
 
+const getFieldDefinitions = async ({
+  modelType,
+  modelOptions,
+  identifiers,
+  options,
+}: {
+  modelType: any,
+  modelOptions: ModelOptions,
+  identifiers: any[],
+  options: any
+}) => {
+  const { include, useEntityIdFromInclude } = modelOptions;
+  const where: WhereOptions = {
+    modelType,
+    disabled: false,
+    ...(!useEntityIdFromInclude && { entityId: identifiers }),
+  };
+
+  const fieldDefinitions = await DefinitionRepo.findAll(where, {
+    withDisabled: false,
+    transaction: options.transaction,
+    include: include?.(identifiers),
+  });
+  return fieldDefinitions;
+};
+
+const formatDates = (fieldDefinitions: CustomFieldDefinition[], instance: any) => {
+  (fieldDefinitions || []).forEach((fieldDefinition) => {
+    const { fieldType, name } = fieldDefinition;
+    if ([CustomFieldDefinitionType.DATE, CustomFieldDefinitionType.DATETIME].includes(fieldType)) {
+      const value = instance.customFields?.[name];
+      if (value) {
+        const validationError = Joi.date().validate(value).error;
+        if (validationError) {
+          throw new InvalidValueError(value, name, validationError);
+        }
+        // eslint-disable-next-line no-param-reassign
+        instance.customFields[name] = new Date(value).toISOString();
+      }
+    }
+  });
+};
+
 /**
  * Hook to handle validation and custom fields during creation
  */
@@ -167,28 +277,16 @@ export const beforeCreate = (
 ): Promise<void> => {
   logger.debug('sadot - before create hook');
   const { fields } = options;
-  const { include, useEntityIdFromInclude } = modelOptions;
   const modelType = instance.constructor.name;
 
   const identifiers = applyScopeToInstance(instance, scopeAttributes);
 
   // Step 1: Handle custom fields default values and required fields
-  const where: WhereOptions = {
-    modelType,
-    disabled: false,
-    ...(!useEntityIdFromInclude && { entityId: identifiers }),
-  };
 
-  const fieldDefinitions = await DefinitionRepo.findAll(where, {
-    withDisabled: false,
-    transaction: options.transaction,
-    include: include?.(identifiers),
+  const fieldDefinitions = await getFieldDefinitions({
+    modelType, modelOptions, identifiers, options,
   });
 
-  const requiredFieldsNames = Array.from(
-    new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)),
-  );
-
   // Apply default values
   const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
   if (fieldsWithDefaultValue.length) {
@@ -203,6 +301,9 @@ export const beforeCreate = (
   }
 
   // Check for required fields
+  const requiredFieldsNames = Array.from(
+    new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)),
+  );
   const { customFields } = instance;
   const fieldsNames = Object.keys(customFields ?? {});
   const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
@@ -213,6 +314,9 @@ export const beforeCreate = (
   // Step 2: Validate the model data (including custom fields)
   await validateModel(instance, options, scopeAttributes, true);
 
+  // format date and datetime fields
+  formatDates(fieldDefinitions, instance);
+
   // Step 3: Save custom field values if they exist
   const customFieldsIdx = fields.indexOf('customFields');
   if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
@@ -254,9 +358,16 @@ export const beforeUpdate = (
   const modelType = instance.constructor.name;
   const identifiers = applyScopeToInstance(instance, scopeAttributes);
 
+  const fieldDefinitions = await getFieldDefinitions({
+    modelType, modelOptions, identifiers, options,
+  });
+
   // Step 1: Validate the model data (including custom fields)
   await validateModel(instance, options, scopeAttributes, false);
 
+  // format date and datetime fields
+  formatDates(fieldDefinitions, instance);
+
   // Step 2: Update custom field values if they exist
   const customFieldsIdx = fields.indexOf('customFields');
   if (customFieldsIdx > -1) {

package/src/index.ts

@@ -17,11 +17,6 @@ export * from './utils/constants';
 
 export * from './utils/helpers';
 
-// Export repositories
-export * as DefinitionRepo from './repository/definition';
-export * as ValueRepo from './repository/value';
-export * as ValidatorRepo from './repository/validator';
-
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
  * @see {@link 'custom-fields/config'} for configurations

package/src/models/CustomValidator.ts

@@ -6,10 +6,12 @@ import {
   DataType,
   Default,
   AfterUpsert,
+  DefaultScope,
 } from 'sequelize-typescript';
 import { randomUUID } from 'node:crypto';
 import { sendDimEvent } from '../events';
 
+@DefaultScope(() => ({ where: { disabled: false } }))
 @Table({
   timestamps: true,
 })

package/src/models/index.ts

@@ -68,6 +68,22 @@ const initTables = async (
     };
   });
 
+  CustomValidator.addScope('userScope', () => {
+    const user = getUser();
+    if (!user?.permissions) {
+      return {};
+    }
+    return {
+      where: {
+        entityId: [
+          ...Object.keys(user.permissions.fleets),
+          ...Object.keys(user.permissions.businessModels),
+          ...Object.keys(user.permissions.demandSources),
+        ],
+      },
+    };
+  });
+
   logger.info('custom-fields: models added');
 
   const SequelizeMeta = sequelize.define(

package/src/repository/validator.ts

@@ -11,7 +11,7 @@ export interface ValidatorAttributes {
   entityId: string;
   entityType: string;
   modelType: string;
-  schema: Record<string, unknown>;
+  schema: CustomValidator['schema'];
   disabled?: boolean;
   [key: string]: unknown; // Add index signature for Sequelize compatibility
 }
@@ -36,14 +36,22 @@ export const findAll = async (
 
   const { transaction, withDisabled } = options;
 
-  const fullWhere = withDisabled
-    ? where
-    : { ...where, disabled: false };
-
-  const validators = await CustomValidator.findAll({
-    where: fullWhere,
-    transaction,
-  });
+  let validators;
+  if (withDisabled) {
+    // If withDisabled is true, use unscoped to ignore the default scope that filters disabled items
+    // Apply the userScope separately to maintain permission filtering
+    validators = await CustomValidator.unscoped().scope('userScope').findAll({
+      where,
+      transaction,
+    });
+  } else {
+    // Use defaultScope and userScope to filter both disabled and by permissions
+    // The defaultScope keeps only non-disabled validators
+    validators = await CustomValidator.scope(['defaultScope', 'userScope']).findAll({
+      where,
+      transaction,
+    });
+  }
 
   return validators;
 };

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

@@ -2,7 +2,7 @@ export default {
   test: {
     username: process.env.DB_USERNAME || '',
     password: process.env.DB_PASSWORD || null,
-    database: process.env.DB_NAME || 'sadot_package_test',
+    database: process.env.DB_NAME || 'postgres',
     host: process.env.DB_HOST || '127.0.0.1',
     port: process.env.DB_PORT || 5432,
     dialect: process.env.DB_TYPE || 'postgres',

package/validator-test.js

@@ -1,79 +0,0 @@
-const Ajv = require("ajv");
-const addFormats = require("ajv-formats");
-const ajv = new Ajv({
-    allErrors: true,
-    strict: false, // Disable strict mode to avoid warnings
-    strictTypes: false, // Disable strict type checking
-    $data: true, // Enable $data references
-  }); // options can be passed, e.g. {allErrors: true}
-  addFormats(ajv);
-
-
-const schema = {
-    "type": "object",
-    "properties": {
-        "after": {
-            "type": "object",
-            "properties": {
-                "customFields": {
-                    "type": "object",
-                    "properties": {
-                        "actualStartTime": {
-                            "type": "string",
-                            "format": "date-time"
-                        },
-                        "actualEndTime": {
-                            "type": "string",
-                            "format": "date-time",
-                            "formatMinimum": {
-                                "$data": "/after/customFields/actualStartTime"
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-  };
-
-const validate = ajv.compile(schema);
-
-const data = {
-    "id": "c9c87cec-28c7-4a1f-9376-4d8a4ba0f49c",
-    "typeId": "4fcd7096-4c90-46a2-a20e-91bb5bff3ced",
-    "priorityId": null,
-    "statusId": "51d28a37-c042-429f-a9cd-fbc81bba2b39",
-    "subjectId": null,
-    "subjectType": null,
-    "title": "ff",
-    "description": null,
-    "dueTime": null,
-    "startTime": null,
-    "endTime": null,
-    "driverId": null,
-    "vendorId": null,
-    "userId": null,
-    "businessModelId": "72ecf740-42a1-46f4-81ca-8132b08c4f04",
-    "createdAt": "2025-03-12T12:58:05.529Z",
-    "updatedAt": "2025-03-12T12:58:05.529Z",
-    "deletedAt": null,
-    "actions": [],
-    "customFields": {
-        "actualStartTime": "2025-03-14T12:48:01.373Z",
-        "actualEndTime": "2025-03-01T12:51:46.685Z"
-    },
-    "isBlocker": false
-};
-
-const valid = validate({after: data});
-
-if (!valid) {
-  console.log("invalid, the errors is: ");
-  validate.errors.forEach((error) =>
-    console.log(error.instancePath, error.message)
-  );
-} else {
-  console.log("valid");
-}
-
-console.log("--------------------");