@autofleet/sadot 0.13.3-beta-1bef9935.8 → 0.13.3

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 {};
@@ -78,6 +80,7 @@ const serializeCustomFields = (customFieldValues, customFieldDefinitionsHash) =>
  * A hook to attach the custom fields when fetching a model instances.
  */
 const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instancesOrInstance, options) => {
+    var _a;
     if (options.originalAttributes?.length > 0
         && !options.originalAttributes?.includes?.('customFields')) {
         return;
@@ -93,7 +96,27 @@ 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;
+    if (options.transaction) {
+        // Initialize definition cache Map if not already present directly on the transaction object
+        (_a = options.transaction).definitionCache || (_a.definitionCache = new Map());
+        cacheKey = `${modelType}:${uniqueIdentifiers.slice().sort().join(',')}`;
+        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 });
+        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 +137,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

@@ -38,6 +38,7 @@ 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");
+const CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL = ['schema'];
 // Initialize Ajv with relaxed settings to avoid warnings
 const ajv = new ajv_1.default({
     allErrors: true,
@@ -90,6 +91,7 @@ const getCompleteCustomFields = async (instance, options) => {
  * Validates the model using custom validators
  */
 const validateModel = async (instance, options, scopeAttributes, 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);
@@ -106,7 +108,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
+        (_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,
+        });
+        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');
@@ -125,16 +144,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;
@@ -180,7 +189,7 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
             };
             // Validate
             const isValid = validateSchema(JSON.parse(JSON.stringify(payload)));
-            logger_1.default.info('sadot - validation result', {
+            logger_1.default.debug('sadot - validation result', {
                 isValid,
                 test: {
                     before: originalValues,
@@ -188,10 +197,9 @@ const validateModel = async (instance, options, scopeAttributes, isCreate = fals
                 },
             });
             if (!isValid) {
-                const errorDetails = validateSchema.errors?.map((err) => {
-                    logger_1.default.info('dor', err);
-                    return `${err.instancePath || ''} ${err.message || 'Invalid value'}`;
-                }).join(', ');
+                const errorDetails = validateSchema
+                    .errors
+                    ?.map((err) => `${err.instancePath || ''} ${err.message || 'Invalid value'}`).join(', ');
                 throw new errors_1.BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
             }
         }

package/dist/index.js

@@ -43,36 +43,21 @@ __exportStar(require("./utils/helpers"), exports);
  * @see {@link 'custom-fields/config'} for configurations
  */
 const useCustomFields = async (app, getModel, options) => {
-    console.log('useCustomFields: start');
-    (0, logger_1.tryAddingTraceIdMiddleware)()
-        .then(() => console.log('useCustomFields: tryAddingTraceIdMiddleware done'))
-        .catch(() => console.log('useCustomFields: tryAddingTraceIdMiddleware failed'));
+    (0, logger_1.tryAddingTraceIdMiddleware)().catch(() => null);
     const { models, useCustomFieldsEntries } = options;
-    console.log('useCustomFields: options extracted', { models, useCustomFieldsEntries });
     if (app) {
-        console.log('useCustomFields: app exists, setting up /api route');
         app.use('/api', api_1.default);
     }
-    else {
-        console.log('useCustomFields: no app provided');
-    }
     const sequelize = options.sequelize ?? (0, db_1.default)(options.databaseConfig);
-    if (!options.sequelize) {
-        console.log('useCustomFields: initialized new Sequelize instance');
-    }
-    else {
-        console.log('useCustomFields: using provided Sequelize instance');
+    if (process.env.NODE_ENV === 'test') {
+        await (0, models_1.initTestModels)(sequelize);
     }
-    console.log('useCustomFields: adding hooks');
+    // The order is important
     (0, init_1.addHooks)(models, getModel, { useCustomFieldsEntries });
-    console.log('useCustomFields: initializing tables');
     await (0, models_1.initTables)(sequelize, options.getUser, { useCustomFieldsEntries });
-    console.log('useCustomFields: adding scopes');
     (0, init_1.addScopes)(models, getModel, { useCustomFieldsEntries });
-    console.log('useCustomFields: applying custom associations');
     (0, init_1.applyCustomAssociation)(models);
     logger_1.default.debug('sadot - custom fields finished initializing with models', models);
-    console.log('useCustomFields: finished and returning sequelize');
     return sequelize;
 };
 exports.default = useCustomFields;

package/dist/models/index.js

@@ -112,44 +112,20 @@ const initTables = async (sequelize, getUser, { schemaPrefix = SADOT_MIGRATION_P
 };
 exports.initTables = initTables;
 const initTestModels = async (sequelize) => {
-    // console.log('initTestModels: start');
-    // logger.info('custom-fields: initialize custom-fields test models');
-    //
-    // if (!sequelize.addModels) {
-    //   console.error('initTestModels: sequelize missing addModels function');
-    //   throw new Error('sequelize instance must have addModels function');
-    // }
-    // console.log('initTestModels: addModels function exists');
-    //
-    // sequelize.addModels(testModels);
-    // console.log('initTestModels: test models added');
-    //
-    // try {
-    //   await sequelize.dropSchema('custom-fields', { logging: true });
-    //   console.log('initTestModels: schema dropped');
-    //
-    //   await sequelize.createSchema('custom-fields', { logging: true });
-    //   console.log('initTestModels: schema created');
-    // } catch (error) {
-    //   console.log('initTestModels: error dropping or creating schema', error);
-    //   throw new Error('Failed to drop or create schema');
-    // }
-    //
-    // logger.info('custom-fields: test models added');
-    //
-    // console.log('initTestModels: syncing TestModel');
-    // await TestModel.sync({ alter: true });
-    //
-    // console.log('initTestModels: syncing AssociatedTestModel');
-    // await AssociatedTestModel.sync({ alter: true });
-    //
-    // console.log('initTestModels: syncing ContextTestModel');
-    // await ContextTestModel.sync({ alter: true });
-    //
-    // console.log('initTestModels: syncing ContextAwareTestModel');
-    // await ContextAwareTestModel.sync({ alter: true });
-    //
-    // logger.info('custom-fields: test models synced');
-    // console.log('initTestModels: finished');
+    logger_1.default.info('custom-fields: initialize custom-fields test models');
+    // Detect models and import them to the orm
+    // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+    if (!sequelize.addModels) {
+        throw new Error('sequelize instance must have addModels function');
+    }
+    sequelize.addModels(testModels);
+    await sequelize.dropSchema('custom-fields', { logging: false });
+    await sequelize.createSchema('custom-fields', { logging: false });
+    logger_1.default.info('custom-fields: test models added');
+    await TestModel_1.default.sync({ alter: true });
+    await AssociatedTestModel_1.default.sync({ alter: true });
+    await ContextTestModel_1.default.sync({ alter: true });
+    await ContextAwareTestModel_1.default.sync({ alter: true });
+    logger_1.default.info('custom-fields: test models synced');
 };
 exports.initTestModels = initTestModels;

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,15 @@
-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';
+import type CustomValidator from '../models/CustomValidator';
 export type ModelFetcher = (name: string) => any;
+export interface TransactionOptions extends Record<string, any> {
+    transaction?: Transaction & {
+        definitionCache?: Map<string, CustomFieldDefinition[]>;
+        validationsCache?: Map<string, CustomValidator[]>;
+    };
+}
 export type ModelOptions = {
     /**
      * Include options for the model
@@ -16,6 +24,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.3-beta-1bef9935.8",
+  "version": "0.13.3",
   "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,37 @@ 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;
+
+  if (options.transaction) {
+    // Initialize definition cache Map if not already present directly on the transaction object
+    options.transaction.definitionCache ||= new Map();
+    cacheKey = `${modelType}:${uniqueIdentifiers.slice().sort().join(',')}`;
+    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 },
+    );
+
+    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 +188,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

@@ -13,6 +13,8 @@ import updateInstanceValues from './utils/updateInstanceValues';
 import { CustomFieldDefinitionType } from '../utils/constants';
 import type { CustomFieldDefinition } from '../models';
 
+const CUSTOM_VALIDATOR_ATTRIBUTES_TO_PULL = ['schema'];
+
 // Initialize Ajv with relaxed settings to avoid warnings
 const ajv = new Ajv({
   allErrors: true,
@@ -105,11 +107,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 ||= 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,
+      },
+    );
+    if (options.transaction) {
+      options?.transaction?.validationsCache.set(cacheKey, validatorsPromise);
+    }
+  }
+  const validators = await validatorsPromise;
 
   logger.debug('sadot - validators found', { count: validators.length });
 
@@ -134,18 +154,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) {
     const { schema } = validator;
@@ -201,7 +209,7 @@ const validateModel = async (
       // Validate
       const isValid = validateSchema(JSON.parse(JSON.stringify(payload)));
 
-      logger.info('sadot - validation result', {
+      logger.debug('sadot - validation result', {
         isValid,
         test: {
           before: originalValues,
@@ -210,10 +218,9 @@ const validateModel = async (
       });
 
       if (!isValid) {
-        const errorDetails = validateSchema.errors?.map((err) => {
-          logger.info('dor', err);
-          return `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`;
-        }).join(', ');
+        const errorDetails = validateSchema
+          .errors
+          ?.map((err) => `${(err as any).instancePath || ''} ${(err as any).message || 'Invalid value'}`).join(', ');
 
         throw new BadRequest([new Error(`Validation failed for ${modelType}: ${errorDetails}`)]);
       }

package/src/index.ts

@@ -26,44 +26,22 @@ const useCustomFields = async (
   getModel: ModelFetcher,
   options: CustomFieldOptions,
 ): Promise<Sequelize> => {
-  console.log('useCustomFields: start');
-
-  tryAddingTraceIdMiddleware()
-    .then(() => console.log('useCustomFields: tryAddingTraceIdMiddleware done'))
-    .catch(() => console.log('useCustomFields: tryAddingTraceIdMiddleware failed'));
-
+  tryAddingTraceIdMiddleware().catch(() => null);
   const { models, useCustomFieldsEntries } = options;
-  console.log('useCustomFields: options extracted', { models, useCustomFieldsEntries });
-
   if (app) {
-    console.log('useCustomFields: app exists, setting up /api route');
     app.use('/api', api);
-  } else {
-    console.log('useCustomFields: no app provided');
   }
-
   const sequelize = options.sequelize ?? initDB(options.databaseConfig);
-  if (!options.sequelize) {
-    console.log('useCustomFields: initialized new Sequelize instance');
-  } else {
-    console.log('useCustomFields: using provided Sequelize instance');
+  if (process.env.NODE_ENV === 'test') {
+    await initTestModels(sequelize);
   }
-
-  console.log('useCustomFields: adding hooks');
+  // The order is important
   addHooks(models, getModel, { useCustomFieldsEntries });
-
-  console.log('useCustomFields: initializing tables');
   await initTables(sequelize, options.getUser, { useCustomFieldsEntries });
-
-  console.log('useCustomFields: adding scopes');
   addScopes(models, getModel, { useCustomFieldsEntries });
-
-  console.log('useCustomFields: applying custom associations');
   applyCustomAssociation(models);
 
   logger.debug('sadot - custom fields finished initializing with models', models);
-  console.log('useCustomFields: finished and returning sequelize');
-
   return sequelize;
 };
 

package/src/models/index.ts

@@ -132,45 +132,23 @@ const initTables = async (
 };
 
 const initTestModels = async (sequelize: Sequelize): Promise<void> => {
-  // console.log('initTestModels: start');
-  // logger.info('custom-fields: initialize custom-fields test models');
-  //
-  // if (!sequelize.addModels) {
-  //   console.error('initTestModels: sequelize missing addModels function');
-  //   throw new Error('sequelize instance must have addModels function');
-  // }
-  // console.log('initTestModels: addModels function exists');
-  //
-  // sequelize.addModels(testModels);
-  // console.log('initTestModels: test models added');
-  //
-  // try {
-  //   await sequelize.dropSchema('custom-fields', { logging: true });
-  //   console.log('initTestModels: schema dropped');
-  //
-  //   await sequelize.createSchema('custom-fields', { logging: true });
-  //   console.log('initTestModels: schema created');
-  // } catch (error) {
-  //   console.log('initTestModels: error dropping or creating schema', error);
-  //   throw new Error('Failed to drop or create schema');
-  // }
-  //
-  // logger.info('custom-fields: test models added');
-  //
-  // console.log('initTestModels: syncing TestModel');
-  // await TestModel.sync({ alter: true });
-  //
-  // console.log('initTestModels: syncing AssociatedTestModel');
-  // await AssociatedTestModel.sync({ alter: true });
-  //
-  // console.log('initTestModels: syncing ContextTestModel');
-  // await ContextTestModel.sync({ alter: true });
-  //
-  // console.log('initTestModels: syncing ContextAwareTestModel');
-  // await ContextAwareTestModel.sync({ alter: true });
-  //
-  // logger.info('custom-fields: test models synced');
-  // console.log('initTestModels: finished');
+  logger.info('custom-fields: initialize custom-fields test models');
+  // Detect models and import them to the orm
+  // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
+  if (!sequelize.addModels) {
+    throw new Error('sequelize instance must have addModels function');
+  }
+
+  sequelize.addModels(testModels);
+  await sequelize.dropSchema('custom-fields', { logging: false });
+  await sequelize.createSchema('custom-fields', { logging: false });
+
+  logger.info('custom-fields: test models added');
+  await TestModel.sync({ alter: true });
+  await AssociatedTestModel.sync({ alter: true });
+  await ContextTestModel.sync({ alter: true });
+  await ContextAwareTestModel.sync({ alter: true });
+  logger.info('custom-fields: test models synced');
 };
 
 export {

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,18 @@
-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';
+import type CustomValidator from '../models/CustomValidator';
 
 export type ModelFetcher = (name: string) => any;
 
+export interface TransactionOptions extends Record<string, any> {
+  transaction?: Transaction & {
+    definitionCache?: Map<string, CustomFieldDefinition[]>;
+    validationsCache?: Map<string, CustomValidator[]>;
+  };
+}
+
 export type ModelOptions = {
   /**
    * Include options for the model
@@ -19,6 +28,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/.env

@@ -1,4 +0,0 @@
-AF_SERVICE_NAME=sadot_package_test
-NODE_ENV=test
-DB_USERNAME=postgres
-DB_PASSWORD=postgres