@autofleet/sadot 0.10.3 → 0.10.4-beta-74e8bd5c.0

package/.env

@@ -0,0 +1,4 @@
+AF_SERVICE_NAME=sadot
+NODE_ENV=test
+DB_USERNAME=postgres
+DB_PASSWORD=postgres

package/dist/hooks/create.js

@@ -62,7 +62,7 @@ const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
     if (fieldsWithDefaultValue.length) {
         // eslint-disable-next-line no-param-reassign
         instance.customFields || (instance.customFields = {});
-        fieldsWithDefaultValue.filter((def) => (instance.customFields?.[def.name] === undefined)).forEach(({ name, defaultValue }) => {
+        fieldsWithDefaultValue.filter((def) => !(def.name in instance.customFields)).forEach(({ name, defaultValue }) => {
             // eslint-disable-next-line no-param-reassign
             instance.customFields[name] = defaultValue;
         });

package/dist/hooks/enrich.js

@@ -36,17 +36,14 @@ const getCustomFieldEntriesByInstanceId = async ({ instancesIds, options, sadotO
         return {};
     }
     const customFieldEntries = await EntriesRepo.findEntriesByModelIds(instancesIds, options ?? {});
-    const customFieldEntriesByInstanceId = Object.fromEntries(customFieldEntries.map((instanceEntries) => {
+    return customFieldEntries.reduce((valuesByInstanceId, instanceEntries) => {
         const { modelId, customFields } = instanceEntries?.dataValues ?? {};
         if (!modelId) {
-            return undefined;
+            return valuesByInstanceId;
         }
-        return [modelId, customFields];
-    }).filter(Boolean));
-    instancesIds.forEach((instanceId) => {
-        customFieldEntriesByInstanceId[instanceId] ?? (customFieldEntriesByInstanceId[instanceId] = {});
-    });
-    return customFieldEntriesByInstanceId;
+        valuesByInstanceId[modelId] = customFields ?? {};
+        return valuesByInstanceId;
+    }, {});
 };
 exports.getCustomFieldEntriesByInstanceId = getCustomFieldEntriesByInstanceId;
 const getValuesGroupByInstance = async ({ instancesIds, options, sadotOptions, }) => {
@@ -57,7 +54,9 @@ const getValuesGroupByInstance = async ({ instancesIds, options, sadotOptions, }
     // Group fields by modelId
     return customFieldValues.reduce((acc, v) => {
         const { modelId } = v;
-        acc[modelId] ?? (acc[modelId] = []);
+        if (!acc[modelId]) {
+            acc[modelId] = [];
+        }
         acc[modelId].push(v);
         return acc;
     }, {});
@@ -128,10 +127,10 @@ const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {},
     instances.forEach((instance) => {
         const { id } = instance;
         const instanceValues = valuesGroupByInstance[id];
-        const serializedCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
+        const serializeCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
         const customFields = sadotOptions.useCustomFieldsEntries
             ? customFieldEntriesByInstanceId[id]
-            : serializedCustomFieldsValues;
+            : serializeCustomFieldsValues;
         scopeAttributes.forEach((attribute) => {
             const identifier = instance[attribute];
             const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];

package/dist/index.js

@@ -42,7 +42,7 @@ const useCustomFields = async (app, getModel, options) => {
     // The order is important
     (0, init_1.addHooks)(models, getModel, { useCustomFieldsEntries });
     await (0, models_1.initTables)(sequelize, options.getUser, { useCustomFieldsEntries });
-    (0, init_1.addScopes)(models, getModel, { useCustomFieldsEntries });
+    (0, init_1.addScopes)(models, getModel);
     (0, init_1.applyCustomAssociation)(models);
     logger_1.default.debug('sadot - custom fields finished initializing with models', models);
     return sequelize;

package/dist/repository/entries.js

@@ -31,7 +31,6 @@ const models_1 = require("../models");
 const logger_1 = __importDefault(require("../utils/logger"));
 const errors_1 = require("../errors");
 const DefinitionRepo = __importStar(require("./definition"));
-const formatValues_1 = require("./utils/formatValues");
 const findEntriesByModelId = async (modelId, options = {}) => {
     const { transaction } = options;
     return models_1.CustomFieldEntries.findOne({
@@ -74,14 +73,6 @@ const updateEntries = async (modelId, modelType, customFields, identifiers, opti
     if (valuesWithDisabledDefinitions?.length > 0) {
         logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
     }
-    const definitionsByName = Object.fromEntries(fieldDefinitions.map((definition) => [definition.name, definition]));
-    // If we need to format the value before we save it
-    Object.entries(customFields)
-        .filter(([definitionName]) => formatValues_1.formatFunctions[definitionsByName[definitionName].fieldType])
-        .forEach(([definitionName, value]) => {
-        const { fieldType } = definitionsByName[definitionName];
-        customFields[definitionName] = formatValues_1.formatFunctions[fieldType](value);
-    });
     return models_1.CustomFieldEntries.upsert({
         modelId,
         entityId: fieldDefinitions[0].entityId,

package/dist/repository/value.js

@@ -31,7 +31,7 @@ const models_1 = require("../models");
 const DefinitionRepo = __importStar(require("./definition"));
 const logger_1 = __importDefault(require("../utils/logger"));
 const errors_1 = require("../errors");
-const formatValues_1 = require("./utils/formatValues");
+const constants_1 = require("../utils/constants");
 const findByModelIdAndDefinition = async (modelId, customFieldDefinitionId) => models_1.CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [models_1.CustomFieldDefinition] });
 exports.findByModelIdAndDefinition = findByModelIdAndDefinition;
 const create = async (data, withAssociations = false) => {
@@ -67,6 +67,18 @@ const findValuesByModelIds = async (modelIds, options) => {
     });
 };
 exports.findValuesByModelIds = findValuesByModelIds;
+const formatFunctions = {
+    [constants_1.CustomFieldDefinitionType.DATE]: (value) => {
+        if (value) {
+            const date = new Date(value);
+            if (date.toString() === 'Invalid Date') {
+                throw new Error(`Invalid date value: ${value}`);
+            }
+            return date.toISOString();
+        }
+        return null;
+    },
+};
 /**
  * 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.
@@ -100,7 +112,7 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     }
     const values = names.map((name) => {
         const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
-        const formatFunction = formatValues_1.formatFunctions[fieldDefinition.fieldType];
+        const formatFunction = formatFunctions[fieldDefinition.fieldType];
         const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
         return {
             modelId,

package/dist/scopes/filter.d.ts

@@ -1,5 +1,22 @@
-import type { CustomFieldOptions } from '../types';
-import { type ConditionValue, type CustomFieldFilterOptions } from './helpers/filter.helpers';
+import { type WhereOptions } from 'sequelize';
+/**
+ * Type representing possible condition values.
+ * Currently supporting strings and arrays of strings.
+ * More types to be added (TBA).
+ */
+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>;
+};
 type customFieldsFilterScopeParams = {
     replacementsMap: Record<string, string>;
     scopeValue: Record<string, ConditionValue>;
@@ -11,9 +28,9 @@ type customFieldsFilterScopeParams = {
  * @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 declare const customFieldsFilterScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap: replacements, scopeValue: conditions }: customFieldsFilterScopeParams) => CustomFieldFilterOptions;
+export declare const customFieldsFilterScope: (name: string) => ({ replacementsMap: replacements, scopeValue: conditions }: customFieldsFilterScopeParams) => CustomFieldFilterOptions;
 export declare const scopeName = "filterByCustomFields";
-export declare const customFieldsSortScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap, scopeValue: sort }: {
+export declare const customFieldsSortScope: (name: string) => ({ replacementsMap, scopeValue: sort }: {
     replacementsMap: any;
     scopeValue: any;
 }) => {

package/dist/scopes/filter.js

@@ -6,8 +6,26 @@ const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const common_types_1 = require("@autofleet/common-types");
 const helpers_1 = require("../utils/helpers");
-const filter_helpers_1 = require("./helpers/filter.helpers");
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
+const isConditionStringArray = (input) => Array.isArray(input) && typeof input[0] === 'string';
+const isBooleanString = (input) => ['true', 'false'].includes(input.toString());
+const isDate = (input) => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+const castValueToJsonb = (value, type) => `to_jsonb(${value}::${type})`;
+const castValueToJsonbText = (value) => castValueToJsonb(value, 'text');
+const castValueToJsonbBoolean = (value) => castValueToJsonb(value, 'boolean');
+const castValueToJsonbNumeric = (value) => castValueToJsonb(value, 'numeric');
+const castIfNeeded = (columnName, conditionValue) => {
+    if (isDate(conditionValue)) {
+        return castValueToJsonb(columnName, 'timestamp');
+    }
+    return columnName;
+};
+const AND_DELIMITER = ' AND ';
+const OR_DELIMITER = ' OR ';
+const CD_TABLE_ALIAS = 'cd';
+const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
+const CV_TABLE_ALIAS = 'cv';
+const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -15,27 +33,68 @@ const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
  * @param name - The model type name used to join custom_field_definitions.
  * @returns A function that takes conditions and returns the Sequelize options object.
  */
-const customFieldsFilterScope = (name, options) => ({ replacementsMap: replacements, scopeValue: conditions }) => {
+const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scopeValue: conditions }) => {
     if (!conditions || Object.keys(conditions).length === 0) {
         return {};
     }
-    const queryType = options?.useCustomFieldsEntries ? filter_helpers_1.SubQueryType.ENTRIES : filter_helpers_1.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 filter_helpers_1.SubQueryType.ENTRIES:
-                return (0, filter_helpers_1.formatConditionsForEntries)(key, condition, reverseReplacementsMap);
-            case filter_helpers_1.SubQueryType.VALUES:
-                return (0, filter_helpers_1.formatConditionsForValues)(key, condition, reverseReplacementsMap);
-            default:
+        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;
     }).filter(Boolean);
     if (conditionsStrings.length === 0) {
         return {};
     }
-    const subQuery = (0, filter_helpers_1.getFilterCustomFieldsSubQuery)(queryType, name, conditionsStrings);
+    const customFieldConditions = conditionsStrings.join(OR_DELIMITER);
+    const subQuery = `
+    SELECT cv.model_id
+    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 = '${name}'
+    WHERE ${customFieldConditions}
+    ${AND_DELIMITER}cv.deleted_at IS NULL${AND_DELIMITER}cd.deleted_at IS NULL
+    GROUP BY cv.model_id
+    HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
+  `.replace(/\n/g, '');
     return {
         where: {
             id: {
@@ -47,17 +106,25 @@ const customFieldsFilterScope = (name, options) => ({ replacementsMap: replaceme
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
 exports.scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
-const customFieldsSortScope = (name, options) => ({ replacementsMap, scopeValue: sort }) => {
+const customFieldsSortScope = (name) => ({ replacementsMap, scopeValue: sort }) => {
     if (!sort || sort.length === 0) {
         return {};
     }
-    const queryType = options?.useCustomFieldsEntries ? filter_helpers_1.SubQueryType.ENTRIES : filter_helpers_1.SubQueryType.VALUES;
     const randomStr = (0, helpers_1.generateRandomString)();
     const includes = Object.entries(sort).map(([key]) => {
-        const replacementKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
+        const replacemetKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
         return ([
-            sequelize_typescript_1.Sequelize.literal((0, filter_helpers_1.getSortCustomFieldsSubQuery)(queryType, name, replacementKey)),
-            randomStr,
+            sequelize_typescript_1.Sequelize.literal(`(
+            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 = '${name}'
+                    WHERE cv.model_id = "${name}"."id"
+                          ${AND_DELIMITER}cd.name = :${replacemetKey}
+                          ) AS CustomFieldAggregation
+            )
+          `), randomStr,
         ]);
     });
     const orders = Object.entries(sort).map(([, sortObject]) => {

package/dist/utils/init.d.ts

@@ -1,7 +1,7 @@
-import type { CustomFieldOptions, ModelFetcher, Models } from '../types';
+import type { ModelFetcher, Models } from '../types';
 export declare const addHooks: (models: Models[], getModel: ModelFetcher, sadotOptions?: {
     useCustomFieldsEntries: boolean;
 }) => void;
 export declare const removeHooks: (models: Models[], getModel: ModelFetcher) => void;
-export declare const addScopes: (models: Models[], getModel: ModelFetcher, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => void;
+export declare const addScopes: (models: Models[], getModel: ModelFetcher) => void;
 export declare const applyCustomAssociation: (models: Models[]) => void;

package/dist/utils/init.js

@@ -78,7 +78,7 @@ const addAssociations = (model, modelName) => {
     // TBC: maybe can be removed
     models_1.CustomFieldValue.belongsTo(model, { foreignKey: 'modelId', as: modelName });
 };
-const addScopes = (models, getModel, options = { useCustomFieldsEntries: false }) => {
+const addScopes = (models, getModel) => {
     models.forEach(async ({ name, scopeAttributes }) => {
         try {
             const model = getModel(name);
@@ -92,8 +92,8 @@ const addScopes = (models, getModel, options = { useCustomFieldsEntries: false }
             // Necessary associations for the filtering scope
             addAssociations(model, name);
             // Add filter scope
-            model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, (0, scopes_1.customFieldsFilterScope)(name, options));
-            model.addScope(custom_fields_1.CUSTOM_FIELDS_SORT_SCOPE, (0, filter_1.customFieldsSortScope)(name, options));
+            model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, (0, scopes_1.customFieldsFilterScope)(name));
+            model.addScope(custom_fields_1.CUSTOM_FIELDS_SORT_SCOPE, (0, filter_1.customFieldsSortScope)(name));
         }
         catch (e) {
             logger_1.default.error(`Could not add custom fields scopes to model ${name}. `, e);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.10.3",
+  "version": "0.10.4-beta-74e8bd5c.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/hooks/create.ts

@@ -45,7 +45,7 @@ export const beforeCreate = (
   if (fieldsWithDefaultValue.length) {
     // eslint-disable-next-line no-param-reassign
     instance.customFields ||= {};
-    fieldsWithDefaultValue.filter((def) => (instance.customFields?.[def.name] === undefined)).forEach(({ name, defaultValue }) => {
+    fieldsWithDefaultValue.filter((def) => !(def.name in instance.customFields)).forEach(({ name, defaultValue }) => {
       // eslint-disable-next-line no-param-reassign
       instance.customFields[name] = defaultValue;
     });

package/src/hooks/enrich.ts

@@ -39,19 +39,15 @@ export const getCustomFieldEntriesByInstanceId = async ({
     options ?? {},
   );
 
-  const customFieldEntriesByInstanceId = Object.fromEntries(customFieldEntries.map((instanceEntries) => {
+  return customFieldEntries.reduce((valuesByInstanceId, instanceEntries) => {
     const { modelId, customFields } = instanceEntries?.dataValues ?? {};
     if (!modelId) {
-      return undefined;
+      return valuesByInstanceId;
     }
-    return [modelId, customFields];
-  }).filter(Boolean));
 
-  instancesIds.forEach((instanceId) => {
-    customFieldEntriesByInstanceId[instanceId] ??= {};
-  });
-
-  return customFieldEntriesByInstanceId;
+    valuesByInstanceId[modelId] = customFields ?? {};
+    return valuesByInstanceId;
+  }, {});
 };
 
 export const getValuesGroupByInstance = async ({
@@ -75,7 +71,9 @@ export const getValuesGroupByInstance = async ({
   // Group fields by modelId
   return customFieldValues.reduce((acc, v) => {
     const { modelId } = v;
-    acc[modelId] ??= [];
+    if (!acc[modelId]) {
+      acc[modelId] = [];
+    }
     acc[modelId].push(v);
     return acc;
   }, {});
@@ -181,11 +179,11 @@ const enrichResults = (
     const { id } = instance;
 
     const instanceValues = valuesGroupByInstance[id];
-    const serializedCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
+    const serializeCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
 
     const customFields = sadotOptions.useCustomFieldsEntries
       ? customFieldEntriesByInstanceId[id]
-      : serializedCustomFieldsValues;
+      : serializeCustomFieldsValues;
 
     scopeAttributes.forEach((attribute) => {
       const identifier = instance[attribute];

package/src/index.ts

@@ -37,7 +37,7 @@ const useCustomFields = async (
   // The order is important
   addHooks(models, getModel, { useCustomFieldsEntries });
   await initTables(sequelize, options.getUser, { useCustomFieldsEntries });
-  addScopes(models, getModel, { useCustomFieldsEntries });
+  addScopes(models, getModel);
   applyCustomAssociation(models);
   logger.debug('sadot - custom fields finished initializing with models', models);
   return sequelize;

package/src/repository/entries.ts

@@ -1,4 +1,3 @@
-/* eslint-disable no-param-reassign */
 import type {
   FindOptions,
   Includeable,
@@ -10,7 +9,6 @@ import type { ModelOptions } from '../types';
 import logger from '../utils/logger';
 import { MissingDefinitionError } from '../errors';
 import * as DefinitionRepo from './definition';
-import { formatFunctions } from './utils/formatValues';
 
 type CustomFieldEntriesModelOptions = ModelOptions & { include?: Includeable, transaction?: Transaction };
 
@@ -67,15 +65,6 @@ export const updateEntries = async (
     logger.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
   }
 
-  const definitionsByName = Object.fromEntries(fieldDefinitions.map((definition) => [definition.name, definition]));
-  // If we need to format the value before we save it
-  Object.entries(customFields)
-    .filter(([definitionName]) => formatFunctions[definitionsByName[definitionName].fieldType])
-    .forEach(([definitionName, value]) => {
-      const { fieldType } = definitionsByName[definitionName];
-      customFields[definitionName] = formatFunctions[fieldType](value);
-    });
-
   return CustomFieldEntries.upsert(
     {
       modelId,

package/src/repository/value.ts

@@ -5,7 +5,7 @@ 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';
+import { CustomFieldDefinitionType } from '../utils/constants';
 
 export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
   CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });
@@ -42,6 +42,19 @@ export const findValuesByModelIds = async (modelIds: string[], options?): Promis
   });
 };
 
+const formatFunctions = {
+  [CustomFieldDefinitionType.DATE]: (value) => {
+    if (value) {
+      const date = new Date(value);
+      if (date.toString() === 'Invalid Date') {
+        throw new Error(`Invalid date value: ${value}`);
+      }
+      return date.toISOString();
+    }
+    return null;
+  },
+};
+
 /**
  * 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.

package/src/scopes/filter.ts

@@ -1,26 +1,58 @@
 /* eslint-disable import/prefer-default-export */
-import { Op } from 'sequelize';
+import { Op, type WhereOptions } 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 representing possible condition values.
+ * Currently supporting strings and arrays of strings.
+ * More types to be added (TBA).
+ */
+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>;
+}
+
 type customFieldsFilterScopeParams = {
     replacementsMap: Record<string, string>;
     scopeValue: Record<string, ConditionValue>;
 }
 
+const isConditionStringArray = (input: any): input is string[] => Array.isArray(input) && typeof input[0] === 'string';
+const isBooleanString = (input: string): boolean => ['true', 'false'].includes(input.toString());
+const isDate = (input: any): input is Date => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
+
+const castValueToJsonb = (value: string, type: string) => `to_jsonb(${value}::${type})`;
+const castValueToJsonbText = (value: string) => castValueToJsonb(value, 'text');
+const castValueToJsonbBoolean = (value: string) => castValueToJsonb(value, 'boolean');
+const castValueToJsonbNumeric = (value: string) => castValueToJsonb(value, 'numeric');
+const castIfNeeded = (columnName: string, conditionValue: string): string => {
+  if (isDate(conditionValue)) {
+    return castValueToJsonb(columnName, 'timestamp');
+  }
+  return columnName;
+};
+const AND_DELIMITER = ' AND ';
+const OR_DELIMITER = ' OR ';
+const CD_TABLE_ALIAS = 'cd';
+const CD_NAME_COLUMN = `${CD_TABLE_ALIAS}.name`;
+const CV_TABLE_ALIAS = 'cv';
+const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
+
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -30,29 +62,68 @@ type customFieldsFilterScopeParams = {
  */
 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:
+    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;
   }).filter(Boolean);
   if (conditionsStrings.length === 0) {
     return {};
   }
-  const subQuery = getFilterCustomFieldsSubQuery(queryType, name, conditionsStrings);
+  const customFieldConditions = conditionsStrings.join(OR_DELIMITER);
+  const subQuery = `
+    SELECT cv.model_id
+    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 = '${name}'
+    WHERE ${customFieldConditions}
+    ${AND_DELIMITER}cv.deleted_at IS NULL${AND_DELIMITER}cd.deleted_at IS NULL
+    GROUP BY cv.model_id
+    HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
+  `.replace(/\n/g, '');
 
   return {
     where: {
@@ -68,21 +139,27 @@ 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(
+    const replacemetKey = Object.keys(replacementsMap).find(
       (randomString) => replacementsMap[randomString] === key,
     );
     return ([
-      Sequelize.literal(getSortCustomFieldsSubQuery(queryType, name, replacementKey)),
-      randomStr,
+      Sequelize.literal(`(
+            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 = '${name}'
+                    WHERE cv.model_id = "${name}"."id"
+                          ${AND_DELIMITER}cd.name = :${replacemetKey}
+                          ) AS CustomFieldAggregation
+            )
+          `), randomStr,
     ]);
   });
 

package/src/utils/init.ts

@@ -16,7 +16,7 @@ import {
 } from '../hooks';
 import { customFieldsFilterScope } from '../scopes';
 import logger from './logger';
-import type { CustomFieldOptions, ModelFetcher, Models } from '../types';
+import type { ModelFetcher, Models } from '../types';
 import { customFieldsSortScope } from '../scopes/filter';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
@@ -90,7 +90,7 @@ const addAssociations = (model: ModelCtor, modelName: string): void => {
   CustomFieldValue.belongsTo(model, { foreignKey: 'modelId', as: modelName });
 };
 
-export const addScopes = (models: Models[], getModel: ModelFetcher, options: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false }): void => {
+export const addScopes = (models: Models[], getModel: ModelFetcher): void => {
   models.forEach(async ({ name, scopeAttributes }) => {
     try {
       const model = getModel(name);
@@ -104,8 +104,8 @@ export const addScopes = (models: Models[], getModel: ModelFetcher, options: Pic
       // Necessary associations for the filtering scope
       addAssociations(model, name);
       // Add filter scope
-      model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, customFieldsFilterScope(name, options));
-      model.addScope(CUSTOM_FIELDS_SORT_SCOPE, customFieldsSortScope(name, options));
+      model.addScope(CUSTOM_FIELDS_FILTER_SCOPE, customFieldsFilterScope(name));
+      model.addScope(CUSTOM_FIELDS_SORT_SCOPE, customFieldsSortScope(name));
     } catch (e) {
       logger.error(`Could not add custom fields scopes to model ${name}. `, e);
     }

package/dist/repository/utils/formatValues.d.ts

@@ -1,3 +0,0 @@
-export declare const formatFunctions: {
-    date: (value: any) => string;
-};

package/dist/repository/utils/formatValues.js

@@ -1,16 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatFunctions = void 0;
-const constants_1 = require("../../utils/constants");
-exports.formatFunctions = {
-    [constants_1.CustomFieldDefinitionType.DATE]: (value) => {
-        if (value) {
-            const date = new Date(value);
-            if (date.toString() === 'Invalid Date') {
-                throw new Error(`Invalid date value: ${value}`);
-            }
-            return date.toISOString();
-        }
-        return null;
-    },
-};

package/dist/scopes/helpers/filter.helpers.d.ts

@@ -1,42 +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 declare enum SubQueryType {
-    VALUES = "values",
-    ENTRIES = "entries"
-}
-export declare const isConditionStringArray: (input: any) => input is string[];
-export declare const isBooleanString: (input: string) => boolean;
-export declare const isDate: (input: any) => input is Date;
-export declare const castValueToJsonb: (value: string, type: string) => string;
-export declare const castValueToJsonbText: (value: string) => string;
-export declare const castValueToJsonbBoolean: (value: string) => string;
-export declare const castValueToJsonbNumeric: (value: string) => string;
-export declare const castIfNeeded: (columnName: string, conditionValue: string) => string;
-export declare const AND_DELIMITER = " AND ";
-export declare const OR_DELIMITER = " OR ";
-export declare const CD_TABLE_ALIAS = "cd";
-export declare const CD_NAME_COLUMN = "cd.name";
-export declare const CV_TABLE_ALIAS = "cv";
-export declare const CV_VALUE_COLUMN = "cv.value";
-export declare const CE_TABLE_ALIAS = "ce";
-export declare const getFilterCustomFieldsSubQuery: (queryType: SubQueryType, modelType: string, conditionsStrings: Array<string | boolean>) => string;
-export declare const getSortCustomFieldsSubQuery: (queryType: SubQueryType, modelType: string, replacementKey: string) => string;
-export declare const formatConditionsForValues: (key: string, condition: ConditionValue, reverseReplacementsMap: Map<string, string>) => string | false;
-export declare const formatConditionsForEntries: (key: string, condition: ConditionValue, reverseReplacementsMap: Map<string, string>) => string | false;

package/dist/scopes/helpers/filter.helpers.js

@@ -1,204 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatConditionsForEntries = exports.formatConditionsForValues = exports.getSortCustomFieldsSubQuery = exports.getFilterCustomFieldsSubQuery = exports.CE_TABLE_ALIAS = exports.CV_VALUE_COLUMN = exports.CV_TABLE_ALIAS = exports.CD_NAME_COLUMN = exports.CD_TABLE_ALIAS = exports.OR_DELIMITER = exports.AND_DELIMITER = exports.castIfNeeded = exports.castValueToJsonbNumeric = exports.castValueToJsonbBoolean = exports.castValueToJsonbText = exports.castValueToJsonb = exports.isDate = exports.isBooleanString = exports.isConditionStringArray = exports.SubQueryType = void 0;
-var SubQueryType;
-(function (SubQueryType) {
-    SubQueryType["VALUES"] = "values";
-    SubQueryType["ENTRIES"] = "entries";
-})(SubQueryType || (exports.SubQueryType = SubQueryType = {}));
-const isConditionStringArray = (input) => Array.isArray(input) && typeof input[0] === 'string';
-exports.isConditionStringArray = isConditionStringArray;
-const isBooleanString = (input) => ['true', 'false'].includes(input.toString());
-exports.isBooleanString = isBooleanString;
-const isDate = (input) => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
-exports.isDate = isDate;
-const castValueToJsonb = (value, type) => `to_jsonb(${value}::${type})`;
-exports.castValueToJsonb = castValueToJsonb;
-const castValueToJsonbText = (value) => (0, exports.castValueToJsonb)(value, 'text');
-exports.castValueToJsonbText = castValueToJsonbText;
-const castValueToJsonbBoolean = (value) => (0, exports.castValueToJsonb)(value, 'boolean');
-exports.castValueToJsonbBoolean = castValueToJsonbBoolean;
-const castValueToJsonbNumeric = (value) => (0, exports.castValueToJsonb)(value, 'numeric');
-exports.castValueToJsonbNumeric = castValueToJsonbNumeric;
-const castIfNeeded = (columnName, conditionValue) => {
-    if ((0, exports.isDate)(conditionValue)) {
-        return (0, exports.castValueToJsonb)(columnName, 'timestamp');
-    }
-    return columnName;
-};
-exports.castIfNeeded = castIfNeeded;
-exports.AND_DELIMITER = ' AND ';
-exports.OR_DELIMITER = ' OR ';
-exports.CD_TABLE_ALIAS = 'cd';
-exports.CD_NAME_COLUMN = `${exports.CD_TABLE_ALIAS}.name`;
-exports.CV_TABLE_ALIAS = 'cv';
-exports.CV_VALUE_COLUMN = `${exports.CV_TABLE_ALIAS}.value`;
-exports.CE_TABLE_ALIAS = 'ce';
-const getSingleConditionWithOperator = (value, operator, replacementKey, reverseReplacementsMap) => {
-    let type = 'text';
-    if ((0, exports.isDate)(value)) {
-        type = 'date';
-    }
-    else if (!Number.isNaN(Number(value))) {
-        type = 'numeric';
-    }
-    else if ((0, exports.isBooleanString)(value)) {
-        type = 'boolean';
-    }
-    const replacedValue = reverseReplacementsMap.get(value);
-    return `(jsonb_extract_path_text(${exports.CE_TABLE_ALIAS}.custom_fields, :${replacementKey})::${type}) ${operator} :${replacedValue}`;
-};
-const getFormattedValue = (value) => {
-    let formattedValue = value;
-    if ((0, exports.isBooleanString)(value)) {
-        formattedValue = value === 'true';
-    }
-    else if (!Number.isNaN(Number(value))) {
-        formattedValue = Number(value);
-    }
-    return formattedValue;
-};
-const getJSONSubQuery = (value, key) => {
-    const formattedValue = getFormattedValue(value);
-    const jsonQuery = JSON.stringify({ [key]: formattedValue });
-    let jsonQueryWithStringBoolean;
-    if ((0, exports.isBooleanString)(value)) {
-        jsonQueryWithStringBoolean = `${exports.CE_TABLE_ALIAS}.custom_fields @> '${JSON.stringify({ [key]: value })}'`;
-    }
-    return `
-    (
-      ${jsonQueryWithStringBoolean ? `${jsonQueryWithStringBoolean} OR` : ''}
-      ${exports.CE_TABLE_ALIAS}.custom_fields @> '${jsonQuery}'
-    )
-  `;
-};
-const getFilterCustomFieldsSubQuery = (queryType, modelType, conditionsStrings) => {
-    switch (queryType) {
-        case SubQueryType.VALUES:
-            return `
-        SELECT ${exports.CV_TABLE_ALIAS}.model_id
-        FROM custom_field_values AS ${exports.CV_TABLE_ALIAS}
-        INNER JOIN custom_field_definitions AS ${exports.CD_TABLE_ALIAS} ON ${exports.CV_TABLE_ALIAS}.custom_field_definition_id = ${exports.CD_TABLE_ALIAS}.id
-        ${exports.AND_DELIMITER}${exports.CD_TABLE_ALIAS}.model_type = '${modelType}'
-        WHERE ${conditionsStrings.join(exports.OR_DELIMITER)}
-        ${exports.AND_DELIMITER}${exports.CV_TABLE_ALIAS}.deleted_at IS NULL${exports.AND_DELIMITER}${exports.CD_TABLE_ALIAS}.deleted_at IS NULL
-        GROUP BY ${exports.CV_TABLE_ALIAS}.model_id
-        HAVING COUNT(DISTINCT ${exports.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(exports.AND_DELIMITER)}
-      `;
-        default:
-            throw new Error('Invalid query type');
-    }
-};
-exports.getFilterCustomFieldsSubQuery = getFilterCustomFieldsSubQuery;
-const getSortCustomFieldsSubQuery = (queryType, modelType, replacementKey) => {
-    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
-                      ${exports.AND_DELIMITER}cd.model_type = '${modelType}'
-                      WHERE cv.model_id = "${modelType}"."id"
-                            ${exports.AND_DELIMITER}cd.name = :${replacementKey}
-                            ) AS CustomFieldAggregation
-              )
-            `;
-        case SubQueryType.ENTRIES:
-            return `(
-        SELECT
-            customFields.value
-        FROM
-            custom_field_entries AS ${exports.CE_TABLE_ALIAS},
-            jsonb_each_text(custom_fields) AS customFields
-        WHERE
-          customFields.key = :${replacementKey}${exports.AND_DELIMITER}
-          ${exports.CE_TABLE_ALIAS}.model_type = '${modelType}'${exports.AND_DELIMITER}
-          ${exports.CE_TABLE_ALIAS}.model_id = "${modelType}"."id"
-        )
-      `;
-        default:
-            throw new Error('Invalid query type');
-    }
-};
-exports.getSortCustomFieldsSubQuery = getSortCustomFieldsSubQuery;
-const formatConditionsForValues = (key, condition, reverseReplacementsMap) => {
-    const replacementKey = reverseReplacementsMap.get(key);
-    if (!replacementKey) {
-        return false;
-    }
-    const columnCondition = `(${exports.CD_NAME_COLUMN} = :${replacementKey})`;
-    if (Array.isArray(condition)) {
-        if (condition.length === 0) {
-            // if empty array, the condition is ignored
-            return false;
-        }
-        if ((0, exports.isConditionStringArray)(condition)) {
-            const values = condition.flatMap((v) => {
-                const valRandom = reverseReplacementsMap.get(v);
-                if ((0, exports.isBooleanString)(v)) {
-                    return [(0, exports.castValueToJsonbText)(`:${valRandom}`), (0, exports.castValueToJsonbBoolean)(`:${valRandom}`)];
-                }
-                if (!Number.isNaN(Number(v))) {
-                    return (0, exports.castValueToJsonbNumeric)(`:${valRandom}`);
-                }
-                return (0, exports.castValueToJsonbText)(`:${valRandom}`);
-            }).join(',');
-            return `(${columnCondition}${exports.AND_DELIMITER}${exports.CV_VALUE_COLUMN} IN (${values}))`;
-        }
-        return condition.map((c) => {
-            const valRep = reverseReplacementsMap.get(c.value);
-            const valueAsJsonb = (0, exports.castValueToJsonbText)(`:${valRep}`);
-            return `(${columnCondition}${exports.AND_DELIMITER}${(0, exports.castIfNeeded)(exports.CV_VALUE_COLUMN, c.value)} ${c.operator} ${valueAsJsonb})`;
-        }).join(exports.AND_DELIMITER);
-    }
-    if (typeof condition === 'string' || typeof condition === 'number') {
-        const conditionRep = reverseReplacementsMap.get(condition);
-        const valueAsJsonb = !Number.isNaN(Number(condition)) ? (0, exports.castValueToJsonbNumeric)(`:${conditionRep}`) : (0, exports.castValueToJsonbText)(`:${conditionRep}`);
-        const valueAsJsonbBoolean = (0, exports.isBooleanString)(condition) ? `${exports.OR_DELIMITER}${exports.CV_VALUE_COLUMN} = ${(0, exports.castValueToJsonbBoolean)(`:${conditionRep}`)}` : '';
-        return `(${columnCondition}${exports.AND_DELIMITER}(${(0, exports.castIfNeeded)(exports.CV_VALUE_COLUMN, condition)} = ${valueAsJsonb}${valueAsJsonbBoolean}))`;
-    }
-    if (condition?.operator) {
-        const valueRep = reverseReplacementsMap.get(condition.value);
-        const valueAsJsonb = (0, exports.castValueToJsonbText)(`:${valueRep}`);
-        return `( ${columnCondition}${exports.AND_DELIMITER}${(0, exports.castIfNeeded)(exports.CV_VALUE_COLUMN, condition.value)} ${condition.operator} ${valueAsJsonb})`;
-    }
-    return false;
-};
-exports.formatConditionsForValues = formatConditionsForValues;
-const formatConditionsForEntries = (key, condition, reverseReplacementsMap) => {
-    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 ((0, exports.isConditionStringArray)(condition)) {
-            const values = condition.map((value) => getJSONSubQuery(value, key)).join(`${exports.OR_DELIMITER}\n`);
-            return `( ${values})`;
-        }
-        return condition.map((c) => getSingleConditionWithOperator(c.value, c.operator, replacementKey, reverseReplacementsMap)).join(exports.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;
-};
-exports.formatConditionsForEntries = formatConditionsForEntries;

package/src/repository/utils/formatValues.ts

@@ -1,14 +0,0 @@
-import { CustomFieldDefinitionType } from '../../utils/constants';
-
-export const formatFunctions = {
-  [CustomFieldDefinitionType.DATE]: (value) => {
-    if (value) {
-      const date = new Date(value);
-      if (date.toString() === 'Invalid Date') {
-        throw new Error(`Invalid date value: ${value}`);
-      }
-      return date.toISOString();
-    }
-    return null;
-  },
-};

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;
-};