@autofleet/sadot 0.9.1 → 0.10.0

package/dist/errors/index.js

@@ -52,7 +52,7 @@ class InvalidEntriesError extends errors_1.BadRequest {
     constructor(modelId, validationErrors) {
         const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
         super(errors, null, null);
-        this.message = `Invalid entries on ${modelId}`;
+        this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (`${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`)).join('\n')}`;
     }
 }
 exports.InvalidEntriesError = InvalidEntriesError;

package/dist/hooks/create.d.ts

@@ -1,4 +1,4 @@
-import type { ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions } from '../types';
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
  */
@@ -7,4 +7,4 @@ export declare const beforeBulkCreate: (options: any) => void;
  * A hook to create the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export declare const beforeCreate: (scopeAttributes: string[], modelOptions?: ModelOptions) => (instance: any, options: any) => Promise<void>;
+export declare const beforeCreate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;

package/dist/hooks/create.js

@@ -28,10 +28,10 @@ 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");
 const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+const updateInstanceValues_1 = __importDefault(require("./utils/updateInstanceValues"));
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
  */
@@ -45,7 +45,7 @@ exports.beforeBulkCreate = beforeBulkCreate;
  * A hook to create the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-const beforeCreate = (scopeAttributes, modelOptions = {}) => async (instance, options) => {
+const beforeCreate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
     logger_1.default.debug('sadot - before create hook');
     const { fields } = options;
     const { include, useEntityIdFromInclude } = modelOptions;
@@ -80,9 +80,16 @@ const beforeCreate = (scopeAttributes, modelOptions = {}) => async (instance, op
     if (missingFields?.length > 0) {
         throw new errors_1.MissingRequiredCustomFieldError(missingFields);
     }
-    await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, {
-        transaction: options.transaction,
-        modelOptions,
+    await (0, updateInstanceValues_1.default)({
+        modelId: instance.id,
+        modelType,
+        identifiers,
+        customFields,
+        options: {
+            useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+            transaction: options.transaction,
+            modelOptions,
+        },
     });
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);

package/dist/hooks/update.d.ts

@@ -1,4 +1,4 @@
-import type { ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions } from '../types';
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
  */
@@ -7,4 +7,4 @@ export declare const beforeBulkUpdate: (options: any) => void;
  * A hook to update the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export declare const beforeUpdate: (scopeAttributes: string[], modelOptions?: ModelOptions) => (instance: any, options: any) => Promise<void>;
+export declare const beforeUpdate: (scopeAttributes: string[], modelOptions?: ModelOptions, sadotOptions?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => (instance: any, options: any) => Promise<void>;

package/dist/hooks/update.js

@@ -1,35 +1,12 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.beforeUpdate = exports.beforeBulkUpdate = void 0;
 const logger_1 = __importDefault(require("../utils/logger"));
-const ValueRepo = __importStar(require("../repository/value"));
 const scopeAttributes_1 = __importDefault(require("../utils/scopeAttributes"));
+const updateInstanceValues_1 = __importDefault(require("./utils/updateInstanceValues"));
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
  */
@@ -43,7 +20,7 @@ exports.beforeBulkUpdate = beforeBulkUpdate;
  * A hook to update the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-const beforeUpdate = (scopeAttributes, modelOptions = {}) => async (instance, options) => {
+const beforeUpdate = (scopeAttributes, modelOptions = {}, sadotOptions = { useCustomFieldsEntries: false }) => async (instance, options) => {
     logger_1.default.debug('sadot - before update hook');
     const { fields } = options;
     const modelType = instance.constructor.name;
@@ -51,7 +28,17 @@ const beforeUpdate = (scopeAttributes, modelOptions = {}) => async (instance, op
     const customFieldsIdx = fields.indexOf('customFields');
     if (customFieldsIdx > -1) {
         const { customFields } = instance;
-        await ValueRepo.updateValues(modelType, instance.id, identifiers, customFields, { transaction: options.transaction, modelOptions });
+        await (0, updateInstanceValues_1.default)({
+            modelId: instance.id,
+            modelType,
+            identifiers,
+            customFields,
+            options: {
+                useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+                transaction: options.transaction,
+                modelOptions,
+            },
+        });
         // eslint-disable-next-line no-param-reassign
         fields.splice(customFieldsIdx, 1);
     }

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

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

package/dist/hooks/utils/updateInstanceValues.js

@@ -0,0 +1,50 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const ValueRepo = __importStar(require("../../repository/value"));
+const EntriesRepo = __importStar(require("../../repository/entries"));
+const updateInstanceValues = async ({ modelId, modelType, identifiers, customFields, options = {
+    modelOptions: {},
+    useCustomFieldsEntries: false,
+}, }) => {
+    await ValueRepo.updateValues(modelType, modelId, identifiers, customFields, {
+        ...options,
+        modelOptions: options.modelOptions ?? {},
+    });
+    /*
+    T.Y TODO - Once we're ready to switch from custom_field_values to custom_field_entries, we should remove the ValueRepo.updateValues call.
+    Currently, We're updating both tables to keep the data in sync, but not all microservices are using the new table yet.
+    */
+    if (!options?.useCustomFieldsEntries) {
+        return;
+    }
+    const { dataValues: { customFields: oldCustomFields } } = await EntriesRepo.findEntriesByModelId(modelId) ?? { dataValues: {} };
+    const newCustomFields = { ...oldCustomFields, ...customFields };
+    await EntriesRepo.updateEntries(modelId, modelType, newCustomFields, identifiers, {
+        ...options,
+        modelOptions: options.modelOptions ?? {},
+    });
+};
+exports.default = updateInstanceValues;

package/dist/index.js

@@ -40,7 +40,7 @@ const useCustomFields = async (app, getModel, options) => {
         await (0, models_1.initTestModels)(sequelize);
     }
     // The order is important
-    (0, init_1.addHooks)(models, getModel);
+    (0, init_1.addHooks)(models, getModel, { useCustomFieldsEntries });
     await (0, models_1.initTables)(sequelize, options.getUser, { useCustomFieldsEntries });
     (0, init_1.addScopes)(models, getModel);
     (0, init_1.applyCustomAssociation)(models);

package/dist/repository/definition.js

@@ -104,7 +104,12 @@ const getCustomFieldDefinitionsDictionary = async (instances, options = { withDi
             customFields.add(fieldName);
         });
     });
-    const definitions = await (0, exports.findByEntityIds)(modelType, Array.from(entityIds), { ...options });
+    const where = {
+        modelType,
+        entityId: { [sequelize_1.Op.in]: Array.from(entityIds) },
+        name: { [sequelize_1.Op.in]: Array.from(customFields) },
+    };
+    const definitions = await (0, exports.findAll)(where, { ...options });
     const matchedDefinitions = definitions.filter((def) => customFields.has(def.name));
     const matchedDefinitionsByName = Object.fromEntries(matchedDefinitions.map((definition) => [definition.name, definition]));
     if (!definitions?.length || matchedDefinitions.length !== customFields.size) {

package/dist/repository/entries.d.ts

@@ -0,0 +1,13 @@
+import type { FindOptions, Includeable, Transaction } from 'sequelize';
+import { CustomFieldEntries } from '../models';
+import type { ModelOptions } from '../types';
+type CustomFieldEntriesModelOptions = ModelOptions & {
+    include?: Includeable;
+    transaction?: Transaction;
+};
+export declare const findEntriesByModelId: (modelId: string) => Promise<CustomFieldEntries>;
+export declare const findEntriesByModelIds: (modelIds: string[], options?: CustomFieldEntriesModelOptions) => Promise<CustomFieldEntries[]>;
+export declare const updateEntries: (modelId: string, modelType: string, customFields: Record<string, any>, identifiers: string[], options?: FindOptions & {
+    modelOptions?: ModelOptions;
+}) => Promise<[CustomFieldEntries, boolean]>;
+export {};

package/dist/repository/entries.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateEntries = exports.findEntriesByModelIds = exports.findEntriesByModelId = void 0;
+const models_1 = require("../models");
+const logger_1 = __importDefault(require("../utils/logger"));
+const errors_1 = require("../errors");
+const DefinitionRepo = __importStar(require("./definition"));
+const findEntriesByModelId = async (modelId) => models_1.CustomFieldEntries.findOne({ where: { modelId } });
+exports.findEntriesByModelId = findEntriesByModelId;
+const findEntriesByModelIds = async (modelIds, options = {}) => {
+    const { transaction } = options;
+    return models_1.CustomFieldEntries.findAll({
+        where: { modelId: modelIds },
+        transaction,
+    });
+};
+exports.findEntriesByModelIds = findEntriesByModelIds;
+const updateEntries = async (modelId, modelType, customFields, identifiers, options = {}) => {
+    const customFieldsNames = Object.keys(customFields);
+    logger_1.default.debug(`custom-fields: updating entries for ${modelType} ${modelId}`, {
+        customFieldsNames,
+        optionsKeys: options ? Object.keys(options) : null,
+        customFields,
+        identifiers,
+    });
+    const { modelOptions, transaction } = options;
+    const where = {
+        modelType,
+        name: customFieldsNames,
+        ...(!options.modelOptions?.useEntityIdFromInclude && { 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 !== customFieldsNames.length) {
+        logger_1.default.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names: customFieldsNames, fieldDefinitions });
+        const missingDefinitions = customFieldsNames.filter((name) => !fieldDefinitions.some((def) => def.name === name));
+        throw new errors_1.MissingDefinitionError(missingDefinitions);
+    }
+    const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+    const valuesWithDisabledDefinitions = customFieldsNames.filter((name) => disabledNames.includes(name));
+    if (valuesWithDisabledDefinitions?.length > 0) {
+        logger_1.default.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
+    }
+    return models_1.CustomFieldEntries.upsert({
+        modelId,
+        entityId: fieldDefinitions[0].entityId,
+        modelType,
+        customFields,
+    }, options);
+};
+exports.updateEntries = updateEntries;

package/dist/tests/helpers/commonHooks.d.ts

@@ -1,3 +1,5 @@
 import type { Application } from 'express';
 import type { Models } from '../../types';
-export declare function commonTestHooks(app?: Application | null, models?: Models[]): void;
+export declare function commonTestHooks(app?: Application | null, models?: Models[], options?: {
+    useCustomFieldsEntries: boolean;
+}): void;

package/dist/tests/helpers/commonHooks.js

@@ -31,7 +31,7 @@ const __1 = __importDefault(require("../.."));
 const _1 = require(".");
 const database_config_1 = __importDefault(require("./database-config"));
 const db_1 = __importStar(require("../../utils/db"));
-function commonTestHooks(app = null, models = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }]) {
+function commonTestHooks(app = null, models = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }], options = { useCustomFieldsEntries: false }) {
     let sequelize;
     beforeAll(async () => {
         sequelize = (0, db_1.default)(database_config_1.default);
@@ -41,11 +41,12 @@ function commonTestHooks(app = null, models = [{ name: 'TestModel', scopeAttribu
             databaseConfig: database_config_1.default,
             getUser: () => undefined,
             sequelize,
+            useCustomFieldsEntries: options.useCustomFieldsEntries,
         });
     });
     afterEach(async () => {
         jest.clearAllMocks();
-        await (0, _1.cleanup)();
+        await (0, _1.cleanup)({ useCustomFieldsEntries: options.useCustomFieldsEntries });
     });
     afterAll(async () => {
         await sequelize.close();

package/dist/tests/helpers/index.d.ts

@@ -1,4 +1,5 @@
-export declare const cleanup: () => Promise<void>;
+import type { CustomFieldOptions } from '../../types';
+export declare const cleanup: (options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>) => Promise<void>;
 export declare const getModel: (name: string) => any;
 export declare const getReplacementMapWithScopeValue: (conditions: Record<string, any>) => {
     replacementsMap: Record<string, string>;

package/dist/tests/helpers/index.js

@@ -4,12 +4,15 @@ exports.getReplacementMapWithScopeValue = exports.getModel = exports.cleanup = v
 const formatter_1 = require("@autofleet/sheilta/lib/formatter");
 const models_1 = require("../../models");
 // eslint-disable-next-line import/prefer-default-export
-const cleanup = async () => {
+const cleanup = async (options) => {
     if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
         await models_1.CustomFieldDefinition.unscoped().destroy({ where: {} });
         await models_1.TestModel.destroy({ where: {} });
         await models_1.ContextAwareTestModel.destroy({ where: {} });
         await models_1.ContextTestModel.destroy({ where: {} });
+        if (options?.useCustomFieldsEntries) {
+            await models_1.CustomFieldEntries.unscoped().destroy({ where: {} });
+        }
     }
 };
 exports.cleanup = cleanup;

package/dist/utils/init.d.ts

@@ -1,5 +1,7 @@
 import type { ModelFetcher, Models } from '../types';
-export declare const addHooks: (models: Models[], getModel: ModelFetcher) => void;
+export declare const addHooks: (models: Models[], getModel: ModelFetcher, sadotOptions?: {
+    useCustomFieldsEntries: boolean;
+}) => 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

@@ -13,7 +13,7 @@ const scopes_1 = require("../scopes");
 const logger_1 = __importDefault(require("./logger"));
 const filter_1 = require("../scopes/filter");
 const { CUSTOM_FIELDS_FILTER_SCOPE } = common_types_1.customFields;
-const addHooks = (models, getModel) => {
+const addHooks = (models, getModel, sadotOptions = { useCustomFieldsEntries: false }) => {
     models.forEach(async ({ name, scopeAttributes, modelOptions, }) => {
         try {
             const model = getModel(name);
@@ -33,8 +33,8 @@ const addHooks = (models, getModel) => {
             model.addHook('beforeFind', 'sadot-beforeFind', (0, hooks_1.beforeFind)(scopeAttributes));
             model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', hooks_1.beforeBulkCreate);
             model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', hooks_1.beforeBulkUpdate);
-            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes, modelOptions));
-            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes, modelOptions));
+            model.addHook('beforeCreate', 'sadot-beforeCreate', (0, hooks_1.beforeCreate)(scopeAttributes, modelOptions, sadotOptions));
+            model.addHook('beforeUpdate', 'sadot-beforeUpdate', (0, hooks_1.beforeUpdate)(scopeAttributes, modelOptions, sadotOptions));
             model.addHook('afterFind', 'sadot-afterFind', (0, hooks_1.enrichResults)(name, scopeAttributes, 'afterFind', modelOptions));
             model.addHook('afterUpdate', 'sadot-afterUpdate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));
             model.addHook('afterCreate', 'sadot-afterCreate', (0, hooks_1.enrichResults)(name, scopeAttributes, null, modelOptions));

package/dist/utils/validations/index.js

@@ -19,6 +19,9 @@ exports.validateValue = validateValue;
 const validateInstanceCustomFieldEntries = (instance, definitionsByName) => {
     const validationErrors = Object.entries(instance.customFields)
         .map(([customFieldName, value]) => {
+        // Allow NULL values, just like we do in custom_field_values.
+        if (value === null)
+            return null;
         const { validation, fieldType } = definitionsByName[customFieldName];
         const result = (0, exports.validateValue)(value, fieldType, validation);
         if (result?.error) {

package/package.json

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

package/src/errors/index.ts

@@ -55,7 +55,9 @@ export class InvalidEntriesError extends BadRequest {
   constructor(modelId: string, validationErrors: EntriesValidationError[]) {
     const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
     super(errors, null, null);
-    this.message = `Invalid entries on ${modelId}`;
+    this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (
+      `${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`
+    )).join('\n')}`;
   }
 }
 

package/src/hooks/create.ts

@@ -1,10 +1,10 @@
 import type { WhereOptions } from 'sequelize';
 import logger from '../utils/logger';
-import * as ValueRepo from '../repository/value';
 import * as DefinitionRepo from '../repository/definition';
 import { MissingRequiredCustomFieldError } from '../errors';
-import type { ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
+import updateInstanceValues from './utils/updateInstanceValues';
 
 /**
  * A hook to create the custom fields when updating a model (more then one instance).
@@ -18,7 +18,11 @@ export const beforeBulkCreate = (options): void => {
  * A hook to create the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export const beforeCreate = (scopeAttributes: string[], modelOptions: ModelOptions = {}) => async (
+export const beforeCreate = (
+  scopeAttributes: string[],
+  modelOptions: ModelOptions = {},
+  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
+) => async (
   instance,
   options,
 ): Promise<void> => {
@@ -61,16 +65,17 @@ export const beforeCreate = (scopeAttributes: string[], modelOptions: ModelOptio
     throw new MissingRequiredCustomFieldError(missingFields);
   }
 
-  await ValueRepo.updateValues(
+  await updateInstanceValues({
+    modelId: instance.id,
     modelType,
-    instance.id,
     identifiers,
     customFields,
-    {
+    options: {
+      useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
       transaction: options.transaction,
       modelOptions,
     },
-  );
+  });
 
   // eslint-disable-next-line no-param-reassign
   fields.splice(customFieldsIdx, 1);

package/src/hooks/update.ts

@@ -1,7 +1,7 @@
 import logger from '../utils/logger';
-import * as ValueRepo from '../repository/value';
-import type { ModelOptions } from '../types';
+import type { CustomFieldOptions, ModelOptions } from '../types';
 import applyScopeToInstance from '../utils/scopeAttributes';
+import updateInstanceValues from './utils/updateInstanceValues';
 
 /**
  * A hook to update the custom fields when updating a model (more then one instance).
@@ -16,7 +16,11 @@ export const beforeBulkUpdate = (options): void => {
  * A hook to update the custom fields when updating a model instance.
  * TODO - cleanup if update fail
  */
-export const beforeUpdate = (scopeAttributes: string[], modelOptions: ModelOptions = {}) => async (
+export const beforeUpdate = (
+  scopeAttributes: string[],
+  modelOptions: ModelOptions = {},
+  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
+) => async (
   instance,
   options,
 ): Promise<void> => {
@@ -28,14 +32,19 @@ export const beforeUpdate = (scopeAttributes: string[], modelOptions: ModelOptio
   const customFieldsIdx = fields.indexOf('customFields');
   if (customFieldsIdx > -1) {
     const { customFields } = instance;
-    await ValueRepo.updateValues(
+
+    await updateInstanceValues({
+      modelId: instance.id,
       modelType,
-      instance.id,
       identifiers,
       customFields,
-      { transaction: options.transaction, modelOptions },
+      options: {
+        useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
+        transaction: options.transaction,
+        modelOptions,
+      },
+    });
 
-    );
     // eslint-disable-next-line no-param-reassign
     fields.splice(customFieldsIdx, 1);
   }

package/src/hooks/utils/updateInstanceValues.ts

@@ -0,0 +1,63 @@
+import type { Transaction } from 'sequelize';
+import * as ValueRepo from '../../repository/value';
+import * as EntriesRepo from '../../repository/entries';
+import type { ModelOptions } from '../../types';
+
+interface UpdateInstanceValuesParams {
+  modelId: string;
+  modelType: string;
+  identifiers: string[];
+  customFields: Record<string, any>;
+  options?: {
+    transaction?: Transaction;
+    modelOptions?: ModelOptions;
+    useCustomFieldsEntries?: boolean;
+  };
+}
+
+const updateInstanceValues = async ({
+  modelId,
+  modelType,
+  identifiers,
+  customFields,
+  options = {
+    modelOptions: {},
+    useCustomFieldsEntries: false,
+  },
+}: UpdateInstanceValuesParams): Promise<void> => {
+  await ValueRepo.updateValues(
+    modelType,
+    modelId,
+    identifiers,
+    customFields,
+    {
+      ...options,
+      modelOptions: options.modelOptions ?? {},
+    },
+  );
+
+  /*
+  T.Y TODO - Once we're ready to switch from custom_field_values to custom_field_entries, we should remove the ValueRepo.updateValues call.
+  Currently, We're updating both tables to keep the data in sync, but not all microservices are using the new table yet.
+  */
+
+  if (!options?.useCustomFieldsEntries) {
+    return;
+  }
+
+  const { dataValues: { customFields: oldCustomFields } } = await EntriesRepo.findEntriesByModelId(modelId) ?? { dataValues: {} };
+  const newCustomFields = { ...oldCustomFields, ...customFields };
+
+  await EntriesRepo.updateEntries(
+    modelId,
+    modelType,
+    newCustomFields,
+    identifiers,
+    {
+      ...options,
+      modelOptions: options.modelOptions ?? {},
+    },
+  );
+};
+
+export default updateInstanceValues;

package/src/index.ts

@@ -35,7 +35,7 @@ const useCustomFields = async (
     await initTestModels(sequelize);
   }
   // The order is important
-  addHooks(models, getModel);
+  addHooks(models, getModel, { useCustomFieldsEntries });
   await initTables(sequelize, options.getUser, { useCustomFieldsEntries });
   addScopes(models, getModel);
   applyCustomAssociation(models);

package/src/repository/definition.ts

@@ -155,7 +155,13 @@ export const getCustomFieldDefinitionsDictionary = async (
     });
   });
 
-  const definitions = await findByEntityIds(modelType, Array.from(entityIds), { ...options });
+  const where: WhereOptions = {
+    modelType,
+    entityId: { [Op.in]: Array.from(entityIds) },
+    name: { [Op.in]: Array.from(customFields) },
+  };
+
+  const definitions = await findAll(where, { ...options });
 
   const matchedDefinitions = definitions.filter((def) => customFields.has(def.name));
   const matchedDefinitionsByName = Object.fromEntries(matchedDefinitions.map((definition) => [definition.name, definition]));

package/src/repository/entries.ts

@@ -0,0 +1,71 @@
+import type {
+  FindOptions,
+  Includeable,
+  Transaction,
+  WhereOptions,
+} from 'sequelize';
+import { CustomFieldEntries } from '../models';
+import type { ModelOptions } from '../types';
+import logger from '../utils/logger';
+import { MissingDefinitionError } from '../errors';
+import * as DefinitionRepo from './definition';
+
+type CustomFieldEntriesModelOptions = ModelOptions & { include?: Includeable, transaction?: Transaction };
+
+export const findEntriesByModelId = async (modelId: string) => CustomFieldEntries.findOne({ where: { modelId } });
+
+export const findEntriesByModelIds = async (modelIds: string[], options: CustomFieldEntriesModelOptions = {}) => {
+  const { transaction } = options;
+  return CustomFieldEntries.findAll({
+    where: { modelId: modelIds },
+    transaction,
+  });
+};
+
+export const updateEntries = async (
+  modelId: string,
+  modelType: string,
+  customFields: Record<string, any>,
+  identifiers: string[],
+  options: FindOptions & { modelOptions?: ModelOptions } = {},
+) => {
+  const customFieldsNames = Object.keys(customFields);
+  logger.debug(`custom-fields: updating entries for ${modelType} ${modelId}`, {
+    customFieldsNames,
+    optionsKeys: options ? Object.keys(options) : null,
+    customFields,
+    identifiers,
+  });
+  const { modelOptions, transaction } = options;
+
+  const where: WhereOptions = {
+    modelType,
+    name: customFieldsNames,
+    ...(!options.modelOptions?.useEntityIdFromInclude && { 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 !== customFieldsNames.length) {
+    logger.warn(`custom-fields: missing definitions for ${modelType} ${modelId}`, { names: customFieldsNames, fieldDefinitions });
+    const missingDefinitions = customFieldsNames.filter((name) => !fieldDefinitions.some((def) => def.name === name));
+    throw new MissingDefinitionError(missingDefinitions);
+  }
+
+  const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
+  const valuesWithDisabledDefinitions = customFieldsNames.filter((name) => disabledNames.includes(name));
+  if (valuesWithDisabledDefinitions?.length > 0) {
+    logger.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
+  }
+
+  return CustomFieldEntries.upsert(
+    {
+      modelId,
+      entityId: fieldDefinitions[0].entityId,
+      modelType,
+      customFields,
+    },
+    options,
+  );
+};

package/src/tests/helpers/commonHooks.ts

@@ -6,7 +6,11 @@ import databaseConfig from './database-config';
 import initDB, { createSequelizeMeta } from '../../utils/db';
 import type { Models } from '../../types';
 
-export function commonTestHooks(app: Application | null = null, models: Models[] = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }]) {
+export function commonTestHooks(
+  app: Application | null = null,
+  models: Models[] = [{ name: 'TestModel', scopeAttributes: ['fleetId'] }],
+  options: { useCustomFieldsEntries: boolean } = { useCustomFieldsEntries: false },
+) {
   let sequelize: Sequelize;
 
   beforeAll(async () => {
@@ -17,12 +21,13 @@ export function commonTestHooks(app: Application | null = null, models: Models[]
       databaseConfig,
       getUser: () => undefined,
       sequelize,
+      useCustomFieldsEntries: options.useCustomFieldsEntries,
     });
   });
 
   afterEach(async () => {
     jest.clearAllMocks();
-    await cleanup();
+    await cleanup({ useCustomFieldsEntries: options.useCustomFieldsEntries });
   });
 
   afterAll(async () => {

package/src/tests/helpers/index.ts

@@ -1,15 +1,20 @@
 import { generateFilterReplacements } from '@autofleet/sheilta/lib/formatter';
 import {
-  ContextAwareTestModel, ContextTestModel, CustomFieldDefinition, TestModel,
+  ContextAwareTestModel, ContextTestModel, CustomFieldDefinition, CustomFieldEntries, TestModel,
 } from '../../models';
+import type { CustomFieldOptions } from '../../types';
 
 // eslint-disable-next-line import/prefer-default-export
-export const cleanup = async (): Promise<void> => {
+export const cleanup = async (options?: Pick<CustomFieldOptions, 'useCustomFieldsEntries'>): Promise<void> => {
   if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
     await CustomFieldDefinition.unscoped().destroy({ where: {} });
     await TestModel.destroy({ where: {} });
     await ContextAwareTestModel.destroy({ where: {} });
     await ContextTestModel.destroy({ where: {} });
+
+    if (options?.useCustomFieldsEntries) {
+      await CustomFieldEntries.unscoped().destroy({ where: {} });
+    }
   }
 };
 

package/src/utils/init.ts

@@ -21,7 +21,11 @@ import { customFieldsSortScope } from '../scopes/filter';
 
 const { CUSTOM_FIELDS_FILTER_SCOPE } = customFields;
 
-export const addHooks = (models: Models[], getModel: ModelFetcher): void => {
+export const addHooks = (
+  models: Models[],
+  getModel: ModelFetcher,
+  sadotOptions: { useCustomFieldsEntries: boolean } = { useCustomFieldsEntries: false },
+): void => {
   models.forEach(async ({
     name, scopeAttributes, modelOptions,
   }) => {
@@ -43,8 +47,8 @@ export const addHooks = (models: Models[], getModel: ModelFetcher): void => {
       model.addHook('beforeFind', 'sadot-beforeFind', beforeFind(scopeAttributes));
       model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', beforeBulkCreate);
       model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', beforeBulkUpdate);
-      model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes, modelOptions));
-      model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes, modelOptions));
+      model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes, modelOptions, sadotOptions));
+      model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes, modelOptions, sadotOptions));
       model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes, 'afterFind', modelOptions));
       model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes, null, modelOptions));
       model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes, null, modelOptions));

package/src/utils/validations/index.ts

@@ -24,6 +24,9 @@ export const validateValue = (
 export const validateInstanceCustomFieldEntries = (instance: CustomFieldEntriesDTO, definitionsByName: { [defName: string]: CustomFieldDefinition; }) => {
   const validationErrors = Object.entries(instance.customFields)
     .map(([customFieldName, value]) => {
+      // Allow NULL values, just like we do in custom_field_values.
+      if (value === null) return null;
+
       const { validation, fieldType } = definitionsByName[customFieldName];
       const result = validateValue(value, fieldType, validation);
       if (result?.error) {