@autofleet/sadot 0.0.1-beta

package/src/tests/helpers/database-config.ts

@@ -0,0 +1,14 @@
+export default {
+  test: {
+    username: process.env.DB_USERNAME || '',
+    password: process.env.DB_PASSWORD || null,
+    database: process.env.DB_NAME || 'sadot_package_test',
+    host: process.env.DB_HOST || '127.0.0.1',
+    dialect: process.env.DB_TYPE || 'postgres',
+    define: {
+      underscored: true,
+      underscoredAll: true,
+    },
+    logging: false,
+  },
+};

package/src/tests/helpers/index.ts

@@ -0,0 +1,15 @@
+import { CustomFieldDefinition, TestModel } from '../../models';
+
+// eslint-disable-next-line import/prefer-default-export
+export const cleanup = async (): Promise<void> => {
+  if (process.env.NODE_ENV === 'test' || process.env.NODE_ENV === 'development') {
+    await CustomFieldDefinition.unscoped().destroy({ where: {} });
+    await TestModel.destroy({ where: {} });
+  }
+};
+
+export const getModel = (name: string) => {
+  // eslint-disable-next-line global-require, @typescript-eslint/no-var-requires
+  const models = require('../../models');
+  return models[name];
+};

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

@@ -0,0 +1,69 @@
+import { v4 as uuidv4 } from 'uuid';
+import { CreateCustomFieldDefinition, CustomFieldDefinitionDTO } from '../../types/definition';
+
+export const coolFieldDefinition: CreateCustomFieldDefinition = {
+  name: 'cool field',
+  modelType: 'TestModel',
+  fieldType: 'number',
+  entityId: uuidv4(),
+  entityType: 'fleetId',
+};
+
+export const coolFieldDefinition2 = {
+  ...coolFieldDefinition,
+  name: 'cool field2',
+};
+
+export const coolFieldDefinition3 = {
+  ...coolFieldDefinition,
+  name: 'cool field3',
+};
+
+export const booleanField = (modelType: string): CreateCustomFieldDefinition => ({
+  name: 'shapeless',
+  modelType,
+  fieldType: 'boolean',
+  entityId: uuidv4(),
+  entityType: 'fleetId',
+});
+
+export const enumField = (modelType: string, options): CreateCustomFieldDefinition => ({
+  name: 'choices',
+  modelType,
+  fieldType: 'select',
+  validation: options,
+  entityId: uuidv4(),
+  entityType: 'fleetId',
+});
+
+export const rangeField = (modelType: string): CreateCustomFieldDefinition => ({
+  name: 'ranges',
+  modelType,
+  fieldType: 'number',
+  validation: {
+    between: [10, 12],
+  },
+  entityId: uuidv4(),
+  entityType: 'fleetId',
+});
+
+// eslint-disable-next-line max-len
+export const createDefinition = (defaults: Partial<CustomFieldDefinitionDTO>): CreateCustomFieldDefinition => ({
+  name: defaults?.name || `def_${uuidv4()}`,
+  modelType: defaults?.modelType || 'TestModel',
+  fieldType: defaults?.fieldType || 'boolean',
+  entityId: defaults?.entityId || uuidv4(),
+  entityType: defaults?.entityType || 'fleetId',
+});
+
+export const createDefinitions = (
+  defaults: Partial<CustomFieldDefinitionDTO>,
+  length = 1,
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+): CreateCustomFieldDefinition[] => (Array(length).fill({}).map((_) => ({
+  name: defaults?.name || `def_${uuidv4()}`,
+  modelType: defaults?.modelType || 'TestModel',
+  fieldType: defaults?.fieldType || 'boolean',
+  entityId: defaults?.entityId || uuidv4(),
+  entityType: defaults?.entityType || 'fleetId',
+})));

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

@@ -0,0 +1,18 @@
+/* eslint-disable no-param-reassign */
+
+export const mockEvent = (events: any, eventName, numberOfEvents) => {
+  events.sendObject = jest.fn();
+  return [
+    events.sendObject,
+    (): void => {
+      const matchingEvents = events.sendObject.mock.calls.filter((call) => call[0] === eventName);
+      expect(matchingEvents.length).toEqual(numberOfEvents);
+    },
+  ];
+};
+
+export const mockDimCustomFieldDefinitionEvent = (events, numberOfEvents) =>
+  mockEvent(events, 'dim_custom_field_definition', numberOfEvents);
+
+export const mockDimCustomFieldValueEvent = (events, numberOfEvents) =>
+  mockEvent(events, 'dim_custom_field_value', numberOfEvents);

package/src/tests/mocks/testModel.ts

@@ -0,0 +1,37 @@
+import { TestModel, AssociatedTestModel } from '../../models';
+
+export const createTestModel = (payload = {}) => TestModel.create(payload);
+
+export const createTestModels = (fleetId, total: number) => {
+  const models = [];
+  for (let i = 0; i < total; i += 1) {
+    models.push(createTestModel({ fleetId }));
+  }
+  return Promise.all<TestModel>(models);
+};
+
+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 getSomeTestModels = (
+  options = { limit: 1 },
+): Promise<TestModel[]> => TestModel.findAll(options);
+
+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 });
+  return model;
+};
+
+export const getTestModelWithAssociation = (limit = 1) => TestModel.findAll({
+  limit, include: [AssociatedTestModel],
+});

package/src/types/definition/index.ts

@@ -0,0 +1,22 @@
+export interface CustomFieldDefinitionDTO {
+    id: string;
+    name: string;
+    displayName?: string;
+    validation?: any;
+    fieldType: string;
+    entityId: string;
+    entityType: string;
+    modelType: string;
+    required?: boolean;
+    description?: string;
+    disabled?: boolean;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+  }
+export type CreateCustomFieldDefinition = Omit<CustomFieldDefinitionDTO, 'id'>;
+export type UpdateCustomFieldDefinition = Partial<CreateCustomFieldDefinition>;
+
+export type SerializedCustomFields = {
+  [name: string]: CustomFieldDefinitionDTO & { value: any };
+};

package/src/types/index.ts

@@ -0,0 +1,15 @@
+export type ModelFetcher = (name: string) => any;
+
+export type ModelOptions = {
+  name: string;
+  scopeAttributes: string[];
+  creationWebhookHandler?: (instance: any) => any;
+  updateWebhookHandler?: (instance: any) => any;
+  deletionWebhookHandler?: (instance: any) => any;
+}
+
+export type CustomFieldOptions= {
+  models: ModelOptions[];
+  databaseConfig: any;
+  getUser: () => any;
+};

package/src/types/value/index.ts

@@ -0,0 +1,14 @@
+export interface CustomFieldValueDTO {
+    id?: string;
+    modelId: string;
+    customFieldDefinitionId: string;
+    value: any;
+    createdAt?: Date;
+    updatedAt?: Date;
+    deletedAt?: Date;
+  }
+
+export type ValuesToUpdate = {[name: string]: any };
+export type CreateCustomFieldValue = Omit<CustomFieldValueDTO, 'id'>;
+export type UpdateCustomFieldValue = ValuesToUpdate;
+export type BulkUpdateCustomFieldValue = Partial<CustomFieldValueDTO>[];

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

@@ -0,0 +1,21 @@
+import { Sequelize } from 'sequelize-typescript';
+import { QueryTypes } from 'sequelize';
+
+export default (databaseConfig: any): Sequelize => {
+  const ENV_DEV = 'test';
+  const env: string = process.env.NODE_ENV || ENV_DEV;
+  const config = databaseConfig[env];
+  let sequelize: Sequelize;
+  if (config.use_env_variable) {
+    sequelize = new Sequelize(process.env[config.use_env_variable], config);
+  } else {
+    sequelize = new Sequelize(config.database, config.username, config.password, config);
+  }
+  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

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

package/src/utils/validations/custom-fields.ts

@@ -0,0 +1,9 @@
+/* eslint-disable import/prefer-default-export */
+import Joi from '@hapi/joi';
+
+const CustomFieldsSchema = Joi.object().pattern(
+  Joi.string(),
+  Joi.any(),
+);
+
+export { CustomFieldsSchema };

package/src/utils/validations/custom.ts

@@ -0,0 +1,39 @@
+/* eslint-disable no-shadow */
+import logger from '../logger';
+import { CustomFieldDefinitionType } from './type';
+import validators from './validators';
+
+export const mustHaveCustomValidation = {
+  [CustomFieldDefinitionType.SELECT]: true,
+};
+
+/**
+ * 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]) {
+      logger.error(`No custom validation for custom field type ${valueType} found`);
+      return false;
+    }
+    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);
+  }
+  // Always allow null values
+  return value === null || validator(value, validation);
+};
+
+export default customValidation;

package/src/utils/validations/index.ts

@@ -0,0 +1,19 @@
+import customValidation from './custom';
+import validateValueType from './type';
+
+const validateValue = (value, valueType, customValidations) => {
+  if (!validateValueType(value, valueType)) {
+    return false;
+  }
+  if (customValidations) {
+    return customValidation(value, valueType, customValidations);
+  }
+
+  // if (validations.required && !value) {
+  //   return false;
+  // }
+
+  return true;
+};
+
+export default validateValue;

package/src/utils/validations/type.ts

@@ -0,0 +1,45 @@
+import Joi from '@hapi/joi';
+/**
+ * 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',
+  SELECT = 'select',
+}
+/**
+ * Validate that the given value is really of type "valueType"
+ * TODO: verify that required field not set to null
+ */
+const validateValueType = (value: unknown, valueType: CustomFieldDefinitionType): boolean => {
+  if (value === null) {
+    // Null is always allowed
+    return true;
+  }
+
+  switch (valueType) {
+    case CustomFieldDefinitionType.TEXT:
+      return typeof value === 'string';
+    case CustomFieldDefinitionType.NUMBER:
+      return typeof value === 'number';
+    case CustomFieldDefinitionType.BOOLEAN:
+      return typeof value === 'boolean';
+    case CustomFieldDefinitionType.DATE:
+    case CustomFieldDefinitionType.DATETIME:
+      return !Joi.date().validate(value).error;
+    case CustomFieldDefinitionType.SELECT:
+      return true; // custom validation
+    case CustomFieldDefinitionType.IMAGE:
+      return !Joi.array().min(1).unique().items(Joi.string().uri())
+        .validate(value).error;
+    default:
+      return false;
+  }
+};
+
+export default validateValueType;

package/src/utils/validations/validators.ts

@@ -0,0 +1,34 @@
+// eslint-disable-next-line no-shadow
+export enum CustomValidations {
+    SELECT = 'select',
+    RANGE = 'between'
+}
+
+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 validators: { [key: string]: Validator } = {
+  [CustomValidations.SELECT]: validateEnum,
+  [CustomValidations.RANGE]: validateRange,
+};
+
+export default validators;

package/tsconfig.json

@@ -0,0 +1,13 @@
+{
+  "compilerOptions": {
+    "target": "es2020",
+    "module": "commonjs",
+    "declaration": true,
+    "outDir": "./dist",
+    "esModuleInterop": true,
+    "experimentalDecorators": true,
+    "emitDecoratorMetadata": true,
+    "allowJs": true
+  },
+  "exclude": ["node_modules", "**/*.test.ts"]
+}