@autofleet/sadot 0.0.1-beta → 0.0.1-beta.0

package/src/models/CustomFieldValue.ts

@@ -1,5 +1,4 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -14,18 +13,16 @@ import {
   BeforeUpdate,
   BeforeBulkCreate,
   BeforeBulkUpdate,
-  Scopes,
 } from 'sequelize-typescript';
 import { sendDimEvent } from '../events';
 import { CustomFieldDefinition } from '.';
 import validateValue from '../utils/validations';
 import * as CustomFieldDefinitionRepo from '../repository/definition';
 import logger from '../utils/logger';
-import { InvalidValueError } from '../errors';
 
 @Table({
   timestamps: true,
-})
+  })
 class CustomFieldValue extends Model {
   @PrimaryKey
   @Column({
@@ -44,7 +41,7 @@ class CustomFieldValue extends Model {
 
   @Column({
     type: DataType.JSONB,
-    allowNull: true,
+    allowNull: false,
   })
   value!: any;
 
@@ -63,7 +60,8 @@ class CustomFieldValue extends Model {
   @BeforeBulkCreate
   @BeforeBulkUpdate
   static async validateValues(instances: CustomFieldValue[]): Promise<void> {
-    const ids = instances.map((instance) => instance.customFieldDefinitionId);
+    logger.info('CustomFieldValue BeforeBulkCreate/BeforeBulkUpdate', { instances });
+    const ids = instances.map(instance => instance.customFieldDefinitionId);
     const uniqueIds = [...new Set(ids)];
     const definitions = await CustomFieldDefinitionRepo.findByIds(
       uniqueIds,
@@ -79,10 +77,10 @@ class CustomFieldValue extends Model {
         validation,
         fieldType,
       } = definitions
-        .find((definition) => definition.id === instance.customFieldDefinitionId);
+        .find(definition => definition.id === instance.customFieldDefinitionId);
       const isValid = validateValue(instance.value, fieldType, validation);
       if (!isValid) {
-        throw new InvalidValueError(instance.value, fieldType);
+        throw new Error('Invalid value');
       }
     });
   }
@@ -91,18 +89,19 @@ class CustomFieldValue extends Model {
   @BeforeCreate
   @BeforeUpsert
   static async validateValue(instance: CustomFieldValue): Promise<void> {
+    logger.info('CustomFieldValue BeforeCreate/BeforeUpdate', { instance });
     const { customFieldDefinitionId } = instance;
-    // eslint-disable-next-line max-len
     const cfd = await CustomFieldDefinitionRepo.findById(customFieldDefinitionId, { withDisabled: true });
     const { validation, fieldType } = cfd;
     const isValid = validateValue(instance.value, fieldType, validation);
     if (!isValid) {
-      throw new InvalidValueError(instance.value, fieldType);
+      throw new Error('Invalid value');
     }
   }
 
   @AfterUpsert
   static afterSaveHandler(instance: CustomFieldValue, options): void {
+    logger.info('CustomFieldValue afterSave', { instance });
     if (options.transaction) {
       options.transaction.afterCommit(() => sendDimEvent(instance[0]));
     } else {
@@ -112,3 +111,4 @@ class CustomFieldValue extends Model {
 }
 
 export default CustomFieldValue;
+

package/src/models/index.ts

@@ -1,101 +1,39 @@
 /* eslint-disable no-param-reassign */
-import { DataTypes } from 'sequelize';
 import type { Sequelize } from 'sequelize-typescript';
 import logger from '../utils/logger';
+// import addPermanentHooks from '../hooks/permanent-hooks';
+
 import CustomFieldDefinition from './CustomFieldDefinition';
 import CustomFieldValue from './CustomFieldValue';
 import TestModel from './tests/TestModel';
 import AssociatedTestModel from './tests/AssociatedTestModel';
 
-const productionModels = [CustomFieldDefinition, CustomFieldValue];
-const testModels = [TestModel, AssociatedTestModel];
+// export const CustomFieldDefinition = CustomFieldDefinitionModel;
+// export { default as CustomFieldDefinition } from './custom-field-definition.model';
 
-const SADOT_MIGRATION_PREFIX = 'sadot-migration';
-const SCHEMA_VERSION = 1;
-const CUSTOM_FIELDS_SCHEMA_VERSION = `${SADOT_MIGRATION_PREFIX}_${SCHEMA_VERSION}`;
+const productionModels = [CustomFieldDefinition, CustomFieldValue];
+const testModels = [...productionModels, TestModel, AssociatedTestModel];
 
-const initTables = async (sequelize: Sequelize, getUser): Promise<void> => {
+const initTables = async (sequelize: Sequelize): Promise<void> => {
   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');
   }
-  sequelize.addModels(productionModels);
-
-  CustomFieldDefinition.addScope('userScope', () => {
-    const user = getUser();
-    if (user?.permissions) {
-      return {
-        where: {
-          entityId: [
-            ...Object.keys(user.permissions.fleets),
-            ...Object.keys(user.permissions.businessModels),
-            ...Object.keys(user.permissions.demandSources),
-          ],
-        },
-      };
-    }
-    return {};
-  });
+  sequelize.addModels(process.env.NODE_ENV === 'test' ? testModels : productionModels);
+  await sequelize.dropSchema('custom-fields', { logging: false });
+  await sequelize.createSchema('custom-fields', { logging: false });
 
   logger.info('custom-fields: models added');
+  await CustomFieldDefinition.sync({ alter: true });
+  await CustomFieldValue.sync({ alter: true });
 
-  const SequelizeMeta = sequelize.define(
-    'SequelizeMeta',
-    {
-      name: {
-        type: DataTypes.STRING,
-        allowNull: false,
-        unique: true,
-        primaryKey: true,
-        autoIncrement: false,
-      },
-    },
-    {
-      tableName: 'SequelizeMeta',
-      timestamps: false,
-      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 !== CUSTOM_FIELDS_SCHEMA_VERSION
-  ) {
-    await CustomFieldDefinition.sync({ alter: true });
-    await CustomFieldValue.sync({ alter: true });
-    await SequelizeMeta.create({ name: CUSTOM_FIELDS_SCHEMA_VERSION });
-    logger.info('custom-fields: models synced');
+  if (process.env.NODE_ENV === 'test') {
+    await TestModel.sync({ alter: true });
+    await AssociatedTestModel.sync({ alter: true });
   }
+  logger.info('custom-fields: models synced');
 };
 
-const initTestModels = async (sequelize: Sequelize): Promise<void> => {
-  logger.info('custom-fields: initialize custom-fields test models');
-  // 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');
-  }
-
-  sequelize.addModels(testModels);
-  await sequelize.dropSchema('custom-fields', { logging: false });
-  await sequelize.createSchema('custom-fields', { logging: false });
-
-  logger.info('custom-fields: test models added');
-  await TestModel.sync({ alter: true });
-  await AssociatedTestModel.sync({ alter: true });
-  logger.info('custom-fields: test models synced');
-};
-
-export {
-  CustomFieldValue,
-  CustomFieldDefinition,
-  TestModel,
-  AssociatedTestModel,
-  initTables,
-  initTestModels,
-};
+export { CustomFieldValue, CustomFieldDefinition, TestModel, AssociatedTestModel, initTables };

package/src/models/tests/AssociatedTestModel.ts

@@ -55,3 +55,4 @@ class AssociatedTestModel extends Model {
 }
 
 export default AssociatedTestModel;
+

package/src/models/tests/TestModel.ts

@@ -47,3 +47,4 @@ class TestModel extends Model {
 }
 
 export default TestModel;
+

package/src/repository/definition.ts

@@ -1,21 +1,24 @@
 import { Op, WhereOptions } from 'sequelize';
-import { CustomFieldDefinition } from '../models';
+import { CustomFieldDefinition, CustomFieldValue } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
 
 export const findAll = (
-  where: any,
+  query: any,
   options: any = { withDisabled: false },
 ): Promise<CustomFieldDefinition[]> => {
-  const queryModel = options.withDisabled
-    ? CustomFieldDefinition.unscoped()
-    : CustomFieldDefinition;
-  return queryModel.scope('userScope').findAll({
-    where,
-    transaction: options.transaction,
-    raw: true,
+  if (options.withDisabled) {
+    return CustomFieldDefinition.unscoped().findAll({
+      where: query,
+      include: [CustomFieldValue],
+    });
+  }
+
+  return CustomFieldDefinition.findAll({
+    where: query,
+    include: [CustomFieldValue],
   });
 };
 
@@ -30,9 +33,13 @@ export const findById = (
 ): Promise<CustomFieldDefinition | null> => {
   const { withDisabled } = options;
   if (withDisabled) {
-    return CustomFieldDefinition.unscoped().scope('userScope').findByPk(id);
+    return CustomFieldDefinition.unscoped().findByPk(id, {
+      include: [CustomFieldValue],
+    });
   }
-  return CustomFieldDefinition.scope('userScope').findByPk(id);
+  return CustomFieldDefinition.findByPk(id, {
+    include: [CustomFieldValue],
+  });
 };
 
 export const findByEntityId = async (
@@ -43,22 +50,10 @@ export const findByEntityId = async (
   transaction: options.transaction,
 });
 
-export const findByEntityIds = async (
-  modelType: string,
-  entityIds: string[],
-  options: any = {},
-): Promise<CustomFieldDefinition[]> => CustomFieldDefinition.findAll({
-  where: {
-    modelType,
-    entityId: entityIds,
-  },
-  transaction: options.transaction,
-  raw: true,
-});
-
 export const findByWhere = (where): Promise<CustomFieldDefinition | null> =>
-  CustomFieldDefinition.scope('userScope').findOne({
+  CustomFieldDefinition.findOne({
     where,
+    include: [CustomFieldValue],
   });
 
 export const findDefinitionsByModels = async (
@@ -68,6 +63,7 @@ export const findDefinitionsByModels = async (
   const query: WhereOptions<CreateCustomFieldDefinition> = { modelType: { [Op.in]: modelTypes } };
   return CustomFieldDefinition.findAll({
     where: query,
+    include: [CustomFieldValue],
     transaction: options?.transaction,
   });
 };
@@ -76,7 +72,7 @@ export const update = async (
   id: string,
   data: UpdateCustomFieldDefinition,
 ): Promise<CustomFieldDefinition> => {
-  const updatedDefinition = (await CustomFieldDefinition.scope('userScope').update(data, {
+  const updatedDefinition = (await CustomFieldDefinition.update(data, {
     where: { id },
     returning: true,
     individualHooks: true,
@@ -93,6 +89,7 @@ export const disable = (id: string): Promise<any> =>
 export const destroy = (id: string): Promise<any> =>
   CustomFieldDefinition.destroy({ where: { id } });
 
+
 /**
  * Return the names of the required fields for a given model
  */
@@ -100,12 +97,29 @@ export const getRequiredFields = async (
   modelType: string,
   modelId: string | string[],
   entityId: string | string[],
+  onlyNull = false,
 ): Promise<string[]> => {
   const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+  const modelIds = Array.isArray(modelId) ? modelId : [modelId];
+  // const valueQuery = Object.assign(
+  //   {
+  //     modelId: { [Op.in]: modelIds },
+  //   },
+  //   onlyNull ? { value: { [Op.eq]: null } } : null,
+  // );
+  const valueQuery = onlyNull ? {
+    modelId: { [Op.in]: modelIds },
+    value: { [Op.eq]: null },
+  } : {};
   const requiredFields = await CustomFieldDefinition.findAll({
     where: { required: true, modelType, entityId: { [Op.in]: entityIds } },
+    include: {
+      model: CustomFieldValue,
+      where: { ...valueQuery },
+      required: false,
+    },
     logging: true,
   });
-  const requiredFieldsNames = requiredFields.map((definition) => definition.name);
+  const requiredFieldsNames = requiredFields.map(definition => definition.name);
   return [...new Set(requiredFieldsNames)];
 };

package/src/repository/value.ts

@@ -1,9 +1,10 @@
 /* eslint-disable max-len */
+import { Op } from 'sequelize';
+
 import { CustomFieldValue, CustomFieldDefinition } from '../models';
 import * as DefinitionRepo from './definition';
 import { CreateCustomFieldValue, ValuesToUpdate } from '../types/value';
 import logger from '../utils/logger';
-import { MissingDefinitionError } from '../errors';
 
 export const findByModelIdAndDefinition = async (modelId: string, customFieldDefinitionId: string) =>
   CustomFieldValue.findAll({ where: { modelId, customFieldDefinitionId }, include: [CustomFieldDefinition] });
@@ -34,9 +35,8 @@ export const findValuesByModelIds = async (modelIds: string[], options?): Promis
   const { transaction } = options;
   return CustomFieldValue.findAll({
     where: { modelId: modelIds },
+    include: [CustomFieldDefinition],
     transaction,
-    raw: true,
-    nest: true,
   });
 };
 
@@ -48,7 +48,6 @@ export const findValuesByModelIds = async (modelIds: string[], options?): Promis
 export const updateValues = async (
   modelType: string,
   modelId: string,
-  identifiers: string[],
   valuesToUpdate: ValuesToUpdate,
   options: any = {},
 ): Promise<CustomFieldValue[]> => {
@@ -56,27 +55,27 @@ export const updateValues = async (
 
   const names = Object.keys(valuesToUpdate);
   const fieldDefinitions = await DefinitionRepo.findAll(
-    { modelType, name: names, entityId: identifiers },
+    { modelType, name: { [Op.in]: names } },
     { withDisabled: true, transaction: options.transaction },
   ) || [];
 
-  const disabledDefinitions = fieldDefinitions.filter((def) => def.disabled);
+  const disabledDefinitions = fieldDefinitions.filter(def => def.disabled);
   if (fieldDefinitions.length !== names.length) {
-    const missingDefinitions = names.filter((name) => !fieldDefinitions.some((def) => def.name === name));
-    throw new MissingDefinitionError(missingDefinitions);
+    const missingDefinitions = names.filter(name => !fieldDefinitions.some(def => def.name === name));
+    throw new Error(`custom-fields: missing definitions for ${missingDefinitions.join(', ')}`);
   }
 
-  const disabledNames = disabledDefinitions?.map((def) => def.name) || [];
-  const valuesWithDisabledDefinitions = names.filter((name) => disabledNames.includes(name));
+  const disabledNames = disabledDefinitions?.map(def => def.name) || [];
+  const valuesWithDisabledDefinitions = names.filter(name => disabledNames.includes(name));
   if (valuesWithDisabledDefinitions?.length > 0) {
     logger.warn(`custom-fields: trying to update disabled values: ${valuesWithDisabledDefinitions.join(', ')}`);
   }
 
-  const values: CreateCustomFieldValue[] = names.map((name) => ({
+  const values: CreateCustomFieldValue[] = names.map(name => ({
     modelId,
     value: valuesToUpdate[name],
     updatedAt: new Date(),
-    customFieldDefinitionId: fieldDefinitions.find((def) => def.name === name).id,
+    customFieldDefinitionId: fieldDefinitions.find(def => def.name === name).id,
   }));
 
   return Promise.all(values.map(async (value) => {

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

@@ -5,7 +5,7 @@ export const mockEvent = (events: any, eventName, numberOfEvents) => {
   return [
     events.sendObject,
     (): void => {
-      const matchingEvents = events.sendObject.mock.calls.filter((call) => call[0] === eventName);
+      const matchingEvents = events.sendObject.mock.calls.filter(call => call[0] === eventName);
       expect(matchingEvents.length).toEqual(numberOfEvents);
     },
   ];

package/src/tests/mocks/{definition.mock.ts → index.ts}

@@ -30,8 +30,10 @@ export const booleanField = (modelType: string): CreateCustomFieldDefinition =>
 export const enumField = (modelType: string, options): CreateCustomFieldDefinition => ({
   name: 'choices',
   modelType,
-  fieldType: 'select',
-  validation: options,
+  fieldType: 'enum',
+  validation: {
+    enum: options,
+  },
   entityId: uuidv4(),
   entityType: 'fleetId',
 });
@@ -47,7 +49,7 @@ export const rangeField = (modelType: string): CreateCustomFieldDefinition => ({
   entityType: 'fleetId',
 });
 
-// eslint-disable-next-line max-len
+
 export const createDefinition = (defaults: Partial<CustomFieldDefinitionDTO>): CreateCustomFieldDefinition => ({
   name: defaults?.name || `def_${uuidv4()}`,
   modelType: defaults?.modelType || 'TestModel',
@@ -59,8 +61,7 @@ export const createDefinition = (defaults: Partial<CustomFieldDefinitionDTO>): C
 export const createDefinitions = (
   defaults: Partial<CustomFieldDefinitionDTO>,
   length = 1,
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-): CreateCustomFieldDefinition[] => (Array(length).fill({}).map((_) => ({
+): CreateCustomFieldDefinition[] => (Array(length).fill({}).map(_ => ({
   name: defaults?.name || `def_${uuidv4()}`,
   modelType: defaults?.modelType || 'TestModel',
   fieldType: defaults?.fieldType || 'boolean',

package/src/tests/mocks/testModel.ts

@@ -1,5 +1,6 @@
 import { TestModel, AssociatedTestModel } from '../../models';
 
+
 export const createTestModel = (payload = {}) => TestModel.create(payload);
 
 export const createTestModels = (fleetId, total: number) => {
@@ -10,28 +11,22 @@ export const createTestModels = (fleetId, total: number) => {
   return Promise.all<TestModel>(models);
 };
 
-export const upsertTestModel = (payload) => TestModel.upsert(payload);
+export const upsertTestModel = payload => TestModel.upsert(payload);
 
 export const destroyTestModels = () => TestModel.destroy({ truncate: true });
 
-export const getTestModel = (
-  id: string,
-  options = {},
-): Promise<TestModel> => TestModel.findByPk(id, options);
+export const getTestModel = (id: string): Promise<TestModel> => TestModel.findByPk(id);
 
-export const getSomeTestModels = (
-  options = { limit: 1 },
-): Promise<TestModel[]> => TestModel.findAll(options);
+export const getSomeTestModels = (limit = 1): Promise<TestModel[]> => TestModel.findAll({ limit });
 
 export const updateTestModel = (payload, query) => TestModel.update(payload, query);
 
 // Associations
 export const createTestModelWithAssociation = async () => {
   const model = await TestModel.create({});
-  await AssociatedTestModel.create({ testModelId: model.id });
+  const associatedTestModel = await AssociatedTestModel.create({ testModelId: model.id });
   return model;
 };
 
-export const getTestModelWithAssociation = (limit = 1) => TestModel.findAll({
-  limit, include: [AssociatedTestModel],
-});
+export const getTestModelWithAssociation = (limit = 1) => TestModel.findAll({ limit, include: [AssociatedTestModel] });
+

package/src/types/definition/index.ts

@@ -20,3 +20,4 @@ export type UpdateCustomFieldDefinition = Partial<CreateCustomFieldDefinition>;
 export type SerializedCustomFields = {
   [name: string]: CustomFieldDefinitionDTO & { value: any };
 };
+

package/src/types/index.ts

@@ -1,3 +1,5 @@
+import type { Sequelize as InnerSequelize } from 'sequelize-typescript';
+
 export type ModelFetcher = (name: string) => any;
 
 export type ModelOptions = {
@@ -9,7 +11,7 @@ export type ModelOptions = {
 }
 
 export type CustomFieldOptions= {
-  models: ModelOptions[];
-  databaseConfig: any;
-  getUser: () => any;
-};
+    models: ModelOptions[];
+    innerSequelize?: InnerSequelize;
+    databaseConfig: any;
+  };

package/src/types/value/index.ts

@@ -8,7 +8,8 @@ export interface CustomFieldValueDTO {
     deletedAt?: Date;
   }
 
-export type ValuesToUpdate = {[name: string]: any };
 export type CreateCustomFieldValue = Omit<CustomFieldValueDTO, 'id'>;
 export type UpdateCustomFieldValue = ValuesToUpdate;
 export type BulkUpdateCustomFieldValue = Partial<CustomFieldValueDTO>[];
+
+export type ValuesToUpdate = {[name: string]: any };

package/src/utils/db/index.ts

@@ -1,5 +1,4 @@
 import { Sequelize } from 'sequelize-typescript';
-import { QueryTypes } from 'sequelize';
 
 export default (databaseConfig: any): Sequelize => {
   const ENV_DEV = 'test';
@@ -13,9 +12,3 @@ export default (databaseConfig: any): Sequelize => {
   }
   return sequelize;
 };
-
-export const createSequelizeMeta = (sequelize: Sequelize) => sequelize.query(`
-CREATE TABLE IF NOT EXISTS "SequelizeMeta" (
-  name character varying(255) PRIMARY KEY
-);
-`, { type: QueryTypes.SELECT });

package/src/utils/logger/index.ts

@@ -1,6 +1,4 @@
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const Logger = require('@autofleet/logger');
 
-const logger = Logger();
-
-export default logger;
+export default Logger();

package/src/utils/validations/custom.ts

@@ -1,39 +1,56 @@
-/* eslint-disable no-shadow */
-import logger from '../logger';
-import { CustomFieldDefinitionType } from './type';
-import validators from './validators';
+import { CustomFieldDefinitionType } from "../../models/CustomFieldDefinition";
+import logger from "../logger";
 
-export const mustHaveCustomValidation = {
-  [CustomFieldDefinitionType.SELECT]: true,
+enum CustomValidations {
+    ENUM = 'enum',
+    RANGE = 'between'
+  }
+const mustHaveCustomValidation = {
+  [CustomFieldDefinitionType.ENUM]: true,
+};
+  type Validator = (value, validation) => boolean;
+  /**
+   * Validate {@link CustomValidations.ENUM Enum}
+   */
+const validateEnum: Validator = (value, enumValues) => (Array.isArray(enumValues)
+    && enumValues.length > 0
+    && enumValues.includes(value)
+);
+  /**
+   * Validate {@link CustomValidations.RANGE Range}
+   */
+const validateRange: Validator = (value, range) => {
+  const [min, max] = range;
+  if (min === undefined || max === undefined) {
+    return false;
+  }
+  return value >= range.min && value <= range.max;
+};
+  /**
+   * Validators for custom fields
+   */
+const customValidators: { [key: string]: Validator } = {
+  [CustomValidations.ENUM]: validateEnum,
+  [CustomValidations.RANGE]: validateRange,
 };
 
-/**
- * Validates the given validations object against the supported field types and their validators.
- * @return true if the validation is valid, false otherwise.
- */
-export const validateValidation = (valueType, validation) => {
-  if (!validation) {
-    if (mustHaveCustomValidation[valueType]) {
+const customValidation = (value, valueType, validations) => {
+  const validator = customValidators[valueType];
+  const validation = validations[valueType];
+  if (mustHaveCustomValidation[valueType]) {
+    if (!validation) {
       logger.error(`No custom validation for custom field type ${valueType} found`);
-      return false;
+      return false; // TODO: Return better error message
     }
+  }
+  if (!validation) {
     return true;
   }
-  return true;
-};
-
-/**
- * Validates the given value against the custom validation rules for the specified field type.
- * If no custom validation rules are provided, it falls back to the default validation.
- * @returns true if the value is valid according to the validation rules, false otherwise.
- */
-const customValidation = (value, valueType, validation) => {
-  const validator = validators?.[valueType];
-  if (!validation || !validator) {
-    return validateValidation(valueType, validation);
+  if (!validator) {
+    logger.error(`No validator for custom field type ${valueType} found`);
+    return false;
   }
-  // Always allow null values
-  return value === null || validator(value, validation);
+  return validator(value, validation);
 };
 
 export default customValidation;