@autofleet/sadot 0.7.8-beta-1 → 0.7.8-beta--beta-1.0

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

@@ -6,10 +6,17 @@ 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 statusValidationObjectSchema = joi_1.default.array().items(joi_1.default.object({
+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({
     value: joi_1.default.string().required(),
     color: joi_1.default.string().required(),
-})).min(1).unique('value');
+});
+const statusValidationObjectSchema = joi_1.default.array().items(statusValidationObject).min(1).unique('value');
 /**
  * Schema for the validation of custom field definition
  * The only custom validation is for
@@ -28,10 +35,24 @@ 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(),
@@ -42,6 +63,7 @@ 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'];
-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 KEYS_TO_CONVERT = ['value', 'defaultValue'];
+const stringifyBooleans = (savedObject, keysToConvert) => {
+    if (!Object.keys(savedObject).some((key) => keysToConvert.includes(key))) {
+        return savedObject;
     }
-    return savedObject;
+    const objectToReturn = { ...savedObject };
+    keysToConvert.forEach((key) => {
+        if (typeof savedObject[key] === 'boolean') {
+            objectToReturn[key] = savedObject[key].toString();
+        }
+    });
+    return objectToReturn;
 };
 const modelTableMapping = {
     CustomFieldDefinition: {
@@ -32,16 +32,17 @@ const modelTableMapping = {
 };
 const sendDimEvent = (instance) => {
     const mapping = modelTableMapping[instance.constructor.name];
-    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);
+    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);
     }
+    events.sendObject(mapping.tableName, mapping.eventVersion, objectToSend);
 };
 exports.sendDimEvent = sendDimEvent;
 exports.default = events;

package/dist/hooks/create.js

@@ -48,27 +48,43 @@ 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);
-    // get all model's required definitions
-    const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers, modelOptions);
+    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)));
     const customFieldsIdx = fields.indexOf('customFields');
-    const { customFields } = instance;
-    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,
-        });
+    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
-        fields.splice(customFieldsIdx, 1);
+        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;
+        });
     }
-    else if (requiredFieldsNames?.length > 0) {
-        throw new errors_1.MissingRequiredCustomFieldError(requiredFieldsNames);
+    const { customFields } = instance;
+    if (customFieldsIdx === -1 || !customFields) {
+        return;
     }
+    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);
 };
 exports.beforeCreate = beforeCreate;

package/dist/models/CustomFieldDefinition.d.ts

@@ -13,6 +13,7 @@ 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,12 +19,19 @@ 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) {
@@ -116,6 +123,13 @@ __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 = 1;
+const SCHEMA_VERSION = 2;
 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,9 +28,7 @@ __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,20 +1,26 @@
-import { type FindOptions, type WhereOptions } from 'sequelize';
+import { type Includeable, type Transaction, 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>;
-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>;
+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 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<any>;
-export declare const destroy: (id: string) => Promise<any>;
+export declare const disable: (id: string) => Promise<[affectedCount: number]>;
+export declare const destroy: (id: string) => Promise<number>;
 /**
  * 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,6 +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 findByModelIdAndDefinition = async (modelId, customFieldDefinitionId) => models_1.CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [models_1.CustomFieldDefinition] });
 exports.findByModelIdAndDefinition = findByModelIdAndDefinition;
 const create = async (data, withAssociations = false) => {
@@ -66,6 +67,18 @@ const findValuesByModelIds = async (modelIds, options) => {
     });
 };
 exports.findValuesByModelIds = findValuesByModelIds;
+const formatFunctions = {
+    [constants_1.CustomFieldDefinitionType.DATE]: (value) => {
+        if (value) {
+            const date = new Date(value);
+            if (date.toString() === 'Invalid Date') {
+                throw new Error(`Invalid date value: ${value}`);
+            }
+            return date.toISOString();
+        }
+        return null;
+    },
+};
 /**
  * Try to update custom field values for a model instance.
  * Create new value record if not exists, but fails if value's definition not exist.
@@ -83,11 +96,9 @@ const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, opt
     const where = {
         modelType,
         name: names,
+        ...(!options.modelOptions?.useEntityIdFromInclude && { entityId: identifiers }),
     };
-    if (!options.modelOptions?.useEntityIdFromInclude) {
-        where.entityId = identifiers;
-    }
-    const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(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 });
@@ -99,12 +110,17 @@ 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) => ({
-        modelId,
-        value: valuesToUpdate[name],
-        updatedAt: new Date(),
-        customFieldDefinitionId: fieldDefinitions.find((def) => def.name === name).id,
-    }));
+    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,
+        };
+    });
     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,6 +17,10 @@ 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.
@@ -24,9 +28,12 @@ export type CustomFieldFilterOptions = {
  * @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) => (conditions: Record<string, ConditionValue>) => CustomFieldFilterOptions;
+export declare const customFieldsFilterScope: (name: string) => ({ replacementsMap: replacements, scopeValue: conditions, }: customFieldsFilterScopeParams) => CustomFieldFilterOptions;
 export declare const scopeName = "filterByCustomFields";
-export declare const customFieldsSortScope: (name: string) => (sort: CustomFieldSort[]) => {
+export declare const customFieldsSortScope: (name: string) => ({ replacementsMap, scopeValue: sort }: {
+    replacementsMap: any;
+    scopeValue: any;
+}) => {
     attributes?: undefined;
     order?: undefined;
     replacements?: undefined;
@@ -35,6 +42,6 @@ export declare const customFieldsSortScope: (name: string) => (sort: CustomField
         include: (string | import("sequelize/types/utils").Literal)[][];
     };
     order: import("sequelize/types/utils").Literal[];
-    replacements: Record<string, string>;
+    replacements: any;
 };
 export {};

package/dist/scopes/filter.js

@@ -1,18 +1,15 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.customFieldsSortScope = exports.scopeName = exports.customFieldsFilterScope = void 0;
 /* eslint-disable import/prefer-default-export */
 const sequelize_1 = require("sequelize");
 const sequelize_typescript_1 = require("sequelize-typescript");
 const common_types_1 = require("@autofleet/common-types");
-const moment_1 = __importDefault(require("moment"));
 const helpers_1 = require("../utils/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 (moment_1.default.isDate(conditionValue)) {
+    if (isDate(conditionValue)) {
         return '::timestamp';
     }
     if (!Number.isNaN(Number(conditionValue))) {
@@ -34,19 +31,17 @@ const castValueToJsonb = (value) => `to_jsonb(${value}::text)`;
  * @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) => (conditions) => {
+const customFieldsFilterScope = (name) => ({ replacementsMap: replacements, scopeValue: 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 = (0, helpers_1.generateRandomString)();
-        replacements[replacemetKey] = `${key}`;
+        const replacemetKey = Object.keys(replacements).find((randomString) => replacements[randomString] === key);
         const columnCondition = `(${CD_NAME_COLUMN} = :${replacemetKey})`;
+        if (!replacemetKey)
+            return false;
         if (Array.isArray(condition)) {
             if (condition.length === 0) {
                 // if empty array, the condition is ignored
@@ -54,29 +49,25 @@ const customFieldsFilterScope = (name) => (conditions) => {
             }
             if (typeof condition[0] === 'string') {
                 const values = condition.map((v) => {
-                    const valRandom = (0, helpers_1.generateRandomString)();
-                    replacements[`${valRandom}`] = `${v}`;
+                    const valRandom = Object.keys(replacements).find((randomString) => replacements[randomString] === v);
                     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 = (0, helpers_1.generateRandomString)();
-                replacements[valRep] = `${c.value}`;
+                const valRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === 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 = (0, helpers_1.generateRandomString)();
-            replacements[conditionRep] = `${condition}`;
+            const conditionRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === condition);
             const valueAsJsonb = castValueToJsonb(`:${conditionRep}`);
             return `(${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition)} = ${valueAsJsonb})`;
         }
         if (condition?.operator) {
-            const valueRep = (0, helpers_1.generateRandomString)();
-            replacements[valueRep] = `${condition.value}`;
+            const valueRep = Object.keys(replacements).find((replacementKey) => replacements[replacementKey] === condition.value);
             const valueAsJsonb = castValueToJsonb(`:${valueRep}`);
             return `( ${columnCondition} AND ${CV_VALUE_COLUMN}${castIfNeeded(condition.value)} ${condition.operator} ${valueAsJsonb})`;
         }
@@ -91,8 +82,9 @@ const customFieldsFilterScope = (name) => (conditions) => {
     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}
+    AND cd.model_type = '${name}'
     WHERE ${customFieldConditions}
+    AND cv.deleted_at IS NULL AND cd.deleted_at IS NULL
     GROUP BY cv.model_id
     HAVING COUNT(DISTINCT cv.custom_field_definition_id) = ${conditionsStrings.length}
   `.replace(/\n/g, '');
@@ -107,15 +99,13 @@ const customFieldsFilterScope = (name) => (conditions) => {
 };
 exports.customFieldsFilterScope = customFieldsFilterScope;
 exports.scopeName = CUSTOM_FIELDS_FILTER_SCOPE;
-const customFieldsSortScope = (name) => (sort) => {
+const customFieldsSortScope = (name) => ({ replacementsMap, scopeValue: sort }) => {
     if (!sort || sort.length === 0) {
         return {};
     }
     const randomStr = (0, helpers_1.generateRandomString)();
-    const replacements = {};
     const includes = Object.entries(sort).map(([key]) => {
-        const keyRandomReplacement = (0, helpers_1.generateRandomString)();
-        replacements[keyRandomReplacement] = `${key}`;
+        const replacemetKey = Object.keys(replacementsMap).find((randomString) => replacementsMap[randomString] === key);
         return ([
             sequelize_typescript_1.Sequelize.literal(`(
             SELECT value
@@ -124,19 +114,22 @@ const customFieldsSortScope = (name) => (sort) => {
                     ON cv.custom_field_definition_id = cd.id
                     AND cd.model_type = '${name}'
                     WHERE cv.model_id = "${name}"."id"
-                          AND cd.name = :${keyRandomReplacement}
+                          AND cd.name = :${replacemetKey}
                           ) AS CustomFieldAggregation
             )
           `), randomStr,
         ]);
     });
-    const orders = Object.entries(sort).map(([, value]) => sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${value}`));
+    const orders = Object.entries(sort).map(([, sortObject]) => {
+        const direction = typeof sortObject === 'string' ? sortObject : Object.values(sortObject)[0];
+        return sequelize_typescript_1.Sequelize.literal(`"${randomStr}" ${direction || 'ASC'}`);
+    });
     return {
         attributes: {
             include: includes,
         },
         order: orders,
-        replacements,
+        replacements: replacementsMap,
     };
 };
 exports.customFieldsSortScope = customFieldsSortScope;

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

@@ -14,6 +14,7 @@ export declare const coolFieldDefinition2: {
     createdAt?: Date;
     updatedAt?: Date;
     deletedAt?: Date;
+    defaultValue?: any;
     displayName?: string;
     validation?: any;
     fieldType: string;
@@ -29,6 +30,7 @@ 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 uuid_1 = require("uuid");
+const node_crypto_1 = require("node:crypto");
 exports.contextAwareFieldDefinition = {
     name: 'cool field',
     modelType: 'ContextAwareTestModel',
@@ -12,7 +12,7 @@ exports.coolFieldDefinition = {
     name: 'cool field',
     modelType: 'TestModel',
     fieldType: 'number',
-    entityId: (0, uuid_1.v4)(),
+    entityId: (0, node_crypto_1.randomUUID)(),
     entityType: 'fleetId',
 };
 exports.coolFieldDefinition2 = {
@@ -27,7 +27,7 @@ const booleanField = (modelType) => ({
     name: 'shapeless',
     modelType,
     fieldType: 'boolean',
-    entityId: (0, uuid_1.v4)(),
+    entityId: (0, node_crypto_1.randomUUID)(),
     entityType: 'fleetId',
 });
 exports.booleanField = booleanField;
@@ -36,7 +36,7 @@ const selectField = (modelType, options) => ({
     modelType,
     fieldType: 'select',
     validation: options,
-    entityId: (0, uuid_1.v4)(),
+    entityId: (0, node_crypto_1.randomUUID)(),
     entityType: 'fleetId',
 });
 exports.selectField = selectField;
@@ -45,24 +45,25 @@ const statusField = (modelType, options) => ({
     modelType,
     fieldType: 'status',
     validation: options,
-    entityId: (0, uuid_1.v4)(),
+    entityId: (0, node_crypto_1.randomUUID)(),
     entityType: 'fleetId',
 });
 exports.statusField = statusField;
 // eslint-disable-next-line max-len
 const createDefinition = (defaults) => ({
-    name: defaults?.name || `def_${(0, uuid_1.v4)()}`,
+    name: defaults?.name || `def_${(0, node_crypto_1.randomUUID)()}`,
     modelType: defaults?.modelType || 'TestModel',
     fieldType: defaults?.fieldType || 'boolean',
-    entityId: defaults?.entityId || (0, uuid_1.v4)(),
+    entityId: defaults?.entityId || (0, node_crypto_1.randomUUID)(),
     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, uuid_1.v4)()}`,
+    name: defaults?.name || `def_${(0, node_crypto_1.randomUUID)()}`,
     modelType: defaults?.modelType || 'TestModel',
     fieldType: defaults?.fieldType || 'boolean',
-    entityId: defaults?.entityId || (0, uuid_1.v4)(),
+    entityId: defaults?.entityId || (0, node_crypto_1.randomUUID)(),
     entityType: defaults?.entityType || 'fleetId',
 })));
 exports.createDefinitions = createDefinitions;

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

@@ -3,6 +3,7 @@ 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: any;
+declare const logger: import("@autofleet/logger").LoggerInstanceManager;
 export default logger;

package/dist/utils/logger/index.js

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.7.8-beta-1",
+  "version": "0.7.8-beta--beta-1.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {