@autofleet/sadot 0.7.7-beta.1 → 0.7.7

package/dist/api/v1/definition/validations.js

@@ -6,17 +6,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCustomFieldDefinitionUpdate = exports.validateCustomFieldDefinitionCreation = void 0;
 const joi_1 = __importDefault(require("joi"));
 const constants_1 = require("../../../utils/constants");
-const FileValidationSchema = joi_1.default.object({
-    name: joi_1.default.string().required(),
-    type: joi_1.default.string(),
-    size: joi_1.default.string(),
-    addedBy: joi_1.default.string().uuid(),
-});
-const statusValidationObject = joi_1.default.object({
+const statusValidationObjectSchema = joi_1.default.array().items(joi_1.default.object({
     value: joi_1.default.string().required(),
     color: joi_1.default.string().required(),
-});
-const statusValidationObjectSchema = joi_1.default.array().items(statusValidationObject).min(1).unique('value');
+})).min(1).unique('value');
 /**
  * Schema for the validation of custom field definition
  * The only custom validation is for
@@ -35,24 +28,10 @@ const ValidationSchema = joi_1.default.when('fieldType', {
     then: statusValidationObjectSchema,
     otherwise: joi_1.default.any(),
 });
-const DefaultValueSchema = joi_1.default.when('fieldType', {
-    switch: [
-        { is: constants_1.CustomFieldDefinitionType.BOOLEAN, then: joi_1.default.boolean().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.DATE, then: joi_1.default.date().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.DATETIME, then: joi_1.default.date().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.FILE, then: FileValidationSchema },
-        { is: constants_1.CustomFieldDefinitionType.IMAGE, then: joi_1.default.string().uri().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.NUMBER, then: joi_1.default.number().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.SELECT, then: joi_1.default.string().allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.STATUS, then: statusValidationObject.allow(null) },
-        { is: constants_1.CustomFieldDefinitionType.TEXT, then: joi_1.default.string().allow(null) },
-    ],
-});
 const CustomFieldDefinitionCreationSchema = joi_1.default.object({
     name: joi_1.default.string().required(),
     displayName: joi_1.default.string().required(),
     validation: ValidationSchema,
-    defaultValue: DefaultValueSchema,
     fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)).required(),
     entityId: joi_1.default.string().guid().required(),
     entityType: joi_1.default.string().required(),
@@ -63,7 +42,6 @@ const CustomFieldDefinitionCreationSchema = joi_1.default.object({
 const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
     displayName: joi_1.default.string(),
     validation: ValidationSchema,
-    defaultValue: DefaultValueSchema,
     fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)),
     description: joi_1.default.string().allow(null),
     required: joi_1.default.boolean(),

package/dist/events/index.js

@@ -7,18 +7,18 @@ exports.sendDimEvent = void 0;
 const events_1 = __importDefault(require("@autofleet/events"));
 const logger_1 = __importDefault(require("../utils/logger"));
 const events = new events_1.default({ logger: logger_1.default });
-const KEYS_TO_CONVERT = ['value', 'defaultValue'];
-const stringifyBooleans = (savedObject, keysToConvert) => {
-    if (!Object.keys(savedObject).some((key) => keysToConvert.includes(key))) {
-        return savedObject;
+const KEYS_TO_CONVERT = ['value'];
+const stringifyBools = (savedObject, keysToConvert) => {
+    if (Object.keys(savedObject).some((key) => keysToConvert.includes(key))) {
+        const objectToReturn = { ...savedObject };
+        keysToConvert.forEach((key) => {
+            if (typeof savedObject[key] === 'boolean') {
+                objectToReturn[key] = savedObject[key].toString();
+            }
+        });
+        return objectToReturn;
     }
-    const objectToReturn = { ...savedObject };
-    keysToConvert.forEach((key) => {
-        if (typeof savedObject[key] === 'boolean') {
-            objectToReturn[key] = savedObject[key].toString();
-        }
-    });
-    return objectToReturn;
+    return savedObject;
 };
 const modelTableMapping = {
     CustomFieldDefinition: {
@@ -32,17 +32,16 @@ const modelTableMapping = {
 };
 const sendDimEvent = (instance) => {
     const mapping = modelTableMapping[instance.constructor.name];
-    if (!mapping) {
-        return;
-    }
-    let objectToSend = instance.get();
-    try {
-        objectToSend = stringifyBooleans(instance.get(), KEYS_TO_CONVERT);
-    }
-    catch (err) {
-        logger_1.default.error('Failed to convert booleans in dim event payload', err);
+    if (mapping) {
+        let objectToSend = instance.get();
+        try {
+            objectToSend = stringifyBools(instance.get(), KEYS_TO_CONVERT);
+        }
+        catch (err) {
+            logger_1.default.error('Failed to convert booleans in dim event payload', err);
+        }
+        events.sendObject(mapping.tableName, mapping.eventVersion, objectToSend);
     }
-    events.sendObject(mapping.tableName, mapping.eventVersion, objectToSend);
 };
 exports.sendDimEvent = sendDimEvent;
 exports.default = events;

package/dist/hooks/create.js

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

package/dist/models/CustomFieldDefinition.d.ts

@@ -13,7 +13,6 @@ declare class CustomFieldDefinition extends Model {
     description?: string;
     required?: boolean;
     disabled?: boolean;
-    defaultValue?: any;
     createdAt?: Date;
     updatedAt?: Date;
     deletedAt?: Date;

package/dist/models/CustomFieldDefinition.js

@@ -19,19 +19,12 @@ const _1 = require(".");
 const events_1 = require("../events");
 const errors_1 = require("../errors");
 const logger_1 = __importDefault(require("../utils/logger"));
-const validations_1 = require("../utils/validations");
 let CustomFieldDefinition = class CustomFieldDefinition extends sequelize_typescript_1.Model {
     static displayNameDefaultValue(instance) {
         if (!instance?.displayName) {
             // eslint-disable-next-line no-param-reassign
             instance.displayName = instance.name;
         }
-        if (![null, undefined].includes(instance.defaultValue)) {
-            const isValid = (0, validations_1.validateValue)(instance.defaultValue, instance.fieldType, instance.validation);
-            if (!isValid) {
-                throw new errors_1.InvalidValueError(instance.defaultValue, instance.fieldType);
-            }
-        }
     }
     static afterSaveHandler(instance, options) {
         if (options.transaction) {
@@ -123,13 +116,6 @@ __decorate([
     }),
     __metadata("design:type", Boolean)
 ], CustomFieldDefinition.prototype, "disabled", void 0);
-__decorate([
-    (0, sequelize_typescript_1.Column)({
-        type: sequelize_typescript_1.DataType.JSONB,
-        allowNull: true,
-    }),
-    __metadata("design:type", Object)
-], CustomFieldDefinition.prototype, "defaultValue", void 0);
 __decorate([
     sequelize_typescript_1.Column,
     __metadata("design:type", Date)

package/dist/models/index.js

@@ -22,7 +22,7 @@ exports.AssociatedTestModel = AssociatedTestModel_1.default;
 const productionModels = [CustomFieldDefinition_1.default, CustomFieldValue_1.default];
 const testModels = [TestModel_1.default, AssociatedTestModel_1.default, ContextAwareTestModel_1.default, ContextTestModel_1.default];
 const SADOT_MIGRATION_PREFIX = 'sadot-migration';
-const SCHEMA_VERSION = 2;
+const SCHEMA_VERSION = 1;
 const CUSTOM_FIELDS_SCHEMA_VERSION = `${SADOT_MIGRATION_PREFIX}_${SCHEMA_VERSION}`;
 const initTables = async (sequelize, getUser) => {
     logger_1.default.info('custom-fields: initialize custom-fields tables');

package/dist/models/tests/contextAwareModels/ContextAwareTestModel.js

@@ -28,7 +28,9 @@ __decorate([
 ], ContextAwareTestModel.prototype, "id", void 0);
 __decorate([
     (0, sequelize_typescript_1.ForeignKey)(() => ContextTestModel_1.default),
-    (0, sequelize_typescript_1.Column)({ type: sequelize_typescript_1.DataType.UUID }),
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+    }),
     __metadata("design:type", String)
 ], ContextAwareTestModel.prototype, "contextId", void 0);
 __decorate([

package/dist/repository/definition.d.ts

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

package/dist/repository/value.js

@@ -31,7 +31,6 @@ 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 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 +66,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.
@@ -96,9 +83,11 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     const where = {
         modelType,
         name: names,
-        ...(!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }),
     };
-    const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) ?? [];
+    if (!options.modelOptions?.useEntityIdFromInclude) {
+        where.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 });
@@ -110,17 +99,12 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     if (valuesWithDisabledDefinitions?.length > 0) {
         logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
     }
-    const values = names.map((name) => {
-        const fieldDefinition = fieldDefinitions.find((def) => def.name === name);
-        const formatFunction = 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,
-        };
-    });
+    const values = names.map((name) => ({
+        modelId,
+        value: valuesToUpdate[name],
+        updatedAt: new Date(),
+        customFieldDefinitionId: fieldDefinitions.find((def) => def.name === name).id,
+    }));
     return Promise.all(values.map(async (value) => {
         const [cfv] = await models_1.CustomFieldValue.upsert(value, {
             transaction: options.transaction,

package/dist/scopes/filter.d.ts

@@ -17,10 +17,6 @@ export type CustomFieldFilterOptions = {
     where?: WhereOptions;
     replacements?: Record<string, string>;
 };
-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.
@@ -28,12 +24,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) => (conditions: Record<string, ConditionValue>) => CustomFieldFilterOptions;
 export declare const scopeName = "filterByCustomFields";
-export declare const customFieldsSortScope: (name: string) => ({ replacementsMap, scopeValue: sort }: {
-    replacementsMap: any;
-    scopeValue: any;
-}) => {
+export declare const customFieldsSortScope: (name: string) => (sort: CustomFieldSort[]) => {
     attributes?: undefined;
     order?: undefined;
     replacements?: undefined;
@@ -42,6 +35,6 @@ export declare const customFieldsSortScope: (name: string) => ({ replacementsMap
         include: (string | import("sequelize/types/utils").Literal)[][];
     };
     order: import("sequelize/types/utils").Literal[];
-    replacements: any;
+    replacements: Record<string, string>;
 };
 export {};

package/dist/scopes/filter.js

@@ -8,12 +8,11 @@ exports.customFieldsSortScope = exports.scopeName = exports.customFieldsFilterSc
 const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const common_types_1 = require("@autofleet/common-types");
+const moment_1 = __importDefault(require("moment"));
 const helpers_1 = require("../utils/helpers");
-const logger_1 = __importDefault(require("../utils/logger"));
 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)) {
+    if (moment_1.default.isDate(conditionValue)) {
         return '::timestamp';
     }
     if (!Number.isNaN(Number(conditionValue))) {
@@ -21,18 +20,13 @@ const castIfNeeded = (conditionValue) => {
     }
     return '';
 };
-const addQuotationIfNeeded = (conditionValue, valRep) => {
-    if (typeof conditionValue === 'string') {
-        return `'"' || :${valRep} || '"'`;
-    }
-    return `:${valRep}`;
-};
 const AND_DELIMETER = ' AND ';
 const OR_DELIMETER = ' 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::varchar)`;
+const CV_VALUE_COLUMN = `(${CV_TABLE_ALIAS}.value)`;
+const castValueToJsonb = (value) => `to_jsonb(${value}::text)`;
 /**
  * A Sequelize scope for filtering models by custom fields.
  * This scope builds a WHERE clause to be applied on the main query.
@@ -40,16 +34,18 @@ const CV_VALUE_COLUMN = `(${CV_TABLE_ALIAS}.value::varchar)`;
  * @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) => (conditions) => {
     if (!conditions || Object.keys(conditions).length === 0) {
         return {};
     }
+    const ConditionNameRandomStr = (0, helpers_1.generateRandomString)();
+    const replacements = {};
+    replacements[ConditionNameRandomStr] = `${name}`;
     // 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;
+        const replacemetKey = (0, helpers_1.generateRandomString)();
+        replacements[replacemetKey] = `${key}`;
         const columnCondition = `(${CD_NAME_COLUMN} = :${replacemetKey})`;
         if (Array.isArray(condition)) {
             if (condition.length === 0) {
@@ -58,24 +54,31 @@ const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scop
             }
             if (typeof condition[0] === 'string') {
                 const values = condition.map((v) => {
-                    const valRandom = Object.keys(replacements).find((randomString) => replacements[randomString] === v);
-                    return addQuotationIfNeeded(v, valRandom);
+                    const valRandom = (0, helpers_1.generateRandomString)();
+                    replacements[`${valRandom}`] = `${v}`;
+                    return castValueToJsonb(`:${valRandom}`);
                 }).join(',');
                 return `(${columnCondition} AND ${CV_VALUE_COLUMN} IN ( ${values} ))`;
             }
             return condition
                 .map((c) => {
-                const valRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === c.value);
-                return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} ${addQuotationIfNeeded(c.value, valRep)} )`;
+                const valRep = (0, helpers_1.generateRandomString)();
+                replacements[valRep] = `${c.value}`;
+                const valueAsJsonb = castValueToJsonb(`:${valRep}`);
+                return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} ${valueAsJsonb})`;
             }).join(AND_DELIMETER);
         }
         if (typeof condition === 'string' || typeof condition === 'number') {
-            const conditionRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === condition);
-            return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${addQuotationIfNeeded(condition, conditionRep)})`;
+            const conditionRep = (0, helpers_1.generateRandomString)();
+            replacements[conditionRep] = `${condition}`;
+            const valueAsJsonb = castValueToJsonb(`:${conditionRep}`);
+            return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${valueAsJsonb})`;
         }
         if (condition?.operator) {
-            const valueRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === condition.value);
-            return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${addQuotationIfNeeded(condition.value, valueRep)})`;
+            const valueRep = (0, helpers_1.generateRandomString)();
+            replacements[valueRep] = `${condition.value}`;
+            const valueAsJsonb = castValueToJsonb(`:${valueRep}`);
+            return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${valueAsJsonb})`;
         }
         return false;
     })
@@ -85,15 +88,14 @@ const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scop
     }
     const customFieldConditions = conditionsStrings.join(OR_DELIMETER);
     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 cd.model_type = '${name}'
-  WHERE ${customFieldConditions}
-  GROUP BY cv.model_id
-  HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
-`.replace(/\n/g, '');
-    logger_1.default.info('custom fields filter scope', { subQuery, replacements });
+    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 cd.model_type = :${ConditionNameRandomStr}
+    WHERE ${customFieldConditions}
+    GROUP BY cv.model_id
+    HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
+  `.replace(/\n/g, '');
     return {
         where: {
             id: {
@@ -105,13 +107,15 @@ const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scop
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
 exports.scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
-const customFieldsSortScope = (name) => ({ replacementsMap, scopeValue: sort }) => {
+const customFieldsSortScope = (name) => (sort) => {
     if (!sort || sort.length === 0) {
         return {};
     }
     const randomStr = (0, helpers_1.generateRandomString)();
+    const replacements = {};
     const includes = Object.entries(sort).map(([key]) => {
-        const replacemetKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
+        const keyRandomReplacement = (0, helpers_1.generateRandomString)();
+        replacements[keyRandomReplacement] = `${key}`;
         return ([
             sequelize_typescript_1.Sequelize.literal(`(
             SELECT value
@@ -120,22 +124,19 @@ const customFieldsSortScope = (name) => ({ replacementsMap, scopeValue: sort })
                     ON cv.custom_field_definition_id = cd.id
                     AND cd.model_type = '${name}'
                     WHERE cv.model_id = "${name}"."id"
-                          AND cd.name = :${replacemetKey}
+                          AND cd.name = :${keyRandomReplacement}
                           ) AS CustomFieldAggregation
             )
           `), 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'}`);
-    });
+    const orders = Object.entries(sort).map(([, value]) => sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${value}`));
     return {
         attributes: {
             include: includes,
         },
         order: orders,
-        replacements: replacementsMap,
+        replacements,
     };
 };
 exports.customFieldsSortScope = customFieldsSortScope;

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

@@ -14,7 +14,6 @@ export declare const coolFieldDefinition2: {
     createdAt?: Date;
     updatedAt?: Date;
     deletedAt?: Date;
-    defaultValue?: any;
     displayName?: string;
     validation?: any;
     fieldType: string;
@@ -30,7 +29,6 @@ export declare const coolFieldDefinition3: {
     createdAt?: Date;
     updatedAt?: Date;
     deletedAt?: Date;
-    defaultValue?: any;
     displayName?: string;
     validation?: any;
     fieldType: string;

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

@@ -1,7 +1,7 @@
 "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;
-const node_crypto_1 = require("node:crypto");
+const uuid_1 = require("uuid");
 exports.contextAwareFieldDefinition = {
     name: 'cool field',
     modelType: 'ContextAwareTestModel',
@@ -12,7 +12,7 @@ exports.coolFieldDefinition = {
     name: 'cool field',
     modelType: 'TestModel',
     fieldType: 'number',
-    entityId: (0, node_crypto_1.randomUUID)(),
+    entityId: (0, uuid_1.v4)(),
     entityType: 'fleetId',
 };
 exports.coolFieldDefinition2 = {
@@ -27,7 +27,7 @@ const booleanField = (modelType) => ({
     name: 'shapeless',
     modelType,
     fieldType: 'boolean',
-    entityId: (0, node_crypto_1.randomUUID)(),
+    entityId: (0, uuid_1.v4)(),
     entityType: 'fleetId',
 });
 exports.booleanField = booleanField;
@@ -36,7 +36,7 @@ const selectField = (modelType, options) => ({
     modelType,
     fieldType: 'select',
     validation: options,
-    entityId: (0, node_crypto_1.randomUUID)(),
+    entityId: (0, uuid_1.v4)(),
     entityType: 'fleetId',
 });
 exports.selectField = selectField;
@@ -45,25 +45,24 @@ const statusField = (modelType, options) => ({
     modelType,
     fieldType: 'status',
     validation: options,
-    entityId: (0, node_crypto_1.randomUUID)(),
+    entityId: (0, uuid_1.v4)(),
     entityType: 'fleetId',
 });
 exports.statusField = statusField;
 // eslint-disable-next-line max-len
 const createDefinition = (defaults) => ({
-    name: defaults?.name || `def_${(0, node_crypto_1.randomUUID)()}`,
+    name: defaults?.name || `def_${(0, uuid_1.v4)()}`,
     modelType: defaults?.modelType || 'TestModel',
     fieldType: defaults?.fieldType || 'boolean',
-    entityId: defaults?.entityId || (0, node_crypto_1.randomUUID)(),
+    entityId: defaults?.entityId || (0, uuid_1.v4)(),
     entityType: defaults?.entityType || 'fleetId',
-    ...(defaults?.defaultValue && { defaultValue: defaults.defaultValue }),
 });
 exports.createDefinition = createDefinition;
 const createDefinitions = (defaults, length = 1) => (Array(length).fill({}).map((_) => ({
-    name: defaults?.name || `def_${(0, node_crypto_1.randomUUID)()}`,
+    name: defaults?.name || `def_${(0, uuid_1.v4)()}`,
     modelType: defaults?.modelType || 'TestModel',
     fieldType: defaults?.fieldType || 'boolean',
-    entityId: defaults?.entityId || (0, node_crypto_1.randomUUID)(),
+    entityId: defaults?.entityId || (0, uuid_1.v4)(),
     entityType: defaults?.entityType || 'fleetId',
 })));
 exports.createDefinitions = createDefinitions;

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

@@ -3,7 +3,6 @@ export interface CustomFieldDefinitionDTO {
     name: string;
     displayName?: string;
     validation?: any;
-    defaultValue?: any;
     fieldType: string;
     entityId: string;
     entityType: string;

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

@@ -1,2 +1,2 @@
-declare const logger: import("@autofleet/logger").LoggerInstanceManager;
+declare const logger: any;
 export default logger;

package/dist/utils/logger/index.js

@@ -1,8 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = __importDefault(require("@autofleet/logger"));
-const logger = (0, logger_1.default)();
+// eslint-disable-next-line @typescript-eslint/no-var-requires
+const Logger = require('@autofleet/logger');
+const logger = Logger();
 exports.default = logger;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.7.7-beta.1",
+  "version": "0.7.7",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -8,7 +8,6 @@
     "build": "rm -rf dist && tsc",
     "linter": "eslint .",
     "test": "jest --forceExit --runInBand",
-    "test-debug": "node --inspect-brk node_modules/.bin/jest --runInBand --testTimeout=10000000",
     "coverage": "jest --coverage --forceExit --runInBand && rm -rf ./coverage",
     "build-to-local-repo": "node --run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
     "dev": "nodemon",

package/src/scopes/filter.ts

@@ -3,7 +3,6 @@ import { Op, type WhereOptions } from 'sequelize';
 import { Sequelize } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
 import { generateRandomString } from '../utils/helpers';
-import logger from '../utils/logger';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
 
@@ -44,21 +43,13 @@ const castIfNeeded = (conditionValue: string): string => {
   }
   return '';
 };
-
-const addQuotationIfNeeded = (conditionValue: string, valRep: string): string => {
-  if (typeof conditionValue === 'string') {
-    return `'"' || :${valRep} || '"'`;
-  }
-  return `:${valRep}`;
-};
-
 const AND_DELIMETER = ' AND ';
 const OR_DELIMETER = ' 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::varchar)`;
+const CV_VALUE_COLUMN = `(${CV_TABLE_ALIAS}.value)`;
+const castValueToJsonb = (value) => `to_jsonb(${value}::text)`;
 
 /**
  * A Sequelize scope for filtering models by custom fields.
@@ -85,8 +76,8 @@ export const customFieldsFilterScope = (
         const replacemetKey = Object.keys(replacements).find(
           (randomString) => replacements[randomString] === key,
         );
-        if (!replacemetKey) return false;
         const columnCondition = `(${CD_NAME_COLUMN} = :${replacemetKey})`;
+        if (!replacemetKey) return false;
 
         if (Array.isArray(condition)) {
           if (condition.length === 0) {
@@ -98,29 +89,32 @@ export const customFieldsFilterScope = (
               const valRandom = Object.keys(replacements).find(
                 (randomString) => replacements[randomString] === v,
               );
-              return addQuotationIfNeeded(v, valRandom);
+              return castValueToJsonb(`:${valRandom}`);
             }).join(',');
-            return `(${columnCondition} AND ${CV_VALUE_COLUMN} IN ( ${values} ))`;
+            return `(${columnCondition} AND ${CV_VALUE_COLUMN} IN (${values}))`;
           }
           return condition
             .map((c) => {
               const valRep = Object.keys(replacements).find(
                 (replacementKey) => replacements[replacementKey] === c.value,
               );
-              return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} ${addQuotationIfNeeded(c.value, valRep)} )`;
+              const valueAsJsonb = castValueToJsonb(`:${valRep}`);
+              return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(c.value)} ${c.operator} ${valueAsJsonb})`;
             }).join(AND_DELIMETER);
         }
         if (typeof condition === 'string' || typeof condition === 'number') {
           const conditionRep = Object.keys(replacements).find(
             (replacementKey) => replacements[replacementKey] === condition,
           );
-          return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${addQuotationIfNeeded(condition, conditionRep)})`;
+          const valueAsJsonb = castValueToJsonb(`:${conditionRep}`);
+          return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${valueAsJsonb})`;
         }
         if (condition?.operator) {
           const valueRep = Object.keys(replacements).find(
             (replacementKey) => replacements[replacementKey] === condition.value,
           );
-          return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${addQuotationIfNeeded(condition.value, valueRep)})`;
+          const valueAsJsonb = castValueToJsonb(`:${valueRep}`);
+          return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${valueAsJsonb})`;
         }
         return false;
       },
@@ -131,15 +125,15 @@ export const customFieldsFilterScope = (
   }
   const customFieldConditions = conditionsStrings.join(OR_DELIMETER);
   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 cd.model_type = '${name}'
-  WHERE ${customFieldConditions}
-  GROUP BY cv.model_id
-  HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
-`.replace(/\n/g, '');
-  logger.info('custom fields filter scope', { subQuery, replacements });
+    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
+    
+    WHERE ${customFieldConditions}
+    GROUP BY cv.model_id
+    HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
+  `.replace(/\n/g, '');
+  console.log(subQuery);
   return {
     where: {
       id: {