@autofleet/sadot 0.13.5-beta → 0.13.5-beta-2

package/dist/hooks/hooks.d.ts

@@ -1,19 +1,4 @@
 import type { CustomFieldOptions, ModelOptions } from '../types';
-type AjvError = {
-    instancePath?: string;
-    keyword: string;
-    message?: string;
-    params?: Record<string, any>;
-    schemaPath?: string;
-    [key: string]: any;
-};
-export declare const formatAjvErrors: (errors?: AjvError[]) => {
-    path: string;
-    keyword: string;
-    message: string;
-    errorCode: string;
-    details: Record<string, any>;
-}[];
 /**
  * Hook to handle validation and custom fields during creation
  */
@@ -30,4 +15,3 @@ export declare const beforeBulkCreate: (options: any) => void;
  * Hook to enable individual hooks for bulk update operations
  */
 export declare const beforeBulkUpdate: (options: any) => void;
-export {};

package/dist/hooks/hooks.js

@@ -26,7 +26,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.beforeBulkUpdate = exports.beforeBulkCreate = exports.beforeUpdate = exports.beforeCreate = exports.formatAjvErrors = void 0;
+exports.beforeBulkUpdate = exports.beforeBulkCreate = exports.beforeUpdate = exports.beforeCreate = void 0;
 const ajv_1 = __importDefault(require("ajv"));
 const joi_1 = __importDefault(require("joi"));
 const ajv_formats_1 = __importDefault(require("ajv-formats"));
@@ -90,25 +90,22 @@ const getCompleteCustomFields = async (instance, options) => {
     }
     return instance.customFields || {};
 };
-const formatAjvErrors = (errors = []) => errors.map((err) => {
-    const path = err.instancePath || '/';
-    const { keyword } = err;
+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';
-    const normalizedPath = path.replace(/\//g, '_').replace(/^_/, '');
-    const errorCode = `${keyword}_${normalizedPath}`;
-    return {
-        path,
-        keyword,
-        message,
-        errorCode,
-        details: err.params || {},
-    };
-});
-exports.formatAjvErrors = formatAjvErrors;
+    acc[key] = message;
+    return acc;
+}, {});
 /**
  * Validates the model using custom validators
  */
-const validateModel = async (instance, options, scopeAttributes, isCreate = false) => {
+const validateModel = async (instance, options, scopeAttributes, modelOptions = {}, isCreate = false) => {
     var _a;
     const modelType = instance.constructor.name;
     logger_1.default.debug('sadot - validating model', { isCreate, modelType });
@@ -138,6 +135,9 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
         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) {
@@ -189,13 +189,9 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
                     },
                 })));
                 if (!isValid) {
-                    const formattedErrors = (0, exports.formatAjvErrors)(validateSchema.errors);
-                    console.log(JSON.stringify({ AAAAAAA: formattedErrors, BBBBB: validateSchema.errors }));
                     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}`),
-                        ...formattedErrors.map((err) => new Error(err.message)),
-                    ]);
+                    const formattedErrors = formatAjvErrors(validateSchema.errors);
+                    throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], undefined, formattedErrors);
                 }
             }
         }
@@ -224,7 +220,8 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
                 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}`)]);
+                const formattedErrors = formatAjvErrors(validateSchema.errors);
+                throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], undefined, formattedErrors);
             }
         }
     }
@@ -292,7 +289,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, true);
+    await validateModel(instance, options, scopeAttributes, modelOptions, true);
     // format date and datetime fields
     formatDates(fieldDefinitions, instance);
     // Step 3: Save custom field values if they exist
@@ -330,7 +327,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, false);
+    await validateModel(instance, options, scopeAttributes, modelOptions, false);
     // format date and datetime fields
     formatDates(fieldDefinitions, instance);
     // Step 2: Update custom field values if they exist

package/dist/models/index.js

@@ -59,13 +59,6 @@ const initTables = async (sequelize, getUser, { schemaPrefix = SADOT_MIGRATION_P
         if (!user?.permissions) {
             return {};
         }
-        console.log({
-            PPPPPPPP: JSON.stringify([
-                ...Object.keys(user.permissions.fleets),
-                ...Object.keys(user.permissions.businessModels),
-                ...Object.keys(user.permissions.demandSources),
-            ]),
-        });
         return {
             where: {
                 entityId: [

package/dist/repository/validator.d.ts

@@ -1,9 +1,10 @@
-import type { Transactionable } from 'sequelize';
+import type { IncludeOptions, 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,7 +40,9 @@ const findAllByModelType = async (modelType, entityId, options = { withDisabled:
     logger_1.default.debug('custom-validator - find all validators by model type');
     return (0, exports.findAll)({
         modelType,
-        entityId,
+        ...(!options.include && {
+            entityId,
+        }),
     }, options);
 };
 exports.findAllByModelType = findAllByModelType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.13.5-beta",
+  "version": "0.13.5-beta-2",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/hooks/hooks.ts

@@ -78,32 +78,28 @@ const getCompleteCustomFields = async (instance, options): Promise<Record<string
   return instance.customFields || {};
 };
 
-type AjvError = {
+const formatAjvErrors = (
+  errors: {
   instancePath?: string;
   keyword: string;
   message?: string;
   params?: Record<string, any>;
-  schemaPath?: string;
-  [key: string]: any;
-};
+}[],
+): Record<string, string> => errors.reduce((acc, err) => {
+  const basePath = (err.instancePath || '')
+    .split('/')
+    .filter(Boolean)
+    .join('.')
+    .replace(/^after\./, '');
 
-export const formatAjvErrors = (errors: AjvError[] = []) =>
-  errors.map((err) => {
-    const path = err.instancePath || '/';
-    const { keyword } = err;
-    const message = err.message || 'Invalid value';
-
-    const normalizedPath = path.replace(/\//g, '_').replace(/^_/, '');
-    const errorCode = `${keyword}_${normalizedPath}`;
-
-    return {
-      path,
-      keyword,
-      message,
-      errorCode,
-      details: err.params || {},
-    };
-  });
+  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
@@ -112,6 +108,7 @@ const validateModel = async (
   instance,
   options,
   scopeAttributes: string[],
+  modelOptions: ModelOptions = {},
   isCreate = false,
 ): Promise<void> => {
   const modelType = instance.constructor.name;
@@ -153,6 +150,9 @@ const validateModel = async (
       {
         transaction: options.transaction,
         attributes: CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL,
+        ...(modelOptions.include && {
+          include: modelOptions.include?.(entityId),
+        }),
         raw: true,
       },
     );
@@ -215,14 +215,15 @@ const validateModel = async (
         })));
 
         if (!isValid) {
-          const formattedErrors = formatAjvErrors(validateSchema.errors);
           const errorDetails = validateSchema.errors?.map((err) =>
             `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
 
-          throw new BadRequest([
-            new Error(`Validation failed for ${modelType}: ${errorDetails}`),
-            ...formattedErrors.map((err) => new Error(err.message)),
-          ]);
+          const formattedErrors = formatAjvErrors(validateSchema.errors);
+          throw new BadRequest(
+            [new Error(`Validation failed for ${modelType}: ${errorDetails}`)],
+            undefined,
+            formattedErrors,
+          );
         }
       }
     } else {
@@ -257,7 +258,12 @@ const validateModel = async (
           .errors
           ?.map((err) => `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
 
-        throw new BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
+        const formattedErrors = formatAjvErrors(validateSchema.errors);
+        throw new BadRequest(
+          [new Error(`Validation failed for ${modelType}: ${errorDetails}`)],
+          undefined,
+          formattedErrors,
+        );
       }
     }
   }
@@ -354,7 +360,7 @@ export const beforeCreate = (
   }
 
   // Step 2: Validate the model data (including custom fields)
-  await validateModel(instance, options, scopeAttributes, true);
+  await validateModel(instance, options, scopeAttributes, modelOptions, true);
 
   // format date and datetime fields
   formatDates(fieldDefinitions, instance);
@@ -405,7 +411,7 @@ export const beforeUpdate = (
   });
 
   // Step 1: Validate the model data (including custom fields)
-  await validateModel(instance, options, scopeAttributes, false);
+  await validateModel(instance, options, scopeAttributes, modelOptions, false);
 
   // format date and datetime fields
   formatDates(fieldDefinitions, instance);

package/src/repository/validator.ts

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