@autofleet/sadot 0.10.3-beta-ab27bd53.0 → 0.10.3

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) => !(def.name in instance.customFields)).forEach(({ name, defaultValue }) => {
+        fieldsWithDefaultValue.filter((def) => (instance.customFields?.[def.name] === undefined)).forEach(({ name, defaultValue }) => {
             // eslint-disable-next-line no-param-reassign
             instance.customFields[name] = defaultValue;
         });

package/dist/hooks/enrich.d.ts

@@ -1,7 +1,30 @@
-import type { ModelOptions } from '../types';
+import type { Transaction } from 'sequelize';
+import type CustomFieldValue from '../models/CustomFieldValue';
+import type { CustomFieldOptions, ModelOptions } from '../types';
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
+type CustomFieldEntries = Record<string, any>;
+interface GetValuesGroupByInstanceResponse {
+    [modelId: string]: CustomFieldValue[];
+}
+interface GetCustomFieldEntriesByInstanceIdResponse {
+    [modelId: string]: CustomFieldEntries;
+}
+export declare const getCustomFieldEntriesByInstanceId: ({ instancesIds, options, sadotOptions, }: {
+    instancesIds: string[];
+    options?: {
+        transaction: Transaction;
+    };
+    sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>;
+}) => Promise<GetCustomFieldEntriesByInstanceIdResponse>;
+export declare const getValuesGroupByInstance: ({ instancesIds, options, sadotOptions, }: {
+    instancesIds: string[];
+    options?: {
+        transaction: Transaction;
+    };
+    sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>;
+}) => Promise<GetValuesGroupByInstanceResponse>;
 /**
  * A hook to attach the custom fields when fetching a model instances.
  */
-declare const enrichResults: (modelType: string, scopeAttributes: string[], hookType?: SupportedHookTypes, modelOptions?: ModelOptions) => (instancesOrInstance: any | any[], options: any) => Promise<void>;
+declare const enrichResults: (modelType: string, scopeAttributes: string[], hookType?: SupportedHookTypes, modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instancesOrInstance: any | any[], options: any) => Promise<void>;
 export default enrichResults;

package/dist/hooks/enrich.js

@@ -26,10 +26,43 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-/* eslint-disable no-param-reassign */
+exports.getValuesGroupByInstance = exports.getCustomFieldEntriesByInstanceId = void 0;
 const ValueRepo = __importStar(require("../repository/value"));
 const DefinitionRepo = __importStar(require("../repository/definition"));
+const EntriesRepo = __importStar(require("../repository/entries"));
 const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+const getCustomFieldEntriesByInstanceId = async ({ instancesIds, options, sadotOptions, }) => {
+    if (!sadotOptions.useCustomFieldsEntries) {
+        return {};
+    }
+    const customFieldEntries = await EntriesRepo.findEntriesByModelIds(instancesIds, options ?? {});
+    const customFieldEntriesByInstanceId = Object.fromEntries(customFieldEntries.map((instanceEntries) => {
+        const { modelId, customFields } = instanceEntries?.dataValues ?? {};
+        if (!modelId) {
+            return undefined;
+        }
+        return [modelId, customFields];
+    }).filter(Boolean));
+    instancesIds.forEach((instanceId) => {
+        customFieldEntriesByInstanceId[instanceId] ?? (customFieldEntriesByInstanceId[instanceId] = {});
+    });
+    return customFieldEntriesByInstanceId;
+};
+exports.getCustomFieldEntriesByInstanceId = getCustomFieldEntriesByInstanceId;
+const getValuesGroupByInstance = async ({ instancesIds, options, sadotOptions, }) => {
+    if (sadotOptions.useCustomFieldsEntries) {
+        return {};
+    }
+    const customFieldValues = await ValueRepo.findValuesByModelIds(instancesIds, options ?? {});
+    // Group fields by modelId
+    return customFieldValues.reduce((acc, v) => {
+        const { modelId } = v;
+        acc[modelId] ?? (acc[modelId] = []);
+        acc[modelId].push(v);
+        return acc;
+    }, {});
+};
+exports.getValuesGroupByInstance = getValuesGroupByInstance;
 /**
  * Serialize custom fields value into the format of {[name] -> [fieldData]}
  */
@@ -44,7 +77,7 @@ const serializeCustomFields = (customFieldValues, customFieldDefinitionsHash) =>
 /**
  * A hook to attach the custom fields when fetching a model instances.
  */
-const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}) => async (instancesOrInstance, options) => {
+const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instancesOrInstance, options) => {
     if (options.originalAttributes?.length > 0
         && !options.originalAttributes?.includes?.('customFields')) {
         return;
@@ -80,25 +113,25 @@ const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {})
     });
     // Get the values per instates ids:
     const instancesIds = instances.map((i) => i[primaryKey]);
-    const customFieldValues = await ValueRepo.findValuesByModelIds(instancesIds, { transaction: options.transaction });
     // Group fields by modelId
-    const valuesGroupByInstance = customFieldValues.reduce((acc, v) => {
-        const { modelId } = v;
-        if (!acc[modelId]) {
-            acc[modelId] = [];
-        }
-        acc[modelId].push(v);
-        return acc;
-    }, {});
+    const valuesGroupByInstance = await (0, exports.getValuesGroupByInstance)({
+        instancesIds,
+        options,
+        sadotOptions,
+    });
+    const customFieldEntriesByInstanceId = await (0, exports.getCustomFieldEntriesByInstanceId)({
+        instancesIds,
+        options,
+        sadotOptions,
+    });
     // Attach custom fields to the instances
     instances.forEach((instance) => {
-        const customFields = {};
         const { id } = instance;
         const instanceValues = valuesGroupByInstance[id];
-        if (instanceValues) {
-            const serializedCustomFields = serializeCustomFields(instanceValues, definitionsMap);
-            Object.assign(customFields, serializedCustomFields);
-        }
+        const serializedCustomFieldsValues = instanceValues ? serializeCustomFields(instanceValues, definitionsMap) : {};
+        const customFields = sadotOptions.useCustomFieldsEntries
+            ? customFieldEntriesByInstanceId[id]
+            : serializedCustomFieldsValues;
         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);
+    (0, init_1.addScopes)(models, getModel, { useCustomFieldsEntries });
     (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,6 +31,7 @@ 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({
@@ -73,6 +74,14 @@ 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/utils/formatValues.d.ts

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

package/dist/repository/utils/formatValues.js

@@ -0,0 +1,16 @@
+"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/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 constants_1 = require("../utils/constants");
+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) => {
@@ -67,18 +67,6 @@ 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.
@@ -112,7 +100,7 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     }
     const values = names.map((name) => {
         const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
-        const formatFunction = formatFunctions[fieldDefinition.fieldType];
+        const formatFunction = formatValues_1.formatFunctions[fieldDefinition.fieldType];
         const value = formatFunction ? formatFunction(valuesToUpdate[name]) : valuesToUpdate[name];
         return {
             modelId,

package/dist/scopes/filter.d.ts

@@ -1,22 +1,5 @@
-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>;
-};
+import type { CustomFieldOptions } from '../types';
+import { type ConditionValue, type CustomFieldFilterOptions } from './helpers/filter.helpers';
 type customFieldsFilterScopeParams = {
     replacementsMap: Record<string, string>;
     scopeValue: Record<string, ConditionValue>;
@@ -28,9 +11,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) => ({ replacementsMap: replacements, scopeValue: conditions }: customFieldsFilterScopeParams) => CustomFieldFilterOptions;
+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) => ({ replacementsMap, scopeValue: sort }: {
+export declare const customFieldsSortScope: (name: string, options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => ({ replacementsMap, scopeValue: sort }: {
     replacementsMap: any;
     scopeValue: any;
 }) => {

package/dist/scopes/filter.js

@@ -6,26 +6,8 @@ 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.
@@ -33,68 +15,27 @@ const CV_VALUE_COLUMN = `${CV_TABLE_ALIAS}.value`;
  * @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) => ({ replacementsMap: replacements, scopeValue: conditions }) => {
+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]) => {
-        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
+        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;
-            }
-            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 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, '');
+    const subQuery = (0, filter_helpers_1.getFilterCustomFieldsSubQuery)(queryType, name, conditionsStrings);
     return {
         where: {
             id: {
@@ -106,25 +47,17 @@ const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scop
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
 exports.scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
-const customFieldsSortScope = (name) => ({ replacementsMap, scopeValue: sort }) => {
+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 replacemetKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
+        const replacementKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
         return ([
-            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,
+            sequelize_typescript_1.Sequelize.literal((0, filter_helpers_1.getSortCustomFieldsSubQuery)(queryType, name, replacementKey)),
+            randomStr,
         ]);
     });
     const orders = Object.entries(sort).map(([, sortObject]) => {

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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,204 @@
+"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;