@autofleet/sadot 0.13.2-beta.1 → 0.13.2-beta.100

package/dist/hooks/enrich.d.ts

@@ -1,6 +1,5 @@
-import type { Transaction } from 'sequelize';
 import type CustomFieldValue from '../models/CustomFieldValue';
-import type { CustomFieldOptions, ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions, TransactionOptions } from '../types';
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
 type CustomFieldEntries = Record<string, any>;
 interface GetValuesGroupByInstanceResponse {
@@ -11,20 +10,16 @@ interface GetCustomFieldEntriesByInstanceIdResponse {
 }
 export declare const getCustomFieldEntriesByInstanceId: ({ instancesIds, options, sadotOptions, }: {
     instancesIds: string[];
-    options?: {
-        transaction: Transaction;
-    };
+    options?: TransactionOptions;
     sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>;
 }) => Promise<GetCustomFieldEntriesByInstanceIdResponse>;
 export declare const getValuesGroupByInstance: ({ instancesIds, options, sadotOptions, }: {
     instancesIds: string[];
-    options?: {
-        transaction: Transaction;
-    };
+    options?: TransactionOptions;
     sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>;
 }) => Promise<GetValuesGroupByInstanceResponse>;
 /**
  * A hook to attach the custom fields when fetching a model instances.
  */
-declare const enrichResults: (modelType: string, scopeAttributes: string[], hookType?: SupportedHookTypes, modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instancesOrInstance: any | any[], options: any) => Promise<void>;
+declare const enrichResults: (modelType: string, scopeAttributes: string[], hookType?: SupportedHookTypes, modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instancesOrInstance: any | any[], options: TransactionOptions) => Promise<void>;
 export default enrichResults;

package/dist/hooks/enrich.js

@@ -27,10 +27,12 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getValuesGroupByInstance = exports.getCustomFieldEntriesByInstanceId = void 0;
+/* eslint-disable no-param-reassign */
 const ValueRepo = __importStar(require("../repository/value"));
 const DefinitionRepo = __importStar(require("../repository/definition"));
 const EntriesRepo = __importStar(require("../repository/entries"));
 const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+const CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL = ['id', 'name', 'entityId'];
 const getCustomFieldEntriesByInstanceId = async ({ instancesIds, options, sadotOptions, }) => {
     if (!sadotOptions.useCustomFieldsEntries) {
         return {};
@@ -93,7 +95,37 @@ const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {},
         ...map,
         [identifier]: [],
     }), {});
-    const customFieldDefinitions = await DefinitionRepo.findByEntityIds(modelType, uniqueIdentifiers, { transaction: options.transaction, modelOptions });
+    // Cache for definitions by model type and transaction to avoid redundant DB queries
+    let customFieldDefinitionsPromise;
+    let cacheKey;
+    // Check if caching is disabled via environment variable
+    const cachingDisabled = process.env.SADOT_DISABLE_DEFINITION_CACHE === 'true';
+    if (options.transaction && !cachingDisabled) {
+        // Initialize definition cache Map if not already present directly on the transaction object
+        options.transaction.definitionCache = options.transaction.definitionCache || new Map();
+        // Create a unique cache key combining model type and sorted identifiers
+        cacheKey = `${modelType}:${uniqueIdentifiers.sort().join(',')}`;
+        // Check if these definitions are already cached for this transaction
+        if (options.transaction.definitionCache.has(cacheKey)) {
+            // Use cached result to avoid duplicate database queries
+            customFieldDefinitionsPromise = options.transaction.definitionCache.get(cacheKey);
+        }
+    }
+    if (!customFieldDefinitionsPromise) {
+        // Fetch from database (either first time in this transaction or no transaction)
+        customFieldDefinitionsPromise = DefinitionRepo.findByEntityIds(modelType, uniqueIdentifiers, { transaction: options.transaction, modelOptions, attributes: CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL });
+        // Store in cache if within a transaction and caching isn't disabled
+        if (options.transaction && options.transaction.definitionCache) {
+            options.transaction.definitionCache.set(cacheKey, customFieldDefinitionsPromise);
+        }
+    }
+    const customFieldDefinitions = await customFieldDefinitionsPromise;
+    if (customFieldDefinitions.length === 0) {
+        // if no custom fields, we can return
+        instances.forEach((instance) => {
+            instance.customFields = {};
+        });
+    }
     if (modelOptions?.include && modelOptions.useEntityIdFromInclude) {
         // if we pass useEntityIdFromInclude,
         //  map the entity from the options to the identifierCustomFieldDefinitionsMapping
@@ -114,16 +146,18 @@ const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {},
     // Get the values per instates ids:
     const instancesIds = instances.map((i) => i[primaryKey]);
     // Group fields by modelId
-    const valuesGroupByInstance = await (0, exports.getValuesGroupByInstance)({
-        instancesIds,
-        options,
-        sadotOptions,
-    });
-    const customFieldEntriesByInstanceId = await (0, exports.getCustomFieldEntriesByInstanceId)({
-        instancesIds,
-        options,
-        sadotOptions,
-    });
+    const [valuesGroupByInstance, customFieldEntriesByInstanceId] = await Promise.all([
+        (0, exports.getValuesGroupByInstance)({
+            instancesIds,
+            options,
+            sadotOptions,
+        }),
+        (0, exports.getCustomFieldEntriesByInstanceId)({
+            instancesIds,
+            options,
+            sadotOptions,
+        }),
+    ]);
     // Attach custom fields to the instances
     instances.forEach((instance) => {
         const { id } = instance;

package/dist/hooks/hooks.js

@@ -28,6 +28,7 @@ var __importDefault = (this && this.__importDefault) || function (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 logger_1 = __importDefault(require("../utils/logger"));
@@ -105,7 +106,24 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
         logger_1.default.debug('sadot - skipping validation: no entityId');
         return;
     }
-    const validators = await ValidatorRepo.findAllByModelType(modelType, entityId, { transaction: options.transaction });
+    let validatorsPromise;
+    let cacheKey;
+    if (options.transaction) {
+        // eslint-disable-next-line no-param-reassign
+        options.transaction.validationsCache = options.transaction.validationsCache || new Map();
+        cacheKey = `${modelType}-${entityId}`;
+        validatorsPromise = options.transaction.validationsCache.get(cacheKey);
+    }
+    if (!validatorsPromise) {
+        validatorsPromise = ValidatorRepo.findAllByModelType(modelType, entityId, {
+            transaction: options.transaction,
+            attributes: ['schema'],
+        });
+        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');
@@ -124,16 +142,6 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
     const completeCustomFields = !isCreate
         ? await getCompleteCustomFields(instance, options)
         : instance.customFields || {};
-    // For debugging in case of update
-    if (!isCreate && process.env.NODE_ENV !== 'production') {
-        // Create after object for logging
-        const logAfterObj = manualObjectCopy(instance.dataValues, { customFields: completeCustomFields });
-        logger_1.default.debug('sadot - validate with values', {
-            before: originalValues,
-            after: logAfterObj,
-            schema: validators[0].schema,
-        });
-    }
     // eslint-disable-next-line no-restricted-syntax
     for (const validator of validators) {
         const { schema } = validator;
@@ -196,7 +204,7 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
         }
     }
 };
-const getFieldDefinitions = async ({ modelType, modelOptions, identifiers, options }) => {
+const getFieldDefinitions = async ({ modelType, modelOptions, identifiers, options, }) => {
     const { include, useEntityIdFromInclude } = modelOptions;
     const where = {
         modelType,
@@ -210,14 +218,18 @@ const getFieldDefinitions = async ({ modelType, modelOptions, identifiers, optio
     });
     return fieldDefinitions;
 };
-const formatDates = (fieldDefinitions = [], instance) => {
-    fieldDefinitions.forEach((fieldDefinition) => {
+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] = new Date(value).toISOString();
+                instance.customFields[name] = joiValue.toISOString();
             }
         }
     });
@@ -232,7 +244,7 @@ const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
     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
+        modelType, modelOptions, identifiers, options,
     });
     // Apply default values
     const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
@@ -290,7 +302,7 @@ const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCu
     const modelType = instance.constructor.name;
     const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
     const fieldDefinitions = await getFieldDefinitions({
-        modelType, modelOptions, identifiers, options
+        modelType, modelOptions, identifiers, options,
     });
     // Step 1: Validate the model data (including custom fields)
     await validateModel(instance, options, scopeAttributes, false);

package/dist/models/index.js

@@ -26,12 +26,8 @@ exports.CustomValidator = CustomValidator_1.default;
 const productionModels = [CustomFieldDefinition_1.default, CustomFieldValue_1.default, CustomValidator_1.default];
 const testModels = [TestModel_1.default, AssociatedTestModel_1.default, ContextAwareTestModel_1.default, ContextTestModel_1.default];
 const SADOT_MIGRATION_PREFIX = 'sadot-migration';
-const SCHEMA_VERSION = 'fb0fa867-1241-4816-b08d-5ed9060c7ae5';
-const initTables = async (sequelize, getUser, { schemaPrefix, schemaVersion, useCustomFieldsEntries, } = {
-    schemaPrefix: SADOT_MIGRATION_PREFIX,
-    schemaVersion: SCHEMA_VERSION,
-    useCustomFieldsEntries: false,
-}) => {
+const SCHEMA_VERSION = '49c9dd1d-b1cc-445b-a911-fd349d783110';
+const initTables = async (sequelize, getUser, { schemaPrefix = SADOT_MIGRATION_PREFIX, schemaVersion = SCHEMA_VERSION, useCustomFieldsEntries = false, } = {}) => {
     const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? '_withEntries' : ''}`;
     logger_1.default.info('custom-fields: initialize custom-fields tables');
     // Detect models and import them to the orm
@@ -87,10 +83,13 @@ const initTables = async (sequelize, getUser, { schemaPrefix, schemaVersion, use
         timestamps: false,
         schema: 'public',
     });
+    logger_1.default.info('custom-fields: starting migrations');
     const migrations = await SequelizeMeta.findAll({ where: { name: { [sequelize_1.Op.like]: `${schemaPrefix}%` } }, raw: true });
     const currentSadotSchemaVersion = migrations.at(-1);
     const expectedSchemaVersionIndex = migrations.findIndex((m) => m.name === CUSTOM_FIELDS_SCHEMA_VERSION);
+    logger_1.default.info('custom-fields: migrations', { migrations, currentSadotSchemaVersion, expectedSchemaVersionIndex });
     if (!currentSadotSchemaVersion || currentSadotSchemaVersion.name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
+        logger_1.default.info('custom-fields: syncing models');
         await CustomFieldDefinition_1.default.sync({ alter: true });
         await CustomFieldValue_1.default.sync({ alter: true });
         // T.Y TODO: Remove the if statement once we're ready to add the new entries table for all MS

package/dist/repository/validator.d.ts

@@ -2,6 +2,7 @@ import type { Transactionable } from 'sequelize';
 import { CustomValidator } from '../models';
 export interface FindValidatorOptions extends Transactionable {
     withDisabled?: boolean;
+    attributes?: string[];
 }
 export interface ValidatorAttributes {
     entityId: string;

package/dist/types/index.d.ts

@@ -1,7 +1,13 @@
-import type { IncludeOptions } from 'sequelize';
+import type { IncludeOptions, Transaction } from 'sequelize';
 import type { ModelCtor, Sequelize } from 'sequelize-typescript';
 import type { getUser as GetUserType } from '@autofleet/zehut';
+import type CustomFieldDefinition from '../models/CustomFieldDefinition';
 export type ModelFetcher = (name: string) => any;
+export interface TransactionOptions extends Record<string, any> {
+    transaction?: Transaction & {
+        definitionCache?: Map<string, CustomFieldDefinition[]>;
+    };
+}
 export type ModelOptions = {
     /**
      * Include options for the model
@@ -16,6 +22,10 @@ export type ModelOptions = {
      * Whether to use the entity id  from the instance per scope attribute
      */
     useEntityIdFromInclude?: boolean;
+    /**
+     * Which attributes to include in the model
+     */
+    attributes?: string[];
 };
 export type Models = {
     name: string;

package/package.json

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

package/src/hooks/enrich.ts

@@ -1,14 +1,15 @@
 /* eslint-disable no-param-reassign */
-import type { Transaction } from 'sequelize';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
 import * as EntriesRepo from '../repository/entries';
 import type CustomFieldValue from '../models/CustomFieldValue';
 import type CustomFieldDefinition from '../models/CustomFieldDefinition';
 import type { SerializedCustomFields } from '../types/definition';
-import type { CustomFieldOptions, ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions, TransactionOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
 
+const CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL = ['id', 'name', 'entityId'];
+
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
 
 type CustomFieldEntries = Record<string, any>;
@@ -27,7 +28,7 @@ export const getCustomFieldEntriesByInstanceId = async ({
   sadotOptions,
 }: {
   instancesIds: string[],
-  options?: { transaction: Transaction },
+  options?: TransactionOptions,
   sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
 }): Promise<GetCustomFieldEntriesByInstanceIdResponse> => {
   if (!sadotOptions.useCustomFieldsEntries) {
@@ -60,7 +61,7 @@ export const getValuesGroupByInstance = async ({
   sadotOptions,
 }: {
   instancesIds: string[],
-  options?: { transaction: Transaction },
+  options?: TransactionOptions,
   sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>,
 }): Promise<GetValuesGroupByInstanceResponse> => {
   if (sadotOptions.useCustomFieldsEntries) {
@@ -108,7 +109,7 @@ const enrichResults = (
   sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
 ) => async (
   instancesOrInstance: any | any[],
-  options,
+  options: TransactionOptions,
 ): Promise<void> => {
   if (
     options.originalAttributes?.length > 0
@@ -131,14 +132,50 @@ const enrichResults = (
   const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
     ...map,
     [identifier]: [],
-
   }), {});
 
-  const customFieldDefinitions = await DefinitionRepo.findByEntityIds(
-    modelType,
-    uniqueIdentifiers,
-    { transaction: options.transaction, modelOptions },
-  );
+  // Cache for definitions by model type and transaction to avoid redundant DB queries
+  let customFieldDefinitionsPromise;
+  let cacheKey;
+
+  // Check if caching is disabled via environment variable
+  const cachingDisabled = process.env.SADOT_DISABLE_DEFINITION_CACHE === 'true';
+
+  if (options.transaction && !cachingDisabled) {
+    // Initialize definition cache Map if not already present directly on the transaction object
+    options.transaction.definitionCache = options.transaction.definitionCache || new Map();
+
+    // Create a unique cache key combining model type and sorted identifiers
+    cacheKey = `${modelType}:${uniqueIdentifiers.sort().join(',')}`;
+
+    // Check if these definitions are already cached for this transaction
+    if (options.transaction.definitionCache.has(cacheKey)) {
+      // Use cached result to avoid duplicate database queries
+      customFieldDefinitionsPromise = options.transaction.definitionCache.get(cacheKey);
+    }
+  }
+
+  if (!customFieldDefinitionsPromise) {
+    // Fetch from database (either first time in this transaction or no transaction)
+    customFieldDefinitionsPromise = DefinitionRepo.findByEntityIds(
+      modelType,
+      uniqueIdentifiers,
+      { transaction: options.transaction, modelOptions, attributes: CUSTOM_FIELD_DEFINITION_ATTRIBUTES_TO_PULL },
+    );
+
+    // Store in cache if within a transaction and caching isn't disabled
+    if (options.transaction && options.transaction.definitionCache) {
+      options.transaction.definitionCache.set(cacheKey, customFieldDefinitionsPromise);
+    }
+  }
+  const customFieldDefinitions = await customFieldDefinitionsPromise;
+
+  if (customFieldDefinitions.length === 0) {
+    // if no custom fields, we can return
+    instances.forEach((instance) => {
+      instance.customFields = {};
+    });
+  }
 
   if (modelOptions?.include && modelOptions.useEntityIdFromInclude) {
     // if we pass useEntityIdFromInclude,
@@ -164,17 +201,18 @@ const enrichResults = (
   const instancesIds = instances.map((i) => i[primaryKey]);
 
   // Group fields by modelId
-  const valuesGroupByInstance = await getValuesGroupByInstance({
-    instancesIds,
-    options,
-    sadotOptions,
-  });
-
-  const customFieldEntriesByInstanceId = await getCustomFieldEntriesByInstanceId({
-    instancesIds,
-    options,
-    sadotOptions,
-  });
+  const [valuesGroupByInstance, customFieldEntriesByInstanceId] = await Promise.all([
+    getValuesGroupByInstance({
+      instancesIds,
+      options,
+      sadotOptions,
+    }),
+    getCustomFieldEntriesByInstanceId({
+      instancesIds,
+      options,
+      sadotOptions,
+    }),
+  ]);
 
   // Attach custom fields to the instances
   instances.forEach((instance) => {

package/src/hooks/hooks.ts

@@ -105,11 +105,29 @@ const validateModel = async (
     return;
   }
 
-  const validators = await ValidatorRepo.findAllByModelType(
-    modelType,
-    entityId,
-    { transaction: options.transaction },
-  );
+  let validatorsPromise;
+  let cacheKey;
+  if (options.transaction) {
+    // eslint-disable-next-line no-param-reassign
+    options.transaction.validationsCache = options.transaction.validationsCache || new Map();
+    cacheKey = `${modelType}-${entityId}`;
+    validatorsPromise = options.transaction.validationsCache.get(cacheKey);
+  }
+
+  if (!validatorsPromise) {
+    validatorsPromise = ValidatorRepo.findAllByModelType(
+      modelType,
+      entityId,
+      {
+        transaction: options.transaction,
+        attributes: ['schema'],
+      },
+    );
+    if (options.transaction) {
+      options.transaction.validationsCache.set(cacheKey, validatorsPromise);
+    }
+  }
+  const validators = await validatorsPromise;
 
   logger.debug('sadot - validators found', { count: validators.length });
 
@@ -134,17 +152,6 @@ const validateModel = async (
     ? await getCompleteCustomFields(instance, options)
     : instance.customFields || {};
 
-  // For debugging in case of update
-  if (!isCreate && process.env.NODE_ENV !== 'production') {
-    // Create after object for logging
-    const logAfterObj = manualObjectCopy(instance.dataValues, { customFields: completeCustomFields });
-
-    logger.debug('sadot - validate with values', {
-      before: originalValues,
-      after: logAfterObj,
-      schema: validators[0].schema,
-    });
-  }
 
   // eslint-disable-next-line no-restricted-syntax
   for (const validator of validators) {
@@ -258,10 +265,7 @@ const formatDates = (fieldDefinitions: CustomFieldDefinition[], instance: any) =
           throw new InvalidValueError(value, name, validationError);
         }
         // eslint-disable-next-line no-param-reassign
-        const typeofjoi = typeof joiValue;
-        logger.info('sadot - formatting date', { name, value, joiValue, type: typeof joiValue });
         instance.customFields[name] = joiValue.toISOString();
-        new Date().toString
       }
     }
   });
@@ -278,72 +282,72 @@ export const beforeCreate = (
   instance,
   options,
 ): Promise<void> => {
-    logger.debug('sadot - before create hook');
-    const { fields } = options;
-    const modelType = instance.constructor.name;
+  logger.debug('sadot - before create hook');
+  const { fields } = options;
+  const modelType = instance.constructor.name;
 
-    const identifiers = applyScopeToInstance(instance, scopeAttributes);
+  const identifiers = applyScopeToInstance(instance, scopeAttributes);
 
-    // Step 1: Handle custom fields default values and required fields
+  // Step 1: Handle custom fields default values and required fields
 
-    const fieldDefinitions = await getFieldDefinitions({
-      modelType, modelOptions, identifiers, options,
-    });
+  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 ||= {};
-      fieldsWithDefaultValue
-        .filter((def) => (instance.customFields?.[def.name] === undefined))
-        .forEach(({ name, defaultValue }) => {
-          // eslint-disable-next-line no-param-reassign
-          instance.customFields[name] = defaultValue;
-        });
-    }
+  // 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 ||= {};
+    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 MissingRequiredCustomFieldError(missingFields);
-    }
+  // 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 MissingRequiredCustomFieldError(missingFields);
+  }
 
-    // Step 2: Validate the model data (including custom fields)
-    await validateModel(instance, options, scopeAttributes, true);
+  // Step 2: Validate the model data (including custom fields)
+  await validateModel(instance, options, scopeAttributes, true);
 
-    // format date and datetime fields
-    formatDates(fieldDefinitions, instance);
+  // 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;
-    }
+  // 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 updateInstanceValues({
-      modelId: instance.id,
-      modelType,
-      identifiers,
-      customFields,
-      options: {
-        useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
-        transaction: options.transaction,
-        modelOptions,
-      },
-    });
+  // Save custom field values
+  await updateInstanceValues({
+    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);
-  };
+  // Remove customFields from fields array after handling
+  // eslint-disable-next-line no-param-reassign
+  fields.splice(customFieldsIdx, 1);
+};
 
 /**
  * Hook to handle validation and custom fields during update
@@ -356,48 +360,48 @@ export const beforeUpdate = (
   instance,
   options,
 ): Promise<void> => {
-    logger.debug('sadot - before update hook');
-    const { fields } = options;
-    const modelType = instance.constructor.name;
-    const identifiers = applyScopeToInstance(instance, scopeAttributes);
+  logger.debug('sadot - before update hook');
+  const { fields } = options;
+  const modelType = instance.constructor.name;
+  const identifiers = applyScopeToInstance(instance, scopeAttributes);
 
-    const fieldDefinitions = await getFieldDefinitions({
-      modelType, modelOptions, identifiers, options,
-    });
+  const fieldDefinitions = await getFieldDefinitions({
+    modelType, modelOptions, identifiers, options,
+  });
 
-    // Step 1: Validate the model data (including custom fields)
-    await validateModel(instance, options, scopeAttributes, false);
+  // Step 1: Validate the model data (including custom fields)
+  await validateModel(instance, options, scopeAttributes, false);
 
-    // format date and datetime fields
-    formatDates(fieldDefinitions, instance);
+  // 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;
+  // 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;
-      }
+    if (!Object.keys(customFields).length) {
+      return;
+    }
 
-      // Save custom field values
-      await updateInstanceValues({
-        modelId: instance.id,
-        modelType,
-        identifiers,
-        customFields,
-        options: {
-          useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
-          transaction: options.transaction,
-          modelOptions,
-        },
-      });
+    // Save custom field values
+    await updateInstanceValues({
+      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);
-    }
-  };
+    // Remove customFields from fields array after handling
+    // eslint-disable-next-line no-param-reassign
+    fields.splice(customFieldsIdx, 1);
+  }
+};
 
 /**
  * Hook to enable individual hooks for bulk create operations

package/src/models/index.ts

@@ -29,14 +29,10 @@ const initTables = async (
   sequelize: Sequelize,
   getUser: CustomFieldOptions['getUser'],
   {
-    schemaPrefix,
-    schemaVersion,
-    useCustomFieldsEntries,
-  }: InitTablesOptions = {
-    schemaPrefix: SADOT_MIGRATION_PREFIX,
-    schemaVersion: SCHEMA_VERSION,
-    useCustomFieldsEntries: false,
-  },
+    schemaPrefix = SADOT_MIGRATION_PREFIX,
+    schemaVersion = SCHEMA_VERSION,
+    useCustomFieldsEntries = false,
+  }: InitTablesOptions = {},
 ): Promise<void> => {
   const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? '_withEntries' : ''}`;
   logger.info('custom-fields: initialize custom-fields tables');
@@ -104,11 +100,14 @@ const initTables = async (
     },
   );
 
+  logger.info('custom-fields: starting migrations');
   const migrations = await SequelizeMeta.findAll({ where: { name: { [Op.like]: `${schemaPrefix}%` } }, raw: true });
   const currentSadotSchemaVersion = migrations.at(-1);
   const expectedSchemaVersionIndex = migrations.findIndex((m) => (m as any).name === CUSTOM_FIELDS_SCHEMA_VERSION);
 
+  logger.info('custom-fields: migrations', { migrations, currentSadotSchemaVersion, expectedSchemaVersionIndex });
   if (!currentSadotSchemaVersion || (currentSadotSchemaVersion as any).name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
+    logger.info('custom-fields: syncing models');
     await CustomFieldDefinition.sync({ alter: true });
     await CustomFieldValue.sync({ alter: true });
     // T.Y TODO: Remove the if statement once we're ready to add the new entries table for all MS

package/src/repository/validator.ts

@@ -4,6 +4,7 @@ import { CustomValidator } from '../models';
 
 export interface FindValidatorOptions extends Transactionable {
   withDisabled?: boolean;
+  attributes?: string[];
 }
 
 // Make sure this interface is compatible with the Sequelize model

package/src/types/index.ts

@@ -1,9 +1,16 @@
-import type { IncludeOptions } from 'sequelize';
+import type { IncludeOptions, Transaction } from 'sequelize';
 import type { ModelCtor, Sequelize } from 'sequelize-typescript';
 import type { getUser as GetUserType } from '@autofleet/zehut';
+import type CustomFieldDefinition from '../models/CustomFieldDefinition';
 
 export type ModelFetcher = (name: string) => any;
 
+export interface TransactionOptions extends Record<string, any> {
+  transaction?: Transaction & {
+    definitionCache?: Map<string, CustomFieldDefinition[]>;
+  };
+}
+
 export type ModelOptions = {
   /**
    * Include options for the model
@@ -19,6 +26,10 @@ export type ModelOptions = {
    * Whether to use the entity id  from the instance per scope attribute
    */
   useEntityIdFromInclude?: boolean
+  /**
+   * Which attributes to include in the model
+   */
+  attributes?: string[];
 }
 export type Models = {
   name: string;