@autofleet/sadot 0.5.4-beta.23 → 0.5.4-beta.25

package/dist/hooks/create.js

@@ -27,6 +27,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.beforeCreate = exports.beforeBulkCreate = void 0;
+const logger_1 = __importDefault(require("../utils/logger"));
 const ValueRepo = __importStar(require("../repository/value"));
 const DefinitionRepo = __importStar(require("../repository/definition"));
 const errors_1 = require("../errors");
@@ -45,12 +46,12 @@ exports.beforeBulkCreate = beforeBulkCreate;
  * TODO - cleanup if update fail
  */
 const beforeCreate = (scopeAttributes, modelOptions = {}) => async (instance, options) => {
+    logger_1.default.debug('sadot - before create hook');
     const { fields } = options;
     const modelType = instance.constructor.name;
-    const { scopeAttributeReplacer } = modelOptions;
-    const identifiers = await (0, scopeAttributes_1.default)(instance, scopeAttributes, scopeAttributeReplacer);
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
     // get all model's required definitions
-    const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers);
+    const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType, instance.id, identifiers, modelOptions);
     const customFieldsIdx = fields.indexOf('customFields');
     const { customFields } = instance;
     if (customFieldsIdx > -1 && customFields) {
@@ -61,6 +62,7 @@ const beforeCreate = (scopeAttributes, modelOptions = {}) => async (instance, op
         }
         await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, {
             transaction: options.transaction,
+            modelOptions,
         });
         // eslint-disable-next-line no-param-reassign
         fields.splice(customFieldsIdx, 1);

package/dist/hooks/enrich.js

@@ -46,7 +46,6 @@ const serializeCustomFields = (customFieldValues, customFieldDefinitionsHash) =>
  * A hook to attach the custom fields when fetching a model instances.
  */
 const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {}) => async (instancesOrInstance, options) => {
-    const { scopeAttributeReplacer } = modelOptions;
     if (options.originalAttributes?.length > 0
         && !options.originalAttributes?.includes?.('customFields')) {
         return;
@@ -56,14 +55,15 @@ const enrichResults = (modelType, scopeAttributes, hookType, modelOptions = {})
         ? instancesOrInstance
         : [instancesOrInstance];
     instances = instances.filter(Boolean);
-    const identifiers = await (0, scopeAttributes_1.default)(instances, scopeAttributes, scopeAttributeReplacer);
+    const identifiers = (0, scopeAttributes_1.default)(instances, scopeAttributes);
     logger_1.default.info('enrichResults - sadot - indentifiers: ', identifiers);
     const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
+    console.log({ uniqueIdentifiers });
     const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
         ...map,
         [identifier]: [],
     }), {});
-    const customFieldDefinitions = await DefinitionRepo.findByEntityIds(modelType, uniqueIdentifiers, { transaction: options.transaction });
+    const customFieldDefinitions = await DefinitionRepo.findByEntityIds(modelType, uniqueIdentifiers, { transaction: options.transaction, modelOptions });
     const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({
         ...map,
         [definition.id]: definition,

package/dist/hooks/update.js

@@ -46,13 +46,12 @@ exports.beforeBulkUpdate = beforeBulkUpdate;
 const beforeUpdate = (scopeAttributes, modelOptions = {}) => async (instance, options) => {
     logger_1.default.debug('sadot - before update hook');
     const { fields } = options;
-    const { scopeAttributeReplacer } = modelOptions;
     const modelType = instance.constructor.name;
-    const identifiers = await (0, scopeAttributes_1.default)(instance, scopeAttributes, scopeAttributeReplacer);
+    const identifiers = (0, scopeAttributes_1.default)(instance, scopeAttributes);
     const customFieldsIdx = fields.indexOf('customFields');
     if (customFieldsIdx > -1) {
         const { customFields } = instance;
-        await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, { transaction: options.transaction });
+        await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, { transaction: options.transaction, modelOptions });
         // eslint-disable-next-line no-param-reassign
         fields.splice(customFieldsIdx, 1);
     }

package/dist/index.js

@@ -42,6 +42,7 @@ const useCustomFields = async (app, getModel, options) => {
     (0, init_1.addHooks)(models, getModel);
     await (0, models_1.initTables)(sequelize, options.getUser);
     (0, init_1.addScopes)(models, getModel);
+    (0, init_1.applyCustomAssociation)(models);
     logger_1.default.debug('sadot - custom fields finished initializing with models', models);
     return sequelize;
 };

package/dist/repository/definition.d.ts

@@ -1,11 +1,14 @@
-import { WhereOptions } from 'sequelize';
+import { FindOptions, WhereOptions } from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
+import { ModelOptions } from '../types';
 export declare const create: (data: CreateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
 export declare const findAll: (where: WhereOptions, options?: any) => Promise<CustomFieldDefinition[]>;
 export declare const findByIds: (ids: string[], options?: any) => Promise<CustomFieldDefinition[]>;
 export declare const findById: (id: string, options?: any) => Promise<CustomFieldDefinition | null>;
-export declare const findByEntityIds: (modelType: string, entityIds: string[], options?: any) => Promise<CustomFieldDefinition[]>;
+export declare const findByEntityIds: (modelType: string, entityIds: string[], options?: FindOptions & {
+    modelOptions?: ModelOptions;
+}) => Promise<CustomFieldDefinition[]>;
 export declare const findByWhere: (where: any) => Promise<CustomFieldDefinition | null>;
 export declare const findDefinitionsByModels: (modelTypes: string[], options?: any) => Promise<CustomFieldDefinition[]>;
 export declare const update: (id: string, data: UpdateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
@@ -14,4 +17,4 @@ export declare const destroy: (id: string) => Promise<any>;
 /**
  * Return the names of the required fields for a given model
  */
-export declare const getRequiredFields: (modelType: string, modelId: string | string[], entityId: string | string[]) => Promise<string[]>;
+export declare const getRequiredFields: (modelType: string, modelId: string | string[], entityId: string | string[], modelOptions?: ModelOptions) => Promise<string[]>;

package/dist/repository/definition.js

@@ -13,6 +13,8 @@ const findAll = (where, options = { withDisabled: false }) => {
         where,
         transaction: options.transaction,
         raw: true,
+        include: options.include,
+        logging: console.log,
     });
 };
 exports.findAll = findAll;
@@ -26,14 +28,21 @@ const findById = (id, options = { withDisabled: false }) => {
     return models_1.CustomFieldDefinition.scope('userScope').findByPk(id);
 };
 exports.findById = findById;
-const findByEntityIds = async (modelType, entityIds, options = {}) => models_1.CustomFieldDefinition.findAll({
-    where: {
+const findByEntityIds = async (modelType, entityIds, options = {}) => {
+    const { include, useEntityIdFromInclude } = options.modelOptions;
+    const where = {
         modelType,
-        entityId: entityIds,
-    },
-    transaction: options.transaction,
-    raw: true,
-});
+    };
+    if (!useEntityIdFromInclude) {
+        where.entityId = entityIds;
+    }
+    return models_1.CustomFieldDefinition.findAll({
+        where,
+        transaction: options.transaction,
+        include: include?.(entityIds),
+        raw: true,
+    });
+};
 exports.findByEntityIds = findByEntityIds;
 const findByWhere = (where) => models_1.CustomFieldDefinition.scope('userScope').findOne({
     where,
@@ -63,14 +72,19 @@ exports.destroy = destroy;
 /**
  * Return the names of the required fields for a given model
  */
-const getRequiredFields = async (modelType, modelId, entityId) => {
+const getRequiredFields = async (modelType, modelId, entityId, modelOptions = {}) => {
     const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+    const { include, useEntityIdFromInclude } = modelOptions;
+    const where = {
+        modelType,
+        required: true,
+    };
+    if (!useEntityIdFromInclude) {
+        where.entityId = entityIds;
+    }
     const requiredFields = await models_1.CustomFieldDefinition.findAll({
-        where: {
-            required: true,
-            modelType,
-            entityId: { [sequelize_1.Op.in]: entityIds },
-        },
+        where,
+        include: include?.(entityIds),
         logging: true,
     });
     const requiredFieldsNames = requiredFields.map((definition) => definition.name);

package/dist/repository/value.d.ts

@@ -1,5 +1,7 @@
+import { FindOptions } from 'sequelize';
 import { CustomFieldValue } from '../models';
 import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
+import { ModelOptions } from '../types';
 export declare const findByModelIdAndDefinition: (modelId: string, customFieldDefinitionId: string) => Promise<CustomFieldValue[]>;
 export declare const create: (data: CreateCustomFieldValue, withAssociations?: boolean) => Promise<CustomFieldValue>;
 export declare const findAllValues: () => Promise<CustomFieldValue[]>;
@@ -20,5 +22,7 @@ export declare const findValuesByModelIds: (modelIds: string[], options?: any) =
  * Create new value record if not exists, but fails if value's definition not exist.
  * Return the updated values
  */
-export declare const updateValues: (modelType: string, modelId: string, identifiers: string[], valuesToUpdate: ValuesToUpdate, options?: any) => Promise<CustomFieldValue[]>;
+export declare const updateValues: (modelType: string, modelId: string, identifiers: string[], valuesToUpdate: ValuesToUpdate, options?: FindOptions & {
+    modelOptions?: ModelOptions;
+}) => Promise<CustomFieldValue[]>;
 export declare const deleteValue: (id: string, options?: any) => Promise<any>;

package/dist/repository/value.js

@@ -27,7 +27,6 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteValue = exports.updateValues = exports.findValuesByModelIds = exports.findValuesByModelId = exports.findAllValues = exports.create = exports.findByModelIdAndDefinition = void 0;
-/* eslint-disable max-len */
 const models_1 = require("../models");
 const DefinitionRepo = __importStar(require("./definition"));
 const logger_1 = __importDefault(require("../utils/logger"));
@@ -74,14 +73,18 @@ exports.findValuesByModelIds = findValuesByModelIds;
  */
 const updateValues = async (modelType, modelId, identifiers, valuesToUpdate, options = {}) => {
     const names = Object.keys(valuesToUpdate);
-    logger_1.default.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
-        names, options, valuesToUpdate, entityId: identifiers,
+    logger_1.default.info(`custom-fiel  ds: updating values for ${modelType} ${modelId}`, {
+        names, options, valuesToUpdate, identifiers,
     });
-    const fieldDefinitions = await DefinitionRepo.findAll({
+    const { modelOptions, transaction } = options;
+    const where = {
         modelType,
         name: names,
-        entityId: identifiers,
-    }, { withDisabled: true, transaction: options.transaction }) || [];
+    };
+    if (!options.modelOptions?.useEntityIdFromInclude) {
+        where.entityId = identifiers;
+    }
+    const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) || [];
     const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
     if (fieldDefinitions.length !== names.length) {
         logger_1.default.info(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names, fieldDefinitions });

package/dist/types/index.d.ts

@@ -1,10 +1,24 @@
+import { Includeable } from 'sequelize';
+import { ModelCtor } from 'sequelize-typescript';
 export type ModelFetcher = (name: string) => any;
 export type ModelOptions = {
-    scopeAttributeReplacer?: (attributes?: string[]) => Promise<(string | undefined)[]>;
+    include?: (entityIds: string[]) => Includeable[];
+    /**
+     * A function that will be called to resolve the entity id.
+     * @param {string | string[]}  -  The entity id.
+     * @returns {void}
+     */
+    customAssociation?: (model: ModelCtor) => void;
+    /**
+     * Whether to use the entity id  from the instance per scope attribute
+     * @param {string}  -
+     * @returns {void}
+     */
+    useEntityIdFromInclude?: boolean;
 };
 export type Models = {
     name: string;
-    scopeAttributes: string[];
+    scopeAttributes: any[];
     modelOptions?: ModelOptions;
     creationWebhookHandler?: (instance: any) => any;
     updateWebhookHandler?: (instance: any) => any;

package/dist/utils/init.d.ts

@@ -2,3 +2,4 @@ import type { ModelFetcher, Models } from '../types';
 export declare const addHooks: (models: Models[], getModel: ModelFetcher) => void;
 export declare const removeHooks: (models: Models[], getModel: ModelFetcher) => void;
 export declare const addScopes: (models: Models[], getModel: ModelFetcher) => void;
+export declare const applyCustomAssociation: (models: Models[]) => void;

package/dist/utils/init.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
+exports.applyCustomAssociation = exports.addScopes = exports.removeHooks = exports.addHooks = void 0;
 const sequelize_1 = require("sequelize");
 const common_types_1 = require("@autofleet/common-types");
 const models_1 = require("../models");
@@ -98,3 +98,9 @@ const addScopes = (models, getModel) => {
     });
 };
 exports.addScopes = addScopes;
+const applyCustomAssociation = (models) => {
+    models.forEach(({ modelOptions }) => {
+        modelOptions?.customAssociation?.(models_1.CustomFieldDefinition);
+    });
+};
+exports.applyCustomAssociation = applyCustomAssociation;

package/dist/utils/scopeAttributes.d.ts

@@ -1,3 +1,2 @@
-import { ModelOptions } from '../types';
-declare const getScopeAttributes: (instance: any, scopeAttributes: string[], scopeAttributeReplacer?: ModelOptions['scopeAttributeReplacer']) => Promise<string[]>;
-export default getScopeAttributes;
+declare const buildAttributesByInstance: (instance: any, scopeAttributes: string[]) => any[];
+export default buildAttributesByInstance;

package/dist/utils/scopeAttributes.js

@@ -1,29 +1,11 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-const logger_1 = __importDefault(require("./logger"));
-const attributeCache = new Map();
 const mapAttributeToInstance = (scopeAttributes, instance) => scopeAttributes.map((attr) => instance[attr]);
 const buildAttributesByInstance = (instance, scopeAttributes) => {
+    const uniqueAttributes = Array.from(new Set(scopeAttributes));
     if (Array.isArray(instance)) {
-        return instance.flatMap((ins) => mapAttributeToInstance(scopeAttributes, ins));
-    }
-    return mapAttributeToInstance(scopeAttributes, instance);
-};
-const getScopeAttributes = async (instance, scopeAttributes, scopeAttributeReplacer) => {
-    logger_1.default.info('Getting scope attributes', { instance, scopeAttributes });
-    const attributes = buildAttributesByInstance(instance, scopeAttributes);
-    const attributeCacheKey = attributes.join();
-    const cachedAttributes = attributeCache.get(attributeCacheKey);
-    if (cachedAttributes) {
-        logger_1.default.info('Using cached attributes', { cachedAttributes });
-        return cachedAttributes;
+        return instance.flatMap((ins) => mapAttributeToInstance(uniqueAttributes, ins));
     }
-    const attributeResult = (scopeAttributeReplacer
-        ? await scopeAttributeReplacer(attributes) : attributes);
-    attributeCache.set(attributeCacheKey, attributeResult);
-    return attributeResult;
+    return mapAttributeToInstance(uniqueAttributes, instance);
 };
-exports.default = getScopeAttributes;
+exports.default = buildAttributesByInstance;

package/package.json

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

package/src/hooks/create.ts

@@ -1,8 +1,9 @@
+import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
 import { MissingRequiredCustomFieldError } from '../errors';
 import { ModelOptions } from '../types';
-import getScopeAttributes from '../utils/scopeAttributes';
+import buildAttributesByInstance from '../utils/scopeAttributes';
 
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
@@ -20,15 +21,16 @@ export const beforeCreate = (scopeAttributes: string[], modelOptions: ModelOptio
   instance,
   options,
 ): Promise<void> => {
+  logger.debug('sadot - before create hook');
   const { fields } = options;
   const modelType = instance.constructor.name;
-  const { scopeAttributeReplacer } = modelOptions;
 
-  const identifiers = await getScopeAttributes(instance, scopeAttributes, scopeAttributeReplacer);
+  const identifiers = buildAttributesByInstance(instance, scopeAttributes);
+
   // get all model's required definitions
   const requiredFieldsNames = await DefinitionRepo.getRequiredFields(modelType,
-    instance.id,
-    identifiers);
+    instance.id, identifiers, modelOptions);
+
   const customFieldsIdx = fields.indexOf('customFields');
   const { customFields } = instance;
   if (customFieldsIdx > -1 && customFields) {
@@ -45,6 +47,7 @@ export const beforeCreate = (scopeAttributes: string[], modelOptions: ModelOptio
       customFields,
       {
         transaction: options.transaction,
+        modelOptions,
       },
     );
 

package/src/hooks/enrich.ts

@@ -6,7 +6,7 @@ import CustomFieldDefinition from '../models/CustomFieldDefinition';
 import { SerializedCustomFields } from '../types/definition';
 import logger from '../utils/logger';
 import { ModelOptions } from '../types';
-import getScopeAttributes from '../utils/scopeAttributes';
+import buildAttributesByInstance from '../utils/scopeAttributes';
 
 type SupportedHookTypes = 'afterFind' | 'afterCreate' | 'afterUpdate';
 
@@ -38,7 +38,6 @@ const enrichResults = (
   instancesOrInstance: any | any[],
   options,
 ): Promise<void> => {
-  const { scopeAttributeReplacer } = modelOptions;
   if (
     options.originalAttributes?.length > 0
       && !options.originalAttributes?.includes?.('customFields')
@@ -53,11 +52,14 @@ const enrichResults = (
 
   instances = instances.filter(Boolean);
 
-  const identifiers = await getScopeAttributes(instances, scopeAttributes, scopeAttributeReplacer);
+  const identifiers = buildAttributesByInstance(instances, scopeAttributes);
+
   logger.info('enrichResults - sadot - indentifiers: ', identifiers);
 
   const uniqueIdentifiers = [...new Set(identifiers)].filter(Boolean);
 
+  console.log({ uniqueIdentifiers });
+
   const identifierCustomFieldDefinitionsMapping = uniqueIdentifiers.reduce((map, identifier) => ({
     ...map,
     [identifier]: [],
@@ -67,7 +69,7 @@ const enrichResults = (
   const customFieldDefinitions = await DefinitionRepo.findByEntityIds(
     modelType,
     uniqueIdentifiers,
-    { transaction: options.transaction },
+    { transaction: options.transaction, modelOptions },
   );
 
   const definitionsMap = customFieldDefinitions.reduce((map, definition) => ({

package/src/hooks/find.ts

@@ -16,7 +16,6 @@ const doScopeAttributesMissing = (
 // eslint-disable-next-line import/prefer-default-export
 export const beforeFind = (scopeAttributes: string[]) => (options): void => {
   const { attributes: queryAttributes } = options;
-
   if (queryAttributes?.includes?.('customFields')) {
     const missingScopeAttributes = doScopeAttributesMissing(scopeAttributes, queryAttributes);
     logger.debug('sadot - before find hook');

package/src/hooks/update.ts

@@ -1,7 +1,7 @@
 import logger from '../utils/logger';
 import * as ValueRepo from '../repository/value';
 import { ModelOptions } from '../types';
-import getScopeAttributes from '../utils/scopeAttributes';
+import buildAttributesByInstance from '../utils/scopeAttributes';
 
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
@@ -22,9 +22,8 @@ export const beforeUpdate = (scopeAttributes: string[], modelOptions: ModelOptio
 ): Promise<void> => {
   logger.debug('sadot - before update hook');
   const { fields } = options;
-  const { scopeAttributeReplacer } = modelOptions;
   const modelType = instance.constructor.name;
-  const identifiers = await getScopeAttributes(instance, scopeAttributes, scopeAttributeReplacer);
+  const identifiers = buildAttributesByInstance(instance, scopeAttributes);
 
   const customFieldsIdx = fields.indexOf('customFields');
   if (customFieldsIdx > -1) {
@@ -34,7 +33,7 @@ export const beforeUpdate = (scopeAttributes: string[], modelOptions: ModelOptio
       instance.id,
       identifiers,
       customFields,
-      { transaction: options.transaction },
+      { transaction: options.transaction, modelOptions },
 
     );
     // eslint-disable-next-line no-param-reassign

package/src/index.ts

@@ -7,7 +7,9 @@ import api from './api';
 import initDB from './utils/db';
 import logger from './utils/logger';
 import type { CustomFieldOptions, ModelFetcher } from './types';
-import { addHooks, addScopes, removeHooks } from './utils/init';
+import {
+  addHooks, addScopes, applyCustomAssociation, removeHooks,
+} from './utils/init';
 
 export * from './utils/validations/custom-fields';
 
@@ -34,6 +36,7 @@ const useCustomFields = async (
   addHooks(models, getModel);
   await initTables(sequelize, options.getUser);
   addScopes(models, getModel);
+  applyCustomAssociation(models);
   logger.debug('sadot - custom fields finished initializing with models', models);
   return sequelize;
 };

package/src/repository/definition.ts

@@ -1,8 +1,10 @@
 import {
+  FindOptions,
   Op, WhereOptions,
 } from 'sequelize';
 import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
+import { ModelOptions } from '../types';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
@@ -19,6 +21,8 @@ export const findAll = (
     where,
     transaction: options.transaction,
     raw: true,
+    include: options.include,
+    logging: console.log,
   });
 };
 
@@ -41,15 +45,23 @@ export const findById = (
 export const findByEntityIds = async (
   modelType: string,
   entityIds: string[],
-  options: any = {},
-): Promise<CustomFieldDefinition[]> => CustomFieldDefinition.findAll({
-  where: {
+  options: FindOptions & { modelOptions?: ModelOptions } = {},
+): Promise<CustomFieldDefinition[]> => {
+  const { include, useEntityIdFromInclude } = options.modelOptions;
+  const where: WhereOptions = {
     modelType,
-    entityId: entityIds,
-  },
-  transaction: options.transaction,
-  raw: true,
-});
+  };
+
+  if (!useEntityIdFromInclude) {
+    where.entityId = entityIds;
+  }
+  return CustomFieldDefinition.findAll({
+    where,
+    transaction: options.transaction,
+    include: include?.(entityIds),
+    raw: true,
+  });
+};
 
 export const findByWhere = (where): Promise<CustomFieldDefinition | null> =>
   CustomFieldDefinition.scope('userScope').findOne({
@@ -95,14 +107,23 @@ export const getRequiredFields = async (
   modelType: string,
   modelId: string | string[],
   entityId: string | string[],
+  modelOptions: ModelOptions = {},
 ): Promise<string[]> => {
   const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+  const { include, useEntityIdFromInclude } = modelOptions;
+
+  const where: WhereOptions = {
+    modelType,
+    required: true,
+  };
+
+  if (!useEntityIdFromInclude) {
+    where.entityId = entityIds;
+  }
+
   const requiredFields = await CustomFieldDefinition.findAll({
-    where: {
-      required: true,
-      modelType,
-      entityId: { [Op.in]: entityIds },
-    },
+    where,
+    include: include?.(entityIds),
     logging: true,
   });
   const requiredFieldsNames = requiredFields.map((definition) => definition.name);

package/src/repository/value.ts

@@ -1,9 +1,11 @@
 /* eslint-disable max-len */
+import { FindOptions, WhereOptions } from 'sequelize';
 import { CustomFieldValue, CustomFieldDefinition } from '../models';
 import * as DefinitionRepo from './definition';
 import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
 import logger from '../utils/logger';
 import { MissingDefinitionError } from '../errors';
+import { ModelOptions } from '../types';
 
 export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
   CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });
@@ -50,21 +52,23 @@ export const updateValues = async (
   modelId: string,
   identifiers: string[],
   valuesToUpdate: ValuesToUpdate,
-  options: any = {},
+  options: FindOptions & { modelOptions?: ModelOptions } = {},
 ): Promise<CustomFieldValue[]> => {
   const names = Object.keys(valuesToUpdate);
-  logger.info(`custom-fields: updating values for ${modelType} ${modelId}`, {
-    names, options, valuesToUpdate, entityId: identifiers,
+  logger.info(`custom-fiel  ds: updating values for ${modelType} ${modelId}`, {
+    names, options, valuesToUpdate, identifiers,
   });
+  const { modelOptions, transaction } = options;
+
+  const where: WhereOptions = {
+    modelType,
+    name: names,
+  };
 
-  const fieldDefinitions = await DefinitionRepo.findAll(
-    {
-      modelType,
-      name: names,
-      entityId: identifiers,
-    },
-    { withDisabled: true, transaction: options.transaction },
-  ) || [];
+  if (!options.modelOptions?.useEntityIdFromInclude) {
+    where.entityId = identifiers;
+  }
+  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: true, transaction, include: modelOptions.include?.(identifiers) }) || [];
 
   const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
   if (fieldDefinitions.length !== names.length) {

package/src/types/index.ts

@@ -1,11 +1,28 @@
+import { Includeable } from 'sequelize';
+import { ModelCtor } from 'sequelize-typescript';
+
 export type ModelFetcher = (name: string) => any;
 
 export type ModelOptions = {
-  scopeAttributeReplacer?: (attributes?: string[]) => Promise<(string | undefined)[]>;
+  include?: (entityIds: string[]) => Includeable[];
+  /**
+   * A function that will be called to resolve the entity id.
+   * @param {string | string[]}  -  The entity id.
+   * @returns {void}
+   */
+
+  customAssociation?: (model: ModelCtor) => void;
+  /**
+   * Whether to use the entity id  from the instance per scope attribute
+   * @param {string}  -
+   * @returns {void}
+   */
+
+  useEntityIdFromInclude?: boolean
 }
 export type Models = {
   name: string;
-  scopeAttributes: string[];
+  scopeAttributes: any[];
   modelOptions?: ModelOptions;
   creationWebhookHandler?: (instance: any) => any;
   updateWebhookHandler?: (instance: any) => any;
@@ -16,4 +33,5 @@ export type CustomFieldOptions = {
   models: Models[];
   databaseConfig: any;
   getUser: () => any;
+
 };

package/src/utils/init.ts

@@ -2,6 +2,7 @@ import { DataTypes } from 'sequelize';
 import { ModelCtor } from 'sequelize-typescript';
 import { customFields } from '@autofleet/common-types';
 import {
+  CustomFieldDefinition,
   CustomFieldValue,
 } from '../models';
 import {
@@ -103,3 +104,9 @@ export const addScopes = (models: Models[], getModel: ModelFetcher): void => {
     }
   });
 };
+
+export const applyCustomAssociation = (models: Models[]): void => {
+  models.forEach(({ modelOptions }) => {
+    modelOptions?.customAssociation?.(CustomFieldDefinition);
+  });
+};

package/src/utils/scopeAttributes.ts

@@ -1,32 +1,12 @@
-import { ModelOptions } from '../types';
-import logger from './logger';
-
-const attributeCache = new Map<string, string[]>();
-
 const mapAttributeToInstance = (scopeAttributes: string[], instance: any) =>
   scopeAttributes.map((attr) => instance[attr]);
 
 const buildAttributesByInstance = (instance: any, scopeAttributes: string[]) => {
+  const uniqueAttributes = Array.from(new Set(scopeAttributes));
   if (Array.isArray(instance)) {
-    return instance.flatMap((ins) => mapAttributeToInstance(scopeAttributes, ins));
-  }
-  return mapAttributeToInstance(scopeAttributes, instance);
-};
-
-const getScopeAttributes = async (instance: any, scopeAttributes: string[],
-  scopeAttributeReplacer?: ModelOptions['scopeAttributeReplacer']): Promise<string[]> => {
-  logger.info('Getting scope attributes', { instance, scopeAttributes });
-  const attributes = buildAttributesByInstance(instance, scopeAttributes);
-  const attributeCacheKey = attributes.join();
-  const cachedAttributes = attributeCache.get(attributeCacheKey);
-  if (cachedAttributes) {
-    logger.info('Using cached attributes', { cachedAttributes });
-    return cachedAttributes;
+    return instance.flatMap((ins) => mapAttributeToInstance(uniqueAttributes, ins));
   }
-  const attributeResult = (scopeAttributeReplacer
-    ? await scopeAttributeReplacer(attributes) : attributes);
-  attributeCache.set(attributeCacheKey, attributeResult);
-  return attributeResult;
+  return mapAttributeToInstance(uniqueAttributes, instance);
 };
 
-export default getScopeAttributes;
+export default buildAttributesByInstance;