@autofleet/sadot 0.0.1-beta.9 → 0.0.2-beta

package/dist/jest.config.d.ts

@@ -0,0 +1,12 @@
+export const testEnvironment: string;
+export const roots: string[];
+export const transform: {
+    '^.+\\.tsx?$': string;
+};
+export const testRegex: string;
+export const moduleFileExtensions: string[];
+export namespace coverageThreshold {
+    namespace global {
+        const lines: number;
+    }
+}

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

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/{api → src/api}/index.js

@@ -9,4 +9,3 @@ const v1_1 = __importDefault(require("./v1"));
 const router = (0, express_1.Router)({ mergeParams: true });
 router.use('/v1', v1_1.default);
 exports.default = router;
-//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/{api → src/api}/v1/definition/index.js

@@ -22,15 +22,6 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
@@ -47,26 +38,29 @@ const toPascalCase = (str) => str.replace(/(^\w|-\w)/g, (subStr) => subStr.repla
 /**
  * Create
  */
-router.post('/', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+router.post('/', async (req, res) => {
     const { modelName } = req.params;
     const modelType = toPascalCase(modelName);
     try {
-        const validatedPayload = yield (0, validations_1.validateCustomFieldDefinitionCreation)(Object.assign(Object.assign({}, req.body), { modelType }));
-        const customFieldDefinition = yield DefinitionRepo.create(validatedPayload);
+        const validatedPayload = await (0, validations_1.validateCustomFieldDefinitionCreation)(req.body);
+        const customFieldDefinition = await DefinitionRepo.create({
+            ...validatedPayload,
+            modelType,
+        });
         return res.status(201).json(customFieldDefinition);
     }
     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` });
     }
-}));
+});
 /**
  * Get by id
  */
-router.get('/:customFieldDefinitionId', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+router.get('/:customFieldDefinitionId', async (req, res) => {
     const { customFieldDefinitionId } = req.params;
     try {
-        const customFieldDefinition = yield DefinitionRepo.findById(customFieldDefinitionId);
+        const customFieldDefinition = await DefinitionRepo.findById(customFieldDefinitionId);
         if (!customFieldDefinition) {
             throw new errors_1.ResourceNotFoundError();
         }
@@ -76,47 +70,49 @@ router.get('/:customFieldDefinitionId', (req, res) => __awaiter(void 0, void 0,
         logger_1.default.error('Failed to fetch custom field definition', err);
         return (0, errors_2.default)(err, res, { message: `Error in get ${ENTITY} request` });
     }
-}));
+});
 /**
  * Get all
  */
-router.get('/', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+router.get('/', async (req, res) => {
     const { modelName } = req.params;
+    const { entityIds } = req.query;
     const modelType = toPascalCase(modelName);
     try {
-        const customFieldDefinitions = yield DefinitionRepo.findAll({
-            modelType,
-        }, { withDisabled: true });
+        const where = { modelType };
+        if (entityIds?.length > 0) {
+            where.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` });
     }
-}));
+});
 /**
  * Update
  */
-router.patch('/:customFieldDefinitionId', (req, res) => __awaiter(void 0, void 0, void 0, function* () {
+router.patch('/:customFieldDefinitionId', async (req, res) => {
     const { customFieldDefinitionId, modelName } = req.params;
     const modelType = toPascalCase(modelName);
     try {
         // eslint-disable-next-line max-len
-        const validatedPayload = yield (0, validations_1.validateCustomFieldDefinitionUpdate)(req.body);
-        const customFieldDefinition = yield DefinitionRepo.findByWhere({
+        const validatedPayload = await (0, validations_1.validateCustomFieldDefinitionUpdate)(req.body);
+        const customFieldDefinition = await DefinitionRepo.findByWhere({
             id: customFieldDefinitionId,
             modelType,
         });
         if (!customFieldDefinition) {
             throw new errors_1.ResourceNotFoundError();
         }
-        const updatedCustomFieldDefinition = yield DefinitionRepo.update(customFieldDefinitionId, validatedPayload);
+        const updatedCustomFieldDefinition = await DefinitionRepo.update(customFieldDefinitionId, { ...validatedPayload, modelType });
         return res.status(200).json(updatedCustomFieldDefinition);
     }
     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` });
     }
-}));
+});
 exports.default = router;
-//# sourceMappingURL=index.js.map

package/dist/src/api/v1/definition/validations.d.ts

@@ -0,0 +1,2 @@
+export declare const validateCustomFieldDefinitionCreation: (payload: any) => any;
+export declare const validateCustomFieldDefinitionUpdate: (payload: any) => any;

package/dist/{api → src/api}/v1/definition/validations.js

@@ -5,26 +5,27 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCustomFieldDefinitionUpdate = exports.validateCustomFieldDefinitionCreation = void 0;
 const joi_1 = __importDefault(require("@hapi/joi"));
-const CustomFieldDefinition_1 = require("../../../models/CustomFieldDefinition");
+const type_1 = require("../../../utils/validations/type");
+const ValidationSchema = joi_1.default.when('fieldType', {
+    is: type_1.CustomFieldDefinitionType.SELECT,
+    then: joi_1.default.array().items(joi_1.default.string()).min(1).unique(),
+    otherwise: joi_1.default.any(),
+});
 const CustomFieldDefinitionCreationSchema = joi_1.default.object({
     name: joi_1.default.string().required(),
     displayName: joi_1.default.string().required(),
-    validation: joi_1.default.object().required(),
-    fieldType: joi_1.default.string().valid(CustomFieldDefinition_1.CustomFieldDefinitionType.BOOLEAN, CustomFieldDefinition_1.CustomFieldDefinitionType.NUMBER, CustomFieldDefinition_1.CustomFieldDefinitionType.DATE, CustomFieldDefinition_1.CustomFieldDefinitionType.DATETIME, CustomFieldDefinition_1.CustomFieldDefinitionType.TEXT, CustomFieldDefinition_1.CustomFieldDefinitionType.IMAGE, CustomFieldDefinition_1.CustomFieldDefinitionType.ENUM).required(),
+    validation: ValidationSchema,
+    fieldType: joi_1.default.string().valid(...Object.values(type_1.CustomFieldDefinitionType)).required(),
     entityId: joi_1.default.string().guid().required(),
     entityType: joi_1.default.string().required(),
-    modelType: joi_1.default.string().required(),
     description: joi_1.default.string(),
     required: joi_1.default.boolean(),
     disabled: joi_1.default.boolean(),
 });
 const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
     displayName: joi_1.default.string(),
-    validation: joi_1.default.object(),
-    fieldType: joi_1.default.string().valid(CustomFieldDefinition_1.CustomFieldDefinitionType.BOOLEAN, CustomFieldDefinition_1.CustomFieldDefinitionType.NUMBER, CustomFieldDefinition_1.CustomFieldDefinitionType.DATE, CustomFieldDefinition_1.CustomFieldDefinitionType.DATETIME, CustomFieldDefinition_1.CustomFieldDefinitionType.TEXT, CustomFieldDefinition_1.CustomFieldDefinitionType.IMAGE, CustomFieldDefinition_1.CustomFieldDefinitionType.ENUM),
-    entityId: joi_1.default.string().guid(),
-    entityType: joi_1.default.string(),
-    modelType: joi_1.default.string(),
+    validation: ValidationSchema,
+    fieldType: joi_1.default.string().valid(...Object.values(type_1.CustomFieldDefinitionType)),
     description: joi_1.default.string(),
     required: joi_1.default.boolean(),
     disabled: joi_1.default.boolean(),
@@ -33,4 +34,3 @@ const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinition
 exports.validateCustomFieldDefinitionCreation = validateCustomFieldDefinitionCreation;
 const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });
 exports.validateCustomFieldDefinitionUpdate = validateCustomFieldDefinitionUpdate;
-//# sourceMappingURL=validations.js.map

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

@@ -0,0 +1,2 @@
+declare const _default: (err: any, res: any, additionalData?: {}) => any;
+export default _default;

package/dist/{api → src/api}/v1/errors.js

@@ -13,4 +13,3 @@ exports.default = (err, res, additionalData = {}) => {
     }
     return (0, errors_1.handleError)(error, res, additionalData);
 };
-//# sourceMappingURL=errors.js.map

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

@@ -0,0 +1,2 @@
+declare const router: import("express-serve-static-core").Router;
+export default router;

package/dist/{api → src/api}/v1/index.js

@@ -6,6 +6,5 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const express_1 = require("express");
 const definition_1 = __importDefault(require("./definition"));
 const router = (0, express_1.Router)({ mergeParams: true });
-router.use('/:modelName/custom-field-definitions', definition_1.default);
+router.use('/custom-field-definitions/:modelName', definition_1.default);
 exports.default = router;
-//# sourceMappingURL=index.js.map

package/dist/src/errors/index.d.ts

@@ -0,0 +1,16 @@
+import { BadRequest } from '@autofleet/errors';
+export declare class MissingRequiredCustomFieldError extends BadRequest {
+    constructor(missingFields: string[]);
+}
+export declare class UnsupportedCustomFieldTypeError extends BadRequest {
+    constructor(fieldType: string);
+}
+export declare class UnsupportedCustomValidationError extends BadRequest {
+    constructor(fieldType: string);
+}
+export declare class InvalidValueError extends BadRequest {
+    constructor(value: any, fieldType: string);
+}
+export declare class MissingDefinitionError extends BadRequest {
+    constructor(fieldNames: string[]);
+}

package/dist/src/errors/index.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MissingDefinitionError = exports.InvalidValueError = 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 {
+    constructor(missingFields) {
+        const err = new Error(`The following custom fields are required: ${missingFields.join(',')}`);
+        super([err], null, missingFields);
+        this.message = 'MISSING_REQUIRED_CUSTOM_FIELDS';
+    }
+}
+exports.MissingRequiredCustomFieldError = MissingRequiredCustomFieldError;
+class UnsupportedCustomFieldTypeError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Type "${fieldType}" is not supported`);
+        super([err], null, null);
+        this.message = 'UNSUPPORTED_CUSTOM_FIELD_TYPE';
+    }
+}
+exports.UnsupportedCustomFieldTypeError = UnsupportedCustomFieldTypeError;
+class UnsupportedCustomValidationError extends errors_1.BadRequest {
+    constructor(fieldType) {
+        const err = new Error(`Validation for "${fieldType}" is not supported`);
+        super([err], null, null);
+        this.message = 'UNSUPPORTED_CUSTOM_VALIDATION_TYPE';
+    }
+}
+exports.UnsupportedCustomValidationError = UnsupportedCustomValidationError;
+class InvalidValueError extends errors_1.BadRequest {
+    constructor(value, fieldType) {
+        const err = new Error(`Invalid "${fieldType}" value ${JSON.stringify(value)}`);
+        super([err], null, null);
+        this.message = 'INVALID_VALUE';
+    }
+}
+exports.InvalidValueError = InvalidValueError;
+class MissingDefinitionError extends errors_1.BadRequest {
+    constructor(fieldNames) {
+        const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);
+        super([err], null, null);
+        this.message = 'MISSING_DEFINITION';
+    }
+}
+exports.MissingDefinitionError = MissingDefinitionError;

package/dist/src/events/index.d.ts

@@ -0,0 +1,4 @@
+import Events from '@autofleet/events';
+declare const events: Events;
+export declare const sendDimEvent: (instance: any) => void;
+export default events;

package/dist/{events → src/events}/index.js

@@ -7,6 +7,19 @@ 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;
+    }
+    return savedObject;
+};
 const modelTableMapping = {
     CustomFieldDefinition: {
         tableName: 'dim_custom_field_definition',
@@ -20,9 +33,15 @@ const modelTableMapping = {
 const sendDimEvent = (instance) => {
     const mapping = modelTableMapping[instance.constructor.name];
     if (mapping) {
-        events.sendObject(mapping.tableName, mapping.eventVersion, instance.get());
+        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);
     }
 };
 exports.sendDimEvent = sendDimEvent;
 exports.default = events;
-//# sourceMappingURL=index.js.map

package/dist/src/hooks/create.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A hook to create the custom fields when updating a model (more then one instance).
+ */
+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[]) => (instance: any, options: any) => Promise<void>;

package/dist/{hooks → src/hooks}/create.js

@@ -22,19 +22,15 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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");
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
  */
@@ -48,26 +44,27 @@ exports.beforeBulkCreate = beforeBulkCreate;
  * A hook to create the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-const beforeCreate = (scopeAttributes) => (instance, options) => __awaiter(void 0, void 0, void 0, function* () {
+const beforeCreate = (scopeAttributes) => async (instance, options) => {
+    logger_1.default.debug('sadot - before create hook');
     const { fields } = options;
     const modelType = instance.constructor.name;
     const identifiers = scopeAttributes.map((attribute) => instance[attribute]);
     // get all model's required definitions
-    const requiredFieldsNames = yield DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers);
+    const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers);
     const customFieldsIdx = fields.indexOf('customFields');
     const { customFields } = instance;
     if (customFieldsIdx > -1 && customFields) {
         const fieldsNames = Object.keys(customFields);
-        if (requiredFieldsNames.some((name) => !fieldsNames.includes(name))) {
-            throw new Error('some fields are required');
+        const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+        if (missingFields?.length > 0) {
+            throw new errors_1.MissingRequiredCustomFieldError(missingFields);
         }
-        yield ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, { transaction: options.transaction });
+        await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, { transaction: options.transaction });
         // eslint-disable-next-line no-param-reassign
         fields.splice(customFieldsIdx, 1);
     }
-    else if ((requiredFieldsNames === null || requiredFieldsNames === void 0 ? void 0 : requiredFieldsNames.length) > 0) {
-        throw new Error('some fields are required');
+    else if (requiredFieldsNames?.length > 0) {
+        throw new errors_1.MissingRequiredCustomFieldError(requiredFieldsNames);
     }
-});
+};
 exports.beforeCreate = beforeCreate;
-//# sourceMappingURL=create.js.map

package/dist/src/hooks/enrich.d.ts

@@ -0,0 +1,5 @@
+/**
+ * A hook to attach the custom fields when fetching a model instances.
+ */
+declare const enrichResults: (modelType: string, scopeAttributes: string[]) => (instancesOrInstance: any | any[], options: any) => Promise<void>;
+export default enrichResults;

package/dist/src/hooks/enrich.js

@@ -0,0 +1,118 @@
+"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 });
+/* eslint-disable no-param-reassign */
+const ValueRepo = __importStar(require("../repository/value"));
+const DefinitionRepo = __importStar(require("../repository/definition"));
+const logger_1 = __importDefault(require("../utils/logger"));
+/**
+ * Serialize custom fields value into the format of {[name] -> [fieldData]}
+ */
+const serializeCustomFields = (customFieldValues, customFieldDefinitionsHash) => {
+    const customFields = customFieldValues.reduce((acc, cfv) => ({
+        ...acc,
+        ...(customFieldDefinitionsHash[cfv.customFieldDefinitionId]
+            && { [customFieldDefinitionsHash[cfv.customFieldDefinitionId].name]: cfv.value }),
+    }), {});
+    return customFields;
+};
+/**
+ * A hook to attach the custom fields when fetching a model instances.
+ */
+const enrichResults = (modelType, scopeAttributes) => async (instancesOrInstance, options) => {
+    if (options.originalAttributes?.length > 0
+        && !options.originalAttributes?.includes?.('customFields')) {
+        return;
+    }
+    const primaryKey = 'id';
+    let instances = Array.isArray(instancesOrInstance)
+        ? instancesOrInstance
+        : [instancesOrInstance];
+    instances = instances.filter(Boolean);
+    const identifiers = instances.map((instance) => scopeAttributes
+        .map((attr) => instance[attr])).flat();
+    const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
+    const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
+        ...map,
+        [identifier]: [],
+    }), {});
+    const customFieldDefinitions = await DefinitionRepo.findByEntityIds(modelType, uniqueIdentifiers, { transaction: options.transaction });
+    const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({
+        ...map,
+        [definition.id]: definition,
+    }), {});
+    customFieldDefinitions.forEach((cfd) => {
+        identifierCustomFieldDefinitionsMapping[cfd.entityId].push(cfd);
+    });
+    // Get the values per instates ids:
+    const instancesIds = instances.map((i) => i[primaryKey]);
+    const customFieldValues = await ValueRepo.findValuesByModelIds(instancesIds, { transaction: options.transaction });
+    // Group fields by modelId
+    const valuesGroupByInstance = customFieldValues.reduce((acc, v) => {
+        const { modelId } = v;
+        if (!acc[modelId]) {
+            acc[modelId] = [];
+        }
+        acc[modelId].push(v);
+        return acc;
+    }, {});
+    // Attach custom fields to the instances
+    instances.forEach((instance) => {
+        const customFields = {};
+        const { id } = instance;
+        const instanceValues = valuesGroupByInstance[id];
+        if (instanceValues) {
+            const serializedCustomFields = serializeCustomFields(instanceValues, definitionsMap);
+            Object.assign(customFields, serializedCustomFields);
+        }
+        scopeAttributes.forEach((attribute) => {
+            const identifier = instance[attribute];
+            const entityCustomFieldDefinitions = identifierCustomFieldDefinitionsMapping[identifier];
+            if (entityCustomFieldDefinitions?.length > 0) {
+                entityCustomFieldDefinitions.forEach((customFieldDefinition) => {
+                    if (customFields[customFieldDefinition.name] === undefined) {
+                        customFields[customFieldDefinition.name] = null;
+                    }
+                });
+            }
+        });
+        if (customFields && Object.keys(customFields).length > 0) {
+            logger_1.default.info('sadot - enrichResults - customFields', customFields);
+            instance.customFields = customFields;
+        }
+        else {
+            logger_1.default.info('sadot - enrichResults - no customFields');
+        }
+        options.attributesToRemove?.forEach?.((attribute) => {
+            delete instance.dataValues?.[attribute];
+            // if raw:
+            delete instance?.[attribute];
+        });
+    });
+};
+exports.default = enrichResults;

package/dist/src/hooks/find.d.ts

@@ -0,0 +1 @@
+export declare const beforeFind: (scopeAttributes: string[]) => (options: any) => void;

package/dist/src/hooks/find.js

@@ -0,0 +1,29 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeFind = void 0;
+/* eslint-disable no-param-reassign */
+const logger_1 = __importDefault(require("../utils/logger"));
+const doScopeAttributesMissing = (scopeAttributes, queryAttributes) => {
+    const attributes = scopeAttributes
+        .filter((attribute) => !queryAttributes.includes(attribute));
+    if (!queryAttributes.includes?.('id')) {
+        attributes.push('id');
+    }
+    return attributes;
+};
+// eslint-disable-next-line import/prefer-default-export
+const beforeFind = (scopeAttributes) => (options) => {
+    const { attributes: queryAttributes } = options;
+    if (queryAttributes?.includes('customFields')) {
+        const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
+        logger_1.default.debug('sadot - before find hook');
+        if (missingScopeAttributes?.length > 0) {
+            queryAttributes.push(...missingScopeAttributes);
+            options.attributesToRemove = missingScopeAttributes;
+        }
+    }
+};
+exports.beforeFind = beforeFind;

package/dist/src/hooks/index.d.ts

@@ -0,0 +1,6 @@
+import enrichResults from './enrich';
+import { beforeFind } from './find';
+import { beforeBulkUpdate, beforeUpdate } from './update';
+import { beforeBulkCreate, beforeCreate } from './create';
+import workaround from './workaround';
+export { enrichResults, beforeFind, beforeBulkUpdate, beforeUpdate, beforeBulkCreate, beforeCreate, workaround, };

package/dist/{hooks → src/hooks}/index.js

@@ -4,8 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.workaround = exports.beforeCreate = exports.beforeBulkCreate = exports.beforeUpdate = exports.beforeBulkUpdate = exports.beforeFind = exports.enrichResults = void 0;
+const enrich_1 = __importDefault(require("./enrich"));
+exports.enrichResults = enrich_1.default;
 const find_1 = require("./find");
-Object.defineProperty(exports, "enrichResults", { enumerable: true, get: function () { return find_1.enrichResults; } });
 Object.defineProperty(exports, "beforeFind", { enumerable: true, get: function () { return find_1.beforeFind; } });
 const update_1 = require("./update");
 Object.defineProperty(exports, "beforeBulkUpdate", { enumerable: true, get: function () { return update_1.beforeBulkUpdate; } });
@@ -15,4 +16,3 @@ Object.defineProperty(exports, "beforeBulkCreate", { enumerable: true, get: func
 Object.defineProperty(exports, "beforeCreate", { enumerable: true, get: function () { return create_1.beforeCreate; } });
 const workaround_1 = __importDefault(require("./workaround"));
 exports.workaround = workaround_1.default;
-//# sourceMappingURL=index.js.map

package/dist/src/hooks/update.d.ts

@@ -0,0 +1,9 @@
+/**
+ * A hook to update the custom fields when updating a model (more then one instance).
+ */
+export declare const beforeBulkUpdate: (options: any) => void;
+/**
+ * A hook to update the custom fields when updating a model instance.
+ * TODO - cleanup if update fail
+ */
+export declare const beforeUpdate: (scopeAttributes: string[]) => (instance: any, options: any) => Promise<void>;

package/dist/{hooks → src/hooks}/update.js

@@ -22,19 +22,13 @@ var __importStar = (this && this.__importStar) || function (mod) {
     __setModuleDefault(result, mod);
     return result;
 };
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.beforeUpdate = exports.beforeBulkUpdate = void 0;
+const logger_1 = __importDefault(require("../utils/logger"));
 const ValueRepo = __importStar(require("../repository/value"));
-const DefinitionRepo = __importStar(require("../repository/definition"));
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
  */
@@ -48,26 +42,17 @@ exports.beforeBulkUpdate = beforeBulkUpdate;
  * A hook to update the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-const beforeUpdate = (scopeAttributes) => (instance, options) => __awaiter(void 0, void 0, void 0, function* () {
+const beforeUpdate = (scopeAttributes) => async (instance, options) => {
+    logger_1.default.debug('sadot - before update hook');
     const { fields } = options;
     const modelType = instance.constructor.name;
     const identifiers = scopeAttributes.map((attribute) => instance[attribute]);
-    // get all model's required definitions
-    const requiredNullFieldsNames = yield DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers, true);
     const customFieldsIdx = fields.indexOf('customFields');
     if (customFieldsIdx > -1) {
         const { customFields } = instance;
-        const fieldsNames = Object.keys(customFields);
-        if (requiredNullFieldsNames.some((name) => !fieldsNames.includes(name))) {
-            throw new Error('some fields are required');
-        }
-        yield ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, { transaction: options.transaction });
+        await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, { transaction: options.transaction });
         // eslint-disable-next-line no-param-reassign
         fields.splice(customFieldsIdx, 1);
     }
-    else if ((requiredNullFieldsNames === null || requiredNullFieldsNames === void 0 ? void 0 : requiredNullFieldsNames.length) > 0) {
-        throw new Error('some fields are required');
-    }
-});
+};
 exports.beforeUpdate = beforeUpdate;
-//# sourceMappingURL=update.js.map