Servant.Util.Combinators.Filtering

Allows complex filtering on specified fields.

General

data FilterKind a

We support two kinds of filters.

Constructors

AutoFilter a

Automatic filter where different operations are supported (eq, in, cmp). When applied to backend, only filtered value should be supplied.

ManualFilter a

User-provided value is passed to backend implementation as-is, and filtering on this value should be written manually.

Instances

FilterBackend backend => BackendApplySomeFilter (backend :: k) ('[] :: [TyNamedFilter])

Defined in Servant.Util.Combinators.Filtering.Backend

Methods

backendApplySomeFilter' :: FilteringSpecApp backend '[] -> SomeFilter '[] -> Maybe (MatchPredicate backend)

(Typeable fk, Typeable a, FilterBackend backend, KnownSymbol name, BackendApplyTypeFilter backend fk a, BackendApplySomeFilter backend params) => BackendApplySomeFilter (backend :: k) ('TyNamedParam name (fk a) ': params)

Defined in Servant.Util.Combinators.Filtering.Backend

Methods

backendApplySomeFilter' :: FilteringSpecApp backend ('TyNamedParam name (fk a) ': params) -> SomeFilter ('TyNamedParam name (fk a) ': params) -> Maybe (MatchPredicate backend)

AreFilteringParams ('[] :: [TyNamedFilter])

Defined in Servant.Util.Combinators.Filtering.Server

Methods

parseFilteringParam :: Text -> Text -> Maybe (Either Text $ SomeFilter '[])

BuildSomeFilter ('[] :: [TyNamedFilter])

Defined in Servant.Util.Combinators.Filtering.Logging

Methods

buildSomeFilter' :: SomeFilter '[] -> Maybe Builder

(FromHttpApiData ty, Buildable ty, Typeable ty, KnownSymbol name, AreFilteringParams params) => AreFilteringParams ('TyNamedParam name ('ManualFilter ty) ': params)

Defined in Servant.Util.Combinators.Filtering.Server

Methods

parseFilteringParam :: Text -> Text -> Maybe (Either Text $ SomeFilter ('TyNamedParam name ('ManualFilter ty) ': params))

(FromHttpApiData ty, Typeable ty, AreAutoFilters (SupportedFilters ty), KnownSymbol name, AreFilteringParams params) => AreFilteringParams ('TyNamedParam name ('AutoFilter ty) ': params)

Defined in Servant.Util.Combinators.Filtering.Server

Methods

parseFilteringParam :: Text -> Text -> Maybe (Either Text $ SomeFilter ('TyNamedParam name ('AutoFilter ty) ': params))

(KnownSymbol name, Typeable a, Buildable a, BuildSomeFilter params) => BuildSomeFilter ('TyNamedParam name ('ManualFilter a) ': params)

Defined in Servant.Util.Combinators.Filtering.Logging

Methods

buildSomeFilter' :: SomeFilter ('TyNamedParam name ('ManualFilter a) ': params) -> Maybe Builder

(KnownSymbol name, Typeable a, Buildable a, BuildSomeFilter params) => BuildSomeFilter ('TyNamedParam name ('AutoFilter a) ': params)

Defined in Servant.Util.Combinators.Filtering.Logging

Methods

buildSomeFilter' :: SomeFilter ('TyNamedParam name ('AutoFilter a) ': params) -> Maybe Builder

data FilteringParams (params :: [TyNamedFilter])

Servant API combinator which enables filtering on given fields.

If type T appears with a name name in params argument, then query parameters of name[op]=value format will be accepted, where op is a filtering operation (e.g. equal, not equal, greater) and value is an item of type T we filter against. Multiple filters will form a conjunction.

List of allowed filtering operations depends on type T and is specified by SupportedFilters type family.

Operation argument is optional, when not specified "equality" filter is applied.

Endpoint implementation will receive FilteringSpec value which contains information about all filters passed by user. You can later put it to an appropriate function to apply filtering.

Instances

(HasClient m subApi, SomeFilterToReq params) => HasClient m (FilteringParams params :> subApi)

Defined in Servant.Util.Combinators.Filtering.Client

Associated Types

type Client m (FilteringParams params :> subApi)

Methods

clientWithRoute :: Proxy m -> Proxy (FilteringParams params :> subApi) -> Request -> Client m (FilteringParams params :> subApi)

hoistClientMonad :: Proxy m -> Proxy (FilteringParams params :> subApi) -> (forall x. mon x -> mon' x) -> Client mon (FilteringParams params :> subApi) -> Client mon' (FilteringParams params :> subApi)

(HasLoggingServer config lcontext subApi ctx, AreFilteringParams params, ReifyParamsNames params, BuildSomeFilter params) => HasLoggingServer (config :: Type) lcontext (FilteringParams params :> subApi :: Type) ctx

Defined in Servant.Util.Combinators.Filtering.Logging

Methods

routeWithLog :: Proxy (LoggingApiRec config lcontext (FilteringParams params :> subApi)) -> Context ctx -> Delayed env (Server (LoggingApiRec config lcontext (FilteringParams params :> subApi))) -> Router env

(HasSwagger api, ReifyParamsNames params, FilterParamsHaveSwagger params) => HasSwagger (FilteringParams params :> api :: Type)

Defined in Servant.Util.Combinators.Filtering.Swagger

Methods

toSwagger :: Proxy (FilteringParams params :> api) -> Swagger

(HasServer subApi ctx, AreFilteringParams params) => HasServer (FilteringParams params :> subApi :: Type) ctx

Defined in Servant.Util.Combinators.Filtering.Server

Associated Types

type ServerT (FilteringParams params :> subApi) m

Methods

route :: Proxy (FilteringParams params :> subApi) -> Context ctx -> Delayed env (Server (FilteringParams params :> subApi)) -> Router env

hoistServerWithContext :: Proxy (FilteringParams params :> subApi) -> Proxy ctx -> (forall x. m x -> n x) -> ServerT (FilteringParams params :> subApi) m -> ServerT (FilteringParams params :> subApi) n

type Client m (FilteringParams params :> subApi)

Defined in Servant.Util.Combinators.Filtering.Client

type Client m (FilteringParams params :> subApi) = FilteringSpec params -> Client m subApi

type ServerT (FilteringParams params :> subApi :: Type) m

Defined in Servant.Util.Combinators.Filtering.Server

type ServerT (FilteringParams params :> subApi :: Type) m = FilteringSpec params -> ServerT subApi m

type family SupportedFilters ty :: [Type -> Type]

For a type of field, get a list of supported filtering operations on this field.

Instances

type SupportedFilters Bool

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Bool = '[FilterMatching]

type SupportedFilters Char

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Char = '[FilterMatching, FilterComparing]

type SupportedFilters Double

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Double = NumericFilterTypes

type SupportedFilters Float

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Float = NumericFilterTypes

type SupportedFilters Int

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Int = NumericFilterTypes

type SupportedFilters Int8

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Int8 = NumericFilterTypes

type SupportedFilters Int16

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Int16 = NumericFilterTypes

type SupportedFilters Int32

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Int32 = NumericFilterTypes

type SupportedFilters Int64

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Int64 = NumericFilterTypes

type SupportedFilters Integer

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Integer = NumericFilterTypes

type SupportedFilters Natural

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Natural = NumericFilterTypes

type SupportedFilters Word

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Word = NumericFilterTypes

type SupportedFilters Word8

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Word8 = NumericFilterTypes

type SupportedFilters Word16

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Word16 = NumericFilterTypes

type SupportedFilters Word32

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Word32 = NumericFilterTypes

type SupportedFilters Word64

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Word64 = NumericFilterTypes

type SupportedFilters ()

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters () = '[] :: [Type -> Type]

type SupportedFilters ByteString

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters ByteString

type SupportedFilters Text

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Text = TextFilterTypes

type SupportedFilters UTCTime

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters UTCTime = DatetimeFilterTypes

type SupportedFilters LocalTime

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters LocalTime = DatetimeFilterTypes

type SupportedFilters Day

Defined in Servant.Util.Combinators.Filtering.Support

type SupportedFilters Day = NumericFilterTypes

newtype FilteringSpec (params :: [TyNamedFilter])

This is what you get in endpoint implementation, it contains all filters supplied by a user. Invariant: each filter correspond to some type mentioned in params.

Constructors

FilteringSpec [SomeFilter params]

Instances

IsList (FilteringSpec params)

Defined in Servant.Util.Combinators.Filtering.Base

Associated Types

type Item (FilteringSpec params)

Methods

fromList :: [Item (FilteringSpec params)] -> FilteringSpec params

fromListN :: Int -> [Item (FilteringSpec params)] -> FilteringSpec params

toList :: FilteringSpec params -> [Item (FilteringSpec params)]

Default (FilteringSpec params)

By default noFilters is used.

Defined in Servant.Util.Combinators.Filtering.Construction

Methods

def :: FilteringSpec params

type Item (FilteringSpec params)

Defined in Servant.Util.Combinators.Filtering.Base

type Item (FilteringSpec params) = Item [SomeFilter params]

Shortcuts

type family FilteringParamTypesOf a :: [TyNamedFilter]

For a given return type of an endpoint get corresponding filtering params. This mapping is sensible, since we usually allow to filter only on fields appearing in endpoint's response.

Instances

type FilteringParamTypesOf NoContent

Defined in Servant.Util.Combinators.Filtering.Base

type FilteringParamTypesOf NoContent = '[] :: [TyNamedFilter]

type FilteringParamsOf a = FilteringParams (FilteringParamTypesOf a)

This you will most probably want to specify in API.

type FilteringSpecOf a = FilteringSpec (FilteringParamTypesOf a)

This you will most probably want to specify in an endpoint implementation.

Filter types

data FilterMatching a

Support for (==), (/=) and IN list operations.

Constructors

FilterMatching a

FilterNotMatching a

FilterItemsIn [a]

Instances

Functor FilterMatching

Defined in Servant.Util.Combinators.Filtering.Filters.General

Methods

fmap :: (a -> b) -> FilterMatching a -> FilterMatching b

(<$) :: a -> FilterMatching b -> FilterMatching a

IsAutoFilter FilterMatching

Defined in Servant.Util.Combinators.Filtering.Filters.General

Methods

autoFilterEnglishOpsNames :: OpsDescriptions

autoFilterParsers :: FromHttpApiData a => Proxy FilterMatching -> Map Text (FilteringValueParser (FilterMatching a))

autoFilterEncode :: ToHttpApiData a => FilterMatching a -> (Text, Text)

mapAutoFilterValue :: (a -> b) -> FilterMatching a -> FilterMatching b

BuildableAutoFilter FilterMatching

Defined in Servant.Util.Combinators.Filtering.Filters.General

Methods

buildAutoFilter :: Buildable a => Text -> FilterMatching a -> Builder

data FilterComparing a

Support for (<), (>), (<=) and (>=) operations.

Constructors

FilterGT a

FilterLT a

FilterGTE a

FilterLTE a

Instances

Functor FilterComparing

Defined in Servant.Util.Combinators.Filtering.Filters.General

Methods

fmap :: (a -> b) -> FilterComparing a -> FilterComparing b

(<$) :: a -> FilterComparing b -> FilterComparing a

IsAutoFilter FilterComparing

Defined in Servant.Util.Combinators.Filtering.Filters.General

Methods

autoFilterEnglishOpsNames :: OpsDescriptions

autoFilterParsers :: FromHttpApiData a => Proxy FilterComparing -> Map Text (FilteringValueParser (FilterComparing a))

autoFilterEncode :: ToHttpApiData a => FilterComparing a -> (Text, Text)

mapAutoFilterValue :: (a -> b) -> FilterComparing a -> FilterComparing b

BuildableAutoFilter FilterComparing

Defined in Servant.Util.Combinators.Filtering.Filters.General

Methods

buildAutoFilter :: Buildable a => Text -> FilterComparing a -> Builder

data FilterLike a

Support for SQL's LIKE syntax.

Constructors

FilterLike CaseSensitivity LikePattern

Instances

Functor FilterLike

Defined in Servant.Util.Combinators.Filtering.Filters.Like

Methods

fmap :: (a -> b) -> FilterLike a -> FilterLike b

(<$) :: a -> FilterLike b -> FilterLike a

IsAutoFilter FilterLike

Defined in Servant.Util.Combinators.Filtering.Filters.Like

Methods

autoFilterEnglishOpsNames :: OpsDescriptions

autoFilterParsers :: FromHttpApiData a => Proxy FilterLike -> Map Text (FilteringValueParser (FilterLike a))

autoFilterEncode :: ToHttpApiData a => FilterLike a -> (Text, Text)

mapAutoFilterValue :: (a -> b) -> FilterLike a -> FilterLike b

BuildableAutoFilter FilterLike

Defined in Servant.Util.Combinators.Filtering.Filters.Like

Methods

buildAutoFilter :: Buildable a => Text -> FilterLike a -> Builder

newtype LikePattern

Simple regexp pattern, . and * signed will be considered. Escaping is performed via prefixing with backslash.

Constructors

LikePatternUnsafe

Fields

• unLikePattern :: LText

Instances

IsString LikePattern

Defined in Servant.Util.Combinators.Filtering.Filters.Like

Methods

fromString :: String -> LikePattern

Buildable LikePattern

Defined in Servant.Util.Combinators.Filtering.Filters.Like

Methods

build :: LikePattern -> Builder

type NumericFilterTypes = [FilterMatching, FilterComparing]

type TextFilterTypes = [FilterMatching, FilterComparing, FilterLike]

type DatetimeFilterTypes = '[FilterComparing]

Manual construction

module Servant.Util.Combinators.Filtering.Construction