@autofleet/sadot 0.9.0 → 0.9.1-beta-8053a0cc.0

package/.env

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

package/dist/events/index.js

@@ -27,10 +27,6 @@ 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/models/CustomFieldEntries.d.ts

@@ -1,15 +1,15 @@
 import { Model } from 'sequelize-typescript';
 declare class CustomFieldEntries extends Model {
-    /** The ID of the model of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / etc.  */
+    /** The ID of the entity of which this row hold the custom field entries of, e.g. Vehicle / StopPoint / 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: Record<string, any>;
+    customFields: any;
     /** The type of model which this custom field entry represents. e.g. Vehicle / StopPoint / etc. */
     modelType: string;
     createdAt?: Date;
     updatedAt?: Date;
+    static validateValues(instances: CustomFieldEntries[]): Promise<void>;
+    static validateValue(instance: CustomFieldEntries): Promise<void>;
     static afterSaveHandler(instance: CustomFieldEntries, options: any): void;
 }
 export default CustomFieldEntries;

package/dist/models/CustomFieldEntries.js

@@ -37,6 +37,14 @@ const events_1 = require("../events");
 const CustomFieldDefinitionRepo = __importStar(require("../repository/definition"));
 const validations_1 = require("../utils/validations");
 let CustomFieldEntries = class CustomFieldEntries extends sequelize_typescript_1.Model {
+    static async validateValues(instances) {
+        const definitionsByName = await CustomFieldDefinitionRepo.getCustomFieldDefinitionsDictionary(instances);
+        instances.forEach((instance) => (0, validations_1.validateInstanceCustomFieldEntries)(instance, definitionsByName));
+    }
+    static async validateValue(instance) {
+        const definitionsByName = await CustomFieldDefinitionRepo.getCustomFieldDefinitionsDictionary([instance]);
+        (0, validations_1.validateInstanceCustomFieldEntries)(instance, definitionsByName);
+    }
     static afterSaveHandler(instance, options) {
         if (options.transaction) {
             options.transaction.afterCommit(() => (0, events_1.sendDimEvent)(instance[0]));
@@ -52,24 +60,14 @@ __decorate([
         type: sequelize_typescript_1.DataType.UUID,
         allowNull: false,
     })
-    /** The ID of the model of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / etc.  */
+    /** The ID of the entity of which this row hold the custom field entries of, e.g. Vehicle / StopPoint / 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,
-        allowNull: false,
-        defaultValue: {},
+        allowNull: true,
     })
     /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
     ,
@@ -92,6 +90,21 @@ __decorate([
     sequelize_typescript_1.Column,
     __metadata("design:type", Date)
 ], CustomFieldEntries.prototype, "updatedAt", void 0);
+__decorate([
+    sequelize_typescript_1.BeforeBulkCreate,
+    sequelize_typescript_1.BeforeBulkUpdate,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [Array]),
+    __metadata("design:returntype", Promise)
+], CustomFieldEntries, "validateValues", null);
+__decorate([
+    sequelize_typescript_1.BeforeUpdate,
+    sequelize_typescript_1.BeforeCreate,
+    sequelize_typescript_1.BeforeUpsert,
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", [CustomFieldEntries]),
+    __metadata("design:returntype", Promise)
+], CustomFieldEntries, "validateValue", null);
 __decorate([
     sequelize_typescript_1.AfterUpsert,
     __metadata("design:type", Function),
@@ -101,23 +114,6 @@ __decorate([
 CustomFieldEntries = __decorate([
     (0, sequelize_typescript_1.Table)({
         timestamps: true,
-        indexes: [
-            {
-                name: 'idx_cfe_custom_fields',
-                using: 'gin',
-                operator: 'jsonb_path_ops',
-                fields: ['custom_fields'],
-            },
-        ],
-        validate: {
-            async validationByType() {
-                if (!Object.keys(this.customFields ?? {}).length) {
-                    return;
-                }
-                const definitionsByName = await CustomFieldDefinitionRepo.getCustomFieldDefinitionsDictionary([this]);
-                (0, validations_1.validateInstanceCustomFieldEntries)(this, definitionsByName);
-            },
-        },
     })
 ], CustomFieldEntries);
 exports.default = CustomFieldEntries;

package/dist/models/index.d.ts

@@ -6,12 +6,8 @@ import ContextAwareTestModel from './tests/contextAwareModels/ContextAwareTestMo
 import ContextTestModel from './tests/contextAwareModels/ContextTestModel';
 import AssociatedTestModel from './tests/AssociatedTestModel';
 import type { CustomFieldOptions } from '../types';
-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 initTables: (sequelize: Sequelize, getUser: CustomFieldOptions['getUser'], options: {
+    useCustomFieldsEntries: boolean;
+}) => Promise<void>;
 declare const initTestModels: (sequelize: Sequelize) => Promise<void>;
-export { CustomFieldValue, CustomFieldDefinition, CustomFieldEntries, TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel, initTables, initTestModels, };
+export { CustomFieldValue, CustomFieldDefinition, 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.CustomFieldEntries = exports.CustomFieldDefinition = exports.CustomFieldValue = void 0;
+exports.initTestModels = exports.initTables = exports.ContextTestModel = exports.ContextAwareTestModel = exports.AssociatedTestModel = exports.TestModel = exports.CustomFieldDefinition = exports.CustomFieldValue = void 0;
 /* eslint-disable no-param-reassign */
 const sequelize_1 = require("sequelize");
 const logger_1 = __importDefault(require("../utils/logger"));
@@ -20,23 +20,21 @@ 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 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' : ''}`;
+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;
     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);
     }
@@ -70,26 +68,17 @@ const initTables = async (sequelize, getUser, { schemaPrefix, schemaVersion, use
         timestamps: false,
         schema: 'public',
     });
-    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) {
+    const migrations = await SequelizeMeta.findAll({ raw: true });
+    const currentSadotSchemaVersion = migrations.reverse().find((m) => m.name.includes(SADOT_MIGRATION_PREFIX));
+    if (!currentSadotSchemaVersion
+        || currentSadotSchemaVersion.name !== schemaVersion) {
         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 });
         }
-        if (expectedSchemaVersionIndex === -1) {
-            await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
-        }
+        await SequelizeMeta.create({ name: schemaVersion });
         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,7 +1,8 @@
 import { type Includeable, type Transaction, type FindOptions, type WhereOptions } from 'sequelize';
-import { CustomFieldDefinition, type CustomFieldEntries } from '../models';
+import { CustomFieldDefinition } 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;
@@ -26,11 +27,7 @@ export declare const destroy: (id: string) => Promise<number>;
  * Return the names of the required fields for a given model
  */
 export declare const getRequiredFields: (modelType: string, modelId: string | string[], entityId: string | string[], modelOptions?: ModelOptions) => Promise<string[]>;
-/**
- * @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: CustomFieldEntries[], options?: SadotGetDefinitionsByEntityIdsOptions) => Promise<{
+export declare const getCustomFieldDefinitionsDictionary: (instances: CustomFieldEntriesDTO[], options?: SadotGetDefinitionsByEntityIdsOptions) => Promise<{
     [definitionName: string]: CustomFieldDefinition;
 }>;
 export {};

package/dist/repository/definition.js

@@ -87,24 +87,27 @@ const getRequiredFields = async (modelType, modelId, entityId, modelOptions = {}
     return [...new Set(requiredFieldsNames)];
 };
 exports.getRequiredFields = getRequiredFields;
-/**
- * @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]?.dataValues ?? {};
+    const { modelType } = instances[0];
     const customFields = new Set();
     const modelIds = [];
-    const entityIds = new Set();
     instances.forEach((instance) => {
-        const { dataValues: { modelId, entityId, customFields: instanceCustomFields } } = instance;
-        modelIds.push(modelId);
-        entityIds.add(entityId);
-        Object.keys(instanceCustomFields ?? {}).forEach((fieldName) => {
+        modelIds.push(instance.modelId);
+        Object.keys(instance.customFields).forEach((fieldName) => {
             customFields.add(fieldName);
         });
     });
-    const definitions = await (0, exports.findByEntityIds)(modelType, Array.from(entityIds), { ...options });
+    const { include, useEntityIdFromInclude } = options.modelOptions;
+    const where = {
+        modelType,
+        ...(!useEntityIdFromInclude && { entityId: modelIds }),
+    };
+    const definitions = await (0, exports.findAll)({
+        where,
+        transaction: options.transaction,
+        include: include?.(modelIds),
+        raw: true,
+    }, 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/scopes/filter.js

@@ -18,6 +18,9 @@ const castIfNeeded = (columnName, conditionValue) => {
     if (isDate(conditionValue)) {
         return castValueToJsonb(columnName, 'timestamp');
     }
+    if (!Number.isNaN(Number(conditionValue))) {
+        return castValueToJsonbNumeric(columnName);
+    }
     return columnName;
 };
 const AND_DELIMITER = ' AND ';

package/dist/tests/mocks/definition.mock.js

@@ -64,7 +64,6 @@ const createDefinition = (defaults) => ({
     fieldType: defaults?.fieldType || 'boolean',
     entityId: defaults?.entityId || (0, node_crypto_1.randomUUID)(),
     entityType: defaults?.entityType || 'fleetId',
-    ...(defaults?.validation && { validation: defaults.validation }),
     ...(defaults?.defaultValue && { defaultValue: defaults.defaultValue }),
 });
 exports.createDefinition = createDefinition;

package/dist/tests/mocks/events.mock.d.ts

@@ -1,4 +1,3 @@
 export declare const mockEvent: (events: any, eventName: any, numberOfEvents: any) => any[];
 export declare const mockDimCustomFieldDefinitionEvent: (events: any, numberOfEvents: any) => any[];
 export declare const mockDimCustomFieldValueEvent: (events: any, numberOfEvents: any) => any[];
-export declare const mockDimCustomFieldEntriesEvent: (events: any, numberOfEvents: any) => any[];

package/dist/tests/mocks/events.mock.js

@@ -1,7 +1,7 @@
 "use strict";
 /* eslint-disable no-param-reassign */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mockDimCustomFieldEntriesEvent = exports.mockDimCustomFieldValueEvent = exports.mockDimCustomFieldDefinitionEvent = exports.mockEvent = void 0;
+exports.mockDimCustomFieldValueEvent = exports.mockDimCustomFieldDefinitionEvent = exports.mockEvent = void 0;
 const mockEvent = (events, eventName, numberOfEvents) => {
     events.sendObject = jest.fn();
     return [
@@ -17,5 +17,3 @@ const mockDimCustomFieldDefinitionEvent = (events, numberOfEvents) => (0, export
 exports.mockDimCustomFieldDefinitionEvent = mockDimCustomFieldDefinitionEvent;
 const mockDimCustomFieldValueEvent = (events, numberOfEvents) => (0, exports.mockEvent)(events, 'dim_custom_field_value', numberOfEvents);
 exports.mockDimCustomFieldValueEvent = mockDimCustomFieldValueEvent;
-const mockDimCustomFieldEntriesEvent = (events, numberOfEvents) => (0, exports.mockEvent)(events, 'dim_custom_field_entries', numberOfEvents);
-exports.mockDimCustomFieldEntriesEvent = mockDimCustomFieldEntriesEvent;

package/dist/types/entries/index.d.ts

@@ -1,20 +1,10 @@
 import type { ValidationError } from 'joi';
 export interface CustomFieldEntriesDTO {
     modelId: string;
-    entityId: string;
     modelType: string;
-    /**
-     * A collection of custom fields where each key is the name of a CustomFieldDefinition and
-     * each value is the value of that custom field for this specific `modelId`.
-     *
-     * Example:
-     * {
-     *   "vehicleColor": "Red",
-     *   "vehicleType": "premium",
-     *   "isActive": true
-     * }
-     */
-    customFields: Record<string, any>;
+    customFields: {
+        [customFieldName: string]: any;
+    };
     createdAt?: Date;
     updatedAt?: Date;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.9.0",
+  "version": "0.9.1-beta-8053a0cc.0",
   "description": "",
   "main": "dist/index.js",
   "scripts": {

package/src/events/index.ts

@@ -25,10 +25,6 @@ const modelTableMapping = {
     tableName: 'dim_custom_field_value',
     eventVersion: '1',
   },
-  CustomFieldEntries: {
-    tableName: 'dim_custom_field_entries',
-    eventVersion: '1',
-  },
 };
 
 export const sendDimEvent = (instance): void => {

package/src/models/CustomFieldEntries.ts

@@ -4,7 +4,12 @@ import {
   Model,
   PrimaryKey,
   DataType,
+  BeforeCreate,
+  BeforeUpsert,
   AfterUpsert,
+  BeforeUpdate,
+  BeforeBulkCreate,
+  BeforeBulkUpdate,
 } from 'sequelize-typescript';
 import { sendDimEvent } from '../events';
 import * as CustomFieldDefinitionRepo from '../repository/definition';
@@ -12,24 +17,6 @@ import { validateInstanceCustomFieldEntries } from '../utils/validations';
 
 @Table({
   timestamps: true,
-  indexes: [
-    {
-      name: 'idx_cfe_custom_fields',
-      using: 'gin',
-      operator: 'jsonb_path_ops',
-      fields: ['custom_fields'],
-    },
-  ],
-  validate: {
-    async validationByType(this: CustomFieldEntries) {
-      if (!Object.keys(this.customFields ?? {}).length) {
-        return;
-      }
-
-      const definitionsByName = await CustomFieldDefinitionRepo.getCustomFieldDefinitionsDictionary([this]);
-      validateInstanceCustomFieldEntries(this, definitionsByName);
-    },
-  },
 })
 class CustomFieldEntries extends Model {
   @PrimaryKey
@@ -37,23 +24,15 @@ class CustomFieldEntries extends Model {
     type: DataType.UUID,
     allowNull: false,
   })
-    /** The ID of the model of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / etc.  */
+    /** The ID of the entity of which this row hold the custom field entries of, e.g. Vehicle / StopPoint / etc.  */
     modelId!: string;
 
-  @Column({
-    type: DataType.UUID,
-    allowNull: false,
-  })
-    /** The ID of the entity of which this row hold the custom field entries of, e.g. fleetId / etc.  */
-    entityId!: string;
-
   @Column({
     type: DataType.JSONB,
-    allowNull: false,
-    defaultValue: {},
+    allowNull: true,
   })
     /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
-    customFields!: Record<string, any>;
+    customFields!: any;
 
   @Column({
     type: DataType.STRING,
@@ -68,6 +47,23 @@ class CustomFieldEntries extends Model {
   @Column
     updatedAt?: Date;
 
+  @BeforeBulkCreate
+  @BeforeBulkUpdate
+  static async validateValues(instances: CustomFieldEntries[]): Promise<void> {
+    const definitionsByName = await CustomFieldDefinitionRepo.getCustomFieldDefinitionsDictionary(instances);
+
+    instances.forEach((instance) => validateInstanceCustomFieldEntries(instance, definitionsByName));
+  }
+
+  @BeforeUpdate
+  @BeforeCreate
+  @BeforeUpsert
+  static async validateValue(instance: CustomFieldEntries): Promise<void> {
+    const definitionsByName = await CustomFieldDefinitionRepo.getCustomFieldDefinitionsDictionary([instance]);
+
+    validateInstanceCustomFieldEntries(instance, definitionsByName);
+  }
+
   @AfterUpsert
   static afterSaveHandler(instance: CustomFieldEntries, options): void {
     if (options.transaction) {

package/src/models/index.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-param-reassign */
-import { DataTypes, Op } from 'sequelize';
+import { DataTypes } from 'sequelize';
 import type { Sequelize } from 'sequelize-typescript';
 import logger from '../utils/logger';
 import CustomFieldDefinition from './CustomFieldDefinition';
@@ -12,32 +12,23 @@ import type { CustomFieldOptions } from '../types';
 import CustomFieldEntries from './CustomFieldEntries';
 
 type ProductionModel = typeof CustomFieldDefinition | typeof CustomFieldValue | typeof CustomFieldEntries
-interface InitTablesOptions {
-  schemaPrefix?: string
-  schemaVersion?: string
-  useCustomFieldsEntries?: boolean
-}
 
 const productionModels: ProductionModel[] = [CustomFieldDefinition, CustomFieldValue];
 const testModels = [TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel];
 
 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: Sequelize,
   getUser: CustomFieldOptions['getUser'],
-  {
-    schemaPrefix,
-    schemaVersion,
-    useCustomFieldsEntries,
-  }: InitTablesOptions = {
-    schemaPrefix: SADOT_MIGRATION_PREFIX,
-    schemaVersion: SCHEMA_VERSION,
-    useCustomFieldsEntries: false,
+  options: {
+    useCustomFieldsEntries: boolean
   },
 ): Promise<void> => {
-  const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? '_withEntries' : ''}`;
+  const { useCustomFieldsEntries } = options;
   logger.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
@@ -45,6 +36,7 @@ const initTables = async (
     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);
   }
@@ -86,29 +78,22 @@ const initTables = async (
       schema: 'public',
     },
   );
+  const migrations = await SequelizeMeta.findAll({ raw: true });
+  const currentSadotSchemaVersion = migrations.reverse().find((m: any) => m.name.includes(SADOT_MIGRATION_PREFIX));
 
-  const migrations = await SequelizeMeta.findAll({ where: { name: { [Op.like]: `${schemaPrefix}%` } }, raw: true });
-  const currentSadotSchemaVersion = migrations.at(-1);
-  const expectedSchemaVersionIndex = migrations.findIndex((m) => (m as any).name === CUSTOM_FIELDS_SCHEMA_VERSION);
-
-  if (!currentSadotSchemaVersion || (currentSadotSchemaVersion as any).name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
+  if (
+    !currentSadotSchemaVersion
+    || (currentSadotSchemaVersion as any).name !== schemaVersion
+  ) {
     await CustomFieldDefinition.sync({ alter: true });
     await CustomFieldValue.sync({ alter: true });
-    // T.Y TODO: Remove the if statement once we're ready to add the new entries table for all MS
+
     if (useCustomFieldsEntries) {
       await CustomFieldEntries.sync({ alter: true });
     }
 
-    if (expectedSchemaVersionIndex === -1) {
-      await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
-    }
+    await SequelizeMeta.create({ name: schemaVersion });
     logger.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: { [Op.in]: migrationsToDelete.map((m) => (m as any).name) } } });
-    }
   }
 };
 
@@ -135,7 +120,6 @@ const initTestModels = async (sequelize: Sequelize): Promise<void> => {
 export {
   CustomFieldValue,
   CustomFieldDefinition,
-  CustomFieldEntries,
   TestModel,
   AssociatedTestModel,
   ContextAwareTestModel,

package/src/repository/definition.ts

@@ -2,10 +2,11 @@ import {
   Op,
   type Includeable, type Transaction, type FindOptions, type WhereOptions,
 } from 'sequelize';
-import { CustomFieldDefinition, type CustomFieldEntries } from '../models';
+import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
 import type { ModelOptions } from '../types';
 import { MissingDefinitionError } from '../errors';
+import type { CustomFieldEntriesDTO } from '../types/entries';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
@@ -133,29 +134,33 @@ export const getRequiredFields = async (
   return [...new Set(requiredFieldsNames)];
 };
 
-/**
- * @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 const getCustomFieldDefinitionsDictionary = async (
-  instances: CustomFieldEntries[],
+  instances: CustomFieldEntriesDTO[],
   options: SadotGetDefinitionsByEntityIdsOptions = { withDisabled: false, modelOptions: {} },
 ): Promise<{ [definitionName: string]: CustomFieldDefinition }> => {
-  const { modelType } = instances[0]?.dataValues ?? {};
+  const { modelType } = instances[0];
   const customFields = new Set<string>();
   const modelIds = [];
-  const entityIds = new Set<string>();
   instances.forEach((instance) => {
-    const { dataValues: { modelId, entityId, customFields: instanceCustomFields } } = instance;
-    modelIds.push(modelId);
-    entityIds.add(entityId);
+    modelIds.push(instance.modelId);
 
-    Object.keys(instanceCustomFields ?? {}).forEach((fieldName) => {
+    Object.keys(instance.customFields).forEach((fieldName) => {
       customFields.add(fieldName);
     });
   });
 
-  const definitions = await findByEntityIds(modelType, Array.from(entityIds), { ...options });
+  const { include, useEntityIdFromInclude } = options.modelOptions;
+  const where: WhereOptions = {
+    modelType,
+    ...(!useEntityIdFromInclude && { entityId: modelIds }),
+  };
+
+  const definitions = await findAll({
+    where,
+    transaction: options.transaction,
+    include: include?.(modelIds),
+    raw: true,
+  }, options);
 
   const matchedDefinitions = definitions.filter((def) => customFields.has(def.name));
   const matchedDefinitionsByName = Object.fromEntries(matchedDefinitions.map((definition) => [definition.name, definition]));

package/src/scopes/filter.ts

@@ -44,6 +44,9 @@ const castIfNeeded = (columnName: string, conditionValue: string): string => {
   if (isDate(conditionValue)) {
     return castValueToJsonb(columnName, 'timestamp');
   }
+  if (!Number.isNaN(Number(conditionValue))) {
+    return castValueToJsonbNumeric(columnName);
+  }
   return columnName;
 };
 const AND_DELIMITER = ' AND ';

package/src/tests/mocks/definition.mock.ts

@@ -1,4 +1,4 @@
-import { randomUUID } from 'node:crypto';
+import { randomUUID as uuidv4 } from 'node:crypto';
 import type { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
 
 export const contextAwareFieldDefinition = {
@@ -12,7 +12,7 @@ export const coolFieldDefinition: CreateCustomFieldDefinition = {
   name: 'cool field',
   modelType: 'TestModel',
   fieldType: 'number',
-  entityId: randomUUID(),
+  entityId: uuidv4(),
   entityType: 'fleetId',
 };
 
@@ -30,7 +30,7 @@ export const booleanField = (modelType: string): CreateCustomFieldDefinition =>
   name: 'shapeless',
   modelType,
   fieldType: 'boolean',
-  entityId: randomUUID(),
+  entityId: uuidv4(),
   entityType: 'fleetId',
 });
 
@@ -39,7 +39,7 @@ export const selectField = (modelType: string, options): CreateCustomFieldDefini
   modelType,
   fieldType: 'select',
   validation: options,
-  entityId: randomUUID(),
+  entityId: uuidv4(),
   entityType: 'fleetId',
 });
 
@@ -48,7 +48,7 @@ export const statusField = (modelType: string, options): CreateCustomFieldDefini
   modelType,
   fieldType: 'status',
   validation: options,
-  entityId: randomUUID(),
+  entityId: uuidv4(),
   entityType: 'fleetId',
 });
 
@@ -56,18 +56,17 @@ export const fileField = (modelType: string): CreateCustomFieldDefinition => ({
   name: 'file',
   modelType,
   fieldType: 'file',
-  entityId: randomUUID(),
+  entityId: uuidv4(),
   entityType: 'fleetId',
 });
 
 // eslint-disable-next-line max-len
 export const createDefinition = (defaults: Partial<CustomFieldDefinitionDTO>): CreateCustomFieldDefinition => ({
-  name: defaults?.name || `def_${randomUUID()}`,
+  name: defaults?.name || `def_${uuidv4()}`,
   modelType: defaults?.modelType || 'TestModel',
   fieldType: defaults?.fieldType || 'boolean',
-  entityId: defaults?.entityId || randomUUID(),
+  entityId: defaults?.entityId || uuidv4(),
   entityType: defaults?.entityType || 'fleetId',
-  ...(defaults?.validation && { validation: defaults.validation }),
   ...(defaults?.defaultValue && { defaultValue: defaults.defaultValue }),
 });
 
@@ -76,9 +75,9 @@ export const createDefinitions = (
   length = 1,
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 ): CreateCustomFieldDefinition[] => (Array(length).fill({}).map((_) => ({
-  name: defaults?.name || `def_${randomUUID()}`,
+  name: defaults?.name || `def_${uuidv4()}`,
   modelType: defaults?.modelType || 'TestModel',
   fieldType: defaults?.fieldType || 'boolean',
-  entityId: defaults?.entityId || randomUUID(),
+  entityId: defaults?.entityId || uuidv4(),
   entityType: defaults?.entityType || 'fleetId',
 })));

package/src/tests/mocks/events.mock.ts

@@ -16,6 +16,3 @@ export const mockDimCustomFieldDefinitionEvent = (events, numberOfEvents) =>
 
 export const mockDimCustomFieldValueEvent = (events, numberOfEvents) =>
   mockEvent(events, 'dim_custom_field_value', numberOfEvents);
-
-export const mockDimCustomFieldEntriesEvent = (events, numberOfEvents) =>
-  mockEvent(events, 'dim_custom_field_entries', numberOfEvents);

package/src/types/entries/index.ts

@@ -2,20 +2,10 @@ import type { ValidationError } from 'joi';
 
 export interface CustomFieldEntriesDTO {
   modelId: string;
-  entityId: string;
   modelType: string;
-  /**
-   * A collection of custom fields where each key is the name of a CustomFieldDefinition and
-   * each value is the value of that custom field for this specific `modelId`.
-   *
-   * Example:
-   * {
-   *   "vehicleColor": "Red",
-   *   "vehicleType": "premium",
-   *   "isActive": true
-   * }
-   */
-  customFields: Record<string, any>;
+  customFields: {
+    [customFieldName: string]: any;
+  };
   createdAt?: Date;
   updatedAt?: Date;
 }