@autofleet/sadot 1.6.18-beta.4 → 1.6.18-beta.7

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/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/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/_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 { __commonJSMin, __export, __require };
+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/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/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/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/field-policies/index.cjs

@@ -0,0 +1,84 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../utils/logger/index.cjs');
+const require_errors = require('../errors.cjs');
+const require_field_policy = require('../../../repository/field-policy.cjs');
+let sequelize = require("sequelize");
+let _autofleet_node_common = require("@autofleet/node-common");
+
+//#region src/api/v1/field-policies/index.ts
+const router = (0, _autofleet_node_common.Router)({ logger: require_index.default });
+router.get("/", async (_req, res) => {
+	try {
+		const policies = await require_field_policy.findAll();
+		res.status(200).json(policies);
+	} catch (err) {
+		require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error in get field policies request"
+		});
+	}
+});
+router.post("/", async (req, res) => {
+	const { contextId, name, fields, models } = req.body;
+	if (!contextId || !name) {
+		res.status(400).json({ error: "contextId and name are required" });
+		return;
+	}
+	try {
+		const policy = await require_field_policy.create({
+			contextId,
+			name,
+			fields,
+			models
+		});
+		res.status(201).json(policy);
+	} catch (err) {
+		if (err instanceof sequelize.UniqueConstraintError) {
+			res.status(409).json({ error: "A field policy for this contextId and name already exists" });
+			return;
+		}
+		require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error in create field policy request"
+		});
+	}
+});
+router.put("/:policyId", async (req, res) => {
+	const { policyId } = req.params;
+	const { fields, models } = req.body;
+	try {
+		const updated = await require_field_policy.update(policyId, {
+			fields,
+			models
+		});
+		if (!updated) {
+			res.status(404).json({ error: "Field policy not found" });
+			return;
+		}
+		res.status(200).json(updated);
+	} catch (err) {
+		require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error in update field policy request"
+		});
+	}
+});
+router.delete("/:policyId", async (req, res) => {
+	const { policyId } = req.params;
+	try {
+		if (!await require_field_policy.remove(policyId)) {
+			res.status(404).json({ error: "Field policy not found" });
+			return;
+		}
+		res.status(204).send();
+	} catch (err) {
+		require_errors.default(err, res, {
+			logger: require_index.default,
+			message: "Error in delete field policy request"
+		});
+	}
+});
+var field_policies_default = router;
+
+//#endregion
+exports.default = field_policies_default;

package/dist/api/v1/field-policies/index.js

@@ -0,0 +1,83 @@
+import logger_default from "../../../utils/logger/index.js";
+import errors_default from "../errors.js";
+import { create, findAll, remove, update } from "../../../repository/field-policy.js";
+import { UniqueConstraintError } from "sequelize";
+import { Router } from "@autofleet/node-common";
+
+//#region src/api/v1/field-policies/index.ts
+const router = Router({ logger: logger_default });
+router.get("/", async (_req, res) => {
+	try {
+		const policies = await findAll();
+		res.status(200).json(policies);
+	} catch (err) {
+		errors_default(err, res, {
+			logger: logger_default,
+			message: "Error in get field policies request"
+		});
+	}
+});
+router.post("/", async (req, res) => {
+	const { contextId, name, fields, models } = req.body;
+	if (!contextId || !name) {
+		res.status(400).json({ error: "contextId and name are required" });
+		return;
+	}
+	try {
+		const policy = await create({
+			contextId,
+			name,
+			fields,
+			models
+		});
+		res.status(201).json(policy);
+	} catch (err) {
+		if (err instanceof UniqueConstraintError) {
+			res.status(409).json({ error: "A field policy for this contextId and name already exists" });
+			return;
+		}
+		errors_default(err, res, {
+			logger: logger_default,
+			message: "Error in create field policy request"
+		});
+	}
+});
+router.put("/:policyId", async (req, res) => {
+	const { policyId } = req.params;
+	const { fields, models } = req.body;
+	try {
+		const updated = await update(policyId, {
+			fields,
+			models
+		});
+		if (!updated) {
+			res.status(404).json({ error: "Field policy not found" });
+			return;
+		}
+		res.status(200).json(updated);
+	} catch (err) {
+		errors_default(err, res, {
+			logger: logger_default,
+			message: "Error in update field policy request"
+		});
+	}
+});
+router.delete("/:policyId", async (req, res) => {
+	const { policyId } = req.params;
+	try {
+		if (!await remove(policyId)) {
+			res.status(404).json({ error: "Field policy not found" });
+			return;
+		}
+		res.status(204).send();
+	} catch (err) {
+		errors_default(err, res, {
+			logger: logger_default,
+			message: "Error in delete field policy request"
+		});
+	}
+});
+var field_policies_default = router;
+
+//#endregion
+export { field_policies_default as default };

package/dist/api/v1/index.cjs

@@ -0,0 +1,16 @@
+const require_rolldown_runtime = require('../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../utils/logger/index.cjs');
+const require_index$1 = require('./definition/index.cjs');
+const require_index$2 = require('./validator/index.cjs');
+const require_index$3 = require('./field-policies/index.cjs');
+let _autofleet_node_common = require("@autofleet/node-common");
+
+//#region src/api/v1/index.ts
+const router = (0, _autofleet_node_common.Router)({ logger: require_index.default });
+router.use("/custom-field-definitions/:modelName", require_index$1.default);
+router.use("/custom-validators/:modelName", require_index$2.default);
+router.use("/field-policies/:modelName", require_index$3.default);
+var v1_default = router;
+
+//#endregion
+exports.default = v1_default;

package/dist/{packages/sadot/src/api → api}/v1/index.js

@@ -1,14 +1,14 @@
 import logger_default from "../../utils/logger/index.js";
 import definition_default from "./definition/index.js";
 import validator_default from "./validator/index.js";
-import templates_default from "./templates/index.js";
+import field_policies_default from "./field-policies/index.js";
 import { Router } from "@autofleet/node-common";
 
 //#region src/api/v1/index.ts
 const router = Router({ logger: logger_default });
 router.use("/custom-field-definitions/:modelName", definition_default);
 router.use("/custom-validators/:modelName", validator_default);
-router.use("/templates", templates_default);
+router.use("/field-policies/:modelName", field_policies_default);
 var v1_default = router;
 
 //#endregion

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

@@ -0,0 +1,115 @@
+const require_rolldown_runtime = require('../../../_virtual/rolldown_runtime.cjs');
+const require_index = require('../../../utils/logger/index.cjs');
+const require_errors = require('../errors.cjs');
+const require_mat_path_state = require('../../../mat-path-state.cjs');
+const require_validator = require('../../../repository/validator.cjs');
+const require_validations = require('./validations.cjs');
+const require_validator_schema = require('../../../utils/validations/schema/validator-schema.cjs');
+let _autofleet_errors = require("@autofleet/errors");
+let _autofleet_node_common = require("@autofleet/node-common");
+let http_status_codes = require("http-status-codes");
+
+//#region src/api/v1/validator/index.ts
+const router = (0, _autofleet_node_common.Router)({ logger: require_index.default });
+const ENTITY = "CustomValidator";
+/**
+* Create
+*/
+router.post("/", async (req, res) => {
+	const { modelName } = req.params;
+	try {
+		const validatedPayload = await require_validations.default.create.validateAsync(req.body);
+		require_validator_schema.validateValidatorSchema(validatedPayload.schema);
+		const validator = await require_validator.create({
+			...validatedPayload,
+			modelType: modelName
+		});
+		return res.status(http_status_codes.StatusCodes.CREATED).json(validator);
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in create ${ENTITY} request`
+		});
+	}
+});
+/**
+* Get all
+*/
+router.get("/", async (req, res) => {
+	try {
+		const { modelName } = req.params;
+		const { entityId, entityType } = req.query;
+		const applyEntityFilters = !require_mat_path_state.matPathState.isMatPathEnabled?.();
+		const where = {
+			modelType: modelName,
+			...applyEntityFilters && entityId && { entityId },
+			...applyEntityFilters && entityType && { entityType }
+		};
+		const validators = await require_validator.findAll(where);
+		return res.status(http_status_codes.StatusCodes.OK).json({ validators });
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in get all ${ENTITY} request`
+		});
+	}
+});
+/**
+* Get by id
+*/
+router.get("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId, modelName } = req.params;
+		const validators = await require_validator.findAll({
+			id: validatorId,
+			modelType: modelName
+		}, { withDisabled: true });
+		if (!validators.length) throw new _autofleet_errors.ResourceNotFoundError("Validator not found");
+		return res.status(http_status_codes.StatusCodes.OK).json(validators[0]);
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in get ${ENTITY} request`
+		});
+	}
+});
+/**
+* Update
+*/
+router.patch("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId } = req.params;
+		const validatedPayload = await require_validations.default.update.validateAsync(req.body);
+		if (validatedPayload.schema) require_validator_schema.validateValidatorSchema(validatedPayload.schema);
+		if (!(await require_validator.findAll({ id: validatorId }, { withDisabled: true })).length) throw new _autofleet_errors.ResourceNotFoundError("Validator not found");
+		const [count, validators] = await require_validator.update(validatorId, validatedPayload);
+		if (!count) throw new _autofleet_errors.ResourceNotFoundError("Validator not found");
+		return res.status(http_status_codes.StatusCodes.OK).json(validators[0]);
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in update ${ENTITY} request`
+		});
+	}
+});
+/**
+* Delete (disable)
+*/
+router.delete("/:validatorId", async (req, res) => {
+	try {
+		const { validatorId } = req.params;
+		if (!(await require_validator.findAll({ id: validatorId }, { withDisabled: true })).length) throw new _autofleet_errors.ResourceNotFoundError("Validator not found");
+		const [count] = await require_validator.disable(validatorId);
+		if (!count) throw new _autofleet_errors.ResourceNotFoundError("Validator failed to be disabled");
+		return res.status(http_status_codes.StatusCodes.NO_CONTENT).send();
+	} catch (err) {
+		return require_errors.default(err, res, {
+			logger: require_index.default,
+			message: `Error in delete ${ENTITY} request`
+		});
+	}
+});
+var validator_default = router;
+
+//#endregion
+exports.default = validator_default;