@autofleet/sadot 0.0.1-beta.8 → 0.0.2-beta

package/src/index.ts

@@ -1,10 +1,11 @@
 import type { Application } from 'express';
 import { DataTypes } from 'sequelize';
-import { initTables } from './models';
+import { Sequelize } from 'sequelize-typescript';
+import { initTables, initTestModels } from './models';
 import api from './api';
 import {
   beforeFind,
-  afterFind,
+  enrichResults,
   beforeBulkUpdate,
   beforeUpdate,
   beforeCreate,
@@ -20,19 +21,27 @@ const addHooks = (models: ModelOptions[], getModel: ModelFetcher) => {
   models.forEach(async ({ name, scopeAttributes }) => {
     try {
       const model = getModel(name);
-      if (!model) return;
+      if (!model) {
+        logger.warn('sadot - tried to addHooks to a model that does not exist yet', {
+          name,
+          scopeAttributes,
+        });
+        return;
+      }
       model.rawAttributes.customFields = {
         type: DataTypes.VIRTUAL,
       };
       model.refreshAttributes();
       // TODO: Uncomment after tests are passed
       // model.addHook('afterFind', workaround);
-      model.addHook('beforeFind', beforeFind(scopeAttributes));
-      model.addHook('beforeBulkCreate', beforeBulkCreate);
-      model.addHook('afterFind', afterFind(scopeAttributes));
-      model.addHook('beforeBulkUpdate', beforeBulkUpdate);
-      model.addHook('beforeCreate', beforeCreate(scopeAttributes));
-      model.addHook('beforeUpdate', beforeUpdate(scopeAttributes));
+      model.addHook('beforeFind', 'sadot-beforeFind', beforeFind(scopeAttributes));
+      model.addHook('beforeBulkCreate', 'sadot-beforeBulkCreate', beforeBulkCreate);
+      model.addHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate', beforeBulkUpdate);
+      model.addHook('beforeCreate', 'sadot-beforeCreate', beforeCreate(scopeAttributes));
+      model.addHook('beforeUpdate', 'sadot-beforeUpdate', beforeUpdate(scopeAttributes));
+      model.addHook('afterFind', 'sadot-afterFind', enrichResults(name, scopeAttributes));
+      model.addHook('afterUpdate', 'sadot-afterUpdate', enrichResults(name, scopeAttributes));
+      model.addHook('afterCreate', 'sadot-afterCreate', enrichResults(name, scopeAttributes));
     } catch (e) {
       logger.error(`Could not add custom fields hook to model ${name}. `, e);
     }
@@ -47,19 +56,46 @@ const useCustomFields = async (
   app: Application | null,
   getModel: ModelFetcher,
   options: CustomFieldOptions,
-): Promise<void> => {
-  const { innerSequelize, models } = options;
-  // deepAfterFindWorkAround(sequelize);
+): Promise<Sequelize> => {
+  const { models } = options;
   if (app) {
     app.use('/api', api);
   }
-  if (!innerSequelize) {
-    const moreInnerSequelize = initDB(options.databaseConfig);
-    await initTables(moreInnerSequelize);
-  } else {
-    await initTables(innerSequelize);
+  const sequelize = initDB(options.databaseConfig);
+  if (process.env.NODE_ENV === 'test') {
+    await initTestModels(sequelize);
   }
   addHooks(models, getModel);
+  await initTables(sequelize, options.getUser);
+  logger.debug('sadot - custom fields finished initializing with models', models);
+  return sequelize;
 };
 
 export default useCustomFields;
+
+const removeHooks = (models: ModelOptions[], getModel: ModelFetcher) => {
+  models.forEach(async ({ name }) => {
+    try {
+      const model = getModel(name);
+      if (!model) return;
+      if (model.rawAttributes.customFields) {
+        delete model.rawAttributes.customFields;
+        model.refreshAttributes();
+      }
+      // model.removeHook('afterFind', 'sadot-workaround');
+      model.removeHook('beforeFind', 'sadot-beforeFind');
+      model.removeHook('beforeBulkCreate', 'sadot-beforeBulkCreate');
+      model.removeHook('beforeBulkUpdate', 'sadot-beforeBulkUpdate');
+      model.removeHook('beforeCreate', 'sadot-beforeCreate');
+      model.removeHook('beforeUpdate', 'sadot-beforeUpdate');
+      model.removeHook('afterFind', 'sadot-afterFind');
+      model.removeHook('afterUpdate', 'sadot-afterUpdate');
+    } catch (e) {
+      logger.error(`Could not add custom fields hook to model ${name}. `, e);
+    }
+  });
+};
+
+export const disableCustomFields = (models, getModel) => {
+  removeHooks(models, getModel);
+};

package/src/models/CustomFieldDefinition.ts

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -9,31 +10,32 @@ import {
   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';
-
-/**
- * Supported custom field types
- */
-// eslint-disable-next-line no-shadow
-export enum CustomFieldDefinitionType {
-  NUMBER = 'number',
-  BOOLEAN = 'boolean',
-  DATE = 'date',
-  DATETIME = 'datetime',
-  TEXT = 'text',
-  IMAGE = 'image',
-  ENUM = 'enum',
-}
+import { UnsupportedCustomFieldTypeError, UnsupportedCustomValidationError } from '../errors';
 
 @DefaultScope(() => ({ where: { disabled: false } }))
 @Table({
   indexes: [
-  { name: "unique_name_model_type", fields: ["name", "model_type", "entity_id"], unique: true },
+    {
+      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({
@@ -54,6 +56,11 @@ class CustomFieldDefinition extends Model {
   })
   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,

package/src/models/CustomFieldValue.ts

@@ -1,4 +1,5 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable indent */
 import {
   Table,
   Column,
@@ -13,16 +14,18 @@ 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({
@@ -41,7 +44,7 @@ class CustomFieldValue extends Model {
 
   @Column({
     type: DataType.JSONB,
-    allowNull: false,
+    allowNull: true,
   })
   value!: any;
 
@@ -60,7 +63,6 @@ class CustomFieldValue extends Model {
   @BeforeBulkCreate
   @BeforeBulkUpdate
   static async validateValues(instances: CustomFieldValue[]): Promise<void> {
-    logger.info('CustomFieldValue BeforeBulkCreate/BeforeBulkUpdate', { instances });
     const ids = instances.map((instance) => instance.customFieldDefinitionId);
     const uniqueIds = [...new Set(ids)];
     const definitions = await CustomFieldDefinitionRepo.findByIds(
@@ -80,7 +82,7 @@ class CustomFieldValue extends Model {
         .find((definition) => definition.id === instance.customFieldDefinitionId);
       const isValid = validateValue(instance.value, fieldType, validation);
       if (!isValid) {
-        throw new Error('Invalid value');
+        throw new InvalidValueError(instance.value, fieldType);
       }
     });
   }
@@ -89,20 +91,18 @@ 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 Error('Invalid value');
+      throw new InvalidValueError(instance.value, fieldType);
     }
   }
 
   @AfterUpsert
   static afterSaveHandler(instance: CustomFieldValue, options): void {
-    logger.info('CustomFieldValue afterSave', { instance });
     if (options.transaction) {
       options.transaction.afterCommit(() => sendDimEvent(instance[0]));
     } else {

package/src/models/index.ts

@@ -1,39 +1,94 @@
 /* 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';
 
-// export const CustomFieldDefinition = CustomFieldDefinitionModel;
-// export { default as CustomFieldDefinition } from './custom-field-definition.model';
-
 const productionModels = [CustomFieldDefinition, CustomFieldValue];
-const testModels = [...productionModels, TestModel, AssociatedTestModel];
+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): Promise<void> => {
+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(process.env.NODE_ENV === 'test' ? testModels : productionModels);
-  await sequelize.dropSchema('custom-fields', { logging: false });
-  await sequelize.createSchema('custom-fields', { logging: false });
+  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');
-  await CustomFieldDefinition.sync({ alter: true });
-  await CustomFieldValue.sync({ alter: true });
 
-  if (process.env.NODE_ENV === 'test') {
-    await TestModel.sync({ alter: true });
-    await AssociatedTestModel.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');
+  }
+};
+
+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');
   }
-  logger.info('custom-fields: models synced');
+
+  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 {
@@ -42,4 +97,5 @@ export {
   TestModel,
   AssociatedTestModel,
   initTables,
+  initTestModels,
 };

package/src/repository/definition.ts

@@ -1,24 +1,21 @@
 import { Op, WhereOptions } from 'sequelize';
-import { CustomFieldDefinition, CustomFieldValue } from '../models';
+import { CustomFieldDefinition } from '../models';
 import type { CreateCustomFieldDefinition, UpdateCustomFieldDefinition } from '../types/definition';
 
 export const create = (data: CreateCustomFieldDefinition): Promise<CustomFieldDefinition> =>
   CustomFieldDefinition.create(data);
 
 export const findAll = (
-  query: any,
+  where: any,
   options: any = { withDisabled: false },
 ): Promise<CustomFieldDefinition[]> => {
-  if (options.withDisabled) {
-    return CustomFieldDefinition.unscoped().findAll({
-      where: query,
-      include: [CustomFieldValue],
-    });
-  }
-
-  return CustomFieldDefinition.findAll({
-    where: query,
-    include: [CustomFieldValue],
+  const queryModel = options.withDisabled
+    ? CustomFieldDefinition.unscoped()
+    : CustomFieldDefinition;
+  return queryModel.scope('userScope').findAll({
+    where,
+    transaction: options.transaction,
+    raw: true,
   });
 };
 
@@ -33,13 +30,9 @@ export const findById = (
 ): Promise<CustomFieldDefinition | null> => {
   const { withDisabled } = options;
   if (withDisabled) {
-    return CustomFieldDefinition.unscoped().findByPk(id, {
-      include: [CustomFieldValue],
-    });
+    return CustomFieldDefinition.unscoped().scope('userScope').findByPk(id);
   }
-  return CustomFieldDefinition.findByPk(id, {
-    include: [CustomFieldValue],
-  });
+  return CustomFieldDefinition.scope('userScope').findByPk(id);
 };
 
 export const findByEntityId = async (
@@ -50,10 +43,22 @@ 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.findOne({
+  CustomFieldDefinition.scope('userScope').findOne({
     where,
-    include: [CustomFieldValue],
   });
 
 export const findDefinitionsByModels = async (
@@ -63,7 +68,6 @@ export const findDefinitionsByModels = async (
   const query: WhereOptions<CreateCustomFieldDefinition> = { modelType: { [Op.in]: modelTypes } };
   return CustomFieldDefinition.findAll({
     where: query,
-    include: [CustomFieldValue],
     transaction: options?.transaction,
   });
 };
@@ -72,7 +76,7 @@ export const update = async (
   id: string,
   data: UpdateCustomFieldDefinition,
 ): Promise<CustomFieldDefinition> => {
-  const updatedDefinition = (await CustomFieldDefinition.update(data, {
+  const updatedDefinition = (await CustomFieldDefinition.scope('userScope').update(data, {
     where: { id },
     returning: true,
     individualHooks: true,
@@ -96,27 +100,10 @@ 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);

package/src/repository/value.ts

@@ -1,10 +1,9 @@
 /* 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] });
@@ -35,8 +34,9 @@ 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,6 +48,7 @@ export const findValuesByModelIds = async (modelIds: string[], options?): Promis
 export const updateValues = async (
   modelType: string,
   modelId: string,
+  identifiers: string[],
   valuesToUpdate: ValuesToUpdate,
   options: any = {},
 ): Promise<CustomFieldValue[]> => {
@@ -55,14 +56,14 @@ export const updateValues = async (
 
   const names = Object.keys(valuesToUpdate);
   const fieldDefinitions = await DefinitionRepo.findAll(
-    { modelType, name: { [Op.in]: names } },
+    { 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 Error(`custom-fields: missing definitions for ${missingDefinitions.join(', ')}`);
+    throw new MissingDefinitionError(missingDefinitions);
   }
 
   const disabledNames = disabledDefinitions?.map((def) => def.name) || [];

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

@@ -30,10 +30,8 @@ export const booleanField = (modelType: string): CreateCustomFieldDefinition =>
 export const enumField = (modelType: string, options): CreateCustomFieldDefinition => ({
   name: 'choices',
   modelType,
-  fieldType: 'enum',
-  validation: {
-    enum: options,
-  },
+  fieldType: 'select',
+  validation: options,
   entityId: uuidv4(),
   entityType: 'fleetId',
 });

package/src/tests/mocks/testModel.ts

@@ -14,9 +14,14 @@ export const upsertTestModel = (payload) => TestModel.upsert(payload);
 
 export const destroyTestModels = () => TestModel.destroy({ truncate: true });
 
-export const getTestModel = (id: string): Promise<TestModel> => TestModel.findByPk(id);
-
-export const getSomeTestModels = (limit = 1): Promise<TestModel[]> => TestModel.findAll({ limit });
+export const getTestModel = (
+  id: string,
+  options = {},
+): Promise<TestModel> => TestModel.findByPk(id, options);
+
+export const getSomeTestModels = (
+  options = { limit: 1 },
+): Promise<TestModel[]> => TestModel.findAll(options);
 
 export const updateTestModel = (payload, query) => TestModel.update(payload, query);
 

package/src/types/index.ts

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

package/src/utils/constants/index.ts

@@ -0,0 +1,2 @@
+// eslint-disable-next-line import/prefer-default-export
+export const supportedEntities = ['businessModelId', 'fleetId', 'demandSourceId'];

package/src/utils/db/index.ts

@@ -1,4 +1,5 @@
 import { Sequelize } from 'sequelize-typescript';
+import { QueryTypes } from 'sequelize';
 
 export default (databaseConfig: any): Sequelize => {
   const ENV_DEV = 'test';
@@ -12,3 +13,9 @@ 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,4 +1,6 @@
 // eslint-disable-next-line @typescript-eslint/no-var-requires
 const Logger = require('@autofleet/logger');
 
-export default Logger();
+const logger = Logger();
+
+export default logger;