@satoshibits/functional 1.0.2

package/dist/validation.d.mts

@@ -0,0 +1,622 @@
+/**
+ * @module validation
+ * @description Functional validation utilities using Result types for composable,
+ * type-safe data validation. This module provides a rich set of validators and
+ * combinators for building complex validation schemas. Unlike traditional validation
+ * libraries that throw exceptions, all validators return Result types, making
+ * error handling explicit and composable. Validators can be combined, transformed,
+ * and reused to build sophisticated validation logic.
+ *
+ * @example
+ * ```typescript
+ * import { Validation, validators, schema, ValidationError } from './validation.mts';
+ *
+ * // simple validators
+ * const validateAge = validators.number.between(0, 150);
+ * const validateEmail = validators.string.email();
+ *
+ * // combining validators
+ * const validatePassword = Validation.all(
+ *   validators.string.minLength(8),
+ *   validators.string.matches(/[A-Z]/, 'Must contain uppercase'),
+ *   validators.string.matches(/[0-9]/, 'Must contain number')
+ * );
+ *
+ * // object validation schema
+ * const userSchema = schema({
+ *   name: validators.string.nonEmpty(),
+ *   email: validateEmail,
+ *   age: Validation.optional(validateAge),
+ *   password: validatePassword
+ * });
+ *
+ * // using the validator
+ * const result = userSchema({
+ *   name: 'John Doe',
+ *   email: 'john@example.com',
+ *   age: 30,
+ *   password: 'SecurePass123'
+ * });
+ *
+ * if (result.success) {
+ *   console.log('Valid user:', result.data);
+ * } else {
+ *   console.error('Validation errors:', result.error.errors);
+ * }
+ * ```
+ *
+ * @category Core
+ * @since 2025-07-03
+ */
+import { Result } from "./result.mjs";
+/**
+ * Custom validation error that can hold multiple error messages.
+ * @description Extends the standard Error class to accumulate multiple validation
+ * errors. This allows validators to collect all errors rather than failing on
+ * the first error, providing better user experience for form validation.
+ *
+ * @category Errors
+ * @example
+ * // Creating validation errors
+ * const error = new ValidationError(['Name is required', 'Email is invalid']);
+ * console.log(error.message); // "Validation failed: Name is required, Email is invalid"
+ *
+ * @example
+ * // Working with errors
+ * if (!result.success) {
+ *   const validationError = result.error;
+ *   console.log('First error:', validationError.firstError());
+ *   console.log('All errors:', validationError.errors);
+ *
+ *   if (validationError.hasError('Email is invalid')) {
+ *     // Handle email error specifically
+ *   }
+ * }
+ *
+ * @since 2025-07-03
+ */
+export declare class ValidationError extends Error {
+    readonly errors: string[];
+    /**
+     * Creates a new ValidationError with the given error messages.
+     *
+     * @param {string[]} errors - Array of error messages
+     */
+    constructor(errors: string[]);
+    /**
+     * Adds additional errors to this validation error.
+     * @description Creates a new ValidationError with the combined errors.
+     * The original error remains unchanged (immutable).
+     *
+     * @param {string[]} newErrors - Additional error messages to add
+     * @returns {ValidationError} A new ValidationError with all errors
+     *
+     * @example
+     * const error1 = new ValidationError(['Name required']);
+     * const error2 = error1.addErrors(['Email invalid']);
+     * // error2.errors => ['Name required', 'Email invalid']
+     * // error1.errors => ['Name required'] (unchanged)
+     */
+    addErrors(newErrors: string[]): ValidationError;
+    /**
+     * Checks if this error contains a specific error message.
+     * @description Useful for conditional error handling based on specific
+     * validation failures.
+     *
+     * @param {string} error - The error message to check for
+     * @returns {boolean} True if the error message is present
+     *
+     * @example
+     * if (!result.success && result.error.hasError('Email is invalid')) {
+     *   showEmailHelp();
+     * }
+     */
+    hasError(error: string): boolean;
+    /**
+     * Gets the first error message.
+     * @description Returns the first error in the list, useful when you only
+     * want to display one error at a time.
+     *
+     * @returns {string | undefined} The first error message or undefined if no errors
+     *
+     * @example
+     * const firstError = validationError.firstError();
+     * if (firstError) {
+     *   showToast(firstError);
+     * }
+     */
+    firstError(): string | undefined;
+}
+/**
+ * A validator is a function that takes a value and returns a Result.
+ * @description The core type of the validation system. Validators are pure functions
+ * that take a value and return either a successful Result with the (possibly transformed)
+ * value, or a failed Result with a ValidationError.
+ *
+ * @template T - The type of value being validated
+ *
+ * @category Types
+ * @example
+ * // Simple validator
+ * const isPositive: Validator<number> = (n) =>
+ *   n > 0 ? Result.ok(n) : Result.err(new ValidationError(['Must be positive']));
+ *
+ * @example
+ * // Transforming validator
+ * const trimString: Validator<string> = (s) =>
+ *   Result.ok(s.trim());
+ *
+ * @since 2025-07-03
+ */
+export type Validator<T> = (value: T) => Result<T, ValidationError>;
+/**
+ * Validation utilities for creating and composing validators.
+ * @description The main namespace for validation combinators and utilities.
+ * Provides methods for creating, combining, and transforming validators
+ * in a functional style.
+ *
+ * @category Utilities
+ * @since 2025-07-03
+ */
+export declare const Validation: {
+    /**
+     * Creates a validator that always succeeds.
+     * @description Useful as a default validator or when conditionally applying
+     * validation. The value passes through unchanged.
+     *
+     * @template T - The type of value
+     * @returns {Validator<T>} A validator that always returns success
+     *
+     * @category Constructors
+     * @example
+     * // Conditional validation
+     * const validator = shouldValidate
+     *   ? validators.string.email()
+     *   : Validation.success();
+     *
+     * @since 2025-07-03
+     */
+    success: <T>() => Validator<T>;
+    /**
+     * Creates a validator that always fails with the given error.
+     * @description Useful for custom validation logic or placeholder validators
+     * during development.
+     *
+     * @template T - The type of value
+     * @param {string} error - The error message
+     * @returns {Validator<T>} A validator that always returns failure
+     *
+     * @category Constructors
+     * @example
+     * // Feature flag validation
+     * const validator = featureEnabled
+     *   ? actualValidator
+     *   : Validation.failure('Feature not available');
+     *
+     * @since 2025-07-03
+     */
+    failure: <T>(error: string) => Validator<T>;
+    /**
+     * Creates a validator from a predicate function.
+     * @description The fundamental building block for custom validators. Converts
+     * a boolean-returning function into a validator.
+     *
+     * @template T - The type of value to validate
+     * @param {function(T): boolean} predicate - Function that returns true if valid
+     * @param {string} error - Error message if validation fails
+     * @returns {Validator<T>} A validator based on the predicate
+     *
+     * @category Constructors
+     * @example
+     * // Custom age validator
+     * const isAdult = Validation.fromPredicate(
+     *   (age: number) => age >= 18,
+     *   'Must be 18 or older'
+     * );
+     *
+     * @example
+     * // Complex validation
+     * const isValidUsername = Validation.fromPredicate(
+     *   (username: string) => /^[a-zA-Z0-9_]{3,20}$/.test(username),
+     *   'Username must be 3-20 characters, alphanumeric or underscore'
+     * );
+     *
+     * @since 2025-07-03
+     */
+    fromPredicate: <T>(predicate: (value: T) => boolean, error: string) => Validator<T>;
+    /**
+     * Combines multiple validators using AND logic.
+     * @description All validators must pass for the validation to succeed.
+     * Collects all errors from all validators before returning, providing
+     * comprehensive feedback.
+     *
+     * @template T - The type of value to validate
+     * @param {Validator<T>[]} validators - Validators to combine
+     * @returns {Validator<T>} A validator that requires all validations to pass
+     *
+     * @category Combinators
+     * @example
+     * // Password validation
+     * const validatePassword = Validation.all(
+     *   validators.string.minLength(8),
+     *   validators.string.matches(/[A-Z]/, 'Must contain uppercase'),
+     *   validators.string.matches(/[0-9]/, 'Must contain number'),
+     *   validators.string.matches(/[!@#$%]/, 'Must contain special character')
+     * );
+     *
+     * @example
+     * // Numeric range validation
+     * const validatePercentage = Validation.all(
+     *   validators.number.min(0),
+     *   validators.number.max(100),
+     *   validators.number.integer()
+     * );
+     *
+     * @since 2025-07-03
+     */
+    all: <T>(...validators: Validator<T>[]) => Validator<T>;
+    /**
+     * Combines multiple validators using OR logic.
+     * @description At least one validator must pass for the validation to succeed.
+     * Returns the result of the first successful validator, or all errors if
+     * none succeed.
+     *
+     * @template T - The type of value to validate
+     * @param {Validator<T>[]} validators - Validators to try
+     * @returns {Validator<T>} A validator that requires at least one validation to pass
+     *
+     * @category Combinators
+     * @example
+     * // Multiple format support
+     * const validateDate = Validation.any(
+     *   validators.string.matches(/^\d{4}-\d{2}-\d{2}$/, 'Invalid ISO date'),
+     *   validators.string.matches(/^\d{2}\/\d{2}\/\d{4}$/, 'Invalid US date')
+     * );
+     *
+     * @example
+     * // Flexible identifier
+     * const validateIdentifier = Validation.any(
+     *   validators.string.matches(/^\d+$/, 'Not a numeric ID'),
+     *   validators.string.email(),
+     *   validators.string.matches(/^[A-Z]{2,}$/, 'Not a code')
+     * );
+     *
+     * @since 2025-07-03
+     */
+    any: <T>(...validators: Validator<T>[]) => Validator<T>;
+    /**
+     * Transforms the validated value if validation passes.
+     * @description Note: The returned validator still takes an input of type T.
+     * This is the functor map operation for validators, allowing value transformation
+     * after successful validation.
+     *
+     * @template T - The input type
+     * @template U - The output type
+     * @param {function(T): U} fn - Function to transform the validated value
+     * @returns {function(Validator<T>): function(T): Result<U, ValidationError>} A function that transforms validators
+     *
+     * @category Transformations
+     * @example
+     * // Normalize email
+     * const normalizeEmail = Validation.map((email: string) => email.toLowerCase());
+     * const validateEmail = normalizeEmail(validators.string.email());
+     *
+     * @example
+     * // Parse and validate
+     * const parseNumber = Validation.map((s: string) => parseInt(s, 10));
+     * const validateNumericString = parseNumber(
+     *   validators.string.matches(/^\d+$/, 'Must be numeric')
+     * );
+     *
+     * @since 2025-07-03
+     */
+    map: <T, U>(fn: (value: T) => U) => (validator: Validator<T>) => ((value: T) => Result<U, ValidationError>);
+    /**
+     * Chains validators together.
+     * @description The choice of the second validator depends on the successful
+     * result of the first. This is the monadic bind operation for validators,
+     * enabling dynamic validation based on previous results.
+     *
+     * @template T - The type being validated
+     * @param {function(T): Validator<T>} fn - Function that returns the next validator
+     * @returns {function(Validator<T>): Validator<T>} A function that chains validators
+     *
+     * @category Combinators
+     * @example
+     * // Conditional validation based on value
+     * const validateScore = Validation.flatMap((score: number) => {
+     *   if (score < 0) return Validation.failure('Negative scores not allowed');
+     *   if (score > 100) return validators.number.max(200); // Allow bonus points
+     *   return Validation.success();
+     * });
+     *
+     * @example
+     * // Dynamic validation
+     * const validateField = Validation.flatMap((field: { type: string; value: any }) => {
+     *   switch (field.type) {
+     *     case 'email': return validators.string.email();
+     *     case 'number': return validators.number.positive();
+     *     default: return Validation.success();
+     *   }
+     * });
+     *
+     * @since 2025-07-03
+     */
+    flatMap: <T>(fn: (value: T) => Validator<T>) => (validator: Validator<T>) => Validator<T>;
+    /**
+     * Validates an optional value.
+     * @description If the value is null or undefined, validation passes.
+     * Otherwise, applies the validator. Useful for optional form fields
+     * or nullable database columns.
+     *
+     * @template T - The type being validated
+     * @param {Validator<T>} validator - Validator to apply if value is present
+     * @returns {Validator<T | null | undefined>} A validator that handles optional values
+     *
+     * @category Modifiers
+     * @example
+     * // Optional email field
+     * const validateOptionalEmail = Validation.optional(
+     *   validators.string.email()
+     * );
+     *
+     * validateOptionalEmail(null); // => { success: true, data: null }
+     * validateOptionalEmail('user@example.com'); // => validates as email
+     *
+     * @example
+     * // In object schema
+     * const userSchema = schema({
+     *   name: validators.string.nonEmpty(),
+     *   email: validators.string.email(),
+     *   phone: Validation.optional(validators.string.matches(/^\d{10}$/))
+     * });
+     *
+     * @since 2025-07-03
+     */
+    optional: <T>(validator: Validator<T>) => Validator<T | null | undefined>;
+    /**
+     * Makes a validator required.
+     * @description Fails if value is null or undefined. This is a type guard
+     * that narrows T | null | undefined to T.
+     *
+     * @template T - The required type
+     * @param {string} error - Error message if value is missing
+     * @returns {Validator<T | null | undefined>} A validator that requires presence
+     *
+     * @category Modifiers
+     * @example
+     * // Basic usage
+     * const required = Validation.required<string>();
+     * required(null); // => { success: false, error: 'Value is required' }
+     * required('hello'); // => { success: true, data: 'hello' }
+     *
+     * @example
+     * // Combining with other validators
+     * const validateName = Validation.all(
+     *   Validation.required<string>('Name is required'),
+     *   validators.string.minLength(2)
+     * );
+     *
+     * @since 2025-07-03
+     */
+    required: <T>(error?: string) => Validator<T | null | undefined>;
+    /**
+     * Validates each item in an array.
+     * @description Applies the same validator to each element of an array,
+     * collecting all errors with their indices. Returns a new array with
+     * validated (and possibly transformed) items.
+     *
+     * @template T - The type of array elements
+     * @param {Validator<T>} itemValidator - Validator to apply to each item
+     * @returns {Validator<T[]>} A validator for arrays
+     *
+     * @category Collections
+     * @example
+     * // Validate array of emails
+     * const validateEmails = Validation.array(
+     *   validators.string.email()
+     * );
+     *
+     * const result = validateEmails([
+     *   'user@example.com',
+     *   'invalid-email',
+     *   'admin@example.com'
+     * ]);
+     * // Error: "[1]: Invalid email format"
+     *
+     * @example
+     * // Complex item validation
+     * const validateUsers = Validation.array(
+     *   schema({
+     *     name: validators.string.nonEmpty(),
+     *     age: validators.number.positive()
+     *   })
+     * );
+     *
+     * @since 2025-07-03
+     */
+    array: <T>(itemValidator: Validator<T>) => Validator<T[]>;
+    /**
+     * Validates properties of an object.
+     * @description Validates specified properties of an object using individual
+     * validators. Unspecified properties are passed through unchanged. Errors
+     * are prefixed with the property name for clarity.
+     *
+     * @template T - The object type
+     * @param {object} validators - Map of property names to validators
+     * @returns {Validator<T>} A validator for the object
+     *
+     * @category Objects
+     * @example
+     * // Partial object validation
+     * const validatePerson = Validation.object({
+     *   name: validators.string.nonEmpty(),
+     *   age: validators.number.positive()
+     * });
+     *
+     * const result = validatePerson({
+     *   name: 'John',
+     *   age: -5,
+     *   extra: 'ignored'
+     * });
+     * // Error: "age: Number must be positive"
+     *
+     * @see schema - Type-safe alternative for complete object validation
+     * @since 2025-07-03
+     */
+    object: <T extends Record<string, any>>(validators: { [K in keyof T]?: Validator<T[K]>; }) => Validator<T>;
+};
+/**
+ * Common validators for primitive types.
+ * @description Pre-built validators for common validation scenarios.
+ * These validators can be used directly or combined with the Validation
+ * combinators to create more complex validation logic.
+ *
+ * @category Validators
+ * @example
+ * // Using validators directly
+ * const emailValidator = validators.string.email();
+ * const ageValidator = validators.number.between(0, 150);
+ *
+ * @example
+ * // Combining validators
+ * const strongPassword = Validation.all(
+ *   validators.string.minLength(12),
+ *   validators.string.matches(/[A-Z]/, 'Need uppercase'),
+ *   validators.string.matches(/[a-z]/, 'Need lowercase'),
+ *   validators.string.matches(/[0-9]/, 'Need number')
+ * );
+ *
+ * @since 2025-07-03
+ */
+export declare const validators: {
+    /**
+     * String validators.
+     * @description Validators for string values including length checks,
+     * format validation, and pattern matching.
+     *
+     * @category String Validators
+     * @since 2025-07-03
+     */
+    string: {
+        minLength: (min: number) => Validator<string>;
+        maxLength: (max: number) => Validator<string>;
+        nonEmpty: () => Validator<string>;
+        email: () => Validator<string>;
+        url: () => Validator<string>;
+        matches: (pattern: RegExp, error?: string) => Validator<string>;
+        oneOf: (options: string[]) => Validator<string>;
+    };
+    /**
+     * Number validators.
+     */
+    number: {
+        min: (min: number) => Validator<number>;
+        max: (max: number) => Validator<number>;
+        positive: () => Validator<number>;
+        nonNegative: () => Validator<number>;
+        integer: () => Validator<number>;
+        between: (min: number, max: number) => Validator<number>;
+    };
+    /**
+     * Array validators.
+     */
+    array: {
+        minLength: <T>(min: number) => Validator<T[]>;
+        maxLength: <T>(max: number) => Validator<T[]>;
+        nonEmpty: <T>() => Validator<T[]>;
+        unique: <T>() => Validator<T[]>;
+    };
+    /**
+     * Date validators.
+     */
+    date: {
+        after: (date: Date) => Validator<Date>;
+        before: (date: Date) => Validator<Date>;
+        future: () => Validator<Date>;
+        past: () => Validator<Date>;
+    };
+    /**
+     * Object validators.
+     */
+    object: {
+        hasProperty: <T extends object>(prop: keyof T) => Validator<T>;
+        notEmpty: () => Validator<Record<string, any>>;
+    };
+};
+/**
+ * Utility for creating complex validation schemas.
+ * @description Type-safe wrapper around Validation.object that requires
+ * validators for all properties of the type. This ensures complete
+ * validation coverage for object types.
+ *
+ * @template T - The object type to validate
+ * @param {object} validators - Validators for each property of T
+ * @returns {Validator<T>} A validator for objects of type T
+ *
+ * @category Schema
+ * @example
+ * // Type-safe user validation
+ * interface User {
+ *   name: string;
+ *   email: string;
+ *   age: number;
+ * }
+ *
+ * const userValidator = schema<User>({
+ *   name: validators.string.nonEmpty(),
+ *   email: validators.string.email(),
+ *   age: validators.number.between(0, 150)
+ * });
+ *
+ * @example
+ * // Nested schemas
+ * const addressValidator = schema({
+ *   street: validators.string.nonEmpty(),
+ *   city: validators.string.nonEmpty(),
+ *   zipCode: validators.string.matches(/^\d{5}$/)
+ * });
+ *
+ * const personValidator = schema({
+ *   name: validators.string.nonEmpty(),
+ *   address: addressValidator
+ * });
+ *
+ * @since 2025-07-03
+ */
+export declare const schema: <T extends Record<string, any>>(validators: { [K in keyof T]: Validator<T[K]>; }) => Validator<T>;
+/**
+ * Validates a value and returns either the validated value or throws the error.
+ * @description Use sparingly, only when you're certain validation should pass.
+ * This bridges the Result-based validation system with exception-based code.
+ *
+ * @template T - The type being validated
+ * @param {Validator<T>} validator - The validator to apply
+ * @returns {function(T): T} A function that validates or throws
+ * @throws {ValidationError} If validation fails
+ *
+ * @category Utilities
+ * @example
+ * // Configuration validation at startup
+ * const validateConfig = validateOrThrow(
+ *   schema({
+ *     port: validators.number.between(1, 65535),
+ *     host: validators.string.nonEmpty()
+ *   })
+ * );
+ *
+ * // Throws if invalid, otherwise returns validated config
+ * const config = validateConfig(loadConfig());
+ *
+ * @example
+ * // Input sanitization
+ * const sanitizeEmail = validateOrThrow(
+ *   Validation.map((s: string) => s.toLowerCase())(
+ *     validators.string.email()
+ *   )
+ * );
+ *
+ * @since 2025-07-03
+ */
+export declare const validateOrThrow: <T>(validator: Validator<T>) => (value: T) => T;
+//# sourceMappingURL=validation.d.mts.map

package/dist/validation.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validation.d.mts","sourceRoot":"","sources":["../src/validation.mts"],"names":[],"mappings":"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"}