@autofleet/sadot 1.0.0-beta.1 → 1.0.0

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

@@ -1,13 +1,13 @@
 import { ResourceNotFoundError } from '@autofleet/errors';
-import { Router } from 'express';
-import type { Request, Response } from 'express';
+import { Router } from '@autofleet/node-common';
 import handleError from '../errors';
 import * as DefinitionRepo from '../../../repository/definition';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../../../types/definition';
 import { validateCustomFieldDefinitionCreation, validateCustomFieldDefinitionUpdate } from './validations';
 import logger from '../../../utils/logger';
+import type { CustomFieldDefinition } from '../../../models';
 
-const router = Router({ mergeParams: true });
+const router = Router({ logger });
 const ENTITY = 'CustomFieldDefinition';
 
 const toPascalCase = (str: string): string => str.replace(/(^\w|-\w)/g, (subStr) => subStr.replace(/-/, '').toUpperCase());
@@ -15,12 +15,11 @@ const toPascalCase = (str: string): string => str.replace(/(^\w|-\w)/g, (subStr)
 /**
  * Create
  */
-router.post('/', async (req: Request, res: Response) => {
-  const { modelName } = req.params as any;
+router.post<{ modelName: string; }>('/', async (req, res) => {
+  const { modelName } = req.params;
   const modelType = toPascalCase(modelName);
   try {
-    const validatedPayload: CreateCustomFieldDefinition = await
-    validateCustomFieldDefinitionCreation(req.body);
+    const validatedPayload: CreateCustomFieldDefinition = await validateCustomFieldDefinitionCreation(req.body);
 
     const customFieldDefinition = await DefinitionRepo.create({
       ...validatedPayload,
@@ -29,14 +28,14 @@ router.post('/', async (req: Request, res: Response) => {
     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` });
+    return handleError(err, res, { logger, message: `Error in create ${ENTITY} request` });
   }
 });
 
 /**
  * Get by id
  */
-router.get('/:customFieldDefinitionId', async (req, res) => {
+router.get<{ modelName: string; customFieldDefinitionId: string; }, CustomFieldDefinition>('/:customFieldDefinitionId', async (req, res) => {
   const { customFieldDefinitionId } = req.params;
   try {
     const customFieldDefinition = await DefinitionRepo.findById(customFieldDefinitionId);
@@ -48,39 +47,37 @@ router.get('/:customFieldDefinitionId', async (req, res) => {
     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` });
+    return handleError(err, res, { logger, 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;
+router.get<{ modelName: string; }, CustomFieldDefinition[], never, { entityIds?: string[]; }>('/', async (req, res) => {
+  const { params: { modelName }, query: { entityIds } } = req;
 
   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 where = {
+      modelType,
+      ...(entityIds?.length > 0 && { 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` });
+    return handleError(err, res, { logger, message: `Error in get all ${ENTITY} request` });
   }
 });
 
 /**
  * Update
  */
-router.patch('/:customFieldDefinitionId', async (req, res) => {
-  const { customFieldDefinitionId, modelName } = req.params as any;
+router.patch<{ modelName: string; customFieldDefinitionId: string; }, CustomFieldDefinition>('/:customFieldDefinitionId', async (req, res) => {
+  const { customFieldDefinitionId, modelName } = req.params;
   const modelType = toPascalCase(modelName);
   try {
-    // eslint-disable-next-line max-len
     const validatedPayload: UpdateCustomFieldDefinition = await validateCustomFieldDefinitionUpdate(req.body);
 
     const customFieldDefinition = await DefinitionRepo.findByWhere({
@@ -100,7 +97,7 @@ router.patch('/:customFieldDefinitionId', async (req, res) => {
     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` });
+    return handleError(err, res, { logger, message: `Error in update ${ENTITY} request` });
   }
 });
 

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

@@ -1,3 +1,4 @@
+/* eslint-disable newline-per-chained-call */
 import Joi from 'joi';
 import { CustomFieldDefinitionType } from '../../../utils/constants';
 
@@ -11,7 +12,6 @@ const statusValidationObject = Joi.object({
   value: Joi.string().required(),
   color: Joi.string().required(),
 });
-const statusValidationObjectSchema = Joi.array().items(statusValidationObject).min(1).unique('value');
 /**
  * Schema for the validation of custom field definition
  * The only custom validation is for
@@ -23,12 +23,12 @@ const statusValidationObjectSchema = Joi.array().items(statusValidationObject).m
  */
 const ValidationSchema = Joi.when('fieldType', {
   is: CustomFieldDefinitionType.SELECT,
-  then: Joi.array().items(Joi.string()).min(1).unique(),
-  otherwise: Joi.any(),
-}).when('fieldType', {
-  is: CustomFieldDefinitionType.STATUS,
-  then: statusValidationObjectSchema,
-  otherwise: Joi.any(),
+  then: Joi.array().required().items(Joi.string()).min(1).unique(),
+  otherwise: Joi.when('fieldType', {
+    is: CustomFieldDefinitionType.STATUS,
+    then: Joi.array().required().items(statusValidationObject).min(1).unique('value'),
+    otherwise: Joi.forbidden(),
+  }),
 });
 
 const DefaultValueSchema = Joi.when('fieldType', {
@@ -36,11 +36,11 @@ const DefaultValueSchema = Joi.when('fieldType', {
     { is: CustomFieldDefinitionType.BOOLEAN, then: Joi.boolean().allow(null) },
     { is: CustomFieldDefinitionType.DATE, then: Joi.date().allow(null) },
     { is: CustomFieldDefinitionType.DATETIME, then: Joi.date().allow(null) },
-    { is: CustomFieldDefinitionType.FILE, then: FileValidationSchema },
-    { is: CustomFieldDefinitionType.IMAGE, then: Joi.string().uri().allow(null) },
+    { is: CustomFieldDefinitionType.FILE, then: Joi.array().items(FileValidationSchema).allow(null) },
+    { is: CustomFieldDefinitionType.IMAGE, then: Joi.array().items(Joi.string().uri()).allow(null) },
     { is: CustomFieldDefinitionType.NUMBER, then: Joi.number().allow(null) },
     { is: CustomFieldDefinitionType.SELECT, then: Joi.string().allow(null) },
-    { is: CustomFieldDefinitionType.STATUS, then: statusValidationObject.allow(null) },
+    { is: CustomFieldDefinitionType.STATUS, then: Joi.string().allow(null) },
     { is: CustomFieldDefinitionType.TEXT, then: Joi.string().allow(null) },
   ],
 });
@@ -56,7 +56,8 @@ const CustomFieldDefinitionCreationSchema = Joi.object({
   description: Joi.string(),
   required: Joi.boolean(),
   disabled: Joi.boolean(),
-});
+  blockEditingFromUI: Joi.boolean(),
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
 
 const CustomFieldDefinitionUpdateSchema = Joi.object({
   displayName: Joi.string(),
@@ -66,10 +67,9 @@ const CustomFieldDefinitionUpdateSchema = Joi.object({
   description: Joi.string().allow(null),
   required: Joi.boolean(),
   disabled: Joi.boolean(),
-});
+  blockEditingFromUI: Joi.boolean(),
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
 
-export const validateCustomFieldDefinitionCreation = (payload) =>
-  CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
+export const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
 
-export const validateCustomFieldDefinitionUpdate = (payload) =>
-  CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });
+export const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });

package/src/api/v1/errors.ts

@@ -1,14 +1,11 @@
-import { handleError, BadRequest } from '@autofleet/errors';
+import type { Response } from 'express';
+import { handleError, BadRequest, type LogPayload } from '@autofleet/errors';
 import { ValidationError as InputValidationError } from 'joi';
 import { ValidationError as DatabaseValidationError } from 'sequelize';
 
-export default (err, res, additionalData = undefined) => {
+export default (err, res: Response, additionalData: LogPayload = undefined) => {
   let error = err;
-  if (err instanceof InputValidationError) {
-    error = new BadRequest([err], null);
-  }
-
-  if (err instanceof DatabaseValidationError) {
+  if ([InputValidationError, DatabaseValidationError].some((ErrClass) => err instanceof ErrClass)) {
     error = new BadRequest([err], null);
   }
 

package/src/api/v1/index.ts

@@ -1,9 +1,11 @@
-import { Router } from 'express';
-
+import { Router } from '@autofleet/node-common';
+import logger from '../../utils/logger';
 import definitionRouter from './definition';
+import validatorRouter from './validator';
 
-const router = Router({ mergeParams: true });
+const router = Router({ logger });
 
 router.use('/custom-field-definitions/:modelName', definitionRouter);
+router.use('/custom-validators/:modelName', validatorRouter);
 
 export default router;

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

@@ -0,0 +1,141 @@
+import { ResourceNotFoundError } from '@autofleet/errors';
+import { Router } from '@autofleet/node-common';
+import { StatusCodes } from 'http-status-codes';
+import handleError from '../errors';
+import * as ValidatorRepo from '../../../repository/validator';
+import validations from './validations';
+import logger from '../../../utils/logger';
+import { validateValidatorSchema } from '../../../utils/validations/schema/validator-schema';
+import type { CustomValidator } from '../../../models';
+
+const router = Router({ logger });
+const ENTITY = 'CustomValidator';
+
+/**
+ * Create
+ */
+router.post<{ modelName: string }>('/', async (req, res) => {
+  const { modelName } = req.params;
+  try {
+    // Validate the request body
+    const validatedPayload = await validations.create.validateAsync(req.body);
+
+    // Validate that the schema is a valid AJV schema
+    validateValidatorSchema(validatedPayload.schema);
+
+    const validator = await ValidatorRepo.create({
+      ...validatedPayload,
+      modelType: modelName,
+    });
+
+    return res.status(StatusCodes.CREATED).json(validator);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in create ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get all
+ */
+router.get<
+  { modelName: string },
+  { validators: CustomValidator[] },
+  never,
+  { entityId?: string; entityType?: string }
+>('/', async (req, res) => {
+  try {
+    const { modelName } = req.params;
+    const { entityId, entityType } = req.query;
+
+    const where = {
+      modelType: modelName,
+      ...(entityId && { entityId }),
+      ...(entityType && { entityType }),
+    };
+
+    const validators = await ValidatorRepo.findAll(where);
+
+    return res.status(StatusCodes.OK).json({ validators });
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in get all ${ENTITY} request` });
+  }
+});
+
+/**
+ * Get by id
+ */
+router.get<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId, modelName } = req.params;
+    // Include disabled validators when fetching by ID
+    const validators = await ValidatorRepo.findAll({ id: validatorId, modelType: modelName }, { withDisabled: true });
+
+    if (!validators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    return res.status(StatusCodes.OK).json(validators[0]);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in get ${ENTITY} request` });
+  }
+});
+
+/**
+ * Update
+ */
+router.patch<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId } = req.params;
+
+    // Validate the request body
+    const validatedPayload = await validations.update.validateAsync(req.body);
+
+    // If schema is included in the update, validate that it's a valid AJV schema
+    if (validatedPayload.schema) {
+      validateValidatorSchema(validatedPayload.schema);
+    }
+
+    // First verify the validator exists, including disabled ones
+    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+    if (!existingValidators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
+
+    if (!count) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    return res.status(StatusCodes.OK).json(validators[0]);
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in update ${ENTITY} request` });
+  }
+});
+
+/**
+ * Delete (disable)
+ */
+router.delete<{ modelName: string; validatorId: string }>('/:validatorId', async (req, res) => {
+  try {
+    const { validatorId } = req.params;
+
+    // First verify the validator exists, including disabled ones
+    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+    if (!existingValidators.length) {
+      throw new ResourceNotFoundError('Validator not found');
+    }
+
+    const [count] = await ValidatorRepo.disable(validatorId);
+
+    if (!count) {
+      throw new ResourceNotFoundError('Validator failed to be disabled');
+    }
+
+    return res.status(StatusCodes.NO_CONTENT).send();
+  } catch (err) {
+    return handleError(err, res, { logger, message: `Error in delete ${ENTITY} request` });
+  }
+});
+
+export default router;

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

@@ -0,0 +1,39 @@
+import Joi from 'joi';
+
+// Schema for validating JSON Schema objects
+const jsonSchemaValidation = Joi.object().unknown(true);
+
+const validationSchemas = {
+  create: Joi.object({
+    entityId: Joi.string().uuid().required(),
+    entityType: Joi.string().required(),
+    schema: Joi.object({
+      type: Joi.string().valid('object').required(),
+      properties: Joi.object({
+        before: jsonSchemaValidation,
+        after: jsonSchemaValidation,
+      }).required(),
+      if: Joi.object().optional(),
+      then: Joi.object().optional(),
+      else: Joi.object().optional(),
+    }).required(),
+  }),
+
+  update: Joi.object({
+    entityId: Joi.string().uuid(),
+    entityType: Joi.string(),
+    schema: Joi.object({
+      type: Joi.string().valid('object'),
+      properties: Joi.object({
+        before: jsonSchemaValidation,
+        after: jsonSchemaValidation,
+      }),
+      if: Joi.object().optional(),
+      then: Joi.object().optional(),
+      else: Joi.object().optional(),
+    }),
+    disabled: Joi.boolean(),
+  }).min(1),
+};
+
+export default validationSchemas;

package/src/errors/index.ts

@@ -1,5 +1,7 @@
 /* eslint-disable max-classes-per-file */
 import { BadRequest } from '@autofleet/errors';
+import type { ValidationError } from 'joi';
+import type { EntriesValidationError } from '../types/entries';
 
 export class MissingRequiredCustomFieldError extends BadRequest {
   constructor(missingFields: string[]) {
@@ -25,11 +27,37 @@ export class UnsupportedCustomValidationError extends BadRequest {
   }
 }
 
+export class InvalidFieldTypeError extends BadRequest {
+  constructor(fieldType: string) {
+    const err = new Error(`Invalid field type ${fieldType}`);
+    super([err], null, null);
+    this.message = 'INVALID_FIELD_TYPE';
+  }
+}
+
 export class InvalidValueError extends BadRequest {
-  constructor(value: any, fieldType: string) {
-    const err = new Error(`Invalid "${fieldType}" value ${JSON.stringify(value)}`);
+  constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError) {
+    const formattedErrorMessage = joiValidationError.message
+      .replace(/"/g, '')
+      .replace('value', `'${fieldDefinitionName}'`);
+
+    const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
+
+    const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
+
+    const err = new Error(invalidValueMessage);
     super([err], null, null);
-    this.message = 'INVALID_VALUE';
+    this.message = invalidValueMessage;
+  }
+}
+
+export class InvalidEntriesError extends BadRequest {
+  constructor(modelId: string, validationErrors: EntriesValidationError[]) {
+    const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
+    super(errors, null, null);
+    this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (
+      `${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`
+    )).join('\n')}`;
   }
 }
 

package/src/events/index.ts

@@ -1,21 +1,29 @@
 import Events from '@autofleet/events';
+import { getUser } from '@autofleet/zehut';
 import logger from '../utils/logger';
+import type {
+  CustomFieldDefinition,
+  CustomFieldEntries,
+  CustomFieldValue,
+  CustomValidator,
+} from '../models';
 
-const events = new Events({ logger });
+const events = new Events({
+  logger,
+  getUserId: (payload) => payload?.user_id ?? getUser()?.id ?? null,
+});
 
-const KEYS_TO_CONVERT = ['value', 'defaultValue'];
+const KEYS_TO_CONVERT = ['value', 'defaultValue', 'blockEditingFromUI'];
 
-const stringifyBooleans = (savedObject: any, keysToConvert: Array<string>) => {
-  if (!Object.keys(savedObject).some((key) => keysToConvert.includes(key))) {
+const stringifyBooleans = (savedObject: any, keysToConvert: string[]) => {
+  const savedObjectKeySet = new Set(Object.keys(savedObject));
+  if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) {
     return savedObject;
   }
-  const objectToReturn = { ...savedObject };
-  keysToConvert.forEach((key) => {
-    if (typeof savedObject[key] === 'boolean') {
-      objectToReturn[key] = savedObject[key].toString();
-    }
-  });
-  return objectToReturn;
+  return {
+    ...savedObject,
+    ...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === 'boolean' ? savedObject[key].toString() : savedObject[key]])),
+  };
 };
 
 const modelTableMapping = {
@@ -27,9 +35,13 @@ const modelTableMapping = {
     tableName: 'dim_custom_field_value',
     eventVersion: '1',
   },
+  CustomFieldEntries: {
+    tableName: 'dim_custom_field_entries',
+    eventVersion: '1',
+  },
 };
 
-export const sendDimEvent = (instance): void => {
+export const sendDimEvent = (instance: CustomFieldDefinition | CustomFieldValue | CustomFieldEntries | CustomValidator): void => {
   const mapping = modelTableMapping[instance.constructor.name];
   if (!mapping) {
     return;
@@ -45,7 +57,7 @@ export const sendDimEvent = (instance): void => {
     mapping.tableName,
     mapping.eventVersion,
     objectToSend,
-  );
+  ).catch(() => {});
 };
 
 export default events;

package/src/hooks/create.ts

@@ -1,9 +1,10 @@
+import type { WhereOptions } from 'sequelize';
 import logger from '../utils/logger';
-import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
 import { MissingRequiredCustomFieldError } from '../errors';
-import type { ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
+import updateInstanceValues from './utils/updateInstanceValues';
 
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
@@ -17,43 +18,64 @@ 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[], modelOptions: ModelOptions = {}) => async (
+export const beforeCreate = (
+  scopeAttributes: string[],
+  modelOptions: ModelOptions = {},
+  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
+) => async (
   instance,
   options,
 ): Promise<void> => {
   logger.debug('sadot - before create hook');
   const { fields } = options;
+  const { include, useEntityIdFromInclude } = modelOptions;
   const modelType = instance.constructor.name;
 
   const identifiers = applyScopeToInstance(instance, scopeAttributes);
 
-  // get all model's required definitions
-  const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers, modelOptions);
+  const where: WhereOptions = {
+    modelType,
+    disabled: false,
+    ...(!useEntityIdFromInclude && { entityId: identifiers }),
+  };
+  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: false, transaction: options.transaction, include: include?.(identifiers) });
+  const requiredFieldsNames = Array.from(new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)));
+
+  const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
+  if (fieldsWithDefaultValue.length) {
+    // eslint-disable-next-line no-param-reassign
+    instance.customFields ||= {};
+    fieldsWithDefaultValue.filter((def) => (instance.customFields?.[def.name] === undefined)).forEach(({ name, defaultValue }) => {
+      // eslint-disable-next-line no-param-reassign
+      instance.customFields[name] = defaultValue;
+    });
+  }
 
-  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);
-    }
-
-    await ValueRepo.updateValues(
-      modelType,
-      instance.id,
-      identifiers,
-      customFields,
-      {
-        transaction: options.transaction,
-        modelOptions,
-      },
-      true,
-    );
+  const fieldsNames = Object.keys(customFields ?? {});
+  const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+  if (missingFields?.length) {
+    throw new MissingRequiredCustomFieldError(missingFields);
+  }
 
-    // eslint-disable-next-line no-param-reassign
-    fields.splice(customFieldsIdx, 1);
-  } else if (requiredFieldsNames?.length > 0) {
-    throw new MissingRequiredCustomFieldError(requiredFieldsNames);
+  const customFieldsIdx = fields.indexOf('customFields');
+  if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
+    // After checking for required fields and fields with default values, and we have no custom fields.
+    return;
   }
+
+  await updateInstanceValues({
+    modelId: instance.id,
+    modelType,
+    identifiers,
+    customFields,
+    options: {
+      useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+      transaction: options.transaction,
+      modelOptions,
+    },
+  });
+
+  // eslint-disable-next-line no-param-reassign
+  fields.splice(customFieldsIdx, 1);
 };