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

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

@@ -1,15 +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.  */
+    /** 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: any;
+    customFields: Record<string, 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,14 +37,6 @@ 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]));
@@ -60,14 +52,24 @@ __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. Vehicle / StopPoint / 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,
-        allowNull: true,
+        allowNull: false,
+        defaultValue: {},
     })
     /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
     ,
@@ -90,21 +92,6 @@ __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),
@@ -114,6 +101,23 @@ __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,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;
@@ -27,7 +26,11 @@ 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<{
+/**
+ * @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<{
     [definitionName: string]: CustomFieldDefinition;
 }>;
 export {};

package/dist/repository/definition.js

@@ -87,27 +87,24 @@ 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];
+    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 }),
-    };
-    const definitions = await (0, exports.findAll)({
-        where,
-        transaction: options.transaction,
-        include: include?.(modelIds),
-        raw: true,
-    }, options);
+    const definitions = await (0, exports.findByEntityIds)(modelType, Array.from(entityIds), { ...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,9 +18,6 @@ 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,6 +64,7 @@ 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,3 +1,4 @@
 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.mockDimCustomFieldValueEvent = exports.mockDimCustomFieldDefinitionEvent = exports.mockEvent = void 0;
+exports.mockDimCustomFieldEntriesEvent = exports.mockDimCustomFieldValueEvent = exports.mockDimCustomFieldDefinitionEvent = exports.mockEvent = void 0;
 const mockEvent = (events, eventName, numberOfEvents) => {
     events.sendObject = jest.fn();
     return [
@@ -17,3 +17,5 @@ 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,10 +1,20 @@
 import type { ValidationError } from 'joi';
 export interface CustomFieldEntriesDTO {
     modelId: string;
+    entityId: string;
     modelType: string;
-    customFields: {
-        [customFieldName: string]: any;
-    };
+    /**
+     * 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>;
     createdAt?: Date;
     updatedAt?: Date;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autofleet/sadot",
-  "version": "0.9.1-beta-8053a0cc.0",
+  "version": "0.9.1",
   "description": "",
   "main": "dist/index.js",
   "scripts": {
@@ -8,7 +8,7 @@
     "build": "rm -rf dist && tsc",
     "linter": "eslint .",
     "test": "jest --runInBand",
-    "coverage": "jest --coverage --runInBand && rm -rf ./coverage",
+    "coverage": "jest --coverage --runInBand",
     "build-to-local-repo": "node --run build && cp -r dist/* ../$REPO/node_modules/$npm_package_name/dist",
     "dev": "nodemon",
     "watch": "npm-watch build-to-local-repo",

package/src/api/v1/definition/index.ts

@@ -1,11 +1,11 @@
 import { ResourceNotFoundError } from '@autofleet/errors';
 import { Router } from 'express';
-import type { Request, Response } from 'express';
 import handleError from '../errors';
 import * as DefinitionRepo from '../../../repository/definition';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../../../types/definition';
 import { validateCustomFieldDefinitionCreation, validateCustomFieldDefinitionUpdate } from './validations';
 import logger from '../../../utils/logger';
+import type { CustomFieldDefinition } from '../../../models';
 
 const router = Router({ mergeParams: true });
 const ENTITY = 'CustomFieldDefinition';
@@ -15,12 +15,11 @@ const toPascalCase = (str: string): string => str.replace(/(^\w|-\w)/g, (subStr)
 /**
  * Create
  */
-router.post('/', async (req: Request, res: Response) => {
-  const { modelName } = req.params as any;
+router.post<{ modelName: string; }>('/', async (req, res) => {
+  const { modelName } = req.params;
   const modelType = toPascalCase(modelName);
   try {
-    const validatedPayload: CreateCustomFieldDefinition = await
-    validateCustomFieldDefinitionCreation(req.body);
+    const validatedPayload: CreateCustomFieldDefinition = await validateCustomFieldDefinitionCreation(req.body);
 
     const customFieldDefinition = await DefinitionRepo.create({
       ...validatedPayload,
@@ -29,14 +28,14 @@ router.post('/', async (req: Request, res: Response) => {
     return res.status(201).json(customFieldDefinition);
   } catch (err) {
     logger.error('Failed to create custom field definition', err);
-    return handleError(err, res, { message: `Error in create ${ENTITY} request` });
+    return handleError(err, res, { logger, message: `Error in create ${ENTITY} request` });
   }
 });
 
 /**
  * Get by id
  */
-router.get('/:customFieldDefinitionId', async (req, res) => {
+router.get<{ modelName: string; customFieldDefinitionId: string; }, CustomFieldDefinition>('/:customFieldDefinitionId', async (req, res) => {
   const { customFieldDefinitionId } = req.params;
   try {
     const customFieldDefinition = await DefinitionRepo.findById(customFieldDefinitionId);
@@ -48,15 +47,15 @@ router.get('/:customFieldDefinitionId', async (req, res) => {
     return res.json(customFieldDefinition);
   } catch (err) {
     logger.error('Failed to fetch custom field definition', err);
-    return handleError(err, res, { message: `Error in get ${ENTITY} request` });
+    return handleError(err, res, { logger, message: `Error in get ${ENTITY} request` });
   }
 });
 
 /**
  * Get all
  */
-router.get('/', async (req, res) => {
-  const { params: { modelName }, query: { entityIds } } = req as any;
+router.get<{ modelName: string; }, CustomFieldDefinition[], never, { entityIds?: string[]; }>('/', async (req, res) => {
+  const { params: { modelName }, query: { entityIds } } = req;
 
   const modelType = toPascalCase(modelName);
   try {
@@ -68,15 +67,15 @@ router.get('/', async (req, res) => {
     return res.json(customFieldDefinitions);
   } catch (err) {
     logger.error('Failed to fetch custom field definitions', err);
-    return handleError(err, res, { message: `Error in get all ${ENTITY} request` });
+    return handleError(err, res, { logger, message: `Error in get all ${ENTITY} request` });
   }
 });
 
 /**
  * Update
  */
-router.patch('/:customFieldDefinitionId', async (req, res) => {
-  const { customFieldDefinitionId, modelName } = req.params as any;
+router.patch<{ modelName: string; customFieldDefinitionId: string; }, CustomFieldDefinition>('/:customFieldDefinitionId', async (req, res) => {
+  const { customFieldDefinitionId, modelName } = req.params;
   const modelType = toPascalCase(modelName);
   try {
     const validatedPayload: UpdateCustomFieldDefinition = await validateCustomFieldDefinitionUpdate(req.body);
@@ -98,7 +97,7 @@ router.patch('/:customFieldDefinitionId', async (req, res) => {
     return res.status(200).json(updatedCustomFieldDefinition);
   } catch (err) {
     logger.error('Failed to patch custom field definition', err);
-    return handleError(err, res, { message: `Error in update ${ENTITY} request` });
+    return handleError(err, res, { logger, message: `Error in update ${ENTITY} request` });
   }
 });
 

package/src/api/v1/definition/validations.ts

@@ -1,3 +1,4 @@
+/* eslint-disable newline-per-chained-call */
 import Joi from 'joi';
 import { CustomFieldDefinitionType } from '../../../utils/constants';
 
@@ -11,7 +12,6 @@ const statusValidationObject = Joi.object({
   value: Joi.string().required(),
   color: Joi.string().required(),
 });
-const statusValidationObjectSchema = Joi.array().items(statusValidationObject).min(1).unique('value');
 /**
  * Schema for the validation of custom field definition
  * The only custom validation is for
@@ -23,12 +23,12 @@ const statusValidationObjectSchema = Joi.array().items(statusValidationObject).m
  */
 const ValidationSchema = Joi.when('fieldType', {
   is: CustomFieldDefinitionType.SELECT,
-  then: Joi.array().items(Joi.string()).min(1).unique(),
-  otherwise: Joi.any(),
-}).when('fieldType', {
-  is: CustomFieldDefinitionType.STATUS,
-  then: statusValidationObjectSchema,
-  otherwise: Joi.any(),
+  then: Joi.array().required().items(Joi.string()).min(1).unique(),
+  otherwise: Joi.when('fieldType', {
+    is: CustomFieldDefinitionType.STATUS,
+    then: Joi.array().required().items(statusValidationObject).min(1).unique('value'),
+    otherwise: Joi.forbidden(),
+  }),
 });
 
 const DefaultValueSchema = Joi.when('fieldType', {
@@ -57,7 +57,7 @@ const CustomFieldDefinitionCreationSchema = Joi.object({
   required: Joi.boolean(),
   disabled: Joi.boolean(),
   blockEditingFromUI: Joi.boolean(),
-});
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
 
 const CustomFieldDefinitionUpdateSchema = Joi.object({
   displayName: Joi.string(),
@@ -68,10 +68,8 @@ const CustomFieldDefinitionUpdateSchema = Joi.object({
   required: Joi.boolean(),
   disabled: Joi.boolean(),
   blockEditingFromUI: Joi.boolean(),
-});
+}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
 
-export const validateCustomFieldDefinitionCreation = (payload) =>
-  CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
+export const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
 
-export const validateCustomFieldDefinitionUpdate = (payload) =>
-  CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });
+export const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });

package/src/api/v1/errors.ts

@@ -1,14 +1,11 @@
-import { handleError, BadRequest } from '@autofleet/errors';
+import type { Response } from 'express';
+import { handleError, BadRequest, type LogPayload } from '@autofleet/errors';
 import { ValidationError as InputValidationError } from 'joi';
 import { ValidationError as DatabaseValidationError } from 'sequelize';
 
-export default (err, res, additionalData = undefined) => {
+export default (err, res: Response, additionalData: LogPayload = undefined) => {
   let error = err;
-  if (err instanceof InputValidationError) {
-    error = new BadRequest([err], null);
-  }
-
-  if (err instanceof DatabaseValidationError) {
+  if ([InputValidationError, DatabaseValidationError].some((ErrClass) => err instanceof ErrClass)) {
     error = new BadRequest([err], null);
   }
 

package/src/events/index.ts

@@ -25,6 +25,10 @@ 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,12 +4,7 @@ import {
   Model,
   PrimaryKey,
   DataType,
-  BeforeCreate,
-  BeforeUpsert,
   AfterUpsert,
-  BeforeUpdate,
-  BeforeBulkCreate,
-  BeforeBulkUpdate,
 } from 'sequelize-typescript';
 import { sendDimEvent } from '../events';
 import * as CustomFieldDefinitionRepo from '../repository/definition';
@@ -17,6 +12,24 @@ 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
@@ -24,15 +37,23 @@ class CustomFieldEntries extends Model {
     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.  */
+    /** The ID of the model of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / 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: true,
+    allowNull: false,
+    defaultValue: {},
   })
     /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
-    customFields!: any;
+    customFields!: Record<string, any>;
 
   @Column({
     type: DataType.STRING,
@@ -47,23 +68,6 @@ 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 } from 'sequelize';
+import { DataTypes, Op } from 'sequelize';
 import type { Sequelize } from 'sequelize-typescript';
 import logger from '../utils/logger';
 import CustomFieldDefinition from './CustomFieldDefinition';
@@ -12,23 +12,32 @@ 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'],
-  options: {
-    useCustomFieldsEntries: boolean
+  {
+    schemaPrefix,
+    schemaVersion,
+    useCustomFieldsEntries,
+  }: InitTablesOptions = {
+    schemaPrefix: SADOT_MIGRATION_PREFIX,
+    schemaVersion: SCHEMA_VERSION,
+    useCustomFieldsEntries: false,
   },
 ): Promise<void> => {
-  const { useCustomFieldsEntries } = options;
+  const CUSTOM_FIELDS_SCHEMA_VERSION = `${schemaPrefix}_${schemaVersion}${useCustomFieldsEntries ? '_withEntries' : ''}`;
   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
@@ -36,7 +45,6 @@ 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);
   }
@@ -78,22 +86,29 @@ 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));
 
-  if (
-    !currentSadotSchemaVersion
-    || (currentSadotSchemaVersion as any).name !== schemaVersion
-  ) {
+  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) {
     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 });
     }
 
-    await SequelizeMeta.create({ name: schemaVersion });
+    if (expectedSchemaVersionIndex === -1) {
+      await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
+    }
     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) } } });
+    }
   }
 };
 
@@ -120,6 +135,7 @@ const initTestModels = async (sequelize: Sequelize): Promise<void> => {
 export {
   CustomFieldValue,
   CustomFieldDefinition,
+  CustomFieldEntries,
   TestModel,
   AssociatedTestModel,
   ContextAwareTestModel,

package/src/repository/definition.ts

@@ -2,11 +2,10 @@ import {
   Op,
   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 { MissingDefinitionError } from '../errors';
-import type { CustomFieldEntriesDTO } from '../types/entries';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
@@ -134,33 +133,29 @@ 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: CustomFieldEntriesDTO[],
+  instances: CustomFieldEntries[],
   options: SadotGetDefinitionsByEntityIdsOptions = { withDisabled: false, modelOptions: {} },
 ): Promise<{ [definitionName: string]: CustomFieldDefinition }> => {
-  const { modelType } = instances[0];
+  const { modelType } = instances[0]?.dataValues ?? {};
   const customFields = new Set<string>();
   const modelIds = [];
+  const entityIds = new Set<string>();
   instances.forEach((instance) => {
-    modelIds.push(instance.modelId);
+    const { dataValues: { modelId, entityId, customFields: instanceCustomFields } } = instance;
+    modelIds.push(modelId);
+    entityIds.add(entityId);
 
-    Object.keys(instance.customFields).forEach((fieldName) => {
+    Object.keys(instanceCustomFields ?? {}).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 definitions = await findByEntityIds(modelType, Array.from(entityIds), { ...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,9 +44,6 @@ 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 as uuidv4 } from 'node:crypto';
+import { randomUUID } 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: uuidv4(),
+  entityId: randomUUID(),
   entityType: 'fleetId',
 };
 
@@ -30,7 +30,7 @@ export const booleanField = (modelType: string): CreateCustomFieldDefinition =>
   name: 'shapeless',
   modelType,
   fieldType: 'boolean',
-  entityId: uuidv4(),
+  entityId: randomUUID(),
   entityType: 'fleetId',
 });
 
@@ -39,7 +39,7 @@ export const selectField = (modelType: string, options): CreateCustomFieldDefini
   modelType,
   fieldType: 'select',
   validation: options,
-  entityId: uuidv4(),
+  entityId: randomUUID(),
   entityType: 'fleetId',
 });
 
@@ -48,7 +48,7 @@ export const statusField = (modelType: string, options): CreateCustomFieldDefini
   modelType,
   fieldType: 'status',
   validation: options,
-  entityId: uuidv4(),
+  entityId: randomUUID(),
   entityType: 'fleetId',
 });
 
@@ -56,17 +56,18 @@ export const fileField = (modelType: string): CreateCustomFieldDefinition => ({
   name: 'file',
   modelType,
   fieldType: 'file',
-  entityId: uuidv4(),
+  entityId: randomUUID(),
   entityType: 'fleetId',
 });
 
 // eslint-disable-next-line max-len
 export const createDefinition = (defaults: Partial<CustomFieldDefinitionDTO>): CreateCustomFieldDefinition => ({
-  name: defaults?.name || `def_${uuidv4()}`,
+  name: defaults?.name || `def_${randomUUID()}`,
   modelType: defaults?.modelType || 'TestModel',
   fieldType: defaults?.fieldType || 'boolean',
-  entityId: defaults?.entityId || uuidv4(),
+  entityId: defaults?.entityId || randomUUID(),
   entityType: defaults?.entityType || 'fleetId',
+  ...(defaults?.validation && { validation: defaults.validation }),
   ...(defaults?.defaultValue && { defaultValue: defaults.defaultValue }),
 });
 
@@ -75,9 +76,9 @@ export const createDefinitions = (
   length = 1,
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
 ): CreateCustomFieldDefinition[] => (Array(length).fill({}).map((_) => ({
-  name: defaults?.name || `def_${uuidv4()}`,
+  name: defaults?.name || `def_${randomUUID()}`,
   modelType: defaults?.modelType || 'TestModel',
   fieldType: defaults?.fieldType || 'boolean',
-  entityId: defaults?.entityId || uuidv4(),
+  entityId: defaults?.entityId || randomUUID(),
   entityType: defaults?.entityType || 'fleetId',
 })));

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

@@ -16,3 +16,6 @@ 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,10 +2,20 @@ import type { ValidationError } from 'joi';
 
 export interface CustomFieldEntriesDTO {
   modelId: string;
+  entityId: string;
   modelType: string;
-  customFields: {
-    [customFieldName: string]: any;
-  };
+  /**
+   * 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>;
   createdAt?: Date;
   updatedAt?: Date;
 }

package/.env

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