@autofleet/sadot 1.1.7-beta → 1.1.7

package/src/api/v1/definition/validations.ts

@@ -1,75 +0,0 @@
-/* eslint-disable newline-per-chained-call */
-import Joi from 'joi';
-import { CustomFieldDefinitionType } from '../../../utils/constants';
-
-const FileValidationSchema = Joi.object({
-  name: Joi.string().required(),
-  type: Joi.string(),
-  size: Joi.string(),
-  addedBy: Joi.string().uuid(),
-});
-const statusValidationObject = Joi.object({
-  value: Joi.string().required(),
-  color: Joi.string().required(),
-});
-/**
- * Schema for the validation of custom field definition
- * The only custom validation is for
- * {@link CustomFieldDefinitionType.SELECT SELECT}
- * and
- * {@link CustomFieldDefinitionType.STATUS STATUS}
- * field types.
- * The rest of the field types are validated by Joi
- */
-const ValidationSchema = Joi.when('fieldType', {
-  is: CustomFieldDefinitionType.SELECT,
-  then: Joi.array().required().items(Joi.string()).min(1).unique(),
-  otherwise: Joi.when('fieldType', {
-    is: CustomFieldDefinitionType.STATUS,
-    then: Joi.array().required().items(statusValidationObject).min(1).unique('value'),
-    otherwise: Joi.forbidden(),
-  }),
-});
-
-const DefaultValueSchema = Joi.when('fieldType', {
-  switch: [
-    { is: CustomFieldDefinitionType.BOOLEAN, then: Joi.boolean().allow(null) },
-    { is: CustomFieldDefinitionType.DATE, then: Joi.date().allow(null) },
-    { is: CustomFieldDefinitionType.DATETIME, then: Joi.date().allow(null) },
-    { is: CustomFieldDefinitionType.FILE, then: Joi.array().items(FileValidationSchema).allow(null) },
-    { is: CustomFieldDefinitionType.IMAGE, then: Joi.array().items(Joi.string().uri()).allow(null) },
-    { is: CustomFieldDefinitionType.NUMBER, then: Joi.number().allow(null) },
-    { is: CustomFieldDefinitionType.SELECT, then: Joi.string().allow(null) },
-    { is: CustomFieldDefinitionType.STATUS, then: Joi.string().allow(null) },
-    { is: CustomFieldDefinitionType.TEXT, then: Joi.string().allow(null) },
-  ],
-});
-
-const CustomFieldDefinitionCreationSchema = Joi.object({
-  name: Joi.string().required(),
-  displayName: Joi.string().required(),
-  validation: ValidationSchema,
-  defaultValue: DefaultValueSchema,
-  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)).required(),
-  entityId: Joi.string().guid().required(),
-  entityType: Joi.string().required(),
-  description: Joi.string(),
-  required: Joi.boolean(),
-  disabled: Joi.boolean(),
-  blockEditingFromUI: Joi.boolean(),
-}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
-
-const CustomFieldDefinitionUpdateSchema = Joi.object({
-  displayName: Joi.string(),
-  validation: ValidationSchema,
-  defaultValue: DefaultValueSchema,
-  fieldType: Joi.string().valid(...Object.values(CustomFieldDefinitionType)),
-  description: Joi.string().allow(null),
-  required: Joi.boolean(),
-  disabled: Joi.boolean(),
-  blockEditingFromUI: Joi.boolean(),
-}).oxor('required', 'blockEditingFromUI', { isPresent: (value) => value === true });
-
-export const validateCustomFieldDefinitionCreation = (payload) => CustomFieldDefinitionCreationSchema.validateAsync(payload, { abortEarly: false });
-
-export const validateCustomFieldDefinitionUpdate = (payload) => CustomFieldDefinitionUpdateSchema.validateAsync(payload, { abortEarly: false });

package/src/api/v1/errors.ts

@@ -1,13 +0,0 @@
-import type { Response } from 'express';
-import { handleError, BadRequest, type LogPayload } from '@autofleet/errors';
-import { ValidationError as InputValidationError } from 'joi';
-import { ValidationError as DatabaseValidationError } from 'sequelize';
-
-export default (err, res: Response, additionalData: LogPayload = undefined) => {
-  let error = err;
-  if ([InputValidationError, DatabaseValidationError].some((ErrClass) => err instanceof ErrClass)) {
-    error = new BadRequest([err], null);
-  }
-
-  return handleError(error, res, additionalData);
-};

package/src/api/v1/index.ts

@@ -1,11 +0,0 @@
-import { Router } from '@autofleet/node-common';
-import logger from '../../utils/logger';
-import definitionRouter from './definition';
-import validatorRouter from './validator';
-
-const router = Router({ logger });
-
-router.use('/custom-field-definitions/:modelName', definitionRouter);
-router.use('/custom-validators/:modelName', validatorRouter);
-
-export default router;

package/src/api/v1/validator/index.ts

@@ -1,141 +0,0 @@
-import { ResourceNotFoundError } from '@autofleet/errors';
-import { Router } from '@autofleet/node-common';
-import { StatusCodes } from 'http-status-codes';
-import handleError from '../errors';
-import * as ValidatorRepo from '../../../repository/validator';
-import validations from './validations';
-import logger from '../../../utils/logger';
-import { validateValidatorSchema } from '../../../utils/validations/schema/validator-schema';
-import type { CustomValidator } from '../../../models';
-
-const router = Router({ logger });
-const ENTITY = 'CustomValidator';
-
-/**
- * Create
- */
-router.post<{ modelName: string }>('/', async (req, res) => {
-  const { modelName } = req.params;
-  try {
-    // Validate the request body
-    const validatedPayload = await validations.create.validateAsync(req.body);
-
-    // Validate that the schema is a valid AJV schema
-    validateValidatorSchema(validatedPayload.schema);
-
-    const validator = await ValidatorRepo.create({
-      ...validatedPayload,
-      modelType: modelName,
-    });
-
-    return res.status(StatusCodes.CREATED).json(validator);
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in create ${ENTITY} request` });
-  }
-});
-
-/**
- * Get all
- */
-router.get<
-  { modelName: string },
-  { validators: CustomValidator[] },
-  never,
-  { entityId?: string; entityType?: string }
->('/', async (req, res) => {
-  try {
-    const { modelName } = req.params;
-    const { entityId, entityType } = req.query;
-
-    const where = {
-      modelType: modelName,
-      ...(entityId && { entityId }),
-      ...(entityType && { entityType }),
-    };
-
-    const validators = await ValidatorRepo.findAll(where);
-
-    return res.status(StatusCodes.OK).json({ validators });
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in get all ${ENTITY} request` });
-  }
-});
-
-/**
- * Get by id
- */
-router.get<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
-  try {
-    const { validatorId, modelName } = req.params;
-    // Include disabled validators when fetching by ID
-    const validators = await ValidatorRepo.findAll({ id: validatorId, modelType: modelName }, { withDisabled: true });
-
-    if (!validators.length) {
-      throw new ResourceNotFoundError('Validator not found');
-    }
-
-    return res.status(StatusCodes.OK).json(validators[0]);
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in get ${ENTITY} request` });
-  }
-});
-
-/**
- * Update
- */
-router.patch<{ modelName: string; validatorId: string }, CustomValidator>('/:validatorId', async (req, res) => {
-  try {
-    const { validatorId } = req.params;
-
-    // Validate the request body
-    const validatedPayload = await validations.update.validateAsync(req.body);
-
-    // If schema is included in the update, validate that it's a valid AJV schema
-    if (validatedPayload.schema) {
-      validateValidatorSchema(validatedPayload.schema);
-    }
-
-    // First verify the validator exists, including disabled ones
-    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
-    if (!existingValidators.length) {
-      throw new ResourceNotFoundError('Validator not found');
-    }
-
-    const [count, validators] = await ValidatorRepo.update(validatorId, validatedPayload);
-
-    if (!count) {
-      throw new ResourceNotFoundError('Validator not found');
-    }
-
-    return res.status(StatusCodes.OK).json(validators[0]);
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in update ${ENTITY} request` });
-  }
-});
-
-/**
- * Delete (disable)
- */
-router.delete<{ modelName: string; validatorId: string }>('/:validatorId', async (req, res) => {
-  try {
-    const { validatorId } = req.params;
-
-    // First verify the validator exists, including disabled ones
-    const existingValidators = await ValidatorRepo.findAll({ id: validatorId }, { withDisabled: true });
-    if (!existingValidators.length) {
-      throw new ResourceNotFoundError('Validator not found');
-    }
-
-    const [count] = await ValidatorRepo.disable(validatorId);
-
-    if (!count) {
-      throw new ResourceNotFoundError('Validator failed to be disabled');
-    }
-
-    return res.status(StatusCodes.NO_CONTENT).send();
-  } catch (err) {
-    return handleError(err, res, { logger, message: `Error in delete ${ENTITY} request` });
-  }
-});
-
-export default router;

package/src/api/v1/validator/validations.ts

@@ -1,38 +0,0 @@
-import Joi from 'joi';
-
-const jsonSchemaValidation = Joi.object().unknown(true);
-
-const schemaObject = Joi.object({
-  type: Joi.string().valid('object'),
-  properties: Joi.object({
-    before: jsonSchemaValidation,
-    after: jsonSchemaValidation,
-  }).required(),
-  required: Joi.array().items(Joi.string()),
-  allOf: Joi.array().items(Joi.object()),
-  anyOf: Joi.array().items(Joi.object()),
-  oneOf: Joi.array().items(Joi.object()),
-  additionalProperties: Joi.alternatives().try(Joi.boolean(), Joi.object()),
-  $id: Joi.string(),
-  $schema: Joi.string(),
-  if: Joi.object(),
-  then: Joi.object(),
-  else: Joi.object(),
-});
-
-const validationSchemas = {
-  create: Joi.object({
-    entityId: Joi.string().uuid().required(),
-    entityType: Joi.string().required(),
-    schema: schemaObject.required(),
-  }),
-
-  update: Joi.object({
-    entityId: Joi.string().uuid(),
-    entityType: Joi.string(),
-    schema: schemaObject,
-    disabled: Joi.boolean(),
-  }).min(1),
-};
-
-export default validationSchemas;

package/src/errors/index.ts

@@ -1,70 +0,0 @@
-/* eslint-disable max-classes-per-file */
-import { BadRequest } from '@autofleet/errors';
-import type { ValidationError } from 'joi';
-import type { EntriesValidationError } from '../types/entries';
-
-export class MissingRequiredCustomFieldError extends BadRequest {
-  constructor(missingFields: string[]) {
-    const err = new Error(`The following custom fields are required: ${missingFields.join(',')}`);
-    super([err], null, missingFields);
-    this.message = 'MISSING_REQUIRED_CUSTOM_FIELDS';
-  }
-}
-
-export class UnsupportedCustomFieldTypeError extends BadRequest {
-  constructor(fieldType: string) {
-    const err = new Error(`Type "${fieldType}" is not supported`);
-    super([err], null, null);
-    this.message = 'UNSUPPORTED_CUSTOM_FIELD_TYPE';
-  }
-}
-
-export class UnsupportedCustomValidationError extends BadRequest {
-  constructor(fieldType: string) {
-    const err = new Error(`Validation for "${fieldType}" is not supported`);
-    super([err], null, null);
-    this.message = 'UNSUPPORTED_CUSTOM_VALIDATION_TYPE';
-  }
-}
-
-export class InvalidFieldTypeError extends BadRequest {
-  constructor(fieldType: string) {
-    const err = new Error(`Invalid field type ${fieldType}`);
-    super([err], null, null);
-    this.message = 'INVALID_FIELD_TYPE';
-  }
-}
-
-export class InvalidValueError extends BadRequest {
-  constructor(value: any, fieldDefinitionName: string, joiValidationError: ValidationError) {
-    const formattedErrorMessage = joiValidationError.message
-      .replace(/"/g, '')
-      .replace('value', `'${fieldDefinitionName}'`);
-
-    const formattedValue = typeof value === 'object' ? JSON.stringify(value) : value;
-
-    const invalidValueMessage = `Invalid Value on field '${fieldDefinitionName}'. ${formattedErrorMessage}. received: '${formattedValue}'`;
-
-    const err = new Error(invalidValueMessage);
-    super([err], null, null);
-    this.message = invalidValueMessage;
-  }
-}
-
-export class InvalidEntriesError extends BadRequest {
-  constructor(modelId: string, validationErrors: EntriesValidationError[]) {
-    const errors = validationErrors.map((validationError) => new InvalidValueError(validationError.value, validationError.fieldDefinitionName, validationError.joiValidationError));
-    super(errors, null, null);
-    this.message = `Invalid entries on ${modelId}\n${validationErrors.map((validationError) => (
-      `${validationError.fieldDefinitionName} - ${validationError.joiValidationError.message}`
-    )).join('\n')}`;
-  }
-}
-
-export class MissingDefinitionError extends BadRequest {
-  constructor(fieldNames: string[]) {
-    const err = new Error(`Missing custom field definition for field ${fieldNames.join(',')}`);
-    super([err], null, null);
-    this.message = 'MISSING_DEFINITION';
-  }
-}

package/src/events/index.ts

@@ -1,63 +0,0 @@
-import Events from '@autofleet/events';
-import { getUser } from '@autofleet/zehut';
-import logger from '../utils/logger';
-import type {
-  CustomFieldDefinition,
-  CustomFieldEntries,
-  CustomFieldValue,
-  CustomValidator,
-} from '../models';
-
-const events = new Events({
-  logger,
-  getUserId: (payload) => payload?.user_id ?? getUser()?.id ?? null,
-});
-
-const KEYS_TO_CONVERT = ['value', 'defaultValue', 'blockEditingFromUI'];
-
-const stringifyBooleans = (savedObject: any, keysToConvert: string[]) => {
-  const savedObjectKeySet = new Set(Object.keys(savedObject));
-  if (keysToConvert.every((key) => !savedObjectKeySet.has(key))) {
-    return savedObject;
-  }
-  return {
-    ...savedObject,
-    ...Object.fromEntries(keysToConvert.map((key) => [key, typeof savedObject[key] === 'boolean' ? savedObject[key].toString() : savedObject[key]])),
-  };
-};
-
-const modelTableMapping = {
-  CustomFieldDefinition: {
-    tableName: 'dim_custom_field_definition',
-    eventVersion: '1',
-  },
-  CustomFieldValue: {
-    tableName: 'dim_custom_field_value',
-    eventVersion: '1',
-  },
-  CustomFieldEntries: {
-    tableName: 'dim_custom_field_entries',
-    eventVersion: '1',
-  },
-};
-
-export const sendDimEvent = (instance: CustomFieldDefinition | CustomFieldValue | CustomFieldEntries | CustomValidator): void => {
-  const mapping = modelTableMapping[instance.constructor.name];
-  if (!mapping) {
-    return;
-  }
-  let objectToSend = instance.get();
-  try {
-    objectToSend = stringifyBooleans(instance.get(), KEYS_TO_CONVERT);
-  } catch (err) {
-    logger.error('Failed to convert booleans in dim event payload', err);
-  }
-
-  events.sendObject(
-    mapping.tableName,
-    mapping.eventVersion,
-    objectToSend,
-  ).catch(() => {});
-};
-
-export default events;

package/src/hooks/create.ts

@@ -1,81 +0,0 @@
-import type { WhereOptions } from 'sequelize';
-import logger from '../utils/logger';
-import * as DefinitionRepo from '../repository/definition';
-import { MissingRequiredCustomFieldError } from '../errors';
-import type { CustomFieldOptions, ModelOptions } from '../types';
-import applyScopeToInstance from '../utils/scopeAttributes';
-import updateInstanceValues from './utils/updateInstanceValues';
-
-/**
- * A hook to create the custom fields when updating a model (more then one instance).
- */
-export const beforeBulkCreate = (options): void => {
-  // This will activate the beforeCreate hook on each updating instance.
-  // eslint-disable-next-line no-param-reassign
-  options.individualHooks = true;
-};
-/**
- * A hook to create the custom fields when updating a model instance.
- * TODO - cleanup if update fail
- */
-export const beforeCreate = (
-  scopeAttributes: string[],
-  modelOptions: ModelOptions = {},
-  sadotOptions: Pick<CustomFieldOptions, 'useCustomFieldsEntries'> = { useCustomFieldsEntries: false },
-) => async (
-  instance,
-  options,
-): Promise<void> => {
-  logger.debug('sadot - before create hook');
-  const { fields } = options;
-  const { include, useEntityIdFromInclude } = modelOptions;
-  const modelType = instance.constructor.name;
-
-  const identifiers = applyScopeToInstance(instance, scopeAttributes);
-
-  const where: WhereOptions = {
-    modelType,
-    disabled: false,
-    ...(!useEntityIdFromInclude && { entityId: identifiers }),
-  };
-  const fieldDefinitions = await DefinitionRepo.findAll(where, { withDisabled: false, transaction: options.transaction, include: include?.(identifiers) });
-  const requiredFieldsNames = Array.from(new Set(fieldDefinitions.filter(({ required }) => required).map(({ name }) => name)));
-
-  const fieldsWithDefaultValue = fieldDefinitions.filter((def) => ![null, undefined].includes(def.defaultValue));
-  if (fieldsWithDefaultValue.length) {
-    // eslint-disable-next-line no-param-reassign
-    instance.customFields ||= {};
-    fieldsWithDefaultValue.filter((def) => (instance.customFields?.[def.name] === undefined)).forEach(({ name, defaultValue }) => {
-      // eslint-disable-next-line no-param-reassign
-      instance.customFields[name] = defaultValue;
-    });
-  }
-
-  const { customFields } = instance;
-  const fieldsNames = Object.keys(customFields ?? {});
-  const missingFields = requiredFieldsNames.filter((name) => !fieldsNames.includes(name));
-  if (missingFields?.length) {
-    throw new MissingRequiredCustomFieldError(missingFields);
-  }
-
-  const customFieldsIdx = fields.indexOf('customFields');
-  if (customFieldsIdx === -1 || !customFields || !Object.keys(customFields).length) {
-    // After checking for required fields and fields with default values, and we have no custom fields.
-    return;
-  }
-
-  await updateInstanceValues({
-    modelId: instance.id,
-    modelType,
-    identifiers,
-    customFields,
-    options: {
-      useCustomFieldsEntries: sadotOptions.useCustomFieldsEntries,
-      transaction: options.transaction,
-      modelOptions,
-    },
-  });
-
-  // eslint-disable-next-line no-param-reassign
-  fields.splice(customFieldsIdx, 1);
-};