jcc-express-mvc 1.0.0

package/src/validation/method.js

@@ -0,0 +1,168 @@
+const validator = require("validator");
+const { capitalize, getModel } = require("../helpers");
+
+class ValidationMethod {
+  //
+  required(fieldName, value) {
+    return validator.default.isEmpty(value)
+      ? `${capitalize(fieldName)} is required`
+      : false;
+  }
+  //
+  min(fieldName, fieldValue, minValue) {
+    return !validator.default.isLength(fieldValue, { min: minValue })
+      ? `${capitalize(fieldName)} should be minimum of ${minValue} ${
+          minValue <= 1 ? "character" : "characters"
+        }`
+      : false;
+  }
+
+  //
+  max(fieldName, fieldValue, maxValue) {
+    return !validator.default.isLength(fieldValue, { max: maxValue })
+      ? `${capitalize(fieldName)} should be maximum of ${maxValue} ${
+          maxValue <= 1 ? "character" : "characters"
+        }`
+      : false;
+  }
+
+  email(fieldValue) {
+    return !validator.default.isEmail(fieldValue) ? ` Invalid email` : false;
+  }
+
+  bool(fieldName, fieldValue) {
+    return !validator.default.isBoolean(fieldValue)
+      ? `${capitalize(fieldName)} should be a boolean`
+      : false;
+  }
+
+  float(fieldName, fieldValue) {
+    return !validator.default.default.isFloat(fieldValue)
+      ? `${capitalize(fieldName)} should be a float`
+      : false;
+  }
+
+  num(fieldName, fieldValue) {
+    return !validator.default.isNumeric(fieldValue)
+      ? `${capitalize(fieldName)} should only be a number`
+      : false;
+  }
+
+  alpha(fieldName, fieldValue) {
+    return !validator.default.isAlpha(fieldValue)
+      ? `${capitalize(fieldName)} should only contain letters`
+      : false;
+  }
+
+  alphaNum = (fieldName, fieldValue) => {
+    return !validator.default.isAlphanumeric(fieldValue)
+      ? `${capitalize(fieldName)} should only contain letters and numbers`
+      : false;
+  };
+
+  same(fieldNames = [], fieldValues = []) {
+    let [firstFieldName, secondFieldName] = fieldNames;
+    let [firstValue, secondValue] = fieldValues;
+    return validator.default.equals(firstValue, secondValue)
+      ? false
+      : `${capitalize(firstFieldName)} did not match with ${capitalize(
+          secondFieldName
+        )}`;
+  }
+
+  creditCard(fieldName, fieldValue) {
+    return !validator.default.isCreditCard(fieldValue)
+      ? `${capitalize(fieldName)} invalid credit card`
+      : false;
+  }
+
+  url(fieldName, fieldValue) {
+    return !validator.default.isURL(fieldValue)
+      ? `${capitalize(fieldName)} invalid url`
+      : false;
+  }
+
+  decimal(fieldName, fieldValue) {
+    return !validator.default.isDecimal(fieldValue)
+      ? `${capitalize(fieldName)} should be a decimal number`
+      : false;
+  }
+
+  int(fieldName, fieldValue) {
+    return !validator.default.isInt(fieldValue)
+      ? `${capitalize(fieldName)} should be an integer`
+      : false;
+  }
+
+  json(fieldName, fieldValue) {
+    return !validator.default.isJSON(fieldValue)
+      ? `${capitalize(fieldName)} invalid json`
+      : false;
+  }
+
+  async unqiue(fieldName, fieldValue, model) {
+    try {
+      console.log(fieldName);
+      let modelName = getModel(`${capitalize(model)}`);
+      return (await modelName.findOne({ [fieldName]: fieldValue }))
+        ? `${capitalize(fieldName)} already exist`
+        : false;
+    } catch (e) {
+      console.log("db error", e.message);
+    }
+  }
+
+  jwt(fieldName, fieldValue) {
+    return validator.default.isJWT(fieldValue)
+      ? `${capitalize(fieldName)} invalid jwt`
+      : false;
+  }
+
+  postal(fieldName, fieldValue) {
+    return !validator.default.isPostalCode(fieldValue)
+      ? `${capitalize(fieldName)} invalid postal code`
+      : false;
+  }
+
+  nullable() {
+    return false;
+  }
+
+  phone(fieldName, fieldValue) {
+    return !validator.default.isMobilePhone(fieldValue)
+      ? `${capitalize(fieldName)} invalid phone number`
+      : false;
+  }
+
+  slug(fieldName, fieldValue) {
+    return !validator.default.isSlug(fieldValue)
+      ? `${capitalize(fieldName)} invalid slug`
+      : false;
+  }
+
+  skip() {
+    return false;
+  }
+
+  mongoId = (fieldName, fieldValue) => {
+    return !validator.default.isMongoId(fieldValue)
+      ? `${capitalize(fieldName)} invalid mongodb id`
+      : false;
+  };
+
+  request(req, data) {
+    return req.body[data] ? req.body[data] : "";
+  }
+
+  extractValue(data, index) {
+    return data.split(":")[index].replace(/\s/g, "");
+  }
+
+  secondValue(data) {
+    return (
+      data.includes("min:") || data.includes("max:") || data.includes("unique:")
+    );
+  }
+}
+
+module.exports = new ValidationMethod();

package/src/validation/rules.js

@@ -0,0 +1,92 @@
+const ValidationMethod = require("./method");
+exports.rules = async (validation, fieldName, fieldValue, secondValue) => {
+  try {
+    switch (validation) {
+      case "required":
+        return ValidationMethod.required(fieldName, fieldValue);
+
+      case "min" || "min:":
+        return ValidationMethod.min(fieldName, fieldValue, Number(secondValue));
+
+      case "max":
+        return ValidationMethod.max(fieldName, fieldValue, Number(secondValue));
+
+      case "email":
+        return ValidationMethod.email(fieldValue);
+
+      case "unique":
+        return await ValidationMethod.unqiue(
+          fieldName,
+          fieldValue,
+          secondValue
+        );
+
+      case "same":
+        return ValidationMethod.same(fieldName, fieldValue);
+
+      case "alpha":
+        return ValidationMethod.alpha(fieldName, fieldValue);
+
+      case "alphaNum":
+        return ValidationMethod.alphaNum(fieldName, fieldValue);
+
+      case "num":
+        return ValidationMethod.num(fieldName, fieldValue);
+
+      case "bool":
+        return ValidationMethod.bool(fieldName, fieldValue);
+
+      case "float":
+        return ValidationMethod.float(fieldName, fieldValue);
+
+      case "int":
+        return ValidationMethod.int(fieldName, fieldValue);
+
+      case "decimal":
+        return ValidationMethod.decimal(fieldName, fieldValue);
+
+      case "jwt":
+        return ValidationMethod.jwt(fieldName, fieldValue);
+
+      case "json":
+        return ValidationMethod.json(fieldName, fieldValue);
+
+      case "postal":
+        return ValidationMethod.postal(fieldName, fieldValue);
+
+      case "slug":
+        return ValidationMethod.slug(fieldName, fieldValue);
+
+      case "url":
+        return ValidationMethod.url(fieldName, fieldValue);
+
+      case "creditCard":
+        return ValidationMethod.creditCard(fieldName, fieldValue);
+
+      case "mongoId":
+        return ValidationMethod.mongoId(fieldValue);
+
+      case "nullable":
+        return ValidationMethod.nullable(fieldName);
+
+      case "phone":
+        return ValidationMethod.phone(fieldName, fieldValue);
+
+      case "skip":
+        return ValidationMethod.skip();
+
+      default:
+        // return `${validation}() invalid method`;
+        let err = new Error(
+          "validation method",
+          `${validation}() invalid method`
+        );
+        err.validationMethod = `${validation}() invalid method`;
+        throw err;
+    }
+  } catch (error) {
+    let err = new Error("validation error", error);
+    err.validationMethod = error.message;
+    throw err;
+  }
+};