@autofleet/sadot 0.0.1-beta → 0.0.1-beta.0

package/package.json

@@ -1,39 +1,32 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.0.1-beta",
+  "version": "0.0.1-beta.0",
   "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",
+    "test": "jest --forceExit",
+    "coverage": "jest --coverage --forceExit && 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"
+    "sequelize": "^6.31.1"
   },
   "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",
+    "sequelize-typescript": "^2.1.5",
     "ts-jest": "^27.0.3",
     "ts-node": "^8.6.2",
     "typescript": "^4.9.5",

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

@@ -10,7 +10,7 @@ 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());
+const toPascalCase = (str: string): string => str.replace(/(^\w|-\w)/g, subStr => subStr.replace(/-/, '').toUpperCase());
 
 /**
  * Create
@@ -19,13 +19,13 @@ 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 validatedPayload: CreateCustomFieldDefinition =
+      await validateCustomFieldDefinitionCreation({
+        ...req.body,
+        modelType,
+      });
 
-    const customFieldDefinition = await DefinitionRepo.create({
-      ...validatedPayload,
-      modelType,
-    });
+    const customFieldDefinition = await DefinitionRepo.create(validatedPayload);
     return res.status(201).json(customFieldDefinition);
   } catch (err) {
     logger.error('Failed to create custom field definition', err);
@@ -57,18 +57,11 @@ router.get('/:customFieldDefinitionId', async (req, res) => {
  */
 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 },
-    );
+    const customFieldDefinitions = await DefinitionRepo.findAll({
+      modelType,
+    });
     return res.json(customFieldDefinitions);
   } catch (err) {
     logger.error('Failed to fetch custom field definitions', err);
@@ -83,8 +76,8 @@ 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 validatedPayload: UpdateCustomFieldDefinition =
+      await validateCustomFieldDefinitionUpdate(req.body);
 
     const customFieldDefinition = await DefinitionRepo.findByWhere({
       id: customFieldDefinitionId,
@@ -97,7 +90,7 @@ router.patch('/:customFieldDefinitionId', async (req, res) => {
 
     const updatedCustomFieldDefinition = await DefinitionRepo.update(
       customFieldDefinitionId,
-      { ...validatedPayload, modelType },
+      validatedPayload,
     );
 
     return res.status(200).json(updatedCustomFieldDefinition);

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

@@ -1,19 +1,22 @@
 import Joi from '@hapi/joi';
-import { CustomFieldDefinitionType } from '../../../utils/validations/type';
-
-const ValidationSchema = Joi.when('fieldType', {
-  is: CustomFieldDefinitionType.SELECT,
-  then: Joi.array().items(Joi.string()).min(1).unique(),
-  otherwise: Joi.any(),
-});
+import { CustomFieldDefinitionType } from '../../../models/CustomFieldDefinition';
 
 const CustomFieldDefinitionCreationSchema = Joi.object({
   name: Joi.string().required(),
   displayName: Joi.string().required(),
-  validation: ValidationSchema,
-  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)).required(),
+  validation: Joi.object().required(),
+  fieldType: Joi.string().valid(
+    CustomFieldDefinitionType.BOOLEAN,
+    CustomFieldDefinitionType.NUMBER,
+    CustomFieldDefinitionType.DATE,
+    CustomFieldDefinitionType.DATETIME,
+    CustomFieldDefinitionType.TEXT,
+    CustomFieldDefinitionType.IMAGE,
+    CustomFieldDefinitionType.ENUM,
+  ).required(),
   entityId: Joi.string().guid().required(),
   entityType: Joi.string().required(),
+  modelType: Joi.string().required(),
   description: Joi.string(),
   required: Joi.boolean(),
   disabled: Joi.boolean(),
@@ -21,15 +24,26 @@ const CustomFieldDefinitionCreationSchema = Joi.object({
 
 const CustomFieldDefinitionUpdateSchema = Joi.object({
   displayName: Joi.string(),
-  validation: ValidationSchema,
-  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)),
+  validation: Joi.object(),
+  fieldType: Joi.string().valid(
+    CustomFieldDefinitionType.BOOLEAN,
+    CustomFieldDefinitionType.NUMBER,
+    CustomFieldDefinitionType.DATE,
+    CustomFieldDefinitionType.DATETIME,
+    CustomFieldDefinitionType.TEXT,
+    CustomFieldDefinitionType.IMAGE,
+    CustomFieldDefinitionType.ENUM,
+  ),
+  entityId: Joi.string().guid(),
+  entityType: Joi.string(),
+  modelType: Joi.string(),
   description: Joi.string(),
   required: Joi.boolean(),
   disabled: Joi.boolean(),
 });
 
-export const validateCustomFieldDefinitionCreation = (payload) =>
+export const validateCustomFieldDefinitionCreation = payload =>
   CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
 
-export const validateCustomFieldDefinitionUpdate = (payload) =>
+export const validateCustomFieldDefinitionUpdate = payload =>
   CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });

package/src/api/v1/index.ts

@@ -4,6 +4,6 @@ import definitionRouter from './definition';
 
 const router = Router({ mergeParams: true });
 
-router.use('/custom-field-definitions/:modelName', definitionRouter);
+router.use('/:modelName/custom-field-definitions', definitionRouter);
 
 export default router;

package/src/events/index.ts

@@ -3,21 +3,6 @@ import logger from '../utils/logger';
 
 const events = new Events({ logger });
 
-const KEYS_TO_CONVERT = ['value'];
-
-const stringifyBools = (savedObject: any, keysToConvert: Array<string>) => {
-  if (Object.keys(savedObject).some((key) => keysToConvert.includes(key))) {
-    const objectToReturn = { ...savedObject };
-    keysToConvert.forEach((key) => {
-      if (typeof savedObject[key] === 'boolean') {
-        objectToReturn[key] = savedObject[key].toString();
-      }
-    });
-    return objectToReturn;
-  }
-  return savedObject;
-};
-
 const modelTableMapping = {
   CustomFieldDefinition: {
     tableName: 'dim_custom_field_definition',
@@ -32,17 +17,10 @@ const modelTableMapping = {
 export const sendDimEvent = (instance): void => {
   const mapping = modelTableMapping[instance.constructor.name];
   if (mapping) {
-    let objectToSend = instance.get();
-    try {
-      objectToSend = stringifyBools(instance.get(), KEYS_TO_CONVERT);
-    } catch (err) {
-      logger.error('Failed to convert booleans in dim event payload', err);
-    }
-
     events.sendObject(
       mapping.tableName,
       mapping.eventVersion,
-      objectToSend,
+      instance.get(),
     );
   }
 };

package/src/hooks/create.ts

@@ -1,7 +1,5 @@
-import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
-import { MissingRequiredCustomFieldError } from '../errors';
 
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
@@ -19,33 +17,29 @@ export const beforeCreate = (scopeAttributes: string[]) => async (
   instance,
   options,
 ): Promise<void> => {
-  logger.debug('sadot - before create hook');
   const { fields } = options;
   const modelType = instance.constructor.name;
-  const identifiers = scopeAttributes.map((attribute) => instance[attribute]);
+  const identifiers = scopeAttributes.map(attribute => instance[attribute]);
   // get all model's required definitions
-  const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType,
-    instance.id,
-    identifiers);
+  const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers);
   const customFieldsIdx = fields.indexOf('customFields');
   const { customFields } = instance;
   if (customFieldsIdx > -1 && customFields) {
     const fieldsNames = Object.keys(customFields);
-    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
-    if (missingFields?.length > 0) {
-      throw new MissingRequiredCustomFieldError(missingFields);
+    if (requiredFieldsNames.some(name => !fieldsNames.includes(name))) {
+      throw new Error('some fields are required');
     }
 
     await ValueRepo.updateValues(
       modelType,
       instance.id,
-      identifiers,
       customFields,
       { transaction: options.transaction },
     );
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);
   } else if (requiredFieldsNames?.length > 0) {
-    throw new MissingRequiredCustomFieldError(requiredFieldsNames);
+    throw new Error('some fields are required');
   }
 };
+

package/src/hooks/find.ts

@@ -1,27 +1,86 @@
-/* eslint-disable no-param-reassign */
-import logger from '../utils/logger';
-
-const doScopeAttributesMissing = (
-  scopeAttributes: string[],
-  queryAttributes: (string | string[])[],
-): string[] => {
-  const attributes = scopeAttributes
-    .filter((attribute) => !queryAttributes.includes(attribute));
-  if (!queryAttributes.includes?.('id')) {
-    attributes.push('id');
-  }
-  return attributes;
+
+import * as ValueRepo from '../repository/value';
+import * as DefinitionRepo from '../repository/definition';
+import CustomFieldValue from '../models/CustomFieldValue';
+import { SerializedCustomFields } from '../types/definition';
+
+/**
+ * Serialize custom fields value into the format of {[name] -> [fieldData]}
+ */
+const serializeCustomFields = (customFieldValues: CustomFieldValue[]): SerializedCustomFields => {
+  const customFields = customFieldValues.reduce((acc, cfv) => ({
+    ...acc,
+    [cfv.customFieldDefinition.name]: cfv.value,
+  }), {});
+  return customFields;
 };
 
-// eslint-disable-next-line import/prefer-default-export
-export const beforeFind = (scopeAttributes: string[]) => (options): void => {
-  const { attributes: queryAttributes } = options;
-  if (queryAttributes?.includes('customFields')) {
-    const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
-    logger.debug('sadot - before find hook');
-    if (missingScopeAttributes?.length > 0) {
-      queryAttributes.push(...missingScopeAttributes);
-      options.attributesToRemove = missingScopeAttributes;
+/**
+ * A hook to attach the custom fields when fetching a model instances.
+ */
+const afterFind = (scopeAttributes: string[]) => async (
+  instancesOrInstance: any | any[],
+  options,
+): Promise<void> => {
+  const primaryKey = 'id';
+  const instances = Array.isArray(instancesOrInstance)
+    ? instancesOrInstance
+    : [instancesOrInstance];
+
+  const identifiers = instances.map(instance => scopeAttributes.map(attr => instance[attr])).flat();
+  const uniqueIdentifiers = [...new Set(identifiers)];
+  const identifierCustomFieldDefinitionsMapping = {};
+  await Promise.all(uniqueIdentifiers.map(async (identifier) => {
+    const customFieldDefinitions = await DefinitionRepo.findByEntityId(
+      identifier,
+      options.transaction,
+    );
+    identifierCustomFieldDefinitionsMapping[identifier] = customFieldDefinitions;
+  }));
+
+  // Get the values per instates ids:
+  const instancesIds = instances.map(i => i[primaryKey]);
+
+  const customFieldValues = await ValueRepo.findValuesByModelIds(
+    instancesIds,
+    { transaction: options.transaction },
+  );
+
+  // Group fields by modelId
+  const valuesGroupByInstance: {
+    [modelId: string]: CustomFieldValue[];
+  } = customFieldValues.reduce((acc, v) => {
+    const { modelId } = v;
+    if (!acc[modelId]) {
+      acc[modelId] = [];
+    }
+    acc[modelId].push(v);
+    return acc;
+  }, {});
+
+  // Attach custom fields to the instances
+  instances.forEach((instance) => {
+    const customFields = {};
+    const { id } = instance;
+    const instanceValues = valuesGroupByInstance[id];
+    if (instanceValues) {
+      const serializedCustomFields = serializeCustomFields(instanceValues);
+      Object.assign(customFields, serializedCustomFields);
     }
-  }
+
+    scopeAttributes.forEach((attribute) => {
+      const identifier = instance[attribute];
+      const customFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];
+      if (customFieldDefinitions?.length > 0) {
+        customFieldDefinitions.forEach((customFieldDefinition) => {
+          if (customFields[customFieldDefinition.name] === undefined) {
+            customFields[customFieldDefinition.name] = null;
+          }
+        });
+      }
+    });
+    instance.setDataValue('customFields', customFields);
+  });
 };
+
+export default afterFind;

package/src/hooks/index.ts

@@ -1,12 +1,10 @@
-import enrichResults from './enrich';
-import { beforeFind } from './find';
+import afterFind from './find';
 import { beforeBulkUpdate, beforeUpdate } from './update';
 import { beforeBulkCreate, beforeCreate } from './create';
 import workaround from './workaround';
 
 export {
-  enrichResults,
-  beforeFind,
+  afterFind,
   beforeBulkUpdate,
   beforeUpdate,
   beforeBulkCreate,

package/src/hooks/update.ts

@@ -1,5 +1,5 @@
-import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
+import * as DefinitionRepo from '../repository/definition';
 
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
@@ -9,7 +9,6 @@ export const beforeBulkUpdate = (options): void => {
   // eslint-disable-next-line no-param-reassign
   options.individualHooks = true;
 };
-
 /**
  * A hook to update the custom fields when updating a model instance.
  * TODO - cleanup if update fail
@@ -18,22 +17,29 @@ export const beforeUpdate = (scopeAttributes: string[]) => async (
   instance,
   options,
 ): Promise<void> => {
-  logger.debug('sadot - before update hook');
   const { fields } = options;
   const modelType = instance.constructor.name;
-  const identifiers = scopeAttributes.map((attribute) => instance[attribute]);
+  const identifiers = scopeAttributes.map(attribute => instance[attribute]);
+  // get all model's required definitions
+  const requiredNullFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers, true);
 
   const customFieldsIdx = fields.indexOf('customFields');
   if (customFieldsIdx > -1) {
     const { customFields } = instance;
+    const fieldsNames = Object.keys(customFields);
+    if (requiredNullFieldsNames.some(name => !fieldsNames.includes(name))) {
+      throw new Error('some fields are required');
+    }
     await ValueRepo.updateValues(
       modelType,
       instance.id,
-      identifiers,
       customFields,
       { transaction: options.transaction },
     );
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);
+  } else if (requiredNullFieldsNames?.length > 0) {
+    throw new Error('some fields are required');
   }
 };
+

package/src/hooks/workaround.ts

@@ -33,11 +33,11 @@ const handleChildrenAfterFindHook = async (instances, options, level = 0) => {
   }
 
   const { associations } = constructor;
-  const associatedNames = Object.keys(instance).filter((attribute) =>
+  const associatedNames = Object.keys(instance).filter(attribute =>
     Object.keys(associations).includes(attribute));
 
   if (associatedNames.length) {
-    const childInstances = associatedNames.map((name) => instance[name]);
+    const childInstances = associatedNames.map(name => instance[name]);
     return handleChildrenAfterFindHook(childInstances, options, level + 1);
   }
 

package/src/index.ts

@@ -1,16 +1,8 @@
 import type { Application } from 'express';
 import { DataTypes } from 'sequelize';
-import { Sequelize } from 'sequelize-typescript';
-import { initTables, initTestModels } from './models';
+import { initTables } from './models';
 import api from './api';
-import {
-  beforeFind,
-  enrichResults,
-  beforeBulkUpdate,
-  beforeUpdate,
-  beforeCreate,
-  beforeBulkCreate,
-} from './hooks';
+import { afterFind, beforeBulkUpdate, beforeUpdate, beforeCreate, beforeBulkCreate } from './hooks';
 import initDB from './utils/db';
 import logger from './utils/logger';
 import { CustomFieldOptions, ModelFetcher, ModelOptions } from './types';
@@ -21,27 +13,19 @@ const addHooks = (models: ModelOptions[], getModel: ModelFetcher) => {
   models.forEach(async ({ name, scopeAttributes }) => {
     try {
       const model = getModel(name);
-      if (!model) {
-        logger.warn('sadot - tried to addHooks to a model that does not exist yet', {
-          name,
-          scopeAttributes,
-        });
-        return;
-      }
+      if (!model) return;
       model.rawAttributes.customFields = {
         type: DataTypes.VIRTUAL,
       };
       model.refreshAttributes();
       // TODO: Uncomment after tests are passed
       // model.addHook('afterFind', workaround);
-      model.addHook('beforeFind', 'sadot-beforeFind', beforeFind(scopeAttributes));
-      model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', beforeBulkCreate);
-      model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', beforeBulkUpdate);
-      model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes));
-      model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes));
-      model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes));
-      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes));
-      model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes));
+      model.addHook('afterFind', afterFind);
+      model.addHook('beforeBulkCreate', beforeBulkCreate);
+      model.addHook('afterFind', afterFind(scopeAttributes));
+      model.addHook('beforeBulkUpdate', beforeBulkUpdate);
+      model.addHook('beforeCreate', beforeCreate(scopeAttributes));
+      model.addHook('beforeUpdate', beforeUpdate(scopeAttributes));
     } catch (e) {
       logger.error(`Could not add custom fields hook to model ${name}. `, e);
     }
@@ -56,46 +40,19 @@ const useCustomFields = async (
   app: Application | null,
   getModel: ModelFetcher,
   options: CustomFieldOptions,
-): Promise<Sequelize> => {
-  const { models } = options;
+): Promise<void> => {
+  const { innerSequelize, models } = options;
+  // deepAfterFindWorkAround(sequelize);
   if (app) {
     app.use('/api', api);
   }
-  const sequelize = initDB(options.databaseConfig);
-  if (process.env.NODE_ENV === 'test') {
-    await initTestModels(sequelize);
+  if (!innerSequelize) {
+    const moreInnerSequelize = initDB(options.databaseConfig);
+    await initTables(moreInnerSequelize);
+  } else {
+    await initTables(innerSequelize);
   }
   addHooks(models, getModel);
-  await initTables(sequelize, options.getUser);
-  logger.debug('sadot - custom fields finished initializing with models', models);
-  return sequelize;
 };
 
 export default useCustomFields;
-
-const removeHooks = (models: ModelOptions[], getModel: ModelFetcher) => {
-  models.forEach(async ({ name }) => {
-    try {
-      const model = getModel(name);
-      if (!model) return;
-      if (model.rawAttributes.customFields) {
-        delete model.rawAttributes.customFields;
-        model.refreshAttributes();
-      }
-      // model.removeHook('afterFind', 'sadot-workaround');
-      model.removeHook('beforeFind', 'sadot-beforeFind');
-      model.removeHook('beforeBulkCreate', 'sadot-beforeBulkCreate');
-      model.removeHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate');
-      model.removeHook('beforeCreate', 'sadot-beforeCreate');
-      model.removeHook('beforeUpdate', 'sadot-beforeUpdate');
-      model.removeHook('afterFind', 'sadot-afterFind');
-      model.removeHook('afterUpdate', 'sadot-afterUpdate');
-    } catch (e) {
-      logger.error(`Could not add custom fields hook to model ${name}. `, e);
-    }
-  });
-};
-
-export const disableCustomFields = (models, getModel) => {
-  removeHooks(models, getModel);
-};

package/src/models/CustomFieldDefinition.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -10,32 +9,30 @@ import {
   BeforeCreate,
   DefaultScope,
   AfterSave,
-  Is,
 } from 'sequelize-typescript';
-import { validateValidation } from '../utils/validations/custom';
-import { CustomFieldDefinitionType } from '../utils/validations/type';
 import { CustomFieldValue } from '.';
 import { sendDimEvent } from '../events';
-import { UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } from '../errors';
+
+/**
+ * Supported custom field types
+ */
+export enum CustomFieldDefinitionType {
+  NUMBER = 'number',
+  BOOLEAN = 'boolean',
+  DATE = 'date',
+  DATETIME = 'datetime',
+  TEXT = 'text',
+  IMAGE = 'image',
+  ENUM = 'enum',
+}
 
 @DefaultScope(() => ({ where: { disabled: false } }))
 @Table({
   indexes: [
-    {
-      name: 'unique_name_model_type',
-      fields: ['model_type', 'entity_id', 'name'],
-      unique: true,
-    },
+  { name: "unique_name_model_type", fields: ["name", "model_type", "entity_id"], unique: true },
   ],
   timestamps: true,
-  validate: {
-    validationByType(this: CustomFieldDefinition) {
-      if (!validateValidation(this.fieldType, this.validation)) {
-        throw new UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
-      }
-    },
-  },
-})
+  })
 class CustomFieldDefinition extends Model {
   @PrimaryKey
   @Column({
@@ -56,11 +53,6 @@ class CustomFieldDefinition extends Model {
   })
   displayName?: string; // Defaulted to name with beforeCreate hook
 
-  @Is('SupportedType', (value) => {
-    if (!Object.values(CustomFieldDefinitionType).includes(value as CustomFieldDefinitionType)) {
-      throw new UnsupportedCustomFieldTypeError(`"${value}" is not a supported type.`);
-    }
-  })
   @Column({
     type: DataType.STRING,
     allowNull: false,