ruler-factory/lib/index.js

A flexible, chainable validation rule factory for typeScript/javaScript.

// src/index.ts
import { isArray, isBoolean, isEmpty, isFunction, isNumber, isPlainObject, isString, isSymbol } from "rattail";
var EMAIL_REGEX = /^(?!\.)(?!.*\.\.)([a-z0-9_'+\-\\.]*)[a-z0-9_+-]@([a-z0-9][a-z0-9\\-]*\.)+[a-z]{2,}$/i;
function rulerFactory(generator, extend) {
  return function ruler() {
    var _a;
    const rules = [];
    const ctx = {
      // helpers
      rules,
      addRule,
      generator,
      getMessage,
      // type
      type: "string",
      string,
      number,
      array,
      boolean,
      object,
      symbol,
      bigint,
      null: _null,
      undefined: _undefined,
      true: _true,
      false: _false,
      // validation
      length,
      min,
      max,
      regex,
      required,
      startsWith,
      endsWith,
      includes,
      uppercase,
      lowercase,
      email,
      gt,
      gte,
      lt,
      lte,
      positive,
      negative,
      is,
      not,
      done,
      // transform
      transformer,
      transform,
      trim,
      shouldTrim: false,
      toLowerCase,
      shouldToLowerCase: false,
      toUpperCase,
      shouldToUpperCase: false
    };
    Object.assign(ctx, (_a = extend == null ? void 0 : extend(ctx)) != null ? _a : {});
    function string(message, params) {
      ctx.type = "string";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!isString(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function number(message, params) {
      ctx.type = "number";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!isNumber(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function object(message, params) {
      ctx.type = "object";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!isPlainObject(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function array(message, params) {
      ctx.type = "array";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!isArray(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function boolean(message, params) {
      ctx.type = "boolean";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!isBoolean(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function _true(message, params) {
      ctx.type = "boolean";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (value !== true) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function _false(message, params) {
      ctx.type = "boolean";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (value !== false) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function symbol(message, params) {
      ctx.type = "symbol";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!isSymbol(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function _null(message, params) {
      ctx.type = "null";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (value !== null) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function _undefined(message, params) {
      ctx.type = "undefined";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (value !== void 0) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function bigint(message, params) {
      ctx.type = "bigint";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (typeof value !== "bigint") {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function required(message, params) {
      addRule((value) => {
        if (isEmpty(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function email(message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || !EMAIL_REGEX.test(value))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function min(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || value.length < v)) {
          return new Error(getMessage(message));
        }
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!isNumber(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value < v) {
            return new Error(getMessage(message));
          }
        }
        if (ctx.type === "array" && (!isArray(value) || value.length < v)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function max(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || value.length > v)) {
          return new Error(getMessage(message));
        }
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!isNumber(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value > v) {
            return new Error(getMessage(message));
          }
        }
        if (ctx.type === "array" && (!isArray(value) || value.length > v)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function length(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || value.length !== v)) {
          return new Error(getMessage(message));
        }
        if (ctx.type === "array" && (!isArray(value) || value.length !== v)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function regex(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || !v.test(value))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function startsWith(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || !value.startsWith(v))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function endsWith(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || !value.endsWith(v))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function includes(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || !value.includes(v))) {
          return new Error(getMessage(message));
        }
        if (ctx.type === "array" && (!isArray(value) || !value.includes(v))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function uppercase(message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || value !== value.toUpperCase())) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function lowercase(message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!isString(value) || value !== value.toLowerCase())) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function gt(v, message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!isNumber(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value <= v) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function gte(v, message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!isNumber(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value < v) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function lt(v, message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!isNumber(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value >= v) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function lte(v, message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!isNumber(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value > v) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function positive(message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!isNumber(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value <= 0) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function negative(message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!isNumber(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value >= 0) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function is(v, message, params) {
      addRule((value) => {
        if (!v(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function not(v, message, params) {
      addRule((value) => {
        if (v(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function trim() {
      ctx.shouldTrim = true;
      return ctx;
    }
    function toLowerCase() {
      ctx.shouldToLowerCase = true;
      return ctx;
    }
    function toUpperCase() {
      ctx.shouldToUpperCase = true;
      return ctx;
    }
    function transformer(value) {
      if (ctx.type === "string" && isString(value)) {
        ctx.shouldTrim && (value = value.trim());
        ctx.shouldToLowerCase && (value = value.toLowerCase());
        ctx.shouldToUpperCase && (value = value.toUpperCase());
      }
      return value;
    }
    function transform(v) {
      ctx.transformer = v;
    }
    function addRule(validator, params) {
      rules.push(
        generator((value) => {
          value = ctx.transformer(value);
          return validator(value);
        }, params)
      );
      return ctx;
    }
    function done() {
      return rules;
    }
    function getMessage(message) {
      return isFunction(message) ? message() : message;
    }
    return ctx;
  };
}
export {
  rulerFactory
};