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

package/dist/migrations/index.js

@@ -0,0 +1,95 @@
+import { __require } from "../_virtual/rolldown_runtime.js";
+import logger_default from "../utils/logger/index.js";
+import { down, up } from "./001-create-core-tables.js";
+import { down as down$1, up as up$1 } from "./002-create-custom-field-entries.js";
+import { down as down$2, up as up$2 } from "./003-create-custom-field-model-type-map.js";
+import { down as down$3, up as up$3 } from "./004-create-field-policy-tables.js";
+import { down as down$4, up as up$4 } from "./005-add-entity-type-to-field-policies.js";
+
+//#region src/migrations/index.ts
+const { Umzug, SequelizeStorage } = __require("umzug");
+const buildMigrationList = (options) => {
+	const { useCustomFieldsEntries = false, useModelTypeMapping = false } = options;
+	return [
+		{
+			name: "001-create-core-tables",
+			up,
+			down
+		},
+		...useCustomFieldsEntries ? [{
+			name: "002-create-custom-field-entries",
+			up: up$1,
+			down: down$1
+		}] : [],
+		...useModelTypeMapping ? [{
+			name: "003-create-custom-field-model-type-map",
+			up: up$2,
+			down: down$2
+		}] : [],
+		{
+			name: "004-create-field-policy-tables",
+			up: up$3,
+			down: down$3
+		},
+		{
+			name: "005-add-entity-type-to-field-policies",
+			up: up$4,
+			down: down$4
+		}
+	];
+};
+const SADOT_MIGRATION_LOCK_ID = 839274628;
+/**
+* Runs sadot migrations via umzug. All migrations use IF NOT EXISTS / IF EXISTS,
+* so they are fully idempotent — safe to run against both fresh and existing
+* databases (including DBs previously managed by the legacy sync() path).
+*
+* A PostgreSQL advisory lock is acquired before running migrations so that when
+* multiple pods start concurrently only one of them executes the migrations.
+* The remaining pods block until the lock is released, then proceed — Umzug will
+* see the migrations have already been applied and skip them.
+*/
+const runSadotMigrations = async (sequelize, options = {}) => {
+	const queryInterface = sequelize.getQueryInterface();
+	const storage = new SequelizeStorage({
+		sequelize,
+		tableName: "sadot_migrations"
+	});
+	const migrator = new Umzug({
+		migrations: buildMigrationList(options),
+		context: queryInterface,
+		storage,
+		logger: {
+			info: (msg) => logger_default.info(`[sadot] ${JSON.stringify(msg)}`),
+			warn: (msg) => logger_default.warn(`[sadot] ${JSON.stringify(msg)}`),
+			error: (msg) => logger_default.error(`[sadot] ${JSON.stringify(msg)}`),
+			debug: (msg) => logger_default.debug(`[sadot] ${JSON.stringify(msg)}`)
+		}
+	});
+	const pending = await migrator.pending();
+	if (pending.length === 0) {
+		logger_default.info("[sadot] no pending migrations, skipping");
+		return;
+	}
+	logger_default.info("[sadot] pending migrations detected", { pending: pending.map((m) => m.name) });
+	if ((sequelize.options?.pool?.max ?? 5) < 2) {
+		logger_default.info("[sadot] connection pool too small for advisory lock, running migrations directly");
+		await migrator.up();
+		return;
+	}
+	logger_default.info("[sadot] acquiring advisory lock");
+	const transaction = await sequelize.transaction();
+	try {
+		await sequelize.query(`SELECT pg_advisory_lock(${SADOT_MIGRATION_LOCK_ID})`, { transaction });
+		logger_default.info("[sadot] advisory lock acquired");
+		if ((await migrator.pending()).length > 0) await migrator.up();
+		else logger_default.info("[sadot] migrations already applied by another instance, skipping");
+	} finally {
+		await sequelize.query(`SELECT pg_advisory_unlock(${SADOT_MIGRATION_LOCK_ID})`, { transaction });
+		await transaction.commit();
+		logger_default.info("[sadot] advisory lock released");
+	}
+};
+
+//#endregion
+export { runSadotMigrations };

package/dist/models/CustomFieldDefinition.cjs

@@ -0,0 +1,147 @@
+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('../utils/validations/validators/index.cjs');
+const require_index$3 = require('../events/index.cjs');
+const require_index$4 = require('../errors/index.cjs');
+const require_index$5 = require('../utils/validations/index.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_CustomFieldValue = require('./CustomFieldValue.cjs');
+let sequelize_typescript = require("sequelize-typescript");
+
+//#region src/models/CustomFieldDefinition.ts
+var _ref, _ref2, _ref3, _ref4, _ref5, _ref6;
+let CustomFieldDefinition = class CustomFieldDefinition$1 extends sequelize_typescript.Model {
+	get modelTypeIds() {
+		return this._modelTypeIds;
+	}
+	set modelTypeIds(value) {
+		this._modelTypeIds = value;
+		this.setDataValue("modelTypeIds", value);
+	}
+	static displayNameDefaultValue(instance) {
+		if (!instance?.displayName) instance.displayName = instance.name;
+		if (![null, void 0].includes(instance.defaultValue)) {
+			const isValid = require_index$5.validateValue(instance.defaultValue, instance.fieldType, instance.validation);
+			if (isValid.error) throw new require_index$4.InvalidValueError(instance.defaultValue, instance.name, isValid.error);
+		}
+	}
+	static afterSaveHandler(instance, options) {
+		if (options.transaction) options.transaction.afterCommit(() => require_index$3.sendDimEvent(instance));
+		else require_index$3.sendDimEvent(instance);
+	}
+	/**
+	* Override toJSON to exclude internal associations from API responses
+	* The modelTypeMappings association is used internally to optimize queries
+	* but should not be exposed in the API response (use modelTypeIds instead)
+	*/
+	toJSON() {
+		const { modelTypeMappings: _modelTypeMappings, ...values } = this.get();
+		return values;
+	}
+};
+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)
+], CustomFieldDefinition.prototype, "id", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.STRING,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "name", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.STRING }), require_decorateMetadata.__decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "displayName", void 0);
+require_decorate.__decorate([
+	(0, sequelize_typescript.Is)("SupportedType", (value) => {
+		if (!Object.values(require_index$1.CustomFieldDefinitionType).includes(value)) throw new require_index$4.UnsupportedCustomFieldTypeError(`"${value}" is not a supported type.`);
+	}),
+	(0, sequelize_typescript.Column)({
+		type: sequelize_typescript.DataType.STRING,
+		allowNull: false
+	}),
+	require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref = typeof require_index$1.CustomFieldDefinitionType !== "undefined" && require_index$1.CustomFieldDefinitionType) === "function" ? _ref : Object)
+], CustomFieldDefinition.prototype, "fieldType", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.JSONB }), require_decorateMetadata.__decorateMetadata("design:type", Object)], CustomFieldDefinition.prototype, "validation", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.UUID,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "entityId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.STRING,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "entityType", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.STRING,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "modelType", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({ type: sequelize_typescript.DataType.TEXT }), require_decorateMetadata.__decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "description", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.BOOLEAN,
+	defaultValue: false
+}), require_decorateMetadata.__decorateMetadata("design:type", Boolean)], CustomFieldDefinition.prototype, "required", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.BOOLEAN,
+	defaultValue: false
+}), require_decorateMetadata.__decorateMetadata("design:type", Boolean)], CustomFieldDefinition.prototype, "disabled", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.JSONB,
+	allowNull: true
+}), require_decorateMetadata.__decorateMetadata("design:type", Object)], CustomFieldDefinition.prototype, "defaultValue", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.DATE,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref2 = typeof Date !== "undefined" && Date) === "function" ? _ref2 : Object)], CustomFieldDefinition.prototype, "createdAt", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.DATE,
+	allowNull: true
+}), require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref3 = typeof Date !== "undefined" && Date) === "function" ? _ref3 : Object)], CustomFieldDefinition.prototype, "updatedAt", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.DATE,
+	allowNull: true
+}), require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref4 = typeof Date !== "undefined" && Date) === "function" ? _ref4 : Object)], CustomFieldDefinition.prototype, "deletedAt", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.BOOLEAN,
+	defaultValue: false,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", Boolean)], CustomFieldDefinition.prototype, "blockEditingFromUI", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.HasMany)(() => require_CustomFieldValue.default), require_decorateMetadata.__decorateMetadata("design:type", Array)], CustomFieldDefinition.prototype, "values", void 0);
+require_decorate.__decorate([
+	sequelize_typescript.BeforeCreate,
+	require_decorateMetadata.__decorateMetadata("design:type", Function),
+	require_decorateMetadata.__decorateMetadata("design:paramtypes", [typeof (_ref5 = typeof CustomFieldDefinition !== "undefined" && CustomFieldDefinition) === "function" ? _ref5 : Object]),
+	require_decorateMetadata.__decorateMetadata("design:returntype", void 0)
+], CustomFieldDefinition, "displayNameDefaultValue", null);
+require_decorate.__decorate([
+	sequelize_typescript.AfterSave,
+	require_decorateMetadata.__decorateMetadata("design:type", Function),
+	require_decorateMetadata.__decorateMetadata("design:paramtypes", [typeof (_ref6 = typeof CustomFieldDefinition !== "undefined" && CustomFieldDefinition) === "function" ? _ref6 : Object, Object]),
+	require_decorateMetadata.__decorateMetadata("design:returntype", void 0)
+], CustomFieldDefinition, "afterSaveHandler", null);
+CustomFieldDefinition = require_decorate.__decorate([(0, sequelize_typescript.DefaultScope)(() => ({ where: { disabled: false } })), (0, sequelize_typescript.Table)({
+	tableName: "custom_field_definitions",
+	modelName: "CustomFieldDefinition",
+	indexes: [{
+		name: "unique_name_model_type",
+		fields: [
+			"model_type",
+			"entity_id",
+			"name"
+		],
+		unique: true
+	}],
+	timestamps: true,
+	validate: { validationByType() {
+		if (!this.validation && require_index$2.CustomValidationTypes[this.fieldType]) {
+			require_index.default.error(`No custom validation for custom field type ${this.fieldType} found`);
+			throw new require_index$4.UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
+		}
+	} }
+})], CustomFieldDefinition);
+var CustomFieldDefinition_default = CustomFieldDefinition;
+
+//#endregion
+exports.default = CustomFieldDefinition_default;

package/dist/models/CustomFieldDefinition.d.cts

@@ -0,0 +1,40 @@
+import { CustomFieldDefinitionType } from "../utils/constants/index.cjs";
+import { CustomFieldValue } from "./CustomFieldValue.cjs";
+import { CustomFieldModelTypeMap } from "./CustomFieldModelTypeMap.cjs";
+import { Model } from "sequelize-typescript";
+import { CreateOptions } from "sequelize";
+
+//#region src/models/CustomFieldDefinition.d.ts
+declare class CustomFieldDefinition extends Model {
+  id: string;
+  name: string;
+  displayName?: string;
+  fieldType: CustomFieldDefinitionType;
+  validation?: any;
+  entityId: string;
+  entityType: string;
+  modelType: string;
+  description?: string;
+  required?: boolean;
+  disabled?: boolean;
+  defaultValue?: any;
+  createdAt?: Date;
+  updatedAt?: Date;
+  deletedAt?: Date;
+  blockEditingFromUI: boolean;
+  values: CustomFieldValue[];
+  modelTypeMappings?: CustomFieldModelTypeMap[];
+  private _modelTypeIds?;
+  get modelTypeIds(): string[] | undefined;
+  set modelTypeIds(value: string[] | undefined);
+  static displayNameDefaultValue(instance: CustomFieldDefinition): void;
+  static afterSaveHandler(instance: CustomFieldDefinition, options: CreateOptions): void;
+  /**
+  * Override toJSON to exclude internal associations from API responses
+  * The modelTypeMappings association is used internally to optimize queries
+  * but should not be exposed in the API response (use modelTypeIds instead)
+  */
+  toJSON(): object;
+}
+//#endregion
+export { CustomFieldDefinition };

package/dist/models/CustomFieldDefinition.d.ts

@@ -0,0 +1,40 @@
+import { CustomFieldDefinitionType } from "../utils/constants/index.js";
+import { CustomFieldValue } from "./CustomFieldValue.js";
+import { CustomFieldModelTypeMap } from "./CustomFieldModelTypeMap.js";
+import { CreateOptions } from "sequelize";
+import { Model } from "sequelize-typescript";
+
+//#region src/models/CustomFieldDefinition.d.ts
+declare class CustomFieldDefinition extends Model {
+  id: string;
+  name: string;
+  displayName?: string;
+  fieldType: CustomFieldDefinitionType;
+  validation?: any;
+  entityId: string;
+  entityType: string;
+  modelType: string;
+  description?: string;
+  required?: boolean;
+  disabled?: boolean;
+  defaultValue?: any;
+  createdAt?: Date;
+  updatedAt?: Date;
+  deletedAt?: Date;
+  blockEditingFromUI: boolean;
+  values: CustomFieldValue[];
+  modelTypeMappings?: CustomFieldModelTypeMap[];
+  private _modelTypeIds?;
+  get modelTypeIds(): string[] | undefined;
+  set modelTypeIds(value: string[] | undefined);
+  static displayNameDefaultValue(instance: CustomFieldDefinition): void;
+  static afterSaveHandler(instance: CustomFieldDefinition, options: CreateOptions): void;
+  /**
+  * Override toJSON to exclude internal associations from API responses
+  * The modelTypeMappings association is used internally to optimize queries
+  * but should not be exposed in the API response (use modelTypeIds instead)
+  */
+  toJSON(): object;
+}
+//#endregion
+export { CustomFieldDefinition };

package/dist/models/CustomFieldDefinition.js

@@ -0,0 +1,146 @@
+import logger_default from "../utils/logger/index.js";
+import { CustomFieldDefinitionType } from "../utils/constants/index.js";
+import { CustomValidationTypes } from "../utils/validations/validators/index.js";
+import { sendDimEvent } from "../events/index.js";
+import { InvalidValueError, UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } from "../errors/index.js";
+import { validateValue } from "../utils/validations/index.js";
+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 CustomFieldValue_default from "./CustomFieldValue.js";
+import { AfterSave, BeforeCreate, Column, DataType, DefaultScope, HasMany, Is, Model, PrimaryKey, Table } from "sequelize-typescript";
+
+//#region src/models/CustomFieldDefinition.ts
+var _ref, _ref2, _ref3, _ref4, _ref5, _ref6;
+let CustomFieldDefinition = class CustomFieldDefinition$1 extends Model {
+	get modelTypeIds() {
+		return this._modelTypeIds;
+	}
+	set modelTypeIds(value) {
+		this._modelTypeIds = value;
+		this.setDataValue("modelTypeIds", value);
+	}
+	static displayNameDefaultValue(instance) {
+		if (!instance?.displayName) instance.displayName = instance.name;
+		if (![null, void 0].includes(instance.defaultValue)) {
+			const isValid = validateValue(instance.defaultValue, instance.fieldType, instance.validation);
+			if (isValid.error) throw new InvalidValueError(instance.defaultValue, instance.name, isValid.error);
+		}
+	}
+	static afterSaveHandler(instance, options) {
+		if (options.transaction) options.transaction.afterCommit(() => sendDimEvent(instance));
+		else sendDimEvent(instance);
+	}
+	/**
+	* Override toJSON to exclude internal associations from API responses
+	* The modelTypeMappings association is used internally to optimize queries
+	* but should not be exposed in the API response (use modelTypeIds instead)
+	*/
+	toJSON() {
+		const { modelTypeMappings: _modelTypeMappings, ...values } = this.get();
+		return values;
+	}
+};
+__decorate([
+	PrimaryKey,
+	Column({
+		type: DataType.UUID,
+		defaultValue: DataType.UUIDV4,
+		allowNull: false
+	}),
+	__decorateMetadata("design:type", String)
+], CustomFieldDefinition.prototype, "id", void 0);
+__decorate([Column({
+	type: DataType.STRING,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "name", void 0);
+__decorate([Column({ type: DataType.STRING }), __decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "displayName", void 0);
+__decorate([
+	Is("SupportedType", (value) => {
+		if (!Object.values(CustomFieldDefinitionType).includes(value)) throw new UnsupportedCustomFieldTypeError(`"${value}" is not a supported type.`);
+	}),
+	Column({
+		type: DataType.STRING,
+		allowNull: false
+	}),
+	__decorateMetadata("design:type", typeof (_ref = typeof CustomFieldDefinitionType !== "undefined" && CustomFieldDefinitionType) === "function" ? _ref : Object)
+], CustomFieldDefinition.prototype, "fieldType", void 0);
+__decorate([Column({ type: DataType.JSONB }), __decorateMetadata("design:type", Object)], CustomFieldDefinition.prototype, "validation", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "entityId", void 0);
+__decorate([Column({
+	type: DataType.STRING,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "entityType", void 0);
+__decorate([Column({
+	type: DataType.STRING,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "modelType", void 0);
+__decorate([Column({ type: DataType.TEXT }), __decorateMetadata("design:type", String)], CustomFieldDefinition.prototype, "description", void 0);
+__decorate([Column({
+	type: DataType.BOOLEAN,
+	defaultValue: false
+}), __decorateMetadata("design:type", Boolean)], CustomFieldDefinition.prototype, "required", void 0);
+__decorate([Column({
+	type: DataType.BOOLEAN,
+	defaultValue: false
+}), __decorateMetadata("design:type", Boolean)], CustomFieldDefinition.prototype, "disabled", void 0);
+__decorate([Column({
+	type: DataType.JSONB,
+	allowNull: true
+}), __decorateMetadata("design:type", Object)], CustomFieldDefinition.prototype, "defaultValue", void 0);
+__decorate([Column({
+	type: DataType.DATE,
+	allowNull: false
+}), __decorateMetadata("design:type", typeof (_ref2 = typeof Date !== "undefined" && Date) === "function" ? _ref2 : Object)], CustomFieldDefinition.prototype, "createdAt", void 0);
+__decorate([Column({
+	type: DataType.DATE,
+	allowNull: true
+}), __decorateMetadata("design:type", typeof (_ref3 = typeof Date !== "undefined" && Date) === "function" ? _ref3 : Object)], CustomFieldDefinition.prototype, "updatedAt", void 0);
+__decorate([Column({
+	type: DataType.DATE,
+	allowNull: true
+}), __decorateMetadata("design:type", typeof (_ref4 = typeof Date !== "undefined" && Date) === "function" ? _ref4 : Object)], CustomFieldDefinition.prototype, "deletedAt", void 0);
+__decorate([Column({
+	type: DataType.BOOLEAN,
+	defaultValue: false,
+	allowNull: false
+}), __decorateMetadata("design:type", Boolean)], CustomFieldDefinition.prototype, "blockEditingFromUI", void 0);
+__decorate([HasMany(() => CustomFieldValue_default), __decorateMetadata("design:type", Array)], CustomFieldDefinition.prototype, "values", void 0);
+__decorate([
+	BeforeCreate,
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [typeof (_ref5 = typeof CustomFieldDefinition !== "undefined" && CustomFieldDefinition) === "function" ? _ref5 : Object]),
+	__decorateMetadata("design:returntype", void 0)
+], CustomFieldDefinition, "displayNameDefaultValue", null);
+__decorate([
+	AfterSave,
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [typeof (_ref6 = typeof CustomFieldDefinition !== "undefined" && CustomFieldDefinition) === "function" ? _ref6 : Object, Object]),
+	__decorateMetadata("design:returntype", void 0)
+], CustomFieldDefinition, "afterSaveHandler", null);
+CustomFieldDefinition = __decorate([DefaultScope(() => ({ where: { disabled: false } })), Table({
+	tableName: "custom_field_definitions",
+	modelName: "CustomFieldDefinition",
+	indexes: [{
+		name: "unique_name_model_type",
+		fields: [
+			"model_type",
+			"entity_id",
+			"name"
+		],
+		unique: true
+	}],
+	timestamps: true,
+	validate: { validationByType() {
+		if (!this.validation && CustomValidationTypes[this.fieldType]) {
+			logger_default.error(`No custom validation for custom field type ${this.fieldType} found`);
+			throw new UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
+		}
+	} }
+})], CustomFieldDefinition);
+var CustomFieldDefinition_default = CustomFieldDefinition;
+
+//#endregion
+export { CustomFieldDefinition_default as default };

package/dist/models/CustomFieldEntries.cjs

@@ -0,0 +1,71 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../events/index.cjs');
+const require_index$1 = require('../utils/validations/index.cjs');
+const require_definition = require('../repository/definition.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/CustomFieldEntries.ts
+var _ref, _ref2, _ref3;
+let CustomFieldEntries = class CustomFieldEntries$1 extends sequelize_typescript.Model {
+	static afterSaveHandler(instance, options) {
+		if (options.transaction) options.transaction.afterCommit(() => require_index.sendDimEvent(instance[0]));
+		else require_index.sendDimEvent(instance[0]);
+	}
+};
+require_decorate.__decorate([
+	sequelize_typescript.PrimaryKey,
+	(0, sequelize_typescript.Column)({
+		type: sequelize_typescript.DataType.UUID,
+		allowNull: false
+	}),
+	require_decorateMetadata.__decorateMetadata("design:type", String)
+], CustomFieldEntries.prototype, "modelId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.UUID,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], CustomFieldEntries.prototype, "entityId", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.JSONB,
+	allowNull: false,
+	defaultValue: {}
+}), require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref = typeof Record !== "undefined" && Record) === "function" ? _ref : Object)], CustomFieldEntries.prototype, "customFields", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.STRING,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", String)], CustomFieldEntries.prototype, "modelType", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.DATE,
+	allowNull: false
+}), require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref2 = typeof Date !== "undefined" && Date) === "function" ? _ref2 : Object)], CustomFieldEntries.prototype, "createdAt", void 0);
+require_decorate.__decorate([(0, sequelize_typescript.Column)({
+	type: sequelize_typescript.DataType.DATE,
+	allowNull: true
+}), require_decorateMetadata.__decorateMetadata("design:type", typeof (_ref3 = typeof Date !== "undefined" && Date) === "function" ? _ref3 : Object)], CustomFieldEntries.prototype, "updatedAt", void 0);
+require_decorate.__decorate([
+	sequelize_typescript.AfterUpsert,
+	require_decorateMetadata.__decorateMetadata("design:type", Function),
+	require_decorateMetadata.__decorateMetadata("design:paramtypes", [Array, Object]),
+	require_decorateMetadata.__decorateMetadata("design:returntype", void 0)
+], CustomFieldEntries, "afterSaveHandler", null);
+CustomFieldEntries = require_decorate.__decorate([(0, sequelize_typescript.Table)({
+	tableName: "custom_field_entries",
+	modelName: "CustomFieldEntries",
+	timestamps: true,
+	indexes: [{
+		name: "idx_cfe_custom_fields",
+		using: "gin",
+		operator: "jsonb_path_ops",
+		fields: ["custom_fields"]
+	}],
+	validate: { async validationByType() {
+		if (!Object.keys(this.customFields ?? {}).length) return;
+		const definitionsByName = await require_definition.getCustomFieldDefinitionsDictionary([this]);
+		require_index$1.validateInstanceCustomFieldEntries(this, definitionsByName);
+	} }
+})], CustomFieldEntries);
+var CustomFieldEntries_default = CustomFieldEntries;
+
+//#endregion
+exports.default = CustomFieldEntries_default;

package/dist/models/CustomFieldEntries.d.cts

@@ -0,0 +1,15 @@
+import { Model } from "sequelize-typescript";
+import { CreateOptions } from "sequelize";
+
+//#region src/models/CustomFieldEntries.d.ts
+declare class CustomFieldEntries extends Model {
+  modelId: string;
+  entityId: string;
+  customFields: Record<string, any>;
+  modelType: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  static afterSaveHandler(instance: CustomFieldEntries[], options: CreateOptions): void;
+}
+//#endregion
+export { CustomFieldEntries };

package/dist/models/CustomFieldEntries.d.ts

@@ -0,0 +1,15 @@
+import { CreateOptions } from "sequelize";
+import { Model } from "sequelize-typescript";
+
+//#region src/models/CustomFieldEntries.d.ts
+declare class CustomFieldEntries extends Model {
+  modelId: string;
+  entityId: string;
+  customFields: Record<string, any>;
+  modelType: string;
+  createdAt?: Date;
+  updatedAt?: Date;
+  static afterSaveHandler(instance: CustomFieldEntries[], options: CreateOptions): void;
+}
+//#endregion
+export { CustomFieldEntries };

package/dist/models/CustomFieldEntries.js

@@ -0,0 +1,70 @@
+import { sendDimEvent } from "../events/index.js";
+import { validateInstanceCustomFieldEntries } from "../utils/validations/index.js";
+import { getCustomFieldDefinitionsDictionary } from "../repository/definition.js";
+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 { AfterUpsert, Column, DataType, Model, PrimaryKey, Table } from "sequelize-typescript";
+
+//#region src/models/CustomFieldEntries.ts
+var _ref, _ref2, _ref3;
+let CustomFieldEntries = class CustomFieldEntries$1 extends Model {
+	static afterSaveHandler(instance, options) {
+		if (options.transaction) options.transaction.afterCommit(() => sendDimEvent(instance[0]));
+		else sendDimEvent(instance[0]);
+	}
+};
+__decorate([
+	PrimaryKey,
+	Column({
+		type: DataType.UUID,
+		allowNull: false
+	}),
+	__decorateMetadata("design:type", String)
+], CustomFieldEntries.prototype, "modelId", void 0);
+__decorate([Column({
+	type: DataType.UUID,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], CustomFieldEntries.prototype, "entityId", void 0);
+__decorate([Column({
+	type: DataType.JSONB,
+	allowNull: false,
+	defaultValue: {}
+}), __decorateMetadata("design:type", typeof (_ref = typeof Record !== "undefined" && Record) === "function" ? _ref : Object)], CustomFieldEntries.prototype, "customFields", void 0);
+__decorate([Column({
+	type: DataType.STRING,
+	allowNull: false
+}), __decorateMetadata("design:type", String)], CustomFieldEntries.prototype, "modelType", void 0);
+__decorate([Column({
+	type: DataType.DATE,
+	allowNull: false
+}), __decorateMetadata("design:type", typeof (_ref2 = typeof Date !== "undefined" && Date) === "function" ? _ref2 : Object)], CustomFieldEntries.prototype, "createdAt", void 0);
+__decorate([Column({
+	type: DataType.DATE,
+	allowNull: true
+}), __decorateMetadata("design:type", typeof (_ref3 = typeof Date !== "undefined" && Date) === "function" ? _ref3 : Object)], CustomFieldEntries.prototype, "updatedAt", void 0);
+__decorate([
+	AfterUpsert,
+	__decorateMetadata("design:type", Function),
+	__decorateMetadata("design:paramtypes", [Array, Object]),
+	__decorateMetadata("design:returntype", void 0)
+], CustomFieldEntries, "afterSaveHandler", null);
+CustomFieldEntries = __decorate([Table({
+	tableName: "custom_field_entries",
+	modelName: "CustomFieldEntries",
+	timestamps: true,
+	indexes: [{
+		name: "idx_cfe_custom_fields",
+		using: "gin",
+		operator: "jsonb_path_ops",
+		fields: ["custom_fields"]
+	}],
+	validate: { async validationByType() {
+		if (!Object.keys(this.customFields ?? {}).length) return;
+		const definitionsByName = await getCustomFieldDefinitionsDictionary([this]);
+		validateInstanceCustomFieldEntries(this, definitionsByName);
+	} }
+})], CustomFieldEntries);
+var CustomFieldEntries_default = CustomFieldEntries;
+
+//#endregion
+export { CustomFieldEntries_default as default };