@autofleet/sadot 0.7.6-beta.4 → 0.7.6

package/dist/hooks/create.js

@@ -48,27 +48,43 @@ exports.beforeBulkCreate = beforeBulkCreate;
 const beforeCreate = (scopeAttributes, modelOptions = {}) => async (instance, options) => {
     logger_1.default.debug('sadot - before create hook');
     const { fields } = options;
+    const { include, useEntityIdFromInclude } = modelOptions;
     const modelType = instance.constructor.name;
     const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
-    // get all model's required definitions
-    const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers, modelOptions);
+    const where = {
+        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 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 errors_1.MissingRequiredCustomFieldError(missingFields);
-        }
-        await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, {
-            transaction: options.transaction,
-            modelOptions,
-        }, true);
+    if ((customFieldsIdx === -1 || !instance.customFields) && requiredFieldsNames?.length > 0) {
+        throw new errors_1.MissingRequiredCustomFieldError(requiredFieldsNames);
+    }
+    const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
+    if (fieldsWithDefaultValue.length) {
         // eslint-disable-next-line no-param-reassign
-        fields.splice(customFieldsIdx, 1);
+        instance.customFields || (instance.customFields = {});
+        fieldsWithDefaultValue.filter((def) => !(def.name in instance.customFields)).forEach(({ name, defaultValue }) => {
+            // eslint-disable-next-line no-param-reassign
+            instance.customFields[name] = defaultValue;
+        });
     }
-    else if (requiredFieldsNames?.length > 0) {
-        throw new errors_1.MissingRequiredCustomFieldError(requiredFieldsNames);
+    const { customFields } = instance;
+    if (customFieldsIdx === -1 || !customFields) {
+        return;
+    }
+    const fieldsNames = Object.keys(customFields);
+    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+    if (missingFields?.length > 0) {
+        throw new errors_1.MissingRequiredCustomFieldError(missingFields);
     }
+    await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, {
+        transaction: options.transaction,
+        modelOptions,
+    });
+    // eslint-disable-next-line no-param-reassign
+    fields.splice(customFieldsIdx, 1);
 };
 exports.beforeCreate = beforeCreate;

package/dist/repository/definition.d.ts

@@ -1,20 +1,26 @@
-import { type FindOptions, type WhereOptions } from 'sequelize';
+import { type Includeable, type Transaction, type FindOptions, type WhereOptions } from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
 import type { ModelOptions } from '../types';
 export declare const create: (data: CreateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
-export declare const findAll: (where: WhereOptions, options?: any) => Promise<CustomFieldDefinition[]>;
-export declare const findByIds: (ids: string[], options?: any) => Promise<CustomFieldDefinition[]>;
-export declare const findById: (id: string, options?: any) => Promise<CustomFieldDefinition | null>;
+interface SadotFindOptions {
+    withDisabled?: boolean;
+    transaction?: Transaction;
+    include?: Includeable | Includeable[];
+}
+export declare const findAll: (where: WhereOptions, options?: SadotFindOptions) => Promise<CustomFieldDefinition[]>;
+export declare const findByIds: (ids: string[], options?: SadotFindOptions) => Promise<CustomFieldDefinition[]>;
+export declare const findById: (id: string, options?: Pick<SadotFindOptions, 'withDisabled'>) => Promise<CustomFieldDefinition | null>;
 export declare const findByEntityIds: (modelType: string, entityIds: string[], options?: FindOptions & {
     modelOptions?: ModelOptions;
 }) => Promise<CustomFieldDefinition[]>;
 export declare const findByWhere: (where: any) => Promise<CustomFieldDefinition | null>;
 export declare const findDefinitionsByModels: (modelTypes: string[], options?: any) => Promise<CustomFieldDefinition[]>;
 export declare const update: (id: string, data: UpdateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
-export declare const disable: (id: string) => Promise<any>;
-export declare const destroy: (id: string) => Promise<any>;
+export declare const disable: (id: string) => Promise<[affectedCount: number]>;
+export declare const destroy: (id: string) => Promise<number>;
 /**
  * Return the names of the required fields for a given model
  */
 export declare const getRequiredFields: (modelType: string, modelId: string | string[], entityId: string | string[], modelOptions?: ModelOptions) => Promise<string[]>;
+export {};

package/dist/repository/value.d.ts

@@ -24,5 +24,5 @@ export declare const findValuesByModelIds: (modelIds: string[], options?: any) =
  */
 export declare const updateValues: (modelType: string, modelId: string, identifiers: string[], valuesToUpdate: ValuesToUpdate, options?: FindOptions & {
     modelOptions?: ModelOptions;
-}, defineAllDefaults?: boolean) => Promise<CustomFieldValue[]>;
+}) => Promise<CustomFieldValue[]>;
 export declare const deleteValue: (id: string, options?: any) => Promise<any>;

package/dist/repository/value.js

@@ -84,7 +84,7 @@ const formatFunctions = {
  * Create new value record if not exists, but fails if value's definition not exist.
  * Return the updated values
  */
-const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}, defineAllDefaults = false) => {
+const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
     const names = Object.keys(valuesToUpdate);
     logger_1.default.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
         names,
@@ -96,11 +96,9 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     const where = {
         modelType,
         name: names,
+        ...(!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }),
     };
-    if (!options.modelOptions?.useEntityIdFromInclude) {
-        where.entityId = identifiers;
-    }
-    const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(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_1.default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
@@ -112,28 +110,17 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     if (valuesWithDisabledDefinitions?.length > 0) {
         logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
     }
-    const visitedFields = new Set();
     const values = names.map((name) => {
         const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
-        visitedFields.add(fieldDefinition);
         const formatFunction = formatFunctions[fieldDefinition.fieldType];
+        const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
         return {
             modelId,
-            value: (formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name]) ?? fieldDefinition.defaultValue,
             updatedAt: new Date(),
             customFieldDefinitionId: fieldDefinition.id,
+            value: value !== undefined ? value : fieldDefinition.defaultValue,
         };
     });
-    if (defineAllDefaults) {
-        fieldDefinitions.filter((def) => !visitedFields.has(def) && ![null, undefined].includes(def.defaultValue)).forEach(({ id, defaultValue }) => {
-            values.push({
-                modelId,
-                value: defaultValue,
-                updatedAt: new Date(),
-                customFieldDefinitionId: id,
-            });
-        });
-    }
     return Promise.all(values.map(async (value) => {
         const [cfv] = await models_1.CustomFieldValue.upsert(value, {
             transaction: options.transaction,

package/dist/utils/helpers/index.d.ts

@@ -1,4 +1,4 @@
-import { type WhereOptions, type IncludeOptions } from 'sequelize';
+import { type WhereOptions, type BindOrReplacements } from 'sequelize';
 import { type ModelStatic } from 'sequelize-typescript';
 import { CustomFieldDefinitionType } from '../constants';
 /**
@@ -14,12 +14,12 @@ import { CustomFieldDefinitionType } from '../constants';
  * @param {CustomFieldDefinitionType[]} excludedCustomFieldsTypes - An array of custom field types
  * to exclude from the search
  *
- * @returns {CustomFieldsSearchPayload} - An object containing the INCLUDE clause and WHERE clause
+ * @returns {CustomFieldsSearchPayload} - An object containing the WHERE clause and replacements
  * for Sequelize.
  */
 interface CustomFieldsSearchPayload {
     where: WhereOptions;
-    include: IncludeOptions[];
+    replacements: BindOrReplacements;
 }
 export declare const generateRandomString: (length?: number) => string;
 export declare const generateCustomFieldSearchQueryPayload: (searchTerm: string, model: ModelStatic, entityId: string, customFieldsTypesToExclude?: CustomFieldDefinitionType[]) => CustomFieldsSearchPayload;

package/dist/utils/helpers/index.js

@@ -6,7 +6,6 @@ const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const node_crypto_1 = require("node:crypto");
 const constants_1 = require("../constants");
-const models_1 = require("../../models");
 const generateRandomString = (length = 5) => {
     const characters = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
     return Array.from({ length }, () => characters.charAt((0, node_crypto_1.randomInt)(characters.length))).join('');
@@ -15,29 +14,27 @@ exports.generateRandomString = generateRandomString;
 const generateCustomFieldSearchQueryPayload = (searchTerm, model, entityId, customFieldsTypesToExclude = [
     constants_1.CustomFieldDefinitionType.DATETIME,
     constants_1.CustomFieldDefinitionType.DATE,
-]) => ({
-    include: [{
-            model: models_1.CustomFieldValue,
-            as: 'customFieldValue',
-            required: false,
-            include: [
-                {
-                    model: models_1.CustomFieldDefinition,
-                    attributes: [],
-                    required: true,
-                    where: {
-                        entityId,
-                        modelType: model.name,
-                        fieldType: { [sequelize_1.Op.notIn]: customFieldsTypesToExclude },
-                    },
-                },
+]) => {
+    const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(',');
+    const subQuery = 'EXISTS ('
+        + ' SELECT 1'
+        + ' FROM "custom_field_values" AS "cv"'
+        + ' INNER JOIN custom_field_definitions AS cd '
+        + ` ON cd.entity_id = '${entityId}'`
+        + ' AND cv.custom_field_definition_id = cd.id'
+        + ` AND cd.model_type = '${model.name}'`
+        + ` ${excludedTypesString ? `AND cd.field_type NOT IN (${excludedTypesString})` : ''}`
+        + ' WHERE'
+        + ' "cv"."deleted_at" IS NULL'
+        + ` AND "cv"."model_id" = "${model.name}"."id"`
+        + ' AND CAST("cv"."value" AS TEXT) ILIKE :searchTerm)';
+    return {
+        where: {
+            [sequelize_1.Op.or]: [
+                sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.literal(subQuery), true),
             ],
-            where: {
-                deletedAt: null,
-                value: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.cast(sequelize_typescript_1.Sequelize.col('value'), 'text'), { [sequelize_1.Op.iLike]: `%${searchTerm}%` }),
-            },
-            subQuery: true,
-        }],
-    where: sequelize_typescript_1.Sequelize.where(sequelize_typescript_1.Sequelize.col('customFieldValue.model_id'), { [sequelize_1.Op.not]: null }),
-});
+        },
+        replacements: { searchTerm: `%${searchTerm}%` },
+    };
+};
 exports.generateCustomFieldSearchQueryPayload = generateCustomFieldSearchQueryPayload;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.7.6-beta.4",
+  "version": "0.7.6",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/hooks/create.ts

@@ -1,3 +1,4 @@
+import type { WhereOptions } from 'sequelize';
 import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
@@ -23,37 +24,54 @@ export const beforeCreate = (scopeAttributes: string[], modelOptions: ModelOptio
 ): 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 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,
-    );
 
-    // eslint-disable-next-line no-param-reassign
-    fields.splice(customFieldsIdx, 1);
-  } else if (requiredFieldsNames?.length > 0) {
+  if ((customFieldsIdx === -1 || !instance.customFields) && requiredFieldsNames?.length > 0) {
     throw new MissingRequiredCustomFieldError(requiredFieldsNames);
   }
+  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) => !(def.name in instance.customFields)).forEach(({ name, defaultValue }) => {
+      // eslint-disable-next-line no-param-reassign
+      instance.customFields[name] = defaultValue;
+    });
+  }
+  const { customFields } = instance;
+  if (customFieldsIdx === -1 || !customFields) {
+    return;
+  }
+  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,
+    },
+  );
+
+  // eslint-disable-next-line no-param-reassign
+  fields.splice(customFieldsIdx, 1);
 };

package/src/repository/definition.ts

@@ -1,4 +1,7 @@
-import { Op, type FindOptions, type WhereOptions } from 'sequelize';
+import {
+  Op,
+  type Includeable, type Transaction, type FindOptions, type WhereOptions,
+} from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
 import type { ModelOptions } from '../types';
@@ -6,9 +9,15 @@ import type { ModelOptions } from '../types';
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
 
+interface SadotFindOptions {
+  withDisabled?: boolean;
+  transaction?: Transaction;
+  include?: Includeable | Includeable[];
+}
+
 export const findAll = (
   where: WhereOptions,
-  options: any = { withDisabled: false },
+  options: SadotFindOptions = { withDisabled: false },
 ): Promise<CustomFieldDefinition[]> => {
   const queryModel = options.withDisabled
     ? CustomFieldDefinition.unscoped()
@@ -24,12 +33,12 @@ export const findAll = (
 
 export const findByIds = (
   ids: string[],
-  options: any = { withDisabled: false },
+  options: SadotFindOptions = { withDisabled: false },
 ): Promise<CustomFieldDefinition[]> => findAll({ id: { [Op.in]: ids } }, options);
 
 export const findById = (
   id: string,
-  options: any = { withDisabled: false },
+  options: Pick<SadotFindOptions, 'withDisabled'> = { withDisabled: false },
 ): Promise<CustomFieldDefinition | null> => {
   const { withDisabled } = options;
   if (withDisabled) {
@@ -87,13 +96,13 @@ export const update = async (
   return updatedDefinition;
 };
 
-export const disable = (id: string): Promise<any> =>
+export const disable = (id: string): Promise<[affectedCount: number]> =>
   CustomFieldDefinition.update(
     { disabled: true },
     { where: { id } },
   );
 
-export const destroy = (id: string): Promise<any> =>
+export const destroy = (id: string): Promise<number> =>
   CustomFieldDefinition.destroy({ where: { id } });
 
 /**

package/src/repository/value.ts

@@ -67,7 +67,6 @@ export const updateValues = async (
   identifiers: string[],
   valuesToUpdate: ValuesToUpdate,
   options: FindOptions & { modelOptions?: ModelOptions } = {},
-  defineAllDefaults = false,
 ): Promise<CustomFieldValue[]> => {
   const names = Object.keys(valuesToUpdate);
   logger.debug(`custom-fields: updating values for ${modelType} ${modelId}`, {
@@ -81,12 +80,10 @@ export const updateValues = async (
   const where: WhereOptions = {
     modelType,
     name: names,
+    ...(!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }),
   };
 
-  if (!options.modelOptions?.useEntityIdFromInclude) {
-    where.entityId = identifiers;
-  }
-  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(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) {
@@ -101,31 +98,18 @@ export const updateValues = async (
     logger.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
   }
 
-  const visitedFields = new Set<CustomFieldDefinition>();
-
   const values: CreateCustomFieldValue[] = names.map((name) => {
     const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
-    visitedFields.add(fieldDefinition);
     const formatFunction = formatFunctions[fieldDefinition.fieldType];
+    const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
     return {
       modelId,
-      value: (formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name]) ?? fieldDefinition.defaultValue,
       updatedAt: new Date(),
       customFieldDefinitionId: fieldDefinition.id,
+      value: value !== undefined ? value : fieldDefinition.defaultValue,
     };
   });
 
-  if (defineAllDefaults) {
-    fieldDefinitions.filter((def) => !visitedFields.has(def) && ![null, undefined].includes(def.defaultValue)).forEach(({ id, defaultValue }) => {
-      values.push({
-        modelId,
-        value: defaultValue,
-        updatedAt: new Date(),
-        customFieldDefinitionId: id,
-      });
-    });
-  }
-
   return Promise.all(values.map(async (value) => {
     const [cfv] = await CustomFieldValue.upsert(value, {
       transaction: options.transaction,

package/src/utils/helpers/index.ts

@@ -1,11 +1,8 @@
 /* eslint-disable import/prefer-default-export */
-import {
-  type WhereOptions, Op, type IncludeOptions,
-} from 'sequelize';
+import { type WhereOptions, Op, type BindOrReplacements } from 'sequelize';
 import { type ModelStatic, Sequelize } from 'sequelize-typescript';
 import { randomInt } from 'node:crypto';
 import { CustomFieldDefinitionType } from '../constants';
-import { CustomFieldDefinition, CustomFieldValue } from '../../models';
 
 /**
  * Builds a WHERE clause and replacements for free-text search by custom fields.
@@ -20,13 +17,13 @@ import { CustomFieldDefinition, CustomFieldValue } from '../../models';
  * @param {CustomFieldDefinitionType[]} excludedCustomFieldsTypes - An array of custom field types
  * to exclude from the search
  *
- * @returns {CustomFieldsSearchPayload} - An object containing the INCLUDE clause and WHERE clause
+ * @returns {CustomFieldsSearchPayload} - An object containing the WHERE clause and replacements
  * for Sequelize.
  */
 
 interface CustomFieldsSearchPayload {
   where: WhereOptions;
-  include: IncludeOptions[];
+  replacements: BindOrReplacements;
 }
 
 export const generateRandomString = (length = 5): string => {
@@ -42,28 +39,28 @@ export const generateCustomFieldSearchQueryPayload = (
     CustomFieldDefinitionType.DATETIME,
     CustomFieldDefinitionType.DATE,
   ],
-): CustomFieldsSearchPayload => ({
-  include: [{
-    model: CustomFieldValue,
-    as: 'customFieldValue',
-    required: false,
-    include: [
-      {
-        model: CustomFieldDefinition,
-        attributes: [],
-        required: true,
-        where: {
-          entityId,
-          modelType: model.name,
-          fieldType: { [Op.notIn]: customFieldsTypesToExclude },
-        },
-      },
-    ],
+): CustomFieldsSearchPayload => {
+  const excludedTypesString = customFieldsTypesToExclude.map((type) => `'${type}'`).join(',');
+
+  const subQuery = 'EXISTS ('
+      + ' SELECT 1'
+      + ' FROM "custom_field_values" AS "cv"'
+      + ' INNER JOIN custom_field_definitions AS cd '
+        + ` ON cd.entity_id = '${entityId}'`
+        + ' AND cv.custom_field_definition_id = cd.id'
+        + ` AND cd.model_type = '${model.name}'`
+        + ` ${excludedTypesString ? `AND cd.field_type NOT IN (${excludedTypesString})` : ''}`
+      + ' WHERE'
+        + ' "cv"."deleted_at" IS NULL'
+        + ` AND "cv"."model_id" = "${model.name}"."id"`
+        + ' AND CAST("cv"."value" AS TEXT) ILIKE :searchTerm)';
+
+  return {
     where: {
-      deletedAt: null,
-      value: Sequelize.where(Sequelize.cast(Sequelize.col('value'), 'text'), { [Op.iLike]: `%${searchTerm}%` }),
+      [Op.or]: [
+        Sequelize.where(Sequelize.literal(subQuery), true),
+      ],
     },
-    subQuery: true,
-  }],
-  where: Sequelize.where(Sequelize.col('customFieldValue.model_id'), { [Op.not]: null }),
-});
+    replacements: { searchTerm: `%${searchTerm}%` },
+  };
+};