@autofleet/sadot 1.6.18-beta.2 → 1.6.18-beta.21

package/dist/hooks/hooks.cjs

@@ -0,0 +1,310 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../utils/logger/index.cjs');
+const require_index$1 = require('../utils/constants/index.cjs');
+const require_index$2 = require('../errors/index.cjs');
+const require_definition = require('../repository/definition.cjs');
+const require_validator = require('../repository/validator.cjs');
+const require_scopeAttributes = require('../utils/scopeAttributes.cjs');
+const require_updateInstanceValues = require('./utils/updateInstanceValues.cjs');
+let joi = require("joi");
+joi = require_rolldown_runtime.__toESM(joi);
+let _autofleet_errors = require("@autofleet/errors");
+let ajv = require("ajv");
+ajv = require_rolldown_runtime.__toESM(ajv);
+let ajv_formats = require("ajv-formats");
+ajv_formats = require_rolldown_runtime.__toESM(ajv_formats);
+let ajv_errors = require("ajv-errors");
+ajv_errors = require_rolldown_runtime.__toESM(ajv_errors);
+
+//#region src/hooks/hooks.ts
+const CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL = [
+	"id",
+	"schema",
+	"modelType",
+	"entityId",
+	"disabled"
+];
+const ajv$1 = new ajv.default({
+	allErrors: true,
+	strict: false,
+	strictTypes: false,
+	$data: true
+});
+(0, ajv_formats.default)(ajv$1);
+(0, ajv_errors.default)(ajv$1);
+/**
+* Helper function to manually copy object properties
+* This is more efficient for large objects and avoids excessive object creation
+*/
+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 (!instance.id || !instance.customFields || Object.keys(instance.customFields).length === 0) return instance.customFields || {};
+	try {
+		const currentCustomFields = await instance.constructor.findOne({
+			where: { id: instance.id },
+			attributes: ["customFields"],
+			transaction: options.transaction,
+			raw: true
+		});
+		if (currentCustomFields?.customFields) {
+			const completeFields = manualObjectCopy(currentCustomFields.customFields, instance.customFields);
+			require_index.default.debug("sadot - fetched complete custom fields for validation", {
+				fieldsCount: Object.keys(completeFields).length,
+				updateFieldsCount: Object.keys(instance.customFields).length
+			});
+			return completeFields;
+		}
+	} catch (error) {
+		require_index.default.error("sadot - error fetching complete model for validation", { error });
+	}
+	return instance.customFields || {};
+};
+const buildPreChangeState = (instance) => {
+	const beforeFull = { ...instance.dataValues };
+	(instance.changed?.() || []).forEach((key) => {
+		const prevVal = instance.previous?.(key);
+		if (prevVal !== void 0) beforeFull[key] = prevVal;
+	});
+	const prevCF = instance.previous?.("customFields");
+	if (prevCF !== void 0) beforeFull.customFields = prevCF;
+	return beforeFull;
+};
+const formatAjvErrors = (errors) => errors.reduce((acc, err) => {
+	const key = ((err.instancePath || "").split("/").filter(Boolean).join(".").replace(/^after\./, "") + (err.keyword === "required" ? `.${err.params?.missingProperty}` : "")).replace(/^\./, "") || "root";
+	acc[key] = err.message || "Invalid value";
+	return acc;
+}, {});
+/**
+* Validates the model using custom validators
+*/
+const validateModel = async (instance, options, scopeAttributes, modelOptions = {}, isCreate = false) => {
+	const modelType = instance.constructor.name;
+	require_index.default.debug("sadot - validating model", {
+		isCreate,
+		modelType
+	});
+	const identifiers = require_scopeAttributes.default(instance, scopeAttributes);
+	require_index.default.debug("sadot - identifiers", { identifiers });
+	if (!identifiers || Object.keys(identifiers).length === 0) {
+		require_index.default.debug("sadot - skipping validation: no identifiers");
+		return;
+	}
+	const entityId = Object.values(identifiers)[0];
+	require_index.default.debug("sadot - entityId", { entityId });
+	if (!entityId) {
+		require_index.default.debug("sadot - skipping validation: no entityId");
+		return;
+	}
+	let validatorsPromise;
+	let cacheKey;
+	if (options.transaction) {
+		options.transaction.validationsCache ??= /* @__PURE__ */ new Map();
+		cacheKey = `${modelType}-${entityId}`;
+		validatorsPromise = options.transaction.validationsCache.get(cacheKey);
+	}
+	if (!validatorsPromise) {
+		validatorsPromise = require_validator.findAllByModelType(modelType, entityId, {
+			transaction: options.transaction,
+			attributes: CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL,
+			modelOptions
+		});
+		if (options.transaction) options?.transaction?.validationsCache.set(cacheKey, validatorsPromise);
+	}
+	const validators = await validatorsPromise;
+	require_index.default.debug("sadot - validators found", { count: validators.length });
+	if (!validators.length) {
+		require_index.default.debug("sadot - skipping validation: no validators found");
+		return;
+	}
+	let originalValues = null;
+	if (!isCreate) originalValues = buildPreChangeState(instance);
+	const completeCustomFields = !isCreate ? await getCompleteCustomFields(instance, options) : instance.customFields || {};
+	for (const validator of validators) {
+		const { schema } = validator;
+		const typedSchema = schema;
+		require_index.default.debug("sadot - validating with schema", {
+			schema,
+			hasAfterProps: !!typedSchema.properties?.after,
+			hasBeforeProps: !!typedSchema.properties?.before
+		});
+		if (isCreate) {
+			if (typedSchema.properties?.after) {
+				const validateSchema = ajv$1.compile({
+					...schema,
+					properties: { after: typedSchema.properties.after }
+				});
+				if (!validateSchema(JSON.parse(JSON.stringify({ after: {
+					...instance.dataValues,
+					customFields: completeCustomFields
+				} })))) {
+					const errorDetails = validateSchema.errors?.map((err) => `${err.instancePath || ""} ${err.message || "Invalid value"}`).join(", ");
+					const formattedErrors = formatAjvErrors(validateSchema.errors);
+					throw new _autofleet_errors.BadRequest([/* @__PURE__ */ new Error(`Validation failed for ${modelType}: ${errorDetails}`)], void 0, { customError: formattedErrors });
+				}
+			}
+		} else {
+			const validateSchema = ajv$1.compile(typedSchema);
+			const afterObj = manualObjectCopy(instance.dataValues);
+			afterObj.customFields = completeCustomFields;
+			const payload = {
+				before: originalValues,
+				after: afterObj
+			};
+			const isValid = validateSchema(JSON.parse(JSON.stringify(payload)));
+			require_index.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 _autofleet_errors.BadRequest([/* @__PURE__ */ new Error(`Validation failed for ${modelType}: ${errorDetails}`)], void 0, { customError: formattedErrors });
+			}
+		}
+	}
+};
+const getFieldDefinitions = async ({ modelType, modelOptions, identifiers, options, instance, sadotOptions }) => {
+	const { include, useEntityIdFromInclude } = modelOptions;
+	if (sadotOptions.hasTypeId && instance?.typeId) return require_definition.findByModelTypeId(instance.typeId, {
+		withDisabled: false,
+		transaction: options.transaction,
+		entityIds: identifiers,
+		modelType,
+		modelOptions
+	});
+	const where = {
+		modelType,
+		disabled: false,
+		...!useEntityIdFromInclude && { entityId: identifiers }
+	};
+	return require_definition.findAll(where, {
+		withDisabled: false,
+		transaction: options.transaction,
+		include: include?.(identifiers)
+	});
+};
+const formatDates = (fieldDefinitions, instance) => {
+	(fieldDefinitions || []).forEach((fieldDefinition) => {
+		const { fieldType, name } = fieldDefinition;
+		if ([require_index$1.CustomFieldDefinitionType.DATE, require_index$1.CustomFieldDefinitionType.DATETIME].includes(fieldType)) {
+			const value = instance.customFields?.[name];
+			if (value) {
+				const { value: joiValue, error: validationError } = joi.default.date().validate(value);
+				if (validationError) throw new require_index$2.InvalidValueError(value, name, validationError);
+				instance.customFields[name] = joiValue.toISOString();
+			}
+		}
+	});
+};
+/**
+* Hook to handle validation and custom fields during creation
+*/
+const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
+	require_index.default.debug("sadot - before create hook");
+	const { fields } = options;
+	const modelType = instance.constructor.name;
+	const identifiers = require_scopeAttributes.default(instance, scopeAttributes);
+	const fieldDefinitions = await getFieldDefinitions({
+		modelType,
+		modelOptions,
+		identifiers,
+		options,
+		instance,
+		sadotOptions
+	});
+	const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, void 0].includes(def.defaultValue));
+	if (fieldsWithDefaultValue.length) {
+		instance.customFields ||= {};
+		fieldsWithDefaultValue.filter((def) => instance.customFields?.[def.name] === void 0).forEach(({ name, defaultValue }) => {
+			instance.customFields[name] = defaultValue;
+		});
+	}
+	let requiredFieldsNames;
+	if (sadotOptions.getRequiredCustomFields) requiredFieldsNames = await Promise.resolve(sadotOptions.getRequiredCustomFields(instance, fieldDefinitions, options));
+	else 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 require_index$2.MissingRequiredCustomFieldError(missingFields);
+	await validateModel(instance, options, scopeAttributes, modelOptions, true);
+	formatDates(fieldDefinitions, instance);
+	const customFieldsIdx = fields.indexOf("customFields");
+	if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) return;
+	await require_updateInstanceValues.default({
+		modelId: instance.id,
+		modelType,
+		identifiers,
+		customFields,
+		options: {
+			useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+			transaction: options.transaction,
+			modelOptions
+		}
+	});
+	fields.splice(customFieldsIdx, 1);
+};
+/**
+* Hook to handle validation and custom fields during update
+*/
+const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
+	require_index.default.debug("sadot - before update hook");
+	const { fields } = options;
+	const modelType = instance.constructor.name;
+	const identifiers = require_scopeAttributes.default(instance, scopeAttributes);
+	const fieldDefinitions = await getFieldDefinitions({
+		modelType,
+		modelOptions,
+		identifiers,
+		options,
+		instance,
+		sadotOptions
+	});
+	await validateModel(instance, options, scopeAttributes, modelOptions, false);
+	formatDates(fieldDefinitions, instance);
+	const customFieldsIdx = fields.indexOf("customFields");
+	if (customFieldsIdx > -1) {
+		const { customFields } = instance;
+		if (!Object.keys(customFields).length) return;
+		await require_updateInstanceValues.default({
+			modelId: instance.id,
+			modelType,
+			identifiers,
+			customFields,
+			options: {
+				useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+				transaction: options.transaction,
+				modelOptions
+			}
+		});
+		fields.splice(customFieldsIdx, 1);
+	}
+};
+/**
+* Hook to enable individual hooks for bulk create operations
+*/
+const beforeBulkCreate = (options) => {
+	options.individualHooks = true;
+};
+/**
+* Hook to enable individual hooks for bulk update operations
+*/
+const beforeBulkUpdate = (options) => {
+	options.individualHooks = true;
+};
+
+//#endregion
+exports.beforeBulkCreate = beforeBulkCreate;
+exports.beforeBulkUpdate = beforeBulkUpdate;
+exports.beforeCreate = beforeCreate;
+exports.beforeUpdate = beforeUpdate;

package/dist/hooks/hooks.js

@@ -0,0 +1,302 @@
+import logger_default from "../utils/logger/index.js";
+import { CustomFieldDefinitionType } from "../utils/constants/index.js";
+import { InvalidValueError, MissingRequiredCustomFieldError } from "../errors/index.js";
+import { findAll, findByModelTypeId } from "../repository/definition.js";
+import { findAllByModelType } from "../repository/validator.js";
+import scopeAttributes_default from "../utils/scopeAttributes.js";
+import updateInstanceValues_default from "./utils/updateInstanceValues.js";
+import Joi from "joi";
+import { BadRequest } from "@autofleet/errors";
+import Ajv from "ajv";
+import addFormats from "ajv-formats";
+import ajvErrors from "ajv-errors";
+
+//#region src/hooks/hooks.ts
+const CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL = [
+	"id",
+	"schema",
+	"modelType",
+	"entityId",
+	"disabled"
+];
+const ajv = new Ajv({
+	allErrors: true,
+	strict: false,
+	strictTypes: false,
+	$data: true
+});
+addFormats(ajv);
+ajvErrors(ajv);
+/**
+* Helper function to manually copy object properties
+* This is more efficient for large objects and avoids excessive object creation
+*/
+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 (!instance.id || !instance.customFields || Object.keys(instance.customFields).length === 0) return instance.customFields || {};
+	try {
+		const currentCustomFields = await instance.constructor.findOne({
+			where: { id: instance.id },
+			attributes: ["customFields"],
+			transaction: options.transaction,
+			raw: true
+		});
+		if (currentCustomFields?.customFields) {
+			const completeFields = manualObjectCopy(currentCustomFields.customFields, instance.customFields);
+			logger_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_default.error("sadot - error fetching complete model for validation", { error });
+	}
+	return instance.customFields || {};
+};
+const buildPreChangeState = (instance) => {
+	const beforeFull = { ...instance.dataValues };
+	(instance.changed?.() || []).forEach((key) => {
+		const prevVal = instance.previous?.(key);
+		if (prevVal !== void 0) beforeFull[key] = prevVal;
+	});
+	const prevCF = instance.previous?.("customFields");
+	if (prevCF !== void 0) beforeFull.customFields = prevCF;
+	return beforeFull;
+};
+const formatAjvErrors = (errors) => errors.reduce((acc, err) => {
+	const key = ((err.instancePath || "").split("/").filter(Boolean).join(".").replace(/^after\./, "") + (err.keyword === "required" ? `.${err.params?.missingProperty}` : "")).replace(/^\./, "") || "root";
+	acc[key] = err.message || "Invalid value";
+	return acc;
+}, {});
+/**
+* Validates the model using custom validators
+*/
+const validateModel = async (instance, options, scopeAttributes, modelOptions = {}, isCreate = false) => {
+	const modelType = instance.constructor.name;
+	logger_default.debug("sadot - validating model", {
+		isCreate,
+		modelType
+	});
+	const identifiers = scopeAttributes_default(instance, scopeAttributes);
+	logger_default.debug("sadot - identifiers", { identifiers });
+	if (!identifiers || Object.keys(identifiers).length === 0) {
+		logger_default.debug("sadot - skipping validation: no identifiers");
+		return;
+	}
+	const entityId = Object.values(identifiers)[0];
+	logger_default.debug("sadot - entityId", { entityId });
+	if (!entityId) {
+		logger_default.debug("sadot - skipping validation: no entityId");
+		return;
+	}
+	let validatorsPromise;
+	let cacheKey;
+	if (options.transaction) {
+		options.transaction.validationsCache ??= /* @__PURE__ */ new Map();
+		cacheKey = `${modelType}-${entityId}`;
+		validatorsPromise = options.transaction.validationsCache.get(cacheKey);
+	}
+	if (!validatorsPromise) {
+		validatorsPromise = findAllByModelType(modelType, entityId, {
+			transaction: options.transaction,
+			attributes: CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL,
+			modelOptions
+		});
+		if (options.transaction) options?.transaction?.validationsCache.set(cacheKey, validatorsPromise);
+	}
+	const validators = await validatorsPromise;
+	logger_default.debug("sadot - validators found", { count: validators.length });
+	if (!validators.length) {
+		logger_default.debug("sadot - skipping validation: no validators found");
+		return;
+	}
+	let originalValues = null;
+	if (!isCreate) originalValues = buildPreChangeState(instance);
+	const completeCustomFields = !isCreate ? await getCompleteCustomFields(instance, options) : instance.customFields || {};
+	for (const validator of validators) {
+		const { schema } = validator;
+		const typedSchema = schema;
+		logger_default.debug("sadot - validating with schema", {
+			schema,
+			hasAfterProps: !!typedSchema.properties?.after,
+			hasBeforeProps: !!typedSchema.properties?.before
+		});
+		if (isCreate) {
+			if (typedSchema.properties?.after) {
+				const validateSchema = ajv.compile({
+					...schema,
+					properties: { after: typedSchema.properties.after }
+				});
+				if (!validateSchema(JSON.parse(JSON.stringify({ after: {
+					...instance.dataValues,
+					customFields: completeCustomFields
+				} })))) {
+					const errorDetails = validateSchema.errors?.map((err) => `${err.instancePath || ""} ${err.message || "Invalid value"}`).join(", ");
+					const formattedErrors = formatAjvErrors(validateSchema.errors);
+					throw new BadRequest([/* @__PURE__ */ new Error(`Validation failed for ${modelType}: ${errorDetails}`)], void 0, { customError: formattedErrors });
+				}
+			}
+		} else {
+			const validateSchema = ajv.compile(typedSchema);
+			const afterObj = manualObjectCopy(instance.dataValues);
+			afterObj.customFields = completeCustomFields;
+			const payload = {
+				before: originalValues,
+				after: afterObj
+			};
+			const isValid = validateSchema(JSON.parse(JSON.stringify(payload)));
+			logger_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 BadRequest([/* @__PURE__ */ new Error(`Validation failed for ${modelType}: ${errorDetails}`)], void 0, { customError: formattedErrors });
+			}
+		}
+	}
+};
+const getFieldDefinitions = async ({ modelType, modelOptions, identifiers, options, instance, sadotOptions }) => {
+	const { include, useEntityIdFromInclude } = modelOptions;
+	if (sadotOptions.hasTypeId && instance?.typeId) return findByModelTypeId(instance.typeId, {
+		withDisabled: false,
+		transaction: options.transaction,
+		entityIds: identifiers,
+		modelType,
+		modelOptions
+	});
+	const where = {
+		modelType,
+		disabled: false,
+		...!useEntityIdFromInclude && { entityId: identifiers }
+	};
+	return findAll(where, {
+		withDisabled: false,
+		transaction: options.transaction,
+		include: include?.(identifiers)
+	});
+};
+const formatDates = (fieldDefinitions, instance) => {
+	(fieldDefinitions || []).forEach((fieldDefinition) => {
+		const { fieldType, name } = fieldDefinition;
+		if ([CustomFieldDefinitionType.DATE, CustomFieldDefinitionType.DATETIME].includes(fieldType)) {
+			const value = instance.customFields?.[name];
+			if (value) {
+				const { value: joiValue, error: validationError } = Joi.date().validate(value);
+				if (validationError) throw new InvalidValueError(value, name, validationError);
+				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_default.debug("sadot - before create hook");
+	const { fields } = options;
+	const modelType = instance.constructor.name;
+	const identifiers = scopeAttributes_default(instance, scopeAttributes);
+	const fieldDefinitions = await getFieldDefinitions({
+		modelType,
+		modelOptions,
+		identifiers,
+		options,
+		instance,
+		sadotOptions
+	});
+	const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, void 0].includes(def.defaultValue));
+	if (fieldsWithDefaultValue.length) {
+		instance.customFields ||= {};
+		fieldsWithDefaultValue.filter((def) => instance.customFields?.[def.name] === void 0).forEach(({ name, defaultValue }) => {
+			instance.customFields[name] = defaultValue;
+		});
+	}
+	let requiredFieldsNames;
+	if (sadotOptions.getRequiredCustomFields) requiredFieldsNames = await Promise.resolve(sadotOptions.getRequiredCustomFields(instance, fieldDefinitions, options));
+	else 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 MissingRequiredCustomFieldError(missingFields);
+	await validateModel(instance, options, scopeAttributes, modelOptions, true);
+	formatDates(fieldDefinitions, instance);
+	const customFieldsIdx = fields.indexOf("customFields");
+	if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) return;
+	await updateInstanceValues_default({
+		modelId: instance.id,
+		modelType,
+		identifiers,
+		customFields,
+		options: {
+			useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+			transaction: options.transaction,
+			modelOptions
+		}
+	});
+	fields.splice(customFieldsIdx, 1);
+};
+/**
+* Hook to handle validation and custom fields during update
+*/
+const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
+	logger_default.debug("sadot - before update hook");
+	const { fields } = options;
+	const modelType = instance.constructor.name;
+	const identifiers = scopeAttributes_default(instance, scopeAttributes);
+	const fieldDefinitions = await getFieldDefinitions({
+		modelType,
+		modelOptions,
+		identifiers,
+		options,
+		instance,
+		sadotOptions
+	});
+	await validateModel(instance, options, scopeAttributes, modelOptions, false);
+	formatDates(fieldDefinitions, instance);
+	const customFieldsIdx = fields.indexOf("customFields");
+	if (customFieldsIdx > -1) {
+		const { customFields } = instance;
+		if (!Object.keys(customFields).length) return;
+		await updateInstanceValues_default({
+			modelId: instance.id,
+			modelType,
+			identifiers,
+			customFields,
+			options: {
+				useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+				transaction: options.transaction,
+				modelOptions
+			}
+		});
+		fields.splice(customFieldsIdx, 1);
+	}
+};
+/**
+* Hook to enable individual hooks for bulk create operations
+*/
+const beforeBulkCreate = (options) => {
+	options.individualHooks = true;
+};
+/**
+* Hook to enable individual hooks for bulk update operations
+*/
+const beforeBulkUpdate = (options) => {
+	options.individualHooks = true;
+};
+
+//#endregion
+export { beforeBulkCreate, beforeBulkUpdate, beforeCreate, beforeUpdate };

package/dist/hooks/index.cjs

@@ -0,0 +1,3 @@
+const require_enrich = require('./enrich.cjs');
+const require_find = require('./find.cjs');
+const require_hooks = require('./hooks.cjs');

package/dist/hooks/index.js

@@ -0,0 +1,5 @@
+import enrich_default from "./enrich.js";
+import { beforeFind } from "./find.js";
+import { beforeBulkCreate, beforeBulkUpdate, beforeCreate, beforeUpdate } from "./hooks.js";
+
+export {  };

package/dist/hooks/utils/updateInstanceValues.cjs

@@ -0,0 +1,27 @@
+const require_value = require('../../repository/value.cjs');
+const require_entries = require('../../repository/entries.cjs');
+
+//#region src/hooks/utils/updateInstanceValues.ts
+const updateInstanceValues = async ({ modelId, modelType, identifiers, customFields, options = {
+	modelOptions: {},
+	useCustomFieldsEntries: false
+} }) => {
+	await require_value.updateValues(modelType, modelId, identifiers, customFields, {
+		...options,
+		modelOptions: options.modelOptions ?? {}
+	});
+	if (!options?.useCustomFieldsEntries) return;
+	const { dataValues: { customFields: oldCustomFields } } = await require_entries.findEntriesByModelId(modelId, options) ?? { dataValues: {} };
+	const newCustomFields = {
+		...oldCustomFields,
+		...customFields
+	};
+	await require_entries.updateEntries(modelId, modelType, newCustomFields, identifiers, {
+		...options,
+		modelOptions: options.modelOptions ?? {}
+	});
+};
+var updateInstanceValues_default = updateInstanceValues;
+
+//#endregion
+exports.default = updateInstanceValues_default;

package/dist/hooks/utils/updateInstanceValues.js

@@ -0,0 +1,27 @@
+import { updateValues } from "../../repository/value.js";
+import { findEntriesByModelId, updateEntries } from "../../repository/entries.js";
+
+//#region src/hooks/utils/updateInstanceValues.ts
+const updateInstanceValues = async ({ modelId, modelType, identifiers, customFields, options = {
+	modelOptions: {},
+	useCustomFieldsEntries: false
+} }) => {
+	await updateValues(modelType, modelId, identifiers, customFields, {
+		...options,
+		modelOptions: options.modelOptions ?? {}
+	});
+	if (!options?.useCustomFieldsEntries) return;
+	const { dataValues: { customFields: oldCustomFields } } = await findEntriesByModelId(modelId, options) ?? { dataValues: {} };
+	const newCustomFields = {
+		...oldCustomFields,
+		...customFields
+	};
+	await updateEntries(modelId, modelType, newCustomFields, identifiers, {
+		...options,
+		modelOptions: options.modelOptions ?? {}
+	});
+};
+var updateInstanceValues_default = updateInstanceValues;
+
+//#endregion
+export { updateInstanceValues_default as default };