@chidchanun/bcp 0.1.18 → 0.1.19

package/packages/client/src/validation.ts

@@ -0,0 +1,1118 @@
+export type ValidationPathSegment =
+    | string
+    | number;
+
+export type ValidationPath =
+    readonly ValidationPathSegment[];
+
+export interface ValidationIssue {
+    path: ValidationPath;
+    message: string;
+    code: string;
+}
+
+export interface ValidationSuccess<T> {
+    success: true;
+    data: T;
+}
+
+export interface ValidationFailure {
+    success: false;
+    issues: ValidationIssue[];
+    fieldErrors: Record<string, string[]>;
+    formErrors: string[];
+}
+
+export type ValidationResult<T> =
+    | ValidationSuccess<T>
+    | ValidationFailure;
+
+export interface Validator<T> {
+    safeParse(
+        input: unknown,
+        path?: ValidationPath
+    ): ValidationResult<T>;
+    parse(input: unknown): T;
+    optional(): Validator<T | undefined>;
+    nullable(): Validator<T | null>;
+    refine(
+        predicate: (value: T) => boolean,
+        message: string,
+        code?: string
+    ): Validator<T>;
+}
+
+export type InferValidator<TValidator> =
+    TValidator extends Validator<infer TValue>
+        ? TValue
+        : never;
+
+export type ValidationShape =
+    Record<string, Validator<any>>;
+
+export type InferValidationShape<
+    TShape extends ValidationShape
+> = {
+    [TKey in keyof TShape]:
+        InferValidator<TShape[TKey]>;
+};
+
+export interface StringValidationOptions {
+    trim?: boolean;
+    minLength?: number;
+    maxLength?: number;
+    email?: boolean;
+    pattern?: RegExp;
+}
+
+export interface NumberValidationOptions {
+    coerce?: boolean;
+    integer?: boolean;
+    min?: number;
+    max?: number;
+}
+
+export interface BooleanValidationOptions {
+    coerce?: boolean;
+}
+
+export interface ArrayValidationOptions {
+    minLength?: number;
+    maxLength?: number;
+}
+
+export interface ObjectValidationOptions {
+    allowUnknown?: boolean;
+}
+
+export class ValidationError
+    extends Error {
+    readonly issues:
+        ValidationIssue[];
+    readonly fieldErrors:
+        Record<string, string[]>;
+    readonly formErrors:
+        string[];
+
+    constructor(
+        issues: readonly ValidationIssue[],
+        message = "Validation failed."
+    ) {
+        super(message);
+        this.name =
+            "ValidationError";
+
+        const failure =
+            createFailure(
+                issues
+            );
+
+        this.issues =
+            failure.issues;
+        this.fieldErrors =
+            failure.fieldErrors;
+        this.formErrors =
+            failure.formErrors;
+    }
+}
+
+class BcpValidator<T>
+    implements Validator<T> {
+    constructor(
+        private readonly parser:
+            (
+                input: unknown,
+                path: ValidationPath
+            ) => ValidationResult<T>
+    ) {}
+
+    safeParse(
+        input: unknown,
+        path: ValidationPath = []
+    ): ValidationResult<T> {
+        return this.parser(
+            input,
+            [
+                ...path,
+            ]
+        );
+    }
+
+    parse(input: unknown): T {
+        const result =
+            this.safeParse(
+                input
+            );
+
+        if (!result.success) {
+            throw new ValidationError(
+                result.issues
+            );
+        }
+
+        return result.data;
+    }
+
+    optional():
+        Validator<T | undefined> {
+        return new BcpValidator<
+            T | undefined
+        >(
+            (
+                input,
+                path
+            ) => {
+                if (
+                    input ===
+                    undefined
+                ) {
+                    return success(
+                        undefined
+                    );
+                }
+
+                return this.safeParse(
+                    input,
+                    path
+                );
+            }
+        );
+    }
+
+    nullable():
+        Validator<T | null> {
+        return new BcpValidator<
+            T | null
+        >(
+            (
+                input,
+                path
+            ) => {
+                if (
+                    input === null
+                ) {
+                    return success(
+                        null
+                    );
+                }
+
+                return this.safeParse(
+                    input,
+                    path
+                );
+            }
+        );
+    }
+
+    refine(
+        predicate:
+            (value: T) => boolean,
+        message: string,
+        code = "custom"
+    ): Validator<T> {
+        return new BcpValidator<T>(
+            (
+                input,
+                path
+            ) => {
+                const result =
+                    this.safeParse(
+                        input,
+                        path
+                    );
+
+                if (!result.success) {
+                    return result;
+                }
+
+                let accepted =
+                    false;
+
+                try {
+                    accepted =
+                        predicate(
+                            result.data
+                        );
+                } catch {
+                    accepted =
+                        false;
+                }
+
+                if (!accepted) {
+                    return failure(
+                        path,
+                        message,
+                        code
+                    );
+                }
+
+                return result;
+            }
+        );
+    }
+}
+
+export function string(
+    options:
+        StringValidationOptions = {}
+): Validator<string> {
+    validateLengthOption(
+        options.minLength,
+        "minLength"
+    );
+    validateLengthOption(
+        options.maxLength,
+        "maxLength"
+    );
+
+    if (
+        options.minLength !== undefined &&
+        options.maxLength !== undefined &&
+        options.minLength >
+            options.maxLength
+    ) {
+        throw new Error(
+            "BCP Validation: string minLength cannot be greater than maxLength."
+        );
+    }
+
+    return new BcpValidator<string>(
+        (
+            input,
+            path
+        ) => {
+            if (
+                typeof input !==
+                "string"
+            ) {
+                return requiredOrTypeFailure(
+                    input,
+                    path,
+                    "string"
+                );
+            }
+
+            const value =
+                options.trim
+                    ? input.trim()
+                    : input;
+
+            if (
+                options.minLength !== undefined &&
+                value.length <
+                    options.minLength
+            ) {
+                return failure(
+                    path,
+                    `Must contain at least ${options.minLength} character(s).`,
+                    "too_small"
+                );
+            }
+
+            if (
+                options.maxLength !== undefined &&
+                value.length >
+                    options.maxLength
+            ) {
+                return failure(
+                    path,
+                    `Must contain at most ${options.maxLength} character(s).`,
+                    "too_big"
+                );
+            }
+
+            if (
+                options.email &&
+                !isEmail(
+                    value
+                )
+            ) {
+                return failure(
+                    path,
+                    "Must be a valid email address.",
+                    "invalid_email"
+                );
+            }
+
+            if (
+                options.pattern &&
+                !testPattern(
+                    options.pattern,
+                    value
+                )
+            ) {
+                return failure(
+                    path,
+                    "Must match the required format.",
+                    "invalid_string"
+                );
+            }
+
+            return success(
+                value
+            );
+        }
+    );
+}
+
+export function number(
+    options:
+        NumberValidationOptions = {}
+): Validator<number> {
+    return new BcpValidator<number>(
+        (
+            input,
+            path
+        ) => {
+            let value =
+                input;
+
+            if (
+                options.coerce &&
+                typeof value ===
+                    "string" &&
+                value.trim() !==
+                    ""
+            ) {
+                value =
+                    Number(
+                        value
+                    );
+            }
+
+            if (
+                typeof value !==
+                    "number" ||
+                !Number.isFinite(
+                    value
+                )
+            ) {
+                return requiredOrTypeFailure(
+                    input,
+                    path,
+                    "number"
+                );
+            }
+
+            if (
+                options.integer &&
+                !Number.isInteger(
+                    value
+                )
+            ) {
+                return failure(
+                    path,
+                    "Must be an integer.",
+                    "invalid_integer"
+                );
+            }
+
+            if (
+                options.min !== undefined &&
+                value < options.min
+            ) {
+                return failure(
+                    path,
+                    `Must be greater than or equal to ${options.min}.`,
+                    "too_small"
+                );
+            }
+
+            if (
+                options.max !== undefined &&
+                value > options.max
+            ) {
+                return failure(
+                    path,
+                    `Must be less than or equal to ${options.max}.`,
+                    "too_big"
+                );
+            }
+
+            return success(
+                value
+            );
+        }
+    );
+}
+
+export function boolean(
+    options:
+        BooleanValidationOptions = {}
+): Validator<boolean> {
+    return new BcpValidator<boolean>(
+        (
+            input,
+            path
+        ) => {
+            if (
+                typeof input ===
+                "boolean"
+            ) {
+                return success(
+                    input
+                );
+            }
+
+            if (
+                options.coerce &&
+                typeof input ===
+                    "string"
+            ) {
+                const normalized =
+                    input
+                        .trim()
+                        .toLowerCase();
+
+                if (
+                    [
+                        "1",
+                        "true",
+                        "on",
+                        "yes",
+                    ].includes(
+                        normalized
+                    )
+                ) {
+                    return success(
+                        true
+                    );
+                }
+
+                if (
+                    [
+                        "0",
+                        "false",
+                        "off",
+                        "no",
+                    ].includes(
+                        normalized
+                    )
+                ) {
+                    return success(
+                        false
+                    );
+                }
+            }
+
+            return requiredOrTypeFailure(
+                input,
+                path,
+                "boolean"
+            );
+        }
+    );
+}
+
+export function literal<
+    const TValue extends
+        | string
+        | number
+        | boolean
+        | null
+>(
+    expected: TValue
+): Validator<TValue> {
+    return new BcpValidator<TValue>(
+        (
+            input,
+            path
+        ) => {
+            if (
+                input !==
+                expected
+            ) {
+                return failure(
+                    path,
+                    `Must equal ${JSON.stringify(expected)}.`,
+                    "invalid_literal"
+                );
+            }
+
+            return success(
+                expected
+            );
+        }
+    );
+}
+
+export function enumValue<
+    const TValues extends
+        readonly [
+            string,
+            ...string[],
+        ]
+>(
+    values: TValues
+): Validator<TValues[number]> {
+    const accepted =
+        new Set<string>(
+            values
+        );
+
+    return new BcpValidator<
+        TValues[number]
+    >(
+        (
+            input,
+            path
+        ) => {
+            if (
+                typeof input !==
+                    "string" ||
+                !accepted.has(
+                    input
+                )
+            ) {
+                return failure(
+                    path,
+                    `Must be one of: ${values.join(", ")}.`,
+                    "invalid_enum"
+                );
+            }
+
+            return success(
+                input as TValues[number]
+            );
+        }
+    );
+}
+
+export function array<T>(
+    item: Validator<T>,
+    options:
+        ArrayValidationOptions = {}
+): Validator<T[]> {
+    validateLengthOption(
+        options.minLength,
+        "minLength"
+    );
+    validateLengthOption(
+        options.maxLength,
+        "maxLength"
+    );
+
+    return new BcpValidator<T[]>(
+        (
+            input,
+            path
+        ) => {
+            if (
+                !Array.isArray(
+                    input
+                )
+            ) {
+                return requiredOrTypeFailure(
+                    input,
+                    path,
+                    "array"
+                );
+            }
+
+            if (
+                options.minLength !== undefined &&
+                input.length <
+                    options.minLength
+            ) {
+                return failure(
+                    path,
+                    `Must contain at least ${options.minLength} item(s).`,
+                    "too_small"
+                );
+            }
+
+            if (
+                options.maxLength !== undefined &&
+                input.length >
+                    options.maxLength
+            ) {
+                return failure(
+                    path,
+                    `Must contain at most ${options.maxLength} item(s).`,
+                    "too_big"
+                );
+            }
+
+            const output:
+                T[] = [];
+            const issues:
+                ValidationIssue[] = [];
+
+            for (
+                let index = 0;
+                index < input.length;
+                index += 1
+            ) {
+                const result =
+                    item.safeParse(
+                        input[index],
+                        [
+                            ...path,
+                            index,
+                        ]
+                    );
+
+                if (result.success) {
+                    output.push(
+                        result.data
+                    );
+                } else {
+                    issues.push(
+                        ...result.issues
+                    );
+                }
+            }
+
+            return issues.length > 0
+                ? createFailure(
+                    issues
+                )
+                : success(
+                    output
+                );
+        }
+    );
+}
+
+export function object<
+    TShape extends ValidationShape
+>(
+    shape: TShape,
+    options:
+        ObjectValidationOptions = {}
+): Validator<
+    InferValidationShape<TShape>
+> {
+    return new BcpValidator<
+        InferValidationShape<TShape>
+    >(
+        (
+            input,
+            path
+        ) => {
+            if (
+                !isPlainObject(
+                    input
+                )
+            ) {
+                return requiredOrTypeFailure(
+                    input,
+                    path,
+                    "object"
+                );
+            }
+
+            const source =
+                input as Record<
+                    string,
+                    unknown
+                >;
+            const output:
+                Record<string, unknown> =
+                options.allowUnknown
+                    ? {
+                        ...source,
+                    }
+                    : {};
+            const issues:
+                ValidationIssue[] = [];
+
+            for (
+                const [
+                    key,
+                    validator,
+                ]
+                of Object.entries(
+                    shape
+                )
+            ) {
+                const result =
+                    validator.safeParse(
+                        source[key],
+                        [
+                            ...path,
+                            key,
+                        ]
+                    );
+
+                if (result.success) {
+                    output[key] =
+                        result.data;
+                } else {
+                    issues.push(
+                        ...result.issues
+                    );
+                }
+            }
+
+            return issues.length > 0
+                ? createFailure(
+                    issues
+                )
+                : success(
+                    output as
+                        InferValidationShape<TShape>
+                );
+        }
+    );
+}
+
+export function union<
+    const TValidators extends
+        readonly [
+            Validator<any>,
+            ...Validator<any>[],
+        ]
+>(
+    validators: TValidators
+): Validator<
+    InferValidator<
+        TValidators[number]
+    >
+> {
+    return new BcpValidator<
+        InferValidator<
+            TValidators[number]
+        >
+    >(
+        (
+            input,
+            path
+        ) => {
+            const issues:
+                ValidationIssue[] = [];
+
+            for (
+                const validator
+                of validators
+            ) {
+                const result =
+                    validator.safeParse(
+                        input,
+                        path
+                    );
+
+                if (result.success) {
+                    return result;
+                }
+
+                issues.push(
+                    ...result.issues
+                );
+            }
+
+            return createFailure(
+                issues.length > 0
+                    ? issues
+                    : [
+                        {
+                            path,
+                            message:
+                                "Value did not match any allowed type.",
+                            code:
+                                "invalid_union",
+                        },
+                    ]
+            );
+        }
+    );
+}
+
+export function optional<T>(
+    validator: Validator<T>
+): Validator<T | undefined> {
+    return validator.optional();
+}
+
+export function nullable<T>(
+    validator: Validator<T>
+): Validator<T | null> {
+    return validator.nullable();
+}
+
+export function safeParse<T>(
+    validator: Validator<T>,
+    input: unknown
+): ValidationResult<T> {
+    return validator.safeParse(
+        input
+    );
+}
+
+export function parse<T>(
+    validator: Validator<T>,
+    input: unknown
+): T {
+    return validator.parse(
+        input
+    );
+}
+
+export function validateFormData<T>(
+    validator: Validator<T>,
+    formData: FormData
+): ValidationResult<T> {
+    return validator.safeParse(
+        formDataToObject(
+            formData
+        )
+    );
+}
+
+export function formDataToObject(
+    formData: FormData
+): Record<string, unknown> {
+    const result:
+        Record<string, unknown> = {};
+
+    for (
+        const [
+            key,
+            value,
+        ]
+        of formData.entries()
+    ) {
+        const existing =
+            result[key];
+
+        if (
+            existing === undefined
+        ) {
+            result[key] =
+                value;
+            continue;
+        }
+
+        if (
+            Array.isArray(
+                existing
+            )
+        ) {
+            existing.push(
+                value
+            );
+            continue;
+        }
+
+        result[key] = [
+            existing,
+            value,
+        ];
+    }
+
+    return result;
+}
+
+export function flattenValidationIssues(
+    issues: readonly ValidationIssue[]
+): Pick<
+    ValidationFailure,
+    "fieldErrors" | "formErrors"
+> {
+    const fieldErrors:
+        Record<string, string[]> = {};
+    const formErrors:
+        string[] = [];
+
+    for (
+        const issue
+        of issues
+    ) {
+        if (
+            issue.path.length ===
+            0
+        ) {
+            formErrors.push(
+                issue.message
+            );
+            continue;
+        }
+
+        const field =
+            formatValidationPath(
+                issue.path
+            );
+
+        fieldErrors[field] ??=
+            [];
+        fieldErrors[field].push(
+            issue.message
+        );
+    }
+
+    return {
+        fieldErrors,
+        formErrors,
+    };
+}
+
+export function getFieldError(
+    result:
+        ValidationResult<unknown>,
+    field: string
+): string | undefined {
+    if (result.success) {
+        return undefined;
+    }
+
+    return result
+        .fieldErrors[field]?.[0];
+}
+
+export function isValidationError(
+    value: unknown
+): value is ValidationError {
+    return value instanceof
+        ValidationError;
+}
+
+export function formatValidationPath(
+    path: ValidationPath
+): string {
+    return path
+        .map(
+            String
+        )
+        .join(".");
+}
+
+export const v = {
+    string,
+    number,
+    boolean,
+    literal,
+    enum:
+        enumValue,
+    array,
+    object,
+    union,
+    optional,
+    nullable,
+} as const;
+
+function success<T>(
+    data: T
+): ValidationSuccess<T> {
+    return {
+        success: true,
+        data,
+    };
+}
+
+function failure(
+    path: ValidationPath,
+    message: string,
+    code: string
+): ValidationFailure {
+    return createFailure([
+        {
+            path:
+                [
+                    ...path,
+                ],
+            message,
+            code,
+        },
+    ]);
+}
+
+function createFailure(
+    sourceIssues:
+        readonly ValidationIssue[]
+): ValidationFailure {
+    const issues =
+        sourceIssues.map(
+            (issue) => ({
+                ...issue,
+                path: [
+                    ...issue.path,
+                ],
+            })
+        );
+    const flattened =
+        flattenValidationIssues(
+            issues
+        );
+
+    return {
+        success: false,
+        issues,
+        ...flattened,
+    };
+}
+
+function requiredOrTypeFailure(
+    input: unknown,
+    path: ValidationPath,
+    expected: string
+): ValidationFailure {
+    if (
+        input === undefined ||
+        input === null ||
+        input === ""
+    ) {
+        return failure(
+            path,
+            "Required.",
+            "required"
+        );
+    }
+
+    return failure(
+        path,
+        `Expected ${expected}.`,
+        "invalid_type"
+    );
+}
+
+function validateLengthOption(
+    value: number | undefined,
+    name: string
+): void {
+    if (
+        value !== undefined &&
+        (
+            !Number.isInteger(
+                value
+            ) ||
+            value < 0
+        )
+    ) {
+        throw new Error(
+            `BCP Validation: ${name} must be a non-negative integer.`
+        );
+    }
+}
+
+function isPlainObject(
+    value: unknown
+): value is Record<string, unknown> {
+    return (
+        typeof value ===
+            "object" &&
+        value !== null &&
+        !Array.isArray(
+            value
+        )
+    );
+}
+
+function isEmail(
+    value: string
+): boolean {
+    return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(
+        value
+    );
+}
+
+function testPattern(
+    pattern: RegExp,
+    value: string
+): boolean {
+    pattern.lastIndex =
+        0;
+
+    return pattern.test(
+        value
+    );
+}