@autofleet/sadot 0.5.5-beta.8 → 0.6.0

package/dist/utils/init.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
+exports.applyCustomAssociation = exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
 const sequelize_1 = require("sequelize");
 const common_types_1 = require("@autofleet/common-types");
 const models_1 = require("../models");
@@ -12,7 +12,7 @@ const scopes_1 = require("../scopes");
 const logger_1 = __importDefault(require("./logger"));
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
 const addHooks = (models, getModel) => {
-    models.forEach(async ({ name, scopeAttributes }) => {
+    models.forEach(async ({ name, scopeAttributes, modelOptions, }) => {
         try {
             const model = getModel(name);
             if (!model) {
@@ -31,11 +31,11 @@ const addHooks = (models, getModel) => {
             model.addHook('beforeFind', 'sadot-beforeFind', (0, hooks_1.beforeFind)(scopeAttributes));
             model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', hooks_1.beforeBulkCreate);
             model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', hooks_1.beforeBulkUpdate);
-            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes));
-            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes));
-            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes, 'afterFind'));
-            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes));
-            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes));
+            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes, modelOptions));
+            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes, modelOptions));
+            model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes, 'afterFind', modelOptions));
+            model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
+            model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
         }
         catch (e) {
             logger_1.default.error(`Could not add custom fields hook to model ${name}. `, e);
@@ -98,3 +98,9 @@ const addScopes = (models, getModel) => {
     });
 };
 exports.addScopes = addScopes;
+const applyCustomAssociation = (models) => {
+    models.forEach(({ modelOptions }) => {
+        modelOptions?.customAssociation?.(models_1.CustomFieldDefinition);
+    });
+};
+exports.applyCustomAssociation = applyCustomAssociation;

package/dist/utils/scopeAttributes.d.ts

@@ -0,0 +1,2 @@
+declare const applyScopeToInstance: (instance: any, scopeAttributes: string[]) => any[];
+export default applyScopeToInstance;

package/dist/utils/scopeAttributes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mapAttributeToInstance = (scopeAttributes, instance) => scopeAttributes.map((attr) => instance[attr]);
+const applyScopeToInstance = (instance, scopeAttributes) => {
+    const uniqueAttributes = Array.from(new Set(scopeAttributes));
+    if (Array.isArray(instance)) {
+        return instance.flatMap((ins) => mapAttributeToInstance(uniqueAttributes, ins));
+    }
+    return mapAttributeToInstance(uniqueAttributes, instance);
+};
+exports.default = applyScopeToInstance;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.5.5-beta.8",
+  "version": "0.6.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -9,7 +9,24 @@
     "linter": "./node_modules/.bin/eslint .",
     "test": "jest --forceExit --runInBand",
     "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
-    "dev": "nodemon"
+    "build-to-local-repo": "npm run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
+    "dev": "nodemon",
+    "watch": "npm-watch build-to-local-repo"
+  },
+  "watch": {
+    "build-to-local-repo": {
+      "extensions": [
+        "js",
+        "jsx",
+        "ts",
+        "tsx",
+        "css"
+      ],
+      "patterns": [
+        "src"
+      ],
+      "quiet": false
+    }
   },
   "dependencies": {
     "@autofleet/common-types": "^1.7.29",
@@ -34,6 +51,7 @@
     "eslint-config-airbnb-typescript": "^12.0.0",
     "eslint-plugin-import": "^2.22.1",
     "jest": "^27.0.5",
+    "npm-watch": "^0.11.0",
     "ts-jest": "^27.0.3",
     "ts-node": "^8.6.2",
     "typescript": "^4.9.5",

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

@@ -65,10 +65,8 @@ router.get('/', async (req, res) => {
     if (entityIds?.length > 0) {
       where.entityId = entityIds;
     }
-    const customFieldDefinitions = await DefinitionRepo.findAll(
-      { ...where },
-      { withDisabled: true },
-    );
+    const customFieldDefinitions = await DefinitionRepo.findAll({ ...where },
+      { withDisabled: true });
     return res.json(customFieldDefinitions);
   } catch (err) {
     logger.error('Failed to fetch custom field definitions', err);

package/src/hooks/create.ts

@@ -2,6 +2,8 @@ import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
 import { MissingRequiredCustomFieldError } from '../errors';
+import { ModelOptions } from '../types';
+import applyScopeToInstance from '../utils/scopeAttributes';
 
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
@@ -15,18 +17,20 @@ export const beforeBulkCreate = (options): void => {
  * A hook to create the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export const beforeCreate = (scopeAttributes: string[]) => async (
+export const beforeCreate = (scopeAttributes: string[], modelOptions: ModelOptions = {}) => 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 = applyScopeToInstance(instance, scopeAttributes);
+
   // get all model's required definitions
   const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType,
-    instance.id,
-    identifiers);
+    instance.id, identifiers, modelOptions);
+
   const customFieldsIdx = fields.indexOf('customFields');
   const { customFields } = instance;
   if (customFieldsIdx > -1 && customFields) {
@@ -41,8 +45,12 @@ export const beforeCreate = (scopeAttributes: string[]) => async (
       instance.id,
       identifiers,
       customFields,
-      { transaction: options.transaction },
+      {
+        transaction: options.transaction,
+        modelOptions,
+      },
     );
+
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);
   } else if (requiredFieldsNames?.length > 0) {

package/src/hooks/enrich.ts

@@ -4,6 +4,8 @@ import * as DefinitionRepo from '../repository/definition';
 import CustomFieldValue from '../models/CustomFieldValue';
 import CustomFieldDefinition from '../models/CustomFieldDefinition';
 import { SerializedCustomFields } from '../types/definition';
+import { ModelOptions } from '../types';
+import applyScopeToInstance from '../utils/scopeAttributes';
 
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
 
@@ -30,6 +32,7 @@ const enrichResults = (
   modelType: string,
   scopeAttributes: string[],
   hookType?: SupportedHookTypes,
+  modelOptions: ModelOptions = {},
 ) => async (
   instancesOrInstance: any | any[],
   options,
@@ -48,21 +51,33 @@ const enrichResults = (
 
   instances = instances.filter(Boolean);
 
-  const identifiers = instances.map((instance) =>
-    scopeAttributes
-      .map((attr) => instance[attr])).flat();
+  const identifiers = applyScopeToInstance(instances, scopeAttributes);
 
   const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
+
   const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
     ...map,
     [identifier]: [],
+
   }), {});
+
   const customFieldDefinitions = await DefinitionRepo.findByEntityIds(
     modelType,
     uniqueIdentifiers,
-    { transaction: options.transaction },
+    { transaction: options.transaction, modelOptions },
   );
 
+  if (modelOptions?.include && modelOptions.useEntityIdFromInclude) {
+    // if we pass useEntityIdFromInclude,
+    //  map the entity from the options to the identifierCustomFieldDefinitionsMapping
+    modelOptions.include(identifiers).forEach(({ model }) => {
+      customFieldDefinitions.forEach((cfd) => {
+        const entityId = cfd[`${model.name}.entityId`];
+        identifierCustomFieldDefinitionsMapping[entityId] = [];
+      });
+    });
+  }
+
   const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({
     ...map,
     [definition.id]: definition,
@@ -104,6 +119,7 @@ const enrichResults = (
 
     scopeAttributes.forEach((attribute) => {
       const identifier = instance[attribute];
+
       const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];
       if (entityCustomFieldDefinitions?.length > 0) {
         entityCustomFieldDefinitions.forEach((customFieldDefinition) => {

package/src/hooks/update.ts

@@ -1,5 +1,7 @@
 import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
+import { ModelOptions } from '../types';
+import applyScopeToInstance from '../utils/scopeAttributes';
 
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
@@ -14,14 +16,14 @@ export const beforeBulkUpdate = (options): void => {
  * A hook to update the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export const beforeUpdate = (scopeAttributes: string[]) => async (
+export const beforeUpdate = (scopeAttributes: string[], modelOptions: ModelOptions = {}) => 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 = applyScopeToInstance(instance, scopeAttributes);
 
   const customFieldsIdx = fields.indexOf('customFields');
   if (customFieldsIdx > -1) {
@@ -31,7 +33,8 @@ export const beforeUpdate = (scopeAttributes: string[]) => async (
       instance.id,
       identifiers,
       customFields,
-      { transaction: options.transaction },
+      { transaction: options.transaction, modelOptions },
+
     );
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);

package/src/index.ts

@@ -7,13 +7,14 @@ import api from './api';
 import initDB from './utils/db';
 import logger from './utils/logger';
 import type { CustomFieldOptions, ModelFetcher } from './types';
-import { addHooks, addScopes, removeHooks } from './utils/init';
+import {
+  addHooks, addScopes, applyCustomAssociation, removeHooks,
+} from './utils/init';
 
 export * from './utils/validations/custom-fields';
 
 export * from './utils/constants';
 
-export * from './utils/helpers';
 /**
  * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
  * @see {@link 'custom-fields/config'} for configurations
@@ -35,6 +36,7 @@ const useCustomFields = async (
   addHooks(models, getModel);
   await initTables(sequelize, options.getUser);
   addScopes(models, getModel);
+  applyCustomAssociation(models);
   logger.debug('sadot - custom fields finished initializing with models', models);
   return sequelize;
 };

package/src/models/index.ts

@@ -5,10 +5,12 @@ import logger from '../utils/logger';
 import CustomFieldDefinition from './CustomFieldDefinition';
 import CustomFieldValue from './CustomFieldValue';
 import TestModel from './tests/TestModel';
+import ContextAwareTestModel from './tests/contextAwareModels/ContextAwareTestModel';
+import ContextTestModel from './tests/contextAwareModels/ContextTestModel';
 import AssociatedTestModel from './tests/AssociatedTestModel';
 
 const productionModels = [CustomFieldDefinition, CustomFieldValue];
-const testModels = [TestModel, AssociatedTestModel];
+const testModels = [TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel];
 
 const SADOT_MIGRATION_PREFIX = 'sadot-migration';
 const SCHEMA_VERSION = 1;
@@ -88,6 +90,8 @@ const initTestModels = async (sequelize: Sequelize): Promise<void> => {
   logger.info('custom-fields: test models added');
   await TestModel.sync({ alter: true });
   await AssociatedTestModel.sync({ alter: true });
+  await ContextTestModel.sync({ alter: true });
+  await ContextAwareTestModel.sync({ alter: true });
   logger.info('custom-fields: test models synced');
 };
 
@@ -96,6 +100,8 @@ export {
   CustomFieldDefinition,
   TestModel,
   AssociatedTestModel,
+  ContextAwareTestModel,
+  ContextTestModel,
   initTables,
   initTestModels,
 };

package/src/models/tests/contextAwareModels/ContextAwareTestModel.ts

@@ -0,0 +1,45 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  HasMany,
+  BelongsTo,
+  ForeignKey,
+} from 'sequelize-typescript';
+import AssociatedTestModel from '../AssociatedTestModel';
+import ContextTestModel from './ContextTestModel';
+
+@Table({ createdAt: false, updatedAt: false })
+class ContextAwareTestModel extends Model {
+    @PrimaryKey
+    @Column({
+      type: DataType.UUID,
+      defaultValue: DataType.UUIDV4,
+      allowNull: false,
+    })
+    id!: string;
+
+  @ForeignKey(() => ContextTestModel)
+    @Column({
+      type: DataType.UUID,
+    })
+      contextId: string;
+
+    @Column({
+      type: DataType.BOOLEAN,
+    })
+    coolAttribute?: boolean;
+
+    @Column({
+      type: DataType.VIRTUAL,
+    })
+    customFields?: any;
+
+  @BelongsTo(() => ContextTestModel)
+  context: ContextTestModel;
+}
+
+export default ContextAwareTestModel;

package/src/models/tests/contextAwareModels/ContextTestModel.ts

@@ -0,0 +1,38 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+} from 'sequelize-typescript';
+
+// eslint-disable-next-line no-shadow
+ enum EEntityTypes {
+  BUSINESS_MODEL = 'businessModel',
+  CONTEXT = 'context',
+  DEMAND_SOURCE = 'demandSource',
+  FLEET = 'fleet',
+}
+
+@Table({ createdAt: false, updatedAt: false })
+class ContextTestModel extends Model {
+  @PrimaryKey
+  @Column({
+    defaultValue: DataType.UUIDV4,
+    type: DataType.UUID,
+  })
+    id: string;
+
+  @Column({
+    type: DataType.UUID,
+  })
+    entityId: string;
+
+  @Column({
+    type: DataType.ENUM(...Object.values(EEntityTypes)),
+  })
+    entityType: EEntityTypes;
+}
+
+export default ContextTestModel;

package/src/repository/definition.ts

@@ -1,21 +1,27 @@
-import { Op, WhereOptions } from 'sequelize';
+import {
+  FindOptions,
+  Op, WhereOptions,
+} from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
+import { ModelOptions } from '../types';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
 
 export const findAll = (
-  where: any,
+  where: WhereOptions,
   options: any = { withDisabled: false },
 ): Promise<CustomFieldDefinition[]> => {
   const queryModel = options.withDisabled
     ? CustomFieldDefinition.unscoped()
     : CustomFieldDefinition;
+
   return queryModel.scope('userScope').findAll({
     where,
     transaction: options.transaction,
     raw: true,
+    include: options.include,
   });
 };
 
@@ -35,26 +41,26 @@ export const findById = (
   return CustomFieldDefinition.scope('userScope').findByPk(id);
 };
 
-export const findByEntityId = async (
-  entityId: string,
-  options: any = {},
-): Promise<CustomFieldDefinition[]> => CustomFieldDefinition.findAll({
-  where: { entityId },
-  transaction: options.transaction,
-});
-
 export const findByEntityIds = async (
   modelType: string,
   entityIds: string[],
-  options: any = {},
-): Promise<CustomFieldDefinition[]> => CustomFieldDefinition.findAll({
-  where: {
+  options: FindOptions & { modelOptions?: ModelOptions } = {},
+): Promise<CustomFieldDefinition[]> => {
+  const { include, useEntityIdFromInclude } = options.modelOptions;
+  const where: WhereOptions = {
     modelType,
-    entityId: entityIds,
-  },
-  transaction: options.transaction,
-  raw: true,
-});
+  };
+
+  if (!useEntityIdFromInclude) {
+    where.entityId = entityIds;
+  }
+  return CustomFieldDefinition.findAll({
+    where,
+    transaction: options.transaction,
+    include: include?.(entityIds),
+    raw: true,
+  });
+};
 
 export const findByWhere = (where): Promise<CustomFieldDefinition | null> =>
   CustomFieldDefinition.scope('userScope').findOne({
@@ -100,10 +106,23 @@ export const getRequiredFields = async (
   modelType: string,
   modelId: string | string[],
   entityId: string | string[],
+  modelOptions: ModelOptions = {},
 ): Promise<string[]> => {
   const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+  const { include, useEntityIdFromInclude } = modelOptions;
+
+  const where: WhereOptions = {
+    modelType,
+    required: true,
+  };
+
+  if (!useEntityIdFromInclude) {
+    where.entityId = entityIds;
+  }
+
   const requiredFields = await CustomFieldDefinition.findAll({
-    where: { required: true, modelType, entityId: { [Op.in]: entityIds } },
+    where,
+    include: include?.(entityIds),
     logging: true,
   });
   const requiredFieldsNames = requiredFields.map((definition) => definition.name);

package/src/repository/value.ts

@@ -1,9 +1,11 @@
 /* eslint-disable max-len */
+import type { FindOptions, WhereOptions } from 'sequelize';
 import { CustomFieldValue, CustomFieldDefinition } from '../models';
 import * as DefinitionRepo from './definition';
 import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
 import logger from '../utils/logger';
 import { MissingDefinitionError } from '../errors';
+import { ModelOptions } from '../types';
 
 export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
   CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });
@@ -50,18 +52,27 @@ export const updateValues = async (
   modelId: string,
   identifiers: string[],
   valuesToUpdate: ValuesToUpdate,
-  options: any = {},
+  options: FindOptions & { modelOptions?: ModelOptions } = {},
 ): Promise<CustomFieldValue[]> => {
-  logger.info(`custom-fields: updating values for ${modelType} ${modelId}`, { valuesToUpdate });
-
   const names = Object.keys(valuesToUpdate);
-  const fieldDefinitions = await DefinitionRepo.findAll(
-    { modelType, name: names, entityId: identifiers },
-    { withDisabled: true, transaction: options.transaction },
-  ) || [];
+  logger.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
+    names, options, valuesToUpdate, identifiers,
+  });
+  const { modelOptions, transaction } = options;
+
+  const where: WhereOptions = {
+    modelType,
+    name: names,
+  };
+
+  if (!options.modelOptions?.useEntityIdFromInclude) {
+    where.entityId = identifiers;
+  }
+  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) || [];
 
   const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
   if (fieldDefinitions.length !== names.length) {
+    logger.info(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
     const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
     throw new MissingDefinitionError(missingDefinitions);
   }

package/src/tests/helpers/database-config.ts

@@ -4,6 +4,7 @@ export default {
     password: process.env.DB_PASSWORD || null,
     database: process.env.DB_NAME || 'sadot_package_test',
     host: process.env.DB_HOST || '127.0.0.1',
+    port: process.env.DB_PORT || 5432,
     dialect: process.env.DB_TYPE || 'postgres',
     define: {
       underscored: true,

package/src/tests/helpers/index.ts

@@ -1,10 +1,14 @@
-import { CustomFieldDefinition, TestModel } from '../../models';
+import {
+  ContextAwareTestModel, ContextTestModel, CustomFieldDefinition, TestModel,
+} from '../../models';
 
 // eslint-disable-next-line import/prefer-default-export
 export const cleanup = async (): Promise<void> => {
   if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
     await CustomFieldDefinition.unscoped().destroy({ where: {} });
     await TestModel.destroy({ where: {} });
+    await ContextAwareTestModel.destroy({ where: {} });
+    await ContextTestModel.destroy({ where: {} });
   }
 };
 

package/src/tests/mocks/definition.mock.ts

@@ -1,6 +1,13 @@
 import { v4 as uuidv4 } from 'uuid';
 import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
 
+export const contextAwareFieldDefinition = {
+  name: 'cool field',
+  modelType: 'ContextAwareTestModel',
+  fieldType: 'number',
+  entityType: 'fleetId',
+};
+
 export const coolFieldDefinition: CreateCustomFieldDefinition = {
   name: 'cool field',
   modelType: 'TestModel',

package/src/types/index.ts

@@ -1,15 +1,35 @@
+import { IncludeOptions } from 'sequelize';
+import { ModelCtor } from 'sequelize-typescript';
+
 export type ModelFetcher = (name: string) => any;
 
 export type ModelOptions = {
+  /**
+   * Include options for the model
+   */
+  include?: (entityIds: string[]) => IncludeOptions[];
+  /**
+    * Custom association for the model
+    * @param model - The model to associate with
+   */
+
+  customAssociation?: (model: ModelCtor) => void;
+  /**
+   * Whether to use the entity id  from the instance per scope attribute
+   */
+  useEntityIdFromInclude?: boolean
+}
+export type Models = {
   name: string;
-  scopeAttributes: string[];
+  scopeAttributes: any[];
+  modelOptions?: ModelOptions;
   creationWebhookHandler?: (instance: any) => any;
   updateWebhookHandler?: (instance: any) => any;
   deletionWebhookHandler?: (instance: any) => any;
 }
 
-export type CustomFieldOptions= {
-  models: ModelOptions[];
+export type CustomFieldOptions = {
+  models: Models[];
   databaseConfig: any;
   getUser: () => any;
 };