| Safe Haskell | None |
|---|---|
| Language | Haskell2010 |
Servant.Util.Combinators.Filtering.Base
Synopsis
- data FilterKind a
- = AutoFilter a
- | ManualFilter a
- type TyNamedFilter = TyNamedParam (FilterKind Type)
- data FilteringParams (params :: [TyNamedFilter])
- type family SupportedFilters ty :: [Type -> Type]
- newtype FilteringSpec (params :: [TyNamedFilter]) = FilteringSpec [SomeFilter params]
- pattern DefFilteringCmd :: Text
- data SomeTypeAutoFilter a = forall filter.IsAutoFilter filter => SomeTypeAutoFilter (filter a)
- data TypeFilter (fk :: Type -> FilterKind Type) a where
- TypeAutoFilter :: SomeTypeAutoFilter a -> TypeFilter 'AutoFilter a
- TypeManualFilter :: a -> TypeFilter 'ManualFilter a
- data SomeFilter (params :: [TyNamedFilter]) where
- SomeFilter :: (Typeable fk, Typeable a) => {..} -> SomeFilter params
- extendSomeFilter :: SomeFilter params -> SomeFilter (param ': params)
- castTypeFilter :: forall fk1 a1 fk2 a2. (Typeable fk1, Typeable a1, Typeable fk2, Typeable a2) => TypeFilter fk1 a1 -> Maybe (TypeFilter fk2 a2)
- class BuildableAutoFilter (filter :: Type -> Type) where
- buildAutoFilter :: Buildable a => Text -> filter a -> Builder
- class (Typeable filter, BuildableAutoFilter filter) => IsAutoFilter (filter :: Type -> Type) where
- autoFilterEnglishOpsNames :: OpsDescriptions
- autoFilterParsers :: FromHttpApiData a => Proxy filter -> Map Text (FilteringValueParser (filter a))
- autoFilterEncode :: ToHttpApiData a => filter a -> (Text, Text)
- mapAutoFilterValue :: (a -> b) -> filter a -> filter b
- class AreAutoFilters (filters :: [Type -> Type]) where
- mapFilterTypes :: (forall filter. IsAutoFilter filter => Proxy filter -> a) -> Proxy filters -> [a]
- newtype FilteringValueParser a = FilteringValueParser (Text -> Either Text a)
- type OpsDescriptions = [(Text, Text)]
- parseFilteringValueAsIs :: FromHttpApiData a => FilteringValueParser a
- unsupportedFilteringValue :: Text -> FilteringValueParser a
- autoFiltersParsers :: forall filters a. (AreAutoFilters filters, FromHttpApiData a) => Map Text $ FilteringValueParser (SomeTypeAutoFilter a)
- type family FilteringParamTypesOf a :: [TyNamedFilter]
- type FilteringParamsOf a = FilteringParams (FilteringParamTypesOf a)
- type FilteringSpecOf a = FilteringSpec (FilteringParamTypesOf a)
Documentation
data FilterKind a Source #
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
type TyNamedFilter = TyNamedParam (FilterKind Type) Source #
data FilteringParams (params :: [TyNamedFilter]) Source #
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
type family SupportedFilters ty :: [Type -> Type] Source #
For a type of field, get a list of supported filtering operations on this field.
Instances
newtype FilteringSpec (params :: [TyNamedFilter]) Source #
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) Source # | |
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) Source # | By default |
Defined in Servant.Util.Combinators.Filtering.Construction Methods def :: FilteringSpec params # | |
| type Item (FilteringSpec params) Source # | |
Defined in Servant.Util.Combinators.Filtering.Base | |
pattern DefFilteringCmd :: Text Source #
If no filtering command specified, think like if the given one was passed.
data SomeTypeAutoFilter a Source #
Some filter for an item of type a.
Filter type is guaranteed to be one of SupportedFilters a.
Constructors
| forall filter.IsAutoFilter filter => SomeTypeAutoFilter (filter a) |
Instances
| Functor SomeTypeAutoFilter Source # | |
Defined in Servant.Util.Combinators.Filtering.Base Methods fmap :: (a -> b) -> SomeTypeAutoFilter a -> SomeTypeAutoFilter b # (<$) :: a -> SomeTypeAutoFilter b -> SomeTypeAutoFilter a # | |
| Buildable a => Buildable (Text, SomeTypeAutoFilter a) Source # | |
Defined in Servant.Util.Combinators.Filtering.Base Methods build :: (Text, SomeTypeAutoFilter a) -> Builder # | |
data TypeFilter (fk :: Type -> FilterKind Type) a where Source #
Some filter for an item of type a.
Constructors
| TypeAutoFilter :: SomeTypeAutoFilter a -> TypeFilter 'AutoFilter a | One of automatic filters for type |
| TypeManualFilter :: a -> TypeFilter 'ManualFilter a | Manually implemented filter. |
data SomeFilter (params :: [TyNamedFilter]) where Source #
Some filter.
This filter is guaranteed to match a type which is mentioned in params.
Constructors
| SomeFilter | |
Fields
| |
extendSomeFilter :: SomeFilter params -> SomeFilter (param ': params) Source #
castTypeFilter :: forall fk1 a1 fk2 a2. (Typeable fk1, Typeable a1, Typeable fk2, Typeable a2) => TypeFilter fk1 a1 -> Maybe (TypeFilter fk2 a2) Source #
class BuildableAutoFilter (filter :: Type -> Type) where Source #
How auto filters appear in logging.
Instances
| BuildableAutoFilter FilterLike Source # | |
Defined in Servant.Util.Combinators.Filtering.Filters.Like Methods buildAutoFilter :: Buildable a => Text -> FilterLike a -> Builder Source # | |
| BuildableAutoFilter FilterComparing Source # | |
Defined in Servant.Util.Combinators.Filtering.Filters.General Methods buildAutoFilter :: Buildable a => Text -> FilterComparing a -> Builder Source # | |
| BuildableAutoFilter FilterMatching Source # | |
Defined in Servant.Util.Combinators.Filtering.Filters.General Methods buildAutoFilter :: Buildable a => Text -> FilterMatching a -> Builder Source # | |
class (Typeable filter, BuildableAutoFilter filter) => IsAutoFilter (filter :: Type -> Type) where Source #
Application of a filter type to Servant API.
Minimal complete definition
autoFilterEnglishOpsNames, autoFilterParsers, autoFilterEncode
Methods
autoFilterEnglishOpsNames :: OpsDescriptions Source #
For each supported filtering operation specifies a short plain-english description.
autoFilterParsers :: FromHttpApiData a => Proxy filter -> Map Text (FilteringValueParser (filter a)) Source #
For each supported filtering operation specifies parser for a filtering value.
autoFilterEncode :: ToHttpApiData a => filter a -> (Text, Text) Source #
Encode a filter to query parameter value.
mapAutoFilterValue :: (a -> b) -> filter a -> filter b Source #
default mapAutoFilterValue :: Functor filter => (a -> b) -> filter a -> filter b Source #
Instances
class AreAutoFilters (filters :: [Type -> Type]) where Source #
Multi-version of IsFilter.
Methods
mapFilterTypes :: (forall filter. IsAutoFilter filter => Proxy filter -> a) -> Proxy filters -> [a] Source #
Instances
| AreAutoFilters ('[] :: [Type -> Type]) Source # | |
Defined in Servant.Util.Combinators.Filtering.Base Methods mapFilterTypes :: (forall (filter :: Type -> Type). IsAutoFilter filter => Proxy filter -> a) -> Proxy '[] -> [a] Source # | |
| (IsAutoFilter filter, AreAutoFilters filters) => AreAutoFilters (filter ': filters) Source # | |
Defined in Servant.Util.Combinators.Filtering.Base Methods mapFilterTypes :: (forall (filter0 :: Type -> Type). IsAutoFilter filter0 => Proxy filter0 -> a) -> Proxy (filter ': filters) -> [a] Source # | |
newtype FilteringValueParser a Source #
Parses text on the right side of "=" sign in query parameters.
Constructors
| FilteringValueParser (Text -> Either Text a) |
Instances
| Functor FilteringValueParser Source # | |
Defined in Servant.Util.Combinators.Filtering.Base Methods fmap :: (a -> b) -> FilteringValueParser a -> FilteringValueParser b # (<$) :: a -> FilteringValueParser b -> FilteringValueParser a # | |
type OpsDescriptions = [(Text, Text)] Source #
For each filtering operation specifies a short plain-english description.
This is not a Map to prevent developer-defined entries order.
parseFilteringValueAsIs :: FromHttpApiData a => FilteringValueParser a Source #
Delegate to FromHttpApiData.
autoFiltersParsers :: forall filters a. (AreAutoFilters filters, FromHttpApiData a) => Map Text $ FilteringValueParser (SomeTypeAutoFilter a) Source #
Gather parsers from multiple filters.
type family FilteringParamTypesOf a :: [TyNamedFilter] Source #
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 Source # | |
Defined in Servant.Util.Combinators.Filtering.Base | |
type FilteringParamsOf a = FilteringParams (FilteringParamTypesOf a) Source #
This you will most probably want to specify in API.
type FilteringSpecOf a = FilteringSpec (FilteringParamTypesOf a) Source #
This you will most probably want to specify in an endpoint implementation.