706 dev graph parameters display

See merge request !407

Fix a bug in `buildPatterns` and friends

Closes #395

See merge request !413

Update IGraph

See merge request !411

Fixes a bug in the implementation of `buildPatterns`. In particular,
when we are building a `Pattern`, we need to do so in a case insenstive
fashion, otherwise later in the call to `replaceTerms` we would be
calling this from `extractTermsWithList` that cast everything into
lowercase due to the use of `monoTextsBySentence`.

This means that before this commit if we tried to search "Map" into
the text "Map is what I use when I'm lost" we wouldn't get a match,
because the latter would be converted into lowercase first
(i.e. "map is what i use when i'm lost") and we were trying to look
for the string "Map" (i.e. the former) into the transformer, yielding
no matches.

Previously the generator was generating all sorts of unicode symbols,
which doesn't play well for things like tab separators, carriage returns
and other things.

Furthermore, we need to be careful to not use the same symbol set of
`isSep` when we generate terms, because we are simulating an ngrams
search in a document and ngrams do not contain those separators
(i.e. `k2(` is not a valid ngram, but `k2` is).

Our IGraph library was updated to fix [this issue](haskell-igraph#5).

The `filterNodes` function's name and type signature were confusing, so
they were changed to make it evident that the filtering function for an
antry is applied to its total number of cooccurrences.

Reduce code duplication and simplify a few things.

The changes in this commit were made without relying on any knowledge
about what the code means or does; the changes should be understandable
even without knowing the project.

There's a filter in place to not show nodes not connected to any other
node, however the strict inequality was also filtering out nodes
connected to exactly one other node.

Removed some dead code, renamed some stuff, made exports explicit

Spinglass functions would output incoherent clusters when the input graph
was nonconnected.

`occurrencesWith` takes a function parameter to map over the input
collection before counting occurrences. Every time it's called, though,
it's with `identity`, so I replaced the function with a basic occurence
counting function.

Note that if one needs to apply a function to a collection before counting
occurrences, they can simply `fmap` over the collection first.

Port (almost all) DB operations in GGTX to use the transaction API

Closes #466

See merge request !408

The refactored DB API now has a separate building block to create an Opaleye query that
counts the number of returned results; we do that via `countRows`, exactly like the previous version.

However, I have discovered a small footgun in the Opaleye API -- if you have
two `Select` statements both calling countRows in a chain, that will always yield a value of 1,
because the inner `countRows` will give you the actual number of results by returning
a single row with an integer inside (i.e. the count).

However, the subsequent (outer) call to `countRows` will return the number of rows
of the previous step .. which is always going to be one!

The bug was that I had left somewhere the spurious `countRows` in the query which
would return the number of documents needed for the TFICF field, triggering the bug
(because then we had `it` ALWAYS equal to 1.0).

In the new API, while we cannot prevent the bug at the type level we can
easily do an audit by grepping for `countRows`, making sure we have exactly one instance,
i.e. inside `mkOpaCountQuery`.

This gigantic commit ports the existing DB operations in GGTX to use the
transactional API, meaning that we can now compose DB operations and
they will all run in the same Postgres transaction using the same
connection, which will eliminate those class of bugs where concurrent DB
access might result in an inconsistent state.

On top of that, we simplify some parts of the API, for which a summary
is given below:

1. The `NodeStoryEnv` management has been greatly simplified; in the new
   API we don't need an external connection pool to be passed and we
   don't have to pass IO actions, we can just pass DB operations,
   therefore we can greatly simplify the API to just pass mostly pure
   values;

2. Due to the fact that our `DBTx` monad can't do arbitrary IO (which is
   a good thing) we cannot fire Central Exchange notifications
   immediately. Rather that happens now is that we collect the
   `CEMessage` to be sent and we fire them in the relevant concrete
   monad after we finished with the DB transaction. This means that in
   principle there would be a small delay between the DB operation
   taking place and the notification firing but in practice the latency
   should be negligible and bear in mind this is typically what we want:
   if we have a long DB Tx that triggers an error in the middle we don't
   want to be sending out CE messages prematurely if the overall
   operation didn't succeed!

3. There are still a few places in the codebase where we couldn't make
   things fully compositional with regards to the DBTx API, because we
   had Servant handlers which had DB operations mixed with other IO
   effectful computations (or other things like the notification from
   the `MonadJobStatus`). For now we are splitting these functions by
   manually running the partial DB operations, and while this is not
   ideal it can be fixed in subsequent merge requests.

4. The `WorkerEnv` doesn't use `IOException` as its `MonadError`
   anymore, as for consistency we can just use `BackendInternalError` by
   adding a `InternalWorkerError` data constructor accepting the
   `IOException` triggered by the Worker monad.

More testing is needed, with particular attention to performance
(regression) but this should hopefully offer a decent baseline.

Transaction API for DB Transactions

See merge request !406

.. before we start adding the transactional tests (and testing the
rollback).

Use Async.race in serverCLI start-all to fix initialisation bug

See merge request !404

It's a simple DB query, it shouldn't need any extra effect.

This commit uses the `race` function from the async library to fix a bug
where exceptions raised from the server async wouldn't be caught by the
top-level code.

The bug was stemming from the fact that `runAllWorkers` is **blocking**,
despite its usage of `forConcurrently_`. Therefore we were never
actually running the `wait` function below, but rather we were hanging
waiting on the result of the first function.

As a result the server could die but the workers could keep the main
thread alive, causing the bug we just saw as part of #463.

Proper incremental TSV parser

See merge request !402