@autofleet/sadot 1.2.0 → 1.2.1-beta

package/src/models/CustomFieldDefinition.ts

@@ -0,0 +1,162 @@
+import {
+  Table,
+  Column,
+  Model,
+  DataType,
+  HasMany,
+  PrimaryKey,
+  BeforeCreate,
+  DefaultScope,
+  AfterSave,
+  Is,
+} from 'sequelize-typescript';
+import { CustomFieldDefinitionType } from '../utils/constants';
+import { CustomValidationTypes } from '../utils/validations/validators';
+import { CustomFieldValue } from '.';
+import { sendDimEvent } from '../events';
+import { InvalidValueError, UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } from '../errors';
+import logger from '../utils/logger';
+import { validateValue } from '../utils/validations';
+
+@DefaultScope(() => ({ where: { disabled: false } }))
+@Table({
+  indexes: [
+    {
+      name: 'unique_name_model_type',
+      fields: ['model_type', 'entity_id', 'name'],
+      unique: true,
+    },
+  ],
+  timestamps: true,
+  validate: {
+    validationByType(this: CustomFieldDefinition) {
+      // Verify the validation is provided if needed
+      if (!this.validation && CustomValidationTypes[this.fieldType]) {
+        // TODO: enforce the validation-object schema based on the fieldType
+        logger.error(`No custom validation for custom field type ${this.fieldType} found`);
+        throw new UnsupportedCustomValidationError(`Validation provided for "${this.fieldType}" is not supported`);
+      }
+    },
+  },
+})
+class CustomFieldDefinition extends Model {
+  @PrimaryKey
+  @Column({
+    type: DataType.UUID,
+    defaultValue: DataType.UUIDV4,
+    allowNull: false,
+  })
+    id!: string;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    name!: string;
+
+  @Column({
+    type: DataType.STRING,
+  })
+    displayName?: string; // Defaulted to name with beforeCreate hook
+
+  @Is('SupportedType', (value) => {
+    if (!Object.values(CustomFieldDefinitionType).includes(value as CustomFieldDefinitionType)) {
+      throw new UnsupportedCustomFieldTypeError(`"${value}" is not a supported type.`);
+    }
+  })
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    fieldType!: CustomFieldDefinitionType;
+
+  @Column({
+    type: DataType.JSONB,
+  })
+    validation?: any;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    entityId!: string; /** Client association entity id */
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    entityType!: string; /** Client association entity type (demand source / fleet / etc.) */
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    modelType!: string; /** Model type. e.g. Vehicle / StopPoint / etc. */
+
+  @Column({
+    type: DataType.TEXT,
+  })
+    description?: string;
+
+  @Column({
+    type: DataType.BOOLEAN,
+    defaultValue: false,
+  })
+    required?: boolean;
+
+  @Column({
+    type: DataType.BOOLEAN,
+    defaultValue: false,
+  })
+    disabled?: boolean;
+
+  @Column({
+    type: DataType.JSONB,
+    allowNull: true,
+  })
+    defaultValue?: any;
+
+  @Column
+    createdAt?: Date;
+
+  @Column
+    updatedAt?: Date;
+
+  @Column
+    deletedAt?: Date;
+
+    @Column({
+      type: DataType.BOOLEAN,
+      defaultValue: false,
+      allowNull: false,
+    })
+      blockEditingFromUI!: boolean;
+
+  @HasMany(() => CustomFieldValue)
+    values: CustomFieldValue[];
+
+  @BeforeCreate
+  static displayNameDefaultValue(instance: CustomFieldDefinition): void {
+    if (!instance?.displayName) {
+      // eslint-disable-next-line no-param-reassign
+      instance.displayName = instance.name;
+    }
+    if (![null, undefined].includes(instance.defaultValue)) {
+      const isValid = validateValue(instance.defaultValue, instance.fieldType, instance.validation);
+      if (isValid.error) {
+        throw new InvalidValueError(instance.defaultValue, instance.name, isValid.error);
+      }
+    }
+  }
+
+  @AfterSave
+  static afterSaveHandler(instance: CustomFieldDefinition, options): void {
+    if (options.transaction) {
+      options.transaction.afterCommit(() => sendDimEvent(instance));
+    } else {
+      sendDimEvent(instance);
+    }
+  }
+}
+
+export default CustomFieldDefinition;

package/src/models/CustomFieldEntries.ts

@@ -0,0 +1,81 @@
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  AfterUpsert,
+} from 'sequelize-typescript';
+import { sendDimEvent } from '../events';
+import * as CustomFieldDefinitionRepo from '../repository/definition';
+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
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    /** The ID of the model of which this row hold the custom field entries of, e.g. vehicleId / stopPointId / etc.  */
+    modelId!: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    /** The ID of the entity of which this row hold the custom field entries of, e.g. fleetId / etc.  */
+    entityId!: string;
+
+  @Column({
+    type: DataType.JSONB,
+    allowNull: false,
+    defaultValue: {},
+  })
+    /** A dictionary of customFields and values with the following structure: `{ customFieldName: 'CustomFieldValue' }` */
+    customFields!: Record<string, 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;
+
+  @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/CustomFieldValue.ts

@@ -0,0 +1,118 @@
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  BelongsTo,
+  ForeignKey,
+  BeforeCreate,
+  BeforeUpsert,
+  AfterUpsert,
+  BeforeUpdate,
+  BeforeBulkCreate,
+  BeforeBulkUpdate,
+} from 'sequelize-typescript';
+import { sendDimEvent } from '../events';
+import { CustomFieldDefinition } from '.';
+import { validateFieldType, validateValue } from '../utils/validations';
+import * as CustomFieldDefinitionRepo from '../repository/definition';
+import { InvalidFieldTypeError, InvalidValueError } from '../errors';
+
+@Table({
+  timestamps: true,
+})
+class CustomFieldValue extends Model {
+  @PrimaryKey
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    modelId!: string;
+
+  @PrimaryKey
+  @ForeignKey(() => CustomFieldDefinition)
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    customFieldDefinitionId!: string;
+
+  @Column({
+    type: DataType.JSONB,
+    allowNull: true,
+  })
+    value!: any;
+
+  @Column
+    createdAt?: Date;
+
+  @Column
+    updatedAt?: Date;
+
+  @Column
+    deletedAt?: Date;
+
+  @BelongsTo(() => CustomFieldDefinition, { scope: { disabled: false } })
+    customFieldDefinition: CustomFieldDefinition;
+
+  private static validateValueAgainstDefinition(
+    instance: CustomFieldValue,
+    definition: CustomFieldDefinition,
+  ): void {
+    const { validation, fieldType, name } = definition;
+    const isValidFieldType = validateFieldType(fieldType);
+    if (!isValidFieldType) {
+      throw new InvalidFieldTypeError(fieldType);
+    }
+    // Always allow null values
+    if (instance.value === null) return;
+    const validateValueResponse = validateValue(instance.value, fieldType, validation);
+    if (validateValueResponse.error) {
+      throw new InvalidValueError(instance.value, name, validateValueResponse.error);
+    }
+  }
+
+  @BeforeBulkCreate
+  @BeforeBulkUpdate
+  static async validateCustomFieldValues(instances: CustomFieldValue[]): Promise<void> {
+    const ids = instances.map((instance) => instance.customFieldDefinitionId);
+    const uniqueIds = [...new Set(ids)];
+    const definitions = await CustomFieldDefinitionRepo.findByIds(
+      uniqueIds,
+      { withDisabled: true },
+    );
+
+    if (!definitions || definitions.length !== uniqueIds.length) {
+      throw new Error('Definitions not found');
+    }
+
+    instances.forEach((instance) => {
+      const definition = definitions.find((d) => d.id === instance.customFieldDefinitionId);
+      if (definition) {
+        this.validateValueAgainstDefinition(instance, definition);
+      }
+    });
+  }
+
+  @BeforeUpdate
+  @BeforeCreate
+  @BeforeUpsert
+  static async validateCustomFieldValue(instance: CustomFieldValue): Promise<void> {
+    const { customFieldDefinitionId } = instance;
+    // eslint-disable-next-line max-len
+    const cfd = await CustomFieldDefinitionRepo.findById(customFieldDefinitionId, { withDisabled: true });
+    this.validateValueAgainstDefinition(instance, cfd);
+  }
+
+  @AfterUpsert
+  static afterSaveHandler(instance: CustomFieldValue, options): void {
+    if (options.transaction) {
+      options.transaction.afterCommit(() => sendDimEvent(instance[0]));
+    } else {
+      sendDimEvent(instance[0]);
+    }
+  }
+}
+
+export default CustomFieldValue;

package/src/models/CustomValidator.ts

@@ -0,0 +1,78 @@
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  Default,
+  AfterUpsert,
+  DefaultScope,
+} from 'sequelize-typescript';
+import { randomUUID } from 'node:crypto';
+import { sendDimEvent } from '../events';
+
+@DefaultScope(() => ({ where: { disabled: false } }))
+@Table({
+  timestamps: true,
+})
+class CustomValidator extends Model {
+  @PrimaryKey
+  @Default(() => randomUUID())
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    id!: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    /** The ID of the entity for which this validator is defined, e.g. fleetId / etc. */
+    entityId!: string;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    /** The type of entity (fleet, businessModel, etc). */
+    entityType!: string;
+
+  @Column({
+    type: DataType.STRING,
+    allowNull: false,
+  })
+    /** The type of model this validator applies to. e.g. Vehicle / StopPoint / etc. */
+    modelType!: string;
+
+  @Column({
+    type: DataType.JSONB,
+    allowNull: false,
+  })
+    /** JSON Schema to validate models against */
+    schema!: Record<string, unknown>;
+
+  @Column({
+    type: DataType.BOOLEAN,
+    allowNull: false,
+    defaultValue: false,
+  })
+    disabled!: boolean;
+
+  @Column
+    createdAt?: Date;
+
+  @Column
+    updatedAt?: Date;
+
+  @AfterUpsert
+  static afterSaveHandler(instance: CustomValidator, options): void {
+    if (options.transaction) {
+      options.transaction.afterCommit(() => sendDimEvent(instance));
+    } else {
+      sendDimEvent(instance);
+    }
+  }
+}
+
+export default CustomValidator;

package/src/models/index.ts

@@ -0,0 +1,165 @@
+/* eslint-disable no-param-reassign */
+import { DataTypes, Op } from 'sequelize';
+import type { Sequelize } from 'sequelize-typescript';
+import logger from '../utils/logger';
+import CustomFieldDefinition from './CustomFieldDefinition';
+import CustomFieldValue from './CustomFieldValue';
+import TestModel from './tests/TestModel';
+import ContextAwareTestModel from './tests/contextAwareModels/ContextAwareTestModel';
+import ContextTestModel from './tests/contextAwareModels/ContextTestModel';
+import AssociatedTestModel from './tests/AssociatedTestModel';
+import type { CustomFieldOptions } from '../types';
+import CustomFieldEntries from './CustomFieldEntries';
+import CustomValidator from './CustomValidator';
+
+type ProductionModel = typeof CustomFieldDefinition | typeof CustomFieldValue | typeof CustomFieldEntries | typeof CustomValidator
+interface InitTablesOptions {
+  schemaPrefix?: string
+  schemaVersion?: string
+  useCustomFieldsEntries?: boolean
+}
+
+const productionModels: ProductionModel[] = [CustomFieldDefinition, CustomFieldValue, CustomValidator];
+const testModels = [TestModel, AssociatedTestModel, ContextAwareTestModel, ContextTestModel];
+
+const SADOT_MIGRATION_PREFIX = 'sadot-migration';
+const SCHEMA_VERSION = '49c9dd1d-b1cc-445b-a911-fd349d783110';
+
+const initTables = async (
+  sequelize: Sequelize,
+  getUser: CustomFieldOptions['getUser'],
+  {
+    schemaPrefix = SADOT_MIGRATION_PREFIX,
+    schemaVersion = SCHEMA_VERSION,
+    useCustomFieldsEntries = false,
+  }: InitTablesOptions = {},
+): Promise<void> => {
+  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
+  if (!sequelize.addModels) {
+    throw new Error('sequelize instance must have addModels function');
+  }
+
+  if (useCustomFieldsEntries) {
+    productionModels.push(CustomFieldEntries);
+  }
+
+  sequelize.addModels(productionModels);
+
+  CustomFieldDefinition.addScope('userScope', () => {
+    const user = getUser();
+    if (!user?.permissions) {
+      return {};
+    }
+    return {
+      where: {
+        entityId: [
+          ...Object.keys(user.permissions.fleets),
+          ...Object.keys(user.permissions.businessModels),
+          ...Object.keys(user.permissions.demandSources),
+        ],
+      },
+    };
+  });
+
+  CustomValidator.addScope('userScope', () => {
+    const user = getUser();
+    if (!user?.permissions) {
+      return {};
+    }
+    return {
+      where: {
+        entityId: [
+          ...Object.keys(user.permissions.fleets),
+          ...Object.keys(user.permissions.businessModels),
+          ...Object.keys(user.permissions.demandSources),
+        ],
+      },
+    };
+  });
+
+  logger.info('custom-fields: models added');
+
+  const SequelizeMeta = sequelize.define(
+    'SequelizeMeta',
+    {
+      name: {
+        type: DataTypes.STRING,
+        allowNull: false,
+        unique: true,
+        primaryKey: true,
+        autoIncrement: false,
+      },
+    },
+    {
+      tableName: 'SequelizeMeta',
+      timestamps: false,
+      schema: 'public',
+    },
+  );
+
+  logger.info('custom-fields: starting migrations');
+  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);
+
+  logger.info('custom-fields: migrations', { migrations, currentSadotSchemaVersion, expectedSchemaVersionIndex });
+  if (!currentSadotSchemaVersion || (currentSadotSchemaVersion as any).name !== CUSTOM_FIELDS_SCHEMA_VERSION) {
+    logger.info('custom-fields: syncing models');
+    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 });
+    }
+
+    // Always sync CustomValidator
+    await CustomValidator.sync({ alter: true });
+
+    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) } } });
+    }
+  }
+};
+
+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 });
+  await ContextTestModel.sync({ alter: true });
+  await ContextAwareTestModel.sync({ alter: true });
+  logger.info('custom-fields: test models synced');
+};
+
+export {
+  CustomFieldValue,
+  CustomFieldDefinition,
+  CustomFieldEntries,
+  CustomValidator,
+  TestModel,
+  AssociatedTestModel,
+  ContextAwareTestModel,
+  ContextTestModel,
+  initTables,
+  initTestModels,
+};

package/src/models/tests/AssociatedTestModel.ts

@@ -0,0 +1,57 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  ForeignKey,
+  BelongsTo,
+} from 'sequelize-typescript';
+import TestModel from './TestModel';
+
+@Table({ schema: 'custom-fields', createdAt: false, updatedAt: false })
+class AssociatedTestModel extends Model {
+  @PrimaryKey
+  @Column({
+    type: DataType.UUID,
+    defaultValue: DataType.UUIDV4,
+    allowNull: false,
+  })
+    id!: string;
+
+  @ForeignKey(() => TestModel)
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    testModelId!: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    fleetId: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: true,
+  })
+    businessModelId: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: true,
+  })
+    demandSourceId: string;
+
+  @Column({
+    type: DataType.BOOLEAN,
+  })
+    anotherAttribute?: boolean;
+
+  @BelongsTo(() => TestModel)
+    testModel: TestModel;
+}
+
+export default AssociatedTestModel;

package/src/models/tests/TestModel.ts

@@ -0,0 +1,54 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  HasMany,
+} from 'sequelize-typescript';
+import AssociatedTestModel from './AssociatedTestModel';
+
+@Table({ schema: 'custom-fields', createdAt: false, updatedAt: false })
+class TestModel extends Model {
+  @PrimaryKey
+  @Column({
+    type: DataType.UUID,
+    defaultValue: DataType.UUIDV4,
+    allowNull: false,
+  })
+    id!: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: false,
+  })
+    fleetId: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: true,
+  })
+    businessModelId: string;
+
+  @Column({
+    type: DataType.UUID,
+    allowNull: true,
+  })
+    demandSourceId: string;
+
+  @Column({
+    type: DataType.BOOLEAN,
+  })
+    coolAttribute?: boolean;
+
+  @HasMany(() => AssociatedTestModel)
+    associatedModels: AssociatedTestModel[];
+
+  @Column({
+    type: DataType.VIRTUAL,
+  })
+    customFields?: any;
+}
+
+export default TestModel;