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

package/dist/repository/entries.js

@@ -0,0 +1,67 @@
+import logger_default from "../utils/logger/index.js";
+import { MissingDefinitionError } from "../errors/index.js";
+import { findAll } from "./definition.js";
+import CustomFieldEntries_default from "../models/CustomFieldEntries.js";
+import "../models/index.js";
+import { formatFunctions } from "./utils/formatValues.js";
+
+//#region src/repository/entries.ts
+const findEntriesByModelId = async (modelId, options = {}) => {
+	const { transaction } = options;
+	return CustomFieldEntries_default.findOne({
+		where: { modelId },
+		transaction
+	});
+};
+const findEntriesByModelIds = async (modelIds, options = {}) => {
+	const { transaction } = options;
+	return CustomFieldEntries_default.findAll({
+		where: { modelId: modelIds },
+		transaction
+	});
+};
+const updateEntries = async (modelId, modelType, customFields, identifiers, options = {}) => {
+	const customFieldsNames = Object.keys(customFields);
+	logger_default.debug(`custom-fields: updating entries for ${modelType} ${modelId}`, {
+		customFieldsNames,
+		optionsKeys: options ? Object.keys(options) : null,
+		customFields,
+		identifiers
+	});
+	const { modelOptions, transaction } = options;
+	const where = {
+		modelType,
+		name: customFieldsNames,
+		...!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }
+	};
+	const fieldDefinitions = await findAll(where, {
+		withDisabled: true,
+		transaction,
+		include: modelOptions.include?.(identifiers)
+	}) ?? [];
+	const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
+	if (fieldDefinitions.length !== customFieldsNames.length) {
+		logger_default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, {
+			names: customFieldsNames,
+			fieldDefinitions
+		});
+		throw new MissingDefinitionError(customFieldsNames.filter((name) => !fieldDefinitions.some((def) => def.name === name)));
+	}
+	const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+	const valuesWithDisabledDefinitions = customFieldsNames.filter((name) => disabledNames.includes(name));
+	if (valuesWithDisabledDefinitions?.length > 0) logger_default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(", ")}`);
+	const definitionsByName = Object.fromEntries(fieldDefinitions.map((definition) => [definition.name, definition]));
+	Object.entries(customFields).filter(([definitionName]) => formatFunctions[definitionsByName[definitionName].fieldType]).forEach(([definitionName, value]) => {
+		const { fieldType } = definitionsByName[definitionName];
+		customFields[definitionName] = formatFunctions[fieldType](value);
+	});
+	return CustomFieldEntries_default.upsert({
+		modelId,
+		entityId: fieldDefinitions[0].entityId,
+		modelType,
+		customFields
+	}, options);
+};
+
+//#endregion
+export { findEntriesByModelId, findEntriesByModelIds, updateEntries };

package/dist/repository/field-policy.cjs

@@ -0,0 +1,69 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_mat_path_state = require('../mat-path-state.cjs');
+const require_FieldPolicy = require('../models/FieldPolicy.cjs');
+let sequelize = require("sequelize");
+
+//#region src/repository/field-policy.ts
+var field_policy_exports = /* @__PURE__ */ require_rolldown_runtime.__export({
+	create: () => create,
+	findAll: () => findAll,
+	findAllByContext: () => findAllByContext,
+	findAllByContextIds: () => findAllByContextIds,
+	findByContextAndName: () => findByContextAndName,
+	findById: () => findById,
+	findEffectivePolicy: () => findEffectivePolicy,
+	remove: () => remove,
+	update: () => update
+});
+const findByContextAndName = (contextId, name) => require_FieldPolicy.default.findOne({ where: {
+	contextId,
+	name
+} });
+const findById = (id) => require_FieldPolicy.default.findByPk(id);
+const findAllByContext = (contextId) => require_FieldPolicy.default.findAll({ where: { contextId } });
+const findAll = () => require_FieldPolicy.default.findAll();
+const findAllByContextIds = (contextIds) => require_FieldPolicy.default.findAll({ where: { contextId: contextIds } });
+const create = ({ contextId, name, entityType, fields, models }) => require_FieldPolicy.default.create({
+	contextId,
+	name,
+	entityType,
+	fields,
+	models
+});
+const update = async (id, data) => {
+	const policy = await require_FieldPolicy.default.findByPk(id);
+	if (!policy) return null;
+	return policy.update(data);
+};
+const remove = (id) => require_FieldPolicy.default.destroy({ where: { id } });
+const findEffectivePolicy = (entityType) => {
+	const tableName = require_FieldPolicy.default.getTableName();
+	const EFFECTIVE_POLICY_QUERY = `
+  SELECT fp.*
+  FROM "${tableName}" fp
+  LEFT JOIN context_entity_path cep ON cep.deleted_at IS NULL
+    AND cep.entity_id = fp.context_id
+    AND cep.entity_type = 'context'
+    AND cep.path @> ANY(current_setting('mat_path.paths', true)::ltree[])
+  WHERE fp.entity_type = $1
+  ORDER BY COALESCE(nlevel(cep.path), 0) DESC
+  LIMIT 1`;
+	return require_mat_path_state.matPathState.withMatPath(tableName, (transaction) => require_FieldPolicy.default.sequelize.query(EFFECTIVE_POLICY_QUERY, {
+		bind: [entityType],
+		type: sequelize.QueryTypes.SELECT,
+		transaction
+	}));
+};
+
+//#endregion
+exports.create = create;
+Object.defineProperty(exports, 'field_policy_exports', {
+  enumerable: true,
+  get: function () {
+    return field_policy_exports;
+  }
+});
+exports.findAll = findAll;
+exports.findEffectivePolicy = findEffectivePolicy;
+exports.remove = remove;
+exports.update = update;

package/dist/repository/field-policy.d.cts

@@ -0,0 +1,35 @@
+import { EntityType, FieldPolicy, ModelInclusion } from "../models/FieldPolicy.cjs";
+
+//#region src/repository/field-policy.d.ts
+declare namespace field_policy_d_exports {
+  export { CreateFieldPolicyData, UpdateFieldPolicyData, create, findAll, findAllByContext, findAllByContextIds, findByContextAndName, findById, findEffectivePolicy, remove, update };
+}
+interface CreateFieldPolicyData {
+  contextId: string;
+  name: string;
+  entityType?: EntityType;
+  fields?: string[];
+  models?: ModelInclusion[];
+}
+interface UpdateFieldPolicyData {
+  entityType?: EntityType;
+  fields?: string[];
+  models?: ModelInclusion[];
+}
+declare const findByContextAndName: (contextId: string, name: string) => Promise<FieldPolicy | null>;
+declare const findById: (id: string) => Promise<FieldPolicy | null>;
+declare const findAllByContext: (contextId: string) => Promise<FieldPolicy[]>;
+declare const findAll: () => Promise<FieldPolicy[]>;
+declare const findAllByContextIds: (contextIds: string[]) => Promise<FieldPolicy[]>;
+declare const create: ({
+  contextId,
+  name,
+  entityType,
+  fields,
+  models
+}: CreateFieldPolicyData) => Promise<FieldPolicy>;
+declare const update: (id: string, data: UpdateFieldPolicyData) => Promise<FieldPolicy | null>;
+declare const remove: (id: string) => Promise<number>;
+declare const findEffectivePolicy: (entityType: string) => Promise<Record<string, unknown>[]>;
+//#endregion
+export { field_policy_d_exports };

package/dist/repository/field-policy.d.ts

@@ -0,0 +1,35 @@
+import { EntityType, FieldPolicy, ModelInclusion } from "../models/FieldPolicy.js";
+
+//#region src/repository/field-policy.d.ts
+declare namespace field_policy_d_exports {
+  export { CreateFieldPolicyData, UpdateFieldPolicyData, create, findAll, findAllByContext, findAllByContextIds, findByContextAndName, findById, findEffectivePolicy, remove, update };
+}
+interface CreateFieldPolicyData {
+  contextId: string;
+  name: string;
+  entityType?: EntityType;
+  fields?: string[];
+  models?: ModelInclusion[];
+}
+interface UpdateFieldPolicyData {
+  entityType?: EntityType;
+  fields?: string[];
+  models?: ModelInclusion[];
+}
+declare const findByContextAndName: (contextId: string, name: string) => Promise<FieldPolicy | null>;
+declare const findById: (id: string) => Promise<FieldPolicy | null>;
+declare const findAllByContext: (contextId: string) => Promise<FieldPolicy[]>;
+declare const findAll: () => Promise<FieldPolicy[]>;
+declare const findAllByContextIds: (contextIds: string[]) => Promise<FieldPolicy[]>;
+declare const create: ({
+  contextId,
+  name,
+  entityType,
+  fields,
+  models
+}: CreateFieldPolicyData) => Promise<FieldPolicy>;
+declare const update: (id: string, data: UpdateFieldPolicyData) => Promise<FieldPolicy | null>;
+declare const remove: (id: string) => Promise<number>;
+declare const findEffectivePolicy: (entityType: string) => Promise<Record<string, unknown>[]>;
+//#endregion
+export { field_policy_d_exports };

package/dist/repository/field-policy.js

@@ -0,0 +1,59 @@
+import { __export } from "../_virtual/rolldown_runtime.js";
+import { matPathState } from "../mat-path-state.js";
+import FieldPolicy_default from "../models/FieldPolicy.js";
+import { QueryTypes } from "sequelize";
+
+//#region src/repository/field-policy.ts
+var field_policy_exports = /* @__PURE__ */ __export({
+	create: () => create,
+	findAll: () => findAll,
+	findAllByContext: () => findAllByContext,
+	findAllByContextIds: () => findAllByContextIds,
+	findByContextAndName: () => findByContextAndName,
+	findById: () => findById,
+	findEffectivePolicy: () => findEffectivePolicy,
+	remove: () => remove,
+	update: () => update
+});
+const findByContextAndName = (contextId, name) => FieldPolicy_default.findOne({ where: {
+	contextId,
+	name
+} });
+const findById = (id) => FieldPolicy_default.findByPk(id);
+const findAllByContext = (contextId) => FieldPolicy_default.findAll({ where: { contextId } });
+const findAll = () => FieldPolicy_default.findAll();
+const findAllByContextIds = (contextIds) => FieldPolicy_default.findAll({ where: { contextId: contextIds } });
+const create = ({ contextId, name, entityType, fields, models }) => FieldPolicy_default.create({
+	contextId,
+	name,
+	entityType,
+	fields,
+	models
+});
+const update = async (id, data) => {
+	const policy = await FieldPolicy_default.findByPk(id);
+	if (!policy) return null;
+	return policy.update(data);
+};
+const remove = (id) => FieldPolicy_default.destroy({ where: { id } });
+const findEffectivePolicy = (entityType) => {
+	const tableName = FieldPolicy_default.getTableName();
+	const EFFECTIVE_POLICY_QUERY = `
+  SELECT fp.*
+  FROM "${tableName}" fp
+  LEFT JOIN context_entity_path cep ON cep.deleted_at IS NULL
+    AND cep.entity_id = fp.context_id
+    AND cep.entity_type = 'context'
+    AND cep.path @> ANY(current_setting('mat_path.paths', true)::ltree[])
+  WHERE fp.entity_type = $1
+  ORDER BY COALESCE(nlevel(cep.path), 0) DESC
+  LIMIT 1`;
+	return matPathState.withMatPath(tableName, (transaction) => FieldPolicy_default.sequelize.query(EFFECTIVE_POLICY_QUERY, {
+		bind: [entityType],
+		type: QueryTypes.SELECT,
+		transaction
+	}));
+};
+
+//#endregion
+export { create, field_policy_exports, findAll, findEffectivePolicy, remove, update };

package/dist/repository/utils/formatValues.cjs

@@ -0,0 +1,14 @@
+const require_index = require('../../utils/constants/index.cjs');
+
+//#region src/repository/utils/formatValues.ts
+const formatFunctions = { [require_index.CustomFieldDefinitionType.DATE]: (value) => {
+	if (value) {
+		const date = new Date(value);
+		if (date.toString() === "Invalid Date") throw new Error(`Invalid date value: ${value}`);
+		return date.toISOString();
+	}
+	return null;
+} };
+
+//#endregion
+exports.formatFunctions = formatFunctions;

package/dist/repository/utils/formatValues.js

@@ -0,0 +1,14 @@
+import { CustomFieldDefinitionType } from "../../utils/constants/index.js";
+
+//#region src/repository/utils/formatValues.ts
+const formatFunctions = { [CustomFieldDefinitionType.DATE]: (value) => {
+	if (value) {
+		const date = new Date(value);
+		if (date.toString() === "Invalid Date") throw new Error(`Invalid date value: ${value}`);
+		return date.toISOString();
+	}
+	return null;
+} };
+
+//#endregion
+export { formatFunctions };

package/dist/repository/validator.cjs

@@ -0,0 +1,85 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../utils/logger/index.cjs');
+const require_CustomValidator = require('../models/CustomValidator.cjs');
+require('../models/index.cjs');
+let sequelize_lib_sequelize = require("sequelize/lib/sequelize");
+sequelize_lib_sequelize = require_rolldown_runtime.__toESM(sequelize_lib_sequelize);
+
+//#region src/repository/validator.ts
+const create = async (validatorAttributes, options = {}) => {
+	require_index.default.debug("custom-validator - create validator");
+	return await require_CustomValidator.default.create(validatorAttributes, options);
+};
+const findAll = async (where = {}, options = {}) => {
+	require_index.default.debug("custom-validator - find all validators");
+	const { transaction, withDisabled, include, attributes, raw } = options;
+	let validators;
+	if (withDisabled) validators = await require_CustomValidator.default.unscoped().scope("userScope").findAll({
+		where,
+		transaction,
+		include,
+		attributes,
+		raw
+	});
+	else validators = await require_CustomValidator.default.scope(["defaultScope", "userScope"]).findAll({
+		where,
+		transaction,
+		include,
+		attributes,
+		raw
+	});
+	return validators;
+};
+const findAllByModelType = async (modelType, entityId, options = {}) => {
+	require_index.default.debug("custom-validator - find all validators by model type");
+	return findAll({
+		modelType,
+		...!options?.modelOptions?.useEntityIdFromInclude && { entityId }
+	}, {
+		...options,
+		include: options?.modelOptions?.include?.(entityId)
+	});
+};
+const update = async (id, updates, options) => {
+	require_index.default.debug("custom-validator - update validator");
+	return require_CustomValidator.default.update(updates, {
+		where: { id },
+		returning: true,
+		...options
+	});
+};
+const disable = async (id, options) => {
+	require_index.default.debug("custom-validator - disable validator");
+	return update(id, { disabled: true }, options);
+};
+const findEffective = async (entityType = "Vehicle", requestPath) => {
+	const QUERY = `
+ 	SELECT DISTINCT ON (cv.model_type) cv.*, cep.path
+	FROM custom_validators cv
+	LEFT JOIN context_entity_path cep ON cep.deleted_at IS NULL
+ 	AND cep.entity_id = cv.entity_id
+ 	AND cep.entity_type = cv.entity_type
+ 	AND cep.path @> ANY(ARRAY['${requestPath}']::ltree[])
+	WHERE cv.model_type IN ($1) AND cv.disabled = false
+	ORDER BY cv.model_type, COALESCE(nlevel(cep.path), 0) DESC;`;
+	try {
+		await sequelize_lib_sequelize.default.query(QUERY, {
+			bind: [entityType],
+			type: sequelize_lib_sequelize.default.QueryTypes.SELECT
+		});
+		return {
+			...result.schema.properties.after,
+			path: result.path
+		};
+	} catch (err) {
+		throw err;
+	}
+};
+
+//#endregion
+exports.create = create;
+exports.disable = disable;
+exports.findAll = findAll;
+exports.findAllByModelType = findAllByModelType;
+exports.findEffective = findEffective;
+exports.update = update;

package/dist/repository/validator.js

@@ -0,0 +1,78 @@
+import logger_default from "../utils/logger/index.js";
+import CustomValidator_default from "../models/CustomValidator.js";
+import "../models/index.js";
+import sequelize from "sequelize/lib/sequelize";
+
+//#region src/repository/validator.ts
+const create = async (validatorAttributes, options = {}) => {
+	logger_default.debug("custom-validator - create validator");
+	return await CustomValidator_default.create(validatorAttributes, options);
+};
+const findAll = async (where = {}, options = {}) => {
+	logger_default.debug("custom-validator - find all validators");
+	const { transaction, withDisabled, include, attributes, raw } = options;
+	let validators;
+	if (withDisabled) validators = await CustomValidator_default.unscoped().scope("userScope").findAll({
+		where,
+		transaction,
+		include,
+		attributes,
+		raw
+	});
+	else validators = await CustomValidator_default.scope(["defaultScope", "userScope"]).findAll({
+		where,
+		transaction,
+		include,
+		attributes,
+		raw
+	});
+	return validators;
+};
+const findAllByModelType = async (modelType, entityId, options = {}) => {
+	logger_default.debug("custom-validator - find all validators by model type");
+	return findAll({
+		modelType,
+		...!options?.modelOptions?.useEntityIdFromInclude && { entityId }
+	}, {
+		...options,
+		include: options?.modelOptions?.include?.(entityId)
+	});
+};
+const update = async (id, updates, options) => {
+	logger_default.debug("custom-validator - update validator");
+	return CustomValidator_default.update(updates, {
+		where: { id },
+		returning: true,
+		...options
+	});
+};
+const disable = async (id, options) => {
+	logger_default.debug("custom-validator - disable validator");
+	return update(id, { disabled: true }, options);
+};
+const findEffective = async (entityType = "Vehicle", requestPath) => {
+	const QUERY = `
+ 	SELECT DISTINCT ON (cv.model_type) cv.*, cep.path
+	FROM custom_validators cv
+	LEFT JOIN context_entity_path cep ON cep.deleted_at IS NULL
+ 	AND cep.entity_id = cv.entity_id
+ 	AND cep.entity_type = cv.entity_type
+ 	AND cep.path @> ANY(ARRAY['${requestPath}']::ltree[])
+	WHERE cv.model_type IN ($1) AND cv.disabled = false
+	ORDER BY cv.model_type, COALESCE(nlevel(cep.path), 0) DESC;`;
+	try {
+		await sequelize.query(QUERY, {
+			bind: [entityType],
+			type: sequelize.QueryTypes.SELECT
+		});
+		return {
+			...result.schema.properties.after,
+			path: result.path
+		};
+	} catch (err) {
+		throw err;
+	}
+};
+
+//#endregion
+export { create, disable, findAll, findAllByModelType, findEffective, update };

package/dist/repository/value.cjs

@@ -0,0 +1,77 @@
+const require_index = require('../utils/logger/index.cjs');
+const require_index$1 = require('../errors/index.cjs');
+const require_definition = require('./definition.cjs');
+const require_CustomFieldValue = require('../models/CustomFieldValue.cjs');
+require('../models/index.cjs');
+const require_formatValues = require('./utils/formatValues.cjs');
+
+//#region src/repository/value.ts
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+const findValuesByModelIds = async (modelIds, options) => {
+	const { transaction } = options;
+	return require_CustomFieldValue.default.findAll({
+		where: { modelId: modelIds },
+		transaction,
+		raw: true,
+		nest: true
+	});
+};
+/**
+* Try to update custom field values for a model instance.
+* Create new value record if not exists, but fails if value's definition not exist.
+* Return the updated values
+*/
+const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
+	const names = Object.keys(valuesToUpdate);
+	require_index.default.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
+		names,
+		optionsKeys: options ? Object.keys(options) : null,
+		valuesToUpdate,
+		identifiers
+	});
+	const { modelOptions, transaction } = options;
+	const where = {
+		modelType,
+		name: names,
+		...!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }
+	};
+	const fieldDefinitions = await require_definition.findAll(where, {
+		withDisabled: true,
+		transaction,
+		include: modelOptions.include?.(identifiers)
+	}) ?? [];
+	const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
+	if (fieldDefinitions.length !== names.length) {
+		require_index.default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, {
+			names,
+			fieldDefinitions
+		});
+		throw new require_index$1.MissingDefinitionError(names.filter((name) => !fieldDefinitions.some((def) => def.name === name)));
+	}
+	const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+	const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
+	if (valuesWithDisabledDefinitions?.length > 0) require_index.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(", ")}`);
+	const values = names.map((name) => {
+		const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
+		const formatFunction = require_formatValues.formatFunctions[fieldDefinition.fieldType];
+		const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
+		return {
+			modelId,
+			updatedAt: /* @__PURE__ */ new Date(),
+			customFieldDefinitionId: fieldDefinition.id,
+			value: value !== void 0 ? value : fieldDefinition.defaultValue
+		};
+	});
+	return Promise.all(values.map(async (value) => {
+		const [cfv] = await require_CustomFieldValue.default.upsert(value, { transaction: options.transaction });
+		return cfv;
+	}));
+};
+
+//#endregion
+exports.findValuesByModelIds = findValuesByModelIds;
+exports.updateValues = updateValues;

package/dist/repository/value.js

@@ -0,0 +1,76 @@
+import logger_default from "../utils/logger/index.js";
+import { MissingDefinitionError } from "../errors/index.js";
+import { findAll } from "./definition.js";
+import CustomFieldValue_default from "../models/CustomFieldValue.js";
+import "../models/index.js";
+import { formatFunctions } from "./utils/formatValues.js";
+
+//#region src/repository/value.ts
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+const findValuesByModelIds = async (modelIds, options) => {
+	const { transaction } = options;
+	return CustomFieldValue_default.findAll({
+		where: { modelId: modelIds },
+		transaction,
+		raw: true,
+		nest: true
+	});
+};
+/**
+* Try to update custom field values for a model instance.
+* Create new value record if not exists, but fails if value's definition not exist.
+* Return the updated values
+*/
+const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
+	const names = Object.keys(valuesToUpdate);
+	logger_default.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
+		names,
+		optionsKeys: options ? Object.keys(options) : null,
+		valuesToUpdate,
+		identifiers
+	});
+	const { modelOptions, transaction } = options;
+	const where = {
+		modelType,
+		name: names,
+		...!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }
+	};
+	const fieldDefinitions = await findAll(where, {
+		withDisabled: true,
+		transaction,
+		include: modelOptions.include?.(identifiers)
+	}) ?? [];
+	const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
+	if (fieldDefinitions.length !== names.length) {
+		logger_default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, {
+			names,
+			fieldDefinitions
+		});
+		throw new MissingDefinitionError(names.filter((name) => !fieldDefinitions.some((def) => def.name === name)));
+	}
+	const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+	const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
+	if (valuesWithDisabledDefinitions?.length > 0) logger_default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(", ")}`);
+	const values = names.map((name) => {
+		const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
+		const formatFunction = formatFunctions[fieldDefinition.fieldType];
+		const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
+		return {
+			modelId,
+			updatedAt: /* @__PURE__ */ new Date(),
+			customFieldDefinitionId: fieldDefinition.id,
+			value: value !== void 0 ? value : fieldDefinition.defaultValue
+		};
+	});
+	return Promise.all(values.map(async (value) => {
+		const [cfv] = await CustomFieldValue_default.upsert(value, { transaction: options.transaction });
+		return cfv;
+	}));
+};
+
+//#endregion
+export { findValuesByModelIds, updateValues };

package/dist/scopes/filter.cjs

@@ -0,0 +1,56 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../utils/helpers/index.cjs');
+const require_filter_helpers = require('./helpers/filter.helpers.cjs');
+let sequelize = require("sequelize");
+let sequelize_typescript = require("sequelize-typescript");
+let _autofleet_common_types = require("@autofleet/common-types");
+
+//#region src/scopes/filter.ts
+/**
+* A Sequelize scope for filtering models by custom fields.
+* This scope builds a WHERE clause to be applied on the main query.
+*
+* @param name - The model type name used to join custom_field_definitions.
+* @returns A function that takes conditions and returns the Sequelize options object.
+*/
+const customFieldsFilterScope = (name, options) => ({ replacementsMap: replacements, scopeValue: conditions }) => {
+	if (!conditions || Object.keys(conditions).length === 0) return {};
+	const queryType = options?.useCustomFieldsEntries ? require_filter_helpers.SubQueryType.ENTRIES : require_filter_helpers.SubQueryType.VALUES;
+	const reverseReplacementsMap = new Map(Object.entries(replacements).map(([key, value]) => [value, key]));
+	const conditionsStrings = Object.entries(conditions).map(([key, condition]) => {
+		switch (queryType) {
+			case require_filter_helpers.SubQueryType.ENTRIES: return require_filter_helpers.formatConditionsForEntries(key, condition, reverseReplacementsMap);
+			case require_filter_helpers.SubQueryType.VALUES: return require_filter_helpers.formatConditionsForValues(key, condition, reverseReplacementsMap);
+			default: return false;
+		}
+	}).filter(Boolean);
+	if (conditionsStrings.length === 0) return {};
+	const subQuery = require_filter_helpers.getFilterCustomFieldsSubQuery(queryType, name, conditionsStrings);
+	return {
+		where: { id: { [sequelize.Op.in]: sequelize_typescript.Sequelize.literal(`(${subQuery})`) } },
+		replacements
+	};
+};
+const scopeName = _autofleet_common_types.customFields.CUSTOM_FIELDS_FILTER_SCOPE;
+const customFieldsSortScope = (name, options) => ({ replacementsMap, scopeValue: sort }) => {
+	if (!sort || sort.length === 0) return {};
+	const queryType = options?.useCustomFieldsEntries ? require_filter_helpers.SubQueryType.ENTRIES : require_filter_helpers.SubQueryType.VALUES;
+	const randomStr = require_index.generateRandomString();
+	const includes = Object.entries(sort).map(([key]) => {
+		const replacementKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
+		return [sequelize_typescript.Sequelize.literal(require_filter_helpers.getSortCustomFieldsSubQuery(queryType, name, replacementKey)), randomStr];
+	});
+	const orders = Object.entries(sort).map(([, sortObject]) => {
+		const direction = typeof sortObject === "string" ? sortObject : Object.values(sortObject)[0];
+		return sequelize_typescript.Sequelize.literal(`"${randomStr}" ${direction || "ASC"}`);
+	});
+	return {
+		attributes: { include: includes },
+		order: orders,
+		replacements: replacementsMap
+	};
+};
+
+//#endregion
+exports.customFieldsFilterScope = customFieldsFilterScope;
+exports.customFieldsSortScope = customFieldsSortScope;