For the given identity type identity-type and optional acceptable type tag acceptable-type (amelinium.identity/standard by default), returns that type as keyword, or nil if the type is not acceptable.

Adds a header header to :response/headers map of the req using built-in function qassoc. If a header name argument is a literal keyword, a character, a number, or a literal string, it will be converted to a string literal and placed as qassoc argument. Otherwise it will be left as is and wrapped into a call to io.randomseed.utils/some-str to ensure the result is a string run-time. All arguments of the body are used to calculate a value of the header. Assumes that req is always a map.

Adds headers with associated values to :response/headers map of the req using built-in function qassoc. If any header name argument is a literal keyword, a character, a number, or a literal string, it will be converted to a string literal and placed as an argument passed to qassoc. Otherwise it will be left as is and wrapped in a call to io.randomseed.utils/some-str to ensure at run-time that the result will be a string. Missing header value, if any, will be padded with nil.

For the given body map it adds a language under the :lang key if it does not exists yet. The language is obtained from the request map req by reading a value associated with the :language/id key.

For the given body map, a new key new-k, a key k and a translation function sub-translation-fn, tries to add a translation of the key k as a value under the given key new-k, if it does not exist yet in body. Optional suffix argument is used to add suffix to a key name.

Adds HX-Trigger server response header to :response/headers map of the given req map by putting a JSON in the following form:

{"setSession":{"session-id": "SID"}}

where the session-id string is obtained from session’s ID field (using amelinium.http.middleware.session/id-field) and SID is replaced with session ID (obtained with amelinium.http.middleware.session/any-id).

If the HX-Trigger header already exists but it does not contain setSession trigger name, it will be modified. If it already contains it, it will be left as is.

Adds session ID header to the :response/headers map of the given req map. Name of the header is obtained from session ID field (by calling amelinium.http.middleware.session/id-field) and its value is set to session ID (obtained by calling amelinium.http.middleware.session/any-id). If the header already exists it is not added.

Adds trailing slash to a path unless it already exists.

Adds response status to a request map req under its key :response/status using qassoc. The status is a result of evaluating expressions passed as additional arguments. Returns updated req. Assumes that req is always a map.

Returns a path for the authentication page. The page must have ID of :user/welcome.

Returns true if the current (or given as a match) page is an authentication page (has :auth-page? route data set to a truthy value).

Gets a session map and a session config map from the given request map. Returns a two-element vector.

Uses the page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 201 to it using resp/created. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

Returns a path of the current page.

Returns an identifier of a current page if it is defined for a HTTP route.

Returns an identifier of a current page if it is defined for a HTTP route or a path if the page name is not defined.

Generates a language-parameterized redirect function which acts like localized-redirect.

Generates a language-parameterized redirect function which acts like redirect.

103 Early Hints The server sends some response headers (e.g. HTML resource links) before final HTTP message.

Adds session ID header with an empty string to the :response/headers map of the given req map. Name of the header is obtained from session ID field (by calling amelinium.http.middleware.session/id-field). If the header already exists it is replaced.

Uses the page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 302 to it using resp/found. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

For the given request map req it tries to get a request header identified by a name id-field, and then checks if it is valid session identifier. Returns a session identifier or nil if the obtained value is not valid session ID or the header is not found.

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 303 to it using resp/see-other. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Detects an identity type and checks if it is assigned to a tag :amelinium.identity/standard or to a tag passed as acceptable-tag argument. To accept any valid identity type the :amelinium.identity/valid must be explicitly given.

The src may be a map or a single value. If it is a map, the keys :identity, :user/identity and :id are looked up to get the identity of a user, keys :id-type and :identity/type are used to look up to get already established identity type. If it is a single value then it should contain the identity source (a string, a phone number, a number, etc).

When the optional id argument is given, it is tried before any lookup in a source map and even before getting it from src directly (in case it is a single value).

If the identity type was obtained (from the optional identity-type argument or a map entry, if any), it is checked whether it is acceptable. If the identity type was not obtained, it is guessed by analyzing the identity value (and also checked against the acceptable types).

If the identity type cannot be established or it is not acceptable, nil is returned.

For the given src argument, tries to obtain a language ID. If it’s a map it looks for :param key and for :language/settings if that fails. If :language/settings is found, it will try to get :param, assuming it’s a map too. If the argument is not a map it will simply convert it into a keyword (without a namespace). If all of that fails (e.g. the src is nil) then the :lang keyword is returned.

Gets a hard-lock time for a given user specified by a map having the :locked key.

Returns true if the given user map contains the :locked key and a value associated with it is not nil. Does not connect to a database.

Checks if the given route match can be parameterized with a parameter of the given id.

Returns true if the client request has HX-Request header set to any value but false or an empty string.

Returns a string from HX-Target header set by a client. If the header does not exist, it returns nil. If the header exists but contains an empty string, it returns nil.

Returns URL type identifier which matches the given identity type and confirmation reason. Used to generate confirmation link which is to be sent in verification message.

If id-type is :user/email or :email and reason is :change or “change”, the result is :url/update-email.

If id-type is :user/email or :email and reason is :recovery or “recovery”, the result is :url/update-password.

If id-type is :user/email or :email and reason is not of any above, the result is :url/create.

If id-type is :user/phone or :phone and reason is :recovery or “recovery”, the result is :url/update-password.

If id-type is :user/phone or :phone, and reason is not of any above, the result is :url/update-phone.

In all other cases :url/update-email is returned.

Detects an identity type and checks if it is assigned to a tag :amelinium.identity/standard or to a tag passed as acceptable-tag argument.

To accept any valid identity type the :amelinium.identity/valid must be explicitly given as acceptable-tag argument.

If identity-type is not given, is set to nil or to :amelinium.identity/any, it is guessed by analyzing user-identity.

Returns a 2-element vector containing original value of user-identity argument and detected identity type.

If user-identity is nil or false then only the given identity-type is checked whether it is acceptable. If it is not, nil is returned instead of vector.

If user-identity is given but it is not matching the given identity type or its identity type is not acceptable, nil is returned instead of vector.

If user-identity is given but identity-type is nil or :amelinium.identity/any, the type of user identity is extracted and checked whether it is acceptable.

User identity is only tested, never transformed, even if it is not an Identity object. Identity type is extracted from identity object (given or ad-hoc created).

418 I’m a teapot The server cannot brew coffee because it is, permanently, a teapot.

Redirects to a best-suited language version of the URI. Uses :browser pickers chain to get the right language if the path is language-parameterized.

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 201 to it using resp/created. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 302 to it using resp/found. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 301 to it using resp/moved-permanently. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 300 to it using resp/multiple-choices. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Generates a page path for the given page identifier and language identifier. When called with just a request map, returns a path of the current page but re-generated to support current language in use (taken from :language/str key of the request map).

The optional name-path-fallback? argument, when set to a truthy value (true by default), causes non-matching route identifier to be retried by extracting its path and calling this function for that path given as a string.

The optional lang-required? argument (set to false when not given) enables extra check eliminating pages which do not support the given language parameter. Example:

(localized-page req :login-page :pl true)

will fail if there is no parameter :lang handled by the route named :login-page.

When the given path is already parameterized with language then re-parameterized path is generated and checked if it exists, unless the value of the parameter is the same as the existing one. In such case the path is returned after a quick existence check.

Additional path parameters (path-params) can be given to be used when matching by name. Giving extra (unknown to route) parameters does not affect lookup. Giving path-params when matching by path causes them to be silently ignored.

Additional query parameters (query-params) can be given. They will be used when generating path. If the path was given and it already contains query parameters, they will be replaced.

If the path is given instead of a route identifier, it must exist (after being equipped with any extra parameters, if needed, using path-params).

When the lang-required? is set to false (default) and a path is given but it does not require language parameter, a path will be generated by testing whether it exists for regular and for slash-stripped or slash-added variant (the original variant goes first).

When the lang-required? is set to false (default) and a path is given but it does not require language parameter plus the name-path-fallback? argument is set to :brute-force, all possible path variants (with language parameter injected within its succesive segments) will be tried in hope that one will exist, regardless of parameter name that matches. Use it with caution as it may give weird matches; if for example, there is a route path /users/:id defined, and the given path is /users/ with language set to :pl, then it will match /users/pl even though the parameter is not related to a language.

When the lang-required? is set to true and a path is given but it does not require a language parameter, all possible path variants (with parameter injected within its succesive segments) will be tried in hope that one will match, being a path that requires language parameter.

Creates a URL on a basis of route name or a path.

Uses very optimistic matching algorithm. Tries to obtain language from user settings and client settings if the path does not contain language information. Uses the :default language picker.

Non-matching route identifier is retried by extracting its path and calling the localized-page function for that path given as a string.

If a page found does not have a language parameter it is accepted too.

When the given path is already parameterized with language then re-parameterized path is generated and checked if it exists, unless the value of the parameter is the same as the existing one. In such case the path is returned after a quick existence check.

Additional path parameters (params) can be given to be used when matching by name. Giving extra (unknown to route) parameters does not affect lookup. Giving params when matching by path causes them to be silently ignored.

Additional query parameters (query-params) can be given. They will be used when generating path. If the path was given and it already contains query parameters, they will be replaced.

If the path is given instead of a route identifier, it must exist (after being equipped with any extra parameters, if needed, using params).

When a path is given but it does not require language parameter, a path will be generated by testing whether it exists for regular and for slash-stripped or slash-added variant (the original variant goes first).

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 308 to it using resp/permanent-redirect. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Generic redirect wrapper. The f should be a function which takes a request map and returns a response; should take at least one single argument which should be a URL. The URL will be parameterized with a language. Works almost the same way as the redirect but it will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that localized path will be produced, or nil.

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 303 to it using resp/see-other. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 307 to it using resp/temporary-redirect. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 305 to it using resp/use-proxy. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Returns lock-wait configuration option taken from the authentication configuration map or given as a time duration. Does not connect to a database.

Helper which returns 2-element vector telling if the current (or given as a match) page is a login page (1st element) and/or an auth page (2nd element).

Returns a path for the login page. The page must have ID of :user/login.

Returns true if the current (or given as a match) page is a login page (has :login-page? route data set to a truthy value).

421 Misdirected Request The request was directed at a server that is not able to produce a response (e.g. network balancer forwarded traffic to a wrong server).

Uses the localized-page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 307 to it using resp/temporary-redirect. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

The difference between this function and its regular counterpart (if defined) is in binary variants of them (when a request map and a name or a path are given as arguments). The regular function will fail to generate a redirect if there is no language parameter and the given path does not point to an existing page. On the contrary, this function will generate a localized path using a language obtained from a request (under :language/str key) and if there will be no language-parameterized variant of the path, it will fail. Use this function to make sure that a localized path will be produced, or nil.

Uses the page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 301 to it using resp/moved-permanently. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

Uses the page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 300 to it using resp/multiple-choices. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

Checks if a current page matches the given route name (if an identifier is given) or the exact path. For multiple page names or paths, it returns true when any of them matches.

Logs operation using operations logger. First argument should be a request map or a Match object containing configuration associated with the current route data under the :oplog/config key.

Returns operations logger configuration obtained from a request or a Match object.

Retrieves operations logger function from a current route data (via :oplog/config key and then the :fn/reporter key), and if that fails, tries to retrieve it using :oplog/config key of the request map (and :fn/reporter sub-key). When everything fails it will fall back to a global variable amelinium.common.oplog.auth/log. The given argument can be either a request map or a Match object.

Retrieves operations logger function from a given route data map (via :oplog/config key and then the :fn/reporter key) and creates a wrapper for handling keyword arguments.

Creates operations logging function on a basis of operations logger retrieved by getting :oplog/logger key of the request (req), and if that fails by calling oplog-logger-from-route-data (when route-data is given), and if that fails by calling oplog-logger function on a req (which falls back to amelinium.common.oplog.auth/log).

Generates a page path for the given page identifier (a route name) or a path, and optional language identifier. When called with just a request map, returns a path of the current page.

It tries to be optimistic. When called for a page identified by its name (expressed as an identifier, usually a keyword) and with a language parameter to be found (so it cannot be looked up using just a name alone), it will use currently detected language obtained from the given request map (key :language/str), and will use it.

Additional query parameters (query-params) can be given. They will be used when generating path with localized-page. If the path was given and it already contains query parameters, they will be replaced.

Additional path parameters (path-params) may be given. Giving extra (unknown to route) parameters does not affect lookup. Giving path-params when matching by path causes them to be silently ignored.

When invoked with a language parameter, calls localized-page internally.

When invoked with a language parameter, the lang-required? argument may be used (by default set to false) to check if a matching route is parameterized with a language parameter. This is to ensure that only a localized route is used.

When invoked with a language parameter, the optional name-path-fallback? argument may be used (set to true by default) to cause non-matching route identifier to be retried by extracting its path and calling localized-page function for that path expressed as a string.

If the path is given instead of a route identifier, it must exist (after being equipped with any extra parameters, if needed, using path-params).

When invoked with a language parameter, the lang-required? is set to false (default), and a path is given but it does not require language parameter, a path will be generated by testing whether it exists for regular and for slash-stripped or slash-added variant (the original variant goes first).

When invoked with a language parameter, the lang-required? is set to false (default), and a path is given but it does not require language parameter plus the name-path-fallback? argument is set to :brute-force, all possible path variants (with language parameter injected within its succesive segments) will be tried in hope that one will exist, regardless of parameter name that matches. Use it with caution as it may give weird matches; if for example, there is a route path /users/:id defined, and the given path is /users/ with language set to :pl, then it will match /users/pl even though the parameter is not related to a language.

When invoked with a language parameter, the lang-required? is set to true, and a path is given but it does not require a language parameter, all possible path variants (with language parameter injected within its succesive segments) will be tried in hope that one will match, being a path that requires language parameter.

Generates a path for the given page identifier (which may be a name expressed with an identifier, preferably a keyword, or a path expressed as a string) and a parameter with the given value.

Optional path parameters may be given. They will be used to match a page by name if it requires additional parameters to be present.

Examples:

(parameterized-page req) (parameterized-page req :login-page) (parameterized-page req :login-page :lang :pl) (parameterized-page req :login-page :lang :pl {:client "wow-corp"}) (parameterized-page req "/login/page/") (parameterized-page req "/login/page/" :lang :pl) (parameterized-page req "/en/login/page/" :lang :pl)

When called with just a request map, returns a path of the current page if the page exists. When called with a page name or path, it returns a path if the page exists.

The optional name-path-fallback? argument, when set to a truthy value (default is false), causes non-matching route identifier to be retried by extracting its path and calling this function for that path given as a string.

The optional require-param? argument (set to false when not given) enables extra check eliminating pages which do not support the given parameter, yet would be matched. Example:

(parameterized-page req :login-page :lang :pl true)

will fail if there is no parameter :lang handled by the route named :login-page.

When the given path is already parameterized then re-parameterized path is generated and checked if it exists, unless the value of the parameter is the same as the existing one. In such case the path is returned after a quick existence check.

Additional path parameters (path-params) can be given to be used when matching by name. Giving extra (unknown to route) parameters does not affect lookup. Giving path-params when matching by path causes them to be silently ignored.

Additional query parameters (query-params) can be given. They will be used when generating path. If the path was given and it already contains query parameters, they will be replaced.

If the path is given instead of a route identifier, it must exist (after being equipped with any extra parameters, if needed, using path-params).

When the require-param? is set to false (default) and a path is given but it does not require this parameter, a path will be generated by testing whether it exists for regular and for slash-stripped or slash-added variant (the original variant goes first).

When the require-param? is set to false (default) and a path is given but it does not require this parameter plus the name-path-fallback? argument is set to :brute-force, all possible path variants (with parameter injected within its succesive segments) will be tried in hope that one will exist, regardless of parameter name that matches. Use it with caution as it may give weird matches; if for example, there is a route path /users/:id defined, and the given path is /users/ with :lang parameter set to :pl, then it will match /users/pl even though the parameter name is different.

When the require-param? is set to true and a path is given but it does not require this parameter, all possible path variants (with parameter injected within its succesive segments) will be tried in hope that one will match, being a path that requires this parameter.

Parses query params string qstr using Ring’s ring.util.codec/form-decode. The given request map req is used internally to get the current character encoding (with fallback to UTF-8).

Creates a URL on a basis of route name or a path.

If a page found does not have a language parameter it is accepted too.

When the given path is already parameterized with language then re-parameterized path is generated and checked if it exists, unless the value of the parameter is the same as the existing one. In such case the path is returned after a quick existence check.

Additional path parameters (params) can be given to be used when matching by name. Giving extra (unknown to route) parameters does not affect lookup. Giving params when matching by path causes them to be silently ignored.

Additional query parameters (query-params) can be given. They will be used when generating path. If the path was given and it already contains query parameters, they will be replaced.

If the path is given instead of a route identifier, it must exist (after being equipped with any extra parameters, if needed, using params).

When a path is given but it does not require language parameter, a path will be generated by testing whether it exists for regular and for slash-stripped or slash-added variant (the original variant goes first).

Returns a language string if the given path contains a language parameter. Otherwise it returns nil.

Returns a parameter if the given path contains it and it is set. Otherwise it returns nil.

Returns a map of parameters if the given path contains it. Otherwise it returns nil.

Returns a 2-element vector of a path containing its two variants: with and without a trailing slash. The original path is always placed first.

If the path is empty, vector of an empty string and a slash is returned. If the path is a slash, vector of a slash and an empty string is returned.

If the path is nil, it returns nil.

Returns a path template for the given match if the route supports the given parameter.

Generates a list of all possible language variants of a path.

Uses the page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 308 to it using resp/permanent-redirect. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

Tries to pick the best language for a known user or a visitor. To be used (among other scenarios) after a successful log-in to show the right language version of a welcome page. Does not use pre-calculated values from a request map, instead triggers configured pickers from a default or given chain. Returns a keyword.

Tries to pick the best language for a known user or a visitor. To be used (among other scenarios) after a successful log-in to show the right language version of a welcome page. Does not use pre-calculated values from a request map, instead triggers configured pickers from a default or given chain. Returns a string.

Tries to pick the best language for a known user or a visitor. To be used (among other scenarios) after a successful log-in to show the right language version of a welcome page. Does not use pre-calculated values from a request map, instead triggers configured pickers from a default or given chain. When a language cannot be found it simply returns nil instead of a default language. Returns a string.

Tries to pick the best language for a known user or a visitor. To be used (among other scenarios) after a successful log-in to show the right language version of a welcome page. Does not use pre-calculated values from a request map, instead triggers configured pickers from a default or given chain. When a language cannot be found it simply returns nil instead of a default language. Returns a keyword.

Removes namespaces from keys in params or renames keys according to the given key-map.

The keys argument should be a sequence of keys to be found in params. Only the entries identified by these keys will be preserved, with keys stripped from their namespaces. When new-ns is present then the keys in generated map will have their namespace set to this value (which should be a string or any object convertible to a string).

The key-map argument should be a map of keys to be found in params mapped to their new names. Only the entries from params identified by the keys from key-map will be preserved and renamed to corresponding values.

The ns argument should be a string or an object which can be converted to a string. It will be used to select the entries from params by the given namespace and to remove this namespace when producing the result. When new-ns is present then the keys in generated map will have their namespace set to this value (which should be a string or any object convertible to a string).

When only params argument is given, it will simply rename all keys from namespaced to simple keywords.

When params argument is given, then ns is set to nil, and new-ns is set, it will strip all keys from their namespaces replacing it with the given namespace in a resulting map.

Generic redirect wrapper. The f should be a function which takes a request map and returns a response; should take at least one single argument which should be a URL. The URL will be parameterized with a language if required. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

Tries to obtain session ID from the given sess object, and if that fails from the request header with name same as session ID field (obtained by calling amelinium.http.middleware.session/id-field on sess) from the req map. Then it uses add-json-event-handler to set HX-Trigger response header in a similar way the add-session-hx-header does.

Adds session ID header to the :response/headers map of the given req map. Name of the header is obtained from session ID field (by calling amelinium.http.middleware.session/id-field) and its value is set to session ID (obtained by calling amelinium.http.middleware.session/any-id, and if that fails by getting the value of client request header with the same name using get-session-id-header). If the header already exists it is not added.

Removes the given parameter or parameters from a request map locations: [:parameters :body], :body-params and :params. All parameters must be either keywords or strings, they cannot be mixed.

Removes the given parameter or parameters from a request map locations: [:parameters :form], :form-params and :params. All parameters must be either keywords or strings, they cannot be mixed.

Removes the given parameter or parameters from a request map locations: - from a map associated with parameters-sub-key key within a map associated with :parameters key in m, - from a map associated with params-key key in m, - from a map associated with :params key in m (if combined? is truthy). All parameters must be either keywords or strings, they cannot be mixed. Parameter type params-key and parameters-sub-key should be keywords. If params-key or parameters-sub-key is nil then the removal within a specific location(s) will be skipped.

Removes the given parameter or parameters from a request map locations: [:parameters :path], :path-params and :params. All parameters must be either keywords or strings, they cannot be mixed.

Removes the given parameter or parameters from a request map locations: [:parameters :query], :query-params and :params. All parameters must be either keywords or strings, they cannot be mixed.

Removes :response/status from req using clojure.core/dissoc.

Universal response renderer. Returns the result of calling the resp-fn with headers attached (from :response/headers key of the req) unless the req is already a valid response. Arguments from the third are passed to resp-fn function.

Universal body-less response renderer. Returns the result of calling the resp-fn with headers attached (from :response/headers key of the req). Arguments from the third are passed to resp-fn function.

Adds HX-Trigger server response header to :response/headers map of the given req map by putting a JSON in the following form:

{"setSession":{"session-id": "SID"}}

where the session-id string is obtained from session’s ID field (using amelinium.http.middleware.session/id-field) and SID is replaced with session ID (obtained with amelinium.http.middleware.session/any-id).

If the HX-Trigger header already exists, it will be modified and any value associated with setSession key will be modified.

Adds session ID header to the :response/headers map of the given req map. Name of the header is obtained from session ID field (by calling amelinium.http.middleware.session/id-field) and its value is set to session ID (obtained by calling amelinium.http.middleware.session/any-id). If the header already exists it is replaced.

Returns true if the given argument is Reitit’s Match object.

Uses the page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 303 to it using resp/see-other. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

Gets a session map from the given request map.

Gets a session config map from the given request map.

Adds session data to a request map. Session key is obtained from the config field of smap or (if given) from a session-key argument.

Redirects to a slash-trailed version of the same URI. If the URI already has a slash, it returns a req.

Returns the time duration between soft lock and the given moment. If the duration is zero or negative, it returns nil.

Returns the amount of time left before reaching lock-wait. If the amount is negative or zero, it returns nil. Does not connect to a database.

Gets a soft lock time for the given user specified by a map having :soft-locked key.

Returns true if the given user account is soft-locked (the time amount which passed from the lock till the given time is lesser than the soft lock wait configuration option). Does not connect to a database.

Splits path into 3 string components: path, location and query params. Returns a vector.

Splits path into 2 components: path string and location / query params string. Returns a sequence.

Same as localized-page with lang-required? always set to true, name-path-fallback? set to false, and with less arities supported. When the language version of a page identified by its name is not present it will return nil.

Replaces parameters in the given path using a template.

Uses the page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 307 to it using resp/temporary-redirect. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).

Generates a translation function using populated values from :i18n/translator or :i18n/translator-nd (variant which returns nil for missing keys, used when i18n/*handle-missing-keys* is set to a falsy value).

Falls back to i18n/translator if predefined functions are not populated in the request map or if a language was specified as an optional lang argument and it differs from the language stored in req under :language/id (or :language/default).

Returns true if the given argument cannot be used as a translation key.

Takes a request map req and URI (u) and tries to decompose it into 2-element vector with first element being a URI and second a query params map. If there is a processing exception during the operation, string-converted u is returned unmodified and query params slot is set to be nil. The request map is used internally to get the current character encoding (with fallback to UTF-8).

Returns true if response should be HTMX-compatible, false if it should not. Uses optional route-data or gets it from the req to look for (optional) extra-key first, and if it is not given or has falsy value then gets a value associated with the :use-htmx? key.

• If the obtained value is false, it will return false.
• If the obtained value is true or any non-nil value, it will return true.
• If the obtained value is nil, or there is no route data nor any of the mentioned keys can be found in route data, it will try to auto-detect HTMX using hx-request? function which analyzes the HX-Request request header.

Uses the page function to calculate the destination path on a basis of page name (identifier) or a path (a string) and performs a redirect with code 305 to it using resp/use-proxy. If the language is given it uses the localized-page function. If there is no language given but the page identified by its name requires a language parameter to be set, it will be obtained from the given request map (under the key :language/str).