@autofleet/sadot 1.1.7-beta → 1.1.8

package/src/repository/value.ts

@@ -1,116 +0,0 @@
-import type { FindOptions, WhereOptions } from 'sequelize';
-import { CustomFieldValue, CustomFieldDefinition } from '../models';
-import * as DefinitionRepo from './definition';
-import type { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
-import logger from '../utils/logger';
-import { MissingDefinitionError } from '../errors';
-import type { ModelOptions } from '../types';
-import { formatFunctions } from './utils/formatValues';
-
-export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
-  CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });
-
-export const create = async (data: CreateCustomFieldValue, withAssociations = false) => {
-  const created = await CustomFieldValue.create(data);
-  if (withAssociations) {
-    const createdWithAssociations = await findByModelIdAndDefinition(created.modelId, created.customFieldDefinitionId);
-    return createdWithAssociations?.[0];
-  }
-  return created;
-};
-
-export const findAllValues = async () => CustomFieldValue.findAll({ include: [CustomFieldDefinition] });
-/**
- * Get all values for model instance id (with their definitions)
- * @param modelId
- * @returns CustomFieldValue[]
- */
-export const findValuesByModelId = async (modelId: string) => CustomFieldValue.findAll({ where: { modelId }, include: [CustomFieldDefinition] });
-
-/**
-* Retrieves custom field values for given model IDs
-* @param modelIds - An array of model IDs to query custom field values for.
-* @param options - Optional configuration object.
-*/
-export const findValuesByModelIds = async (modelIds: string[], options?): Promise<CustomFieldValue[]> => {
-  const { transaction } = options;
-  return CustomFieldValue.findAll({
-    where: { modelId: modelIds },
-    transaction,
-    raw: true,
-    nest: true,
-  });
-};
-
-/**
- * Try to update custom field values for a model instance.
- * Create new value record if not exists, but fails if value's definition not exist.
- * Return the updated values
- */
-export const updateValues = async (
-  modelType: string,
-  modelId: string,
-  identifiers: string[],
-  valuesToUpdate: ValuesToUpdate,
-  options: FindOptions & { modelOptions?: ModelOptions } = {},
-): Promise<CustomFieldValue[]> => {
-  const names = Object.keys(valuesToUpdate);
-  logger.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
-    names,
-    optionsKeys: options ? Object.keys(options) : null,
-    valuesToUpdate,
-    identifiers,
-  });
-  const { modelOptions, transaction } = options;
-
-  const where: WhereOptions = {
-    modelType,
-    name: names,
-    ...(!options.modelOptions?.useEntityIdFromInclude && { 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.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
-    const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
-    throw new MissingDefinitionError(missingDefinitions);
-  }
-
-  const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
-  const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
-  if (valuesWithDisabledDefinitions?.length > 0) {
-    logger.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
-  }
-
-  const values: CreateCustomFieldValue[] = names.map((name) => {
-    const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
-    const formatFunction = formatFunctions[fieldDefinition.fieldType];
-    const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
-    return {
-      modelId,
-      updatedAt: new Date(),
-      customFieldDefinitionId: fieldDefinition.id,
-      value: value !== undefined ? value : fieldDefinition.defaultValue,
-    };
-  });
-
-  return Promise.all(values.map(async (value) => {
-    const [cfv] = await CustomFieldValue.upsert(value, {
-      transaction: options.transaction,
-    });
-    return cfv;
-  }));
-};
-
-export const deleteValue = (
-  id: string,
-  options: any = {},
-): Promise<any> => CustomFieldValue.update(
-  { deletedAt: new Date() },
-  {
-    where: { id },
-    transaction: options.transaction,
-  },
-);

package/src/scopes/filter.ts

@@ -1,100 +0,0 @@
-/* eslint-disable import/prefer-default-export */
-import { Op } from 'sequelize';
-import { Sequelize } from 'sequelize-typescript';
-import { customFields } from '@autofleet/common-types';
-import { generateRandomString } from '../utils/helpers';
-import type { CustomFieldOptions } from '../types';
-import {
-  formatConditionsForEntries,
-  formatConditionsForValues,
-  getFilterCustomFieldsSubQuery,
-  getSortCustomFieldsSubQuery,
-  SubQueryType,
-  type ConditionValue,
-  type CustomFieldFilterOptions,
-} from './helpers/filter.helpers';
-
-const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
-
-type customFieldsFilterScopeParams = {
-    replacementsMap: Record<string, string>;
-    scopeValue: Record<string, ConditionValue>;
-}
-
-/**
- * A Sequelize scope for filtering models by custom fields.
- * This scope builds a WHERE clause to be applied on the main query.
- *
- * @param name - The model type name used to join custom_field_definitions.
- * @returns A function that takes conditions and returns the Sequelize options object.
- */
-export const customFieldsFilterScope = (
-  name: string,
-  options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
-) => ({ replacementsMap: replacements, scopeValue: conditions }: customFieldsFilterScopeParams): CustomFieldFilterOptions => {
-  if (!conditions || Object.keys(conditions).length === 0) {
-    return {};
-  }
-
-  const queryType = options?.useCustomFieldsEntries ? SubQueryType.ENTRIES : SubQueryType.VALUES;
-  const reverseReplacementsMap = new Map(Object.entries(replacements).map(([key, value]) => [value, key]));
-  // Build the WHERE clause for custom field filtering
-  const conditionsStrings = Object.entries(conditions).map(([key, condition]) => {
-    switch (queryType) {
-      case SubQueryType.ENTRIES:
-        return formatConditionsForEntries(key, condition, reverseReplacementsMap);
-      case SubQueryType.VALUES:
-        return formatConditionsForValues(key, condition, reverseReplacementsMap);
-      default:
-        return false;
-    }
-  }).filter(Boolean);
-  if (conditionsStrings.length === 0) {
-    return {};
-  }
-  const subQuery = getFilterCustomFieldsSubQuery(queryType, name, conditionsStrings);
-
-  return {
-    where: {
-      id: {
-        [Op.in]: Sequelize.literal(`(${subQuery})`),
-      },
-    },
-    replacements,
-  };
-};
-
-export const scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
-
-export const customFieldsSortScope = (
-  name: string,
-  options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
-) => ({ replacementsMap, scopeValue: sort }) => {
-  if (!sort || sort.length === 0) {
-    return {};
-  }
-
-  const queryType = options?.useCustomFieldsEntries ? SubQueryType.ENTRIES : SubQueryType.VALUES;
-  const randomStr = generateRandomString();
-  const includes = Object.entries(sort).map(([key]) => {
-    const replacementKey = Object.keys(replacementsMap).find(
-      (randomString) => replacementsMap[randomString] === key,
-    );
-    return ([
-      Sequelize.literal(getSortCustomFieldsSubQuery(queryType, name, replacementKey)),
-      randomStr,
-    ]);
-  });
-
-  const orders = Object.entries(sort).map(([, sortObject]) => {
-    const direction = typeof sortObject === 'string' ? sortObject : Object.values(sortObject)[0];
-    return Sequelize.literal(`"${randomStr}" ${direction || 'ASC'}`);
-  });
-  return {
-    attributes: {
-      include: includes,
-    },
-    order: orders,
-    replacements: replacementsMap,
-  };
-};

package/src/scopes/helpers/filter.helpers.ts

@@ -1,227 +0,0 @@
-import type { WhereOptions } from 'sequelize';
-
-/**
- * Type representing possible condition values.
- * Currently supporting strings and arrays of strings.
- * More types to be added (TBA).
- */
-export type ConditionWithOperator = {
-  operator: string;
-  value: string;
-};
-export type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
-
-export type CustomFieldSort = {
-  field: string;
-  direction: 'ASC' | 'DESC';
-}
-
-export type CustomFieldFilterOptions = {
-  where?: WhereOptions;
-  replacements?: Record<string, string>;
-}
-
-export enum SubQueryType {
-  VALUES = 'values',
-  ENTRIES = 'entries',
-}
-
-export const isConditionStringArray = (input: any): input is string[] => Array.isArray(input) && typeof input[0] === 'string';
-export const isBooleanString = (input: string): boolean => ['true', 'false'].includes(input.toString());
-export const isDate = (input: any): input is Date => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
-
-export const castValueToJsonb = (value: string, type: string) => `to_jsonb(${value}::${type})`;
-export const castValueToJsonbText = (value: string) => castValueToJsonb(value, 'text');
-export const castValueToJsonbBoolean = (value: string) => castValueToJsonb(value, 'boolean');
-export const castValueToJsonbNumeric = (value: string) => castValueToJsonb(value, 'numeric');
-export const castIfNeeded = (columnName: string, conditionValue: string): string => {
-  if (isDate(conditionValue)) {
-    return castValueToJsonb(columnName, 'timestamp');
-  }
-  return columnName;
-};
-
-export const AND_DELIMITER = ' AND ';
-export const OR_DELIMITER = ' OR ';
-export const CD_TABLE_ALIAS = 'cd';
-export const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
-export const CV_TABLE_ALIAS = 'cv';
-export const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
-export const CE_TABLE_ALIAS = 'ce';
-
-const getSingleConditionWithOperator = (value: any, operator: string, replacementKey: string, reverseReplacementsMap: Map<string, string>) => {
-  let type = 'text';
-  if (isDate(value)) {
-    type = 'date';
-  } else if (!Number.isNaN(Number(value))) {
-    type = 'numeric';
-  } else if (isBooleanString(value)) {
-    type = 'boolean';
-  }
-  const replacedValue = reverseReplacementsMap.get(value);
-
-  return `(jsonb_extract_path_text(${CE_TABLE_ALIAS}.custom_fields, :${replacementKey})::${type}) ${operator} :${replacedValue}`;
-};
-
-const getFormattedValue = (value: string) => {
-  let formattedValue: string | number | boolean = value;
-  if (isBooleanString(value)) {
-    formattedValue = value === 'true';
-  } else if (!Number.isNaN(Number(value))) {
-    formattedValue = Number(value);
-  }
-
-  return formattedValue;
-};
-
-const getJSONSubQuery = (value: string, key: string) => {
-  const formattedValue = getFormattedValue(value);
-  const jsonQuery = JSON.stringify({ [key]: formattedValue });
-  let jsonQueryWithStringBoolean;
-  if (isBooleanString(value)) {
-    jsonQueryWithStringBoolean = `${CE_TABLE_ALIAS}.custom_fields @> '${JSON.stringify({ [key]: value })}'`;
-  }
-  return `
-    (
-      ${jsonQueryWithStringBoolean ? `${jsonQueryWithStringBoolean} OR` : ''}
-      ${CE_TABLE_ALIAS}.custom_fields @> '${jsonQuery}'
-    )
-  `;
-};
-
-export const getFilterCustomFieldsSubQuery = (queryType: SubQueryType, modelType: string, conditionsStrings: Array<string | boolean>): string => {
-  switch (queryType) {
-    case SubQueryType.VALUES:
-      return `
-        SELECT ${CV_TABLE_ALIAS}.model_id
-        FROM custom_field_values AS ${CV_TABLE_ALIAS}
-        INNER JOIN custom_field_definitions AS ${CD_TABLE_ALIAS} ON ${CV_TABLE_ALIAS}.custom_field_definition_id = ${CD_TABLE_ALIAS}.id
-        ${AND_DELIMITER}${CD_TABLE_ALIAS}.model_type = '${modelType}'
-        WHERE ${conditionsStrings.join(OR_DELIMITER)}
-        ${AND_DELIMITER}${CV_TABLE_ALIAS}.deleted_at IS NULL${AND_DELIMITER}${CD_TABLE_ALIAS}.deleted_at IS NULL
-        GROUP BY ${CV_TABLE_ALIAS}.model_id
-        HAVING COUNT(DISTINCT ${CV_TABLE_ALIAS}.custom_field_definition_id) = ${conditionsStrings.length}
-      `.replace(/\n/g, '');
-    case SubQueryType.ENTRIES:
-      return `
-        SELECT ce.model_id
-        FROM custom_field_entries ce
-        JOIN custom_field_definitions cfd
-        ON ce.model_type = cfd.model_type
-        AND ce.entity_id = cfd.entity_id
-        WHERE
-          cfd.deleted_at IS NULL AND
-          ${conditionsStrings.join(AND_DELIMITER)}
-      `;
-    default:
-      throw new Error('Invalid query type');
-  }
-};
-
-export const getSortCustomFieldsSubQuery = (queryType: SubQueryType, modelType: string, replacementKey: string): string => {
-  switch (queryType) {
-    case SubQueryType.VALUES:
-      return `(
-              SELECT value
-              FROM (SELECT cv.model_id, cv.value
-                    FROM custom_field_values AS cv INNER JOIN custom_field_definitions AS cd
-                      ON cv.custom_field_definition_id = cd.id
-                      ${AND_DELIMITER}cd.model_type = '${modelType}'
-                      WHERE cv.model_id = "${modelType}"."id"
-                            ${AND_DELIMITER}cd.name = :${replacementKey}
-                            ) AS CustomFieldAggregation
-              )
-            `;
-    case SubQueryType.ENTRIES:
-      return `(
-        SELECT
-            customFields.value
-        FROM
-            custom_field_entries AS ${CE_TABLE_ALIAS},
-            jsonb_each_text(custom_fields) AS customFields
-        WHERE
-          customFields.key = :${replacementKey}${AND_DELIMITER}
-          ${CE_TABLE_ALIAS}.model_type = '${modelType}'${AND_DELIMITER}
-          ${CE_TABLE_ALIAS}.model_id = "${modelType}"."id"
-        )
-      `;
-    default:
-      throw new Error('Invalid query type');
-  }
-};
-
-export const formatConditionsForValues = (key: string, condition: ConditionValue, reverseReplacementsMap: Map<string, string>) => {
-  const replacementKey = reverseReplacementsMap.get(key);
-  if (!replacementKey) {
-    return false;
-  }
-
-  const columnCondition = `(${CD_NAME_COLUMN} = :${replacementKey})`;
-  if (Array.isArray(condition)) {
-    if (condition.length === 0) {
-      // if empty array, the condition is ignored
-      return false;
-    }
-
-    if (isConditionStringArray(condition)) {
-      const values = condition.flatMap((v) => {
-        const valRandom = reverseReplacementsMap.get(v);
-        if (isBooleanString(v)) {
-          return [castValueToJsonbText(`:${valRandom}`), castValueToJsonbBoolean(`:${valRandom}`)];
-        }
-        if (!Number.isNaN(Number(v))) {
-          return castValueToJsonbNumeric(`:${valRandom}`);
-        }
-        return castValueToJsonbText(`:${valRandom}`);
-      }).join(',');
-      return `(${columnCondition}${AND_DELIMITER}${CV_VALUE_COLUMN} IN (${values}))`;
-    }
-    return condition.map((c) => {
-      const valRep = reverseReplacementsMap.get(c.value);
-      const valueAsJsonb = castValueToJsonbText(`:${valRep}`);
-
-      return `(${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, c.value)} ${c.operator} ${valueAsJsonb})`;
-    }).join(AND_DELIMITER);
-  }
-  if (typeof condition === 'string' || typeof condition === 'number') {
-    const conditionRep = reverseReplacementsMap.get(condition);
-    const valueAsJsonb = !Number.isNaN(Number(condition)) ? castValueToJsonbNumeric(`:${conditionRep}`) : castValueToJsonbText(`:${conditionRep}`);
-    const valueAsJsonbBoolean = isBooleanString(condition) ? `${OR_DELIMITER}${CV_VALUE_COLUMN} = ${castValueToJsonbBoolean(`:${conditionRep}`)}` : '';
-    return `(${columnCondition}${AND_DELIMITER}(${castIfNeeded(CV_VALUE_COLUMN, condition)} = ${valueAsJsonb}${valueAsJsonbBoolean}))`;
-  }
-  if (condition?.operator) {
-    const valueRep = reverseReplacementsMap.get(condition.value);
-    const valueAsJsonb = castValueToJsonbText(`:${valueRep}`);
-    return `( ${columnCondition}${AND_DELIMITER}${castIfNeeded(CV_VALUE_COLUMN, condition.value)} ${condition.operator} ${valueAsJsonb})`;
-  }
-  return false;
-};
-
-export const formatConditionsForEntries = (key: string, condition: ConditionValue, reverseReplacementsMap: Map<string, string>) => {
-  const replacementKey = reverseReplacementsMap.get(key);
-  if (!replacementKey) {
-    return false;
-  }
-
-  if (Array.isArray(condition)) {
-    if (condition.length === 0) {
-      // if empty array, the condition is ignored
-      return false;
-    }
-
-    if (isConditionStringArray(condition)) {
-      const values = condition.map((value) => getJSONSubQuery(value, key)).join(`${OR_DELIMITER}\n`);
-      return `( ${values})`;
-    }
-    return condition.map((c) => getSingleConditionWithOperator(c.value, c.operator, replacementKey, reverseReplacementsMap)).join(AND_DELIMITER);
-  }
-
-  if (typeof condition === 'string' || typeof condition === 'number') {
-    return getJSONSubQuery(condition, key);
-  }
-
-  if (condition?.operator) {
-    return getSingleConditionWithOperator(condition.value, condition.operator, replacementKey, reverseReplacementsMap);
-  }
-  return false;
-};

package/src/scopes/index.ts

@@ -1,6 +0,0 @@
-/* eslint-disable import/prefer-default-export */
-import { customFieldsFilterScope } from './filter';
-
-export {
-  customFieldsFilterScope,
-};

package/src/tests/api/test-api.ts

@@ -1,40 +0,0 @@
-import express from 'express';
-import { Router } from '@autofleet/node-common';
-import logger from '../../utils/logger';
-import { TestModel } from '../../models';
-
-const app = express();
-app.use(express.json());
-const api = Router({ logger });
-
-api.get('/v1/test-models', async (req, res) => {
-  const testModels = await TestModel.findAll();
-  return res.json(testModels);
-});
-
-api.get('/v1/test-models/:testModelId', async (req, res) => {
-  const { params: { testModelId } } = req;
-  const testModel = await TestModel.findByPk(testModelId);
-  return res.json(testModel);
-});
-
-api.post('/v1/test-models', async (req, res) => {
-  const { body } = req;
-  const testModel = await TestModel.create(body);
-  return res.json(testModel);
-});
-
-api.patch('/v1/test-models/:testModelId', async (req, res) => {
-  const { body, params: { testModelId } } = req;
-  const testModel = await TestModel.update(body, {
-    where: {
-      id: testModelId,
-    },
-    returning: true,
-  });
-  return res.json(testModel[1][0]);
-});
-
-app.use('/api', api);
-
-export default app;

package/src/tests/functional/searching/index.ts

@@ -1,39 +0,0 @@
-import { generateCustomFieldSearchQueryPayload } from '../../../index';
-import * as DefinitionRepo from '../../../repository/definition';
-import { createDefinition } from '../../mocks/definition.mock';
-import { createTestModels } from '../../mocks/testModel';
-import { TestModel } from '../../../models';
-
-interface CustomFieldsSearchTestFlowInput {
-  fieldType: string;
-  fieldValue: string | number;
-  searchTerm: string;
-  expectedNumberOfQueryResults: number;
-}
-
-const customFieldsSearchTestFlow = async ({
-  fieldType,
-  fieldValue,
-  searchTerm,
-  expectedNumberOfQueryResults,
-}: CustomFieldsSearchTestFlowInput): Promise<void> => {
-  const definition = createDefinition({ fieldType, name: 'coolDefinition' });
-  await DefinitionRepo.create({ ...definition });
-  const [testModel1] = await createTestModels(definition.entityId, 2);
-  await testModel1.update({ customFields: { [definition.name]: fieldValue } });
-  const models = await TestModel.findAndCountAll(
-    {
-      ...generateCustomFieldSearchQueryPayload(
-        searchTerm,
-        TestModel,
-        definition.entityId,
-      ),
-    },
-  );
-  expect(models.count).toBe(expectedNumberOfQueryResults);
-  if (expectedNumberOfQueryResults > 0) {
-    expect(models.rows[0].dataValues.id).toBe(testModel1.id);
-  }
-};
-
-export default customFieldsSearchTestFlow;

package/src/tests/helpers/commonHooks.ts

@@ -1,43 +0,0 @@
-import type { Application } from 'express';
-import type { Sequelize } from 'sequelize-typescript';
-import useCustomFields from '../..';
-import { cleanup, getModel } from '.';
-import databaseConfig from './database-config';
-import initDB, { createSequelizeMeta } from '../../utils/db';
-import type { Models } from '../../types';
-
-export function commonTestHooks(
-  app: Application | null = null,
-  models: Models[] = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }],
-  options: { useCustomFieldsEntries: boolean, useValidators?: boolean } = {
-    useCustomFieldsEntries: false,
-    useValidators: false,
-  },
-) {
-  let sequelize: Sequelize;
-
-  beforeAll(async () => {
-    sequelize = initDB(databaseConfig);
-    await createSequelizeMeta(sequelize);
-    await useCustomFields(app, getModel, {
-      models,
-      databaseConfig,
-      getUser: () => undefined,
-      sequelize,
-      useCustomFieldsEntries: options.useCustomFieldsEntries,
-      useValidators: options.useValidators,
-    });
-  });
-
-  afterEach(async () => {
-    jest.clearAllMocks();
-    await cleanup({
-      useCustomFieldsEntries: options.useCustomFieldsEntries,
-      useValidators: options.useValidators,
-    });
-  });
-
-  afterAll(async () => {
-    await sequelize.close();
-  });
-}

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

@@ -1,15 +0,0 @@
-export default {
-  test: {
-    username: process.env.DB_USERNAME || '',
-    password: process.env.DB_PASSWORD || null,
-    database: process.env.DB_NAME || 'postgres',
-    host: process.env.DB_HOST || '127.0.0.1',
-    port: process.env.DB_PORT || 5432,
-    dialect: process.env.DB_TYPE || 'postgres',
-    define: {
-      underscored: true,
-      underscoredAll: true,
-    },
-    logging: false,
-  },
-};

package/src/tests/helpers/index.ts

@@ -1,35 +0,0 @@
-import { generateFilterReplacements } from '@autofleet/sheilta';
-import {
-  ContextAwareTestModel, ContextTestModel, CustomFieldDefinition, CustomFieldEntries, CustomValidator, TestModel,
-} from '../../models';
-import type { CustomFieldOptions } from '../../types';
-
-// eslint-disable-next-line import/prefer-default-export
-export const cleanup = async (options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries' | 'useValidators'>): 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: {} });
-
-    if (options?.useCustomFieldsEntries) {
-      await CustomFieldEntries.unscoped().destroy({ where: {} });
-    }
-
-    // Clean up validators if they were used
-    if (options?.useValidators) {
-      await CustomValidator.unscoped().destroy({ where: {} });
-    }
-  }
-};
-
-export const getModel = (name: string) => {
-  // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
-  const models = require('../../models');
-  return models[name];
-};
-
-export const getReplacementMapWithScopeValue = (conditions: Record<string, any>) => ({
-  replacementsMap: generateFilterReplacements(Object.fromEntries(Object.entries(conditions).map(([key, value]) => [`customFields.${key}`, value]))),
-  scopeValue: conditions,
-});