@autofleet/sadot 0.6.2-temp-file-2 → 0.6.2-temp-file-4

package/dist/api/index.d.ts

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

package/dist/api/index.js

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// export the api object
+const express_1 = require("express");
+const v1_1 = __importDefault(require("./v1"));
+const router = (0, express_1.Router)({ mergeParams: true });
+router.use('/v1', v1_1.default);
+exports.default = router;

package/dist/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/v1/definition/index.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 });
+const errors_1 = require("@autofleet/errors");
+const express_1 = require("express");
+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 ENTITY = 'CustomFieldDefinition';
+const toPascalCase = (str) => str.replace(/(^\w|-\w)/g, (subStr) => subStr.replace(/-/, '').toUpperCase());
+/**
+ * Create
+ */
+router.post('/', async (req, res) => {
+    const { modelName } = req.params;
+    const modelType = toPascalCase(modelName);
+    try {
+        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', async (req, res) => {
+    const { customFieldDefinitionId } = req.params;
+    try {
+        const customFieldDefinition = await DefinitionRepo.findById(customFieldDefinitionId);
+        if (!customFieldDefinition) {
+            throw new errors_1.ResourceNotFoundError();
+        }
+        return res.json(customFieldDefinition);
+    }
+    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` });
+    }
+});
+/**
+ * Get all
+ */
+router.get('/', async (req, res) => {
+    const { modelName } = req.params;
+    const { entityIds } = req.query;
+    const modelType = toPascalCase(modelName);
+    try {
+        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', 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,
+            modelType,
+        });
+        if (!customFieldDefinition) {
+            throw new errors_1.ResourceNotFoundError();
+        }
+        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;

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

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

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

@@ -0,0 +1,49 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCustomFieldDefinitionUpdate = exports.validateCustomFieldDefinitionCreation = void 0;
+const joi_1 = __importDefault(require("joi"));
+const constants_1 = require("../../../utils/constants");
+/**
+ * Schema for the validation of custom field definition
+ * The only custom validation is for
+ * {@link CustomFieldDefinitionType.SELECT SELECT}
+ * and
+ * {@link CustomFieldDefinitionType.STATUS STATUS}
+ * field types.
+ * The rest of the field types are validated by Joi
+ */
+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: joi_1.default.string().min(1).required(),
+    otherwise: joi_1.default.any(),
+});
+const CustomFieldDefinitionCreationSchema = joi_1.default.object({
+    name: joi_1.default.string().required(),
+    displayName: joi_1.default.string().required(),
+    validation: ValidationSchema,
+    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(),
+    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: ValidationSchema,
+    fieldType: joi_1.default.string().valid(...Object.values(constants_1.CustomFieldDefinitionType)),
+    description: joi_1.default.string().allow(null),
+    required: joi_1.default.boolean(),
+    disabled: joi_1.default.boolean(),
+});
+const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
+exports.validateCustomFieldDefinitionCreation = validateCustomFieldDefinitionCreation;
+const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });
+exports.validateCustomFieldDefinitionUpdate = validateCustomFieldDefinitionUpdate;

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

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

package/dist/api/v1/errors.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("@autofleet/errors");
+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) {
+        error = new errors_1.BadRequest([err], null);
+    }
+    return (0, errors_1.handleError)(error, res, additionalData);
+};

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

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

package/dist/api/v1/index.js

@@ -0,0 +1,10 @@
+"use strict";
+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 definition_1 = __importDefault(require("./definition"));
+const router = (0, express_1.Router)({ mergeParams: true });
+router.use('/custom-field-definitions/:modelName', definition_1.default);
+exports.default = router;

package/dist/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/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/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/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+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',
+        eventVersion: '1',
+    },
+    CustomFieldValue: {
+        tableName: 'dim_custom_field_value',
+        eventVersion: '1',
+    },
+};
+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);
+    }
+};
+exports.sendDimEvent = sendDimEvent;
+exports.default = events;

package/dist/hooks/create.d.ts

@@ -0,0 +1,10 @@
+import type { ModelOptions } from '../types';
+/**
+ * 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[], modelOptions?: ModelOptions) => (instance: any, options: any) => Promise<void>;

package/dist/hooks/create.js

@@ -0,0 +1,74 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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"));
+/**
+ * A hook to create the custom fields when updating a model (more then one instance).
+ */
+const beforeBulkCreate = (options) => {
+    // This will activate the beforeCreate hook on each updating instance.
+    // eslint-disable-next-line no-param-reassign
+    options.individualHooks = true;
+};
+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) => {
+    logger_1.default.debug('sadot - before create hook');
+    const { fields } = options;
+    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,
+        });
+        // eslint-disable-next-line no-param-reassign
+        fields.splice(customFieldsIdx, 1);
+    }
+    else if (requiredFieldsNames?.length > 0) {
+        throw new errors_1.MissingRequiredCustomFieldError(requiredFieldsNames);
+    }
+};
+exports.beforeCreate = beforeCreate;

package/dist/hooks/enrich.d.ts

@@ -0,0 +1,7 @@
+import type { ModelOptions } from '../types';
+type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
+/**
+ * A hook to attach the custom fields when fetching a model instances.
+ */
+declare const enrichResults: (modelType: string, scopeAttributes: string[], hookType?: SupportedHookTypes, modelOptions?: ModelOptions) => (instancesOrInstance: any | any[], options: any) => Promise<void>;
+export default enrichResults;

package/dist/hooks/enrich.js

@@ -0,0 +1,126 @@
+"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 scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+/**
+ * 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, hookType, modelOptions = {}) => 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 = (0, scopeAttributes_1.default)(instances, scopeAttributes);
+    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, modelOptions });
+    if (modelOptions?.include && modelOptions.useEntityIdFromInclude) {
+        // if we pass useEntityIdFromInclude,
+        //  map the entity from the options to the identifierCustomFieldDefinitionsMapping
+        modelOptions.include(identifiers).forEach(({ model }) => {
+            customFieldDefinitions.forEach((cfd) => {
+                const entityId = cfd[`${model.name}.entityId`];
+                identifierCustomFieldDefinitionsMapping[entityId] = [];
+            });
+        });
+    }
+    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;
+                    }
+                });
+            }
+        });
+        instance.customFields = customFields;
+        options.attributesToRemove?.forEach?.((attribute) => {
+            delete instance.dataValues?.[attribute];
+            // if raw:
+            delete instance?.[attribute];
+        });
+        // sequelize will think customFields changed also in 'find', so we need to mark it as unchanged
+        if (hookType === 'afterFind') {
+            // changed() could be undefined, i.e in raw: true
+            instance?.changed?.('customFields', false);
+        }
+    });
+};
+exports.default = enrichResults;

package/dist/hooks/find.d.ts

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

package/dist/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/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/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": 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, "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; } });
+Object.defineProperty(exports, "beforeUpdate", { enumerable: true, get: function () { return update_1.beforeUpdate; } });
+const create_1 = require("./create");
+Object.defineProperty(exports, "beforeBulkCreate", { enumerable: true, get: function () { return create_1.beforeBulkCreate; } });
+Object.defineProperty(exports, "beforeCreate", { enumerable: true, get: function () { return create_1.beforeCreate; } });
+const workaround_1 = __importDefault(require("./workaround"));
+exports.workaround = workaround_1.default;

package/dist/hooks/update.d.ts

@@ -0,0 +1,10 @@
+import type { ModelOptions } from '../types';
+/**
+ * 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[], modelOptions?: ModelOptions) => (instance: any, options: any) => Promise<void>;