@linktic/validator 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,159 @@
+import { V as ValidationMessageMap } from './es-QPgrpTLv.js';
+export { s as spanishMessages } from './es-QPgrpTLv.js';
+
+interface ValidationFieldError {
+    field: string;
+    message: string;
+    rule: string;
+    value?: unknown;
+}
+
+type ValidationType = 'string' | 'number' | 'boolean' | 'array' | 'object' | 'date' | 'email' | 'uuid';
+interface ValidationRuleConfig {
+    required?: boolean;
+    type?: ValidationType;
+    minLength?: number;
+    maxLength?: number;
+    min?: number;
+    max?: number;
+    pattern?: RegExp;
+    patternExample?: string;
+    enum?: unknown[];
+    allowedChars?: string;
+    custom?: (value: unknown) => boolean | string;
+}
+interface FieldValidationConfig extends ValidationRuleConfig {
+    field: string;
+    label?: string;
+    messages?: Partial<Record<keyof ValidationRuleConfig, string>>;
+}
+interface SchemaValidationConfig {
+    [field: string]: ValidationRuleConfig & {
+        label?: string;
+        messages?: Partial<Record<keyof ValidationRuleConfig, string>>;
+    };
+}
+interface ValidationResult {
+    isValid: boolean;
+    errors: ValidationFieldError[];
+}
+
+interface ValidatorOptions {
+    stopOnFirstError?: boolean;
+    throwOnError?: boolean;
+}
+declare class FieldValidator {
+    private readonly fieldName;
+    private readonly fieldLabel;
+    private readonly value;
+    private readonly options;
+    private readonly parentErrors;
+    private readonly errors;
+    private isOptional;
+    constructor(fieldName: string, fieldLabel: string, value: unknown, options: ValidatorOptions, parentErrors: ValidationFieldError[]);
+    private get isEmpty();
+    private addError;
+    private shouldSkip;
+    optional(): this;
+    required(message?: string): this;
+    string(message?: string): this;
+    number(message?: string): this;
+    boolean(message?: string): this;
+    array(message?: string): this;
+    object(message?: string): this;
+    type(expectedType: ValidationType, message?: string): this;
+    minLength(min: number, message?: string): this;
+    maxLength(max: number, message?: string): this;
+    private getLength;
+    min(minValue: number, message?: string): this;
+    max(maxValue: number, message?: string): this;
+    range(minValue: number, maxValue: number, message?: string): this;
+    pattern(regex: RegExp, example?: string, message?: string): this;
+    email(message?: string): this;
+    uuid(message?: string): this;
+    date(message?: string): this;
+    enum(allowedValues: unknown[], message?: string): this;
+    allowedChars(chars: string, message?: string): this;
+    custom(validator: (value: unknown) => boolean | string, message?: string): this;
+    nullable(): this;
+}
+declare class Validator<T extends object = object> {
+    private readonly data;
+    private readonly errors;
+    private readonly options;
+    constructor(data: T, options?: ValidatorOptions);
+    field(fieldName: string, label?: string): FieldValidator;
+    private getNestedValue;
+    schema(config: SchemaValidationConfig): this;
+    validate(): void;
+    getResult(): ValidationResult;
+    getErrors(): ValidationFieldError[];
+    isValid(): boolean;
+    hasErrors(): boolean;
+    reset(): this;
+}
+declare const validate: <T extends object>(data: T, options?: ValidatorOptions) => Validator<T>;
+
+declare class DomainError extends Error {
+    readonly code: string;
+    readonly statusCode?: number | undefined;
+    readonly metadata?: Record<string, unknown> | undefined;
+    constructor(message: string, code: string, statusCode?: number | undefined, metadata?: Record<string, unknown> | undefined);
+}
+
+declare class ValidationError extends DomainError {
+    readonly errors: ValidationFieldError[];
+    constructor(errors: ValidationFieldError[]);
+    static single(field: string, message: string, rule: string, value?: unknown): ValidationError;
+    hasFieldError(field: string): boolean;
+    getFieldErrors(field: string): ValidationFieldError[];
+    getFirstError(): ValidationFieldError | undefined;
+}
+
+declare function interpolate(template: string, params: Record<string, unknown>): string;
+
+declare const ValidationMessages: {
+    required: (campo: string) => string;
+    pattern: (campo: string, ejemplo: string) => string;
+    maxLength: (campo: string, max: number, actual: number) => string;
+    minLength: (campo: string, min: number) => string;
+    range: (campo: string, min: number, max: number) => string;
+    date: (campo: string) => string;
+    allowedChars: (campo: string, permitidos: string) => string;
+    email: () => string;
+    string: (campo: string) => string;
+    number: (campo: string) => string;
+    boolean: (campo: string) => string;
+    array: (campo: string) => string;
+    object: (campo: string) => string;
+    uuid: (campo: string) => string;
+    enum: (campo: string, valores: unknown[]) => string;
+    custom: (campo: string) => string;
+};
+
+/**
+ * Replace ALL messages at once.
+ * Useful for full locale swaps (e.g., switching to English).
+ */
+declare function setMessages(messages: ValidationMessageMap): void;
+/**
+ * Merge partial overrides on top of current messages.
+ * Useful for customizing only a few messages while keeping the rest.
+ *
+ * @example
+ * configure({
+ *   required: (campo) => `${campo} is required`,
+ *   email: () => 'Invalid email address',
+ * })
+ */
+declare function configure(overrides: Partial<ValidationMessageMap>): void;
+/**
+ * Reset to Spanish defaults.
+ */
+declare function resetMessages(): void;
+/**
+ * Get the currently active message map. Used internally by ValidationRules.
+ */
+declare function getMessages(): ValidationMessageMap;
+
+export { DomainError, type FieldValidationConfig, type SchemaValidationConfig, ValidationError, type ValidationFieldError, ValidationMessageMap, ValidationMessages, type ValidationResult, type ValidationRuleConfig, type ValidationType, Validator, configure, getMessages, interpolate, resetMessages, setMessages, validate };

package/dist/index.js

@@ -0,0 +1,437 @@
+import { spanishMessages } from './chunk-5LU5LI4H.js';
+export { interpolate, spanishMessages } from './chunk-5LU5LI4H.js';
+
+// src/errors/DomainError.ts
+var DomainError = class extends Error {
+  constructor(message, code, statusCode, metadata) {
+    super(message);
+    this.code = code;
+    this.statusCode = statusCode;
+    this.metadata = metadata;
+    this.name = this.constructor.name;
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+};
+
+// src/ValidationError.ts
+var ValidationError = class _ValidationError extends DomainError {
+  errors;
+  constructor(errors) {
+    const message = errors.length === 1 ? errors[0]?.message : `Errores de validaci\xF3n: ${errors.map((e) => e.message).join(", ")}`;
+    super(message ?? "", "VALIDATION_ERROR", 422, { errors });
+    this.errors = errors;
+    this.name = "ValidationError";
+  }
+  static single(field, message, rule, value) {
+    return new _ValidationError([{ field, message, rule, value }]);
+  }
+  hasFieldError(field) {
+    return this.errors.some((e) => e.field === field);
+  }
+  getFieldErrors(field) {
+    return this.errors.filter((e) => e.field === field);
+  }
+  getFirstError() {
+    return this.errors[0];
+  }
+};
+
+// src/messages/index.ts
+var currentMessages = { ...spanishMessages };
+function setMessages(messages) {
+  currentMessages = { ...messages };
+}
+function configure(overrides) {
+  currentMessages = { ...currentMessages, ...overrides };
+}
+function resetMessages() {
+  currentMessages = { ...spanishMessages };
+}
+function getMessages() {
+  return currentMessages;
+}
+
+// src/ValidationRules.ts
+var ValidationMessages = {
+  required: (campo) => getMessages().required(campo),
+  pattern: (campo, ejemplo) => getMessages().pattern(campo, ejemplo),
+  maxLength: (campo, max, actual) => getMessages().maxLength(campo, max, actual),
+  minLength: (campo, min) => getMessages().minLength(campo, min),
+  range: (campo, min, max) => getMessages().range(campo, min, max),
+  date: (campo) => getMessages().date(campo),
+  allowedChars: (campo, permitidos) => getMessages().allowedChars(campo, permitidos),
+  email: () => getMessages().email(),
+  string: (campo) => getMessages().string(campo),
+  number: (campo) => getMessages().number(campo),
+  boolean: (campo) => getMessages().boolean(campo),
+  array: (campo) => getMessages().array(campo),
+  object: (campo) => getMessages().object(campo),
+  uuid: (campo) => getMessages().uuid(campo),
+  enum: (campo, valores) => getMessages().enum(campo, valores),
+  custom: (campo) => getMessages().custom(campo)
+};
+
+// src/Validator.ts
+var FieldValidator = class {
+  constructor(fieldName, fieldLabel, value, options, parentErrors) {
+    this.fieldName = fieldName;
+    this.fieldLabel = fieldLabel;
+    this.value = value;
+    this.options = options;
+    this.parentErrors = parentErrors;
+  }
+  errors = [];
+  isOptional = false;
+  get isEmpty() {
+    if (this.value === void 0 || this.value === null) return true;
+    if (typeof this.value === "string" && this.value.trim() === "") return true;
+    if (Array.isArray(this.value) && this.value.length === 0) return true;
+    return false;
+  }
+  addError(rule, message) {
+    const error = {
+      field: this.fieldName,
+      message,
+      rule,
+      value: this.value
+    };
+    this.errors.push(error);
+    this.parentErrors.push(error);
+    if (this.options.stopOnFirstError && this.options.throwOnError) {
+      throw new ValidationError(this.parentErrors);
+    }
+    return this;
+  }
+  shouldSkip() {
+    if (this.options.stopOnFirstError && this.errors.length > 0) return true;
+    if (this.isOptional && this.isEmpty) return true;
+    return false;
+  }
+  optional() {
+    this.isOptional = true;
+    return this;
+  }
+  required(message) {
+    if (this.isEmpty) {
+      this.addError(
+        "required",
+        message ?? ValidationMessages.required(this.fieldLabel)
+      );
+    }
+    return this;
+  }
+  string(message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && typeof this.value !== "string") {
+      this.addError(
+        "string",
+        message ?? ValidationMessages.string(this.fieldLabel)
+      );
+    }
+    return this;
+  }
+  number(message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && typeof this.value !== "number") {
+      this.addError(
+        "number",
+        message ?? ValidationMessages.number(this.fieldLabel)
+      );
+    }
+    return this;
+  }
+  boolean(message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && typeof this.value !== "boolean") {
+      this.addError(
+        "boolean",
+        message ?? ValidationMessages.boolean(this.fieldLabel)
+      );
+    }
+    return this;
+  }
+  array(message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && !Array.isArray(this.value)) {
+      this.addError(
+        "array",
+        message ?? ValidationMessages.array(this.fieldLabel)
+      );
+    }
+    return this;
+  }
+  object(message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && (typeof this.value !== "object" || Array.isArray(this.value))) {
+      this.addError(
+        "object",
+        message ?? ValidationMessages.object(this.fieldLabel)
+      );
+    }
+    return this;
+  }
+  type(expectedType, message) {
+    switch (expectedType) {
+      case "string":
+        return this.string(message);
+      case "number":
+        return this.number(message);
+      case "boolean":
+        return this.boolean(message);
+      case "array":
+        return this.array(message);
+      case "object":
+        return this.object(message);
+      case "date":
+        return this.date(message);
+      case "email":
+        return this.email(message);
+      case "uuid":
+        return this.uuid(message);
+      default:
+        return this;
+    }
+  }
+  minLength(min, message) {
+    if (this.shouldSkip()) return this;
+    const len = this.getLength();
+    if (!this.isEmpty && len < min) {
+      this.addError(
+        "minLength",
+        message ?? ValidationMessages.minLength(this.fieldLabel, min)
+      );
+    }
+    return this;
+  }
+  maxLength(max, message) {
+    if (this.shouldSkip()) return this;
+    const len = this.getLength();
+    if (!this.isEmpty && len > max) {
+      this.addError(
+        "maxLength",
+        message ?? ValidationMessages.maxLength(this.fieldLabel, max, len)
+      );
+    }
+    return this;
+  }
+  getLength() {
+    if (typeof this.value === "string") return this.value.length;
+    if (Array.isArray(this.value)) return this.value.length;
+    return 0;
+  }
+  min(minValue, message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && typeof this.value === "number" && this.value < minValue) {
+      this.addError(
+        "min",
+        message ?? ValidationMessages.range(this.fieldLabel, minValue, Infinity)
+      );
+    }
+    return this;
+  }
+  max(maxValue, message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && typeof this.value === "number" && this.value > maxValue) {
+      this.addError(
+        "max",
+        message ?? ValidationMessages.range(this.fieldLabel, -Infinity, maxValue)
+      );
+    }
+    return this;
+  }
+  range(minValue, maxValue, message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && typeof this.value === "number" && (this.value < minValue || this.value > maxValue)) {
+      this.addError(
+        "range",
+        message ?? ValidationMessages.range(this.fieldLabel, minValue, maxValue)
+      );
+    }
+    return this;
+  }
+  pattern(regex, example, message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && typeof this.value === "string" && !regex.test(this.value)) {
+      this.addError(
+        "pattern",
+        message ?? ValidationMessages.pattern(
+          this.fieldLabel,
+          example ?? regex.toString()
+        )
+      );
+    }
+    return this;
+  }
+  email(message) {
+    if (this.shouldSkip()) return this;
+    const emailRegex = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+    if (!this.isEmpty && typeof this.value === "string" && !emailRegex.test(this.value)) {
+      this.addError("email", message ?? ValidationMessages.email() ?? "");
+    }
+    return this;
+  }
+  uuid(message) {
+    if (this.shouldSkip()) return this;
+    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-5][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+    if (!this.isEmpty && typeof this.value === "string" && !uuidRegex.test(this.value)) {
+      this.addError("uuid", message ?? ValidationMessages.uuid(this.fieldLabel));
+    }
+    return this;
+  }
+  date(message) {
+    if (this.shouldSkip()) return this;
+    let isValid = false;
+    if (this.value instanceof Date && !isNaN(this.value.getTime())) {
+      isValid = true;
+    } else if (typeof this.value === "string") {
+      const parsed = new Date(this.value);
+      isValid = !isNaN(parsed.getTime());
+    }
+    if (!this.isEmpty && !isValid) {
+      this.addError("date", message ?? ValidationMessages.date(this.fieldLabel));
+    }
+    return this;
+  }
+  enum(allowedValues, message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && !allowedValues.includes(this.value)) {
+      this.addError(
+        "enum",
+        message ?? ValidationMessages.enum(this.fieldLabel, allowedValues)
+      );
+    }
+    return this;
+  }
+  allowedChars(chars, message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty && typeof this.value === "string") {
+      const regex = new RegExp(
+        `^[${chars.replace(/[-[\]{}()*+?.,\\^$|#\s]/g, "\\$&")}]+$`
+      );
+      if (!regex.test(this.value)) {
+        this.addError(
+          "allowedChars",
+          message ?? ValidationMessages.allowedChars(this.fieldLabel, chars)
+        );
+      }
+    }
+    return this;
+  }
+  custom(validator, message) {
+    if (this.shouldSkip()) return this;
+    if (!this.isEmpty) {
+      const result = validator(this.value);
+      if (result !== true) {
+        const errorMessage = typeof result === "string" ? result : message ?? ValidationMessages.custom(this.fieldLabel);
+        this.addError("custom", errorMessage);
+      }
+    }
+    return this;
+  }
+  nullable() {
+    return this.optional();
+  }
+};
+var Validator = class {
+  constructor(data, options = {}) {
+    this.data = data;
+    this.options = {
+      stopOnFirstError: false,
+      throwOnError: true,
+      ...options
+    };
+  }
+  errors = [];
+  options;
+  field(fieldName, label) {
+    const value = this.getNestedValue(fieldName);
+    const fieldLabel = label ?? fieldName;
+    return new FieldValidator(
+      fieldName,
+      fieldLabel,
+      value,
+      this.options,
+      this.errors
+    );
+  }
+  getNestedValue(path) {
+    return path.split(".").reduce((obj, key) => {
+      if (obj && typeof obj === "object" && key in obj) {
+        return obj[key];
+      }
+      return void 0;
+    }, this.data);
+  }
+  schema(config) {
+    for (const [fieldName, rules] of Object.entries(config)) {
+      const fieldValidator = this.field(fieldName, rules.label);
+      const messages = rules.messages ?? {};
+      if (rules.required) {
+        fieldValidator.required(messages.required);
+      } else {
+        fieldValidator.optional();
+      }
+      if (rules.type) {
+        fieldValidator.type(rules.type, messages.type);
+      }
+      if (rules.minLength !== void 0) {
+        fieldValidator.minLength(rules.minLength, messages.minLength);
+      }
+      if (rules.maxLength !== void 0) {
+        fieldValidator.maxLength(rules.maxLength, messages.maxLength);
+      }
+      if (rules.min !== void 0) {
+        fieldValidator.min(rules.min, messages.min);
+      }
+      if (rules.max !== void 0) {
+        fieldValidator.max(rules.max, messages.max);
+      }
+      if (rules.pattern) {
+        fieldValidator.pattern(
+          rules.pattern,
+          rules.patternExample,
+          messages.pattern
+        );
+      }
+      if (rules.enum) {
+        fieldValidator.enum(rules.enum, messages.enum);
+      }
+      if (rules.allowedChars) {
+        fieldValidator.allowedChars(rules.allowedChars, messages.allowedChars);
+      }
+      if (rules.custom) {
+        fieldValidator.custom(rules.custom, messages.custom);
+      }
+    }
+    return this;
+  }
+  validate() {
+    if (this.errors.length > 0) {
+      throw new ValidationError(this.errors);
+    }
+  }
+  getResult() {
+    return {
+      isValid: this.errors.length === 0,
+      errors: [...this.errors]
+    };
+  }
+  getErrors() {
+    return [...this.errors];
+  }
+  isValid() {
+    return this.errors.length === 0;
+  }
+  hasErrors() {
+    return this.errors.length > 0;
+  }
+  reset() {
+    this.errors.length = 0;
+    return this;
+  }
+};
+var validate = (data, options) => {
+  return new Validator(data, options);
+};
+
+export { DomainError, ValidationError, ValidationMessages, Validator, configure, getMessages, resetMessages, setMessages, validate };

package/dist/messages/es.cjs

@@ -0,0 +1,10 @@
+'use strict';
+
+var chunkGGX2GQQ6_cjs = require('../chunk-GGX2GQQ6.cjs');
+
+
+
+Object.defineProperty(exports, "spanishMessages", {
+  enumerable: true,
+  get: function () { return chunkGGX2GQQ6_cjs.spanishMessages; }
+});

package/dist/messages/es.d.cts

@@ -0,0 +1 @@
+export { s as spanishMessages } from '../es-QPgrpTLv.cjs';

package/dist/messages/es.d.ts

@@ -0,0 +1 @@
+export { s as spanishMessages } from '../es-QPgrpTLv.js';

package/dist/messages/es.js

@@ -0,0 +1 @@
+export { spanishMessages } from '../chunk-5LU5LI4H.js';

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@linktic/validator",
+  "version": "1.0.0",
+  "description": "Framework-agnostic TypeScript validation library with fluent API and configurable Spanish default messages",
+  "author": "LinkTIC",
+  "license": "UNLICENSED",
+  "private": false,
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.js"
+    },
+    "./messages/es": {
+      "types": "./dist/messages/es.d.ts",
+      "import": "./dist/messages/es.js",
+      "require": "./dist/messages/es.cjs",
+      "default": "./dist/messages/es.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "messages/es": [
+        "./dist/messages/es.d.ts"
+      ]
+    }
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.0.0",
+    "typescript": "~5.6.0",
+    "vitest": "^2.0.0"
+  },
+  "keywords": [
+    "validation",
+    "validator",
+    "typescript",
+    "fluent-api",
+    "linktic"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "clean": "rm -rf dist",
+    "prebuild": "npm run clean",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "typecheck": "tsc --noEmit"
+  }
+}