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

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

@@ -0,0 +1,23 @@
+import { customFields } from "@autofleet/common-types";
+
+//#region src/utils/constants/index.d.ts
+declare const supportedEntities: readonly ["businessModelId", "fleetId", "demandSourceId"];
+/**
+* Supported custom field types
+*/
+declare enum CustomFieldDefinitionType {
+  NUMBER = "number",
+  BOOLEAN = "boolean",
+  DATE = "date",
+  DATETIME = "datetime",
+  TEXT = "text",
+  IMAGE = "image",
+  SELECT = "select",
+  STATUS = "status",
+  FILE = "file",
+  MULTI_SELECT_STATUS = "multi-select-status",
+  MULTI_SELECT_DROPDOWN = "multi-select-dropdown",
+}
+declare const CUSTOM_FIELDS_FILTER_SCOPE: typeof customFields.CUSTOM_FIELDS_FILTER_SCOPE;
+//#endregion
+export { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinitionType, supportedEntities };

package/dist/utils/constants/index.js

@@ -0,0 +1,29 @@
+import { customFields } from "@autofleet/common-types";
+
+//#region src/utils/constants/index.ts
+const supportedEntities = [
+	"businessModelId",
+	"fleetId",
+	"demandSourceId"
+];
+/**
+* Supported custom field types
+*/
+let CustomFieldDefinitionType = /* @__PURE__ */ function(CustomFieldDefinitionType$1) {
+	CustomFieldDefinitionType$1["NUMBER"] = "number";
+	CustomFieldDefinitionType$1["BOOLEAN"] = "boolean";
+	CustomFieldDefinitionType$1["DATE"] = "date";
+	CustomFieldDefinitionType$1["DATETIME"] = "datetime";
+	CustomFieldDefinitionType$1["TEXT"] = "text";
+	CustomFieldDefinitionType$1["IMAGE"] = "image";
+	CustomFieldDefinitionType$1["SELECT"] = "select";
+	CustomFieldDefinitionType$1["STATUS"] = "status";
+	CustomFieldDefinitionType$1["FILE"] = "file";
+	CustomFieldDefinitionType$1["MULTI_SELECT_STATUS"] = "multi-select-status";
+	CustomFieldDefinitionType$1["MULTI_SELECT_DROPDOWN"] = "multi-select-dropdown";
+	return CustomFieldDefinitionType$1;
+}({});
+const CUSTOM_FIELDS_FILTER_SCOPE = customFields.CUSTOM_FIELDS_FILTER_SCOPE;
+
+//#endregion
+export { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinitionType, supportedEntities };

package/dist/utils/db/index.cjs

@@ -0,0 +1,15 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let sequelize = require("sequelize");
+let sequelize_typescript = require("sequelize-typescript");
+
+//#region src/utils/db/index.ts
+var db_default = (databaseConfig) => {
+	const config = databaseConfig[process.env.NODE_ENV || "test"];
+	let sequelize$1;
+	if (config.use_env_variable) sequelize$1 = new sequelize_typescript.Sequelize(process.env[config.use_env_variable], config);
+	else sequelize$1 = new sequelize_typescript.Sequelize(config.database, config.username, config.password, config);
+	return sequelize$1;
+};
+
+//#endregion
+exports.default = db_default;

package/dist/utils/db/index.js

@@ -0,0 +1,14 @@
+import { QueryTypes } from "sequelize";
+import { Sequelize } from "sequelize-typescript";
+
+//#region src/utils/db/index.ts
+var db_default = (databaseConfig) => {
+	const config = databaseConfig[process.env.NODE_ENV || "test"];
+	let sequelize;
+	if (config.use_env_variable) sequelize = new Sequelize(process.env[config.use_env_variable], config);
+	else sequelize = new Sequelize(config.database, config.username, config.password, config);
+	return sequelize;
+};
+
+//#endregion
+export { db_default as default };

package/dist/utils/helpers/index.cjs

@@ -0,0 +1,23 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../constants/index.cjs');
+let sequelize = require("sequelize");
+let sequelize_typescript = require("sequelize-typescript");
+let node_crypto = require("node:crypto");
+
+//#region src/utils/helpers/index.ts
+const generateRandomString = (length = 5) => {
+	const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+	return Array.from({ length }, () => characters.charAt((0, node_crypto.randomInt)(52))).join("");
+};
+const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [require_index.CustomFieldDefinitionType.DATETIME, require_index.CustomFieldDefinitionType.DATE]) => {
+	const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(",");
+	const subQuery = `SELECT cv.model_id FROM "custom_field_values" AS cv INNER JOIN custom_field_definitions AS cd ON cv.custom_field_definition_id = cd.id AND cd.entity_id = '${entityId}' AND cd.model_type = '${model.name}' AND cd.deleted_at IS NULL` + (excludedTypesString ? ` AND cd.field_type NOT IN (${excludedTypesString})` : "") + " WHERE cv.deleted_at IS NULL AND CAST(cv.value AS TEXT) ILIKE :searchTerm";
+	return {
+		where: { id: { [sequelize.Op.in]: sequelize_typescript.Sequelize.literal(`(${subQuery})`) } },
+		replacements: { searchTerm: `%${searchTerm}%` }
+	};
+};
+
+//#endregion
+exports.generateCustomFieldSearchQueryPayload = generateCustomFieldSearchQueryPayload;
+exports.generateRandomString = generateRandomString;

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

@@ -0,0 +1,30 @@
+import { CustomFieldDefinitionType } from "../constants/index.cjs";
+import { ModelStatic } from "sequelize-typescript";
+import { BindOrReplacements, WhereOptions } from "sequelize";
+
+//#region src/utils/helpers/index.d.ts
+
+/**
+* Builds a WHERE clause and replacements for free-text search by custom fields.
+*
+* This function constructs a WHERE clause and replacement bindings that allow searching
+* for a given term within custom fields associated with a specific model type and entity ID.
+* The WHERE clause and replacements are designed to be added to the main query.
+*
+* @param {string} searchTerm - The term to search for within custom fields.
+* @param {ModelStatic} model - The Sequelize model representing the entity type to search for.
+* @param {string} entityId - The entity ID to filter the custom fields by.
+* @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.
+*/
+interface CustomFieldsSearchPayload {
+  where: WhereOptions;
+  replacements: BindOrReplacements;
+}
+declare const generateRandomString: (length?: number) => string;
+declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;
+//#endregion
+export { generateCustomFieldSearchQueryPayload, generateRandomString };

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

@@ -0,0 +1,30 @@
+import { CustomFieldDefinitionType } from "../constants/index.js";
+import { BindOrReplacements, WhereOptions } from "sequelize";
+import { ModelStatic } from "sequelize-typescript";
+
+//#region src/utils/helpers/index.d.ts
+
+/**
+* Builds a WHERE clause and replacements for free-text search by custom fields.
+*
+* This function constructs a WHERE clause and replacement bindings that allow searching
+* for a given term within custom fields associated with a specific model type and entity ID.
+* The WHERE clause and replacements are designed to be added to the main query.
+*
+* @param {string} searchTerm - The term to search for within custom fields.
+* @param {ModelStatic} model - The Sequelize model representing the entity type to search for.
+* @param {string} entityId - The entity ID to filter the custom fields by.
+* @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.
+*/
+interface CustomFieldsSearchPayload {
+  where: WhereOptions;
+  replacements: BindOrReplacements;
+}
+declare const generateRandomString: (length?: number) => string;
+declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;
+//#endregion
+export { generateCustomFieldSearchQueryPayload, generateRandomString };

package/dist/utils/helpers/index.js

@@ -0,0 +1,21 @@
+import { CustomFieldDefinitionType } from "../constants/index.js";
+import { Op } from "sequelize";
+import { Sequelize } from "sequelize-typescript";
+import { randomInt } from "node:crypto";
+
+//#region src/utils/helpers/index.ts
+const generateRandomString = (length = 5) => {
+	const characters = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
+	return Array.from({ length }, () => characters.charAt(randomInt(52))).join("");
+};
+const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [CustomFieldDefinitionType.DATETIME, CustomFieldDefinitionType.DATE]) => {
+	const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(",");
+	const subQuery = `SELECT cv.model_id FROM "custom_field_values" AS cv INNER JOIN custom_field_definitions AS cd ON cv.custom_field_definition_id = cd.id AND cd.entity_id = '${entityId}' AND cd.model_type = '${model.name}' AND cd.deleted_at IS NULL` + (excludedTypesString ? ` AND cd.field_type NOT IN (${excludedTypesString})` : "") + " WHERE cv.deleted_at IS NULL AND CAST(cv.value AS TEXT) ILIKE :searchTerm";
+	return {
+		where: { id: { [Op.in]: Sequelize.literal(`(${subQuery})`) } },
+		replacements: { searchTerm: `%${searchTerm}%` }
+	};
+};
+
+//#endregion
+export { generateCustomFieldSearchQueryPayload, generateRandomString };

package/dist/utils/init.cjs

@@ -0,0 +1,115 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('./logger/index.cjs');
+const require_CustomFieldValue = require('../models/CustomFieldValue.cjs');
+const require_CustomFieldDefinition = require('../models/CustomFieldDefinition.cjs');
+const require_CustomValidator = require('../models/CustomValidator.cjs');
+require('../models/index.cjs');
+const require_enrich = require('../hooks/enrich.cjs');
+const require_find = require('../hooks/find.cjs');
+const require_hooks = require('../hooks/hooks.cjs');
+require('../hooks/index.cjs');
+const require_filter = require('../scopes/filter.cjs');
+require('../scopes/index.cjs');
+let sequelize = require("sequelize");
+let _autofleet_common_types = require("@autofleet/common-types");
+let _autofleet_common_types_lib_custom_fields = require("@autofleet/common-types/lib/custom-fields");
+
+//#region src/utils/init.ts
+const { CUSTOM_FIELDS_FILTER_SCOPE } = _autofleet_common_types.customFields;
+const addHooks = (models, getModel, sadotOptions = { useCustomFieldsEntries: false }) => {
+	models.forEach(async ({ name, scopeAttributes, modelOptions, hasTypeId, getRequiredCustomFields }) => {
+		try {
+			const model = getModel(name);
+			if (!model) {
+				require_index.default.warn("sadot - tried to addHooks to a model that does not exist yet", {
+					name,
+					scopeAttributes
+				});
+				return;
+			}
+			model.rawAttributes.customFields = { type: sequelize.DataTypes.VIRTUAL };
+			model.refreshAttributes();
+			const enrichOptions = {
+				...sadotOptions,
+				hasTypeId: hasTypeId ?? false,
+				getRequiredCustomFields
+			};
+			model.addHook("beforeFind", "sadot-beforeFind", require_find.beforeFind(scopeAttributes));
+			model.addHook("beforeBulkCreate", "sadot-beforeBulkCreate", require_hooks.beforeBulkCreate);
+			model.addHook("beforeBulkUpdate", "sadot-beforeBulkUpdate", require_hooks.beforeBulkUpdate);
+			model.addHook("beforeCreate", "sadot-beforeCreate", require_hooks.beforeCreate(scopeAttributes, modelOptions, enrichOptions));
+			model.addHook("beforeUpdate", "sadot-beforeUpdate", require_hooks.beforeUpdate(scopeAttributes, modelOptions, enrichOptions));
+			model.addHook("afterFind", "sadot-afterFind", require_enrich.default(name, scopeAttributes, "afterFind", modelOptions, enrichOptions));
+			model.addHook("afterUpdate", "sadot-afterUpdate", require_enrich.default(name, scopeAttributes, void 0, modelOptions, enrichOptions));
+			model.addHook("afterCreate", "sadot-afterCreate", require_enrich.default(name, scopeAttributes, void 0, modelOptions, enrichOptions));
+		} catch (e) {
+			require_index.default.error(`Could not add custom fields hook to model ${name}. `, e);
+		}
+	});
+};
+const removeHooks = (models, getModel) => {
+	models.forEach(async ({ name }) => {
+		try {
+			const model = getModel(name);
+			if (!model) return;
+			if (model.rawAttributes.customFields) {
+				delete model.rawAttributes.customFields;
+				model.refreshAttributes();
+			}
+			model.removeHook("beforeFind", "sadot-beforeFind");
+			model.removeHook("beforeBulkCreate", "sadot-beforeBulkCreate");
+			model.removeHook("beforeBulkUpdate", "sadot-beforeBulkUpdate");
+			model.removeHook("beforeCreate", "sadot-beforeCreate");
+			model.removeHook("beforeUpdate", "sadot-beforeUpdate");
+			model.removeHook("afterFind", "sadot-afterFind");
+			model.removeHook("afterUpdate", "sadot-afterUpdate");
+		} catch (e) {
+			require_index.default.error(`Could not add custom fields hook to model ${name}. `, e);
+		}
+	});
+};
+/**
+*  Necessary associations for the {@link customFieldsFilterScope} scope
+*/
+const addAssociations = (model, modelName, options) => {
+	if (options?.useCustomFieldsEntries) return;
+	model.hasMany(require_CustomFieldValue.default, {
+		foreignKey: "modelId",
+		as: "customFieldValue"
+	});
+	require_CustomFieldValue.default.belongsTo(model, {
+		foreignKey: "modelId",
+		as: modelName
+	});
+};
+const addScopes = (models, getModel, options = { useCustomFieldsEntries: false }) => {
+	models.forEach(async ({ name, scopeAttributes }) => {
+		try {
+			const model = getModel(name);
+			if (!model) {
+				require_index.default.warn("sadot - tried to addScopes to a model that does not exist yet", {
+					name,
+					scopeAttributes
+				});
+				return;
+			}
+			addAssociations(model, name, options);
+			model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, require_filter.customFieldsFilterScope(name, options));
+			model.addScope(_autofleet_common_types_lib_custom_fields.CUSTOM_FIELDS_SORT_SCOPE, require_filter.customFieldsSortScope(name, options));
+		} catch (e) {
+			require_index.default.error(`Could not add custom fields scopes to model ${name}. `, e);
+		}
+	});
+};
+const applyCustomAssociation = (models) => {
+	models.forEach(({ modelOptions }) => {
+		modelOptions?.customAssociation?.(require_CustomFieldDefinition.default);
+		modelOptions?.customAssociation?.(require_CustomValidator.default);
+	});
+};
+
+//#endregion
+exports.addHooks = addHooks;
+exports.addScopes = addScopes;
+exports.applyCustomAssociation = applyCustomAssociation;
+exports.removeHooks = removeHooks;

package/dist/utils/init.js

@@ -0,0 +1,111 @@
+import logger_default from "./logger/index.js";
+import CustomFieldValue_default from "../models/CustomFieldValue.js";
+import CustomFieldDefinition_default from "../models/CustomFieldDefinition.js";
+import CustomValidator_default from "../models/CustomValidator.js";
+import "../models/index.js";
+import enrich_default from "../hooks/enrich.js";
+import { beforeFind } from "../hooks/find.js";
+import { beforeBulkCreate, beforeBulkUpdate, beforeCreate, beforeUpdate } from "../hooks/hooks.js";
+import "../hooks/index.js";
+import { customFieldsFilterScope, customFieldsSortScope } from "../scopes/filter.js";
+import "../scopes/index.js";
+import { DataTypes } from "sequelize";
+import { customFields } from "@autofleet/common-types";
+import { CUSTOM_FIELDS_SORT_SCOPE } from "@autofleet/common-types/lib/custom-fields";
+
+//#region src/utils/init.ts
+const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
+const addHooks = (models, getModel, sadotOptions = { useCustomFieldsEntries: false }) => {
+	models.forEach(async ({ name, scopeAttributes, modelOptions, hasTypeId, getRequiredCustomFields }) => {
+		try {
+			const model = getModel(name);
+			if (!model) {
+				logger_default.warn("sadot - tried to addHooks to a model that does not exist yet", {
+					name,
+					scopeAttributes
+				});
+				return;
+			}
+			model.rawAttributes.customFields = { type: DataTypes.VIRTUAL };
+			model.refreshAttributes();
+			const enrichOptions = {
+				...sadotOptions,
+				hasTypeId: hasTypeId ?? false,
+				getRequiredCustomFields
+			};
+			model.addHook("beforeFind", "sadot-beforeFind", beforeFind(scopeAttributes));
+			model.addHook("beforeBulkCreate", "sadot-beforeBulkCreate", beforeBulkCreate);
+			model.addHook("beforeBulkUpdate", "sadot-beforeBulkUpdate", beforeBulkUpdate);
+			model.addHook("beforeCreate", "sadot-beforeCreate", beforeCreate(scopeAttributes, modelOptions, enrichOptions));
+			model.addHook("beforeUpdate", "sadot-beforeUpdate", beforeUpdate(scopeAttributes, modelOptions, enrichOptions));
+			model.addHook("afterFind", "sadot-afterFind", enrich_default(name, scopeAttributes, "afterFind", modelOptions, enrichOptions));
+			model.addHook("afterUpdate", "sadot-afterUpdate", enrich_default(name, scopeAttributes, void 0, modelOptions, enrichOptions));
+			model.addHook("afterCreate", "sadot-afterCreate", enrich_default(name, scopeAttributes, void 0, modelOptions, enrichOptions));
+		} catch (e) {
+			logger_default.error(`Could not add custom fields hook to model ${name}. `, e);
+		}
+	});
+};
+const removeHooks = (models, getModel) => {
+	models.forEach(async ({ name }) => {
+		try {
+			const model = getModel(name);
+			if (!model) return;
+			if (model.rawAttributes.customFields) {
+				delete model.rawAttributes.customFields;
+				model.refreshAttributes();
+			}
+			model.removeHook("beforeFind", "sadot-beforeFind");
+			model.removeHook("beforeBulkCreate", "sadot-beforeBulkCreate");
+			model.removeHook("beforeBulkUpdate", "sadot-beforeBulkUpdate");
+			model.removeHook("beforeCreate", "sadot-beforeCreate");
+			model.removeHook("beforeUpdate", "sadot-beforeUpdate");
+			model.removeHook("afterFind", "sadot-afterFind");
+			model.removeHook("afterUpdate", "sadot-afterUpdate");
+		} catch (e) {
+			logger_default.error(`Could not add custom fields hook to model ${name}. `, e);
+		}
+	});
+};
+/**
+*  Necessary associations for the {@link customFieldsFilterScope} scope
+*/
+const addAssociations = (model, modelName, options) => {
+	if (options?.useCustomFieldsEntries) return;
+	model.hasMany(CustomFieldValue_default, {
+		foreignKey: "modelId",
+		as: "customFieldValue"
+	});
+	CustomFieldValue_default.belongsTo(model, {
+		foreignKey: "modelId",
+		as: modelName
+	});
+};
+const addScopes = (models, getModel, options = { useCustomFieldsEntries: false }) => {
+	models.forEach(async ({ name, scopeAttributes }) => {
+		try {
+			const model = getModel(name);
+			if (!model) {
+				logger_default.warn("sadot - tried to addScopes to a model that does not exist yet", {
+					name,
+					scopeAttributes
+				});
+				return;
+			}
+			addAssociations(model, name, options);
+			model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, customFieldsFilterScope(name, options));
+			model.addScope(CUSTOM_FIELDS_SORT_SCOPE, customFieldsSortScope(name, options));
+		} catch (e) {
+			logger_default.error(`Could not add custom fields scopes to model ${name}. `, e);
+		}
+	});
+};
+const applyCustomAssociation = (models) => {
+	models.forEach(({ modelOptions }) => {
+		modelOptions?.customAssociation?.(CustomFieldDefinition_default);
+		modelOptions?.customAssociation?.(CustomValidator_default);
+	});
+};
+
+//#endregion
+export { addHooks, addScopes, applyCustomAssociation, removeHooks };

package/dist/utils/logger/index.cjs

@@ -0,0 +1,15 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let _autofleet_zehut = require("@autofleet/zehut");
+let _autofleet_logger = require("@autofleet/logger");
+_autofleet_logger = require_rolldown_runtime.__toESM(_autofleet_logger);
+
+//#region src/utils/logger/index.ts
+const logger = (0, _autofleet_logger.default)();
+function tryAddingTraceIdMiddleware() {
+	logger.addContextMiddleware(() => ({ traceId: _autofleet_zehut.outbreak.getCurrentContextTraceId() }));
+}
+var logger_default = logger;
+
+//#endregion
+exports.default = logger_default;
+exports.tryAddingTraceIdMiddleware = tryAddingTraceIdMiddleware;

package/dist/utils/logger/index.js

@@ -0,0 +1,12 @@
+import { outbreak } from "@autofleet/zehut";
+import Logger from "@autofleet/logger";
+
+//#region src/utils/logger/index.ts
+const logger = Logger();
+function tryAddingTraceIdMiddleware() {
+	logger.addContextMiddleware(() => ({ traceId: outbreak.getCurrentContextTraceId() }));
+}
+var logger_default = logger;
+
+//#endregion
+export { logger_default as default, tryAddingTraceIdMiddleware };

package/dist/utils/scopeAttributes.cjs

@@ -0,0 +1,12 @@
+
+//#region src/utils/scopeAttributes.ts
+const mapAttributeToInstance = (scopeAttributes, instance) => scopeAttributes.map((attr) => instance[attr]);
+const applyScopeToInstance = (instance, scopeAttributes) => {
+	const uniqueAttributes = Array.from(new Set(scopeAttributes));
+	if (Array.isArray(instance)) return instance.flatMap((ins) => mapAttributeToInstance(uniqueAttributes, ins));
+	return mapAttributeToInstance(uniqueAttributes, instance);
+};
+var scopeAttributes_default = applyScopeToInstance;
+
+//#endregion
+exports.default = scopeAttributes_default;

package/dist/utils/scopeAttributes.js

@@ -0,0 +1,11 @@
+//#region src/utils/scopeAttributes.ts
+const mapAttributeToInstance = (scopeAttributes, instance) => scopeAttributes.map((attr) => instance[attr]);
+const applyScopeToInstance = (instance, scopeAttributes) => {
+	const uniqueAttributes = Array.from(new Set(scopeAttributes));
+	if (Array.isArray(instance)) return instance.flatMap((ins) => mapAttributeToInstance(uniqueAttributes, ins));
+	return mapAttributeToInstance(uniqueAttributes, instance);
+};
+var scopeAttributes_default = applyScopeToInstance;
+
+//#endregion
+export { scopeAttributes_default as default };

package/dist/utils/validations/index.cjs

@@ -0,0 +1,34 @@
+const require_index = require('./validators/index.cjs');
+const require_index$1 = require('../../errors/index.cjs');
+
+//#region src/utils/validations/index.ts
+const validateFieldType = (type) => Object.keys(require_index.validators).includes(type);
+const validateValue = (value, valueType, validation) => {
+	const validator = require_index.validators[valueType];
+	return validator(value, validation);
+	/** TODO: Add validation for required fields
+	* @example
+	* if (validations.required && !value) {
+	*  return false;
+	* }
+	*/
+};
+const validateInstanceCustomFieldEntries = (instance, definitionsByName, _validateValue = validateValue) => {
+	const validationErrors = Object.entries(instance.customFields).map(([customFieldName, value]) => {
+		if (value === null) return null;
+		const { validation, fieldType } = definitionsByName[customFieldName];
+		const result = _validateValue(value, fieldType, validation);
+		if (result?.error) return {
+			joiValidationError: result.error,
+			fieldDefinitionName: customFieldName,
+			value
+		};
+		return null;
+	}).filter((result) => !!result);
+	if (validationErrors?.length) throw new require_index$1.InvalidEntriesError(instance.modelId, validationErrors);
+};
+
+//#endregion
+exports.validateFieldType = validateFieldType;
+exports.validateInstanceCustomFieldEntries = validateInstanceCustomFieldEntries;
+exports.validateValue = validateValue;

package/dist/utils/validations/index.js

@@ -0,0 +1,32 @@
+import { validators } from "./validators/index.js";
+import { InvalidEntriesError } from "../../errors/index.js";
+
+//#region src/utils/validations/index.ts
+const validateFieldType = (type) => Object.keys(validators).includes(type);
+const validateValue = (value, valueType, validation) => {
+	const validator = validators[valueType];
+	return validator(value, validation);
+	/** TODO: Add validation for required fields
+	* @example
+	* if (validations.required && !value) {
+	*  return false;
+	* }
+	*/
+};
+const validateInstanceCustomFieldEntries = (instance, definitionsByName, _validateValue = validateValue) => {
+	const validationErrors = Object.entries(instance.customFields).map(([customFieldName, value]) => {
+		if (value === null) return null;
+		const { validation, fieldType } = definitionsByName[customFieldName];
+		const result = _validateValue(value, fieldType, validation);
+		if (result?.error) return {
+			joiValidationError: result.error,
+			fieldDefinitionName: customFieldName,
+			value
+		};
+		return null;
+	}).filter((result) => !!result);
+	if (validationErrors?.length) throw new InvalidEntriesError(instance.modelId, validationErrors);
+};
+
+//#endregion
+export { validateFieldType, validateInstanceCustomFieldEntries, validateValue };

package/dist/utils/validations/schema/custom-fields.cjs

@@ -0,0 +1,9 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+let joi = require("joi");
+joi = require_rolldown_runtime.__toESM(joi);
+
+//#region src/utils/validations/schema/custom-fields.ts
+const CustomFieldsSchema = joi.default.object().pattern(joi.default.string(), joi.default.any());
+
+//#endregion
+exports.CustomFieldsSchema = CustomFieldsSchema;

package/dist/utils/validations/schema/custom-fields.d.cts

@@ -0,0 +1,6 @@
+import Joi from "joi";
+
+//#region src/utils/validations/schema/custom-fields.d.ts
+declare const CustomFieldsSchema: Joi.ObjectSchema<Record<string, any>>;
+//#endregion
+export { CustomFieldsSchema };

package/dist/utils/validations/schema/custom-fields.d.ts

@@ -0,0 +1,6 @@
+import Joi from "joi";
+
+//#region src/utils/validations/schema/custom-fields.d.ts
+declare const CustomFieldsSchema: Joi.ObjectSchema<Record<string, any>>;
+//#endregion
+export { CustomFieldsSchema };

package/dist/utils/validations/schema/custom-fields.js

@@ -0,0 +1,7 @@
+import Joi from "joi";
+
+//#region src/utils/validations/schema/custom-fields.ts
+const CustomFieldsSchema = Joi.object().pattern(Joi.string(), Joi.any());
+
+//#endregion
+export { CustomFieldsSchema };