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

package/dist/models/tests/contextAwareModels/ContextAwareTestModel.cjs

@@ -0,0 +1,35 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_decorateMetadata = require('../../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.cjs');
+const require_decorate = require('../../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.cjs');
+const require_ContextTestModel = require('./ContextTestModel.cjs');
+let sequelize_typescript = require("sequelize-typescript");
+
+//#region src/models/tests/contextAwareModels/ContextAwareTestModel.ts
+var _ref;
+let ContextAwareTestModel = class ContextAwareTestModel$1 extends sequelize_typescript.Model {};
+require_decorate.__decorate([
+	sequelize_typescript.PrimaryKey,
+	(0, sequelize_typescript.Column)({
+		type: sequelize_typescript.DataType.UUID,
+		defaultValue: sequelize_typescript.DataType.UUIDV4,
+		allowNull: false
+	}),
+	require_decorateMetadata.__decorateMetadata("design:type", String)
+], ContextAwareTestModel.prototype, "id", void 0);
+require_decorate.__decorate([
+	(0, sequelize_typescript.ForeignKey)(() => require_ContextTestModel.default),
+	(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.UUID }),
+	require_decorateMetadata.__decorateMetadata("design:type", String)
+], ContextAwareTestModel.prototype, "contextId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.BOOLEAN }), require_decorateMetadata.__decorateMetadata("design:type", Boolean)], ContextAwareTestModel.prototype, "coolAttribute", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.VIRTUAL }), require_decorateMetadata.__decorateMetadata("design:type", Object)], ContextAwareTestModel.prototype, "customFields", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.BelongsTo)(() => require_ContextTestModel.default), require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref = typeof require_ContextTestModel.default !== "undefined" && require_ContextTestModel.default) === "function" ? _ref : Object)], ContextAwareTestModel.prototype, "context", void 0);
+ContextAwareTestModel = require_decorate.__decorate([(0, sequelize_typescript.Table)({
+	createdAt: false,
+	updatedAt: false,
+	modelName: "ContextAwareTestModel"
+})], ContextAwareTestModel);
+var ContextAwareTestModel_default = ContextAwareTestModel;
+
+//#endregion
+exports.default = ContextAwareTestModel_default;

package/dist/models/tests/contextAwareModels/ContextAwareTestModel.d.ts

@@ -0,0 +1,2 @@
+import "./ContextTestModel.js";
+import { Model } from "sequelize-typescript";

package/dist/models/tests/contextAwareModels/ContextAwareTestModel.js

@@ -0,0 +1,34 @@
+import { __decorateMetadata } from "../../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js";
+import ContextTestModel_default from "./ContextTestModel.js";
+import { BelongsTo, Column, DataType, ForeignKey, Model, PrimaryKey, Table } from "sequelize-typescript";
+
+//#region src/models/tests/contextAwareModels/ContextAwareTestModel.ts
+var _ref;
+let ContextAwareTestModel = class ContextAwareTestModel$1 extends Model {};
+__decorate([
+	PrimaryKey,
+	Column({
+		type: DataType.UUID,
+		defaultValue: DataType.UUIDV4,
+		allowNull: false
+	}),
+	__decorateMetadata("design:type", String)
+], ContextAwareTestModel.prototype, "id", void 0);
+__decorate([
+	ForeignKey(() => ContextTestModel_default),
+	Column({ type: DataType.UUID }),
+	__decorateMetadata("design:type", String)
+], ContextAwareTestModel.prototype, "contextId", void 0);
+__decorate([Column({ type: DataType.BOOLEAN }), __decorateMetadata("design:type", Boolean)], ContextAwareTestModel.prototype, "coolAttribute", void 0);
+__decorate([Column({ type: DataType.VIRTUAL }), __decorateMetadata("design:type", Object)], ContextAwareTestModel.prototype, "customFields", void 0);
+__decorate([BelongsTo(() => ContextTestModel_default), __decorateMetadata("design:type", typeof (_ref = typeof ContextTestModel_default !== "undefined" && ContextTestModel_default) === "function" ? _ref : Object)], ContextAwareTestModel.prototype, "context", void 0);
+ContextAwareTestModel = __decorate([Table({
+	createdAt: false,
+	updatedAt: false,
+	modelName: "ContextAwareTestModel"
+})], ContextAwareTestModel);
+var ContextAwareTestModel_default = ContextAwareTestModel;
+
+//#endregion
+export { ContextAwareTestModel_default as default };

package/dist/models/tests/contextAwareModels/ContextTestModel.cjs

@@ -0,0 +1,33 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_decorateMetadata = require('../../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.cjs');
+const require_decorate = require('../../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.cjs');
+let sequelize_typescript = require("sequelize-typescript");
+
+//#region src/models/tests/contextAwareModels/ContextTestModel.ts
+var EEntityTypes = /* @__PURE__ */ function(EEntityTypes$1) {
+	EEntityTypes$1["BUSINESS_MODEL"] = "businessModel";
+	EEntityTypes$1["CONTEXT"] = "context";
+	EEntityTypes$1["DEMAND_SOURCE"] = "demandSource";
+	EEntityTypes$1["FLEET"] = "fleet";
+	return EEntityTypes$1;
+}(EEntityTypes || {});
+let ContextTestModel = class ContextTestModel$1 extends sequelize_typescript.Model {};
+require_decorate.__decorate([
+	sequelize_typescript.PrimaryKey,
+	(0, sequelize_typescript.Column)({
+		defaultValue: sequelize_typescript.DataType.UUIDV4,
+		type: sequelize_typescript.DataType.UUID
+	}),
+	require_decorateMetadata.__decorateMetadata("design:type", String)
+], ContextTestModel.prototype, "id", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.UUID }), require_decorateMetadata.__decorateMetadata("design:type", String)], ContextTestModel.prototype, "entityId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.ENUM(...Object.values(EEntityTypes)) }), require_decorateMetadata.__decorateMetadata("design:type", String)], ContextTestModel.prototype, "entityType", void 0);
+ContextTestModel = require_decorate.__decorate([(0, sequelize_typescript.Table)({
+	createdAt: false,
+	updatedAt: false,
+	modelName: "ContextTestModel"
+})], ContextTestModel);
+var ContextTestModel_default = ContextTestModel;
+
+//#endregion
+exports.default = ContextTestModel_default;

package/dist/models/tests/contextAwareModels/ContextTestModel.d.ts

@@ -0,0 +1 @@
+import { Model } from "sequelize-typescript";

package/dist/models/tests/contextAwareModels/ContextTestModel.js

@@ -0,0 +1,32 @@
+import { __decorateMetadata } from "../../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js";
+import { __decorate } from "../../../_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js";
+import { Column, DataType, Model, PrimaryKey, Table } from "sequelize-typescript";
+
+//#region src/models/tests/contextAwareModels/ContextTestModel.ts
+var EEntityTypes = /* @__PURE__ */ function(EEntityTypes$1) {
+	EEntityTypes$1["BUSINESS_MODEL"] = "businessModel";
+	EEntityTypes$1["CONTEXT"] = "context";
+	EEntityTypes$1["DEMAND_SOURCE"] = "demandSource";
+	EEntityTypes$1["FLEET"] = "fleet";
+	return EEntityTypes$1;
+}(EEntityTypes || {});
+let ContextTestModel = class ContextTestModel$1 extends Model {};
+__decorate([
+	PrimaryKey,
+	Column({
+		defaultValue: DataType.UUIDV4,
+		type: DataType.UUID
+	}),
+	__decorateMetadata("design:type", String)
+], ContextTestModel.prototype, "id", void 0);
+__decorate([Column({ type: DataType.UUID }), __decorateMetadata("design:type", String)], ContextTestModel.prototype, "entityId", void 0);
+__decorate([Column({ type: DataType.ENUM(...Object.values(EEntityTypes)) }), __decorateMetadata("design:type", String)], ContextTestModel.prototype, "entityType", void 0);
+ContextTestModel = __decorate([Table({
+	createdAt: false,
+	updatedAt: false,
+	modelName: "ContextTestModel"
+})], ContextTestModel);
+var ContextTestModel_default = ContextTestModel;
+
+//#endregion
+export { ContextTestModel_default as default };

package/dist/repository/definition.cjs

@@ -0,0 +1,221 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../errors/index.cjs');
+const require_CustomFieldDefinition = require('../models/CustomFieldDefinition.cjs');
+const require_CustomFieldModelTypeMap = require('../models/CustomFieldModelTypeMap.cjs');
+require('../models/index.cjs');
+let sequelize = require("sequelize");
+
+//#region src/repository/definition.ts
+/**
+* Check if the modelTypeMappings association exists on CustomFieldDefinition
+* The association is only created when useModelTypeMapping: true is passed to initTables
+*/
+const hasModelTypeMappingsAssociation = () => "modelTypeMappings" in (require_CustomFieldDefinition.default.associations || {});
+/**
+* Helper to extract modelTypeIds from the modelTypeMappings association data
+* Handles both raw and non-raw Sequelize results
+*/
+const extractModelTypeIdsFromMappings = (mappings) => {
+	if (!mappings || !Array.isArray(mappings)) return [];
+	return mappings.map((m) => m.modelTypeId || m.dataValues?.modelTypeId).filter((id) => Boolean(id));
+};
+/**
+* Helper to extract modelTypeIds from a definition with loaded association
+* Handles the common pattern of getting mappings from a definition
+*/
+const enrichDefinitionWithModelTypeIds = (definition) => {
+	const defWithMappings = definition;
+	definition.modelTypeIds = extractModelTypeIdsFromMappings(defWithMappings.modelTypeMappings ?? defWithMappings.dataValues?.modelTypeMappings);
+	return definition;
+};
+const create = async (data) => {
+	const { modelTypeIds, ...definitionData } = data;
+	const result = await require_CustomFieldDefinition.default.sequelize.transaction(async (transaction) => {
+		const customFieldDefinition = await require_CustomFieldDefinition.default.create(definitionData, { transaction });
+		if (modelTypeIds?.length) await require_CustomFieldModelTypeMap.default.bulkCreate(modelTypeIds.map((modelTypeId) => ({
+			customFieldDefinitionId: customFieldDefinition.id,
+			modelTypeId
+		})), { transaction });
+		return customFieldDefinition;
+	});
+	result.modelTypeIds = modelTypeIds ?? [];
+	return result;
+};
+const findAll = async (where, options = { withDisabled: false }) => {
+	const queryModel = options.withDisabled ? require_CustomFieldDefinition.default.unscoped() : require_CustomFieldDefinition.default;
+	let includeToUse = options.include;
+	if (options.enrichWithModelTypeIds && hasModelTypeMappingsAssociation()) {
+		const modelTypeMappingsInclude = {
+			association: "modelTypeMappings",
+			required: false,
+			attributes: ["modelTypeId"]
+		};
+		if (options.include) includeToUse = Array.isArray(options.include) ? [...options.include, modelTypeMappingsInclude] : [options.include, modelTypeMappingsInclude];
+		else includeToUse = modelTypeMappingsInclude;
+	}
+	const definitions = await queryModel.scope("userScope").findAll({
+		where,
+		transaction: options.transaction,
+		raw: !options.enrichWithModelTypeIds,
+		include: includeToUse
+	});
+	if (options.enrichWithModelTypeIds && hasModelTypeMappingsAssociation()) return definitions.map(enrichDefinitionWithModelTypeIds);
+	return definitions;
+};
+const findByIds = (ids, options = { withDisabled: false }) => findAll({ id: { [sequelize.Op.in]: ids } }, options);
+const findById = async (id, options = { withDisabled: false }) => {
+	const { withDisabled } = options;
+	const queryModel = withDisabled ? require_CustomFieldDefinition.default.unscoped().scope("userScope") : require_CustomFieldDefinition.default.scope("userScope");
+	const includeModelTypeMappings = hasModelTypeMappingsAssociation();
+	const definition = await queryModel.findByPk(id, { include: includeModelTypeMappings ? [{
+		association: "modelTypeMappings",
+		required: false,
+		attributes: ["modelTypeId"]
+	}] : void 0 });
+	if (!definition) return null;
+	if (includeModelTypeMappings) return enrichDefinitionWithModelTypeIds(definition);
+	return definition;
+};
+const findByEntityIds = async (modelType, entityIds, options = {}) => {
+	const { include, useEntityIdFromInclude } = options.modelOptions;
+	const where = {
+		modelType,
+		...!useEntityIdFromInclude && { entityId: { [sequelize.Op.in]: entityIds } }
+	};
+	return require_CustomFieldDefinition.default.findAll({
+		where,
+		transaction: options.transaction,
+		include: include?.(entityIds),
+		raw: true
+	});
+};
+const findByWhere = (where) => require_CustomFieldDefinition.default.scope("userScope").findOne({ where });
+const update = async (id, data) => {
+	const { modelTypeIds, ...definitionData } = data;
+	const result = await require_CustomFieldDefinition.default.sequelize.transaction(async (transaction) => {
+		const updatedDefinition = (await require_CustomFieldDefinition.default.scope("userScope").update(definitionData, {
+			where: { id },
+			returning: true,
+			individualHooks: true,
+			transaction
+		}))[1][0];
+		if (modelTypeIds) {
+			const existingMappings = await require_CustomFieldModelTypeMap.default.findAll({
+				where: { customFieldDefinitionId: id },
+				attributes: ["id", "modelTypeId"],
+				raw: true,
+				transaction
+			});
+			const existingTypeIds = existingMappings.map((m) => m.modelTypeId);
+			const toAdd = modelTypeIds.filter((typeId) => !existingTypeIds.includes(typeId));
+			const toRemove = existingMappings.filter((m) => !modelTypeIds.includes(m.modelTypeId));
+			const hasMappingChanges = toRemove.length > 0 || toAdd.length > 0;
+			if (toRemove.length > 0) await require_CustomFieldModelTypeMap.default.destroy({
+				where: { id: toRemove.map((m) => m.id) },
+				transaction
+			});
+			if (toAdd.length > 0) await require_CustomFieldModelTypeMap.default.bulkCreate(toAdd.map((modelTypeId) => ({
+				customFieldDefinitionId: id,
+				modelTypeId
+			})), { transaction });
+			if (hasMappingChanges) {
+				updatedDefinition.changed("updatedAt", true);
+				await updatedDefinition.save({ transaction });
+			}
+		}
+		return updatedDefinition;
+	});
+	result.modelTypeIds = modelTypeIds ?? [];
+	return result;
+};
+/**
+* @returns A promise resolving with a dictionary of custom field definitions by name.
+* @throws A {@link MissingDefinitionError} if any of the custom fields doesn't have a definition.
+*/
+/**
+* Find custom field definitions applicable to a specific model type instance
+*
+* Returns definitions that either:
+* 1. Have NO mappings (apply to all instances of this model type)
+* 2. Have a mapping to this specific model type instance
+*/
+const findByModelTypeId = async (modelTypeId, options = {
+	withDisabled: false,
+	modelType: ""
+}) => {
+	const { withDisabled, entityIds, modelType, modelOptions } = options;
+	const { include, useEntityIdFromInclude } = modelOptions ?? {};
+	const baseWhere = {
+		modelType,
+		...!useEntityIdFromInclude && entityIds && entityIds.length > 0 && { entityId: { [sequelize.Op.in]: entityIds } }
+	};
+	const queryModel = withDisabled ? require_CustomFieldDefinition.default.unscoped() : require_CustomFieldDefinition.default;
+	const includeModelTypeMappings = hasModelTypeMappingsAssociation();
+	const includeArray = [];
+	if (includeModelTypeMappings) includeArray.push({
+		association: "modelTypeMappings",
+		required: false,
+		attributes: ["id", "modelTypeId"]
+	});
+	if (useEntityIdFromInclude && include && entityIds) {
+		const contextIncludes = include(entityIds);
+		includeArray.push(...contextIncludes);
+	}
+	const definitions = await queryModel.scope("userScope").findAll({
+		where: baseWhere,
+		include: includeArray.length > 0 ? includeArray : void 0,
+		raw: false,
+		transaction: options.transaction
+	});
+	const filteredDefinitions = includeModelTypeMappings ? definitions.filter((def) => {
+		const mappings = def.modelTypeMappings ?? def.dataValues?.modelTypeMappings ?? [];
+		if (!Array.isArray(mappings) || mappings.length === 0) return true;
+		return mappings.some((mapping) => {
+			return (mapping.modelTypeId ?? mapping.dataValues?.modelTypeId) === modelTypeId;
+		});
+	}) : definitions;
+	if (includeModelTypeMappings) return filteredDefinitions.map(enrichDefinitionWithModelTypeIds);
+	return filteredDefinitions;
+};
+const getCustomFieldDefinitionsDictionary = async (instances, { findAll: _findAll, modelOptions = {}, withDisabled = false, ...options } = {
+	withDisabled: false,
+	modelOptions: {}
+}) => {
+	const { modelType } = instances[0]?.dataValues ?? {};
+	const customFields = /* @__PURE__ */ new Set();
+	const modelIds = [];
+	const entityIds = /* @__PURE__ */ new Set();
+	instances.forEach((instance) => {
+		const { dataValues: { modelId, entityId, customFields: instanceCustomFields } } = instance;
+		modelIds.push(modelId);
+		entityIds.add(entityId);
+		Object.keys(instanceCustomFields ?? {}).forEach((fieldName) => {
+			customFields.add(fieldName);
+		});
+	});
+	const where = {
+		modelType,
+		entityId: { [sequelize.Op.in]: Array.from(entityIds) },
+		name: { [sequelize.Op.in]: Array.from(customFields) }
+	};
+	const definitions = await (_findAll ?? findAll)(where, {
+		withDisabled,
+		modelOptions,
+		...options
+	});
+	const matchedDefinitions = definitions.filter((def) => customFields.has(def.name));
+	const matchedDefinitionsByName = Object.fromEntries(matchedDefinitions.map((definition) => [definition.name, definition]));
+	if (!definitions?.length || matchedDefinitions.length !== customFields.size) throw new require_index.MissingDefinitionError(Array.from(customFields).filter((customField) => !matchedDefinitionsByName[customField]));
+	return matchedDefinitionsByName;
+};
+
+//#endregion
+exports.create = create;
+exports.findAll = findAll;
+exports.findByEntityIds = findByEntityIds;
+exports.findById = findById;
+exports.findByIds = findByIds;
+exports.findByModelTypeId = findByModelTypeId;
+exports.findByWhere = findByWhere;
+exports.getCustomFieldDefinitionsDictionary = getCustomFieldDefinitionsDictionary;
+exports.update = update;

package/dist/repository/definition.js

@@ -0,0 +1,212 @@
+import { MissingDefinitionError } from "../errors/index.js";
+import CustomFieldDefinition_default from "../models/CustomFieldDefinition.js";
+import CustomFieldModelTypeMap_default from "../models/CustomFieldModelTypeMap.js";
+import "../models/index.js";
+import { Op } from "sequelize";
+
+//#region src/repository/definition.ts
+/**
+* Check if the modelTypeMappings association exists on CustomFieldDefinition
+* The association is only created when useModelTypeMapping: true is passed to initTables
+*/
+const hasModelTypeMappingsAssociation = () => "modelTypeMappings" in (CustomFieldDefinition_default.associations || {});
+/**
+* Helper to extract modelTypeIds from the modelTypeMappings association data
+* Handles both raw and non-raw Sequelize results
+*/
+const extractModelTypeIdsFromMappings = (mappings) => {
+	if (!mappings || !Array.isArray(mappings)) return [];
+	return mappings.map((m) => m.modelTypeId || m.dataValues?.modelTypeId).filter((id) => Boolean(id));
+};
+/**
+* Helper to extract modelTypeIds from a definition with loaded association
+* Handles the common pattern of getting mappings from a definition
+*/
+const enrichDefinitionWithModelTypeIds = (definition) => {
+	const defWithMappings = definition;
+	definition.modelTypeIds = extractModelTypeIdsFromMappings(defWithMappings.modelTypeMappings ?? defWithMappings.dataValues?.modelTypeMappings);
+	return definition;
+};
+const create = async (data) => {
+	const { modelTypeIds, ...definitionData } = data;
+	const result = await CustomFieldDefinition_default.sequelize.transaction(async (transaction) => {
+		const customFieldDefinition = await CustomFieldDefinition_default.create(definitionData, { transaction });
+		if (modelTypeIds?.length) await CustomFieldModelTypeMap_default.bulkCreate(modelTypeIds.map((modelTypeId) => ({
+			customFieldDefinitionId: customFieldDefinition.id,
+			modelTypeId
+		})), { transaction });
+		return customFieldDefinition;
+	});
+	result.modelTypeIds = modelTypeIds ?? [];
+	return result;
+};
+const findAll = async (where, options = { withDisabled: false }) => {
+	const queryModel = options.withDisabled ? CustomFieldDefinition_default.unscoped() : CustomFieldDefinition_default;
+	let includeToUse = options.include;
+	if (options.enrichWithModelTypeIds && hasModelTypeMappingsAssociation()) {
+		const modelTypeMappingsInclude = {
+			association: "modelTypeMappings",
+			required: false,
+			attributes: ["modelTypeId"]
+		};
+		if (options.include) includeToUse = Array.isArray(options.include) ? [...options.include, modelTypeMappingsInclude] : [options.include, modelTypeMappingsInclude];
+		else includeToUse = modelTypeMappingsInclude;
+	}
+	const definitions = await queryModel.scope("userScope").findAll({
+		where,
+		transaction: options.transaction,
+		raw: !options.enrichWithModelTypeIds,
+		include: includeToUse
+	});
+	if (options.enrichWithModelTypeIds && hasModelTypeMappingsAssociation()) return definitions.map(enrichDefinitionWithModelTypeIds);
+	return definitions;
+};
+const findByIds = (ids, options = { withDisabled: false }) => findAll({ id: { [Op.in]: ids } }, options);
+const findById = async (id, options = { withDisabled: false }) => {
+	const { withDisabled } = options;
+	const queryModel = withDisabled ? CustomFieldDefinition_default.unscoped().scope("userScope") : CustomFieldDefinition_default.scope("userScope");
+	const includeModelTypeMappings = hasModelTypeMappingsAssociation();
+	const definition = await queryModel.findByPk(id, { include: includeModelTypeMappings ? [{
+		association: "modelTypeMappings",
+		required: false,
+		attributes: ["modelTypeId"]
+	}] : void 0 });
+	if (!definition) return null;
+	if (includeModelTypeMappings) return enrichDefinitionWithModelTypeIds(definition);
+	return definition;
+};
+const findByEntityIds = async (modelType, entityIds, options = {}) => {
+	const { include, useEntityIdFromInclude } = options.modelOptions;
+	const where = {
+		modelType,
+		...!useEntityIdFromInclude && { entityId: { [Op.in]: entityIds } }
+	};
+	return CustomFieldDefinition_default.findAll({
+		where,
+		transaction: options.transaction,
+		include: include?.(entityIds),
+		raw: true
+	});
+};
+const findByWhere = (where) => CustomFieldDefinition_default.scope("userScope").findOne({ where });
+const update = async (id, data) => {
+	const { modelTypeIds, ...definitionData } = data;
+	const result = await CustomFieldDefinition_default.sequelize.transaction(async (transaction) => {
+		const updatedDefinition = (await CustomFieldDefinition_default.scope("userScope").update(definitionData, {
+			where: { id },
+			returning: true,
+			individualHooks: true,
+			transaction
+		}))[1][0];
+		if (modelTypeIds) {
+			const existingMappings = await CustomFieldModelTypeMap_default.findAll({
+				where: { customFieldDefinitionId: id },
+				attributes: ["id", "modelTypeId"],
+				raw: true,
+				transaction
+			});
+			const existingTypeIds = existingMappings.map((m) => m.modelTypeId);
+			const toAdd = modelTypeIds.filter((typeId) => !existingTypeIds.includes(typeId));
+			const toRemove = existingMappings.filter((m) => !modelTypeIds.includes(m.modelTypeId));
+			const hasMappingChanges = toRemove.length > 0 || toAdd.length > 0;
+			if (toRemove.length > 0) await CustomFieldModelTypeMap_default.destroy({
+				where: { id: toRemove.map((m) => m.id) },
+				transaction
+			});
+			if (toAdd.length > 0) await CustomFieldModelTypeMap_default.bulkCreate(toAdd.map((modelTypeId) => ({
+				customFieldDefinitionId: id,
+				modelTypeId
+			})), { transaction });
+			if (hasMappingChanges) {
+				updatedDefinition.changed("updatedAt", true);
+				await updatedDefinition.save({ transaction });
+			}
+		}
+		return updatedDefinition;
+	});
+	result.modelTypeIds = modelTypeIds ?? [];
+	return result;
+};
+/**
+* @returns A promise resolving with a dictionary of custom field definitions by name.
+* @throws A {@link MissingDefinitionError} if any of the custom fields doesn't have a definition.
+*/
+/**
+* Find custom field definitions applicable to a specific model type instance
+*
+* Returns definitions that either:
+* 1. Have NO mappings (apply to all instances of this model type)
+* 2. Have a mapping to this specific model type instance
+*/
+const findByModelTypeId = async (modelTypeId, options = {
+	withDisabled: false,
+	modelType: ""
+}) => {
+	const { withDisabled, entityIds, modelType, modelOptions } = options;
+	const { include, useEntityIdFromInclude } = modelOptions ?? {};
+	const baseWhere = {
+		modelType,
+		...!useEntityIdFromInclude && entityIds && entityIds.length > 0 && { entityId: { [Op.in]: entityIds } }
+	};
+	const queryModel = withDisabled ? CustomFieldDefinition_default.unscoped() : CustomFieldDefinition_default;
+	const includeModelTypeMappings = hasModelTypeMappingsAssociation();
+	const includeArray = [];
+	if (includeModelTypeMappings) includeArray.push({
+		association: "modelTypeMappings",
+		required: false,
+		attributes: ["id", "modelTypeId"]
+	});
+	if (useEntityIdFromInclude && include && entityIds) {
+		const contextIncludes = include(entityIds);
+		includeArray.push(...contextIncludes);
+	}
+	const definitions = await queryModel.scope("userScope").findAll({
+		where: baseWhere,
+		include: includeArray.length > 0 ? includeArray : void 0,
+		raw: false,
+		transaction: options.transaction
+	});
+	const filteredDefinitions = includeModelTypeMappings ? definitions.filter((def) => {
+		const mappings = def.modelTypeMappings ?? def.dataValues?.modelTypeMappings ?? [];
+		if (!Array.isArray(mappings) || mappings.length === 0) return true;
+		return mappings.some((mapping) => {
+			return (mapping.modelTypeId ?? mapping.dataValues?.modelTypeId) === modelTypeId;
+		});
+	}) : definitions;
+	if (includeModelTypeMappings) return filteredDefinitions.map(enrichDefinitionWithModelTypeIds);
+	return filteredDefinitions;
+};
+const getCustomFieldDefinitionsDictionary = async (instances, { findAll: _findAll, modelOptions = {}, withDisabled = false, ...options } = {
+	withDisabled: false,
+	modelOptions: {}
+}) => {
+	const { modelType } = instances[0]?.dataValues ?? {};
+	const customFields = /* @__PURE__ */ new Set();
+	const modelIds = [];
+	const entityIds = /* @__PURE__ */ new Set();
+	instances.forEach((instance) => {
+		const { dataValues: { modelId, entityId, customFields: instanceCustomFields } } = instance;
+		modelIds.push(modelId);
+		entityIds.add(entityId);
+		Object.keys(instanceCustomFields ?? {}).forEach((fieldName) => {
+			customFields.add(fieldName);
+		});
+	});
+	const where = {
+		modelType,
+		entityId: { [Op.in]: Array.from(entityIds) },
+		name: { [Op.in]: Array.from(customFields) }
+	};
+	const definitions = await (_findAll ?? findAll)(where, {
+		withDisabled,
+		modelOptions,
+		...options
+	});
+	const matchedDefinitions = definitions.filter((def) => customFields.has(def.name));
+	const matchedDefinitionsByName = Object.fromEntries(matchedDefinitions.map((definition) => [definition.name, definition]));
+	if (!definitions?.length || matchedDefinitions.length !== customFields.size) throw new MissingDefinitionError(Array.from(customFields).filter((customField) => !matchedDefinitionsByName[customField]));
+	return matchedDefinitionsByName;
+};
+
+//#endregion
+export { create, findAll, findByEntityIds, findById, findByIds, findByModelTypeId, findByWhere, getCustomFieldDefinitionsDictionary, update };

package/dist/repository/entries.cjs

@@ -0,0 +1,69 @@
+const require_index = require('../utils/logger/index.cjs');
+const require_index$1 = require('../errors/index.cjs');
+const require_definition = require('./definition.cjs');
+const require_CustomFieldEntries = require('../models/CustomFieldEntries.cjs');
+require('../models/index.cjs');
+const require_formatValues = require('./utils/formatValues.cjs');
+
+//#region src/repository/entries.ts
+const findEntriesByModelId = async (modelId, options = {}) => {
+	const { transaction } = options;
+	return require_CustomFieldEntries.default.findOne({
+		where: { modelId },
+		transaction
+	});
+};
+const findEntriesByModelIds = async (modelIds, options = {}) => {
+	const { transaction } = options;
+	return require_CustomFieldEntries.default.findAll({
+		where: { modelId: modelIds },
+		transaction
+	});
+};
+const updateEntries = async (modelId, modelType, customFields, identifiers, options = {}) => {
+	const customFieldsNames = Object.keys(customFields);
+	require_index.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 require_definition.findAll(where, {
+		withDisabled: true,
+		transaction,
+		include: modelOptions.include?.(identifiers)
+	}) ?? [];
+	const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
+	if (fieldDefinitions.length !== customFieldsNames.length) {
+		require_index.default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, {
+			names: customFieldsNames,
+			fieldDefinitions
+		});
+		throw new require_index$1.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) require_index.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]) => require_formatValues.formatFunctions[definitionsByName[definitionName].fieldType]).forEach(([definitionName, value]) => {
+		const { fieldType } = definitionsByName[definitionName];
+		customFields[definitionName] = require_formatValues.formatFunctions[fieldType](value);
+	});
+	return require_CustomFieldEntries.default.upsert({
+		modelId,
+		entityId: fieldDefinitions[0].entityId,
+		modelType,
+		customFields
+	}, options);
+};
+
+//#endregion
+exports.findEntriesByModelId = findEntriesByModelId;
+exports.findEntriesByModelIds = findEntriesByModelIds;
+exports.updateEntries = updateEntries;