@autofleet/sadot 0.9.1-beta-8053a0cc.1 → 0.10.0

package/dist/api/v1/definition/index.js

@@ -51,7 +51,7 @@ router.post('/', async (req, res) => {
     }
     catch (err) {
         logger_1.default.error('Failed to create custom field definition', err);
-        return (0, errors_2.default)(err, res, { message: `Error in create ${ENTITY} request` });
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in create ${ENTITY} request` });
     }
 });
 /**
@@ -68,7 +68,7 @@ router.get('/:customFieldDefinitionId', async (req, res) => {
     }
     catch (err) {
         logger_1.default.error('Failed to fetch custom field definition', err);
-        return (0, errors_2.default)(err, res, { message: `Error in get ${ENTITY} request` });
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get ${ENTITY} request` });
     }
 });
 /**
@@ -87,7 +87,7 @@ router.get('/', async (req, res) => {
     }
     catch (err) {
         logger_1.default.error('Failed to fetch custom field definitions', err);
-        return (0, errors_2.default)(err, res, { message: `Error in get all ${ENTITY} request` });
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in get all ${ENTITY} request` });
     }
 });
 /**
@@ -110,7 +110,7 @@ router.patch('/:customFieldDefinitionId', async (req, res) => {
     }
     catch (err) {
         logger_1.default.error('Failed to patch custom field definition', err);
-        return (0, errors_2.default)(err, res, { message: `Error in update ${ENTITY} request` });
+        return (0, errors_2.default)(err, res, { logger: logger_1.default, message: `Error in update ${ENTITY} request` });
     }
 });
 exports.default = router;

package/dist/api/v1/definition/validations.js

@@ -4,6 +4,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.validateCustomFieldDefinitionUpdate = exports.validateCustomFieldDefinitionCreation = void 0;
+/* eslint-disable newline-per-chained-call */
 const joi_1 = __importDefault(require("joi"));
 const constants_1 = require("../../../utils/constants");
 const FileValidationSchema = joi_1.default.object({
@@ -16,7 +17,6 @@ const statusValidationObject = joi_1.default.object({
     value: joi_1.default.string().required(),
     color: joi_1.default.string().required(),
 });
-const statusValidationObjectSchema = joi_1.default.array().items(statusValidationObject).min(1).unique('value');
 /**
  * Schema for the validation of custom field definition
  * The only custom validation is for
@@ -28,12 +28,12 @@ const statusValidationObjectSchema = joi_1.default.array().items(statusValidatio
  */
 const ValidationSchema = joi_1.default.when('fieldType', {
     is: constants_1.CustomFieldDefinitionType.SELECT,
-    then: joi_1.default.array().items(joi_1.default.string()).min(1).unique(),
-    otherwise: joi_1.default.any(),
-}).when('fieldType', {
-    is: constants_1.CustomFieldDefinitionType.STATUS,
-    then: statusValidationObjectSchema,
-    otherwise: joi_1.default.any(),
+    then: joi_1.default.array().required().items(joi_1.default.string()).min(1).unique(),
+    otherwise: joi_1.default.when('fieldType', {
+        is: constants_1.CustomFieldDefinitionType.STATUS,
+        then: joi_1.default.array().required().items(statusValidationObject).min(1).unique('value'),
+        otherwise: joi_1.default.forbidden(),
+    }),
 });
 const DefaultValueSchema = joi_1.default.when('fieldType', {
     switch: [
@@ -60,7 +60,7 @@ const CustomFieldDefinitionCreationSchema = joi_1.default.object({
     required: joi_1.default.boolean(),
     disabled: joi_1.default.boolean(),
     blockEditingFromUI: joi_1.default.boolean(),
-});
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
 const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
     displayName: joi_1.default.string(),
     validation: ValidationSchema,
@@ -70,7 +70,7 @@ const CustomFieldDefinitionUpdateSchema = joi_1.default.object({
     required: joi_1.default.boolean(),
     disabled: joi_1.default.boolean(),
     blockEditingFromUI: joi_1.default.boolean(),
-});
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
 const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
 exports.validateCustomFieldDefinitionCreation = validateCustomFieldDefinitionCreation;
 const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });

package/dist/api/v1/errors.d.ts

@@ -1,2 +1,4 @@
-declare const _default: (err: any, res: any, additionalData?: any) => Promise<any>;
+import type { Response } from 'express';
+import { type LogPayload } from '@autofleet/errors';
+declare const _default: (err: any, res: Response, additionalData?: LogPayload) => Promise<any>;
 export default _default;

package/dist/api/v1/errors.js

@@ -5,10 +5,7 @@ const joi_1 = require("joi");
 const sequelize_1 = require("sequelize");
 exports.default = (err, res, additionalData = undefined) => {
     let error = err;
-    if (err instanceof joi_1.ValidationError) {
-        error = new errors_1.BadRequest([err], null);
-    }
-    if (err instanceof sequelize_1.ValidationError) {
+    if ([joi_1.ValidationError, sequelize_1.ValidationError].some((ErrClass) => err instanceof ErrClass)) {
         error = new errors_1.BadRequest([err], null);
     }
     return (0, errors_1.handleError)(error, res, additionalData);

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/events/index.js

@@ -27,6 +27,10 @@ const modelTableMapping = {
         tableName: 'dim_custom_field_value',
         eventVersion: '1',
     },
+    CustomFieldEntries: {
+        tableName: 'dim_custom_field_entries',
+        eventVersion: '1',
+    },
 };
 const sendDimEvent = (instance) => {
     const mapping = modelTableMapping[instance.constructor.name];

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/models/CustomFieldEntries.d.ts

@@ -1,11 +1,11 @@
 import { Model } from 'sequelize-typescript';
 declare class CustomFieldEntries extends Model {
-    /** The ID of the entity of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / etc.  */
+    /** The ID of the model of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / etc.  */
     modelId: string;
+    /** The ID of the entity of which this row hold the custom field entries of, e.g. fleetId / etc.  */
+    entityId: string;
     /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
-    customFields: {
-        [customFieldName: string]: any;
-    };
+    customFields: Record<string, any>;
     /** The type of model which this custom field entry represents. e.g. Vehicle / StopPoint / etc. */
     modelType: string;
     createdAt?: Date;

package/dist/models/CustomFieldEntries.js

@@ -31,15 +31,11 @@ var __importStar = (this && this.__importStar) || function (mod) {
 var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const sequelize_typescript_1 = require("sequelize-typescript");
 const events_1 = require("../events");
 const CustomFieldDefinitionRepo = __importStar(require("../repository/definition"));
 const validations_1 = require("../utils/validations");
-const logger_1 = __importDefault(require("../utils/logger"));
 let CustomFieldEntries = class CustomFieldEntries extends sequelize_typescript_1.Model {
     static afterSaveHandler(instance, options) {
         if (options.transaction) {
@@ -56,10 +52,19 @@ __decorate([
         type: sequelize_typescript_1.DataType.UUID,
         allowNull: false,
     })
-    /** The ID of the entity of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / etc.  */
+    /** The ID of the model of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / etc.  */
     ,
     __metadata("design:type", String)
 ], CustomFieldEntries.prototype, "modelId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.UUID,
+        allowNull: false,
+    })
+    /** The ID of the entity of which this row hold the custom field entries of, e.g. fleetId / etc.  */
+    ,
+    __metadata("design:type", String)
+], CustomFieldEntries.prototype, "entityId", void 0);
 __decorate([
     (0, sequelize_typescript_1.Column)({
         type: sequelize_typescript_1.DataType.JSONB,
@@ -88,11 +93,6 @@ __decorate([
     __metadata("design:type", Date)
 ], CustomFieldEntries.prototype, "updatedAt", void 0);
 __decorate([
-    sequelize_typescript_1.BeforeBulkCreate,
-    sequelize_typescript_1.BeforeBulkUpdate,
-    sequelize_typescript_1.BeforeUpdate,
-    sequelize_typescript_1.BeforeCreate,
-    sequelize_typescript_1.BeforeUpsert,
     sequelize_typescript_1.AfterUpsert,
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [CustomFieldEntries, Object]),
@@ -110,17 +110,12 @@ CustomFieldEntries = __decorate([
             },
         ],
         validate: {
-            validationByType() {
-                if (Object.keys(this.customFields ?? {}).length) {
-                    CustomFieldDefinitionRepo.getCustomFieldDefinitionsDictionary([this])
-                        .then((definitionsByName) => {
-                        (0, validations_1.validateInstanceCustomFieldEntries)(this, definitionsByName);
-                    })
-                        .catch((error) => {
-                        logger_1.default.error('Validation error on custom_field_entries', error);
-                        throw error;
-                    });
+            async validationByType() {
+                if (!Object.keys(this.customFields ?? {}).length) {
+                    return;
                 }
+                const definitionsByName = await CustomFieldDefinitionRepo.getCustomFieldDefinitionsDictionary([this]);
+                (0, validations_1.validateInstanceCustomFieldEntries)(this, definitionsByName);
             },
         },
     })

package/dist/models/index.d.ts

@@ -6,8 +6,12 @@ import ContextAwareTestModel from './tests/contextAwareModels/ContextAwareTestMo
 import ContextTestModel from './tests/contextAwareModels/ContextTestModel';
 import AssociatedTestModel from './tests/AssociatedTestModel';
 import type { CustomFieldOptions } from '../types';
-declare const initTables: (sequelize: Sequelize, getUser: CustomFieldOptions['getUser'], options: {
-    useCustomFieldsEntries: boolean;
-}) => Promise<void>;
+import CustomFieldEntries from './CustomFieldEntries';
+interface InitTablesOptions {
+    schemaPrefix?: string;
+    schemaVersion?: string;
+    useCustomFieldsEntries?: boolean;
+}
+declare const initTables: (sequelize: Sequelize, getUser: CustomFieldOptions['getUser'], { schemaPrefix, schemaVersion, useCustomFieldsEntries, }?: InitTablesOptions) => Promise<void>;
 declare const initTestModels: (sequelize: Sequelize) => Promise<void>;
-export { CustomFieldValue, CustomFieldDefinition, TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel, initTables, initTestModels, };
+export { CustomFieldValue, CustomFieldDefinition, CustomFieldEntries, TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel, initTables, initTestModels, };

package/dist/models/index.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.initTestModels = exports.initTables = exports.ContextTestModel = exports.ContextAwareTestModel = exports.AssociatedTestModel = exports.TestModel = exports.CustomFieldDefinition = exports.CustomFieldValue = void 0;
+exports.initTestModels = exports.initTables = exports.ContextTestModel = exports.ContextAwareTestModel = exports.AssociatedTestModel = exports.TestModel = exports.CustomFieldEntries = exports.CustomFieldDefinition = exports.CustomFieldValue = void 0;
 /* eslint-disable no-param-reassign */
 const sequelize_1 = require("sequelize");
 const logger_1 = __importDefault(require("../utils/logger"));
@@ -20,21 +20,23 @@ exports.ContextTestModel = ContextTestModel_1.default;
 const AssociatedTestModel_1 = __importDefault(require("./tests/AssociatedTestModel"));
 exports.AssociatedTestModel = AssociatedTestModel_1.default;
 const CustomFieldEntries_1 = __importDefault(require("./CustomFieldEntries"));
+exports.CustomFieldEntries = CustomFieldEntries_1.default;
 const productionModels = [CustomFieldDefinition_1.default, CustomFieldValue_1.default];
 const testModels = [TestModel_1.default, AssociatedTestModel_1.default, ContextAwareTestModel_1.default, ContextTestModel_1.default];
 const SADOT_MIGRATION_PREFIX = 'sadot-migration';
 const SCHEMA_VERSION = 'fb0fa867-1241-4816-b08d-5ed9060c7ae5';
-const CUSTOM_FIELDS_SCHEMA_VERSION = `${SADOT_MIGRATION_PREFIX}_${SCHEMA_VERSION}`;
-const CUSTOM_FIELDS_SCHEMA_VERSION_WITH_ENTRIES = `${CUSTOM_FIELDS_SCHEMA_VERSION}_withEntries`;
-const initTables = async (sequelize, getUser, options) => {
-    const { useCustomFieldsEntries } = options;
+const initTables = async (sequelize, getUser, { schemaPrefix, schemaVersion, useCustomFieldsEntries, } = {
+    schemaPrefix: SADOT_MIGRATION_PREFIX,
+    schemaVersion: SCHEMA_VERSION,
+    useCustomFieldsEntries: false,
+}) => {
+    const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? '_withEntries' : ''}`;
     logger_1.default.info('custom-fields: initialize custom-fields tables');
     // Detect models and import them to the orm
     // eslint-disable-next-line @typescript-eslint/explicit-function-return-type
     if (!sequelize.addModels) {
         throw new Error('sequelize instance must have addModels function');
     }
-    const schemaVersion = useCustomFieldsEntries ? CUSTOM_FIELDS_SCHEMA_VERSION_WITH_ENTRIES : CUSTOM_FIELDS_SCHEMA_VERSION;
     if (useCustomFieldsEntries) {
         productionModels.push(CustomFieldEntries_1.default);
     }
@@ -68,17 +70,26 @@ const initTables = async (sequelize, getUser, options) => {
         timestamps: false,
         schema: 'public',
     });
-    const migrations = await SequelizeMeta.findAll({ raw: true });
-    const currentSadotSchemaVersion = migrations.reverse().find((m) => m.name.includes(SADOT_MIGRATION_PREFIX));
-    if (!currentSadotSchemaVersion
-        || currentSadotSchemaVersion.name !== schemaVersion) {
+    const migrations = await SequelizeMeta.findAll({ where: { name: { [sequelize_1.Op.like]: `${schemaPrefix}%` } }, raw: true });
+    const currentSadotSchemaVersion = migrations.at(-1);
+    const expectedSchemaVersionIndex = migrations.findIndex((m) => m.name === CUSTOM_FIELDS_SCHEMA_VERSION);
+    if (!currentSadotSchemaVersion || currentSadotSchemaVersion.name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
         await CustomFieldDefinition_1.default.sync({ alter: true });
         await CustomFieldValue_1.default.sync({ alter: true });
+        // T.Y TODO: Remove the if statement once we're ready to add the new entries table for all MS
         if (useCustomFieldsEntries) {
             await CustomFieldEntries_1.default.sync({ alter: true });
         }
-        await SequelizeMeta.create({ name: schemaVersion });
+        if (expectedSchemaVersionIndex === -1) {
+            await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
+        }
         logger_1.default.info('custom-fields: models synced');
+        if (migrations.length && expectedSchemaVersionIndex !== -1 && expectedSchemaVersionIndex < migrations.length - 1) {
+            // We have existing migrations, and we are calling `sync`.
+            // This means we are in a `down` migration, and hence we should delete newer migrations to ensure we can reapply them.
+            const migrationsToDelete = migrations.slice(expectedSchemaVersionIndex + 1);
+            await SequelizeMeta.destroy({ where: { name: { [sequelize_1.Op.in]: migrationsToDelete.map((m) => m.name) } } });
+        }
     }
 };
 exports.initTables = initTables;

package/dist/repository/definition.d.ts

@@ -1,8 +1,7 @@
 import { type Includeable, type Transaction, type FindOptions, type WhereOptions } from 'sequelize';
-import { CustomFieldDefinition } from '../models';
+import { CustomFieldDefinition, type CustomFieldEntries } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
 import type { ModelOptions } from '../types';
-import type { CustomFieldEntriesDTO } from '../types/entries';
 export declare const create: (data: CreateCustomFieldDefinition) => Promise<CustomFieldDefinition>;
 interface SadotFindOptions {
     withDisabled?: boolean;
@@ -28,10 +27,10 @@ export declare const destroy: (id: string) => Promise<number>;
  */
 export declare const getRequiredFields: (modelType: string, modelId: string | string[], entityId: string | string[], modelOptions?: ModelOptions) => Promise<string[]>;
 /**
- * @returns A dictionary of custom field definitions by name.
- * @throws A MissingDefinitionError if any of the custom fields doesn't have a definition.
+ * @returns A promise resolving with a dictionary of custom field definitions by name.
+ * @throws A {@link MissingDefinitionError} if any of the custom fields doesn't have a definition.
  */
-export declare const getCustomFieldDefinitionsDictionary: (instances: CustomFieldEntriesDTO[], options?: SadotGetDefinitionsByEntityIdsOptions) => Promise<{
+export declare const getCustomFieldDefinitionsDictionary: (instances: CustomFieldEntries[], options?: SadotGetDefinitionsByEntityIdsOptions) => Promise<{
     [definitionName: string]: CustomFieldDefinition;
 }>;
 export {};

package/dist/repository/definition.js

@@ -88,30 +88,28 @@ const getRequiredFields = async (modelType, modelId, entityId, modelOptions = {}
 };
 exports.getRequiredFields = getRequiredFields;
 /**
- * @returns A dictionary of custom field definitions by name.
- * @throws A MissingDefinitionError if any of the custom fields doesn't have a definition.
+ * @returns A promise resolving with a dictionary of custom field definitions by name.
+ * @throws A {@link MissingDefinitionError} if any of the custom fields doesn't have a definition.
  */
 const getCustomFieldDefinitionsDictionary = async (instances, options = { withDisabled: false, modelOptions: {} }) => {
-    const { modelType } = instances[0];
+    const { modelType } = instances[0]?.dataValues ?? {};
     const customFields = new Set();
     const modelIds = [];
+    const entityIds = new Set();
     instances.forEach((instance) => {
-        modelIds.push(instance.modelId);
-        Object.keys(instance.customFields).forEach((fieldName) => {
+        const { dataValues: { modelId, entityId, customFields: instanceCustomFields } } = instance;
+        modelIds.push(modelId);
+        entityIds.add(entityId);
+        Object.keys(instanceCustomFields ?? {}).forEach((fieldName) => {
             customFields.add(fieldName);
         });
     });
-    const { include, useEntityIdFromInclude } = options.modelOptions;
     const where = {
         modelType,
-        ...(!useEntityIdFromInclude && { entityId: modelIds }),
+        entityId: { [sequelize_1.Op.in]: Array.from(entityIds) },
+        name: { [sequelize_1.Op.in]: Array.from(customFields) },
     };
-    const definitions = await (0, exports.findAll)({
-        where,
-        transaction: options.transaction,
-        include: include?.(modelIds),
-        raw: true,
-    }, options);
+    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 {};