@autofleet/sadot 1.1.3 → 1.1.4-beta

package/dist/repository/value.js

@@ -1,2 +1,124 @@
-import e from"../utils/logger/index.js";import{MissingDefinitionError as t}from"../errors/index.js";import{findAll as n}from"./definition.js";import r from"../models/CustomFieldValue.js";import"../models/index.js";import{formatFunctions as i}from"./utils/formatValues.js";const a=async(e,t)=>{let{transaction:n}=t;return r.findAll({where:{modelId:e},transaction:n,raw:!0,nest:!0})},o=async(a,o,s,c,l={})=>{let u=Object.keys(c);e.debug(`custom-fields: updating values for ${a} ${o}`,{names:u,optionsKeys:l?Object.keys(l):null,valuesToUpdate:c,identifiers:s});let{modelOptions:d,transaction:f}=l,p=await n({modelType:a,name:u,...!l.modelOptions?.useEntityIdFromInclude&&{entityId:s}},{withDisabled:!0,transaction:f,include:d.include?.(s)})??[],m=p.filter(e=>e.disabled);if(p.length!==u.length)throw e.warn(`custom-fields: missing definitions for ${a} ${o}`,{names:u,fieldDefinitions:p}),new t(u.filter(e=>!p.some(t=>t.name===e)));let h=m?.map(e=>e.name)||[],g=u.filter(e=>h.includes(e));g?.length>0&&e.warn(`custom-fields: trying to update disabled values: ${g.join(`, `)}`);let _=u.map(e=>{let t=p.find(t=>t.name===e),n=i[t.fieldType],r=n?n(c[e]):c[e];return{modelId:o,updatedAt:new Date,customFieldDefinitionId:t.id,value:r===void 0?t.defaultValue:r}});return Promise.all(_.map(async e=>{let[t]=await r.upsert(e,{transaction:l.transaction});return t}))};export{a as findValuesByModelIds,o as updateValues};
-//# sourceMappingURL=value.js.map
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteValue = exports.updateValues = exports.findValuesByModelIds = exports.findValuesByModelId = exports.findAllValues = exports.create = exports.findByModelIdAndDefinition = void 0;
+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 findByModelIdAndDefinition = async (modelId, customFieldDefinitionId) => models_1.CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [models_1.CustomFieldDefinition] });
+exports.findByModelIdAndDefinition = findByModelIdAndDefinition;
+const create = async (data, withAssociations = false) => {
+    const created = await models_1.CustomFieldValue.create(data);
+    if (withAssociations) {
+        const createdWithAssociations = await (0, exports.findByModelIdAndDefinition)(created.modelId, created.customFieldDefinitionId);
+        return createdWithAssociations?.[0];
+    }
+    return created;
+};
+exports.create = create;
+const findAllValues = async () => models_1.CustomFieldValue.findAll({ include: [models_1.CustomFieldDefinition] });
+exports.findAllValues = findAllValues;
+/**
+ * Get all values for model instance id (with their definitions)
+ * @param modelId
+ * @returns CustomFieldValue[]
+ */
+const findValuesByModelId = async (modelId) => models_1.CustomFieldValue.findAll({ where: { modelId }, include: [models_1.CustomFieldDefinition] });
+exports.findValuesByModelId = findValuesByModelId;
+/**
+* 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.
+*/
+const findValuesByModelIds = async (modelIds, options) => {
+    const { transaction } = options;
+    return models_1.CustomFieldValue.findAll({
+        where: { modelId: modelIds },
+        transaction,
+        raw: true,
+        nest: true,
+    });
+};
+exports.findValuesByModelIds = findValuesByModelIds;
+/**
+ * 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
+ */
+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,
+        optionsKeys: options ? Object.keys(options) : null,
+        valuesToUpdate,
+        identifiers,
+    });
+    const { modelOptions, transaction } = options;
+    const where = {
+        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_1.default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });
+        const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
+        throw new errors_1.MissingDefinitionError(missingDefinitions);
+    }
+    const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+    const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
+    if (valuesWithDisabledDefinitions?.length > 0) {
+        logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
+    }
+    const values = names.map((name) => {
+        const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
+        const formatFunction = formatValues_1.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 models_1.CustomFieldValue.upsert(value, {
+            transaction: options.transaction,
+        });
+        return cfv;
+    }));
+};
+exports.updateValues = updateValues;
+const deleteValue = (id, options = {}) => models_1.CustomFieldValue.update({ deletedAt: new Date() }, {
+    where: { id },
+    transaction: options.transaction,
+});
+exports.deleteValue = deleteValue;

package/dist/scopes/filter.d.ts

@@ -1,23 +1,30 @@
-import { CustomFieldOptions } from "../types/index.js";
-import { ConditionValue } from "./helpers/filter.helpers.js";
-import { customFields } from "@autofleet/common-types";
-import { Literal } from "sequelize/types/utils";
-
-//#region src/scopes/filter.d.ts
-
-declare const customFieldsSortScope: (name: string, options?: Pick<CustomFieldOptions, "useCustomFieldsEntries">) => ({
-  replacementsMap,
-  scopeValue: sort
-}: {
-  replacementsMap: Record<string, string>;
-  scopeValue: Record<string, ConditionValue>;
+import type { CustomFieldOptions } from '../types';
+import { type ConditionValue, type CustomFieldFilterOptions } from './helpers/filter.helpers';
+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 declare const customFieldsFilterScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap: replacements, scopeValue: conditions }: customFieldsFilterScopeParams) => CustomFieldFilterOptions;
+export declare const scopeName: "filterByCustomFields";
+export declare const customFieldsSortScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap, scopeValue: sort }: {
+    replacementsMap: any;
+    scopeValue: any;
 }) => {
-  attributes: {
-    include: (string | Literal)[][];
-  };
-  order: Literal[];
-  replacements: Record<string, string>;
-} | Record<string, never>;
-//#endregion
-export { customFieldsSortScope };
-//# sourceMappingURL=filter.d.ts.map
+    attributes?: undefined;
+    order?: undefined;
+    replacements?: undefined;
+} | {
+    attributes: {
+        include: (string | import("sequelize/types/utils").Literal)[][];
+    };
+    order: import("sequelize/types/utils").Literal[];
+    replacements: any;
+};
+export {};

package/dist/scopes/filter.js

@@ -1,2 +1,75 @@
-import{generateRandomString as e}from"../utils/helpers/index.js";import{SubQueryType as t,formatConditionsForEntries as n,formatConditionsForValues as r,getFilterCustomFieldsSubQuery as i,getSortCustomFieldsSubQuery as a}from"./helpers/filter.helpers.js";import{Op as o}from"sequelize";import{Sequelize as s}from"sequelize-typescript";import{customFields as c}from"@autofleet/common-types";const l=(e,a)=>({replacementsMap:c,scopeValue:l})=>{if(!l||Object.keys(l).length===0)return{};let u=a?.useCustomFieldsEntries?t.ENTRIES:t.VALUES,d=new Map(Object.entries(c).map(([e,t])=>[t,e])),f=Object.entries(l).map(([e,i])=>{switch(u){case t.ENTRIES:return n(e,i,d);case t.VALUES:return r(e,i,d);default:return!1}}).filter(Boolean);if(f.length===0)return{};let p=i(u,e,f);return{where:{id:{[o.in]:s.literal(`(${p})`)}},replacements:c}};c.CUSTOM_FIELDS_FILTER_SCOPE;const u=(n,r)=>({replacementsMap:i,scopeValue:o})=>{if(!o||o.length===0)return{};let c=r?.useCustomFieldsEntries?t.ENTRIES:t.VALUES,l=e(),u=Object.entries(o).map(([e])=>{let t=Object.keys(i).find(t=>i[t]===e);return[s.literal(a(c,n,t)),l]}),d=Object.entries(o).map(([,e])=>{let t=typeof e==`string`?e:Object.values(e)[0];return s.literal(`"${l}" ${t||`ASC`}`)});return{attributes:{include:u},order:d,replacements:i}};export{l as customFieldsFilterScope,u as customFieldsSortScope};
-//# sourceMappingURL=filter.js.map
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customFieldsSortScope = exports.scopeName = exports.customFieldsFilterScope = void 0;
+/* eslint-disable import/prefer-default-export */
+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;
+/**
+ * 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.
+ */
+const customFieldsFilterScope = (name, options) => ({ 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:
+                return false;
+        }
+    }).filter(Boolean);
+    if (conditionsStrings.length === 0) {
+        return {};
+    }
+    const subQuery = (0, filter_helpers_1.getFilterCustomFieldsSubQuery)(queryType, name, conditionsStrings);
+    return {
+        where: {
+            id: {
+                [sequelize_1.Op.in]: sequelize_typescript_1.Sequelize.literal(`(${subQuery})`),
+            },
+        },
+        replacements,
+    };
+};
+exports.customFieldsFilterScope = customFieldsFilterScope;
+exports.scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
+const customFieldsSortScope = (name, options) => ({ 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);
+        return ([
+            sequelize_typescript_1.Sequelize.literal((0, filter_helpers_1.getSortCustomFieldsSubQuery)(queryType, name, replacementKey)),
+            randomStr,
+        ]);
+    });
+    const orders = Object.entries(sort).map(([, sortObject]) => {
+        const direction = typeof sortObject === 'string' ? sortObject : Object.values(sortObject)[0];
+        return sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${direction || 'ASC'}`);
+    });
+    return {
+        attributes: {
+            include: includes,
+        },
+        order: orders,
+        replacements: replacementsMap,
+    };
+};
+exports.customFieldsSortScope = customFieldsSortScope;

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

@@ -1,17 +1,42 @@
-import { WhereOptions } from "sequelize";
-
-//#region src/scopes/helpers/filter.helpers.d.ts
-
+import type { WhereOptions } from 'sequelize';
 /**
-* Type representing possible condition values.
-* Currently supporting strings and arrays of strings.
-* More types to be added (TBA).
-*/
-interface ConditionWithOperator {
-  operator: string;
-  value: string;
+ * 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"
 }
-type ConditionValue = ConditionWithOperator | ConditionWithOperator[] | string | string[];
-//#endregion
-export { ConditionValue };
-//# sourceMappingURL=filter.helpers.d.ts.map
+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,18 +1,92 @@
-let e=function(e){return e.VALUES=`values`,e.ENTRIES=`entries`,e}({});const t=e=>Array.isArray(e)&&typeof e[0]==`string`,n=e=>[`true`,`false`].includes(e.toString()),r=e=>e instanceof Date||Object.prototype.toString.call(e)===`[object Date]`,i=(e,t)=>`to_jsonb(${e}::${t})`,a=e=>i(e,`text`),o=e=>i(e,`boolean`),s=e=>i(e,`numeric`),c=(e,t)=>r(t)?i(e,`timestamp`):e,l=` AND `,u=` OR `,d=`cv.value`,f=(e,t,i,a)=>{let o=`text`;r(e)?o=`date`:Number.isNaN(Number(e))?n(e)&&(o=`boolean`):o=`numeric`;let s=a.get(e);return`(jsonb_extract_path_text(ce.custom_fields, :${i})::${o}) ${t} :${s}`},p=e=>{let t=e;return n(e)?t=e===`true`:Number.isNaN(Number(e))||(t=Number(e)),t},m=(e,t)=>{let r=p(e),i=JSON.stringify({[t]:r}),a;return n(e)&&(a=`ce.custom_fields @> '${JSON.stringify({[t]:e})}'`),`
+"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 `
     (
-      ${a?`${a} OR`:``}
-      ce.custom_fields @> '${i}'
+      ${jsonQueryWithStringBoolean ? `${jsonQueryWithStringBoolean} OR` : ''}
+      ${exports.CE_TABLE_ALIAS}.custom_fields @> '${jsonQuery}'
     )
-  `},h=(t,n,r)=>{switch(t){case e.VALUES:return`
-        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
-        ${l}cd.model_type = '${n}'
-        WHERE ${r.join(u)}
-        ${l}cv.deleted_at IS NULL${l}cd.deleted_at IS NULL
-        GROUP BY cv.model_id
-        HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${r.length}
-      `.replace(/\n/g,``);case e.ENTRIES:return`
+  `;
+};
+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
@@ -20,27 +94,111 @@ let e=function(e){return e.VALUES=`values`,e.ENTRIES=`entries`,e}({});const t=e=
         AND ce.entity_id = cfd.entity_id
         WHERE
           cfd.deleted_at IS NULL AND
-          ${r.join(l)}
-      `;default:throw Error(`Invalid query type`)}},g=(t,n,r)=>{switch(t){case e.VALUES:return`(
+          ${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
-                      ${l}cd.model_type = '${n}'
-                      WHERE cv.model_id = "${n}"."id"
-                            ${l}cd.name = :${r}
+                      ${exports.AND_DELIMITER}cd.model_type = '${modelType}'
+                      WHERE cv.model_id = "${modelType}"."id"
+                            ${exports.AND_DELIMITER}cd.name = :${replacementKey}
                             ) AS CustomFieldAggregation
               )
-            `;case e.ENTRIES:return`(
+            `;
+        case SubQueryType.ENTRIES:
+            return `(
         SELECT
             customFields.value
         FROM
-            custom_field_entries AS ce,
+            custom_field_entries AS ${exports.CE_TABLE_ALIAS},
             jsonb_each_text(custom_fields) AS customFields
         WHERE
-          customFields.key = :${r}${l}
-          ce.model_type = '${n}'${l}
-          ce.model_id = "${n}"."id"
+          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 Error(`Invalid query type`)}},_=(e,r,i)=>{let f=i.get(e);if(!f)return!1;let p=`(cd.name = :${f})`;if(Array.isArray(r))return r.length===0?!1:t(r)?`(${p}${l}${d} IN (${r.flatMap(e=>{let t=i.get(e);return n(e)?[a(`:${t}`),o(`:${t}`)]:Number.isNaN(Number(e))?a(`:${t}`):s(`:${t}`)}).join(`,`)}))`:r.map(e=>{let t=a(`:${i.get(e.value)}`);return`(${p}${l}${c(d,e.value)} ${e.operator} ${t})`}).join(l);if(typeof r==`string`||typeof r==`number`){let e=i.get(r),t=Number.isNaN(Number(r))?a(`:${e}`):s(`:${e}`),f=n(r)?`${u}${d} = ${o(`:${e}`)}`:``;return`(${p}${l}(${c(d,r)} = ${t}${f}))`}if(r?.operator){let e=a(`:${i.get(r.value)}`);return`( ${p}${l}${c(d,r.value)} ${r.operator} ${e})`}return!1},v=(e,n,r)=>{let i=r.get(e);return i?Array.isArray(n)?n.length===0?!1:t(n)?`( ${n.map(t=>m(t,e)).join(`${u}\n`)})`:n.map(e=>f(e.value,e.operator,i,r)).join(l):typeof n==`string`||typeof n==`number`?m(n,e):n?.operator?f(n.value,n.operator,i,r):!1:!1};export{e as SubQueryType,v as formatConditionsForEntries,_ as formatConditionsForValues,h as getFilterCustomFieldsSubQuery,g as getSortCustomFieldsSubQuery};
-//# sourceMappingURL=filter.helpers.js.map
+      `;
+        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/dist/scopes/index.d.ts

@@ -0,0 +1,2 @@
+import { customFieldsFilterScope } from './filter';
+export { customFieldsFilterScope, };

package/dist/scopes/index.js

@@ -1 +1,6 @@
-import{customFieldsFilterScope as e}from"./filter.js";export{};
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.customFieldsFilterScope = void 0;
+/* eslint-disable import/prefer-default-export */
+const filter_1 = require("./filter");
+Object.defineProperty(exports, "customFieldsFilterScope", { enumerable: true, get: function () { return filter_1.customFieldsFilterScope; } });

package/dist/tests/api/test-api.d.ts

@@ -0,0 +1,2 @@
+declare const app: import("express-serve-static-core").Express;
+export default app;

package/dist/tests/api/test-api.js

@@ -0,0 +1,38 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const express_1 = __importDefault(require("express"));
+const node_common_1 = require("@autofleet/node-common");
+const logger_1 = __importDefault(require("../../utils/logger"));
+const models_1 = require("../../models");
+const app = (0, express_1.default)();
+app.use(express_1.default.json());
+const api = (0, node_common_1.Router)({ logger: logger_1.default });
+api.get('/v1/test-models', async (req, res) => {
+    const testModels = await models_1.TestModel.findAll();
+    return res.json(testModels);
+});
+api.get('/v1/test-models/:testModelId', async (req, res) => {
+    const { params: { testModelId } } = req;
+    const testModel = await models_1.TestModel.findByPk(testModelId);
+    return res.json(testModel);
+});
+api.post('/v1/test-models', async (req, res) => {
+    const { body } = req;
+    const testModel = await models_1.TestModel.create(body);
+    return res.json(testModel);
+});
+api.patch('/v1/test-models/:testModelId', async (req, res) => {
+    const { body, params: { testModelId } } = req;
+    const testModel = await models_1.TestModel.update(body, {
+        where: {
+            id: testModelId,
+        },
+        returning: true,
+    });
+    return res.json(testModel[1][0]);
+});
+app.use('/api', api);
+exports.default = app;

package/dist/tests/functional/searching/index.d.ts

@@ -0,0 +1,8 @@
+interface CustomFieldsSearchTestFlowInput {
+    fieldType: string;
+    fieldValue: string | number;
+    searchTerm: string;
+    expectedNumberOfQueryResults: number;
+}
+declare const customFieldsSearchTestFlow: ({ fieldType, fieldValue, searchTerm, expectedNumberOfQueryResults, }: CustomFieldsSearchTestFlowInput) => Promise<void>;
+export default customFieldsSearchTestFlow;