@autofleet/sadot 1.0.0-beta.1 → 1.0.0

package/README.md

@@ -0,0 +1,5 @@
+# V1 migration
+
+The breaking change in this version is the change of the minimum required version of `zehut` from `^3` to `^4`.
+
+Additionally, the minimum node version is now 18, due to the minimum version of node defined in `zehut`.

package/dist/api/index.d.ts

@@ -1,2 +1,3 @@
-declare const router: import("express-serve-static-core").Router;
+/// <reference types="express" />
+declare const router: import("express").Router;
 export default router;

package/dist/api/index.js

@@ -4,8 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 // export the api object
-const express_1 = require("express");
+const node_common_1 = require("@autofleet/node-common");
 const v1_1 = __importDefault(require("./v1"));
-const router = (0, express_1.Router)({ mergeParams: true });
+const logger_1 = __importDefault(require("../utils/logger"));
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
 router.use('/v1', v1_1.default);
 exports.default = router;

package/dist/api/v1/definition/index.d.ts

@@ -1,2 +1,3 @@
-declare const router: import("express-serve-static-core").Router;
+/// <reference types="express" />
+declare const router: import("express").Router;
 export default router;

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

@@ -27,12 +27,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const errors_1 = require("@autofleet/errors");
-const express_1 = require("express");
+const node_common_1 = require("@autofleet/node-common");
 const errors_2 = __importDefault(require("../errors"));
 const DefinitionRepo = __importStar(require("../../../repository/definition"));
 const validations_1 = require("./validations");
 const logger_1 = __importDefault(require("../../../utils/logger"));
-const router = (0, express_1.Router)({ mergeParams: true });
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
 const ENTITY = 'CustomFieldDefinition';
 const toPascalCase = (str) => str.replace(/(^\w|-\w)/g, (subStr) => subStr.replace(/-/, '').toUpperCase());
 /**
@@ -51,7 +51,7 @@ router.post('/', async (req, res) => {
     }
     catch (err) {
         logger_1.default.error('Failed to create custom field definition', err);
-        return (0, errors_2.default)(err, res, { message: `Error in create ${ENTITY} request` });
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in create ${ENTITY} request` });
     }
 });
 /**
@@ -68,27 +68,26 @@ router.get('/:customFieldDefinitionId', async (req, res) => {
     }
     catch (err) {
         logger_1.default.error('Failed to fetch custom field definition', err);
-        return (0, errors_2.default)(err, res, { message: `Error in get ${ENTITY} request` });
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get ${ENTITY} request` });
     }
 });
 /**
  * Get all
  */
 router.get('/', async (req, res) => {
-    const { modelName } = req.params;
-    const { entityIds } = req.query;
+    const { params: { modelName }, query: { entityIds } } = req;
     const modelType = toPascalCase(modelName);
     try {
-        const where = { modelType };
-        if (entityIds?.length > 0) {
-            where.entityId = entityIds;
-        }
-        const customFieldDefinitions = await DefinitionRepo.findAll({ ...where }, { withDisabled: true });
+        const where = {
+            modelType,
+            ...(entityIds?.length > 0 && { entityId: entityIds }),
+        };
+        const customFieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true });
         return res.json(customFieldDefinitions);
     }
     catch (err) {
         logger_1.default.error('Failed to fetch custom field definitions', err);
-        return (0, errors_2.default)(err, res, { message: `Error in get all ${ENTITY} request` });
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get all ${ENTITY} request` });
     }
 });
 /**
@@ -98,7 +97,6 @@ router.patch('/:customFieldDefinitionId', async (req, res) => {
     const { customFieldDefinitionId, modelName } = req.params;
     const modelType = toPascalCase(modelName);
     try {
-        // eslint-disable-next-line max-len
         const validatedPayload = await (0, validations_1.validateCustomFieldDefinitionUpdate)(req.body);
         const customFieldDefinition = await DefinitionRepo.findByWhere({
             id: customFieldDefinitionId,
@@ -112,7 +110,7 @@ router.patch('/:customFieldDefinitionId', async (req, res) => {
     }
     catch (err) {
         logger_1.default.error('Failed to patch custom field definition', err);
-        return (0, errors_2.default)(err, res, { message: `Error in update ${ENTITY} request` });
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in update ${ENTITY} request` });
     }
 });
 exports.default = router;

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

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCustomFieldDefinitionUpdate = exports.validateCustomFieldDefinitionCreation = void 0;
+/* eslint-disable newline-per-chained-call */
 const joi_1 = __importDefault(require("joi"));
 const constants_1 = require("../../../utils/constants");
 const FileValidationSchema = joi_1.default.object({
@@ -16,7 +17,6 @@ const statusValidationObject = 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');
 /**
  * Schema for the validation of custom field definition
  * The only custom validation is for
@@ -28,23 +28,23 @@ const statusValidationObjectSchema = joi_1.default.array().items(statusValidatio
  */
 const ValidationSchema = joi_1.default.when('fieldType', {
     is: constants_1.CustomFieldDefinitionType.SELECT,
-    then: joi_1.default.array().items(joi_1.default.string()).min(1).unique(),
-    otherwise: joi_1.default.any(),
-}).when('fieldType', {
-    is: constants_1.CustomFieldDefinitionType.STATUS,
-    then: statusValidationObjectSchema,
-    otherwise: joi_1.default.any(),
+    then: joi_1.default.array().required().items(joi_1.default.string()).min(1).unique(),
+    otherwise: joi_1.default.when('fieldType', {
+        is: constants_1.CustomFieldDefinitionType.STATUS,
+        then: joi_1.default.array().required().items(statusValidationObject).min(1).unique('value'),
+        otherwise: joi_1.default.forbidden(),
+    }),
 });
 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.FILE, then: joi_1.default.array().items(FileValidationSchema).allow(null) },
+        { is: constants_1.CustomFieldDefinitionType.IMAGE, then: joi_1.default.array().items(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.STATUS, then: joi_1.default.string().allow(null) },
         { is: constants_1.CustomFieldDefinitionType.TEXT, then: joi_1.default.string().allow(null) },
     ],
 });
@@ -59,7 +59,8 @@ const CustomFieldDefinitionCreationSchema = joi_1.default.object({
     description: joi_1.default.string(),
     required: joi_1.default.boolean(),
     disabled: joi_1.default.boolean(),
-});
+    blockEditingFromUI: joi_1.default.boolean(),
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
 const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
     displayName: joi_1.default.string(),
     validation: ValidationSchema,
@@ -68,7 +69,8 @@ const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
     description: joi_1.default.string().allow(null),
     required: joi_1.default.boolean(),
     disabled: joi_1.default.boolean(),
-});
+    blockEditingFromUI: joi_1.default.boolean(),
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
 const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
 exports.validateCustomFieldDefinitionCreation = validateCustomFieldDefinitionCreation;
 const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });

package/dist/api/v1/errors.d.ts

@@ -1,2 +1,4 @@
-declare const _default: (err: any, res: any, additionalData?: any) => Promise<any>;
+import type { Response } from 'express';
+import { type LogPayload } from '@autofleet/errors';
+declare const _default: (err: any, res: Response, additionalData?: LogPayload) => void;
 export default _default;

package/dist/api/v1/errors.js

@@ -5,10 +5,7 @@ const joi_1 = require("joi");
 const sequelize_1 = require("sequelize");
 exports.default = (err, res, additionalData = undefined) => {
     let error = err;
-    if (err instanceof joi_1.ValidationError) {
-        error = new errors_1.BadRequest([err], null);
-    }
-    if (err instanceof sequelize_1.ValidationError) {
+    if ([joi_1.ValidationError, sequelize_1.ValidationError].some((ErrClass) => err instanceof ErrClass)) {
         error = new errors_1.BadRequest([err], null);
     }
     return (0, errors_1.handleError)(error, res, additionalData);

package/dist/api/v1/index.d.ts

@@ -1,2 +1,3 @@
-declare const router: import("express-serve-static-core").Router;
+/// <reference types="express" />
+declare const router: import("express").Router;
 export default router;

package/dist/api/v1/index.js

@@ -3,8 +3,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const express_1 = require("express");
+const node_common_1 = require("@autofleet/node-common");
+const logger_1 = __importDefault(require("../../utils/logger"));
 const definition_1 = __importDefault(require("./definition"));
-const router = (0, express_1.Router)({ mergeParams: true });
+const validator_1 = __importDefault(require("./validator"));
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
 router.use('/custom-field-definitions/:modelName', definition_1.default);
+router.use('/custom-validators/:modelName', validator_1.default);
 exports.default = router;

package/dist/api/v1/validator/index.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="express" />
+declare const router: import("express").Router;
+export default router;

package/dist/api/v1/validator/index.js

@@ -0,0 +1,143 @@
+"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 errors_1 = require("@autofleet/errors");
+const node_common_1 = require("@autofleet/node-common");
+const http_status_codes_1 = require("http-status-codes");
+const errors_2 = __importDefault(require("../errors"));
+const ValidatorRepo = __importStar(require("../../../repository/validator"));
+const validations_1 = __importDefault(require("./validations"));
+const logger_1 = __importDefault(require("../../../utils/logger"));
+const validator_schema_1 = require("../../../utils/validations/schema/validator-schema");
+const router = (0, node_common_1.Router)({ logger: logger_1.default });
+const ENTITY = 'CustomValidator';
+/**
+ * Create
+ */
+router.post('/', async (req, res) => {
+    const { modelName } = req.params;
+    try {
+        // Validate the request body
+        const validatedPayload = await validations_1.default.create.validateAsync(req.body);
+        // Validate that the schema is a valid AJV schema
+        (0, validator_schema_1.validateValidatorSchema)(validatedPayload.schema);
+        const validator = await ValidatorRepo.create({
+            ...validatedPayload,
+            modelType: modelName,
+        });
+        return res.status(http_status_codes_1.StatusCodes.CREATED).json(validator);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in create ${ENTITY} request` });
+    }
+});
+/**
+ * Get all
+ */
+router.get('/', async (req, res) => {
+    try {
+        const { modelName } = req.params;
+        const { entityId, entityType } = req.query;
+        const where = {
+            modelType: modelName,
+            ...(entityId && { entityId }),
+            ...(entityType && { entityType }),
+        };
+        const validators = await ValidatorRepo.findAll(where);
+        return res.status(http_status_codes_1.StatusCodes.OK).json({ validators });
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get all ${ENTITY} request` });
+    }
+});
+/**
+ * Get by id
+ */
+router.get('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId, modelName } = req.params;
+        // Include disabled validators when fetching by ID
+        const validators = await ValidatorRepo.findAll({ id: validatorId, modelType: modelName }, { withDisabled: true });
+        if (!validators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        return res.status(http_status_codes_1.StatusCodes.OK).json(validators[0]);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get ${ENTITY} request` });
+    }
+});
+/**
+ * Update
+ */
+router.patch('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId } = req.params;
+        // Validate the request body
+        const validatedPayload = await validations_1.default.update.validateAsync(req.body);
+        // If schema is included in the update, validate that it's a valid AJV schema
+        if (validatedPayload.schema) {
+            (0, validator_schema_1.validateValidatorSchema)(validatedPayload.schema);
+        }
+        // First verify the validator exists, including disabled ones
+        const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+        if (!existingValidators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
+        if (!count) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        return res.status(http_status_codes_1.StatusCodes.OK).json(validators[0]);
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in update ${ENTITY} request` });
+    }
+});
+/**
+ * Delete (disable)
+ */
+router.delete('/:validatorId', async (req, res) => {
+    try {
+        const { validatorId } = req.params;
+        // First verify the validator exists, including disabled ones
+        const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
+        if (!existingValidators.length) {
+            throw new errors_1.ResourceNotFoundError('Validator not found');
+        }
+        const [count] = await ValidatorRepo.disable(validatorId);
+        if (!count) {
+            throw new errors_1.ResourceNotFoundError('Validator failed to be disabled');
+        }
+        return res.status(http_status_codes_1.StatusCodes.NO_CONTENT).send();
+    }
+    catch (err) {
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in delete ${ENTITY} request` });
+    }
+});
+exports.default = router;

package/dist/api/v1/validator/validations.d.ts

@@ -0,0 +1,6 @@
+import Joi from 'joi';
+declare const validationSchemas: {
+    create: Joi.ObjectSchema<any>;
+    update: Joi.ObjectSchema<any>;
+};
+export default validationSchemas;

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

@@ -0,0 +1,40 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const joi_1 = __importDefault(require("joi"));
+// Schema for validating JSON Schema objects
+const jsonSchemaValidation = joi_1.default.object().unknown(true);
+const validationSchemas = {
+    create: joi_1.default.object({
+        entityId: joi_1.default.string().uuid().required(),
+        entityType: joi_1.default.string().required(),
+        schema: joi_1.default.object({
+            type: joi_1.default.string().valid('object').required(),
+            properties: joi_1.default.object({
+                before: jsonSchemaValidation,
+                after: jsonSchemaValidation,
+            }).required(),
+            if: joi_1.default.object().optional(),
+            then: joi_1.default.object().optional(),
+            else: joi_1.default.object().optional(),
+        }).required(),
+    }),
+    update: joi_1.default.object({
+        entityId: joi_1.default.string().uuid(),
+        entityType: joi_1.default.string(),
+        schema: joi_1.default.object({
+            type: joi_1.default.string().valid('object'),
+            properties: joi_1.default.object({
+                before: jsonSchemaValidation,
+                after: jsonSchemaValidation,
+            }),
+            if: joi_1.default.object().optional(),
+            then: joi_1.default.object().optional(),
+            else: joi_1.default.object().optional(),
+        }),
+        disabled: joi_1.default.boolean(),
+    }).min(1),
+};
+exports.default = validationSchemas;

package/dist/errors/index.d.ts

@@ -1,4 +1,6 @@
 import { BadRequest } from '@autofleet/errors';
+import type { ValidationError } from 'joi';
+import type { EntriesValidationError } from '../types/entries';
 export declare class MissingRequiredCustomFieldError extends BadRequest {
     constructor(missingFields: string[]);
 }
@@ -8,8 +10,14 @@ export declare class UnsupportedCustomFieldTypeError extends BadRequest {
 export declare class UnsupportedCustomValidationError extends BadRequest {
     constructor(fieldType: string);
 }
+export declare class InvalidFieldTypeError extends BadRequest {
+    constructor(fieldType: string);
+}
 export declare class InvalidValueError extends BadRequest {
-    constructor(value: any, fieldType: string);
+    constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError);
+}
+export declare class InvalidEntriesError extends BadRequest {
+    constructor(modelId: string, validationErrors: EntriesValidationError[]);
 }
 export declare class MissingDefinitionError extends BadRequest {
     constructor(fieldNames: string[]);

package/dist/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MissingDefinitionError = exports.InvalidValueError = exports.UnsupportedCustomValidationError = exports.UnsupportedCustomFieldTypeError = exports.MissingRequiredCustomFieldError = void 0;
+exports.MissingDefinitionError = exports.InvalidEntriesError = exports.InvalidValueError = exports.InvalidFieldTypeError = exports.UnsupportedCustomValidationError = exports.UnsupportedCustomFieldTypeError = exports.MissingRequiredCustomFieldError = void 0;
 /* eslint-disable max-classes-per-file */
 const errors_1 = require("@autofleet/errors");
 class MissingRequiredCustomFieldError extends errors_1.BadRequest {
@@ -27,14 +27,35 @@ class UnsupportedCustomValidationError extends errors_1.BadRequest {
     }
 }
 exports.UnsupportedCustomValidationError = UnsupportedCustomValidationError;
+class InvalidFieldTypeError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Invalid field type ${fieldType}`);
+        super([err], null, null);
+        this.message = 'INVALID_FIELD_TYPE';
+    }
+}
+exports.InvalidFieldTypeError = InvalidFieldTypeError;
 class InvalidValueError extends errors_1.BadRequest {
-    constructor(value, fieldType) {
-        const err = new Error(`Invalid "${fieldType}" value ${JSON.stringify(value)}`);
+    constructor(value, fieldDefinitionName, joiValidationError) {
+        const formattedErrorMessage = joiValidationError.message
+            .replace(/"/g, '')
+            .replace('value', `'${fieldDefinitionName}'`);
+        const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
+        const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
+        const err = new Error(invalidValueMessage);
         super([err], null, null);
-        this.message = 'INVALID_VALUE';
+        this.message = invalidValueMessage;
     }
 }
 exports.InvalidValueError = InvalidValueError;
+class InvalidEntriesError extends errors_1.BadRequest {
+    constructor(modelId, validationErrors) {
+        const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
+        super(errors, null, null);
+        this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (`${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`)).join('\n')}`;
+    }
+}
+exports.InvalidEntriesError = InvalidEntriesError;
 class MissingDefinitionError extends errors_1.BadRequest {
     constructor(fieldNames) {
         const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);

package/dist/events/index.d.ts

@@ -1,4 +1,5 @@
 import Events from '@autofleet/events';
+import type { CustomFieldDefinition, CustomFieldEntries, CustomFieldValue, CustomValidator } from '../models';
 declare const events: Events;
-export declare const sendDimEvent: (instance: any) => void;
+export declare const sendDimEvent: (instance: CustomFieldDefinition | CustomFieldValue | CustomFieldEntries | CustomValidator) => void;
 export default events;

package/dist/events/index.js

@@ -5,20 +5,22 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.sendDimEvent = void 0;
 const events_1 = __importDefault(require("@autofleet/events"));
+const zehut_1 = require("@autofleet/zehut");
 const logger_1 = __importDefault(require("../utils/logger"));
-const events = new events_1.default({ logger: logger_1.default });
-const KEYS_TO_CONVERT = ['value', 'defaultValue'];
+const events = new events_1.default({
+    logger: logger_1.default,
+    getUserId: (payload) => payload?.user_id ?? (0, zehut_1.getUser)()?.id ?? null,
+});
+const KEYS_TO_CONVERT = ['value', 'defaultValue', 'blockEditingFromUI'];
 const stringifyBooleans = (savedObject, keysToConvert) => {
-    if (!Object.keys(savedObject).some((key) => keysToConvert.includes(key))) {
+    const savedObjectKeySet = new Set(Object.keys(savedObject));
+    if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) {
         return savedObject;
     }
-    const objectToReturn = { ...savedObject };
-    keysToConvert.forEach((key) => {
-        if (typeof savedObject[key] === 'boolean') {
-            objectToReturn[key] = savedObject[key].toString();
-        }
-    });
-    return objectToReturn;
+    return {
+        ...savedObject,
+        ...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === 'boolean' ? savedObject[key].toString() : savedObject[key]])),
+    };
 };
 const modelTableMapping = {
     CustomFieldDefinition: {
@@ -29,6 +31,10 @@ const modelTableMapping = {
         tableName: 'dim_custom_field_value',
         eventVersion: '1',
     },
+    CustomFieldEntries: {
+        tableName: 'dim_custom_field_entries',
+        eventVersion: '1',
+    },
 };
 const sendDimEvent = (instance) => {
     const mapping = modelTableMapping[instance.constructor.name];
@@ -42,7 +48,7 @@ const sendDimEvent = (instance) => {
     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).catch(() => { });
 };
 exports.sendDimEvent = sendDimEvent;
 exports.default = events;

package/dist/hooks/create.d.ts

@@ -1,4 +1,4 @@
-import type { ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions } from '../types';
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
  */
@@ -7,4 +7,4 @@ export declare const beforeBulkCreate: (options: any) => void;
  * A hook to create the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export declare const beforeCreate: (scopeAttributes: string[], modelOptions?: ModelOptions) => (instance: any, options: any) => Promise<void>;
+export declare const beforeCreate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;

package/dist/hooks/create.js

@@ -28,10 +28,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.beforeCreate = exports.beforeBulkCreate = void 0;
 const logger_1 = __importDefault(require("../utils/logger"));
-const ValueRepo = __importStar(require("../repository/value"));
 const DefinitionRepo = __importStar(require("../repository/definition"));
 const errors_1 = require("../errors");
 const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+const updateInstanceValues_1 = __importDefault(require("./utils/updateInstanceValues"));
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
  */
@@ -45,30 +45,51 @@ exports.beforeBulkCreate = beforeBulkCreate;
  * A hook to create the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-const beforeCreate = (scopeAttributes, modelOptions = {}) => async (instance, options) => {
+const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => 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 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,
-        }, true);
+    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 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) => (instance.customFields?.[def.name] === undefined)).forEach(({ name, defaultValue }) => {
+            // eslint-disable-next-line no-param-reassign
+            instance.customFields[name] = defaultValue;
+        });
+    }
+    const { customFields } = instance;
+    const fieldsNames = Object.keys(customFields ?? {});
+    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+    if (missingFields?.length) {
+        throw new errors_1.MissingRequiredCustomFieldError(missingFields);
     }
-    else if (requiredFieldsNames?.length > 0) {
-        throw new errors_1.MissingRequiredCustomFieldError(requiredFieldsNames);
+    const customFieldsIdx = fields.indexOf('customFields');
+    if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
+        // After checking for required fields and fields with default values, and we have no custom fields.
+        return;
     }
+    await (0, updateInstanceValues_1.default)({
+        modelId: instance.id,
+        modelType,
+        identifiers,
+        customFields,
+        options: {
+            useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+            transaction: options.transaction,
+            modelOptions,
+        },
+    });
+    // eslint-disable-next-line no-param-reassign
+    fields.splice(customFieldsIdx, 1);
 };
 exports.beforeCreate = beforeCreate;