@condor-labs/ec-events-gateway/src/validate/validate.js

Client to send events to events gateway API

const Joi = require('joi');
const constants = require('../utils/constants');
const {
  PAYLOAD_LARGE,
  INVALID_SCHEMA,
  BAD_PAYLOAD,
  PAYLOAD_REQUIRED,
  MAX_PAYLOAD_SIZE,
  PAYLOAD_VALID,
  MESSAGE_ATTRIBUTES
} = constants;

const validateSize = data => {
  try {
    const payload = JSON.stringify(data);
    const kb = Buffer.byteLength(payload, 'utf8') / 1024;

    if (kb > MAX_PAYLOAD_SIZE) {
      return {
        error: true,
        message: PAYLOAD_LARGE
      };
    }
    return {
      error: false,
      message: PAYLOAD_VALID
    };
  } catch (error) {
    return {
      error: true,
      message: BAD_PAYLOAD
    };
  }
};

const isSchema = schema => {
  if (!schema) return false;

  if (typeof schema !== 'object') return false;

  if (Object.keys(schema).length === 0) return false;

  for (const key in schema) {
    if (!Joi.isSchema(schema[key])) return false;
  }

  return Joi.isSchema(Joi.object(schema));
};

const validateSchema = clientSchema => {
  try {
    const isValid = validateModule.isSchema(clientSchema);

    if (!isValid) {
      return { error: INVALID_SCHEMA };
    }

    return isValid;
  } catch (error) {
    return constants.unhandledError(error.message);
  }
};

const validateParams = (data, clientSchema = null) => {
  try {
    if (!data) return { error: PAYLOAD_REQUIRED };

    let schema = Joi.object({
      type: Joi.string().required(),
      topic: Joi.string().required(),
      data: Joi.object().required()
    });

    if (clientSchema) {
      const result = validateModule.validateSchema(clientSchema);

      if (result && result.error) return result;

      schema = Joi.object({
        type: Joi.string().required(),
        topic: Joi.string().required(),
        data: Joi.object()
          .keys(clientSchema)
          .required()
      });
    }

    const validation = schema.validate(data);

    return validation && validation.error ? validation.error.details : null;
  } catch (error) {
    return constants.unhandledError(error.message);
  }
};

const validateData = data => {
  try {

    const schema = Joi.object({
      topic: Joi.string().required(),
      message: Joi.object().required(),
      messageAttributes: Joi.object()
        .keys({
          name: Joi.string().required(),
          type: Joi.string().required(),
          dataType: Joi.string().required()
        })
        .required()
    });

    if (!data)
      return { error: PAYLOAD_REQUIRED }
        ;
    const result = validateModule.validateSize(data);
    if (result && result.error) return { error: result.message };
    const validation = schema.validate(data);

    return validation && validation.error ? validation.error.details : null;
  } catch (error) {
    return constants.unhandledError(error.message);
  }
};

const formatData = data => {
  const messageAttributes = Object.assign(MESSAGE_ATTRIBUTES, {
    type: data.type
  });

  const newData = {
    topic: data.topic || null,
    message: data.data || null,
    messageAttributes
  };

  return newData;
};

const validateModule = {
  isSchema,
  formatData,
  validateData,
  validateSize,
  validateParams,
  validateSchema
};

module.exports = validateModule;