@autofleet/sadot 0.0.1-beta

package/dist/src/tests/mocks/definition.mock.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefinitions = exports.createDefinition = exports.rangeField = exports.enumField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = void 0;
+const uuid_1 = require("uuid");
+exports.coolFieldDefinition = {
+    name: 'cool field',
+    modelType: 'TestModel',
+    fieldType: 'number',
+    entityId: (0, uuid_1.v4)(),
+    entityType: 'fleetId',
+};
+exports.coolFieldDefinition2 = {
+    ...exports.coolFieldDefinition,
+    name: 'cool field2',
+};
+exports.coolFieldDefinition3 = {
+    ...exports.coolFieldDefinition,
+    name: 'cool field3',
+};
+const booleanField = (modelType) => ({
+    name: 'shapeless',
+    modelType,
+    fieldType: 'boolean',
+    entityId: (0, uuid_1.v4)(),
+    entityType: 'fleetId',
+});
+exports.booleanField = booleanField;
+const enumField = (modelType, options) => ({
+    name: 'choices',
+    modelType,
+    fieldType: 'select',
+    validation: options,
+    entityId: (0, uuid_1.v4)(),
+    entityType: 'fleetId',
+});
+exports.enumField = enumField;
+const rangeField = (modelType) => ({
+    name: 'ranges',
+    modelType,
+    fieldType: 'number',
+    validation: {
+        between: [10, 12],
+    },
+    entityId: (0, uuid_1.v4)(),
+    entityType: 'fleetId',
+});
+exports.rangeField = rangeField;
+// eslint-disable-next-line max-len
+const createDefinition = (defaults) => ({
+    name: defaults?.name || `def_${(0, uuid_1.v4)()}`,
+    modelType: defaults?.modelType || 'TestModel',
+    fieldType: defaults?.fieldType || 'boolean',
+    entityId: defaults?.entityId || (0, uuid_1.v4)(),
+    entityType: defaults?.entityType || 'fleetId',
+});
+exports.createDefinition = createDefinition;
+const createDefinitions = (defaults, length = 1) => (Array(length).fill({}).map((_) => ({
+    name: defaults?.name || `def_${(0, uuid_1.v4)()}`,
+    modelType: defaults?.modelType || 'TestModel',
+    fieldType: defaults?.fieldType || 'boolean',
+    entityId: defaults?.entityId || (0, uuid_1.v4)(),
+    entityType: defaults?.entityType || 'fleetId',
+})));
+exports.createDefinitions = createDefinitions;

package/dist/src/tests/mocks/events.mock.d.ts

@@ -0,0 +1,3 @@
+export declare const mockEvent: (events: any, eventName: any, numberOfEvents: any) => any[];
+export declare const mockDimCustomFieldDefinitionEvent: (events: any, numberOfEvents: any) => any[];
+export declare const mockDimCustomFieldValueEvent: (events: any, numberOfEvents: any) => any[];

package/dist/src/tests/mocks/events.mock.js

@@ -0,0 +1,19 @@
+"use strict";
+/* eslint-disable no-param-reassign */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mockDimCustomFieldValueEvent = exports.mockDimCustomFieldDefinitionEvent = exports.mockEvent = void 0;
+const mockEvent = (events, eventName, numberOfEvents) => {
+    events.sendObject = jest.fn();
+    return [
+        events.sendObject,
+        () => {
+            const matchingEvents = events.sendObject.mock.calls.filter((call) => call[0] === eventName);
+            expect(matchingEvents.length).toEqual(numberOfEvents);
+        },
+    ];
+};
+exports.mockEvent = mockEvent;
+const mockDimCustomFieldDefinitionEvent = (events, numberOfEvents) => (0, exports.mockEvent)(events, 'dim_custom_field_definition', numberOfEvents);
+exports.mockDimCustomFieldDefinitionEvent = mockDimCustomFieldDefinitionEvent;
+const mockDimCustomFieldValueEvent = (events, numberOfEvents) => (0, exports.mockEvent)(events, 'dim_custom_field_value', numberOfEvents);
+exports.mockDimCustomFieldValueEvent = mockDimCustomFieldValueEvent;

package/dist/src/tests/mocks/testModel.d.ts

@@ -0,0 +1,12 @@
+import { TestModel } from '../../models';
+export declare const createTestModel: (payload?: {}) => Promise<TestModel>;
+export declare const createTestModels: (fleetId: any, total: number) => Promise<TestModel[]>;
+export declare const upsertTestModel: (payload: any) => Promise<[TestModel, boolean]>;
+export declare const destroyTestModels: () => Promise<number>;
+export declare const getTestModel: (id: string, options?: {}) => Promise<TestModel>;
+export declare const getSomeTestModels: (options?: {
+    limit: number;
+}) => Promise<TestModel[]>;
+export declare const updateTestModel: (payload: any, query: any) => Promise<[affectedCount: number, affectedRows: TestModel[]]>;
+export declare const createTestModelWithAssociation: () => Promise<TestModel>;
+export declare const getTestModelWithAssociation: (limit?: number) => Promise<TestModel[]>;

package/dist/src/tests/mocks/testModel.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTestModelWithAssociation = exports.createTestModelWithAssociation = exports.updateTestModel = exports.getSomeTestModels = exports.getTestModel = exports.destroyTestModels = exports.upsertTestModel = exports.createTestModels = exports.createTestModel = void 0;
+const models_1 = require("../../models");
+const createTestModel = (payload = {}) => models_1.TestModel.create(payload);
+exports.createTestModel = createTestModel;
+const createTestModels = (fleetId, total) => {
+    const models = [];
+    for (let i = 0; i < total; i += 1) {
+        models.push((0, exports.createTestModel)({ fleetId }));
+    }
+    return Promise.all(models);
+};
+exports.createTestModels = createTestModels;
+const upsertTestModel = (payload) => models_1.TestModel.upsert(payload);
+exports.upsertTestModel = upsertTestModel;
+const destroyTestModels = () => models_1.TestModel.destroy({ truncate: true });
+exports.destroyTestModels = destroyTestModels;
+const getTestModel = (id, options = {}) => models_1.TestModel.findByPk(id, options);
+exports.getTestModel = getTestModel;
+const getSomeTestModels = (options = { limit: 1 }) => models_1.TestModel.findAll(options);
+exports.getSomeTestModels = getSomeTestModels;
+const updateTestModel = (payload, query) => models_1.TestModel.update(payload, query);
+exports.updateTestModel = updateTestModel;
+// Associations
+const createTestModelWithAssociation = async () => {
+    const model = await models_1.TestModel.create({});
+    await models_1.AssociatedTestModel.create({ testModelId: model.id });
+    return model;
+};
+exports.createTestModelWithAssociation = createTestModelWithAssociation;
+const getTestModelWithAssociation = (limit = 1) => models_1.TestModel.findAll({
+    limit, include: [models_1.AssociatedTestModel],
+});
+exports.getTestModelWithAssociation = getTestModelWithAssociation;

package/dist/src/types/definition/index.d.ts

@@ -0,0 +1,23 @@
+export interface CustomFieldDefinitionDTO {
+    id: string;
+    name: string;
+    displayName?: string;
+    validation?: any;
+    fieldType: string;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+    required?: boolean;
+    description?: string;
+    disabled?: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+}
+export type CreateCustomFieldDefinition = Omit<CustomFieldDefinitionDTO, 'id'>;
+export type UpdateCustomFieldDefinition = Partial<CreateCustomFieldDefinition>;
+export type SerializedCustomFields = {
+    [name: string]: CustomFieldDefinitionDTO & {
+        value: any;
+    };
+};

package/dist/src/types/definition/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/index.d.ts

@@ -0,0 +1,13 @@
+export type ModelFetcher = (name: string) => any;
+export type ModelOptions = {
+    name: string;
+    scopeAttributes: string[];
+    creationWebhookHandler?: (instance: any) => any;
+    updateWebhookHandler?: (instance: any) => any;
+    deletionWebhookHandler?: (instance: any) => any;
+};
+export type CustomFieldOptions = {
+    models: ModelOptions[];
+    databaseConfig: any;
+    getUser: () => any;
+};

package/dist/src/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/types/value/index.d.ts

@@ -0,0 +1,15 @@
+export interface CustomFieldValueDTO {
+    id?: string;
+    modelId: string;
+    customFieldDefinitionId: string;
+    value: any;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+}
+export type ValuesToUpdate = {
+    [name: string]: any;
+};
+export type CreateCustomFieldValue = Omit<CustomFieldValueDTO, 'id'>;
+export type UpdateCustomFieldValue = ValuesToUpdate;
+export type BulkUpdateCustomFieldValue = Partial<CustomFieldValueDTO>[];

package/dist/src/types/value/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/src/utils/constants/index.d.ts

@@ -0,0 +1 @@
+export declare const supportedEntities: string[];

package/dist/src/utils/constants/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.supportedEntities = void 0;
+// eslint-disable-next-line import/prefer-default-export
+exports.supportedEntities = ['businessModelId', 'fleetId', 'demandSourceId'];

package/dist/src/utils/db/index.d.ts

@@ -0,0 +1,4 @@
+import { Sequelize } from 'sequelize-typescript';
+declare const _default: (databaseConfig: any) => Sequelize;
+export default _default;
+export declare const createSequelizeMeta: (sequelize: Sequelize) => Promise<object[]>;

package/dist/src/utils/db/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSequelizeMeta = void 0;
+const sequelize_typescript_1 = require("sequelize-typescript");
+const sequelize_1 = require("sequelize");
+exports.default = (databaseConfig) => {
+    const ENV_DEV = 'test';
+    const env = process.env.NODE_ENV || ENV_DEV;
+    const config = databaseConfig[env];
+    let sequelize;
+    if (config.use_env_variable) {
+        sequelize = new sequelize_typescript_1.Sequelize(process.env[config.use_env_variable], config);
+    }
+    else {
+        sequelize = new sequelize_typescript_1.Sequelize(config.database, config.username, config.password, config);
+    }
+    return sequelize;
+};
+const createSequelizeMeta = (sequelize) => sequelize.query(`
+CREATE TABLE IF NOT EXISTS "SequelizeMeta" (
+  name character varying(255) PRIMARY KEY
+);
+`, { type: sequelize_1.QueryTypes.SELECT });
+exports.createSequelizeMeta = createSequelizeMeta;

package/dist/src/utils/logger/index.d.ts

@@ -0,0 +1,2 @@
+declare const logger: any;
+export default logger;

package/dist/src/utils/logger/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Logger = require('@autofleet/logger');
+const logger = Logger();
+exports.default = logger;

package/dist/src/utils/validations/custom-fields.d.ts

@@ -0,0 +1,2 @@
+declare const CustomFieldsSchema: any;
+export { CustomFieldsSchema };

package/dist/src/utils/validations/custom-fields.js

@@ -0,0 +1,10 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomFieldsSchema = void 0;
+/* eslint-disable import/prefer-default-export */
+const joi_1 = __importDefault(require("@hapi/joi"));
+const CustomFieldsSchema = joi_1.default.object().pattern(joi_1.default.string(), joi_1.default.any());
+exports.CustomFieldsSchema = CustomFieldsSchema;

package/dist/src/utils/validations/custom.d.ts

@@ -0,0 +1,15 @@
+export declare const mustHaveCustomValidation: {
+    select: boolean;
+};
+/**
+ * Validates the given validations object against the supported field types and their validators.
+ * @return true if the validation is valid, false otherwise.
+ */
+export declare const validateValidation: (valueType: any, validation: any) => boolean;
+/**
+ * Validates the given value against the custom validation rules for the specified field type.
+ * If no custom validation rules are provided, it falls back to the default validation.
+ * @returns true if the value is valid according to the validation rules, false otherwise.
+ */
+declare const customValidation: (value: any, valueType: any, validation: any) => boolean;
+export default customValidation;

package/dist/src/utils/validations/custom.js

@@ -0,0 +1,42 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateValidation = exports.mustHaveCustomValidation = void 0;
+/* eslint-disable no-shadow */
+const logger_1 = __importDefault(require("../logger"));
+const type_1 = require("./type");
+const validators_1 = __importDefault(require("./validators"));
+exports.mustHaveCustomValidation = {
+    [type_1.CustomFieldDefinitionType.SELECT]: true,
+};
+/**
+ * Validates the given validations object against the supported field types and their validators.
+ * @return true if the validation is valid, false otherwise.
+ */
+const validateValidation = (valueType, validation) => {
+    if (!validation) {
+        if (exports.mustHaveCustomValidation[valueType]) {
+            logger_1.default.error(`No custom validation for custom field type ${valueType} found`);
+            return false;
+        }
+        return true;
+    }
+    return true;
+};
+exports.validateValidation = validateValidation;
+/**
+ * Validates the given value against the custom validation rules for the specified field type.
+ * If no custom validation rules are provided, it falls back to the default validation.
+ * @returns true if the value is valid according to the validation rules, false otherwise.
+ */
+const customValidation = (value, valueType, validation) => {
+    const validator = validators_1.default?.[valueType];
+    if (!validation || !validator) {
+        return (0, exports.validateValidation)(valueType, validation);
+    }
+    // Always allow null values
+    return value === null || validator(value, validation);
+};
+exports.default = customValidation;

package/dist/src/utils/validations/index.d.ts

@@ -0,0 +1,2 @@
+declare const validateValue: (value: any, valueType: any, customValidations: any) => boolean;
+export default validateValue;

package/dist/src/utils/validations/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const custom_1 = __importDefault(require("./custom"));
+const type_1 = __importDefault(require("./type"));
+const validateValue = (value, valueType, customValidations) => {
+    if (!(0, type_1.default)(value, valueType)) {
+        return false;
+    }
+    if (customValidations) {
+        return (0, custom_1.default)(value, valueType, customValidations);
+    }
+    // if (validations.required && !value) {
+    //   return false;
+    // }
+    return true;
+};
+exports.default = validateValue;

package/dist/src/utils/validations/type.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Supported custom field types
+ */
+export declare enum CustomFieldDefinitionType {
+    NUMBER = "number",
+    BOOLEAN = "boolean",
+    DATE = "date",
+    DATETIME = "datetime",
+    TEXT = "text",
+    IMAGE = "image",
+    SELECT = "select"
+}
+/**
+ * Validate that the given value is really of type "valueType"
+ * TODO: verify that required field not set to null
+ */
+declare const validateValueType: (value: unknown, valueType: CustomFieldDefinitionType) => boolean;
+export default validateValueType;

package/dist/src/utils/validations/type.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomFieldDefinitionType = void 0;
+const joi_1 = __importDefault(require("@hapi/joi"));
+/**
+ * Supported custom field types
+ */
+// eslint-disable-next-line no-shadow
+var CustomFieldDefinitionType;
+(function (CustomFieldDefinitionType) {
+    CustomFieldDefinitionType["NUMBER"] = "number";
+    CustomFieldDefinitionType["BOOLEAN"] = "boolean";
+    CustomFieldDefinitionType["DATE"] = "date";
+    CustomFieldDefinitionType["DATETIME"] = "datetime";
+    CustomFieldDefinitionType["TEXT"] = "text";
+    CustomFieldDefinitionType["IMAGE"] = "image";
+    CustomFieldDefinitionType["SELECT"] = "select";
+})(CustomFieldDefinitionType = exports.CustomFieldDefinitionType || (exports.CustomFieldDefinitionType = {}));
+/**
+ * Validate that the given value is really of type "valueType"
+ * TODO: verify that required field not set to null
+ */
+const validateValueType = (value, valueType) => {
+    if (value === null) {
+        // Null is always allowed
+        return true;
+    }
+    switch (valueType) {
+        case CustomFieldDefinitionType.TEXT:
+            return typeof value === 'string';
+        case CustomFieldDefinitionType.NUMBER:
+            return typeof value === 'number';
+        case CustomFieldDefinitionType.BOOLEAN:
+            return typeof value === 'boolean';
+        case CustomFieldDefinitionType.DATE:
+        case CustomFieldDefinitionType.DATETIME:
+            return !joi_1.default.date().validate(value).error;
+        case CustomFieldDefinitionType.SELECT:
+            return true; // custom validation
+        case CustomFieldDefinitionType.IMAGE:
+            return !joi_1.default.array().min(1).unique().items(joi_1.default.string().uri())
+                .validate(value).error;
+        default:
+            return false;
+    }
+};
+exports.default = validateValueType;

package/dist/src/utils/validations/validators.d.ts

@@ -0,0 +1,12 @@
+export declare enum CustomValidations {
+    SELECT = "select",
+    RANGE = "between"
+}
+type Validator = (value: any, validation: any) => boolean;
+/**
+ * Validators for custom fields
+ */
+declare const validators: {
+    [key: string]: Validator;
+};
+export default validators;

package/dist/src/utils/validations/validators.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CustomValidations = void 0;
+// eslint-disable-next-line no-shadow
+var CustomValidations;
+(function (CustomValidations) {
+    CustomValidations["SELECT"] = "select";
+    CustomValidations["RANGE"] = "between";
+})(CustomValidations = exports.CustomValidations || (exports.CustomValidations = {}));
+/**
+ * Validate {@link CustomValidations.ENUM Enum}
+ */
+const validateEnum = (value, enumValues) => (Array.isArray(enumValues)
+    && enumValues.length > 0
+    && enumValues.includes(value));
+/**
+ * Validate {@link CustomValidations.RANGE Range}
+ */
+const validateRange = (value, range) => {
+    const [min, max] = range;
+    if (min === undefined || max === undefined) {
+        return false;
+    }
+    return value >= range.min && value <= range.max;
+};
+/**
+ * Validators for custom fields
+ */
+const validators = {
+    [CustomValidations.SELECT]: validateEnum,
+    [CustomValidations.RANGE]: validateRange,
+};
+exports.default = validators;

package/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "@autofleet/sadot",
+  "version": "0.0.1-beta",
+  "description": "",
+  "main": "dist/index.js",
+  "scripts": {
+    "start": "ts-node  src/index.ts",
+    "build": "rm -rf dist && tsc",
+    "linter": "./node_modules/.bin/eslint .",
+    "test": "jest --forceExit --runInBand",
+    "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
+    "dev": "nodemon"
+  },
+  "dependencies": {
+    "@autofleet/errors": "^1.0.10",
+    "@autofleet/events": "^2.0.0",
+    "@autofleet/logger": "^2.0.5",
+    "@hapi/joi": "^17.1.1",
+    "express": "^4.18.2",
+    "pg": "^8.10.0",
+    "reflect-metadata": "^0.1.13",
+    "sequelize": "^6.31.1",
+    "sequelize-typescript": "^2.1.5",
+    "uuid": "^9.0.0"
+  },
+  "devDependencies": {
+    "@types/express": "^4.17.17",
+    "@types/jest": "^27.0.9",
+    "@types/node": "^20.5.6",
+    "@types/uuid": "^9.0.2",
+    "@typescript-eslint/eslint-plugin": "^4.8.1",
+    "@typescript-eslint/parser": "^4.33.0",
+    "eslint": "^7.13.0",
+    "eslint-config-airbnb-typescript": "^12.0.0",
+    "eslint-plugin-import": "^2.22.1",
+    "jest": "^27.0.5",
+    "ts-jest": "^27.0.3",
+    "ts-node": "^8.6.2",
+    "typescript": "^4.9.5",
+    "typescript-eslint": "^0.0.1-alpha.0"
+  },
+  "author": "Autofleet",
+  "license": "ISC"
+}

package/src/api/index.ts

@@ -0,0 +1,9 @@
+// export the api object
+import { Router } from 'express';
+import v1 from './v1';
+
+const router = Router({ mergeParams: true });
+
+router.use('/v1', v1);
+
+export default router;

package/src/api/v1/definition/index.ts

@@ -0,0 +1,110 @@
+import { ResourceNotFoundError } from '@autofleet/errors';
+import { Router } from 'express';
+import type { Request, Response } from 'express';
+import handleError from '../errors';
+import * as DefinitionRepo from '../../../repository/definition';
+import { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../../../types/definition';
+import { validateCustomFieldDefinitionCreation, validateCustomFieldDefinitionUpdate } from './validations';
+import logger from '../../../utils/logger';
+
+const router = Router({ mergeParams: true });
+const ENTITY = 'CustomFieldDefinition';
+
+const toPascalCase = (str: string): string => str.replace(/(^\w|-\w)/g, (subStr) => subStr.replace(/-/, '').toUpperCase());
+
+/**
+ * Create
+ */
+router.post('/', async (req: Request, res: Response) => {
+  const { modelName } = req.params as any;
+  const modelType = toPascalCase(modelName);
+  try {
+    const validatedPayload: CreateCustomFieldDefinition = await
+    validateCustomFieldDefinitionCreation(req.body);
+
+    const customFieldDefinition = await DefinitionRepo.create({
+      ...validatedPayload,
+      modelType,
+    });
+    return res.status(201).json(customFieldDefinition);
+  } catch (err) {
+    logger.error('Failed to create custom field definition', err);
+    return handleError(err, res, { 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 ResourceNotFoundError();
+    }
+
+    return res.json(customFieldDefinition);
+  } catch (err) {
+    logger.error('Failed to fetch custom field definition', err);
+    return handleError(err, res, { message: `Error in get ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get all
+ */
+router.get('/', async (req, res) => {
+  const { modelName } = req.params as any;
+  const { entityIds } = req.query as any;
+
+  const modelType = toPascalCase(modelName);
+  try {
+    const where: any = { modelType };
+    if (entityIds?.length > 0) {
+      where.entityId = entityIds;
+    }
+    const customFieldDefinitions = await DefinitionRepo.findAll(
+      { ...where },
+      { withDisabled: true },
+    );
+    return res.json(customFieldDefinitions);
+  } catch (err) {
+    logger.error('Failed to fetch custom field definitions', err);
+    return handleError(err, res, { message: `Error in get all ${ENTITY} request` });
+  }
+});
+
+/**
+ * Update
+ */
+router.patch('/:customFieldDefinitionId', async (req, res) => {
+  const { customFieldDefinitionId, modelName } = req.params as any;
+  const modelType = toPascalCase(modelName);
+  try {
+    // eslint-disable-next-line max-len
+    const validatedPayload: UpdateCustomFieldDefinition = await validateCustomFieldDefinitionUpdate(req.body);
+
+    const customFieldDefinition = await DefinitionRepo.findByWhere({
+      id: customFieldDefinitionId,
+      modelType,
+    });
+
+    if (!customFieldDefinition) {
+      throw new ResourceNotFoundError();
+    }
+
+    const updatedCustomFieldDefinition = await DefinitionRepo.update(
+      customFieldDefinitionId,
+      { ...validatedPayload, modelType },
+    );
+
+    return res.status(200).json(updatedCustomFieldDefinition);
+  } catch (err) {
+    logger.error('Failed to patch custom field definition', err);
+    return handleError(err, res, { message: `Error in update ${ENTITY} request` });
+  }
+});
+
+export default router;