@autofleet/sadot 0.0.1-beta.9 → 0.1.0

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

@@ -1,22 +1,13 @@
 import Joi from '@hapi/joi';
-import { CustomFieldDefinitionType } from '../../../models/CustomFieldDefinition';
+import { CustomFieldDefinitionType } from '../../../utils/validations/type';
 
 const CustomFieldDefinitionCreationSchema = Joi.object({
   name: Joi.string().required(),
   displayName: Joi.string().required(),
-  validation: Joi.object().required(),
-  fieldType: Joi.string().valid(
-    CustomFieldDefinitionType.BOOLEAN,
-    CustomFieldDefinitionType.NUMBER,
-    CustomFieldDefinitionType.DATE,
-    CustomFieldDefinitionType.DATETIME,
-    CustomFieldDefinitionType.TEXT,
-    CustomFieldDefinitionType.IMAGE,
-    CustomFieldDefinitionType.ENUM,
-  ).required(),
+  validation: Joi.any().required(),
+  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)).required(),
   entityId: Joi.string().guid().required(),
   entityType: Joi.string().required(),
-  modelType: Joi.string().required(),
   description: Joi.string(),
   required: Joi.boolean(),
   disabled: Joi.boolean(),
@@ -24,19 +15,10 @@ const CustomFieldDefinitionCreationSchema = Joi.object({
 
 const CustomFieldDefinitionUpdateSchema = Joi.object({
   displayName: Joi.string(),
-  validation: Joi.object(),
-  fieldType: Joi.string().valid(
-    CustomFieldDefinitionType.BOOLEAN,
-    CustomFieldDefinitionType.NUMBER,
-    CustomFieldDefinitionType.DATE,
-    CustomFieldDefinitionType.DATETIME,
-    CustomFieldDefinitionType.TEXT,
-    CustomFieldDefinitionType.IMAGE,
-    CustomFieldDefinitionType.ENUM,
-  ),
+  validation: Joi.any(),
+  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)),
   entityId: Joi.string().guid(),
   entityType: Joi.string(),
-  modelType: Joi.string(),
   description: Joi.string(),
   required: Joi.boolean(),
   disabled: Joi.boolean(),

package/src/api/v1/index.ts

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

package/src/errors/index.ts

@@ -0,0 +1,42 @@
+/* eslint-disable max-classes-per-file */
+import { BadRequest } from '@autofleet/errors';
+
+export class MissingRequiredCustomFieldError extends BadRequest {
+  constructor(missingFields: string[]) {
+    const err = new Error(`The following custom fields are required: ${missingFields.join(',')}`);
+    super([err], null, missingFields);
+    this.message = 'MISSING_REQUIRED_CUSTOM_FIELDS';
+  }
+}
+
+export class UnsupportedCustomFieldTypeError extends BadRequest {
+  constructor(fieldType: string) {
+    const err = new Error(`Type "${fieldType}" is not supported`);
+    super([err], null, null);
+    this.message = 'UNSUPPORTED_CUSTOM_FIELD_TYPE';
+  }
+}
+
+export class UnsupportedCustomValidationError extends BadRequest {
+  constructor(fieldType: string) {
+    const err = new Error(`Validation for "${fieldType}" is not supported`);
+    super([err], null, null);
+    this.message = 'UNSUPPORTED_CUSTOM_VALIDATION_TYPE';
+  }
+}
+
+export class InvalidValueError extends BadRequest {
+  constructor(value: any, fieldType: string) {
+    const err = new Error(`Invalid "${fieldType}" value ${JSON.stringify(value)}`);
+    super([err], null, null);
+    this.message = 'INVALID_VALUE';
+  }
+}
+
+export class MissingDefinitionError extends BadRequest {
+  constructor(fieldNames: string[]) {
+    const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);
+    super([err], null, null);
+    this.message = 'MISSING_DEFINITION';
+  }
+}

package/src/hooks/create.ts

@@ -1,5 +1,6 @@
 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).
@@ -28,8 +29,9 @@ export const beforeCreate = (scopeAttributes: string[]) => async (
   const { customFields } = instance;
   if (customFieldsIdx > -1 && customFields) {
     const fieldsNames = Object.keys(customFields);
-    if (requiredFieldsNames.some((name) => !fieldsNames.includes(name))) {
-      throw new Error('some fields are required');
+    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+    if (missingFields?.length > 0) {
+      throw new MissingRequiredCustomFieldError(missingFields);
     }
 
     await ValueRepo.updateValues(
@@ -42,6 +44,6 @@ export const beforeCreate = (scopeAttributes: string[]) => async (
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);
   } else if (requiredFieldsNames?.length > 0) {
-    throw new Error('some fields are required');
+    throw new MissingRequiredCustomFieldError(requiredFieldsNames);
   }
 };

package/src/hooks/enrich.ts

@@ -0,0 +1,102 @@
+/* eslint-disable no-param-reassign */
+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;
+};
+/**
+ * A hook to attach the custom fields when fetching a model instances.
+ */
+const enrichResults = (scopeAttributes: string[]) => async (
+  instancesOrInstance: any | any[],
+  options,
+): Promise<void> => {
+  if (
+    options.originalAttributes?.length > 0
+      && !options.originalAttributes?.includes?.('customFields')
+  ) {
+    return;
+  }
+
+  const primaryKey = 'id';
+  let instances = Array.isArray(instancesOrInstance)
+    ? instancesOrInstance
+    : [instancesOrInstance];
+
+  instances = instances.filter((instance) => !!instance);
+
+  const identifiers = instances.map((instance) =>
+    scopeAttributes
+      .map((attr) => instance[attr])).flat();
+
+  const uniqueIdentifiers = [...new Set(identifiers)].filter((identifier) => !!identifier);
+  const identifierCustomFieldDefinitionsMapping = {};
+  await Promise.all(uniqueIdentifiers.map(async (identifier) => {
+    const customFieldDefinitions = await DefinitionRepo.findByEntityId(
+      identifier,
+      { transaction: 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.customFields = customFields;
+    options.attributesToRemove?.forEach?.((attribute) => {
+      delete instance.dataValues?.[attribute];
+      // if raw:
+      delete instance?.[attribute];
+    });
+  });
+};
+
+export default enrichResults;

package/src/hooks/find.ts

@@ -1,20 +1,4 @@
 /* eslint-disable no-param-reassign */
-import * as ValueRepo from '../repository/value';
-import * as DefinitionRepo from '../repository/definition';
-import CustomFieldValue from '../models/CustomFieldValue';
-import { SerializedCustomFields } from '../types/definition';
-import logger from '../utils/logger';
-
-/**
- * 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;
-};
 
 const doScopeAttributesMissing = (
   scopeAttributes: string[],
@@ -28,6 +12,7 @@ const doScopeAttributesMissing = (
   return attributes;
 };
 
+// eslint-disable-next-line import/prefer-default-export
 export const beforeFind = (scopeAttributes: string[]) => (options): void => {
   const { attributes: queryAttributes } = options;
   if (queryAttributes?.includes('customFields')) {
@@ -38,89 +23,3 @@ export const beforeFind = (scopeAttributes: string[]) => (options): void => {
     }
   }
 };
-
-/**
- * A hook to attach the custom fields when fetching a model instances.
- */
-export const enrichResults = (scopeAttributes: string[]) => async (
-  instancesOrInstance: any | any[],
-  options,
-): Promise<void> => {
-  if (
-    options.originalAttributes?.length > 0
-    && !options.originalAttributes?.includes?.('customFields')
-  ) {
-    logger.info('No custom fields needed, returning', { options });
-    return;
-  }
-
-  const primaryKey = 'id';
-  let instances = Array.isArray(instancesOrInstance)
-    ? instancesOrInstance
-    : [instancesOrInstance];
-
-  instances = instances.filter((instance) => !!instance);
-
-  const identifiers = instances.map((instance) =>
-    scopeAttributes
-      .map((attr) => instance[attr])).flat();
-
-  const uniqueIdentifiers = [...new Set(identifiers)].filter((identifier) => !!identifier);
-  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.customFields = customFields;
-    options.attributesToRemove?.forEach?.((attribute) => {
-      delete instance.dataValues?.[attribute];
-      // if raw:
-      delete instance?.[attribute];
-    });
-  });
-};

package/src/hooks/index.ts

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

package/src/hooks/update.ts

@@ -1,5 +1,4 @@
 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).
@@ -22,21 +21,9 @@ export const beforeUpdate = (scopeAttributes: string[]) => async (
   const modelType = instance.constructor.name;
   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,
@@ -46,7 +33,5 @@ export const beforeUpdate = (scopeAttributes: string[]) => async (
     );
     // 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/index.ts

@@ -27,13 +27,13 @@ const addHooks = (models: ModelOptions[], getModel: ModelFetcher) => {
       model.refreshAttributes();
       // TODO: Uncomment after tests are passed
       // model.addHook('afterFind', workaround);
-      model.addHook('beforeFind', beforeFind(scopeAttributes));
-      model.addHook('beforeBulkCreate', beforeBulkCreate);
-      model.addHook('beforeBulkUpdate', beforeBulkUpdate);
-      model.addHook('beforeCreate', beforeCreate(scopeAttributes));
-      model.addHook('beforeUpdate', beforeUpdate(scopeAttributes));
-      model.addHook('afterFind', enrichResults(scopeAttributes));
-      model.addHook('afterUpdate', enrichResults(scopeAttributes));
+      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(scopeAttributes));
+      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(scopeAttributes));
     } catch (e) {
       logger.error(`Could not add custom fields hook to model ${name}. `, e);
     }
@@ -49,18 +49,40 @@ const useCustomFields = async (
   getModel: ModelFetcher,
   options: CustomFieldOptions,
 ): Promise<void> => {
-  const { innerSequelize, models } = options;
-  // deepAfterFindWorkAround(sequelize);
+  const { models } = options;
   if (app) {
     app.use('/api', api);
   }
-  if (!innerSequelize) {
-    const moreInnerSequelize = initDB(options.databaseConfig);
-    await initTables(moreInnerSequelize);
-  } else {
-    await initTables(innerSequelize);
-  }
+  const sequelize = initDB(options.databaseConfig);
+  await initTables(sequelize, options.getUser);
   addHooks(models, getModel);
 };
 
 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,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -9,31 +10,32 @@ 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';
-
-/**
- * Supported custom field types
- */
-// eslint-disable-next-line no-shadow
-export enum CustomFieldDefinitionType {
-  NUMBER = 'number',
-  BOOLEAN = 'boolean',
-  DATE = 'date',
-  DATETIME = 'datetime',
-  TEXT = 'text',
-  IMAGE = 'image',
-  ENUM = 'enum',
-}
+import { UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } from '../errors';
 
 @DefaultScope(() => ({ where: { disabled: false } }))
 @Table({
   indexes: [
-  { name: "unique_name_model_type", fields: ["name", "model_type", "entity_id"], 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({
@@ -54,6 +56,11 @@ 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,

package/src/models/CustomFieldValue.ts

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -13,16 +14,18 @@ import {
   BeforeUpdate,
   BeforeBulkCreate,
   BeforeBulkUpdate,
+  Scopes,
 } from 'sequelize-typescript';
 import { sendDimEvent } from '../events';
 import { CustomFieldDefinition } from '.';
 import validateValue from '../utils/validations';
 import * as CustomFieldDefinitionRepo from '../repository/definition';
 import logger from '../utils/logger';
+import { InvalidValueError } from '../errors';
 
 @Table({
   timestamps: true,
-  })
+})
 class CustomFieldValue extends Model {
   @PrimaryKey
   @Column({
@@ -41,7 +44,7 @@ class CustomFieldValue extends Model {
 
   @Column({
     type: DataType.JSONB,
-    allowNull: false,
+    allowNull: true,
   })
   value!: any;
 
@@ -60,7 +63,6 @@ class CustomFieldValue extends Model {
   @BeforeBulkCreate
   @BeforeBulkUpdate
   static async validateValues(instances: CustomFieldValue[]): Promise<void> {
-    logger.info('CustomFieldValue BeforeBulkCreate/BeforeBulkUpdate', { instances });
     const ids = instances.map((instance) => instance.customFieldDefinitionId);
     const uniqueIds = [...new Set(ids)];
     const definitions = await CustomFieldDefinitionRepo.findByIds(
@@ -80,7 +82,7 @@ class CustomFieldValue extends Model {
         .find((definition) => definition.id === instance.customFieldDefinitionId);
       const isValid = validateValue(instance.value, fieldType, validation);
       if (!isValid) {
-        throw new Error('Invalid value');
+        throw new InvalidValueError(instance.value, fieldType);
       }
     });
   }
@@ -89,20 +91,18 @@ class CustomFieldValue extends Model {
   @BeforeCreate
   @BeforeUpsert
   static async validateValue(instance: CustomFieldValue): Promise<void> {
-    logger.info('CustomFieldValue BeforeCreate/BeforeUpdate', { instance });
     const { customFieldDefinitionId } = instance;
     // eslint-disable-next-line max-len
     const cfd = await CustomFieldDefinitionRepo.findById(customFieldDefinitionId, { withDisabled: true });
     const { validation, fieldType } = cfd;
     const isValid = validateValue(instance.value, fieldType, validation);
     if (!isValid) {
-      throw new Error('Invalid value');
+      throw new InvalidValueError(instance.value, fieldType);
     }
   }
 
   @AfterUpsert
   static afterSaveHandler(instance: CustomFieldValue, options): void {
-    logger.info('CustomFieldValue afterSave', { instance });
     if (options.transaction) {
       options.transaction.afterCommit(() => sendDimEvent(instance[0]));
     } else {

package/src/models/index.ts

@@ -1,27 +1,25 @@
 /* eslint-disable no-param-reassign */
 import type { Sequelize } from 'sequelize-typescript';
 import logger from '../utils/logger';
-// import addPermanentHooks from '../hooks/permanent-hooks';
-
 import CustomFieldDefinition from './CustomFieldDefinition';
 import CustomFieldValue from './CustomFieldValue';
 import TestModel from './tests/TestModel';
 import AssociatedTestModel from './tests/AssociatedTestModel';
 
-// export const CustomFieldDefinition = CustomFieldDefinitionModel;
-// export { default as CustomFieldDefinition } from './custom-field-definition.model';
-
 const productionModels = [CustomFieldDefinition, CustomFieldValue];
 const testModels = [...productionModels, TestModel, AssociatedTestModel];
 
-const initTables = async (sequelize: Sequelize): Promise<void> => {
+const initTables = async (sequelize: Sequelize, getUser): Promise<void> => {
   logger.info('custom-fields: initialize custom-fields tables');
   // Detect models and import them to the orm
   // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
   if (!sequelize.addModels) {
     throw new Error('sequelize instance must have addModels function');
   }
-  sequelize.addModels(process.env.NODE_ENV === 'test' ? testModels : productionModels);
+
+  const models = process.env.NODE_ENV === 'test' ? testModels : productionModels;
+
+  sequelize.addModels(models);
   await sequelize.dropSchema('custom-fields', { logging: false });
   await sequelize.createSchema('custom-fields', { logging: false });
 
@@ -34,6 +32,22 @@ const initTables = async (sequelize: Sequelize): Promise<void> => {
     await AssociatedTestModel.sync({ alter: true });
   }
   logger.info('custom-fields: models synced');
+
+  CustomFieldDefinition.addScope('userScope', () => {
+    const user = getUser();
+    if (user?.permissions) {
+      return {
+        where: {
+          entityId: [
+            ...Object.keys(user.permissions.fleets),
+            ...Object.keys(user.permissions.businessModels),
+            ...Object.keys(user.permissions.demandSources),
+          ],
+        },
+      };
+    }
+    return {};
+  });
 };
 
 export {