@autofleet/sadot 0.0.1-beta

package/src/models/CustomFieldDefinition.ts

@@ -0,0 +1,140 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
+import {
+  Table,
+  Column,
+  Model,
+  DataType,
+  HasMany,
+  PrimaryKey,
+  BeforeCreate,
+  DefaultScope,
+  AfterSave,
+  Is,
+} from 'sequelize-typescript';
+import { validateValidation } from '../utils/validations/custom';
+import { CustomFieldDefinitionType } from '../utils/validations/type';
+import { CustomFieldValue } from '.';
+import { sendDimEvent } from '../events';
+import { UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } from '../errors';
+
+@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) {
+      if (!validateValidation(this.fieldType, this.validation)) {
+        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
+  createdAt?: Date;
+
+  @Column
+  updatedAt?: Date;
+
+  @Column
+  deletedAt?: Date;
+
+  @HasMany(() => CustomFieldValue)
+  values: CustomFieldValue[];
+
+  @BeforeCreate
+  static displayNameDefaultValue(instance: CustomFieldDefinition): void {
+    if (!instance?.displayName) {
+      // eslint-disable-next-line no-param-reassign
+      instance.displayName = instance.name;
+    }
+  }
+
+  @AfterSave
+  static afterSaveHandler(instance: CustomFieldDefinition, options): void {
+    if (options.transaction) {
+      options.transaction.afterCommit(() => sendDimEvent(instance));
+    } else {
+      sendDimEvent(instance);
+    }
+  }
+}
+
+export default CustomFieldDefinition;

package/src/models/CustomFieldValue.ts

@@ -0,0 +1,114 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
+import {
+  Table,
+  Column,
+  Model,
+  PrimaryKey,
+  DataType,
+  BelongsTo,
+  ForeignKey,
+  BeforeCreate,
+  BeforeUpsert,
+  AfterUpsert,
+  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({
+    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;
+
+  @BeforeBulkCreate
+  @BeforeBulkUpdate
+  static async validateValues(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 {
+        validation,
+        fieldType,
+      } = definitions
+        .find((definition) => definition.id === instance.customFieldDefinitionId);
+      const isValid = validateValue(instance.value, fieldType, validation);
+      if (!isValid) {
+        throw new InvalidValueError(instance.value, fieldType);
+      }
+    });
+  }
+
+  @BeforeUpdate
+  @BeforeCreate
+  @BeforeUpsert
+  static async validateValue(instance: CustomFieldValue): Promise<void> {
+    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);
+    }
+  }
+
+  @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/index.ts

@@ -0,0 +1,101 @@
+/* eslint-disable no-param-reassign */
+import { DataTypes } 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 AssociatedTestModel from './tests/AssociatedTestModel';
+
+const productionModels = [CustomFieldDefinition, CustomFieldValue];
+const testModels = [TestModel, AssociatedTestModel];
+
+const SADOT_MIGRATION_PREFIX = 'sadot-migration';
+const SCHEMA_VERSION = 1;
+const CUSTOM_FIELDS_SCHEMA_VERSION = `${SADOT_MIGRATION_PREFIX}_${SCHEMA_VERSION}`;
+
+const initTables = async (sequelize: Sequelize, getUser): 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 {};
+  });
+
+  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',
+    },
+  );
+  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');
+  }
+};
+
+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,
+};

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,49 @@
+/* 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[];
+}
+
+export default TestModel;

package/src/repository/definition.ts

@@ -0,0 +1,111 @@
+import { Op, WhereOptions } from 'sequelize';
+import { CustomFieldDefinition } from '../models';
+import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
+
+export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
+  CustomFieldDefinition.create(data);
+
+export const findAll = (
+  where: 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,
+  });
+};
+
+export const findByIds = (
+  ids: string[],
+  options: any = { withDisabled: false },
+): Promise<CustomFieldDefinition[]> => findAll({ id: { [Op.in]: ids } }, options);
+
+export const findById = (
+  id: string,
+  options: any = { withDisabled: false },
+): Promise<CustomFieldDefinition | null> => {
+  const { withDisabled } = options;
+  if (withDisabled) {
+    return CustomFieldDefinition.unscoped().scope('userScope').findByPk(id);
+  }
+  return CustomFieldDefinition.scope('userScope').findByPk(id);
+};
+
+export const findByEntityId = async (
+  entityId: string,
+  options: any = {},
+): Promise<CustomFieldDefinition[]> => CustomFieldDefinition.findAll({
+  where: { entityId },
+  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({
+    where,
+  });
+
+export const findDefinitionsByModels = async (
+  modelTypes: string[],
+  options?,
+): Promise<CustomFieldDefinition[]> => {
+  const query: WhereOptions<CreateCustomFieldDefinition> = { modelType: { [Op.in]: modelTypes } };
+  return CustomFieldDefinition.findAll({
+    where: query,
+    transaction: options?.transaction,
+  });
+};
+
+export const update = async (
+  id: string,
+  data: UpdateCustomFieldDefinition,
+): Promise<CustomFieldDefinition> => {
+  const updatedDefinition = (await CustomFieldDefinition.scope('userScope').update(data, {
+    where: { id },
+    returning: true,
+    individualHooks: true,
+  }))[1][0];
+  return updatedDefinition;
+};
+
+export const disable = (id: string): Promise<any> =>
+  CustomFieldDefinition.update(
+    { disabled: true },
+    { where: { id } },
+  );
+
+export const destroy = (id: string): Promise<any> =>
+  CustomFieldDefinition.destroy({ where: { id } });
+
+/**
+ * Return the names of the required fields for a given model
+ */
+export const getRequiredFields = async (
+  modelType: string,
+  modelId: string | string[],
+  entityId: string | string[],
+): Promise<string[]> => {
+  const entityIds = Array.isArray(entityId) ? entityId : [entityId];
+  const requiredFields = await CustomFieldDefinition.findAll({
+    where: { required: true, modelType, entityId: { [Op.in]: entityIds } },
+    logging: true,
+  });
+  const requiredFieldsNames = requiredFields.map((definition) => definition.name);
+  return [...new Set(requiredFieldsNames)];
+};

package/src/repository/value.ts

@@ -0,0 +1,99 @@
+/* eslint-disable max-len */
+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] });
+
+export const create = async (data: CreateCustomFieldValue, withAssociations = false) => {
+  const created = await CustomFieldValue.create(data);
+  if (withAssociations) {
+    const createdWithAssociations = await findByModelIdAndDefinition(created.modelId, created.customFieldDefinitionId);
+    return createdWithAssociations?.[0];
+  }
+  return created;
+};
+
+export const findAllValues = async () => CustomFieldValue.findAll({ include: [CustomFieldDefinition] });
+/**
+ * Get all values for model instance id (with their definitions)
+ * @param modelId
+ * @returns CustomFieldValue[]
+ */
+export const findValuesByModelId = async (modelId: string) => CustomFieldValue.findAll({ where: { modelId }, include: [CustomFieldDefinition] });
+
+/**
+* Retrieves custom field values for given model IDs
+* @param modelIds - An array of model IDs to query custom field values for.
+* @param options - Optional configuration object.
+*/
+export const findValuesByModelIds = async (modelIds: string[], options?): Promise<CustomFieldValue[]> => {
+  const { transaction } = options;
+  return CustomFieldValue.findAll({
+    where: { modelId: modelIds },
+    transaction,
+    raw: true,
+    nest: true,
+  });
+};
+
+/**
+ * Try to update custom field values for a model instance.
+ * Create new value record if not exists, but fails if value's definition not exist.
+ * Return the updated values
+ */
+export const updateValues = async (
+  modelType: string,
+  modelId: string,
+  identifiers: string[],
+  valuesToUpdate: ValuesToUpdate,
+  options: any = {},
+): Promise<CustomFieldValue[]> => {
+  logger.info(`custom-fields: updating values for ${modelType} ${modelId}`, { valuesToUpdate });
+
+  const names = Object.keys(valuesToUpdate);
+  const fieldDefinitions = await DefinitionRepo.findAll(
+    { modelType, name: names, entityId: identifiers },
+    { withDisabled: true, transaction: options.transaction },
+  ) || [];
+
+  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 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) => ({
+    modelId,
+    value: valuesToUpdate[name],
+    updatedAt: new Date(),
+    customFieldDefinitionId: fieldDefinitions.find((def) => def.name === name).id,
+  }));
+
+  return Promise.all(values.map(async (value) => {
+    const [cfv] = await CustomFieldValue.upsert(value, {
+      transaction: options.transaction,
+    });
+    return cfv;
+  }));
+};
+
+export const deleteValue = (
+  id: string,
+  options: any = {},
+): Promise<any> => CustomFieldValue.update(
+  { deletedAt: new Date() },
+  {
+    where: { id },
+    transaction: options.transaction,
+  },
+);

package/src/tests/api/test-api.ts

@@ -0,0 +1,38 @@
+import express, { Router } from 'express';
+import { TestModel } from '../../models';
+
+const app = express();
+app.use(express.json());
+const api = Router();
+
+api.get('/v1/test-models', async (req, res) => {
+  const testModels = await TestModel.findAll();
+  return res.json(testModels);
+});
+
+api.get('/v1/test-models/:testModelId', async (req, res) => {
+  const { params: { testModelId } } = req;
+  const testModel = await TestModel.findByPk(testModelId);
+  return res.json(testModel);
+});
+
+api.post('/v1/test-models', async (req, res) => {
+  const { body } = req;
+  const testModel = await TestModel.create(body);
+  return res.json(testModel);
+});
+
+api.patch('/v1/test-models/:testModelId', async (req, res) => {
+  const { body, params: { testModelId } } = req;
+  const testModel = await TestModel.update(body, {
+    where: {
+      id: testModelId,
+    },
+    returning: true,
+  });
+  return res.json(testModel[1][0]);
+});
+
+app.use('/api', api);
+
+export default app;