@autofleet/sadot 1.0.0-beta.0 → 1.0.0

package/dist/scopes/filter.js

@@ -6,18 +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 isDate = (input) => input instanceof Date || Object.prototype.toString.call(input) === '[object Date]';
-const castIfNeeded = (conditionValue) => {
-    if (isDate(conditionValue)) {
-        return '::timestamp';
-    }
-    if (!Number.isNaN(Number(conditionValue))) {
-        return '::numeric';
-    }
-    return '';
-};
-const AND_DELIMETER = ' AND ';
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -25,56 +15,27 @@ const AND_DELIMETER = ' AND ';
  * @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 replacemetKey = Object.keys(replacements).find((randomString) => replacements[randomString] === key);
-        if (!replacemetKey)
-            return false;
-        if (Array.isArray(condition)) {
-            if (condition.length === 0) {
-                // if empty array, the condition is ignored
+    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;
-            }
-            if (typeof condition[0] === 'string') {
-                const values = condition.map((v) => {
-                    const valRandom = Object.keys(replacements).find((randomString) => replacements[randomString] === v);
-                    return ` :${valRandom} `;
-                }).join(',');
-                return `(custom_fields->> :${replacemetKey} ) IN ( ${values} )`;
-            }
-            return condition
-                .map((c) => {
-                const valRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === c.value);
-                return `(custom_fields->> :${replacemetKey} )${castIfNeeded(c.value)} ${c.operator} :${valRep}`;
-            }).join(AND_DELIMETER);
-        }
-        if (typeof condition === 'string' || typeof condition === 'number') {
-            const conditionRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === condition);
-            return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition)} = :${conditionRep}`;
-        }
-        if (condition?.operator) {
-            const valueRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === condition.value);
-            return `(custom_fields->> :${replacemetKey} ) ${castIfNeeded(condition.value)} ${condition.operator} :${valueRep}`;
         }
-        return false;
-    })
-        .filter(Boolean);
+    }).filter(Boolean);
     if (conditionsStrings.length === 0) {
         return {};
     }
-    const customFieldConditions = conditionsStrings.join(AND_DELIMETER);
-    const subQuery = `${'SELECT model_id FROM ('
-        + 'SELECT cv.model_id, jsonb_object_agg(cd.name, cv.value) AS custom_fields '
-        + 'FROM custom_field_values AS cv '
-        + 'INNER JOIN custom_field_definitions AS cd ON cv.custom_field_definition_id = cd.id '
-        + `AND cd.model_type = '${name}'`
-        + 'GROUP BY cv.model_id'
-        + ') AS CustomFieldAggregation WHERE '} ${customFieldConditions}`;
+    const subQuery = (0, filter_helpers_1.getFilterCustomFieldsSubQuery)(queryType, name, conditionsStrings);
     return {
         where: {
             id: {
@@ -86,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 cd.model_type = '${name}'
-                    WHERE cv.model_id = "${name}"."id"
-                          AND 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;

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

@@ -1,33 +1,15 @@
 "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 });
-const express_1 = __importStar(require("express"));
+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, express_1.Router)();
+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);

package/dist/tests/helpers/commonHooks.d.ts

@@ -0,0 +1,6 @@
+import type { Application } from 'express';
+import type { Models } from '../../types';
+export declare function commonTestHooks(app?: Application | null, models?: Models[], options?: {
+    useCustomFieldsEntries: boolean;
+    useValidators?: boolean;
+}): void;

package/dist/tests/helpers/commonHooks.js

@@ -0,0 +1,62 @@
+"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.commonTestHooks = void 0;
+const __1 = __importDefault(require("../.."));
+const _1 = require(".");
+const database_config_1 = __importDefault(require("./database-config"));
+const db_1 = __importStar(require("../../utils/db"));
+function commonTestHooks(app = null, models = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }], options = {
+    useCustomFieldsEntries: false,
+    useValidators: false,
+}) {
+    let sequelize;
+    beforeAll(async () => {
+        sequelize = (0, db_1.default)(database_config_1.default);
+        await (0, db_1.createSequelizeMeta)(sequelize);
+        await (0, __1.default)(app, _1.getModel, {
+            models,
+            databaseConfig: database_config_1.default,
+            getUser: () => undefined,
+            sequelize,
+            useCustomFieldsEntries: options.useCustomFieldsEntries,
+            useValidators: options.useValidators,
+        });
+    });
+    afterEach(async () => {
+        jest.clearAllMocks();
+        await (0, _1.cleanup)({
+            useCustomFieldsEntries: options.useCustomFieldsEntries,
+            useValidators: options.useValidators,
+        });
+    });
+    afterAll(async () => {
+        await sequelize.close();
+    });
+}
+exports.commonTestHooks = commonTestHooks;

package/dist/tests/helpers/database-config.js

@@ -4,7 +4,7 @@ exports.default = {
     test: {
         username: process.env.DB_USERNAME || '',
         password: process.env.DB_PASSWORD || null,
-        database: process.env.DB_NAME || 'sadot_package_test',
+        database: process.env.DB_NAME || 'postgres',
         host: process.env.DB_HOST || '127.0.0.1',
         port: process.env.DB_PORT || 5432,
         dialect: process.env.DB_TYPE || 'postgres',

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

@@ -1,2 +1,7 @@
-export declare const cleanup: () => Promise<void>;
+import type { CustomFieldOptions } from '../../types';
+export declare const cleanup: (options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries' | 'useValidators'>) => Promise<void>;
 export declare const getModel: (name: string) => any;
+export declare const getReplacementMapWithScopeValue: (conditions: Record<string, any>) => {
+    replacementsMap: Record<string, string>;
+    scopeValue: Record<string, any>;
+};

package/dist/tests/helpers/index.js

@@ -1,14 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getModel = exports.cleanup = void 0;
+exports.getReplacementMapWithScopeValue = exports.getModel = exports.cleanup = void 0;
+const sheilta_1 = require("@autofleet/sheilta");
 const models_1 = require("../../models");
 // eslint-disable-next-line import/prefer-default-export
-const cleanup = async () => {
+const cleanup = async (options) => {
     if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
         await models_1.CustomFieldDefinition.unscoped().destroy({ where: {} });
         await models_1.TestModel.destroy({ where: {} });
         await models_1.ContextAwareTestModel.destroy({ where: {} });
         await models_1.ContextTestModel.destroy({ where: {} });
+        if (options?.useCustomFieldsEntries) {
+            await models_1.CustomFieldEntries.unscoped().destroy({ where: {} });
+        }
+        // Clean up validators if they were used
+        if (options?.useValidators) {
+            await models_1.CustomValidator.unscoped().destroy({ where: {} });
+        }
     }
 };
 exports.cleanup = cleanup;
@@ -18,3 +26,8 @@ const getModel = (name) => {
     return models[name];
 };
 exports.getModel = getModel;
+const getReplacementMapWithScopeValue = (conditions) => ({
+    replacementsMap: (0, sheilta_1.generateFilterReplacements)(Object.fromEntries(Object.entries(conditions).map(([key, value]) => [`customFields.${key}`, value]))),
+    scopeValue: conditions,
+});
+exports.getReplacementMapWithScopeValue = getReplacementMapWithScopeValue;

package/dist/tests/mocks/definition.mock.d.ts

@@ -15,9 +15,10 @@ export declare const coolFieldDefinition2: {
     updatedAt?: Date;
     deletedAt?: Date;
     defaultValue?: any;
+    blockEditingFromUI?: boolean;
     displayName?: string;
-    validation?: any;
     fieldType: string;
+    validation?: any;
     entityId: string;
     entityType: string;
     modelType: string;
@@ -31,9 +32,10 @@ export declare const coolFieldDefinition3: {
     updatedAt?: Date;
     deletedAt?: Date;
     defaultValue?: any;
+    blockEditingFromUI?: boolean;
     displayName?: string;
-    validation?: any;
     fieldType: string;
+    validation?: any;
     entityId: string;
     entityType: string;
     modelType: string;
@@ -41,5 +43,6 @@ export declare const coolFieldDefinition3: {
 export declare const booleanField: (modelType: string) => CreateCustomFieldDefinition;
 export declare const selectField: (modelType: string, options: any) => CreateCustomFieldDefinition;
 export declare const statusField: (modelType: string, options: any) => CreateCustomFieldDefinition;
+export declare const fileField: (modelType: string) => CreateCustomFieldDefinition;
 export declare const createDefinition: (defaults: Partial<CustomFieldDefinitionDTO>) => CreateCustomFieldDefinition;
 export declare const createDefinitions: (defaults: Partial<CustomFieldDefinitionDTO>, length?: number) => CreateCustomFieldDefinition[];

package/dist/tests/mocks/definition.mock.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createDefinitions = exports.createDefinition = exports.statusField = exports.selectField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
+exports.createDefinitions = exports.createDefinition = exports.fileField = exports.statusField = exports.selectField = exports.booleanField = exports.coolFieldDefinition3 = exports.coolFieldDefinition2 = exports.coolFieldDefinition = exports.contextAwareFieldDefinition = void 0;
 const node_crypto_1 = require("node:crypto");
 exports.contextAwareFieldDefinition = {
     name: 'cool field',
@@ -49,6 +49,14 @@ const statusField = (modelType, options) => ({
     entityType: 'fleetId',
 });
 exports.statusField = statusField;
+const fileField = (modelType) => ({
+    name: 'file',
+    modelType,
+    fieldType: 'file',
+    entityId: (0, node_crypto_1.randomUUID)(),
+    entityType: 'fleetId',
+});
+exports.fileField = fileField;
 // eslint-disable-next-line max-len
 const createDefinition = (defaults) => ({
     name: defaults?.name || `def_${(0, node_crypto_1.randomUUID)()}`,
@@ -56,6 +64,7 @@ const createDefinition = (defaults) => ({
     fieldType: defaults?.fieldType || 'boolean',
     entityId: defaults?.entityId || (0, node_crypto_1.randomUUID)(),
     entityType: defaults?.entityType || 'fleetId',
+    ...(defaults?.validation && { validation: defaults.validation }),
     ...(defaults?.defaultValue && { defaultValue: defaults.defaultValue }),
 });
 exports.createDefinition = createDefinition;

package/dist/tests/mocks/events.mock.d.ts

@@ -1,3 +1,4 @@
 export declare const mockEvent: (events: any, eventName: any, numberOfEvents: any) => any[];
 export declare const mockDimCustomFieldDefinitionEvent: (events: any, numberOfEvents: any) => any[];
 export declare const mockDimCustomFieldValueEvent: (events: any, numberOfEvents: any) => any[];
+export declare const mockDimCustomFieldEntriesEvent: (events: any, numberOfEvents: any) => any[];

package/dist/tests/mocks/events.mock.js

@@ -1,9 +1,9 @@
 "use strict";
 /* eslint-disable no-param-reassign */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockDimCustomFieldValueEvent = exports.mockDimCustomFieldDefinitionEvent = exports.mockEvent = void 0;
+exports.mockDimCustomFieldEntriesEvent = exports.mockDimCustomFieldValueEvent = exports.mockDimCustomFieldDefinitionEvent = exports.mockEvent = void 0;
 const mockEvent = (events, eventName, numberOfEvents) => {
-    events.sendObject = jest.fn();
+    events.sendObject = jest.fn().mockResolvedValue(true);
     return [
         events.sendObject,
         () => {
@@ -17,3 +17,5 @@ const mockDimCustomFieldDefinitionEvent = (events, numberOfEvents) => (0, export
 exports.mockDimCustomFieldDefinitionEvent = mockDimCustomFieldDefinitionEvent;
 const mockDimCustomFieldValueEvent = (events, numberOfEvents) => (0, exports.mockEvent)(events, 'dim_custom_field_value', numberOfEvents);
 exports.mockDimCustomFieldValueEvent = mockDimCustomFieldValueEvent;
+const mockDimCustomFieldEntriesEvent = (events, numberOfEvents) => (0, exports.mockEvent)(events, 'dim_custom_field_entries', numberOfEvents);
+exports.mockDimCustomFieldEntriesEvent = mockDimCustomFieldEntriesEvent;

package/dist/types/definition/index.d.ts

@@ -14,6 +14,7 @@ export interface CustomFieldDefinitionDTO {
     createdAt?: Date;
     updatedAt?: Date;
     deletedAt?: Date;
+    blockEditingFromUI?: boolean;
 }
 export type CreateCustomFieldDefinition = Omit<CustomFieldDefinitionDTO, 'id'>;
 export type UpdateCustomFieldDefinition = Partial<CreateCustomFieldDefinition>;

package/dist/types/entries/index.d.ts

@@ -0,0 +1,25 @@
+import type { ValidationError } from 'joi';
+export interface CustomFieldEntriesDTO {
+    modelId: string;
+    entityId: string;
+    modelType: string;
+    /**
+     * A collection of custom fields where each key is the name of a CustomFieldDefinition and
+     * each value is the value of that custom field for this specific `modelId`.
+     *
+     * Example:
+     * {
+     *   "vehicleColor": "Red",
+     *   "vehicleType": "premium",
+     *   "isActive": true
+     * }
+     */
+    customFields: Record<string, any>;
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export interface EntriesValidationError {
+    value: any;
+    fieldDefinitionName: string;
+    joiValidationError: ValidationError;
+}

package/dist/types/entries/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });