@autofleet/sadot 1.1.1 → 1.1.2-beta

package/dist/hooks/hooks.js

@@ -1,2 +1,391 @@
-import e from"../utils/logger/index.js";import{CustomFieldDefinitionType as t}from"../utils/constants/index.js";import{InvalidValueError as n,MissingRequiredCustomFieldError as r}from"../errors/index.js";import{findAll as i}from"../repository/definition.js";import{findAllByModelType as a}from"../repository/validator.js";import o from"../utils/scopeAttributes.js";import s from"./utils/updateInstanceValues.js";import c from"joi";import{BadRequest as l}from"@autofleet/errors";import u from"ajv";import d from"ajv-formats";import f from"ajv-errors";const p=[`id`,`schema`,`modelType`,`entityId`,`disabled`],m=new u({allErrors:!0,strict:!1,strictTypes:!1,$data:!0});d(m),f(m);const h=(e,t)=>({__proto__:null,...e,...t}),g=async(t,n)=>{if(!t.id||!t.customFields||Object.keys(t.customFields).length===0)return t.customFields||{};try{let r=await t.constructor.findOne({where:{id:t.id},attributes:[`customFields`],transaction:n.transaction,raw:!0});if(r?.customFields){let n=h(r.customFields,t.customFields);return e.debug(`sadot - fetched complete custom fields for validation`,{fieldsCount:Object.keys(n).length,updateFieldsCount:Object.keys(t.customFields).length}),n}}catch(t){e.error(`sadot - error fetching complete model for validation`,{error:t})}return t.customFields||{}},_=e=>{let t={...e.dataValues};(e.changed?.()||[]).forEach(n=>{let r=e.previous?.(n);r!==void 0&&(t[n]=r)});let n=e.previous?.(`customFields`);return n!==void 0&&(t.customFields=n),t},v=e=>e.reduce((e,t)=>{let n=((t.instancePath||``).split(`/`).filter(Boolean).join(`.`).replace(/^after\./,``)+(t.keyword===`required`?`.${t.params?.missingProperty}`:``)).replace(/^\./,``)||`root`;return e[n]=t.message||`Invalid value`,e},{}),y=async(t,n,r,i={},s=!1)=>{let c=t.constructor.name;e.debug(`sadot - validating model`,{isCreate:s,modelType:c});let u=o(t,r);if(e.debug(`sadot - identifiers`,{identifiers:u}),!u||Object.keys(u).length===0){e.debug(`sadot - skipping validation: no identifiers`);return}let d=Object.values(u)[0];if(e.debug(`sadot - entityId`,{entityId:d}),!d){e.debug(`sadot - skipping validation: no entityId`);return}let f,y;n.transaction&&(n.transaction.validationsCache??=new Map,y=`${c}-${d}`,f=n.transaction.validationsCache.get(y)),f||(f=a(c,d,{transaction:n.transaction,attributes:p,modelOptions:i}),n.transaction&&n?.transaction?.validationsCache.set(y,f));let b=await f;if(e.debug(`sadot - validators found`,{count:b.length}),!b.length){e.debug(`sadot - skipping validation: no validators found`);return}let x=null;s||(x=_(t));let S=s?t.customFields||{}:await g(t,n);for(let n of b){let{schema:r}=n,i=r;if(e.debug(`sadot - validating with schema`,{schema:r,hasAfterProps:!!i.properties?.after,hasBeforeProps:!!i.properties?.before}),s){if(i.properties?.after){let e=m.compile({...r,properties:{after:i.properties.after}});if(!e(JSON.parse(JSON.stringify({after:{...t.dataValues,customFields:S}})))){let t=e.errors?.map(e=>`${e.instancePath||``} ${e.message||`Invalid value`}`).join(`, `),n=v(e.errors);throw new l([Error(`Validation failed for ${c}: ${t}`)],void 0,{customError:n})}}}else{let n=m.compile(i),r=h(t.dataValues);r.customFields=S;let a={before:x,after:r},o=n(JSON.parse(JSON.stringify(a)));if(e.debug(`sadot - validation result`,{isValid:o,test:{before:x,after:r}}),!o){let e=n.errors?.map(e=>`${e.instancePath||``} ${e.message||`Invalid value`}`).join(`, `),t=v(n.errors);throw new l([Error(`Validation failed for ${c}: ${e}`)],void 0,{customError:t})}}}},b=async({modelType:e,modelOptions:t,identifiers:n,options:r})=>{let{include:a,useEntityIdFromInclude:o}=t;return await i({modelType:e,disabled:!1,...!o&&{entityId:n}},{withDisabled:!1,transaction:r.transaction,include:a?.(n)})},x=(e,r)=>{(e||[]).forEach(e=>{let{fieldType:i,name:a}=e;if([t.DATE,t.DATETIME].includes(i)){let e=r.customFields?.[a];if(e){let{value:t,error:i}=c.date().validate(e);if(i)throw new n(e,a,i);r.customFields[a]=t.toISOString()}}})},S=(t,n={},i={useCustomFieldsEntries:!1})=>async(a,c)=>{e.debug(`sadot - before create hook`);let{fields:l}=c,u=a.constructor.name,d=o(a,t),f=await b({modelType:u,modelOptions:n,identifiers:d,options:c}),p=f.filter(e=>![null,void 0].includes(e.defaultValue));p.length&&(a.customFields||={},p.filter(e=>a.customFields?.[e.name]===void 0).forEach(({name:e,defaultValue:t})=>{a.customFields[e]=t}));let m=Array.from(new Set(f.filter(({required:e})=>e).map(({name:e})=>e))),{customFields:h}=a,g=Object.keys(h??{}),_=m.filter(e=>!g.includes(e));if(_?.length)throw new r(_);await y(a,c,t,n,!0),x(f,a);let v=l.indexOf(`customFields`);v===-1||!h||!Object.keys(h).length||(await s({modelId:a.id,modelType:u,identifiers:d,customFields:h,options:{useCustomFieldsEntries:i.useCustomFieldsEntries,transaction:c.transaction,modelOptions:n}}),l.splice(v,1))},C=(t,n={},r={useCustomFieldsEntries:!1})=>async(i,a)=>{e.debug(`sadot - before update hook`);let{fields:c}=a,l=i.constructor.name,u=o(i,t),d=await b({modelType:l,modelOptions:n,identifiers:u,options:a});await y(i,a,t,n,!1),x(d,i);let f=c.indexOf(`customFields`);if(f>-1){let{customFields:e}=i;if(!Object.keys(e).length)return;await s({modelId:i.id,modelType:l,identifiers:u,customFields:e,options:{useCustomFieldsEntries:r.useCustomFieldsEntries,transaction:a.transaction,modelOptions:n}}),c.splice(f,1)}},w=e=>{e.individualHooks=!0},T=e=>{e.individualHooks=!0};export{w as beforeBulkCreate,T as beforeBulkUpdate,S as beforeCreate,C as beforeUpdate};
-//# sourceMappingURL=hooks.js.map
+"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.beforeBulkUpdate = exports.beforeBulkCreate = exports.beforeUpdate = exports.beforeCreate = void 0;
+const ajv_1 = __importDefault(require("ajv"));
+const joi_1 = __importDefault(require("joi"));
+const ajv_formats_1 = __importDefault(require("ajv-formats"));
+const errors_1 = require("@autofleet/errors");
+const ajv_errors_1 = __importDefault(require("ajv-errors"));
+const logger_1 = __importDefault(require("../utils/logger"));
+const ValidatorRepo = __importStar(require("../repository/validator"));
+const DefinitionRepo = __importStar(require("../repository/definition"));
+const errors_2 = require("../errors");
+const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+const updateInstanceValues_1 = __importDefault(require("./utils/updateInstanceValues"));
+const constants_1 = require("../utils/constants");
+// Include all required fields for proper validation
+const CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL = ['id', 'schema', 'modelType', 'entityId', 'disabled'];
+// Initialize Ajv with relaxed settings to avoid warnings
+const ajv = new ajv_1.default({
+    allErrors: true,
+    strict: false, // Disable strict mode to avoid warnings
+    strictTypes: false, // Disable strict type checking
+    $data: true, // Enable $data references
+});
+(0, ajv_formats_1.default)(ajv);
+(0, ajv_errors_1.default)(ajv);
+/**
+ * Helper function to manually copy object properties
+ * This is more efficient for large objects and avoids excessive object creation
+ */
+// eslint-disable-next-line prefer-object-spread
+const manualObjectCopy = (sourceObj, additionalProps) => ({ __proto__: null, ...sourceObj, ...additionalProps });
+/**
+ * Fetches complete custom fields for an instance by merging DB values with update values
+ * This is needed for partial updates to ensure all related fields are available for validation
+ */
+const getCompleteCustomFields = async (instance, options) => {
+    // If we don't have an instance id or no custom fields being updated, return original fields
+    if (!instance.id || !instance.customFields || Object.keys(instance.customFields).length === 0) {
+        return instance.customFields || {};
+    }
+    try {
+        const ModelClass = instance.constructor;
+        // Only select the customFields column to minimize data transfer
+        const currentCustomFields = await ModelClass.findOne({
+            where: { id: instance.id },
+            attributes: ['customFields'],
+            transaction: options.transaction,
+            raw: true, // Get plain object instead of model instance for better performance
+        });
+        if (currentCustomFields?.customFields) {
+            // Merge existing fields with update fields using our helper function
+            const completeFields = manualObjectCopy(currentCustomFields.customFields, instance.customFields);
+            logger_1.default.debug('sadot - fetched complete custom fields for validation', {
+                fieldsCount: Object.keys(completeFields).length,
+                updateFieldsCount: Object.keys(instance.customFields).length,
+            });
+            return completeFields;
+        }
+    }
+    catch (error) {
+        logger_1.default.error('sadot - error fetching complete model for validation', { error });
+        // Continue with partial data if we can't fetch the complete model
+    }
+    return instance.customFields || {};
+};
+const buildBeforeFromInstance = (instance) => {
+    const beforeFull = { ...instance.dataValues };
+    const changedKeys = instance.changed?.() || [];
+    changedKeys.forEach((key) => {
+        const prevVal = instance.previous?.(key);
+        if (prevVal !== undefined) {
+            beforeFull[key] = prevVal;
+        }
+    });
+    const prevCF = instance.previous?.('customFields');
+    if (prevCF !== undefined) {
+        beforeFull.customFields = prevCF;
+    }
+    return beforeFull;
+};
+const formatAjvErrors = (errors) => errors.reduce((acc, err) => {
+    const basePath = (err.instancePath || '')
+        .split('/')
+        .filter(Boolean)
+        .join('.')
+        .replace(/^after\./, '');
+    const missingProp = err.keyword === 'required' ? `.${err.params?.missingProperty}` : '';
+    const key = (basePath + missingProp).replace(/^\./, '') || 'root';
+    const message = err.message || 'Invalid value';
+    acc[key] = message;
+    return acc;
+}, {});
+/**
+ * Validates the model using custom validators
+ */
+const validateModel = async (instance, options, scopeAttributes, modelOptions = {}, isCreate = false) => {
+    var _a;
+    const modelType = instance.constructor.name;
+    logger_1.default.debug('sadot - validating model', { isCreate, modelType });
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
+    logger_1.default.debug('sadot - identifiers', { identifiers });
+    // Skip if no identifiers
+    if (!identifiers || Object.keys(identifiers).length === 0) {
+        logger_1.default.debug('sadot - skipping validation: no identifiers');
+        return;
+    }
+    // Find the entityId from identifiers (fleetId, businessModelId, etc.)
+    const entityId = Object.values(identifiers)[0]; // Get the first value as entityId
+    logger_1.default.debug('sadot - entityId', { entityId });
+    if (!entityId) {
+        logger_1.default.debug('sadot - skipping validation: no entityId');
+        return;
+    }
+    let validatorsPromise;
+    let cacheKey;
+    if (options.transaction) {
+        // eslint-disable-next-line no-param-reassign
+        (_a = options.transaction).validationsCache || (_a.validationsCache = new Map());
+        cacheKey = `${modelType}-${entityId}`;
+        validatorsPromise = options.transaction.validationsCache.get(cacheKey);
+    }
+    if (!validatorsPromise) {
+        validatorsPromise = ValidatorRepo.findAllByModelType(modelType, entityId, {
+            transaction: options.transaction,
+            attributes: CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL,
+            ...(modelOptions.include && {
+                include: modelOptions.include?.(entityId),
+            }),
+            raw: true,
+        });
+        if (options.transaction) {
+            options?.transaction?.validationsCache.set(cacheKey, validatorsPromise);
+        }
+    }
+    const validators = await validatorsPromise;
+    logger_1.default.debug('sadot - validators found', { count: validators.length });
+    if (!validators.length) {
+        logger_1.default.debug('sadot - skipping validation: no validators found');
+        return;
+    }
+    // For updates, get the previous values
+    let originalValues = null;
+    if (!isCreate) {
+        originalValues = buildBeforeFromInstance(instance);
+    }
+    // Get complete custom fields by merging DB values with update values
+    // This is especially important for partial updates to ensure all related fields are available
+    const completeCustomFields = !isCreate
+        ? await getCompleteCustomFields(instance, options)
+        : instance.customFields || {};
+    // eslint-disable-next-line no-restricted-syntax
+    for (const validator of validators) {
+        const { schema } = validator;
+        const typedSchema = schema;
+        logger_1.default.debug('sadot - validating with schema', {
+            schema,
+            hasAfterProps: !!typedSchema.properties?.after,
+            hasBeforeProps: !!typedSchema.properties?.before,
+        });
+        if (isCreate) {
+            // For create operations, we only need the 'after' state
+            if (typedSchema.properties?.after) {
+                const validateSchema = ajv.compile({
+                    ...schema,
+                    // Focus only on the 'after' validation part for create
+                    properties: {
+                        after: typedSchema.properties.after,
+                    },
+                });
+                const isValid = validateSchema(JSON.parse(JSON.stringify({
+                    after: {
+                        ...instance.dataValues,
+                        customFields: completeCustomFields,
+                    },
+                })));
+                if (!isValid) {
+                    const errorDetails = validateSchema.errors?.map((err) => `${err.instancePath || ''} ${err.message || 'Invalid value'}`).join(', ');
+                    const formattedErrors = formatAjvErrors(validateSchema.errors);
+                    throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], undefined, {
+                        customError: formattedErrors,
+                    });
+                }
+            }
+        }
+        else {
+            // For update operations, we need both before and after
+            const validateSchema = ajv.compile(typedSchema);
+            // Create after object with our helper function
+            const afterObj = manualObjectCopy(instance.dataValues);
+            // Add complete custom fields
+            afterObj.customFields = completeCustomFields;
+            // Create validation payload
+            const payload = {
+                before: originalValues,
+                after: afterObj,
+            };
+            // Validate
+            const isValid = validateSchema(JSON.parse(JSON.stringify(payload)));
+            logger_1.default.debug('sadot - validation result', {
+                isValid,
+                test: {
+                    before: originalValues,
+                    after: afterObj,
+                },
+            });
+            if (!isValid) {
+                const errorDetails = validateSchema
+                    .errors
+                    ?.map((err) => `${err.instancePath || ''} ${err.message || 'Invalid value'}`).join(', ');
+                const formattedErrors = formatAjvErrors(validateSchema.errors);
+                throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)], undefined, {
+                    customError: formattedErrors,
+                });
+            }
+        }
+    }
+};
+const getFieldDefinitions = async ({ modelType, modelOptions, identifiers, options, }) => {
+    const { include, useEntityIdFromInclude } = modelOptions;
+    const where = {
+        modelType,
+        disabled: false,
+        ...(!useEntityIdFromInclude && { entityId: identifiers }),
+    };
+    const fieldDefinitions = await DefinitionRepo.findAll(where, {
+        withDisabled: false,
+        transaction: options.transaction,
+        include: include?.(identifiers),
+    });
+    return fieldDefinitions;
+};
+const formatDates = (fieldDefinitions, instance) => {
+    (fieldDefinitions || []).forEach((fieldDefinition) => {
+        const { fieldType, name } = fieldDefinition;
+        if ([constants_1.CustomFieldDefinitionType.DATE, constants_1.CustomFieldDefinitionType.DATETIME].includes(fieldType)) {
+            const value = instance.customFields?.[name];
+            if (value) {
+                const { value: joiValue, error: validationError } = joi_1.default.date().validate(value);
+                if (validationError) {
+                    throw new errors_2.InvalidValueError(value, name, validationError);
+                }
+                // eslint-disable-next-line no-param-reassign
+                instance.customFields[name] = joiValue.toISOString();
+            }
+        }
+    });
+};
+/**
+ * Hook to handle validation and custom fields during creation
+ */
+const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => 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);
+    // Step 1: Handle custom fields default values and required fields
+    const fieldDefinitions = await getFieldDefinitions({
+        modelType, modelOptions, identifiers, options,
+    });
+    // Apply default values
+    const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
+    if (fieldsWithDefaultValue.length) {
+        // eslint-disable-next-line no-param-reassign
+        instance.customFields || (instance.customFields = {});
+        fieldsWithDefaultValue
+            .filter((def) => (instance.customFields?.[def.name] === undefined))
+            .forEach(({ name, defaultValue }) => {
+            // eslint-disable-next-line no-param-reassign
+            instance.customFields[name] = defaultValue;
+        });
+    }
+    // Check for required fields
+    const requiredFieldsNames = Array.from(new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)));
+    const { customFields } = instance;
+    const fieldsNames = Object.keys(customFields ?? {});
+    const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
+    if (missingFields?.length) {
+        throw new errors_2.MissingRequiredCustomFieldError(missingFields);
+    }
+    // Step 2: Validate the model data (including custom fields)
+    await validateModel(instance, options, scopeAttributes, modelOptions, true);
+    // format date and datetime fields
+    formatDates(fieldDefinitions, instance);
+    // Step 3: Save custom field values if they exist
+    const customFieldsIdx = fields.indexOf('customFields');
+    if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
+        // No custom fields to update
+        return;
+    }
+    // Save custom field values
+    await (0, updateInstanceValues_1.default)({
+        modelId: instance.id,
+        modelType,
+        identifiers,
+        customFields,
+        options: {
+            useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+            transaction: options.transaction,
+            modelOptions,
+        },
+    });
+    // Remove customFields from fields array after handling
+    // eslint-disable-next-line no-param-reassign
+    fields.splice(customFieldsIdx, 1);
+};
+exports.beforeCreate = beforeCreate;
+/**
+ * Hook to handle validation and custom fields during update
+ */
+const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
+    logger_1.default.debug('sadot - before update hook');
+    const { fields } = options;
+    const modelType = instance.constructor.name;
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
+    const fieldDefinitions = await getFieldDefinitions({
+        modelType, modelOptions, identifiers, options,
+    });
+    // Step 1: Validate the model data (including custom fields)
+    await validateModel(instance, options, scopeAttributes, modelOptions, false);
+    // format date and datetime fields
+    formatDates(fieldDefinitions, instance);
+    // Step 2: Update custom field values if they exist
+    const customFieldsIdx = fields.indexOf('customFields');
+    if (customFieldsIdx > -1) {
+        const { customFields } = instance;
+        if (!Object.keys(customFields).length) {
+            return;
+        }
+        // Save custom field values
+        await (0, updateInstanceValues_1.default)({
+            modelId: instance.id,
+            modelType,
+            identifiers,
+            customFields,
+            options: {
+                useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+                transaction: options.transaction,
+                modelOptions,
+            },
+        });
+        // Remove customFields from fields array after handling
+        // eslint-disable-next-line no-param-reassign
+        fields.splice(customFieldsIdx, 1);
+    }
+};
+exports.beforeUpdate = beforeUpdate;
+/**
+ * Hook to enable individual hooks for bulk create operations
+ */
+const beforeBulkCreate = (options) => {
+    // This will activate the beforeCreate hook on each instance
+    // eslint-disable-next-line no-param-reassign
+    options.individualHooks = true;
+};
+exports.beforeBulkCreate = beforeBulkCreate;
+/**
+ * Hook to enable individual hooks for bulk update operations
+ */
+const beforeBulkUpdate = (options) => {
+    // This will activate the beforeUpdate hook on each instance
+    // eslint-disable-next-line no-param-reassign
+    options.individualHooks = true;
+};
+exports.beforeBulkUpdate = beforeBulkUpdate;

package/dist/hooks/index.d.ts

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

package/dist/hooks/index.js

@@ -1 +1,17 @@
-import e from"./enrich.js";import{beforeFind as t}from"./find.js";import{beforeBulkCreate as n,beforeBulkUpdate as r,beforeCreate as i,beforeUpdate as a}from"./hooks.js";export{};
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.beforeBulkUpdate = exports.beforeBulkCreate = exports.beforeUpdate = exports.beforeCreate = exports.workaround = 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 workaround_1 = __importDefault(require("./workaround"));
+exports.workaround = workaround_1.default;
+const hooks_1 = require("./hooks");
+Object.defineProperty(exports, "beforeCreate", { enumerable: true, get: function () { return hooks_1.beforeCreate; } });
+Object.defineProperty(exports, "beforeUpdate", { enumerable: true, get: function () { return hooks_1.beforeUpdate; } });
+Object.defineProperty(exports, "beforeBulkCreate", { enumerable: true, get: function () { return hooks_1.beforeBulkCreate; } });
+Object.defineProperty(exports, "beforeBulkUpdate", { enumerable: true, get: function () { return hooks_1.beforeBulkUpdate; } });

package/dist/hooks/update.d.ts

@@ -0,0 +1,10 @@
+import type { CustomFieldOptions, 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, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;

package/dist/hooks/update.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.beforeUpdate = exports.beforeBulkUpdate = void 0;
+const logger_1 = __importDefault(require("../utils/logger"));
+const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+const updateInstanceValues_1 = __importDefault(require("./utils/updateInstanceValues"));
+/**
+ * A hook to update the custom fields when updating a model (more then one instance).
+ */
+const beforeBulkUpdate = (options) => {
+    // This will activate the beforeUpdate hook on each updating instance.
+    // eslint-disable-next-line no-param-reassign
+    options.individualHooks = true;
+};
+exports.beforeBulkUpdate = beforeBulkUpdate;
+/**
+ * A hook to update the custom fields when updating a model instance.
+ * TODO - cleanup if update fail
+ */
+const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
+    logger_1.default.debug('sadot - before update hook');
+    const { fields } = options;
+    const modelType = instance.constructor.name;
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
+    const customFieldsIdx = fields.indexOf('customFields');
+    if (customFieldsIdx > -1) {
+        const { customFields } = instance;
+        if (!Object.keys(customFields).length) {
+            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.beforeUpdate = beforeUpdate;

package/dist/hooks/utils/updateInstanceValues.d.ts

@@ -0,0 +1,15 @@
+import type { Transaction } from 'sequelize';
+import type { ModelOptions } from '../../types';
+interface UpdateInstanceValuesParams {
+    modelId: string;
+    modelType: string;
+    identifiers: string[];
+    customFields: Record<string, any>;
+    options?: {
+        transaction?: Transaction;
+        modelOptions?: ModelOptions;
+        useCustomFieldsEntries?: boolean;
+    };
+}
+declare const updateInstanceValues: ({ modelId, modelType, identifiers, customFields, options, }: UpdateInstanceValuesParams) => Promise<void>;
+export default updateInstanceValues;

package/dist/hooks/utils/updateInstanceValues.js

@@ -1,2 +1,50 @@
-import{updateValues as e}from"../../repository/value.js";import{findEntriesByModelId as t,updateEntries as n}from"../../repository/entries.js";var r=async({modelId:r,modelType:i,identifiers:a,customFields:o,options:s={modelOptions:{},useCustomFieldsEntries:!1}})=>{if(await e(i,r,a,o,{...s,modelOptions:s.modelOptions??{}}),!s?.useCustomFieldsEntries)return;let{dataValues:{customFields:c}}=await t(r,s)??{dataValues:{}};await n(r,i,{...c,...o},a,{...s,modelOptions:s.modelOptions??{}})};export{r as default};
-//# sourceMappingURL=updateInstanceValues.js.map
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ValueRepo = __importStar(require("../../repository/value"));
+const EntriesRepo = __importStar(require("../../repository/entries"));
+const updateInstanceValues = async ({ modelId, modelType, identifiers, customFields, options = {
+    modelOptions: {},
+    useCustomFieldsEntries: false,
+}, }) => {
+    await ValueRepo.updateValues(modelType, modelId, identifiers, customFields, {
+        ...options,
+        modelOptions: options.modelOptions ?? {},
+    });
+    /*
+    T.Y TODO - Once we're ready to switch from custom_field_values to custom_field_entries, we should remove the ValueRepo.updateValues call.
+    Currently, We're updating both tables to keep the data in sync, but not all microservices are using the new table yet.
+    */
+    if (!options?.useCustomFieldsEntries) {
+        return;
+    }
+    const { dataValues: { customFields: oldCustomFields } } = await EntriesRepo.findEntriesByModelId(modelId, options) ?? { dataValues: {} };
+    const newCustomFields = { ...oldCustomFields, ...customFields };
+    await EntriesRepo.updateEntries(modelId, modelType, newCustomFields, identifiers, {
+        ...options,
+        modelOptions: options.modelOptions ?? {},
+    });
+};
+exports.default = updateInstanceValues;

package/dist/hooks/workaround.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Workaround to a bug in sequelize.🐛
+ *
+ * **afterFind hook** isn't working on nested (included) models.
+ * The solution here is to add a global afterFind hook,
+ * which manually calls the afterFind hook of each model, recursively
+ * https://github.com/sequelize/sequelize/issues/4627
+ */
+declare const handleChildrenAfterFindHook: (instances: any, options: any, level?: number) => any;
+export default handleChildrenAfterFindHook;

package/dist/hooks/workaround.js

@@ -0,0 +1,37 @@
+"use strict";
+/**
+ * Workaround to a bug in sequelize.🐛
+ *
+ * **afterFind hook** isn't working on nested (included) models.
+ * The solution here is to add a global afterFind hook,
+ * which manually calls the afterFind hook of each model, recursively
+ * https://github.com/sequelize/sequelize/issues/4627
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const handleChildrenAfterFindHook = async (instances, options, level = 0) => {
+    if (!instances)
+        return Promise.resolve();
+    if (Array.isArray(instances)) {
+        return Promise.all(instances.map((instance) => {
+            const { options: instanceOptions } = instance.constructor;
+            return handleChildrenAfterFindHook(instance, instanceOptions, level);
+        }));
+    }
+    const instance = instances;
+    const { constructor } = instance;
+    /**
+         * Root model will have already run their "afterFind" hook.
+         * Only run children "afterFind" hooks.
+         */
+    if (level >= 1) {
+        await constructor.runHooks('afterFind', instance, options);
+    }
+    const { associations } = constructor;
+    const associatedNames = Object.keys(instance).filter((attribute) => Object.keys(associations).includes(attribute));
+    if (associatedNames.length) {
+        const childInstances = associatedNames.map((name) => instance[name]);
+        return handleChildrenAfterFindHook(childInstances, options, level + 1);
+    }
+    return Promise.resolve();
+};
+exports.default = handleChildrenAfterFindHook;

package/dist/index.d.ts

@@ -1,23 +1,13 @@
-import { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinitionType, supportedEntities } from "./utils/constants/index.js";
-import { CustomFieldValue } from "./models/CustomFieldValue.js";
-import { CustomFieldEntries } from "./models/CustomFieldEntries.js";
-import { CustomValidator } from "./models/CustomValidator.js";
-import "./models/index.js";
-import { CustomFieldDefinition } from "./models/CustomFieldDefinition.js";
-import { CustomFieldOptions, ModelFetcher, Models } from "./types/index.js";
-import { CustomFieldsSchema } from "./utils/validations/schema/custom-fields.js";
-import { generateCustomFieldSearchQueryPayload, generateRandomString } from "./utils/helpers/index.js";
-import { customFieldsSortScope } from "./scopes/filter.js";
-import { Sequelize } from "sequelize-typescript";
-import { Application } from "express";
-
-//#region src/index.d.ts
+import type { Application } from 'express';
+import type { Sequelize } from 'sequelize-typescript';
+import type { CustomFieldOptions, ModelFetcher, Models } from './types';
+export * from './utils/validations/schema/custom-fields';
+export * from './utils/constants';
+export * from './utils/helpers';
 /**
-* Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
-* @see {@link 'custom-fields/config'} for configurations
-*/
-declare const useCustomFields: (app: Pick<Application, "use"> | null, getModel: ModelFetcher, options: CustomFieldOptions) => Promise<Sequelize>;
-declare const disableCustomFields: (models: Models[], getModel: ModelFetcher) => void;
-//#endregion
-export { CUSTOM_FIELDS_FILTER_SCOPE, CustomFieldDefinition, CustomFieldDefinitionType, CustomFieldEntries, CustomFieldValue, CustomFieldsSchema, CustomValidator, customFieldsSortScope, useCustomFields as default, disableCustomFields, generateCustomFieldSearchQueryPayload, generateRandomString, supportedEntities };
-//# sourceMappingURL=index.d.ts.map
+ * Adding custom fields enrichment to the models inside the MODELS_FILE_NAME json file
+ * @see {@link 'custom-fields/config'} for configurations
+ */
+declare const useCustomFields: (app: Application | null, getModel: ModelFetcher, options: CustomFieldOptions) => Promise<Sequelize>;
+export default useCustomFields;
+export declare const disableCustomFields: (models: Models[], getModel: ModelFetcher) => void;