express5-valid 1.0.1

package/dist/index.mjs

@@ -0,0 +1,851 @@
+// src/arg-error.ts
+var ArgError = class extends Error {
+  field;
+  code;
+  details;
+  params;
+  constructor(field, code, details, params2 = {}) {
+    super(`${field} ${details}`);
+    this.field = field;
+    this.code = code;
+    this.details = details;
+    this.params = params2;
+  }
+  get msg() {
+    return this.details;
+  }
+};
+
+// src/valid-number.ts
+var ValidNumber = class {
+  _value;
+  _name;
+  _isRequired = false;
+  _isNullable = false;
+  _default;
+  _min;
+  _max;
+  _isInteger = false;
+  _isPositive = false;
+  _isNegative = false;
+  _oneOf;
+  constructor(value, name) {
+    this._value = value;
+    this._name = name;
+  }
+  error(code, details, params2 = {}) {
+    throw new ArgError(`${this._name}`, code, details, params2);
+  }
+  get required() {
+    this._isRequired = true;
+    return this;
+  }
+  get nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  default(v) {
+    this._default = v;
+    return this;
+  }
+  min(n) {
+    this._min = n;
+    return this;
+  }
+  max(n) {
+    this._max = n;
+    return this;
+  }
+  get integer() {
+    this._isInteger = true;
+    return this;
+  }
+  get positive() {
+    this._isPositive = true;
+    return this;
+  }
+  get negative() {
+    this._isNegative = true;
+    return this;
+  }
+  between(min, max) {
+    this._min = min;
+    this._max = max;
+    return this;
+  }
+  oneOf(values) {
+    this._oneOf = values;
+    return this;
+  }
+  get value() {
+    let val = this._value;
+    if (val === void 0 && this._default !== void 0) {
+      val = this._default;
+    }
+    if (val === void 0) {
+      if (this._isRequired) {
+        this.error("REQUIRED", "is required");
+      }
+      return void 0;
+    }
+    if (val === null) {
+      if (!this._isNullable) {
+        this.error("NOT_NULLABLE", "cannot be null");
+      }
+      return null;
+    }
+    let num;
+    if (typeof val === "number") {
+      num = val;
+    } else if (typeof val === "string") {
+      num = parseFloat(val);
+    } else {
+      this.error("INVALID_TYPE", "must be a number", { expected: "number" });
+    }
+    if (isNaN(num)) {
+      this.error("INVALID_NUMBER", "must be a valid number");
+    }
+    if (this._isInteger && !Number.isInteger(num)) {
+      this.error("NOT_INTEGER", "must be an integer");
+    }
+    if (this._isPositive && num <= 0) {
+      this.error("NOT_POSITIVE", "must be positive");
+    }
+    if (this._isNegative && num >= 0) {
+      this.error("NOT_NEGATIVE", "must be negative");
+    }
+    if (this._min !== void 0 && num < this._min) {
+      this.error("MIN_VALUE", `must be at least ${this._min}`, { min: this._min });
+    }
+    if (this._max !== void 0 && num > this._max) {
+      this.error("MAX_VALUE", `must be at most ${this._max}`, { max: this._max });
+    }
+    if (this._oneOf !== void 0 && !this._oneOf.includes(num)) {
+      this.error("NOT_IN_LIST", `must be one of: ${this._oneOf.join(", ")}`, { allowed: this._oneOf });
+    }
+    return num;
+  }
+};
+
+// src/valid-string.ts
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var URL_REGEX = /^https?:\/\/.+/;
+var ValidString = class {
+  _value;
+  _name;
+  _isRequired = false;
+  _isNullable = false;
+  _default;
+  _minLength;
+  _maxLength;
+  _pattern;
+  _isEmail = false;
+  _isUrl = false;
+  _shouldTrim = false;
+  _toLowercase = false;
+  _toUppercase = false;
+  _oneOf;
+  constructor(value, name) {
+    this._value = value;
+    this._name = name;
+  }
+  error(code, details, params2 = {}) {
+    throw new ArgError(`${this._name}`, code, details, params2);
+  }
+  get required() {
+    this._isRequired = true;
+    return this;
+  }
+  get nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  default(v) {
+    this._default = v;
+    return this;
+  }
+  minLength(n) {
+    this._minLength = n;
+    return this;
+  }
+  maxLength(n) {
+    this._maxLength = n;
+    return this;
+  }
+  pattern(regex) {
+    this._pattern = regex;
+    return this;
+  }
+  get email() {
+    this._isEmail = true;
+    return this;
+  }
+  get url() {
+    this._isUrl = true;
+    return this;
+  }
+  get trim() {
+    this._shouldTrim = true;
+    return this;
+  }
+  get lowercase() {
+    this._toLowercase = true;
+    return this;
+  }
+  get uppercase() {
+    this._toUppercase = true;
+    return this;
+  }
+  oneOf(values) {
+    this._oneOf = values;
+    return this;
+  }
+  get value() {
+    let val = this._value;
+    if (val === void 0 && this._default !== void 0) {
+      val = this._default;
+    }
+    if (val === void 0) {
+      if (this._isRequired) {
+        this.error("REQUIRED", "is required");
+      }
+      return void 0;
+    }
+    if (val === null) {
+      if (!this._isNullable) {
+        this.error("NOT_NULLABLE", "cannot be null");
+      }
+      return null;
+    }
+    if (typeof val !== "string") {
+      this.error("INVALID_TYPE", "must be a string", { expected: "string" });
+    }
+    let str = val;
+    if (this._shouldTrim) {
+      str = str.trim();
+    }
+    if (this._toLowercase) {
+      str = str.toLowerCase();
+    }
+    if (this._toUppercase) {
+      str = str.toUpperCase();
+    }
+    if (this._minLength !== void 0 && str.length < this._minLength) {
+      this.error("MIN_LENGTH", `must be at least ${this._minLength} characters`, { min: this._minLength });
+    }
+    if (this._maxLength !== void 0 && str.length > this._maxLength) {
+      this.error("MAX_LENGTH", `must be at most ${this._maxLength} characters`, { max: this._maxLength });
+    }
+    if (this._pattern !== void 0 && !this._pattern.test(str)) {
+      this.error("PATTERN_MISMATCH", "does not match required pattern");
+    }
+    if (this._isEmail && !EMAIL_REGEX.test(str)) {
+      this.error("INVALID_EMAIL", "must be a valid email");
+    }
+    if (this._isUrl && !URL_REGEX.test(str)) {
+      this.error("INVALID_URL", "must be a valid URL");
+    }
+    if (this._oneOf !== void 0 && !this._oneOf.includes(str)) {
+      this.error("NOT_IN_LIST", `must be one of: ${this._oneOf.join(", ")}`, { allowed: this._oneOf });
+    }
+    return str;
+  }
+};
+
+// src/valid-boolean.ts
+var ValidBoolean = class {
+  _value;
+  _name;
+  _isRequired = false;
+  _isNullable = false;
+  _default;
+  constructor(value, name) {
+    this._value = value;
+    this._name = name;
+  }
+  error(code, details) {
+    throw new ArgError(`${this._name}`, code, details);
+  }
+  get required() {
+    this._isRequired = true;
+    return this;
+  }
+  get nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  default(v) {
+    this._default = v;
+    return this;
+  }
+  get value() {
+    let val = this._value;
+    if (val === void 0 && this._default !== void 0) {
+      val = this._default;
+    }
+    if (val === void 0) {
+      if (this._isRequired) {
+        this.error("REQUIRED", "is required");
+      }
+      return void 0;
+    }
+    if (val === null) {
+      if (!this._isNullable) {
+        this.error("NOT_NULLABLE", "cannot be null");
+      }
+      return null;
+    }
+    let bool;
+    if (typeof val === "boolean") {
+      bool = val;
+    } else if (val === "true" || val === 1) {
+      bool = true;
+    } else if (val === "false" || val === 0) {
+      bool = false;
+    } else {
+      this.error("INVALID_TYPE", "must be a boolean");
+    }
+    return bool;
+  }
+};
+
+// src/valid-array.ts
+var EMAIL_REGEX2 = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var URL_REGEX2 = /^https?:\/\/.+/;
+var ValidArray = class {
+  _value;
+  _name;
+  _isRequired = false;
+  _isNullable = false;
+  _default;
+  _minLength;
+  _maxLength;
+  _elementValidator;
+  constructor(value, name) {
+    this._value = value;
+    this._name = name;
+  }
+  error(code, details, params2 = {}) {
+    throw new ArgError(`${this._name}`, code, details, params2);
+  }
+  elementError(code, details, index, params2 = {}) {
+    throw new ArgError(
+      `${this._name}`,
+      "ARRAY_ELEMENT",
+      `element at index ${index} ${details}`,
+      { index, code, ...params2 }
+    );
+  }
+  get required() {
+    this._isRequired = true;
+    return this;
+  }
+  get nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  default(v) {
+    this._default = v;
+    return this;
+  }
+  minLength(n) {
+    this._minLength = n;
+    return this;
+  }
+  maxLength(n) {
+    this._maxLength = n;
+    return this;
+  }
+  ofNumbers(config) {
+    this._elementValidator = (val, index) => {
+      let num;
+      if (typeof val === "number") {
+        num = val;
+      } else if (typeof val === "string") {
+        num = parseFloat(val);
+      } else {
+        this.elementError("INVALID_TYPE", "must be a number", index, { expected: "number" });
+      }
+      if (isNaN(num)) {
+        this.elementError("INVALID_NUMBER", "must be a valid number", index);
+      }
+      if (config) {
+        if (config.integer && !Number.isInteger(num)) {
+          this.elementError("NOT_INTEGER", "must be an integer", index);
+        }
+        if (config.positive && num <= 0) {
+          this.elementError("NOT_POSITIVE", "must be positive", index);
+        }
+        if (config.negative && num >= 0) {
+          this.elementError("NOT_NEGATIVE", "must be negative", index);
+        }
+        if (config.min !== void 0 && num < config.min) {
+          this.elementError("MIN_VALUE", `must be at least ${config.min}`, index, { min: config.min });
+        }
+        if (config.max !== void 0 && num > config.max) {
+          this.elementError("MAX_VALUE", `must be at most ${config.max}`, index, { max: config.max });
+        }
+      }
+      return num;
+    };
+    return this;
+  }
+  ofStrings(config) {
+    this._elementValidator = (val, index) => {
+      if (typeof val !== "string") {
+        this.elementError("INVALID_TYPE", "must be a string", index, { expected: "string" });
+      }
+      let str = val;
+      if (config) {
+        if (config.trim) {
+          str = str.trim();
+        }
+        if (config.minLength !== void 0 && str.length < config.minLength) {
+          this.elementError("MIN_LENGTH", `must be at least ${config.minLength} characters`, index, { min: config.minLength });
+        }
+        if (config.maxLength !== void 0 && str.length > config.maxLength) {
+          this.elementError("MAX_LENGTH", `must be at most ${config.maxLength} characters`, index, { max: config.maxLength });
+        }
+        if (config.pattern && !config.pattern.test(str)) {
+          this.elementError("PATTERN_MISMATCH", "does not match required pattern", index);
+        }
+        if (config.email && !EMAIL_REGEX2.test(str)) {
+          this.elementError("INVALID_EMAIL", "must be a valid email", index);
+        }
+        if (config.url && !URL_REGEX2.test(str)) {
+          this.elementError("INVALID_URL", "must be a valid URL", index);
+        }
+      }
+      return str;
+    };
+    return this;
+  }
+  ofBooleans() {
+    this._elementValidator = (val, index) => {
+      if (typeof val === "boolean") {
+        return val;
+      }
+      if (val === "true" || val === 1) {
+        return true;
+      }
+      if (val === "false" || val === 0) {
+        return false;
+      }
+      this.elementError("INVALID_TYPE", "must be a boolean", index, { expected: "boolean" });
+    };
+    return this;
+  }
+  ofObjects(validator) {
+    this._elementValidator = (val, index) => {
+      if (val === null || typeof val !== "object" || Array.isArray(val)) {
+        this.elementError("INVALID_TYPE", "must be an object", index, { expected: "object" });
+      }
+      try {
+        return validator(val, index);
+      } catch (e) {
+        if (e instanceof ArgError) {
+          throw new ArgError(
+            `${this._name}[${index}].${e.field}`,
+            e.code,
+            e.details,
+            e.params
+          );
+        }
+        throw e;
+      }
+    };
+    return this;
+  }
+  get value() {
+    let val = this._value;
+    if (val === void 0 && this._default !== void 0) {
+      val = this._default;
+    }
+    if (val === void 0) {
+      if (this._isRequired) {
+        this.error("REQUIRED", "is required");
+      }
+      return void 0;
+    }
+    if (val === null) {
+      if (!this._isNullable) {
+        this.error("NOT_NULLABLE", "cannot be null");
+      }
+      return null;
+    }
+    if (!Array.isArray(val)) {
+      this.error("INVALID_TYPE", "must be an array", { expected: "array" });
+    }
+    if (this._minLength !== void 0 && val.length < this._minLength) {
+      this.error("ARRAY_MIN_LENGTH", `must have at least ${this._minLength} elements`, { min: this._minLength });
+    }
+    if (this._maxLength !== void 0 && val.length > this._maxLength) {
+      this.error("ARRAY_MAX_LENGTH", `must have at most ${this._maxLength} elements`, { max: this._maxLength });
+    }
+    if (this._elementValidator) {
+      const validated = val.map((item, index) => this._elementValidator(item, index));
+      return validated;
+    }
+    return val;
+  }
+};
+
+// src/valid-date.ts
+var ValidDate = class {
+  _value;
+  _name;
+  _isRequired = false;
+  _isNullable = false;
+  _default;
+  _min;
+  _max;
+  _isPast = false;
+  _isFuture = false;
+  constructor(value, name) {
+    this._value = value;
+    this._name = name;
+  }
+  error(code, details, params2 = {}) {
+    throw new ArgError(`${this._name}`, code, details, params2);
+  }
+  get required() {
+    this._isRequired = true;
+    return this;
+  }
+  get nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  default(v) {
+    this._default = v;
+    return this;
+  }
+  min(date) {
+    this._min = date;
+    return this;
+  }
+  max(date) {
+    this._max = date;
+    return this;
+  }
+  get past() {
+    this._isPast = true;
+    return this;
+  }
+  get future() {
+    this._isFuture = true;
+    return this;
+  }
+  get value() {
+    let val = this._value;
+    if (val === void 0 && this._default !== void 0) {
+      val = this._default;
+    }
+    if (val === void 0) {
+      if (this._isRequired) {
+        this.error("REQUIRED", "is required");
+      }
+      return void 0;
+    }
+    if (val === null) {
+      if (!this._isNullable) {
+        this.error("NOT_NULLABLE", "cannot be null");
+      }
+      return null;
+    }
+    let date;
+    if (val instanceof Date) {
+      date = val;
+    } else if (typeof val === "string" || typeof val === "number") {
+      date = new Date(val);
+    } else {
+      this.error("INVALID_TYPE", "must be a date", { expected: "date" });
+    }
+    if (isNaN(date.getTime())) {
+      this.error("INVALID_DATE", "must be a valid date");
+    }
+    const now = /* @__PURE__ */ new Date();
+    if (this._isPast && date >= now) {
+      this.error("DATE_NOT_PAST", "must be in the past");
+    }
+    if (this._isFuture && date <= now) {
+      this.error("DATE_NOT_FUTURE", "must be in the future");
+    }
+    if (this._min !== void 0 && date < this._min) {
+      this.error("DATE_MIN", `must be after ${this._min.toISOString()}`, { min: this._min.toISOString() });
+    }
+    if (this._max !== void 0 && date > this._max) {
+      this.error("DATE_MAX", `must be before ${this._max.toISOString()}`, { max: this._max.toISOString() });
+    }
+    return date;
+  }
+};
+
+// src/valid-enum.ts
+var ValidEnum = class {
+  _value;
+  _name;
+  _allowedValues;
+  _isRequired = false;
+  _isNullable = false;
+  _default;
+  constructor(value, name, allowedValues) {
+    this._value = value;
+    this._name = name;
+    this._allowedValues = allowedValues;
+  }
+  error(code, details, params2 = {}) {
+    throw new ArgError(`${this._name}`, code, details, params2);
+  }
+  get required() {
+    this._isRequired = true;
+    return this;
+  }
+  get nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  default(v) {
+    this._default = v;
+    return this;
+  }
+  get value() {
+    let val = this._value;
+    if (val === void 0 && this._default !== void 0) {
+      val = this._default;
+    }
+    if (val === void 0) {
+      if (this._isRequired) {
+        this.error("REQUIRED", "is required");
+      }
+      return void 0;
+    }
+    if (val === null) {
+      if (!this._isNullable) {
+        this.error("NOT_NULLABLE", "cannot be null");
+      }
+      return null;
+    }
+    if (!this._allowedValues.includes(val)) {
+      this.error("NOT_IN_LIST", `must be one of: ${this._allowedValues.join(", ")}`, { allowed: this._allowedValues });
+    }
+    return val;
+  }
+};
+
+// src/valid-object.ts
+var ValidObject = class {
+  _value;
+  _name;
+  _validator;
+  _isRequired = false;
+  _isNullable = false;
+  _default;
+  constructor(value, name, validator) {
+    this._value = value;
+    this._name = name;
+    this._validator = validator;
+  }
+  error(code, details, params2 = {}) {
+    throw new ArgError(`${this._name}`, code, details, params2);
+  }
+  get required() {
+    this._isRequired = true;
+    return this;
+  }
+  get nullable() {
+    this._isNullable = true;
+    return this;
+  }
+  default(v) {
+    this._default = v;
+    return this;
+  }
+  get value() {
+    let val = this._value;
+    if (val === void 0 && this._default !== void 0) {
+      val = this._default;
+    }
+    if (val === void 0) {
+      if (this._isRequired) {
+        this.error("REQUIRED", "is required");
+      }
+      return void 0;
+    }
+    if (val === null) {
+      if (!this._isNullable) {
+        this.error("NOT_NULLABLE", "cannot be null");
+      }
+      return null;
+    }
+    if (typeof val !== "object" || Array.isArray(val)) {
+      this.error("INVALID_TYPE", "must be an object", { expected: "object" });
+    }
+    try {
+      const validated = this._validator(val);
+      return validated;
+    } catch (e) {
+      if (e instanceof ArgError) {
+        throw new ArgError(
+          `${this._name}.${e.field}`,
+          e.code,
+          e.details,
+          e.params
+        );
+      }
+      throw e;
+    }
+  }
+};
+
+// src/valid-base.ts
+var ValidBase = class {
+  _value;
+  _name;
+  constructor(value, name) {
+    this._value = value;
+    this._name = name;
+  }
+  get number() {
+    return new ValidNumber(this._value, this._name);
+  }
+  get string() {
+    return new ValidString(this._value, this._name);
+  }
+  get boolean() {
+    return new ValidBoolean(this._value, this._name);
+  }
+  get array() {
+    return new ValidArray(this._value, this._name);
+  }
+  get date() {
+    return new ValidDate(this._value, this._name);
+  }
+  enum(allowedValues) {
+    return new ValidEnum(this._value, this._name, allowedValues);
+  }
+  object(validator) {
+    return new ValidObject(this._value, this._name, validator);
+  }
+};
+
+// src/middleware.ts
+import { AsyncLocalStorage } from "node:async_hooks";
+var requestStorage = new AsyncLocalStorage();
+function getContext() {
+  const ctx = requestStorage.getStore();
+  if (!ctx) {
+    throw new Error("body/params must be called inside validMiddleware context");
+  }
+  return ctx;
+}
+function validMiddleware(req, _res, next) {
+  const context = {
+    body: req.body,
+    params: req.params
+  };
+  requestStorage.run(context, next);
+}
+
+// src/valid-error-handler.ts
+var validErrorHandler = (error, req, res, next) => {
+  if (error instanceof ArgError) {
+    res.status(400).json({
+      error: error.message,
+      code: 400,
+      errorCode: error.code,
+      params: error.params,
+      field: error.field,
+      url: req.originalUrl,
+      message: error.msg
+    });
+  } else {
+    next(error);
+  }
+};
+var valid_error_handler_default = validErrorHandler;
+
+// src/router.ts
+import { Router } from "express";
+function wrapHandler(handler) {
+  return async (req, res, next) => {
+    const context = {
+      body: req.body,
+      params: req.params
+    };
+    requestStorage.run(context, async () => {
+      try {
+        const result = await handler(req, res);
+        if (res.headersSent) {
+          return;
+        }
+        if (result === void 0 || result === null) {
+          res.status(204).end();
+        } else {
+          res.json(result);
+        }
+      } catch (error) {
+        next(error);
+      }
+    });
+  };
+}
+function createJsonRouter() {
+  const expressRouter = Router();
+  const jsonRouter = {
+    router: expressRouter,
+    get: (path, handler, ...middlewares) => {
+      expressRouter.get(path, ...middlewares, wrapHandler(handler));
+      return jsonRouter;
+    },
+    post: (path, handler, ...middlewares) => {
+      expressRouter.post(path, ...middlewares, wrapHandler(handler));
+      return jsonRouter;
+    },
+    put: (path, handler, ...middlewares) => {
+      expressRouter.put(path, ...middlewares, wrapHandler(handler));
+      return jsonRouter;
+    },
+    patch: (path, handler, ...middlewares) => {
+      expressRouter.patch(path, ...middlewares, wrapHandler(handler));
+      return jsonRouter;
+    },
+    delete: (path, handler, ...middlewares) => {
+      expressRouter.delete(path, ...middlewares, wrapHandler(handler));
+      return jsonRouter;
+    }
+  };
+  return jsonRouter;
+}
+
+// src/index.ts
+function body(name) {
+  const ctx = getContext();
+  if (ctx.body === void 0) {
+    throw new ArgError("body", "BODY_UNDEFINED", "body must be defined");
+  }
+  if (ctx.body === null) {
+    throw new ArgError("body", "BODY_NULL", "body must not be null");
+  }
+  if (Array.isArray(ctx.body)) {
+    throw new ArgError("body", "BODY_ARRAY", "body must not be an array");
+  }
+  return validArgument(ctx.body, name);
+}
+function params(name) {
+  const ctx = getContext();
+  return validArgument(ctx.params, name);
+}
+function validArgument(obj, name) {
+  return new ValidBase(obj[name], name);
+}
+export {
+  ArgError,
+  body,
+  createJsonRouter,
+  params,
+  validArgument,
+  valid_error_handler_default as validErrorHandler,
+  validMiddleware
+};
+//# sourceMappingURL=index.mjs.map