daaku.schema — daaku/schema 2.0.0

boolean clj/s

(boolean)

(boolean {:keys [msg] :or {msg "This must be a boolean."}})

Indicates the field must be a boolean.

comp clj/s

(comp & fns)

Compose multiple validators together.

default clj/s

(default d)

Provides a default value to be used when the provided value is nil.

double clj/s

(double)

(double {:keys [msg] :or {msg "This must be a double."}})

Indicates the field must be a double.

error clj/s

(error v)

Use this function to return an error on validation failure.

error-value clj/s

(error-value v)

Returns the error value from v.

error? clj/s

(error? v)

Returns true if v contains an error.

float clj/s

(float)

(float {:keys [msg] :or {msg "This must be a float."}})

Indicates the field must be a float.

greater-or-equal clj/s

(greater-or-equal target)

(greater-or-equal target
                  {:keys [msg]
                   :or {msg "This value is less than the allowed value."}})

Ensure the value is greater than or equal to the provided value. Comparisons are made using compare.

greater-than clj/s

(greater-than target)

(greater-than target
              {:keys [msg]
               :or {msg "This value is less than the allowed value."}})

Ensure the value is greater than the provided value. Comparisons are made using compare.

in clj/s

(in coll)

(in coll {:keys [msg] :or {msg "This is not one of the allowed values."}})

Indicates the field must be contained as defined by contains? in the collection provided as in.

int clj/s

(int)

(int {:keys [msg] :or {msg "This must be a integer."}})

Indicates the field must be a integer.

keyword clj/s

(keyword)

(keyword {:keys [msg] :or {msg "This must be a keyword."}})

Indicates the field must be a keyword.

less-or-equal clj/s

(less-or-equal target)

(less-or-equal target
               {:keys [msg]
                :or {msg "This value is more than the allowed value."}})

Ensure the value is less than or equal to the provided value. Comparisons are made using compare.

less-than clj/s

(less-than target)

(less-than target
           {:keys [msg] :or {msg "This value is more than the allowed value."}})

Ensure the value is less than the provided value. Comparisons are made using compare.

long clj/s≠

clj

(long)

(long {:keys [msg] :or {msg "This must be a long."}})

Indicates the field must be a long.

cljs

negative clj/s

(negative)

(negative {:keys [msg] :or {msg "This value must be negative."}})

Ensure the value is negative checked by neg?.

non-empty clj/s

(non-empty)

(non-empty {:keys [msg] :or {msg "This value cannot be empty."}})

Ensures the value is non-empty.

number clj/s

(number)

(number {:keys [msg] :or {msg "This must be a number."}})

Indicates the field must be a number.

optional clj/s

(optional)

Indicates the field is optional.

positive clj/s

(positive)

(positive {:keys [msg] :or {msg "This value must be positive."}})

Ensure the value is positive checked by pos?.

range clj/s

(range start end)

(range start
       end
       {:keys [msg] :or {msg "This value is outside the allowed range."}})

Ensure the value is the given range, start and end inclusive. Comparisons are made using compare.

re-match clj/s

(re-match re)

(re-match re
          {:keys [msg]
           :or {msg "This value does not match the expected pattern."}})

Ensure the value matches the provided regular expression. If the value is not a string, it is considered not to match.

required clj/s

(required)

(required {:keys [msg] :or {msg "This must be provided."}})

Indicates the field is required.

schema clj/s

(schema m)

(schema m
        {:keys [extra msg]
         :or {extra :fail msg "This field was not expected."}})

Schema takes a map of keys to validators. Optionally :extra can be configured to one of :fail (the default), :drop or :pass to indicate the behavior of extra keys.

set clj/s

(set)

(set {:keys [msg] :or {msg "This must be a set."}})

Indicates the field must be a set.

string clj/s

(string)

(string {:keys [msg] :or {msg "This must be a string."}})

Indicates the field must be a string.

to-boolean clj/s

(to-boolean)

(to-boolean {:keys [msg]
             :or {msg "This value could not be converted to a boolean."}})

Parse strings using the following rules: true | yes | enable | on | 1 => true false | no | disable | off | 0 => false

Parse numbers using the following rules: 1 => true 0 => false

Other values are unacceptable.

to-double clj/s≠

clj

(to-double)

(to-double {:keys [msg]
            :or {msg "This value could not be converted to a double."}})

Parse strings using Double/parseDouble and cast other values using double.

cljs

to-float clj/s

(to-float)

(to-float {:keys [msg]
           :or {msg "This value could not be converted to a float."}})

Parse strings using Float/parseInt and cast other values using float.

to-int clj/s

(to-int)

(to-int {:keys [msg]
         :or {msg "This value could not be converted to an integer."}})

Parse strings using Integer/parseInt and cast other values using int.

to-set clj/s

(to-set)

(to-set sc)

Convert a collection or a single value into a set. Optionally applies the given schema to each value.

to-string clj/s

(to-string)

Apply str to input.

to-vector clj/s

(to-vector)

(to-vector sc)

Convert a collection or a single value into a vector. Optionally applies the given schema to each value.

trim clj/s

(trim)

Trims leading and trailing whitespace.

vector clj/s

(vector)

(vector {:keys [msg] :or {msg "This must be a vector."}})

Indicates the field must be a vector.

zero-or-positive clj/s

(zero-or-positive)

(zero-or-positive {:keys [msg]
                   :or {msg "This value must be zero or positive."}})

Ensure the value is zero or positive checked by pos?.