@autofleet/sadot 0.8.6 → 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/errors/index.d.ts

@@ -1,5 +1,6 @@
 import { BadRequest } from '@autofleet/errors';
 import type { ValidationError } from 'joi';
+import type { EntriesValidationError } from '../types/entries';
 export declare class MissingRequiredCustomFieldError extends BadRequest {
     constructor(missingFields: string[]);
 }
@@ -15,6 +16,9 @@ export declare class InvalidFieldTypeError extends BadRequest {
 export declare class InvalidValueError extends BadRequest {
     constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError);
 }
+export declare class InvalidEntriesError extends BadRequest {
+    constructor(modelId: string, validationErrors: EntriesValidationError[]);
+}
 export declare class MissingDefinitionError extends BadRequest {
     constructor(fieldNames: string[]);
 }

package/dist/errors/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.MissingDefinitionError = exports.InvalidValueError = exports.InvalidFieldTypeError = exports.UnsupportedCustomValidationError = exports.UnsupportedCustomFieldTypeError = exports.MissingRequiredCustomFieldError = void 0;
+exports.MissingDefinitionError = exports.InvalidEntriesError = exports.InvalidValueError = exports.InvalidFieldTypeError = exports.UnsupportedCustomValidationError = exports.UnsupportedCustomFieldTypeError = exports.MissingRequiredCustomFieldError = void 0;
 /* eslint-disable max-classes-per-file */
 const errors_1 = require("@autofleet/errors");
 class MissingRequiredCustomFieldError extends errors_1.BadRequest {
@@ -48,6 +48,14 @@ class InvalidValueError extends errors_1.BadRequest {
     }
 }
 exports.InvalidValueError = InvalidValueError;
+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}`;
+    }
+}
+exports.InvalidEntriesError = InvalidEntriesError;
 class MissingDefinitionError extends errors_1.BadRequest {
     constructor(fieldNames) {
         const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);

package/dist/index.js

@@ -31,7 +31,7 @@ __exportStar(require("./utils/helpers"), exports);
  * @see {@link 'custom-fields/config'} for configurations
  */
 const useCustomFields = async (app, getModel, options) => {
-    const { models } = options;
+    const { models, useCustomFieldsEntries } = options;
     if (app) {
         app.use('/api', api_1.default);
     }
@@ -41,7 +41,7 @@ const useCustomFields = async (app, getModel, options) => {
     }
     // The order is important
     (0, init_1.addHooks)(models, getModel);
-    await (0, models_1.initTables)(sequelize, options.getUser);
+    await (0, models_1.initTables)(sequelize, options.getUser, { useCustomFieldsEntries });
     (0, init_1.addScopes)(models, getModel);
     (0, init_1.applyCustomAssociation)(models);
     logger_1.default.debug('sadot - custom fields finished initializing with models', models);

package/dist/models/CustomFieldEntries.d.ts

@@ -0,0 +1,15 @@
+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. Vehicle / StopPoint / etc.  */
+    modelId: string;
+    /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
+    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

@@ -0,0 +1,119 @@
+"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 __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+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 __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+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");
+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]));
+        }
+        else {
+            (0, events_1.sendDimEvent)(instance[0]);
+        }
+    }
+};
+__decorate([
+    sequelize_typescript_1.PrimaryKey,
+    (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. Vehicle / StopPoint / etc.  */
+    ,
+    __metadata("design:type", String)
+], CustomFieldEntries.prototype, "modelId", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.JSONB,
+        allowNull: true,
+    })
+    /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
+    ,
+    __metadata("design:type", Object)
+], CustomFieldEntries.prototype, "customFields", void 0);
+__decorate([
+    (0, sequelize_typescript_1.Column)({
+        type: sequelize_typescript_1.DataType.STRING,
+        allowNull: false,
+    })
+    /** The type of model which this custom field entry represents. e.g. Vehicle / StopPoint / etc. */
+    ,
+    __metadata("design:type", String)
+], CustomFieldEntries.prototype, "modelType", void 0);
+__decorate([
+    sequelize_typescript_1.Column,
+    __metadata("design:type", Date)
+], CustomFieldEntries.prototype, "createdAt", void 0);
+__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),
+    __metadata("design:paramtypes", [CustomFieldEntries, Object]),
+    __metadata("design:returntype", void 0)
+], CustomFieldEntries, "afterSaveHandler", null);
+CustomFieldEntries = __decorate([
+    (0, sequelize_typescript_1.Table)({
+        timestamps: true,
+    })
+], CustomFieldEntries);
+exports.default = CustomFieldEntries;

package/dist/models/index.d.ts

@@ -6,9 +6,8 @@ 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'], { schemaPrefix, schemaVersion }?: {
-    schemaPrefix: string;
-    schemaVersion: string;
+declare const initTables: (sequelize: Sequelize, getUser: CustomFieldOptions['getUser'], options: {
+    useCustomFieldsEntries: boolean;
 }) => Promise<void>;
 declare const initTestModels: (sequelize: Sequelize) => Promise<void>;
 export { CustomFieldValue, CustomFieldDefinition, TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel, initTables, initTestModels, };

package/dist/models/index.js

@@ -19,18 +19,25 @@ const ContextTestModel_1 = __importDefault(require("./tests/contextAwareModels/C
 exports.ContextTestModel = ContextTestModel_1.default;
 const AssociatedTestModel_1 = __importDefault(require("./tests/AssociatedTestModel"));
 exports.AssociatedTestModel = AssociatedTestModel_1.default;
+const CustomFieldEntries_1 = __importDefault(require("./CustomFieldEntries"));
 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 } = { schemaPrefix: SADOT_MIGRATION_PREFIX, schemaVersion: SCHEMA_VERSION }) => {
-    const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}`;
+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);
+    }
     sequelize.addModels(productionModels);
     CustomFieldDefinition_1.default.addScope('userScope', () => {
         const user = getUser();
@@ -61,22 +68,17 @@ const initTables = async (sequelize, getUser, { schemaPrefix, schemaVersion } =
         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 });
-        if (expectedSchemaVersionIndex === -1) {
-            await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
+        if (useCustomFieldsEntries) {
+            await CustomFieldEntries_1.default.sync({ alter: true });
         }
+        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

@@ -2,12 +2,16 @@ import { type Includeable, type Transaction, type FindOptions, type WhereOptions
 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;
     transaction?: Transaction;
     include?: Includeable | Includeable[];
 }
+type SadotGetDefinitionsByEntityIdsOptions = FindOptions & {
+    modelOptions?: ModelOptions;
+} & Pick<SadotFindOptions, 'withDisabled'>;
 export declare const findAll: (where: WhereOptions, options?: SadotFindOptions) => Promise<CustomFieldDefinition[]>;
 export declare const findByIds: (ids: string[], options?: SadotFindOptions) => Promise<CustomFieldDefinition[]>;
 export declare const findById: (id: string, options?: Pick<SadotFindOptions, 'withDisabled'>) => Promise<CustomFieldDefinition | null>;
@@ -23,4 +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[]>;
+export declare const getCustomFieldDefinitionsDictionary: (instances: CustomFieldEntriesDTO[], options?: SadotGetDefinitionsByEntityIdsOptions) => Promise<{
+    [definitionName: string]: CustomFieldDefinition;
+}>;
 export {};

package/dist/repository/definition.js

@@ -1,8 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getRequiredFields = exports.destroy = exports.disable = exports.update = exports.findDefinitionsByModels = exports.findByWhere = exports.findByEntityIds = exports.findById = exports.findByIds = exports.findAll = exports.create = void 0;
+exports.getCustomFieldDefinitionsDictionary = exports.getRequiredFields = exports.destroy = exports.disable = exports.update = exports.findDefinitionsByModels = exports.findByWhere = exports.findByEntityIds = exports.findById = exports.findByIds = exports.findAll = exports.create = void 0;
 const sequelize_1 = require("sequelize");
 const models_1 = require("../models");
+const errors_1 = require("../errors");
 const create = (data) => models_1.CustomFieldDefinition.create(data);
 exports.create = create;
 const findAll = (where, options = { withDisabled: false }) => {
@@ -86,3 +87,33 @@ const getRequiredFields = async (modelType, modelId, entityId, modelOptions = {}
     return [...new Set(requiredFieldsNames)];
 };
 exports.getRequiredFields = getRequiredFields;
+const getCustomFieldDefinitionsDictionary = async (instances, options = { withDisabled: false, modelOptions: {} }) => {
+    const { modelType } = instances[0];
+    const customFields = new Set();
+    const modelIds = [];
+    instances.forEach((instance) => {
+        modelIds.push(instance.modelId);
+        Object.keys(instance.customFields).forEach((fieldName) => {
+            customFields.add(fieldName);
+        });
+    });
+    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) {
+        const unmatchedCustomFields = Array.from(customFields).filter((customField) => !matchedDefinitionsByName[customField]);
+        throw new errors_1.MissingDefinitionError(unmatchedCustomFields);
+    }
+    return matchedDefinitionsByName;
+};
+exports.getCustomFieldDefinitionsDictionary = getCustomFieldDefinitionsDictionary;

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.d.ts

@@ -16,9 +16,9 @@ export declare const coolFieldDefinition2: {
     deletedAt?: Date;
     defaultValue?: any;
     blockEditingFromUI?: boolean;
-    displayName?: string;
     validation?: any;
     fieldType: string;
+    displayName?: string;
     entityId: string;
     entityType: string;
     modelType: string;
@@ -33,9 +33,9 @@ export declare const coolFieldDefinition3: {
     deletedAt?: Date;
     defaultValue?: any;
     blockEditingFromUI?: boolean;
-    displayName?: string;
     validation?: any;
     fieldType: string;
+    displayName?: string;
     entityId: string;
     entityType: string;
     modelType: string;

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/types/entries/index.d.ts

@@ -0,0 +1,15 @@
+import type { ValidationError } from 'joi';
+export interface CustomFieldEntriesDTO {
+    modelId: string;
+    modelType: string;
+    customFields: {
+        [customFieldName: string]: any;
+    };
+    createdAt?: Date;
+    updatedAt?: Date;
+}
+export interface EntriesValidationError {
+    value: any;
+    fieldDefinitionName: string;
+    joiValidationError: ValidationError;
+}

package/dist/types/entries/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/types/index.d.ts

@@ -30,4 +30,5 @@ export type CustomFieldOptions = {
     databaseConfig: any;
     getUser: typeof GetUserType;
     sequelize?: Sequelize;
+    useCustomFieldsEntries?: boolean;
 };

package/dist/utils/validations/index.d.ts

@@ -1,3 +1,8 @@
+import type { CustomFieldDefinition } from '../../models';
+import type { CustomFieldEntriesDTO } from '../../types/entries';
 import type { CustomFieldDefinitionType } from '../constants';
 export declare const validateFieldType: (type: CustomFieldDefinitionType) => boolean;
 export declare const validateValue: (value: unknown, valueType: CustomFieldDefinitionType, validation?: unknown) => import("joi").ValidationResult;
+export declare const validateInstanceCustomFieldEntries: (instance: CustomFieldEntriesDTO, definitionsByName: {
+    [defName: string]: CustomFieldDefinition;
+}) => void;

package/dist/utils/validations/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.validateValue = exports.validateFieldType = void 0;
+exports.validateInstanceCustomFieldEntries = exports.validateValue = exports.validateFieldType = void 0;
+const errors_1 = require("../../errors");
 const validators_1 = require("./validators");
 const validateFieldType = (type) => Object.keys(validators_1.validators).includes(type);
 exports.validateFieldType = validateFieldType;
@@ -15,3 +16,23 @@ const validateValue = (value, valueType, validation) => {
      */
 };
 exports.validateValue = validateValue;
+const validateInstanceCustomFieldEntries = (instance, definitionsByName) => {
+    const validationErrors = Object.entries(instance.customFields)
+        .map(([customFieldName, value]) => {
+        const { validation, fieldType } = definitionsByName[customFieldName];
+        const result = (0, exports.validateValue)(value, fieldType, validation);
+        if (result?.error) {
+            return {
+                joiValidationError: result.error,
+                fieldDefinitionName: customFieldName,
+                value,
+            };
+        }
+        return null;
+    })
+        .filter((result) => !!result);
+    if (validationErrors?.length) {
+        throw new errors_1.InvalidEntriesError(instance.modelId, validationErrors);
+    }
+};
+exports.validateInstanceCustomFieldEntries = validateInstanceCustomFieldEntries;

package/package.json

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

package/src/errors/index.ts

@@ -1,6 +1,7 @@
 /* eslint-disable max-classes-per-file */
 import { BadRequest } from '@autofleet/errors';
 import type { ValidationError } from 'joi';
+import type { EntriesValidationError } from '../types/entries';
 
 export class MissingRequiredCustomFieldError extends BadRequest {
   constructor(missingFields: string[]) {
@@ -50,6 +51,14 @@ export class InvalidValueError extends BadRequest {
   }
 }
 
+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}`;
+  }
+}
+
 export class MissingDefinitionError extends BadRequest {
   constructor(fieldNames: string[]) {
     const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);

package/src/index.ts

@@ -26,7 +26,7 @@ const useCustomFields = async (
   getModel: ModelFetcher,
   options: CustomFieldOptions,
 ): Promise<Sequelize> => {
-  const { models } = options;
+  const { models, useCustomFieldsEntries } = options;
   if (app) {
     app.use('/api', api);
   }
@@ -36,7 +36,7 @@ const useCustomFields = async (
   }
   // The order is important
   addHooks(models, getModel);
-  await initTables(sequelize, options.getUser);
+  await initTables(sequelize, options.getUser, { useCustomFieldsEntries });
   addScopes(models, getModel);
   applyCustomAssociation(models);
   logger.debug('sadot - custom fields finished initializing with models', models);

package/src/models/CustomFieldEntries.ts

@@ -0,0 +1,77 @@
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  BeforeCreate,
+  BeforeUpsert,
+  AfterUpsert,
+  BeforeUpdate,
+  BeforeBulkCreate,
+  BeforeBulkUpdate,
+} from 'sequelize-typescript';
+import { sendDimEvent } from '../events';
+import * as CustomFieldDefinitionRepo from '../repository/definition';
+import { validateInstanceCustomFieldEntries } from '../utils/validations';
+
+@Table({
+  timestamps: true,
+})
+class CustomFieldEntries extends Model {
+  @PrimaryKey
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    /** 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.JSONB,
+    allowNull: true,
+  })
+    /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
+    customFields!: any;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    /** The type of model which this custom field entry represents. e.g. Vehicle / StopPoint / etc. */
+    modelType!: string;
+
+  @Column
+    createdAt?: Date;
+
+  @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) {
+      options.transaction.afterCommit(() => sendDimEvent(instance[0]));
+    } else {
+      sendDimEvent(instance[0]);
+    }
+  }
+}
+
+export default CustomFieldEntries;

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';
@@ -9,25 +9,38 @@ 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';
 
-const productionModels = [CustomFieldDefinition, CustomFieldValue];
+type ProductionModel = typeof CustomFieldDefinition | typeof CustomFieldValue | typeof CustomFieldEntries
+
+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 } = { schemaPrefix: SADOT_MIGRATION_PREFIX, schemaVersion: SCHEMA_VERSION },
+  options: {
+    useCustomFieldsEntries: boolean
+  },
 ): Promise<void> => {
-  const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}`;
+  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
   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);
+  }
+
   sequelize.addModels(productionModels);
 
   CustomFieldDefinition.addScope('userScope', () => {
@@ -65,24 +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 });
-    if (expectedSchemaVersionIndex === -1) {
-      await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
+
+    if (useCustomFieldsEntries) {
+      await CustomFieldEntries.sync({ alter: true });
     }
+
+    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) } } });
-    }
   }
 };
 

package/src/repository/definition.ts

@@ -5,6 +5,8 @@ import {
 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);
@@ -15,6 +17,8 @@ interface SadotFindOptions {
   include?: Includeable | Includeable[];
 }
 
+type SadotGetDefinitionsByEntityIdsOptions = FindOptions & { modelOptions?: ModelOptions } & Pick<SadotFindOptions, 'withDisabled'>;
+
 export const findAll = (
   where: WhereOptions,
   options: SadotFindOptions = { withDisabled: false },
@@ -129,3 +133,42 @@ export const getRequiredFields = async (
   const requiredFieldsNames = requiredFields.map((definition) => definition.name);
   return [...new Set(requiredFieldsNames)];
 };
+
+export const getCustomFieldDefinitionsDictionary = async (
+  instances: CustomFieldEntriesDTO[],
+  options: SadotGetDefinitionsByEntityIdsOptions = { withDisabled: false, modelOptions: {} },
+): Promise<{ [definitionName: string]: CustomFieldDefinition }> => {
+  const { modelType } = instances[0];
+  const customFields = new Set<string>();
+  const modelIds = [];
+  instances.forEach((instance) => {
+    modelIds.push(instance.modelId);
+
+    Object.keys(instance.customFields).forEach((fieldName) => {
+      customFields.add(fieldName);
+    });
+  });
+
+  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]));
+
+  if (!definitions?.length || matchedDefinitions.length !== customFields.size) {
+    const unmatchedCustomFields = Array.from(customFields).filter((customField) => !matchedDefinitionsByName[customField]);
+    throw new MissingDefinitionError(unmatchedCustomFields);
+  }
+
+  return matchedDefinitionsByName;
+};

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/types/entries/index.ts

@@ -0,0 +1,17 @@
+import type { ValidationError } from 'joi';
+
+export interface CustomFieldEntriesDTO {
+  modelId: string;
+  modelType: string;
+  customFields: {
+    [customFieldName: string]: any;
+  };
+  createdAt?: Date;
+  updatedAt?: Date;
+}
+
+export interface EntriesValidationError {
+  value: any,
+  fieldDefinitionName: string,
+  joiValidationError: ValidationError
+}

package/src/types/index.ts

@@ -34,4 +34,5 @@ export type CustomFieldOptions = {
   databaseConfig: any;
   getUser: typeof GetUserType;
   sequelize?: Sequelize;
+  useCustomFieldsEntries?: boolean;
 };

package/src/utils/validations/index.ts

@@ -1,3 +1,6 @@
+import { InvalidEntriesError } from '../../errors';
+import type { CustomFieldDefinition } from '../../models';
+import type { CustomFieldEntriesDTO } from '../../types/entries';
 import type { CustomFieldDefinitionType } from '../constants';
 import { validators } from './validators';
 
@@ -17,3 +20,24 @@ export const validateValue = (
    * }
    */
 };
+
+export const validateInstanceCustomFieldEntries = (instance: CustomFieldEntriesDTO, definitionsByName: { [defName: string]: CustomFieldDefinition; }) => {
+  const validationErrors = Object.entries(instance.customFields)
+    .map(([customFieldName, value]) => {
+      const { validation, fieldType } = definitionsByName[customFieldName];
+      const result = validateValue(value, fieldType, validation);
+      if (result?.error) {
+        return {
+          joiValidationError: result.error,
+          fieldDefinitionName: customFieldName,
+          value,
+        };
+      }
+      return null;
+    })
+    .filter((result) => !!result);
+
+  if (validationErrors?.length) {
+    throw new InvalidEntriesError(instance.modelId, validationErrors);
+  }
+};