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

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.cjs

@@ -0,0 +1,11 @@
+
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+exports.__decorate = __decorate;

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorate.js

@@ -0,0 +1,10 @@
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+export { __decorate };

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.cjs

@@ -0,0 +1,8 @@
+
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+exports.__decorateMetadata = __decorateMetadata;

package/dist/_virtual/_@oxc-project_runtime@0.103.0/helpers/decorateMetadata.js

@@ -0,0 +1,7 @@
+//#region \0@oxc-project+runtime@0.103.0/helpers/decorateMetadata.js
+function __decorateMetadata(k, v) {
+	if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+}
+
+//#endregion
+export { __decorateMetadata };

package/dist/_virtual/rolldown_runtime.cjs

@@ -0,0 +1,43 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") {
+		for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+			key = keys[i];
+			if (!__hasOwnProp.call(to, key) && key !== except) {
+				__defProp(to, key, {
+					get: ((k) => from[k]).bind(null, key),
+					enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+				});
+			}
+		}
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+
+exports.__export = __export;
+exports.__toESM = __toESM;

package/dist/{chunk-DJulfCLt.js → _virtual/rolldown_runtime.js}

@@ -2,7 +2,6 @@ import { createRequire } from "node:module";
 
 //#region rolldown:runtime
 var __defProp = Object.defineProperty;
-var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __export = (all, symbols) => {
 	let target = {};
 	for (var name in all) {
@@ -19,4 +18,4 @@ var __export = (all, symbols) => {
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 
 //#endregion
-export { __export as n, __require as r, __commonJSMin as t };
+export { __export, __require };

package/dist/api/index.cjs

@@ -0,0 +1,12 @@
+const require_rolldown_runtime = require('../_virtual/rolldown_runtime.cjs');
+const require_index = require('../utils/logger/index.cjs');
+const require_index$1 = require('./v1/index.cjs');
+let _autofleet_node_common = require("@autofleet/node-common");
+
+//#region src/api/index.ts
+const router = (0, _autofleet_node_common.Router)({ logger: require_index.default });
+router.use("/v1", require_index$1.default);
+var api_default = router;
+
+//#endregion
+exports.default = api_default;

package/dist/api/index.js

@@ -0,0 +1,11 @@
+import logger_default from "../utils/logger/index.js";
+import v1_default from "./v1/index.js";
+import { Router } from "@autofleet/node-common";
+
+//#region src/api/index.ts
+const router = Router({ logger: logger_default });
+router.use("/v1", v1_default);
+var api_default = router;
+
+//#endregion
+export { api_default as default };

package/dist/api/v1/definition/index.cjs

@@ -0,0 +1,113 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../utils/logger/index.cjs');
+const require_definition = require('../../../repository/definition.cjs');
+const require_errors = require('../errors.cjs');
+const require_validations = require('./validations.cjs');
+const require_mat_path_state = require('../../../mat-path-state.cjs');
+let _autofleet_errors = require("@autofleet/errors");
+let _autofleet_node_common = require("@autofleet/node-common");
+
+//#region src/api/v1/definition/index.ts
+const router = (0, _autofleet_node_common.Router)({ logger: require_index.default });
+const ENTITY = "CustomFieldDefinition";
+const toPascalCase = (str) => str.replace(/(^\w|-\w)/g, (subStr) => subStr.replace(/-/, "").toUpperCase());
+/**
+* Create
+*/
+router.post("/", async (req, res) => {
+	const { modelName } = req.params;
+	const modelType = toPascalCase(modelName);
+	try {
+		const validatedPayload = await require_validations.validateCustomFieldDefinitionCreation(req.body);
+		const customFieldDefinition = await require_definition.create({
+			...validatedPayload,
+			modelType
+		});
+		return res.status(201).json(customFieldDefinition);
+	} catch (err) {
+		require_index.default.error("Failed to create custom field definition", err);
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in create ${ENTITY} request`
+		});
+	}
+});
+/**
+* Get by id
+*/
+router.get("/:customFieldDefinitionId", async (req, res) => {
+	const { customFieldDefinitionId } = req.params;
+	try {
+		const customFieldDefinition = await require_definition.findById(customFieldDefinitionId);
+		if (!customFieldDefinition) throw new _autofleet_errors.ResourceNotFoundError();
+		return res.json(customFieldDefinition);
+	} catch (err) {
+		require_index.default.error("Failed to fetch custom field definition", err);
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in get ${ENTITY} request`
+		});
+	}
+});
+/**
+* Get all
+*/
+router.get("/", async (req, res) => {
+	const { params: { modelName }, query: { entityIds, modelTypeId } } = req;
+	const modelType = toPascalCase(modelName);
+	try {
+		const applyEntityIdsFilter = !require_mat_path_state.matPathState.isMatPathEnabled?.() && entityIds && entityIds.length > 0;
+		if (modelTypeId) {
+			const customFieldDefinitions$1 = await require_definition.findByModelTypeId(modelTypeId, {
+				withDisabled: true,
+				modelType,
+				entityIds: applyEntityIdsFilter ? entityIds : void 0
+			});
+			return res.json(customFieldDefinitions$1);
+		}
+		const where = {
+			modelType,
+			...applyEntityIdsFilter && { entityId: entityIds }
+		};
+		const customFieldDefinitions = await require_definition.findAll(where, {
+			withDisabled: true,
+			enrichWithModelTypeIds: true
+		});
+		return res.json(customFieldDefinitions);
+	} catch (err) {
+		require_index.default.error("Failed to fetch custom field definitions", err);
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in get all ${ENTITY} request`
+		});
+	}
+});
+/**
+* Update
+*/
+router.patch("/:customFieldDefinitionId", async (req, res) => {
+	const { customFieldDefinitionId, modelName } = req.params;
+	const modelType = toPascalCase(modelName);
+	try {
+		const validatedPayload = await require_validations.validateCustomFieldDefinitionUpdate(req.body);
+		if (!await require_definition.findByWhere({
+			id: customFieldDefinitionId,
+			modelType
+		})) throw new _autofleet_errors.ResourceNotFoundError();
+		const updatedCustomFieldDefinition = await require_definition.update(customFieldDefinitionId, {
+			...validatedPayload,
+			modelType
+		});
+		return res.status(200).json(updatedCustomFieldDefinition);
+	} catch (err) {
+		require_index.default.error("Failed to patch custom field definition", err);
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in update ${ENTITY} request`
+		});
+	}
+});
+var definition_default = router;
+
+//#endregion
+exports.default = definition_default;

package/dist/api/v1/definition/index.js

@@ -0,0 +1,112 @@
+import logger_default from "../../../utils/logger/index.js";
+import { create, findAll, findById, findByModelTypeId, findByWhere, update } from "../../../repository/definition.js";
+import errors_default from "../errors.js";
+import { validateCustomFieldDefinitionCreation, validateCustomFieldDefinitionUpdate } from "./validations.js";
+import { matPathState } from "../../../mat-path-state.js";
+import { ResourceNotFoundError } from "@autofleet/errors";
+import { Router } from "@autofleet/node-common";
+
+//#region src/api/v1/definition/index.ts
+const router = Router({ logger: logger_default });
+const ENTITY = "CustomFieldDefinition";
+const toPascalCase = (str) => str.replace(/(^\w|-\w)/g, (subStr) => subStr.replace(/-/, "").toUpperCase());
+/**
+* Create
+*/
+router.post("/", async (req, res) => {
+	const { modelName } = req.params;
+	const modelType = toPascalCase(modelName);
+	try {
+		const validatedPayload = await validateCustomFieldDefinitionCreation(req.body);
+		const customFieldDefinition = await create({
+			...validatedPayload,
+			modelType
+		});
+		return res.status(201).json(customFieldDefinition);
+	} catch (err) {
+		logger_default.error("Failed to create custom field definition", err);
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in create ${ENTITY} request`
+		});
+	}
+});
+/**
+* Get by id
+*/
+router.get("/:customFieldDefinitionId", async (req, res) => {
+	const { customFieldDefinitionId } = req.params;
+	try {
+		const customFieldDefinition = await findById(customFieldDefinitionId);
+		if (!customFieldDefinition) throw new ResourceNotFoundError();
+		return res.json(customFieldDefinition);
+	} catch (err) {
+		logger_default.error("Failed to fetch custom field definition", err);
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in get ${ENTITY} request`
+		});
+	}
+});
+/**
+* Get all
+*/
+router.get("/", async (req, res) => {
+	const { params: { modelName }, query: { entityIds, modelTypeId } } = req;
+	const modelType = toPascalCase(modelName);
+	try {
+		const applyEntityIdsFilter = !matPathState.isMatPathEnabled?.() && entityIds && entityIds.length > 0;
+		if (modelTypeId) {
+			const customFieldDefinitions$1 = await findByModelTypeId(modelTypeId, {
+				withDisabled: true,
+				modelType,
+				entityIds: applyEntityIdsFilter ? entityIds : void 0
+			});
+			return res.json(customFieldDefinitions$1);
+		}
+		const where = {
+			modelType,
+			...applyEntityIdsFilter && { entityId: entityIds }
+		};
+		const customFieldDefinitions = await findAll(where, {
+			withDisabled: true,
+			enrichWithModelTypeIds: true
+		});
+		return res.json(customFieldDefinitions);
+	} catch (err) {
+		logger_default.error("Failed to fetch custom field definitions", err);
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in get all ${ENTITY} request`
+		});
+	}
+});
+/**
+* Update
+*/
+router.patch("/:customFieldDefinitionId", async (req, res) => {
+	const { customFieldDefinitionId, modelName } = req.params;
+	const modelType = toPascalCase(modelName);
+	try {
+		const validatedPayload = await validateCustomFieldDefinitionUpdate(req.body);
+		if (!await findByWhere({
+			id: customFieldDefinitionId,
+			modelType
+		})) throw new ResourceNotFoundError();
+		const updatedCustomFieldDefinition = await update(customFieldDefinitionId, {
+			...validatedPayload,
+			modelType
+		});
+		return res.status(200).json(updatedCustomFieldDefinition);
+	} catch (err) {
+		logger_default.error("Failed to patch custom field definition", err);
+		return errors_default(err, res, {
+			logger: logger_default,
+			message: `Error in update ${ENTITY} request`
+		});
+	}
+});
+var definition_default = router;
+
+//#endregion
+export { definition_default as default };

package/dist/api/v1/definition/validations.cjs

@@ -0,0 +1,128 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../utils/constants/index.cjs');
+let joi = require("joi");
+joi = require_rolldown_runtime.__toESM(joi);
+
+//#region src/api/v1/definition/validations.ts
+const FileValidationSchema = joi.default.object({
+	name: joi.default.string().required(),
+	type: joi.default.string(),
+	size: joi.default.string(),
+	addedBy: joi.default.string().uuid()
+});
+const statusValidationObject = joi.default.object({
+	value: joi.default.string().required(),
+	color: joi.default.string().required()
+});
+const stringOptionsSchema = joi.default.array().required().items(joi.default.string()).min(1).unique();
+const statusOptionsSchema = joi.default.array().required().items(statusValidationObject).min(1).unique("value");
+/**
+* Schema for the validation of custom field definition
+* The only custom validation is for
+* {@link CustomFieldDefinitionType.SELECT SELECT},
+* {@link CustomFieldDefinitionType.MULTI_SELECT_DROPDOWN MULTI_SELECT_DROPDOWN},
+* {@link CustomFieldDefinitionType.STATUS STATUS},
+* and
+* {@link CustomFieldDefinitionType.MULTI_SELECT_STATUS MULTI_SELECT_STATUS}
+* field types.
+* The rest of the field types are validated by Joi
+*/
+const ValidationSchema = joi.default.when("fieldType", {
+	switch: [
+		{
+			is: require_index.CustomFieldDefinitionType.SELECT,
+			then: stringOptionsSchema
+		},
+		{
+			is: require_index.CustomFieldDefinitionType.MULTI_SELECT_DROPDOWN,
+			then: stringOptionsSchema
+		},
+		{
+			is: require_index.CustomFieldDefinitionType.STATUS,
+			then: statusOptionsSchema
+		},
+		{
+			is: require_index.CustomFieldDefinitionType.MULTI_SELECT_STATUS,
+			then: statusOptionsSchema
+		}
+	],
+	otherwise: joi.default.forbidden()
+});
+const multiSelectDefaultValueSchema = joi.default.array().items(joi.default.string()).unique().allow(null);
+const DefaultValueSchema = joi.default.when("fieldType", { switch: [
+	{
+		is: require_index.CustomFieldDefinitionType.BOOLEAN,
+		then: joi.default.boolean().allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.DATE,
+		then: joi.default.date().allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.DATETIME,
+		then: joi.default.date().allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.FILE,
+		then: joi.default.array().items(FileValidationSchema).allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.IMAGE,
+		then: joi.default.array().items(joi.default.string().uri()).allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.NUMBER,
+		then: joi.default.number().allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.SELECT,
+		then: joi.default.string().allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.STATUS,
+		then: joi.default.string().allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.TEXT,
+		then: joi.default.string().allow(null)
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.MULTI_SELECT_STATUS,
+		then: multiSelectDefaultValueSchema
+	},
+	{
+		is: require_index.CustomFieldDefinitionType.MULTI_SELECT_DROPDOWN,
+		then: multiSelectDefaultValueSchema
+	}
+] });
+const CustomFieldDefinitionCreationSchema = joi.default.object({
+	name: joi.default.string().required(),
+	displayName: joi.default.string().required(),
+	validation: ValidationSchema,
+	defaultValue: DefaultValueSchema,
+	fieldType: joi.default.string().valid(...Object.values(require_index.CustomFieldDefinitionType)).required(),
+	entityId: joi.default.string().guid().required(),
+	entityType: joi.default.string().required(),
+	description: joi.default.string(),
+	required: joi.default.boolean(),
+	disabled: joi.default.boolean(),
+	blockEditingFromUI: joi.default.boolean(),
+	modelTypeIds: joi.default.array().items(joi.default.string().guid())
+}).oxor("required", "blockEditingFromUI", { isPresent: (value) => value === true });
+const CustomFieldDefinitionUpdateSchema = joi.default.object({
+	displayName: joi.default.string(),
+	validation: ValidationSchema,
+	defaultValue: DefaultValueSchema,
+	fieldType: joi.default.string().valid(...Object.values(require_index.CustomFieldDefinitionType)),
+	description: joi.default.string().allow(null),
+	required: joi.default.boolean(),
+	disabled: joi.default.boolean(),
+	blockEditingFromUI: joi.default.boolean(),
+	modelTypeIds: joi.default.array().items(joi.default.string().guid())
+}).oxor("required", "blockEditingFromUI", { isPresent: (value) => value === true });
+const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
+const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });
+
+//#endregion
+exports.validateCustomFieldDefinitionCreation = validateCustomFieldDefinitionCreation;
+exports.validateCustomFieldDefinitionUpdate = validateCustomFieldDefinitionUpdate;

package/dist/api/v1/definition/validations.js

@@ -0,0 +1,125 @@
+import { CustomFieldDefinitionType } from "../../../utils/constants/index.js";
+import Joi from "joi";
+
+//#region src/api/v1/definition/validations.ts
+const FileValidationSchema = Joi.object({
+	name: Joi.string().required(),
+	type: Joi.string(),
+	size: Joi.string(),
+	addedBy: Joi.string().uuid()
+});
+const statusValidationObject = Joi.object({
+	value: Joi.string().required(),
+	color: Joi.string().required()
+});
+const stringOptionsSchema = Joi.array().required().items(Joi.string()).min(1).unique();
+const statusOptionsSchema = Joi.array().required().items(statusValidationObject).min(1).unique("value");
+/**
+* Schema for the validation of custom field definition
+* The only custom validation is for
+* {@link CustomFieldDefinitionType.SELECT SELECT},
+* {@link CustomFieldDefinitionType.MULTI_SELECT_DROPDOWN MULTI_SELECT_DROPDOWN},
+* {@link CustomFieldDefinitionType.STATUS STATUS},
+* and
+* {@link CustomFieldDefinitionType.MULTI_SELECT_STATUS MULTI_SELECT_STATUS}
+* field types.
+* The rest of the field types are validated by Joi
+*/
+const ValidationSchema = Joi.when("fieldType", {
+	switch: [
+		{
+			is: CustomFieldDefinitionType.SELECT,
+			then: stringOptionsSchema
+		},
+		{
+			is: CustomFieldDefinitionType.MULTI_SELECT_DROPDOWN,
+			then: stringOptionsSchema
+		},
+		{
+			is: CustomFieldDefinitionType.STATUS,
+			then: statusOptionsSchema
+		},
+		{
+			is: CustomFieldDefinitionType.MULTI_SELECT_STATUS,
+			then: statusOptionsSchema
+		}
+	],
+	otherwise: Joi.forbidden()
+});
+const multiSelectDefaultValueSchema = Joi.array().items(Joi.string()).unique().allow(null);
+const DefaultValueSchema = Joi.when("fieldType", { switch: [
+	{
+		is: CustomFieldDefinitionType.BOOLEAN,
+		then: Joi.boolean().allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.DATE,
+		then: Joi.date().allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.DATETIME,
+		then: Joi.date().allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.FILE,
+		then: Joi.array().items(FileValidationSchema).allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.IMAGE,
+		then: Joi.array().items(Joi.string().uri()).allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.NUMBER,
+		then: Joi.number().allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.SELECT,
+		then: Joi.string().allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.STATUS,
+		then: Joi.string().allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.TEXT,
+		then: Joi.string().allow(null)
+	},
+	{
+		is: CustomFieldDefinitionType.MULTI_SELECT_STATUS,
+		then: multiSelectDefaultValueSchema
+	},
+	{
+		is: CustomFieldDefinitionType.MULTI_SELECT_DROPDOWN,
+		then: multiSelectDefaultValueSchema
+	}
+] });
+const CustomFieldDefinitionCreationSchema = Joi.object({
+	name: Joi.string().required(),
+	displayName: Joi.string().required(),
+	validation: ValidationSchema,
+	defaultValue: DefaultValueSchema,
+	fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)).required(),
+	entityId: Joi.string().guid().required(),
+	entityType: Joi.string().required(),
+	description: Joi.string(),
+	required: Joi.boolean(),
+	disabled: Joi.boolean(),
+	blockEditingFromUI: Joi.boolean(),
+	modelTypeIds: Joi.array().items(Joi.string().guid())
+}).oxor("required", "blockEditingFromUI", { isPresent: (value) => value === true });
+const CustomFieldDefinitionUpdateSchema = Joi.object({
+	displayName: Joi.string(),
+	validation: ValidationSchema,
+	defaultValue: DefaultValueSchema,
+	fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)),
+	description: Joi.string().allow(null),
+	required: Joi.boolean(),
+	disabled: Joi.boolean(),
+	blockEditingFromUI: Joi.boolean(),
+	modelTypeIds: Joi.array().items(Joi.string().guid())
+}).oxor("required", "blockEditingFromUI", { isPresent: (value) => value === true });
+const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
+const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });
+
+//#endregion
+export { validateCustomFieldDefinitionCreation, validateCustomFieldDefinitionUpdate };

package/dist/api/v1/errors.cjs

@@ -0,0 +1,14 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+let sequelize = require("sequelize");
+let joi = require("joi");
+let _autofleet_errors = require("@autofleet/errors");
+
+//#region src/api/v1/errors.ts
+var errors_default = (err, res, additionalData) => {
+	let error = err;
+	if ([joi.ValidationError, sequelize.ValidationError].some((ErrClass) => err instanceof ErrClass)) error = new _autofleet_errors.BadRequest([err]);
+	return (0, _autofleet_errors.handleError)(error, res, additionalData);
+};
+
+//#endregion
+exports.default = errors_default;

package/dist/api/v1/errors.js

@@ -0,0 +1,13 @@
+import { ValidationError } from "sequelize";
+import { ValidationError as ValidationError$1 } from "joi";
+import { BadRequest, handleError } from "@autofleet/errors";
+
+//#region src/api/v1/errors.ts
+var errors_default = (err, res, additionalData) => {
+	let error = err;
+	if ([ValidationError$1, ValidationError].some((ErrClass) => err instanceof ErrClass)) error = new BadRequest([err]);
+	return handleError(error, res, additionalData);
+};
+
+//#endregion
+export { errors_default as default };