@autofleet/sadot 1.0.0-beta.1 → 1.0.0

package/dist/hooks/enrich.d.ts

@@ -1,7 +1,25 @@
-import type { ModelOptions } from '../types';
+import type CustomFieldValue from '../models/CustomFieldValue';
+import type { CustomFieldOptions, ModelOptions, TransactionOptions } from '../types';
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
+type CustomFieldEntries = Record<string, any>;
+interface GetValuesGroupByInstanceResponse {
+    [modelId: string]: CustomFieldValue[];
+}
+interface GetCustomFieldEntriesByInstanceIdResponse {
+    [modelId: string]: CustomFieldEntries;
+}
+export declare const getCustomFieldEntriesByInstanceId: ({ instancesIds, options, sadotOptions, }: {
+    instancesIds: string[];
+    options?: TransactionOptions;
+    sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>;
+}) => Promise<GetCustomFieldEntriesByInstanceIdResponse>;
+export declare const getValuesGroupByInstance: ({ instancesIds, options, sadotOptions, }: {
+    instancesIds: string[];
+    options?: TransactionOptions;
+    sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>;
+}) => Promise<GetValuesGroupByInstanceResponse>;
 /**
  * A hook to attach the custom fields when fetching a model instances.
  */
-declare const enrichResults: (modelType: string, scopeAttributes: string[], hookType?: SupportedHookTypes, modelOptions?: ModelOptions) => (instancesOrInstance: any | any[], options: any) => Promise<void>;
+declare const enrichResults: (modelType: string, scopeAttributes: string[], hookType?: SupportedHookTypes, modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instancesOrInstance: any | any[], options: TransactionOptions) => Promise<void>;
 export default enrichResults;

package/dist/hooks/enrich.js

@@ -26,10 +26,58 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.getValuesGroupByInstance = exports.getCustomFieldEntriesByInstanceId = void 0;
 /* eslint-disable no-param-reassign */
 const ValueRepo = __importStar(require("../repository/value"));
 const DefinitionRepo = __importStar(require("../repository/definition"));
+const EntriesRepo = __importStar(require("../repository/entries"));
 const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+// Include all required fields for proper functioning
+const CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL = [
+    'id',
+    'name',
+    'entityId',
+    'fieldType',
+    'displayName',
+    'validation',
+    'entityType',
+    'modelType',
+    'required',
+    'disabled',
+    'defaultValue',
+];
+const getCustomFieldEntriesByInstanceId = async ({ instancesIds, options, sadotOptions, }) => {
+    if (!sadotOptions.useCustomFieldsEntries) {
+        return {};
+    }
+    const customFieldEntries = await EntriesRepo.findEntriesByModelIds(instancesIds, options ?? {});
+    const customFieldEntriesByInstanceId = Object.fromEntries(customFieldEntries.map((instanceEntries) => {
+        const { modelId, customFields } = instanceEntries?.dataValues ?? {};
+        if (!modelId) {
+            return undefined;
+        }
+        return [modelId, customFields];
+    }).filter(Boolean));
+    instancesIds.forEach((instanceId) => {
+        customFieldEntriesByInstanceId[instanceId] ?? (customFieldEntriesByInstanceId[instanceId] = {});
+    });
+    return customFieldEntriesByInstanceId;
+};
+exports.getCustomFieldEntriesByInstanceId = getCustomFieldEntriesByInstanceId;
+const getValuesGroupByInstance = async ({ instancesIds, options, sadotOptions, }) => {
+    if (sadotOptions.useCustomFieldsEntries) {
+        return {};
+    }
+    const customFieldValues = await ValueRepo.findValuesByModelIds(instancesIds, options ?? {});
+    // Group fields by modelId
+    return customFieldValues.reduce((acc, v) => {
+        const { modelId } = v;
+        acc[modelId] ?? (acc[modelId] = []);
+        acc[modelId].push(v);
+        return acc;
+    }, {});
+};
+exports.getValuesGroupByInstance = getValuesGroupByInstance;
 /**
  * Serialize custom fields value into the format of {[name] -> [fieldData]}
  */
@@ -44,7 +92,8 @@ const serializeCustomFields = (customFieldValues, customFieldDefinitionsHash) =>
 /**
  * A hook to attach the custom fields when fetching a model instances.
  */
-const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}) => async (instancesOrInstance, options) => {
+const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instancesOrInstance, options) => {
+    var _a;
     if (options.originalAttributes?.length > 0
         && !options.originalAttributes?.includes?.('customFields')) {
         return;
@@ -60,7 +109,28 @@ const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {})
         ...map,
         [identifier]: [],
     }), {});
-    const customFieldDefinitions = await DefinitionRepo.findByEntityIds(modelType, uniqueIdentifiers, { transaction: options.transaction, modelOptions });
+    // Cache for definitions by model type and transaction to avoid redundant DB queries
+    let customFieldDefinitionsPromise;
+    let cacheKey;
+    if (options.transaction) {
+        // Initialize definition cache Map if not already present directly on the transaction object
+        (_a = options.transaction).definitionCache || (_a.definitionCache = new Map());
+        cacheKey = `${modelType}:${uniqueIdentifiers.slice().sort().join(',')}`;
+        customFieldDefinitionsPromise = options.transaction.definitionCache.get(cacheKey);
+    }
+    if (!customFieldDefinitionsPromise) {
+        // Fetch from database (either first time in this transaction or no transaction)
+        customFieldDefinitionsPromise = DefinitionRepo.findByEntityIds(modelType, uniqueIdentifiers, { transaction: options.transaction, modelOptions, attributes: CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL });
+        options.transaction?.definitionCache?.set(cacheKey, customFieldDefinitionsPromise);
+    }
+    const customFieldDefinitions = await customFieldDefinitionsPromise;
+    if (customFieldDefinitions.length === 0) {
+        // if no custom fields, we can return
+        instances.forEach((instance) => {
+            instance.customFields = {};
+        });
+        return;
+    }
     if (modelOptions?.include && modelOptions.useEntityIdFromInclude) {
         // if we pass useEntityIdFromInclude,
         //  map the entity from the options to the identifierCustomFieldDefinitionsMapping
@@ -80,25 +150,27 @@ const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {})
     });
     // Get the values per instates ids:
     const instancesIds = instances.map((i) => i[primaryKey]);
-    const customFieldValues = await ValueRepo.findValuesByModelIds(instancesIds, { transaction: options.transaction });
     // Group fields by modelId
-    const valuesGroupByInstance = customFieldValues.reduce((acc, v) => {
-        const { modelId } = v;
-        if (!acc[modelId]) {
-            acc[modelId] = [];
-        }
-        acc[modelId].push(v);
-        return acc;
-    }, {});
+    const [valuesGroupByInstance, customFieldEntriesByInstanceId] = await Promise.all([
+        (0, exports.getValuesGroupByInstance)({
+            instancesIds,
+            options,
+            sadotOptions,
+        }),
+        (0, exports.getCustomFieldEntriesByInstanceId)({
+            instancesIds,
+            options,
+            sadotOptions,
+        }),
+    ]);
     // Attach custom fields to the instances
     instances.forEach((instance) => {
-        const customFields = {};
         const { id } = instance;
         const instanceValues = valuesGroupByInstance[id];
-        if (instanceValues) {
-            const serializedCustomFields = serializeCustomFields(instanceValues, definitionsMap);
-            Object.assign(customFields, serializedCustomFields);
-        }
+        const serializedCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
+        const customFields = sadotOptions.useCustomFieldsEntries
+            ? customFieldEntriesByInstanceId[id]
+            : serializedCustomFieldsValues;
         scopeAttributes.forEach((attribute) => {
             const identifier = instance[attribute];
             const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];

package/dist/hooks/hooks.d.ts

@@ -0,0 +1,17 @@
+import type { CustomFieldOptions, ModelOptions } from '../types';
+/**
+ * Hook to handle validation and custom fields during creation
+ */
+export declare const beforeCreate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;
+/**
+ * Hook to handle validation and custom fields during update
+ */
+export declare const beforeUpdate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;
+/**
+ * Hook to enable individual hooks for bulk create operations
+ */
+export declare const beforeBulkCreate: (options: any) => void;
+/**
+ * Hook to enable individual hooks for bulk update operations
+ */
+export declare const beforeBulkUpdate: (options: any) => void;

package/dist/hooks/hooks.js

@@ -0,0 +1,379 @@
+"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;
+};
+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 = void 0;
+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"));
+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");
+// Include all required fields for proper validation
+const CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL = ['id', 'schema', 'modelType', 'entityId', 'disabled'];
+// Initialize Ajv with relaxed settings to avoid warnings
+const ajv = new ajv_1.default({
+    allErrors: true,
+    strict: false, // Disable strict mode to avoid warnings
+    strictTypes: false, // Disable strict type checking
+    $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
+ */
+// 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 || {};
+};
+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) => {
+    var _a;
+    const modelType = instance.constructor.name;
+    logger_1.default.debug('sadot - validating model', { isCreate, modelType });
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
+    logger_1.default.debug('sadot - identifiers', { identifiers });
+    // Skip if no identifiers
+    if (!identifiers || Object.keys(identifiers).length === 0) {
+        logger_1.default.debug('sadot - skipping validation: no identifiers');
+        return;
+    }
+    // Find the entityId from identifiers (fleetId, businessModelId, etc.)
+    const entityId = Object.values(identifiers)[0]; // Get the first value as entityId
+    logger_1.default.debug('sadot - entityId', { entityId });
+    if (!entityId) {
+        logger_1.default.debug('sadot - skipping validation: no entityId');
+        return;
+    }
+    let validatorsPromise;
+    let cacheKey;
+    if (options.transaction) {
+        // eslint-disable-next-line no-param-reassign
+        (_a = options.transaction).validationsCache || (_a.validationsCache = new Map());
+        cacheKey = `${modelType}-${entityId}`;
+        validatorsPromise = options.transaction.validationsCache.get(cacheKey);
+    }
+    if (!validatorsPromise) {
+        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) {
+            options?.transaction?.validationsCache.set(cacheKey, validatorsPromise);
+        }
+    }
+    const validators = await validatorsPromise;
+    logger_1.default.debug('sadot - validators found', { count: validators.length });
+    if (!validators.length) {
+        logger_1.default.debug('sadot - skipping validation: no validators found');
+        return;
+    }
+    // For updates, get the previous values
+    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 || {};
+    // eslint-disable-next-line no-restricted-syntax
+    for (const validator of validators) {
+        const { schema } = validator;
+        const typedSchema = schema;
+        logger_1.default.debug('sadot - validating with schema', {
+            schema,
+            hasAfterProps: !!typedSchema.properties?.after,
+            hasBeforeProps: !!typedSchema.properties?.before,
+        });
+        if (isCreate) {
+            // For create operations, we only need the 'after' state
+            if (typedSchema.properties?.after) {
+                const validateSchema = ajv.compile({
+                    ...schema,
+                    // Focus only on the 'after' validation part for create
+                    properties: {
+                        after: typedSchema.properties.after,
+                    },
+                });
+                const isValid = validateSchema(JSON.parse(JSON.stringify({
+                    after: {
+                        ...instance.dataValues,
+                        customFields: completeCustomFields,
+                    },
+                })));
+                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,
+                    });
+                }
+            }
+        }
+        else {
+            // For update operations, we need both before and after
+            const validateSchema = ajv.compile(typedSchema);
+            // 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: afterObj,
+            };
+            // Validate
+            const isValid = validateSchema(JSON.parse(JSON.stringify(payload)));
+            logger_1.default.debug('sadot - validation result', {
+                isValid,
+                test: {
+                    before: originalValues,
+                    after: afterObj,
+                },
+            });
+            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,
+                });
+            }
+        }
+    }
+};
+const getFieldDefinitions = async ({ modelType, modelOptions, identifiers, options, }) => {
+    const { include, useEntityIdFromInclude } = modelOptions;
+    const where = {
+        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, 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) {
+                const { value: joiValue, error: validationError } = joi_1.default.date().validate(value);
+                if (validationError) {
+                    throw new errors_2.InvalidValueError(value, name, validationError);
+                }
+                // eslint-disable-next-line no-param-reassign
+                instance.customFields[name] = joiValue.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) {
+        // eslint-disable-next-line no-param-reassign
+        instance.customFields || (instance.customFields = {});
+        fieldsWithDefaultValue
+            .filter((def) => (instance.customFields?.[def.name] === undefined))
+            .forEach(({ name, defaultValue }) => {
+            // eslint-disable-next-line no-param-reassign
+            instance.customFields[name] = defaultValue;
+        });
+    }
+    // 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));
+    if (missingFields?.length) {
+        throw new errors_2.MissingRequiredCustomFieldError(missingFields);
+    }
+    // Step 2: Validate the model data (including custom fields)
+    await validateModel(instance, options, scopeAttributes, modelOptions, 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) {
+        // No custom fields to update
+        return;
+    }
+    // Save custom field values
+    await (0, updateInstanceValues_1.default)({
+        modelId: instance.id,
+        modelType,
+        identifiers,
+        customFields,
+        options: {
+            useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+            transaction: options.transaction,
+            modelOptions,
+        },
+    });
+    // Remove customFields from fields array after handling
+    // eslint-disable-next-line no-param-reassign
+    fields.splice(customFieldsIdx, 1);
+};
+exports.beforeCreate = beforeCreate;
+/**
+ * Hook to handle validation and custom fields during update
+ */
+const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
+    logger_1.default.debug('sadot - before update hook');
+    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, modelOptions, 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) {
+        const { customFields } = instance;
+        if (!Object.keys(customFields).length) {
+            return;
+        }
+        // Save custom field values
+        await (0, updateInstanceValues_1.default)({
+            modelId: instance.id,
+            modelType,
+            identifiers,
+            customFields,
+            options: {
+                useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+                transaction: options.transaction,
+                modelOptions,
+            },
+        });
+        // Remove customFields from fields array after handling
+        // eslint-disable-next-line no-param-reassign
+        fields.splice(customFieldsIdx, 1);
+    }
+};
+exports.beforeUpdate = beforeUpdate;
+/**
+ * Hook to enable individual hooks for bulk create operations
+ */
+const beforeBulkCreate = (options) => {
+    // This will activate the beforeCreate hook on each instance
+    // eslint-disable-next-line no-param-reassign
+    options.individualHooks = true;
+};
+exports.beforeBulkCreate = beforeBulkCreate;
+/**
+ * Hook to enable individual hooks for bulk update operations
+ */
+const beforeBulkUpdate = (options) => {
+    // This will activate the beforeUpdate hook on each instance
+    // eslint-disable-next-line no-param-reassign
+    options.individualHooks = true;
+};
+exports.beforeBulkUpdate = beforeBulkUpdate;

package/dist/hooks/index.d.ts

@@ -1,6 +1,5 @@
 import enrichResults from './enrich';
 import { beforeFind } from './find';
-import { beforeBulkUpdate, beforeUpdate } from './update';
-import { beforeBulkCreate, beforeCreate } from './create';
 import workaround from './workaround';
-export { enrichResults, beforeFind, beforeBulkUpdate, beforeUpdate, beforeBulkCreate, beforeCreate, workaround, };
+import { beforeCreate, beforeUpdate, beforeBulkCreate, beforeBulkUpdate } from './hooks';
+export { enrichResults, beforeFind, workaround, beforeCreate, beforeUpdate, beforeBulkCreate, beforeBulkUpdate, };

package/dist/hooks/index.js

@@ -3,16 +3,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.workaround = exports.beforeCreate = exports.beforeBulkCreate = exports.beforeUpdate = exports.beforeBulkUpdate = exports.beforeFind = exports.enrichResults = void 0;
+exports.beforeBulkUpdate = exports.beforeBulkCreate = exports.beforeUpdate = exports.beforeCreate = exports.workaround = exports.beforeFind = exports.enrichResults = void 0;
 const enrich_1 = __importDefault(require("./enrich"));
 exports.enrichResults = enrich_1.default;
 const find_1 = require("./find");
 Object.defineProperty(exports, "beforeFind", { enumerable: true, get: function () { return find_1.beforeFind; } });
-const update_1 = require("./update");
-Object.defineProperty(exports, "beforeBulkUpdate", { enumerable: true, get: function () { return update_1.beforeBulkUpdate; } });
-Object.defineProperty(exports, "beforeUpdate", { enumerable: true, get: function () { return update_1.beforeUpdate; } });
-const create_1 = require("./create");
-Object.defineProperty(exports, "beforeBulkCreate", { enumerable: true, get: function () { return create_1.beforeBulkCreate; } });
-Object.defineProperty(exports, "beforeCreate", { enumerable: true, get: function () { return create_1.beforeCreate; } });
 const workaround_1 = __importDefault(require("./workaround"));
 exports.workaround = workaround_1.default;
+const hooks_1 = require("./hooks");
+Object.defineProperty(exports, "beforeCreate", { enumerable: true, get: function () { return hooks_1.beforeCreate; } });
+Object.defineProperty(exports, "beforeUpdate", { enumerable: true, get: function () { return hooks_1.beforeUpdate; } });
+Object.defineProperty(exports, "beforeBulkCreate", { enumerable: true, get: function () { return hooks_1.beforeBulkCreate; } });
+Object.defineProperty(exports, "beforeBulkUpdate", { enumerable: true, get: function () { return hooks_1.beforeBulkUpdate; } });

package/dist/hooks/update.d.ts

@@ -1,4 +1,4 @@
-import type { ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions } from '../types';
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
  */
@@ -7,4 +7,4 @@ export declare const beforeBulkUpdate: (options: any) => void;
  * A hook to update the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export declare const beforeUpdate: (scopeAttributes: string[], modelOptions?: ModelOptions) => (instance: any, options: any) => Promise<void>;
+export declare const beforeUpdate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;