@autofleet/sadot 1.1.3 → 1.1.5-beta

package/.nvmrc

@@ -0,0 +1 @@
+22.9.0

package/dist/api/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/api/index.js

@@ -1,2 +1,12 @@
-import e from"../utils/logger/index.js";import t from"./v1/index.js";import{Router as n}from"@autofleet/node-common";const r=n({logger:e});r.use(`/v1`,t);var i=r;export{i as default};
-//# sourceMappingURL=index.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// export the api object
+const node_common_1 = require("@autofleet/node-common");
+const v1_1 = __importDefault(require("./v1"));
+const logger_1 = __importDefault(require("../utils/logger"));
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
+router.use('/v1', v1_1.default);
+exports.default = router;

package/dist/api/v1/definition/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

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

@@ -1,2 +1,116 @@
-import e from"../../../utils/logger/index.js";import{create as t,findAll as n,findById as r,findByWhere as i,update as a}from"../../../repository/definition.js";import o from"../errors.js";import{validateCustomFieldDefinitionCreation as s,validateCustomFieldDefinitionUpdate as c}from"./validations.js";import{ResourceNotFoundError as l}from"@autofleet/errors";import{Router as u}from"@autofleet/node-common";const d=u({logger:e}),f=`CustomFieldDefinition`,p=e=>e.replace(/(^\w|-\w)/g,e=>e.replace(/-/,``).toUpperCase());d.post(`/`,async(n,r)=>{let{modelName:i}=n.params,a=p(i);try{let e=await t({...await s(n.body),modelType:a});return r.status(201).json(e)}catch(t){return e.error(`Failed to create custom field definition`,t),o(t,r,{logger:e,message:`Error in create ${f} request`})}}),d.get(`/:customFieldDefinitionId`,async(t,n)=>{let{customFieldDefinitionId:i}=t.params;try{let e=await r(i);if(!e)throw new l;return n.json(e)}catch(t){return e.error(`Failed to fetch custom field definition`,t),o(t,n,{logger:e,message:`Error in get ${f} request`})}}),d.get(`/`,async(t,r)=>{let{params:{modelName:i},query:{entityIds:a}}=t,s=p(i);try{let e=await n({modelType:s,...a&&a.length>0&&{entityId:a}},{withDisabled:!0});return r.json(e)}catch(t){return e.error(`Failed to fetch custom field definitions`,t),o(t,r,{logger:e,message:`Error in get all ${f} request`})}}),d.patch(`/:customFieldDefinitionId`,async(t,n)=>{let{customFieldDefinitionId:r,modelName:s}=t.params,u=p(s);try{let e=await c(t.body);if(!await i({id:r,modelType:u}))throw new l;let o=await a(r,{...e,modelType:u});return n.status(200).json(o)}catch(t){return e.error(`Failed to patch custom field definition`,t),o(t,n,{logger:e,message:`Error in update ${f} request`})}});var m=d;export{m as default};
-//# sourceMappingURL=index.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("@autofleet/errors");
+const node_common_1 = require("@autofleet/node-common");
+const errors_2 = __importDefault(require("../errors"));
+const DefinitionRepo = __importStar(require("../../../repository/definition"));
+const validations_1 = require("./validations");
+const logger_1 = __importDefault(require("../../../utils/logger"));
+const router = (0, node_common_1.Router)({ logger: logger_1.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 (0, validations_1.validateCustomFieldDefinitionCreation)(req.body);
+        const customFieldDefinition = await DefinitionRepo.create({
+            ...validatedPayload,
+            modelType,
+        });
+        return res.status(201).json(customFieldDefinition);
+    }
+    catch (err) {
+        logger_1.default.error('Failed to create custom field definition', err);
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in create ${ENTITY} request` });
+    }
+});
+/**
+ * Get by id
+ */
+router.get('/:customFieldDefinitionId', async (req, res) => {
+    const { customFieldDefinitionId } = req.params;
+    try {
+        const customFieldDefinition = await DefinitionRepo.findById(customFieldDefinitionId);
+        if (!customFieldDefinition) {
+            throw new errors_1.ResourceNotFoundError();
+        }
+        return res.json(customFieldDefinition);
+    }
+    catch (err) {
+        logger_1.default.error('Failed to fetch custom field definition', err);
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get ${ENTITY} request` });
+    }
+});
+/**
+ * Get all
+ */
+router.get('/', async (req, res) => {
+    const { params: { modelName }, query: { entityIds } } = req;
+    const modelType = toPascalCase(modelName);
+    try {
+        const where = {
+            modelType,
+            ...(entityIds?.length > 0 && { entityId: entityIds }),
+        };
+        const customFieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true });
+        return res.json(customFieldDefinitions);
+    }
+    catch (err) {
+        logger_1.default.error('Failed to fetch custom field definitions', err);
+        return (0, errors_2.default)(err, res, { logger: logger_1.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 (0, validations_1.validateCustomFieldDefinitionUpdate)(req.body);
+        const customFieldDefinition = await DefinitionRepo.findByWhere({
+            id: customFieldDefinitionId,
+            modelType,
+        });
+        if (!customFieldDefinition) {
+            throw new errors_1.ResourceNotFoundError();
+        }
+        const updatedCustomFieldDefinition = await DefinitionRepo.update(customFieldDefinitionId, { ...validatedPayload, modelType });
+        return res.status(200).json(updatedCustomFieldDefinition);
+    }
+    catch (err) {
+        logger_1.default.error('Failed to patch custom field definition', err);
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in update ${ENTITY} request` });
+    }
+});
+exports.default = router;

package/dist/api/v1/definition/validations.d.ts

@@ -0,0 +1,2 @@
+export declare const validateCustomFieldDefinitionCreation: (payload: any) => Promise<any>;
+export declare const validateCustomFieldDefinitionUpdate: (payload: any) => Promise<any>;

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

@@ -1,2 +1,77 @@
-import{CustomFieldDefinitionType as e}from"../../../utils/constants/index.js";import t from"joi";const n=t.object({name:t.string().required(),type:t.string(),size:t.string(),addedBy:t.string().uuid()}),r=t.object({value:t.string().required(),color:t.string().required()}),i=t.when(`fieldType`,{is:e.SELECT,then:t.array().required().items(t.string()).min(1).unique(),otherwise:t.when(`fieldType`,{is:e.STATUS,then:t.array().required().items(r).min(1).unique(`value`),otherwise:t.forbidden()})}),a=t.when(`fieldType`,{switch:[{is:e.BOOLEAN,then:t.boolean().allow(null)},{is:e.DATE,then:t.date().allow(null)},{is:e.DATETIME,then:t.date().allow(null)},{is:e.FILE,then:t.array().items(n).allow(null)},{is:e.IMAGE,then:t.array().items(t.string().uri()).allow(null)},{is:e.NUMBER,then:t.number().allow(null)},{is:e.SELECT,then:t.string().allow(null)},{is:e.STATUS,then:t.string().allow(null)},{is:e.TEXT,then:t.string().allow(null)}]}),o=t.object({name:t.string().required(),displayName:t.string().required(),validation:i,defaultValue:a,fieldType:t.string().valid(...Object.values(e)).required(),entityId:t.string().guid().required(),entityType:t.string().required(),description:t.string(),required:t.boolean(),disabled:t.boolean(),blockEditingFromUI:t.boolean()}).oxor(`required`,`blockEditingFromUI`,{isPresent:e=>e===!0}),s=t.object({displayName:t.string(),validation:i,defaultValue:a,fieldType:t.string().valid(...Object.values(e)),description:t.string().allow(null),required:t.boolean(),disabled:t.boolean(),blockEditingFromUI:t.boolean()}).oxor(`required`,`blockEditingFromUI`,{isPresent:e=>e===!0}),c=e=>o.validateAsync(e,{abortEarly:!1}),l=e=>s.validateAsync(e,{abortEarly:!1});export{c as validateCustomFieldDefinitionCreation,l as validateCustomFieldDefinitionUpdate};
-//# sourceMappingURL=validations.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCustomFieldDefinitionUpdate = exports.validateCustomFieldDefinitionCreation = void 0;
+/* eslint-disable newline-per-chained-call */
+const joi_1 = __importDefault(require("joi"));
+const constants_1 = require("../../../utils/constants");
+const FileValidationSchema = joi_1.default.object({
+    name: joi_1.default.string().required(),
+    type: joi_1.default.string(),
+    size: joi_1.default.string(),
+    addedBy: joi_1.default.string().uuid(),
+});
+const statusValidationObject = joi_1.default.object({
+    value: joi_1.default.string().required(),
+    color: joi_1.default.string().required(),
+});
+/**
+ * Schema for the validation of custom field definition
+ * The only custom validation is for
+ * {@link CustomFieldDefinitionType.SELECT SELECT}
+ * and
+ * {@link CustomFieldDefinitionType.STATUS STATUS}
+ * field types.
+ * The rest of the field types are validated by Joi
+ */
+const ValidationSchema = joi_1.default.when('fieldType', {
+    is: constants_1.CustomFieldDefinitionType.SELECT,
+    then: joi_1.default.array().required().items(joi_1.default.string()).min(1).unique(),
+    otherwise: joi_1.default.when('fieldType', {
+        is: constants_1.CustomFieldDefinitionType.STATUS,
+        then: joi_1.default.array().required().items(statusValidationObject).min(1).unique('value'),
+        otherwise: joi_1.default.forbidden(),
+    }),
+});
+const DefaultValueSchema = joi_1.default.when('fieldType', {
+    switch: [
+        { is: constants_1.CustomFieldDefinitionType.BOOLEAN, then: joi_1.default.boolean().allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.DATE, then: joi_1.default.date().allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.DATETIME, then: joi_1.default.date().allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.FILE, then: joi_1.default.array().items(FileValidationSchema).allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.IMAGE, then: joi_1.default.array().items(joi_1.default.string().uri()).allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.NUMBER, then: joi_1.default.number().allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.SELECT, then: joi_1.default.string().allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.STATUS, then: joi_1.default.string().allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.TEXT, then: joi_1.default.string().allow(null) },
+    ],
+});
+const CustomFieldDefinitionCreationSchema = joi_1.default.object({
+    name: joi_1.default.string().required(),
+    displayName: joi_1.default.string().required(),
+    validation: ValidationSchema,
+    defaultValue: DefaultValueSchema,
+    fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)).required(),
+    entityId: joi_1.default.string().guid().required(),
+    entityType: joi_1.default.string().required(),
+    description: joi_1.default.string(),
+    required: joi_1.default.boolean(),
+    disabled: joi_1.default.boolean(),
+    blockEditingFromUI: joi_1.default.boolean(),
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
+const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
+    displayName: joi_1.default.string(),
+    validation: ValidationSchema,
+    defaultValue: DefaultValueSchema,
+    fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)),
+    description: joi_1.default.string().allow(null),
+    required: joi_1.default.boolean(),
+    disabled: joi_1.default.boolean(),
+    blockEditingFromUI: joi_1.default.boolean(),
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
+const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
+exports.validateCustomFieldDefinitionCreation = validateCustomFieldDefinitionCreation;
+const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });
+exports.validateCustomFieldDefinitionUpdate = validateCustomFieldDefinitionUpdate;

package/dist/api/v1/errors.d.ts

@@ -0,0 +1,4 @@
+import type { Response } from 'express';
+import { type LogPayload } from '@autofleet/errors';
+declare const _default: (err: any, res: Response, additionalData?: LogPayload) => void;
+export default _default;

package/dist/api/v1/errors.js

@@ -1,2 +1,12 @@
-import{ValidationError as e}from"sequelize";import{ValidationError as t}from"joi";import{BadRequest as n,handleError as r}from"@autofleet/errors";var i=(i,a,o)=>{let s=i;return[t,e].some(e=>i instanceof e)&&(s=new n([i])),r(s,a,o)};export{i as default};
-//# sourceMappingURL=errors.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("@autofleet/errors");
+const joi_1 = require("joi");
+const sequelize_1 = require("sequelize");
+exports.default = (err, res, additionalData = undefined) => {
+    let error = err;
+    if ([joi_1.ValidationError, sequelize_1.ValidationError].some((ErrClass) => err instanceof ErrClass)) {
+        error = new errors_1.BadRequest([err], null);
+    }
+    return (0, errors_1.handleError)(error, res, additionalData);
+};

package/dist/api/v1/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/api/v1/index.js

@@ -1,2 +1,13 @@
-import e from"../../utils/logger/index.js";import t from"./definition/index.js";import n from"./validator/index.js";import{Router as r}from"@autofleet/node-common";const i=r({logger:e});i.use(`/custom-field-definitions/:modelName`,t),i.use(`/custom-validators/:modelName`,n);var a=i;export{a as default};
-//# sourceMappingURL=index.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const node_common_1 = require("@autofleet/node-common");
+const logger_1 = __importDefault(require("../../utils/logger"));
+const definition_1 = __importDefault(require("./definition"));
+const validator_1 = __importDefault(require("./validator"));
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
+router.use('/custom-field-definitions/:modelName', definition_1.default);
+router.use('/custom-validators/:modelName', validator_1.default);
+exports.default = router;

package/dist/api/v1/validator/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

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

@@ -1,2 +1,143 @@
-import e from"../../../utils/logger/index.js";import t from"../errors.js";import{create as n,disable as r,findAll as i,update as a}from"../../../repository/validator.js";import o from"./validations.js";import{validateValidatorSchema as s}from"../../../utils/validations/schema/validator-schema.js";import{ResourceNotFoundError as c}from"@autofleet/errors";import{Router as l}from"@autofleet/node-common";import{StatusCodes as u}from"http-status-codes";const d=l({logger:e}),f=`CustomValidator`;d.post(`/`,async(r,i)=>{let{modelName:a}=r.params;try{let e=await o.create.validateAsync(r.body);s(e.schema);let t=await n({...e,modelType:a});return i.status(u.CREATED).json(t)}catch(n){return t(n,i,{logger:e,message:`Error in create ${f} request`})}}),d.get(`/`,async(n,r)=>{try{let{modelName:e}=n.params,{entityId:t,entityType:a}=n.query,o=await i({modelType:e,...t&&{entityId:t},...a&&{entityType:a}});return r.status(u.OK).json({validators:o})}catch(n){return t(n,r,{logger:e,message:`Error in get all ${f} request`})}}),d.get(`/:validatorId`,async(n,r)=>{try{let{validatorId:e,modelName:t}=n.params,a=await i({id:e,modelType:t},{withDisabled:!0});if(!a.length)throw new c(`Validator not found`);return r.status(u.OK).json(a[0])}catch(n){return t(n,r,{logger:e,message:`Error in get ${f} request`})}}),d.patch(`/:validatorId`,async(n,r)=>{try{let{validatorId:e}=n.params,t=await o.update.validateAsync(n.body);if(t.schema&&s(t.schema),!(await i({id:e},{withDisabled:!0})).length)throw new c(`Validator not found`);let[l,d]=await a(e,t);if(!l)throw new c(`Validator not found`);return r.status(u.OK).json(d[0])}catch(n){return t(n,r,{logger:e,message:`Error in update ${f} request`})}}),d.delete(`/:validatorId`,async(n,a)=>{try{let{validatorId:e}=n.params;if(!(await i({id:e},{withDisabled:!0})).length)throw new c(`Validator not found`);let[t]=await r(e);if(!t)throw new c(`Validator failed to be disabled`);return a.status(u.NO_CONTENT).send()}catch(n){return t(n,a,{logger:e,message:`Error in delete ${f} request`})}});var p=d;export{p as default};
-//# sourceMappingURL=index.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("@autofleet/errors");
+const node_common_1 = require("@autofleet/node-common");
+const http_status_codes_1 = require("http-status-codes");
+const errors_2 = __importDefault(require("../errors"));
+const ValidatorRepo = __importStar(require("../../../repository/validator"));
+const validations_1 = __importDefault(require("./validations"));
+const logger_1 = __importDefault(require("../../../utils/logger"));
+const validator_schema_1 = require("../../../utils/validations/schema/validator-schema");
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
+const ENTITY = 'CustomValidator';
+/**
+ * Create
+ */
+router.post('/', async (req, res) => {
+    const { modelName } = req.params;
+    try {
+        // Validate the request body
+        const validatedPayload = await validations_1.default.create.validateAsync(req.body);
+        // Validate that the schema is a valid AJV schema
+        (0, validator_schema_1.validateValidatorSchema)(validatedPayload.schema);
+        const validator = await ValidatorRepo.create({
+            ...validatedPayload,
+            modelType: modelName,
+        });
+        return res.status(http_status_codes_1.StatusCodes.CREATED).json(validator);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.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 where = {
+            modelType: modelName,
+            ...(entityId && { entityId }),
+            ...(entityType && { entityType }),
+        };
+        const validators = await ValidatorRepo.findAll(where);
+        return res.status(http_status_codes_1.StatusCodes.OK).json({ validators });
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get all ${ENTITY} request` });
+    }
+});
+/**
+ * Get by id
+ */
+router.get('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId, modelName } = req.params;
+        // Include disabled validators when fetching by ID
+        const validators = await ValidatorRepo.findAll({ id: validatorId, modelType: modelName }, { withDisabled: true });
+        if (!validators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        return res.status(http_status_codes_1.StatusCodes.OK).json(validators[0]);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get ${ENTITY} request` });
+    }
+});
+/**
+ * Update
+ */
+router.patch('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId } = req.params;
+        // Validate the request body
+        const validatedPayload = await validations_1.default.update.validateAsync(req.body);
+        // If schema is included in the update, validate that it's a valid AJV schema
+        if (validatedPayload.schema) {
+            (0, validator_schema_1.validateValidatorSchema)(validatedPayload.schema);
+        }
+        // First verify the validator exists, including disabled ones
+        const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+        if (!existingValidators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
+        if (!count) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        return res.status(http_status_codes_1.StatusCodes.OK).json(validators[0]);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in update ${ENTITY} request` });
+    }
+});
+/**
+ * Delete (disable)
+ */
+router.delete('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId } = req.params;
+        // First verify the validator exists, including disabled ones
+        const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+        if (!existingValidators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        const [count] = await ValidatorRepo.disable(validatorId);
+        if (!count) {
+            throw new errors_1.ResourceNotFoundError('Validator failed to be disabled');
+        }
+        return res.status(http_status_codes_1.StatusCodes.NO_CONTENT).send();
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in delete ${ENTITY} request` });
+    }
+});
+exports.default = router;

package/dist/api/v1/validator/validations.d.ts

@@ -1,23 +1,6 @@
-import Joi from "joi";
-
-//#region src/api/v1/validator/validations.d.ts
-interface SchemaObject {
-  type: "object";
-  properties?: {
-    before?: object;
-    after?: object;
-  };
-  required?: string[];
-  allOf?: object[];
-  anyOf?: object[];
-  oneOf?: object[];
-  additionalProperties?: boolean | object;
-  $id?: string;
-  $schema?: string;
-  if?: object;
-  then?: object;
-  else?: object;
-}
-//#endregion
-export { SchemaObject };
-//# sourceMappingURL=validations.d.ts.map
+import Joi from 'joi';
+declare const validationSchemas: {
+    create: Joi.ObjectSchema<any>;
+    update: Joi.ObjectSchema<any>;
+};
+export default validationSchemas;

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

@@ -1,2 +1,38 @@
-import e from"joi";const t=e.object().unknown(!0),n=e.object({type:e.string().valid(`object`),properties:e.object({before:t,after:t}).required(),required:e.array().items(e.string()),allOf:e.array().items(e.object()),anyOf:e.array().items(e.object()),oneOf:e.array().items(e.object()),additionalProperties:e.alternatives().try(e.boolean(),e.object()),$id:e.string(),$schema:e.string(),if:e.object(),then:e.object(),else:e.object()});var r={create:e.object({entityId:e.string().uuid().required(),entityType:e.string().required(),schema:n.required()}),update:e.object({entityId:e.string().uuid(),entityType:e.string(),schema:n,disabled:e.boolean()}).min(1)};export{r as default};
-//# sourceMappingURL=validations.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const joi_1 = __importDefault(require("joi"));
+const jsonSchemaValidation = joi_1.default.object().unknown(true);
+const schemaObject = joi_1.default.object({
+    type: joi_1.default.string().valid('object'),
+    properties: joi_1.default.object({
+        before: jsonSchemaValidation,
+        after: jsonSchemaValidation,
+    }).required(),
+    required: joi_1.default.array().items(joi_1.default.string()),
+    allOf: joi_1.default.array().items(joi_1.default.object()),
+    anyOf: joi_1.default.array().items(joi_1.default.object()),
+    oneOf: joi_1.default.array().items(joi_1.default.object()),
+    additionalProperties: joi_1.default.alternatives().try(joi_1.default.boolean(), joi_1.default.object()),
+    $id: joi_1.default.string(),
+    $schema: joi_1.default.string(),
+    if: joi_1.default.object(),
+    then: joi_1.default.object(),
+    else: joi_1.default.object(),
+});
+const validationSchemas = {
+    create: joi_1.default.object({
+        entityId: joi_1.default.string().uuid().required(),
+        entityType: joi_1.default.string().required(),
+        schema: schemaObject.required(),
+    }),
+    update: joi_1.default.object({
+        entityId: joi_1.default.string().uuid(),
+        entityType: joi_1.default.string(),
+        schema: schemaObject,
+        disabled: joi_1.default.boolean(),
+    }).min(1),
+};
+exports.default = validationSchemas;

package/dist/errors/index.d.ts

@@ -0,0 +1,24 @@
+import { BadRequest } from '@autofleet/errors';
+import type { ValidationError } from 'joi';
+import type { EntriesValidationError } from '../types/entries';
+export declare class MissingRequiredCustomFieldError extends BadRequest {
+    constructor(missingFields: string[]);
+}
+export declare class UnsupportedCustomFieldTypeError extends BadRequest {
+    constructor(fieldType: string);
+}
+export declare class UnsupportedCustomValidationError extends BadRequest {
+    constructor(fieldType: string);
+}
+export declare class InvalidFieldTypeError extends BadRequest {
+    constructor(fieldType: string);
+}
+export declare class InvalidValueError extends BadRequest {
+    constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError);
+}
+export declare class InvalidEntriesError extends BadRequest {
+    constructor(modelId: string, validationErrors: EntriesValidationError[]);
+}
+export declare class MissingDefinitionError extends BadRequest {
+    constructor(fieldNames: string[]);
+}

package/dist/errors/index.js

@@ -1,3 +1,66 @@
-import{BadRequest as e}from"@autofleet/errors";var t=class extends e{constructor(e){let t=Error(`The following custom fields are required: ${e.join(`,`)}`);super([t],void 0,e),this.message=`MISSING_REQUIRED_CUSTOM_FIELDS`}},n=class extends e{constructor(e){let t=Error(`Type "${e}" is not supported`);super([t],void 0,null),this.message=`UNSUPPORTED_CUSTOM_FIELD_TYPE`}},r=class extends e{constructor(e){let t=Error(`Validation for "${e}" is not supported`);super([t],void 0,null),this.message=`UNSUPPORTED_CUSTOM_VALIDATION_TYPE`}},i=class extends e{constructor(e){let t=Error(`Invalid field type ${e}`);super([t],void 0,null),this.message=`INVALID_FIELD_TYPE`}},a=class extends e{constructor(e,t,n){let r=`Invalid Value on field '${t}'. ${n.message.replace(/"/g,``).replace(`value`,`'${t}'`)}. received: '${typeof e==`object`?JSON.stringify(e):e}'`;super([Error(r)],void 0,null),this.message=r}},o=class extends e{constructor(e,t){let n=t.map(e=>new a(e.value,e.fieldDefinitionName,e.joiValidationError));super(n,void 0,null),this.message=`Invalid entries on ${e}\n${t.map(e=>`${e.fieldDefinitionName} - ${e.joiValidationError.message}`).join(`
-`)}`}},s=class extends e{constructor(e){let t=Error(`Missing custom field definition for field ${e.join(`,`)}`);super([t],void 0,null),this.message=`MISSING_DEFINITION`}};export{o as InvalidEntriesError,i as InvalidFieldTypeError,a as InvalidValueError,s as MissingDefinitionError,t as MissingRequiredCustomFieldError,n as UnsupportedCustomFieldTypeError,r as UnsupportedCustomValidationError};
-//# sourceMappingURL=index.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingDefinitionError = exports.InvalidEntriesError = exports.InvalidValueError = exports.InvalidFieldTypeError = exports.UnsupportedCustomValidationError = exports.UnsupportedCustomFieldTypeError = exports.MissingRequiredCustomFieldError = void 0;
+/* eslint-disable max-classes-per-file */
+const errors_1 = require("@autofleet/errors");
+class MissingRequiredCustomFieldError extends errors_1.BadRequest {
+    constructor(missingFields) {
+        const err = new Error(`The following custom fields are required: ${missingFields.join(',')}`);
+        super([err], null, missingFields);
+        this.message = 'MISSING_REQUIRED_CUSTOM_FIELDS';
+    }
+}
+exports.MissingRequiredCustomFieldError = MissingRequiredCustomFieldError;
+class UnsupportedCustomFieldTypeError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Type "${fieldType}" is not supported`);
+        super([err], null, null);
+        this.message = 'UNSUPPORTED_CUSTOM_FIELD_TYPE';
+    }
+}
+exports.UnsupportedCustomFieldTypeError = UnsupportedCustomFieldTypeError;
+class UnsupportedCustomValidationError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Validation for "${fieldType}" is not supported`);
+        super([err], null, null);
+        this.message = 'UNSUPPORTED_CUSTOM_VALIDATION_TYPE';
+    }
+}
+exports.UnsupportedCustomValidationError = UnsupportedCustomValidationError;
+class InvalidFieldTypeError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Invalid field type ${fieldType}`);
+        super([err], null, null);
+        this.message = 'INVALID_FIELD_TYPE';
+    }
+}
+exports.InvalidFieldTypeError = InvalidFieldTypeError;
+class InvalidValueError extends errors_1.BadRequest {
+    constructor(value, fieldDefinitionName, joiValidationError) {
+        const formattedErrorMessage = joiValidationError.message
+            .replace(/"/g, '')
+            .replace('value', `'${fieldDefinitionName}'`);
+        const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
+        const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
+        const err = new Error(invalidValueMessage);
+        super([err], null, null);
+        this.message = invalidValueMessage;
+    }
+}
+exports.InvalidValueError = InvalidValueError;
+class InvalidEntriesError extends errors_1.BadRequest {
+    constructor(modelId, validationErrors) {
+        const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
+        super(errors, null, null);
+        this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (`${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`)).join('\n')}`;
+    }
+}
+exports.InvalidEntriesError = InvalidEntriesError;
+class MissingDefinitionError extends errors_1.BadRequest {
+    constructor(fieldNames) {
+        const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);
+        super([err], null, null);
+        this.message = 'MISSING_DEFINITION';
+    }
+}
+exports.MissingDefinitionError = MissingDefinitionError;

package/dist/events/index.d.ts

@@ -0,0 +1,5 @@
+import Events from '@autofleet/events';
+import type { CustomFieldDefinition, CustomFieldEntries, CustomFieldValue, CustomValidator } from '../models';
+declare const events: Events;
+export declare const sendDimEvent: (instance: CustomFieldDefinition | CustomFieldValue | CustomFieldEntries | CustomValidator) => void;
+export default events;