@villedemontreal/caporal 3.1.7

package/src/validator/__tests__/array.spec.ts

@@ -0,0 +1,41 @@
+import { validateWithArray } from "../array"
+import { createArgument } from "../../argument"
+import { createOption } from "../../option"
+import { ValidationError } from "../../error"
+import { expect, it, describe } from "vitest"
+
+describe("validateWithArray()", () => {
+  const arg = createArgument("<fake>", "Fake arg")
+  const opt = createOption("--file <file>", "File")
+
+  it("should validate a valid string", () => {
+    expect(validateWithArray(["foo", "bar"], "bar", arg)).toEqual("bar")
+    expect(validateWithArray(["foo", "bar"], "bar", opt)).toEqual("bar")
+  })
+  it("should throw for an invalid string", () => {
+    expect(() => validateWithArray(["foo", "bar"], "invalid", arg)).toThrowError(
+      ValidationError,
+    )
+    expect(() => validateWithArray(["foo", "bar"], "invalid", opt)).toThrowError(
+      ValidationError,
+    )
+  })
+  it("should validate a valid string[]", () => {
+    expect(validateWithArray(["foo", "bar", "hey"], ["bar", "hey"], arg)).toEqual([
+      "bar",
+      "hey",
+    ])
+    expect(validateWithArray(["foo", "bar", "hey"], ["bar", "hey"], opt)).toEqual([
+      "bar",
+      "hey",
+    ])
+  })
+  it("should throw for an invalid string[]", () => {
+    expect(() =>
+      validateWithArray(["foo", "bar", "hey"], ["bar", "bad"], arg),
+    ).toThrowError(ValidationError)
+    expect(() =>
+      validateWithArray(["foo", "bar", "hey"], ["bar", "bad"], opt),
+    ).toThrowError(ValidationError)
+  })
+})

package/src/validator/__tests__/caporal.spec.ts

@@ -0,0 +1,132 @@
+import { createArgument } from "../../argument"
+import { createOption } from "../../option"
+import { ValidationError } from "../../error"
+import { validateWithCaporal, CaporalValidator } from "../caporal"
+import { expect, it, describe } from "vitest"
+
+describe("validateWithCaporal()", () => {
+  const arg = createArgument("<fake>", "Fake arg")
+  const opt = createOption("--file <file>", "File")
+
+  it("should work with an array validator", () => {
+    expect(validateWithCaporal(CaporalValidator.ARRAY, ["val2"], arg)).toEqual(["val2"])
+    expect(validateWithCaporal(CaporalValidator.ARRAY, ["val2"], opt)).toEqual(["val2"])
+    expect(validateWithCaporal(CaporalValidator.ARRAY, "hey", arg)).toEqual(["hey"])
+    expect(validateWithCaporal(CaporalValidator.ARRAY, "hey", opt)).toEqual(["hey"])
+    expect(validateWithCaporal(CaporalValidator.ARRAY, "hey,ho", arg)).toEqual([
+      "hey",
+      "ho",
+    ])
+
+    expect(validateWithCaporal(CaporalValidator.ARRAY, "hey,ho", opt)).toEqual([
+      "hey",
+      "ho",
+    ])
+
+    expect(validateWithCaporal(CaporalValidator.ARRAY, ["hey", "ho"], arg)).toEqual([
+      "hey",
+      "ho",
+    ])
+
+    expect(validateWithCaporal(CaporalValidator.ARRAY, ["hey", "ho"], opt)).toEqual([
+      "hey",
+      "ho",
+    ])
+
+    expect(validateWithCaporal(CaporalValidator.ARRAY, 123, arg)).toEqual([123])
+    expect(validateWithCaporal(CaporalValidator.ARRAY, 123, opt)).toEqual([123])
+  })
+  it("should work with an numeric validator", () => {
+    expect(validateWithCaporal(CaporalValidator.NUMBER, 123, arg)).toEqual(123)
+    expect(validateWithCaporal(CaporalValidator.NUMBER, 123, opt)).toEqual(123)
+    expect(validateWithCaporal(CaporalValidator.NUMBER, "123", arg)).toEqual(123)
+    expect(validateWithCaporal(CaporalValidator.NUMBER, "123", opt)).toEqual(123)
+    expect(validateWithCaporal(CaporalValidator.NUMBER, "3.14", arg)).toEqual(3.14)
+    expect(validateWithCaporal(CaporalValidator.NUMBER, "3.14", opt)).toEqual(3.14)
+    expect(() => validateWithCaporal(CaporalValidator.NUMBER, "hello", arg)).toThrowError(
+      ValidationError,
+    )
+    expect(() => validateWithCaporal(CaporalValidator.NUMBER, "hello", opt)).toThrowError(
+      ValidationError,
+    )
+    expect(() =>
+      validateWithCaporal(CaporalValidator.NUMBER, ["array"], arg),
+    ).toThrowError(ValidationError)
+
+    expect(() =>
+      validateWithCaporal(CaporalValidator.NUMBER, ["array"], opt),
+    ).toThrowError(ValidationError)
+
+    expect(() => validateWithCaporal(CaporalValidator.NUMBER, true, arg)).toThrowError(
+      ValidationError,
+    )
+
+    expect(() => validateWithCaporal(CaporalValidator.NUMBER, true, opt)).toThrowError(
+      ValidationError,
+    )
+
+    expect(() => validateWithCaporal(CaporalValidator.NUMBER, false, arg)).toThrowError(
+      ValidationError,
+    )
+    expect(() => validateWithCaporal(CaporalValidator.NUMBER, false, opt)).toThrowError(
+      ValidationError,
+    )
+  })
+
+  it("should work with an string validator", () => {
+    expect(validateWithCaporal(CaporalValidator.STRING, "hey", arg)).toEqual("hey")
+    expect(validateWithCaporal(CaporalValidator.STRING, "hey", opt)).toEqual("hey")
+    expect(validateWithCaporal(CaporalValidator.STRING, 1, opt)).toEqual("1")
+    expect(validateWithCaporal(CaporalValidator.STRING, 3.14, opt)).toEqual("3.14")
+    expect(validateWithCaporal(CaporalValidator.STRING, true, opt)).toEqual("true")
+    expect(validateWithCaporal(CaporalValidator.STRING, false, opt)).toEqual("false")
+    expect(() =>
+      validateWithCaporal(CaporalValidator.STRING, ["hello"], arg),
+    ).toThrowError(ValidationError)
+    expect(() =>
+      validateWithCaporal(CaporalValidator.STRING, ["hello"], opt),
+    ).toThrowError(ValidationError)
+  })
+
+  it("should work with an boolean validator", () => {
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, true, arg)).toEqual(true)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, true, opt)).toEqual(true)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, false, arg)).toEqual(false)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, false, opt)).toEqual(false)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, 1, arg)).toEqual(true)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, 1, opt)).toEqual(true)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, 0, arg)).toEqual(false)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, 0, opt)).toEqual(false)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, "true", arg)).toEqual(true)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, "true", opt)).toEqual(true)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, "false", arg)).toEqual(false)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, "false", opt)).toEqual(false)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, "yes", arg)).toEqual(true)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, "yes", opt)).toEqual(true)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, "no", arg)).toEqual(false)
+    expect(validateWithCaporal(CaporalValidator.BOOLEAN, "no", opt)).toEqual(false)
+    expect(() =>
+      validateWithCaporal(CaporalValidator.BOOLEAN, ["hello"], arg),
+    ).toThrowError(ValidationError)
+
+    expect(() =>
+      validateWithCaporal(CaporalValidator.BOOLEAN, ["hello"], opt),
+    ).toThrowError(ValidationError)
+
+    expect(() =>
+      validateWithCaporal(CaporalValidator.BOOLEAN, "unknown", arg),
+    ).toThrowError(ValidationError)
+
+    expect(() =>
+      validateWithCaporal(CaporalValidator.BOOLEAN, "unknown", opt),
+    ).toThrowError(ValidationError)
+
+    expect(() => validateWithCaporal(CaporalValidator.BOOLEAN, 2, arg)).toThrowError(
+      ValidationError,
+    )
+
+    expect(() => validateWithCaporal(CaporalValidator.BOOLEAN, 2, opt)).toThrowError(
+      ValidationError,
+    )
+  })
+})

package/src/validator/__tests__/function.spec.ts

@@ -0,0 +1,52 @@
+import { validateWithFunction } from "../function"
+import { createArgument } from "../../argument"
+import { createOption } from "../../option"
+import { ValidationError } from "../../error"
+import { FunctionValidator } from "../../types"
+import { expect, it, describe } from "vitest"
+
+describe("validateWithFunction()", () => {
+  const validator: FunctionValidator = function (value) {
+    if (value !== "hey" && value !== "ho") {
+      throw Error("my error")
+    }
+    return value
+  }
+  const arg = createArgument("<fake>", "Fake arg", { validator })
+  const opt = createOption("--file <file>", "File")
+
+  it("should validate a valid value", async () => {
+    await expect(validateWithFunction(validator, "hey", arg)).resolves.toEqual("hey")
+    await expect(validateWithFunction(validator, "hey", opt)).resolves.toEqual("hey")
+  })
+
+  it("should throw for an invalid value", async () => {
+    await expect(validateWithFunction(validator, "invalid", arg)).rejects.toBeInstanceOf(
+      ValidationError,
+    )
+    await expect(validateWithFunction(validator, "invalid", opt)).rejects.toBeInstanceOf(
+      ValidationError,
+    )
+  })
+  it("should validate a valid array", async () => {
+    await expect(validateWithFunction(validator, ["ho"], arg)).resolves.toEqual(["ho"])
+    await expect(validateWithFunction(validator, ["ho"], opt)).resolves.toEqual(["ho"])
+    await expect(validateWithFunction(validator, ["ho", "hey"], arg)).resolves.toEqual([
+      "ho",
+      "hey",
+    ])
+    await expect(validateWithFunction(validator, ["ho", "hey"], opt)).resolves.toEqual([
+      "ho",
+      "hey",
+    ])
+  })
+  it("should throw for an invalid array", async () => {
+    await expect(
+      validateWithFunction(validator, ["invalid", "hey"], arg),
+    ).rejects.toBeInstanceOf(ValidationError)
+
+    await expect(
+      validateWithFunction(validator, ["invalid", "hey"], opt),
+    ).rejects.toBeInstanceOf(ValidationError)
+  })
+})

package/src/validator/__tests__/regexp.spec.ts

@@ -0,0 +1,38 @@
+import { expect, it, describe } from "vitest"
+
+import { validateWithRegExp } from "../regexp"
+import { createArgument } from "../../argument"
+import { createOption } from "../../option"
+import { ValidationError } from "../../error"
+
+describe("validateWithRegExp()", () => {
+  const arg = createArgument("<fake>", "Fake arg")
+  const opt = createOption("--file <file>", "File")
+
+  it("should validate a valid string", () => {
+    expect(validateWithRegExp(/^ex/, "example", arg)).toEqual("example")
+    expect(validateWithRegExp(/^ex/, "example", opt)).toEqual("example")
+  })
+  it("should throw for an invalid string", () => {
+    expect(() => validateWithRegExp(/^ex/, "invalid", arg)).toThrowError(ValidationError)
+    expect(() => validateWithRegExp(/^ex/, "invalid", opt)).toThrowError(ValidationError)
+  })
+  it("should validate a valid string[]", () => {
+    expect(validateWithRegExp(/^ex/, ["example", "executor"], arg)).toEqual([
+      "example",
+      "executor",
+    ])
+    expect(validateWithRegExp(/^ex/, ["example", "executor"], opt)).toEqual([
+      "example",
+      "executor",
+    ])
+  })
+  it("should throw for an invalid string[]", () => {
+    expect(() => validateWithRegExp(/^ex/, ["example", "invalid"], arg)).toThrowError(
+      ValidationError,
+    )
+    expect(() => validateWithRegExp(/^ex/, ["example", "invalid"], opt)).toThrowError(
+      ValidationError,
+    )
+  })
+})

package/src/validator/__tests__/utils.spec.ts

@@ -0,0 +1,67 @@
+import { checkValidator, getTypeHint } from "../utils"
+import { createOption } from "../../option"
+import { InvalidValidatorError } from "../../error"
+import { CaporalValidator } from "../../types"
+import isNumber from "lodash/isNumber"
+import { expect, it, describe } from "vitest"
+
+const validators = Object.values(CaporalValidator).filter(isNumber)
+
+describe("validator / utils", () => {
+  describe("checkValidator()", () => {
+    it("should throw InvalidValidatorError for an invalid Caporal Validator", () => {
+      // @ts-expect-error for tests
+      expect(() => checkValidator(1001)).toThrowError(InvalidValidatorError)
+    })
+    it("should throw InvalidValidatorError for all valid Caporal Validators", () => {
+      // @ts-expect-error for tests
+      expect(() => checkValidator(1001)).toThrowError(InvalidValidatorError)
+    })
+    it.each(validators)("should not throw for %d", (v) => {
+      expect(() => checkValidator(v)).not.toThrowError(InvalidValidatorError)
+    })
+
+    it("should throw for an invalid caporal validator", () => {
+      // @ts-expect-error for tests
+      expect(() => checkValidator(1000)).toThrowError(InvalidValidatorError)
+    })
+
+    it("should throw for an invalid user defined validator", () => {
+      // @ts-expect-error for tests
+      expect(() => checkValidator("wrong")).toThrowError(InvalidValidatorError)
+    })
+  })
+
+  describe("getTypeHint()", () => {
+    it("should return 'boolean' for a boolean option whose default is true", () => {
+      const opt = createOption("--use-this", "Use this", { default: true })
+      expect(getTypeHint(opt)).toBe("boolean")
+    })
+    it("should return a JSON for an array-validator", () => {
+      const opt = createOption("--name <name>", "Your name", {
+        validator: ["john", "jesse"],
+      })
+      expect(getTypeHint(opt)).toBe('one of "john","jesse"')
+    })
+    it("should return undefined for an array-validator if the JSON representation is too long", () => {
+      const arr = new Array(120).fill("str".repeat(15))
+      const opt = createOption("--name <name>", "Your name", {
+        validator: arr,
+      })
+      expect(getTypeHint(opt)).toBeUndefined()
+    })
+    it("should throw InvalidValidatorError for all valid Caporal Validators", () => {
+      // @ts-expect-error for tests
+      expect(() => checkValidator(1001)).toThrowError(InvalidValidatorError)
+    })
+
+    it.each(validators)("should not throw for %d", (v) => {
+      expect(() => checkValidator(v)).not.toThrowError(InvalidValidatorError)
+    })
+
+    it("should throw for an invalid user defined validator", () => {
+      // @ts-expect-error for tests
+      expect(() => checkValidator("wrong")).toThrowError(InvalidValidatorError)
+    })
+  })
+})

package/src/validator/__tests__/validate.spec.ts

@@ -0,0 +1,24 @@
+import { validate } from "../validate"
+import { createArgument } from "../../argument"
+import { FunctionValidator } from "../../types"
+import { expect, it, describe } from "vitest"
+
+describe("validate()", () => {
+  const arg = createArgument("<fake>", "Fake arg")
+  it("should handle function validators", () => {
+    const validator: FunctionValidator = function (value) {
+      if (value !== "hey" && value !== "ho") {
+        throw Error("my error")
+      }
+      return value
+    }
+    return expect(validate("hey", validator, arg)).resolves.toEqual("hey")
+  })
+  it("should handle regexp validators", () => {
+    return expect(validate("TEST", /[A-Z]+/, arg)).toEqual("TEST")
+  })
+  it("should handle unknown validators", () => {
+    // @ts-expect-error for tests
+    return expect(validate("TEST", 1000, arg)).toEqual("TEST")
+  })
+})

package/src/validator/array.ts

@@ -0,0 +1,31 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+
+import type { ParserTypes, Argument, Option } from "../types"
+import { ValidationError } from "../error"
+
+/**
+ * Validate using an array of valid values.
+ *
+ * @param validator
+ * @param value
+ * @ignore
+ */
+export function validateWithArray(
+  validator: ParserTypes[],
+  value: ParserTypes | ParserTypes[],
+  context: Argument | Option,
+): ParserTypes | ParserTypes[] {
+  if (Array.isArray(value)) {
+    value.forEach((v) => validateWithArray(validator, v, context))
+  } else if (validator.includes(value) === false) {
+    throw new ValidationError({
+      validator,
+      value,
+      context,
+    })
+  }
+  return value
+}

package/src/validator/caporal.ts

@@ -0,0 +1,104 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+
+import type { ParserTypes, Argument, Option } from "../types"
+import { CaporalValidator } from "../types"
+import { ValidationError } from "../error"
+import { isNumeric } from "../option/utils"
+import flatMap from "lodash/flatMap"
+
+import {
+  isNumericValidator,
+  isStringValidator,
+  isBoolValidator,
+  isArrayValidator,
+} from "./utils"
+
+// Re-export for convenience
+export { CaporalValidator }
+
+export function validateWithCaporal(
+  validator: CaporalValidator,
+  value: ParserTypes | ParserTypes[],
+  context: Argument | Option,
+  skipArrayValidation = false,
+): ParserTypes | ParserTypes[] {
+  if (!skipArrayValidation && isArrayValidator(validator)) {
+    return validateArrayFlag(validator, value, context)
+  } else if (Array.isArray(value)) {
+    // should not happen!
+    throw new ValidationError({
+      error: "Expected a scalar value, got an array",
+      value,
+      validator,
+      context,
+    })
+  } else if (isNumericValidator(validator)) {
+    return validateNumericFlag(validator, value, context)
+  } else if (isStringValidator(validator)) {
+    return validateStringFlag(value)
+  } else if (isBoolValidator(validator)) {
+    return validateBoolFlag(value, context)
+  }
+  return value
+}
+
+/**
+ * The string validator actually just cast the value to string
+ *
+ * @param value
+ * @ignore
+ */
+export function validateBoolFlag(
+  value: ParserTypes,
+  context: Argument | Option,
+): boolean {
+  if (typeof value === "boolean") {
+    return value
+  } else if (/^(true|false|yes|no|0|1)$/i.test(String(value)) === false) {
+    throw new ValidationError({
+      value,
+      validator: CaporalValidator.BOOLEAN,
+      context,
+    })
+  }
+  return /^0|no|false$/.test(String(value)) === false
+}
+
+export function validateNumericFlag(
+  validator: number,
+  value: ParserTypes,
+  context: Argument | Option,
+): number {
+  const str = value + ""
+  if (Array.isArray(value) || !isNumeric(str)) {
+    throw new ValidationError({
+      value,
+      validator,
+      context,
+    })
+  }
+  return parseFloat(str)
+}
+
+export function validateArrayFlag(
+  validator: number,
+  value: ParserTypes | ParserTypes[],
+  context: Argument | Option,
+): ParserTypes | ParserTypes[] {
+  const values: ParserTypes[] =
+    typeof value === "string" ? value.split(",") : !Array.isArray(value) ? [value] : value
+  return flatMap(values, (el) => validateWithCaporal(validator, el, context, true))
+}
+
+/**
+ * The string validator actually just cast the value to string
+ *
+ * @param value
+ * @ignore
+ */
+export function validateStringFlag(value: ParserTypes | ParserTypes[]): string {
+  return value + ""
+}

package/src/validator/function.ts

@@ -0,0 +1,31 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+
+import type { ParserTypes, FunctionValidator, Argument, Option } from "../types"
+import { ValidationError } from "../error"
+
+export async function validateWithFunction(
+  validator: FunctionValidator,
+  value: ParserTypes | ParserTypes[],
+  context: Argument | Option,
+): Promise<ParserTypes | ParserTypes[]> {
+  if (Array.isArray(value)) {
+    return Promise.all(
+      value.map((v) => {
+        return validateWithFunction(validator, v, context) as Promise<ParserTypes>
+      }),
+    )
+  }
+  try {
+    return await validator(value)
+  } catch (error) {
+    throw new ValidationError({
+      validator,
+      value,
+      error,
+      context,
+    })
+  }
+}

package/src/validator/regexp.ts

@@ -0,0 +1,34 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+
+import type { ParserTypes, Argument, Option } from "../types"
+import { ValidationError } from "../error"
+
+/**
+ * Validate using a RegExp
+ *
+ * @param validator
+ * @param value
+ * @ignore
+ */
+export function validateWithRegExp(
+  validator: RegExp,
+  value: ParserTypes | ParserTypes[],
+  context: Argument | Option,
+): ParserTypes | ParserTypes[] {
+  if (Array.isArray(value)) {
+    return value.map((v) => {
+      return validateWithRegExp(validator, v, context) as ParserTypes
+    })
+  }
+  if (!validator.test(value + "")) {
+    throw new ValidationError({
+      validator: validator,
+      value,
+      context,
+    })
+  }
+  return value
+}

package/src/validator/utils.ts

@@ -0,0 +1,84 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+
+import type { Validator } from "../types"
+import { CaporalValidator, Argument, Option } from "../types"
+import isNumber from "lodash/isNumber"
+import { InvalidValidatorError } from "../error"
+
+export function isCaporalValidator(
+  validator: Validator | undefined,
+): validator is number {
+  if (typeof validator !== "number") {
+    return false
+  }
+  const mask = getCaporalValidatorsMask()
+  const exist = (mask & validator) === validator
+  return exist
+}
+
+export function isNumericValidator(validator: Validator | undefined): boolean {
+  return isCaporalValidator(validator) && Boolean(validator & CaporalValidator.NUMBER)
+}
+
+export function isStringValidator(validator: Validator | undefined): boolean {
+  return isCaporalValidator(validator) && Boolean(validator & CaporalValidator.STRING)
+}
+
+export function isBoolValidator(validator: Validator | undefined): boolean {
+  return isCaporalValidator(validator) && Boolean(validator & CaporalValidator.BOOLEAN)
+}
+
+export function isArrayValidator(validator: Validator | undefined): boolean {
+  return isCaporalValidator(validator) && Boolean(validator & CaporalValidator.ARRAY)
+}
+
+function getCaporalValidatorsMask(): number {
+  return Object.values(CaporalValidator)
+    .filter(isNumber)
+    .reduce((a, b) => a | b, 0)
+}
+
+function checkCaporalValidator(validator: CaporalValidator): void {
+  if (!isCaporalValidator(validator)) {
+    throw new InvalidValidatorError(validator)
+  }
+}
+
+function checkUserDefinedValidator(validator: Validator): void {
+  if (
+    typeof validator !== "function" &&
+    !(validator instanceof RegExp) &&
+    !Array.isArray(validator)
+  ) {
+    throw new InvalidValidatorError(validator)
+  }
+}
+
+export function checkValidator(validator: Validator | undefined): void {
+  if (validator !== undefined) {
+    typeof validator === "number"
+      ? checkCaporalValidator(validator)
+      : checkUserDefinedValidator(validator)
+  }
+}
+
+export function getTypeHint(obj: Argument | Option): string | undefined {
+  let hint
+  if (
+    isBoolValidator(obj.validator) ||
+    ("boolean" in obj && obj.boolean && obj.default !== false)
+  ) {
+    hint = "boolean"
+  } else if (isNumericValidator(obj.validator)) {
+    hint = "number"
+  } else if (Array.isArray(obj.validator)) {
+    const stringified = JSON.stringify(obj.validator)
+    if (stringified.length < 300) {
+      hint = "one of " + stringified.substr(1, stringified.length - 2)
+    }
+  }
+  return hint
+}

package/src/validator/validate.ts

@@ -0,0 +1,38 @@
+/**
+ * @packageDocumentation
+ * @internal
+ */
+
+import type {
+  Validator,
+  Promisable,
+  ParsedOption,
+  ParsedArgument,
+  Argument,
+  Option,
+} from "../types"
+
+import { validateWithRegExp } from "./regexp"
+import { validateWithArray } from "./array"
+import { validateWithFunction } from "./function"
+import { validateWithCaporal } from "./caporal"
+import { isCaporalValidator } from "./utils"
+
+export function validate(
+  value: ParsedOption | ParsedArgument,
+  validator: Validator,
+  context: Argument | Option,
+): Promisable<ParsedOption | ParsedArgument> {
+  if (typeof validator === "function") {
+    return validateWithFunction(validator, value, context)
+  } else if (validator instanceof RegExp) {
+    return validateWithRegExp(validator, value, context)
+  } else if (Array.isArray(validator)) {
+    return validateWithArray(validator, value, context)
+  }
+  // Caporal flag validator
+  else if (isCaporalValidator(validator)) {
+    return validateWithCaporal(validator, value, context)
+  }
+  return value
+}