@autofleet/sadot 0.13.5-beta-4 → 0.13.5-beta.0

package/dist/hooks/hooks.js

@@ -31,7 +31,6 @@ const ajv_1 = __importDefault(require("ajv"));
 const joi_1 = __importDefault(require("joi"));
 const ajv_formats_1 = __importDefault(require("ajv-formats"));
 const errors_1 = require("@autofleet/errors");
-const ajv_errors_1 = __importDefault(require("ajv-errors"));
 const logger_1 = __importDefault(require("../utils/logger"));
 const ValidatorRepo = __importStar(require("../repository/validator"));
 const DefinitionRepo = __importStar(require("../repository/definition"));
@@ -49,7 +48,6 @@ const ajv = new ajv_1.default({
     $data: true, // Enable $data references
 });
 (0, ajv_formats_1.default)(ajv);
-(0, ajv_errors_1.default)(ajv);
 /**
  * Helper function to manually copy object properties
  * This is more efficient for large objects and avoids excessive object creation
@@ -90,22 +88,10 @@ const getCompleteCustomFields = async (instance, options) => {
     }
     return instance.customFields || {};
 };
-const formatAjvErrors = (errors) => errors.reduce((acc, err) => {
-    const basePath = (err.instancePath || '')
-        .split('/')
-        .filter(Boolean)
-        .join('.')
-        .replace(/^after\./, '');
-    const missingProp = err.keyword === 'required' ? `.${err.params?.missingProperty}` : '';
-    const key = (basePath + missingProp).replace(/^\./, '') || 'root';
-    const message = err.message || 'Invalid value';
-    acc[key] = message;
-    return acc;
-}, {});
 /**
  * Validates the model using custom validators
  */
-const validateModel = async (instance, options, scopeAttributes, modelOptions = {}, isCreate = false) => {
+const validateModel = async (instance, options, scopeAttributes, isCreate = false) => {
     var _a;
     const modelType = instance.constructor.name;
     logger_1.default.debug('sadot - validating model', { isCreate, modelType });
@@ -135,9 +121,6 @@ const validateModel = async (instance, options, scopeAttributes, modelOptions =
         validatorsPromise = ValidatorRepo.findAllByModelType(modelType, entityId, {
             transaction: options.transaction,
             attributes: CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL,
-            ...(modelOptions.include && {
-                include: modelOptions.include?.(entityId),
-            }),
             raw: true,
         });
         if (options.transaction) {
@@ -190,10 +173,7 @@ const validateModel = async (instance, options, scopeAttributes, modelOptions =
                 })));
                 if (!isValid) {
                     const errorDetails = validateSchema.errors?.map((err) => `${err.instancePath || ''} ${err.message || 'Invalid value'}`).join(', ');
-                    const formattedErrors = formatAjvErrors(validateSchema.errors);
-                    throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], undefined, {
-                        customError: formattedErrors,
-                    });
+                    throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
                 }
             }
         }
@@ -222,10 +202,7 @@ const validateModel = async (instance, options, scopeAttributes, modelOptions =
                 const errorDetails = validateSchema
                     .errors
                     ?.map((err) => `${err.instancePath || ''} ${err.message || 'Invalid value'}`).join(', ');
-                const formattedErrors = formatAjvErrors(validateSchema.errors);
-                throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], undefined, {
-                    customError: formattedErrors,
-                });
+                throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
             }
         }
     }
@@ -293,7 +270,7 @@ const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
         throw new errors_2.MissingRequiredCustomFieldError(missingFields);
     }
     // Step 2: Validate the model data (including custom fields)
-    await validateModel(instance, options, scopeAttributes, modelOptions, true);
+    await validateModel(instance, options, scopeAttributes, true);
     // format date and datetime fields
     formatDates(fieldDefinitions, instance);
     // Step 3: Save custom field values if they exist
@@ -331,7 +308,7 @@ const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
         modelType, modelOptions, identifiers, options,
     });
     // Step 1: Validate the model data (including custom fields)
-    await validateModel(instance, options, scopeAttributes, modelOptions, false);
+    await validateModel(instance, options, scopeAttributes, false);
     // format date and datetime fields
     formatDates(fieldDefinitions, instance);
     // Step 2: Update custom field values if they exist

package/dist/repository/validator.d.ts

@@ -1,10 +1,9 @@
-import type { IncludeOptions, Transactionable } from 'sequelize';
+import type { Transactionable } from 'sequelize';
 import { CustomValidator } from '../models';
 export interface FindValidatorOptions extends Transactionable {
     withDisabled?: boolean;
     attributes?: string[];
     raw?: boolean;
-    include?: IncludeOptions[];
 }
 export interface ValidatorAttributes {
     entityId: string;

package/dist/repository/validator.js

@@ -40,9 +40,7 @@ const findAllByModelType = async (modelType, entityId, options = { withDisabled:
     logger_1.default.debug('custom-validator - find all validators by model type');
     return (0, exports.findAll)({
         modelType,
-        ...(!options.include && {
-            entityId,
-        }),
+        entityId,
     }, options);
 };
 exports.findAllByModelType = findAllByModelType;

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

@@ -1,4 +1,4 @@
-import { type WhereOptions, type BindOrReplacements } from 'sequelize';
+import { type WhereOptions, type IncludeOptions } from 'sequelize';
 import { type ModelStatic } from 'sequelize-typescript';
 import { CustomFieldDefinitionType } from '../constants';
 /**
@@ -14,12 +14,11 @@ import { CustomFieldDefinitionType } from '../constants';
  * @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.
+ * @returns {CustomFieldsSearchPayload} - An object containing the INCLUDE clause and WHERE clause to add to query payload
  */
 interface CustomFieldsSearchPayload {
     where: WhereOptions;
-    replacements: BindOrReplacements;
+    include: IncludeOptions[];
 }
 export declare const generateRandomString: (length?: number) => string;
 export declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;

package/dist/utils/helpers/index.js

@@ -6,6 +6,7 @@ const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const node_crypto_1 = require("node:crypto");
 const constants_1 = require("../constants");
+const models_1 = require("../../models");
 const generateRandomString = (length = 5) => {
     const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
     return Array.from({ length }, () => characters.charAt((0, node_crypto_1.randomInt)(characters.length))).join('');
@@ -14,27 +15,34 @@ exports.generateRandomString = generateRandomString;
 const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
     constants_1.CustomFieldDefinitionType.DATETIME,
     constants_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),
+]) => ({
+    include: [{
+            attributes: ['value', 'model_id'],
+            model: models_1.CustomFieldValue,
+            as: 'customFieldValue',
+            required: false,
+            include: [
+                {
+                    model: models_1.CustomFieldDefinition,
+                    as: 'customFieldDefinition',
+                    attributes: ['entity_id', 'field_type', 'model_type'],
+                    required: true,
+                    on: {
+                        id: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('id'), { [sequelize_1.Op.eq]: sequelize_typescript_1.Sequelize.col('customFieldValue.custom_field_definition_id') }),
+                        entityId: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('entity_id'), { [sequelize_1.Op.eq]: `${entityId}` }),
+                        modelType: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('model_type'), { [sequelize_1.Op.eq]: `${model.name}` }),
+                        fieldType: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('field_type'), { [sequelize_1.Op.notIn]: customFieldsTypesToExclude }),
+                    },
+                    where: {
+                        deleted_at: null,
+                    },
+                },
             ],
-        },
-        replacements: { searchTerm: `%${searchTerm}%` },
-    };
-};
+            on: {
+                value: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.cast(sequelize_typescript_1.Sequelize.col('value'), 'text'), { [sequelize_1.Op.iLike]: `%${searchTerm}%` }),
+                model_id: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('model_id'), { [sequelize_1.Op.eq]: sequelize_typescript_1.Sequelize.col(`${model.name}.id`) }),
+            },
+        }],
+    where: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('customFieldValue.model_id'), { [sequelize_1.Op.not]: null }),
+});
 exports.generateCustomFieldSearchQueryPayload = generateCustomFieldSearchQueryPayload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.13.5-beta-4",
+  "version": "0.13.5-beta.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -31,7 +31,6 @@
     "@autofleet/common-types": "^4.4.0",
     "@autofleet/events": "^4.0.0",
     "ajv": "^8.12.0",
-    "ajv-errors": "^3.0.0",
     "ajv-formats": "^3.0.1",
     "http-status-codes": "^2.3.0",
     "joi": "^17.7.0",

package/src/hooks/hooks.ts

@@ -1,9 +1,8 @@
 import type { WhereOptions } from 'sequelize';
 import Ajv from 'ajv';
-import Joi, { custom } from 'joi';
+import Joi from 'joi';
 import addFormats from 'ajv-formats';
 import { BadRequest } from '@autofleet/errors';
-import ajvErrors from 'ajv-errors';
 import logger from '../utils/logger';
 import * as ValidatorRepo from '../repository/validator';
 import * as DefinitionRepo from '../repository/definition';
@@ -26,7 +25,6 @@ const ajv = new Ajv({
 });
 
 addFormats(ajv);
-ajvErrors(ajv);
 
 /**
  * Helper function to manually copy object properties
@@ -78,29 +76,6 @@ const getCompleteCustomFields = async (instance, options): Promise<Record<string
   return instance.customFields || {};
 };
 
-const formatAjvErrors = (
-  errors: {
-  instancePath?: string;
-  keyword: string;
-  message?: string;
-  params?: Record<string, any>;
-}[],
-): Record<string, string> => errors.reduce((acc, err) => {
-  const basePath = (err.instancePath || '')
-    .split('/')
-    .filter(Boolean)
-    .join('.')
-    .replace(/^after\./, '');
-
-  const missingProp = err.keyword === 'required' ? `.${err.params?.missingProperty}` : '';
-  const key = (basePath + missingProp).replace(/^\./, '') || 'root';
-
-  const message = err.message || 'Invalid value';
-  acc[key] = message;
-
-  return acc;
-}, {} as Record<string, string>);
-
 /**
  * Validates the model using custom validators
  */
@@ -108,7 +83,6 @@ const validateModel = async (
   instance,
   options,
   scopeAttributes: string[],
-  modelOptions: ModelOptions = {},
   isCreate = false,
 ): Promise<void> => {
   const modelType = instance.constructor.name;
@@ -150,9 +124,6 @@ const validateModel = async (
       {
         transaction: options.transaction,
         attributes: CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL,
-        ...(modelOptions.include && {
-          include: modelOptions.include?.(entityId),
-        }),
         raw: true,
       },
     );
@@ -218,14 +189,7 @@ const validateModel = async (
           const errorDetails = validateSchema.errors?.map((err) =>
             `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
 
-          const formattedErrors = formatAjvErrors(validateSchema.errors);
-          throw new BadRequest(
-            [new Error(`Validation failed for ${modelType}: ${errorDetails}`)],
-            undefined,
-            {
-              customError: formattedErrors,
-            },
-          );
+          throw new BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
         }
       }
     } else {
@@ -260,14 +224,7 @@ const validateModel = async (
           .errors
           ?.map((err) => `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
 
-        const formattedErrors = formatAjvErrors(validateSchema.errors);
-        throw new BadRequest(
-          [new Error(`Validation failed for ${modelType}: ${errorDetails}`)],
-          undefined,
-          {
-            customError: formattedErrors,
-          },
-        );
+        throw new BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
       }
     }
   }
@@ -364,7 +321,7 @@ export const beforeCreate = (
   }
 
   // Step 2: Validate the model data (including custom fields)
-  await validateModel(instance, options, scopeAttributes, modelOptions, true);
+  await validateModel(instance, options, scopeAttributes, true);
 
   // format date and datetime fields
   formatDates(fieldDefinitions, instance);
@@ -415,7 +372,7 @@ export const beforeUpdate = (
   });
 
   // Step 1: Validate the model data (including custom fields)
-  await validateModel(instance, options, scopeAttributes, modelOptions, false);
+  await validateModel(instance, options, scopeAttributes, false);
 
   // format date and datetime fields
   formatDates(fieldDefinitions, instance);

package/src/repository/validator.ts

@@ -1,4 +1,4 @@
-import type { IncludeOptions, Transactionable } from 'sequelize';
+import type { Transactionable } from 'sequelize';
 import logger from '../utils/logger';
 import { CustomValidator } from '../models';
 
@@ -6,7 +6,6 @@ export interface FindValidatorOptions extends Transactionable {
   withDisabled?: boolean;
   attributes?: string[];
   raw?: boolean;
-  include?: IncludeOptions[];
 }
 
 // Make sure this interface is compatible with the Sequelize model
@@ -69,9 +68,7 @@ export const findAllByModelType = async (
   return findAll(
     {
       modelType,
-      ...(!options.include && {
-        entityId,
-      }),
+      entityId,
     },
     options,
   );

package/src/utils/helpers/index.ts

@@ -1,8 +1,11 @@
 /* eslint-disable import/prefer-default-export */
-import { type WhereOptions, Op, type BindOrReplacements } from 'sequelize';
+import {
+  type WhereOptions, Op, type IncludeOptions,
+} from 'sequelize';
 import { type ModelStatic, Sequelize } from 'sequelize-typescript';
 import { randomInt } from 'node:crypto';
 import { CustomFieldDefinitionType } from '../constants';
+import { CustomFieldDefinition, CustomFieldValue } from '../../models';
 
 /**
  * Builds a WHERE clause and replacements for free-text search by custom fields.
@@ -17,13 +20,12 @@ import { CustomFieldDefinitionType } from '../constants';
  * @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.
+ * @returns {CustomFieldsSearchPayload} - An object containing the INCLUDE clause and WHERE clause to add to query payload
  */
 
 interface CustomFieldsSearchPayload {
   where: WhereOptions;
-  replacements: BindOrReplacements;
+  include: IncludeOptions[];
 }
 
 export const generateRandomString = (length = 5): string => {
@@ -39,28 +41,33 @@ export const generateCustomFieldSearchQueryPayload = (
     CustomFieldDefinitionType.DATETIME,
     CustomFieldDefinitionType.DATE,
   ],
-): CustomFieldsSearchPayload => {
-  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: {
-      [Op.or]: [
-        Sequelize.where(Sequelize.literal(subQuery), true),
-      ],
+): CustomFieldsSearchPayload => ({
+  include: [{
+    attributes: ['value', 'model_id'],
+    model: CustomFieldValue,
+    as: 'customFieldValue',
+    required: false,
+    include: [
+      {
+        model: CustomFieldDefinition,
+        as: 'customFieldDefinition',
+        attributes: ['entity_id', 'field_type', 'model_type'],
+        required: true,
+        on: {
+          id: Sequelize.where(Sequelize.col('id'), { [Op.eq]: Sequelize.col('customFieldValue.custom_field_definition_id') }),
+          entityId: Sequelize.where(Sequelize.col('entity_id'), { [Op.eq]: `${entityId}` }),
+          modelType: Sequelize.where(Sequelize.col('model_type'), { [Op.eq]: `${model.name}` }),
+          fieldType: Sequelize.where(Sequelize.col('field_type'), { [Op.notIn]: customFieldsTypesToExclude }),
+        },
+        where: {
+          deleted_at: null,
+        },
+      },
+    ],
+    on: {
+      value: Sequelize.where(Sequelize.cast(Sequelize.col('value'), 'text'), { [Op.iLike]: `%${searchTerm}%` }),
+      model_id: Sequelize.where(Sequelize.col('model_id'), { [Op.eq]: Sequelize.col(`${model.name}.id`) }),
     },
-    replacements: { searchTerm: `%${searchTerm}%` },
-  };
-};
+  }],
+  where: Sequelize.where(Sequelize.col('customFieldValue.model_id'), { [Op.not]: null }),
+});