Search: the interface and the Solr provider
This document describes the search interface of Linked Data Store (LDS) and the provider that implements it on Apache Solr: what the interface promises, how a provider is found, what the Solr provider puts in the index and how it asks for it. It is for developers who change this code or write another search provider.
What this part is for
Search finds documents by text. LDS keeps an index next to the persistence provider. A write puts the document in the index, a delete takes it out, and a search asks the index which documents match. The index answers with document keys, never with the documents. Core reads the documents from the persistence provider.
Search is optional. It is off unless graphql.search.enabled is true.
A search is asked for through the GraphQL field Search and in no other way. The REST handlers do not read the index.
The field is there only when LDS has a GraphQL schema as its model (see How a provider is
found).
The Solr provider indexes the texts of the fields whose path contains languageText, and nothing else. What
search covers is under review.
Layout
| Module | JPMS module | Package | Holds |
|---|---|---|---|
linked-data-store-search-provider-api |
io.descoped.lds.search.api |
io.descoped.lds.api.search |
The interface: SearchIndexProvider, SearchIndex, and what a search gives back, SearchResponse and SearchResult. |
linked-data-store-search-provider-solr |
io.descoped.lds.search.provider.solr |
io.descoped.lds.core.search.solr |
The provider solr: SolrProvider makes the index, SolrSearchIndex is the index. |
The interface module depends on linked-data-store-persistence-provider-api, because a document is a
JsonDocument and a result is a DocumentKey, and on RxJava 3. Its POM and its module-info.java also name
Jackson 3 (tools.jackson.core, tools.jackson.databind), which no class of the module uses. The Solr module
depends on the interface module, on the persistence interface (it flattens a document with
JsonToFlattenedDocument), on solr-solrj and on SLF4J.
Core depends on the interface module only. The server module (linked-data-store-server) brings the Solr
provider. The classes of core that use the interface are these; they belong to core and are named here to show
where the interface is called. The sagas are described in the write path, the
GraphQL schema in GraphQL, and the start and the stop of LDS in
the application.
Class in linked-data-store-core |
What it does with search |
|---|---|
SearchIndexConfigurator |
Finds the provider at start and makes the index. |
SagaRepository |
Adds the index step to the two sagas when there is an index. |
UpdateIndexSagaAdapter, DeleteIndexSagaAdapter |
The index steps: they call createOrOverwrite and delete. |
GraphQLSchemaBuilder, AddSearchTypesVisitor, RegistrySetupVisitor |
Add the field Search to the GraphQL schema when there is an index, and give it its fetcher. |
QueryConnectionFetcher |
The fetcher of Search: it calls search and reads the documents that are found. |
TestSearchIndex, SimpleSearchIndex |
A provider testSearchIndex that keeps documents in a map in memory, for the tests of core. |
SimpleSearchIndex is not a small Solr. It keeps one entry for each document id, whatever the namespace, the
entity type and the version are. A search finds a document when any text in it contains the query, in upper or lower
case; it does not look at languageText, and it does not use the filter, from or size. A test of core that
searches therefore says nothing about what the Solr provider indexes or finds.
The interface
SearchIndexProvider
A search index provider is a class that implements SearchIndexProvider
and has a constructor without parameters.
| Method | What it promises |
|---|---|
String getProviderId() |
The name the provider is chosen by. It is compared with the value of search.index.provider. The Solr provider answers solr. |
Set<String> configurationKeys() |
The configuration keys the provider reads. The Solr provider answers search.index.url. Nothing calls this method for a search provider. |
SearchIndex getSearchIndex(Map<String, String> configuration) |
Makes the index. Core calls it once, at start, with the whole configuration of LDS as a map (DynamicConfiguration.asMap), not only the keys of configurationKeys(). |
SearchIndex
Every method returns a type of RxJava 3 (Completable, Single).
| Method | What it promises |
|---|---|
Completable createOrOverwrite(JsonDocument document) |
Puts one version of a document in the index, or replaces it when it is there. The key of the document (DocumentKey: namespace, entity type, id, the valid time of the version) says which. |
Completable createOrOverwrite(Collection<JsonDocument> documents) |
The same for several documents. |
Completable delete(JsonDocument document) |
Takes a document out of the index. Only the key of the document is of use: core gives a document with no content here. |
Completable deleteAll() |
Empties the index. |
Single<SearchResponse> search(String query, Set<String> typeFilter, long from, long size) |
Searches. query is passed to the index as it is, in the query language of the index. typeFilter narrows the result to the entity types it names. from is the number of results to skip, and size is the number of results to return. |
A SearchResponse holds the total number of hits (getTotalHits), one page of results (getResults), and the
from and size that were asked for. A SearchResult holds one DocumentKey.
The interface has no method that closes an index.
How a provider is found
SearchIndexConfigurator.configureSearchIndex in core is called once when the application is made
(UndertowApplication.initializeUndertowApplication), after the persistence provider and the saga log are
made:
- It reads
graphql.search.enabled(defaultfalse). When it isfalse, the answer isnull, and the log saysGraphQL Search is disabled. Skipping search index initialisation. - It reads
search.index.providerand loads everySearchIndexProviderwithjava.util.ServiceLoader. - The first provider whose
getProviderId()equals the value makes the index, and the log saysSearch index provider configured: solr. - When no provider has that name, it throws
RuntimeException: No search index provider found for providerId: <the value>and LDS does not start (the process ends with exit code 1). Nothing closes the persistence provider that was made before.
A provider is registered in two places: provides SearchIndexProvider with ... in its module-info.java, and a
file META-INF/services/io.descoped.lds.api.search.SearchIndexProvider with the name of the class. LDS runs on
the class path, where the file is the one that is read. Core declares uses SearchIndexProvider in its
module-info.java.
When there is no index, SagaRepository builds both sagas without an index step, and GraphQLSchemaBuilder
adds no Search field: a GraphQL request for it is answered
Field 'Search' in type 'Query' is undefined.
When there is an index, the sagas always get their index step. The Search field needs more: the GraphQL
schema is built only when graphql.enabled is true and graphql.schema names a file (the constructor of
UndertowApplication). With a model of JSON Schema files and no GraphQL schema, every write goes to the index
and nothing can search it: LDS has no /graphql then.
AddSearchTypesVisitor makes the enum TypeFilters and the union SearchResult from every type of the model
that has @domain, and adds Search(query: String!, filter: [TypeFilters]) to the query type.
AddConnectionVisitor then gives it the paging arguments (first, after, last, before) and the type
SearchResultConnection. RegistrySetupVisitor finds the field by the applied directive search
(AddSearchTypesVisitor.SEARCH_NAME) and gives it a QueryConnectionFetcher.
TestSearchIndex is in the main code of core and in its module-info.java, but its META-INF/services file
is among the test resources of core. A running LDS does not find it: with
search.index.provider=testSearchIndex, LDS stops at start with
No search index provider found for providerId: testSearchIndex.
How core calls the index
This is core's code. It is told here in short, because it decides what a provider is given.
A write. The saga
Create or update managed resourcehas the stepstxlog,persistenceand, when there is an index,search-index-update. The last two both followtxlog.UpdateIndexSagaAdapter(adapter namePersistence-Index-Create-or-Overwrite) makes aJsonDocumentfrom the input of the saga (namespace, entity type, id, version, and the document as it was written) and callscreateOrOverwrite(document).blockingAwait().A delete. The saga
Delete managed resourcehas the stepsearch-index-deletein the same place.DeleteIndexSagaAdapter(adapter namePersistence-Index-Delete) callsdelete(document).blockingAwait(). The document it gives has a key and no content.The version. In both sagas the version of the key is the valid time of the REST request: the time the request arrives, or the time in its
timestampparameter, always in the zoneEtc/UTC(DataController). So the key of a delete has the time of the delete as its version, not the time of a version that was written.A search.
QueryConnectionFetcherturns the paging arguments of the GraphQL fieldSearchintofromandsize(IndexBasedRange.fromRange; 0 and 10 when none is given), callssearch(query, filter, from, size).blockingGet(), and reads every document that is named from the persistence provider (readDocument). It reads the document with an as-of read at the snapshot time of the GraphQL request: the time of the request, or the time in itssnapshotparameter. It uses the namespace, the entity type and the id of a result, and not its version. The filter is the list of the argumentfilteras a set, ornullwhen the argument is not given.A result whose document is not found at that time is left out, and
Cound not find document for key ...is written to the log at ERROR. The cursor of an edge isfromplus its place among the edges that are returned, so it is not the place of the result in the index when a result was left out.hasNextPageisfrom + size < getTotalHits().fromis not checked.last: 20withoutbeforegivesfrom-10 andsize20, and the Solr provider sendsstart=-10.
The Solr provider
The client
SolrSearchIndex has two clients from solr-solrj (version solr.version in the root POM, 10.1.0):
HttpJdkSolrClient, the client that uses the HTTP client of the JDK, made from the address insearch.index.url. It sends the queries.ConcurrentUpdateJdkSolrClient, made for the same address on top of the first client. It sends the updates. It keeps additions in a queue, and threads of its own send them over the connection of the first client.
Both are made with the defaults of their builders. Nothing closes them.
The address names one core, for example http://localhost:8983/solr/lds-index. Every namespace and every
entity type is in that one core. The provider sends its requests to /update (POST) and /select (GET) under
the address, and asks for the answer in the binary format of Solr (wt=javabin). Before its first update the
client sends one HEAD request to /update.
The provider does not make the core and does not define its fields. The tests and the compose file of the
server make the core with the command solr-precreate lds-index of the Solr image, from the configuration the
image comes with. The provider sends fields that the core has not been told about, and relies on Solr to take
them.
The address is not tried at start. LDS starts when nothing answers at search.index.url, and also when the
value is empty or is not an address; the first request to Solr then fails. The start fails only when the
configuration does not have the key: SolrProvider.getSearchIndex then gives null to the builder, which
throws IllegalArgumentException: Cannot create HttpSolrClient without a valid baseSolrUrl!. The defaults of
the server have the key; the defaults of core do not.
What a document becomes in the index
One version of a document becomes one entry in the index (SolrSearchIndex.createOrOverwrite). The entry has
these fields:
| Field | Value |
|---|---|
id |
{namespace}/{entity}/{id}/{version}. The version is the valid time of the version as ZonedDateTime.toString() writes it (getIdString). In a running LDS: ns/Company/brew/2026-11-20T15:44:46.369361Z[Etc/UTC], and ns/Company/old/2020-01-01T00:00Z[Etc/UTC] for a write with timestamp=2020-01-01T00:00:00Z. |
entity |
The name of the entity type. |
| one field for each text that is indexed, named by its path | The text. A path is written as JsonToFlattenedDocument writes it: $.about[0].languageText. |
searchfield |
Every text that is indexed, as one value each. A search looks here unless the query names another field. |
addFields decides which texts are indexed. The document is flattened to its leaf values by path. A leaf is
indexed when it is a text (FragmentType.STRING) and its path contains languageText. So:
- A text in another field (
name), a number and a date are not indexed. The namespace and the version are inidonly. - The test is
String.containson the whole path, and upper and lower case differ. A fieldlanguageTextualorMylanguageTextis indexed, and so is every text under an object namedlanguageTextBlock. A fieldLanguageTextis not. - A field
languageTextthat holds a number,true,falseornullis not indexed. An empty text is indexed, as an empty value. - A field
languageTextthat holds an array of texts gives one field for each text ($.title.languageText[0],$.title.languageText[1]). - A document with no such text still gets an entry, with
idandentityonly. - Every entity type is indexed. The argument
searchableof@domainis not read (see What is unfinished or known to be wrong).
This document, with the key ns, Company, brew and the version 2026-11-20T15:29:31.800Z[Etc/UTC]:
{
"name": "Nordic Brewing",
"founded": "2001-05-01T00:00:00Z",
"employees": 12,
"about": [
{
"languageCode": "en",
"languageText": "A small brewery by the fjord"
},
{
"languageCode": "nb",
"languageText": "Et lite bryggeri ved fjorden"
}
],
"languageTextual": "a text field whose name only starts with languageText",
"notes": {"languageText": 42},
"languageTextBlock": {
"inner": "a text under an object whose name starts with languageText"
}
}was given to the provider while a program that prints every request stood where Solr is. The provider sent
POST /solr/lds-index/update?wt=javabin with the parameter commitWithin=5000 and one entry:
| Field | Value |
|---|---|
id |
ns/Company/brew/2026-11-20T15:29:31.800Z[Etc/UTC] |
entity |
Company |
$.about[0].languageText |
A small brewery by the fjord |
$.about[1].languageText |
Et lite bryggeri ved fjorden |
$.languageTextual |
a text field whose name only starts with languageText |
$.languageTextBlock.inner |
a text under an object whose name starts with languageText |
searchfield |
the four texts above |
The time of the version is part of id. A write of another version of the same document has another id, so
it adds an entry and leaves the earlier ones. For a second write of the same version, the provider relies on
Solr to keep one entry for each id; no test checks it.
Writing, and the five seconds
createOrOverwrite calls add(entries, 5000) on the update client. The number is commitWithin in
milliseconds: Solr is asked to commit the addition within five seconds. A search finds the document when Solr
has committed, so up to five seconds after the write: the index is eventually consistent.
Nothing is done until the Completable is subscribed to. Then the update client puts the addition in its
queue and returns, and the provider writes Added 1 documents to index to the log. createOrOverwrite
therefore completes when the addition is queued, not when Solr has it. When the request fails later, a thread
of the client (concurrentUpdateScheduler-...) writes it to the log (ConcurrentUpdateBaseSolrClient - error)
and the caller is not told.
An empty collection is sent too, as an update with no entry.
Deleting
delete calls deleteById(id, 5000) with the id made from the key it is given, version included. It takes
out the entry of that one version. The request is sent when the Completable is subscribed to, and the thread
that subscribes waits for the answer of Solr, so a failure reaches the subscriber.
deleteAll calls deleteByQuery("*:*") and then commit(), so the index is empty when it completes. Only the
tests call it.
Searching: the query and its filters
search builds one SolrQuery:
| Parameter | Value |
|---|---|
start |
from, narrowed to an int |
rows |
size, narrowed to an int |
q |
the query text as it is given, followed by the filter |
df |
searchfield, the field a word is looked for in when the query does not name a field |
hl |
true |
hl.fl |
*languageText |
The filter is added by createFilters when the set of entity types is not null and not empty. It is the text
AND (entity:A OR entity:B), with one entity: for each name, after a space. The names come in the order the
set gives them.
The query text is not changed and not checked. It is in the query language of Solr, so *:* matches every
entry, and a query can name a field (entity:Company). An empty text gives q=, and null gives q=null.
The provider writes each query to the log before it sends it (Executing query:). These are from a running
LDS. Each pair is the arguments of the GraphQL field Search and the query the provider built from them:
query: "fjord"
start=0&rows=10&q=fjord&df=searchfield&hl=true&hl.fl=*languageText
query: "fjord", filter: [Company]
start=0&rows=10&q=fjord+AND+(entity:Company)&df=searchfield&hl=true&hl.fl=*languageText
query: "fjord", filter: [Company, Person]
start=0&rows=10&q=fjord+AND+(entity:Company+OR+entity:Person)&df=searchfield&hl=true&hl.fl=*languageText
query: "fjord", first: 3
start=0&rows=3&q=fjord&df=searchfield&hl=true&hl.fl=*languageText
query: "brewery OR entity:Person", filter: [Company]
start=0&rows=10&q=brewery+OR+entity:Person+AND+(entity:Company)&df=searchfield&hl=true&hl.fl=*languageTextThe query is sent as GET /solr/lds-index/select with these parameters and wt=javabin.
What is returned
From the answer of Solr, search reads the number of hits (numFound) and the field id of each result.
fromIdString splits the id at every /: the first three parts are the namespace, the entity type and the id of
the document, and the fourth and fifth, joined with /, are the version, parsed with
DateTimeFormatter.ISO_ZONED_DATE_TIME. The results are in the order Solr gives them.
The answer is new SearchResponse(numFound, results, from, size).
Highlighting is asked for (hl, hl.fl), but the highlights in the answer are not read.
The provider writes the number of hits to the log at INFO (Number of hits:), as it does the query.
search sends the query when it is called, not when the Single is subscribed to, and waits for the answer.
When anything fails, it writes An error ocurred to the log and throws a RuntimeException from the call. In
a running LDS the GraphQL request is then answered with status 200 and an error for the field, for example
Exception while fetching data (/Search) : java.net.ConnectException: Connection refused (connect failed).
Configuration
| Key | Default in core | Default in the server | Meaning |
|---|---|---|---|
graphql.search.enabled |
false |
false |
true makes an index at start, adds the index step to the sagas and the field Search to the GraphQL schema. |
search.index.provider |
empty | solr |
The name of the provider (getProviderId()). Read only when search is enabled. The comment above the key in application-defaults.properties says it is a class name; that is wrong. |
search.index.url |
not there | http://localhost:8983/solr/lds-index |
Read by the Solr provider: the address of the core. |
The defaults of core are in application-defaults.properties in linked-data-store-core. The defaults of the
server are in application-server-defaults.properties in linked-data-store-server. An environment variable
sets only a key that one of the properties files has; the server has all three, so LDS_GRAPHQL_SEARCH_ENABLED,
LDS_SEARCH_INDEX_PROVIDER and LDS_SEARCH_INDEX_URL work. The compose file of the server (compose.yaml)
sets them to true, solr and http://solr:8983/solr/lds-index.
A new provider that reads keys of its own needs them in a properties file before they can be set from outside.
Rules to keep
These are from the rules of the project (see the invariants) and from the code.
- Core does not know Solr. Core depends on the interface module, and a provider is found by its name. Keep Solr types out of the interface.
- JPMS. Both modules are named modules. The interface module has
requires transitivefor RxJava 3 and for the persistence interface, because its methods give and take their types. A provider is registered withprovidesand inMETA-INF/services, both.uses SearchIndexProvideris in core, which callsServiceLoader; the interface module has nouses. - The id of an entry is read back.
fromIdStringmust be able to read whatgetIdStringwrites. It relies on the version having a zone name with exactly one/. Core gives every version the zoneEtc/UTC(DataController), which is written...Z[Etc/UTC]. Change the two methods together. A caller that makes a version withZonedDateTime.now()gets the zone of the machine, which may have no/(UTC) or two. - One core for every namespace. The namespace is part of
idand is nowhere else in an entry. - The newest stable Solr. The client is
solr.versionin the root POM. The image issolr:10.1inSolr10(the tests) and incompose.yamlof the server. Keep the two images the same: the tests start Solr as the compose file does. - Jackson. The client of Solr brings Jackson 2 for its own use. LDS code uses Jackson 3 and does not use that one.
- Lint and Javadoc. Both modules still override the rule of the root POM:
-Xlint:all,-requires-automatic,-exportsin the interface module,-Xlint:all,-requires-automaticin the Solr module, and doclintall,-missingin both. An override is removed, not widened, when the module is revised.solr-solrjhas no module name of its own (requires solr.solrjis taken from the name of the jar), which is whyrequires-automaticis off. - No spliced identifiers. The rule says that names and search text are checked and never joined into a query. The Solr provider does not meet it yet; see below. New code must.
- Tests run on a real Solr, in a container published on 127.0.0.1 only.
Tests
The Solr provider has one test class, SolrSearchIndexTest (JUnit 6, AssertJ). It runs on a real Solr 10 that
Testcontainers starts, so it needs Docker.
Solr10: Starts one container ofsolr:10.1for the module, with the commandsolr-precreate lds-index, and waits until/solr/lds-index/admin/pinganswers 200.Solr10.configuration()is the provider configuration that reaches it.LoopbackPorts: Publishes every port of the containers on 127.0.0.1 only. Testcontainers finds it throughMETA-INF/services/org.testcontainers.core.CreateContainerCmdModifierin the test resources.LoopbackPorts.checkfails the start when a port is published on another address.SolrSearchIndexTest: Makes the index throughSolrProvider, as LDS does, and empties it before each test withdeleteAll. It has two tests:aDocumentIsFoundByItsTextAndNotAfterItIsDeleted: a document is found by a word of alanguageText(Norway) with a filter on its entity type, the result has the namespace, entity type, id and version of the document, and afterdeletethe word finds nothing.aSearchIsNarrowedToTheEntitiesItNamesAndToItsPage: with three documents of two entity types,*:*finds three, a filter on one entity type finds two, a filter on both finds three, andfrom2 withsize2 gives one result and still three hits in total.
A write is in the index within the five seconds of commitWithin, so the tests search again every 100
milliseconds until the number of hits is the one they expect, for at most 30 seconds (await).
The test documents are the JSON files in src/test/resources. The tests use three of the six. Each document
gets the version ZonedDateTime.now(), so its id has the zone of the machine the tests run on.
The tests do not cover: what is indexed and what is not (every test document has languageText fields, and no
test searches for a text outside them), a second version of a document, a delete with another version than the
one that was written, a failed request, and a search on a core that has no searchfield yet.
The interface module has no tests.
Tests in other modules touch this part:
| Test | What it checks |
|---|---|
SearchIndexConfiguratorTest in core (TestNG) |
A provider is loaded by its name (testSearchIndex), none is loaded when search is off, and a name that no provider has (the empty text) fails. |
QueryVisitorsTest in core (JUnit) |
The Search field, TypeFilters and SearchResult that AddSearchTypesVisitor makes. |
GraphQLSchemaGoldenTest in core (JUnit) |
The whole GraphQL schema that is built when there is an index, compared with files. |
GraphQLIntegrationTest in core (TestNG) |
thatSeachByContactNameWorks and thatNestedSeachWorks write, search and delete through LDS with the provider testSearchIndex. Core's tests run with search on (application_test.properties). |
ServerStackIT in the server (JUnit) |
aDocumentIsFoundByATextOfIt starts the compose file and finds a document through LDS and Solr by a word of its languageText. It asks again for up to 30 seconds. |
The tests of the module run with the build of the module and what it needs. The other commands are in the build:
./mvnw verify -pl linked-data-store-search-provider-solr -amWhat is unfinished or known to be wrong
Both modules hold code that is not revised for 3.0 yet.
Not finished: what search covers is under review. The Solr provider indexes only texts whose path contains
languageText. With a model that has no such field, search finds nothing. The field searchfield is in the
core only after the first such text is written. On a new core, a search before that is answered by Solr with
undefined field searchfield, and no test covers it.
Not finished: the argument searchable of @domain is not read. AddSearchTypesVisitor.isSearchable and
DomainDirective.isSearchable are called by nothing. An entity type with @domain(searchable: false) is
in TypeFilters and SearchResult, is indexed and is found, like every other entity type.
Not finished: with a model of JSON Schema files and no GraphQL schema, search can be on, and every write goes
to the index, but LDS has no Search field and so nothing reads the index.
Not finished: the search text is joined into the query (text + createFilters(typeFilters)), which the rule
"No spliced identifiers" forbids. The text can name any field of the index. The filter is added without
brackets around the text, so brewery OR entity:Person with the filter Company becomes
brewery OR entity:Person AND (entity:Company). The names of the entity types of the filter are joined in as
well, without a check; core gives the values of the GraphQL enum TypeFilters there.
Not finished: a failed addition is not seen. With no Solr at the address, a PUT with sync=true (a
synchronous write) is answered 201, the log has the error of the update
client, and the document is not in the index. Nothing sends it again.
Not finished: a delete fails when Solr cannot be reached. With no Solr at the address, a DELETE with
sync=true is answered 500 with no text, the log says Observed Saga failure during execution, and the
document is deleted from the persistence provider: the next GET is answered 404.
Not finished: a delete takes out one entry at most. DeleteIndexSagaAdapter gives the time of the delete as
the version, and delete removes the entry with exactly that id. The entries of the versions that were
written before have another time in their id and stay in the index. An entry is removed only when the
DELETE has the same timestamp as the PUT that wrote it. A search that matches an entry that stayed gets
no document for it (seen with the memory provider), leaves it out, and writes
Cound not find document for key ... to the log at ERROR, every time.
Not finished: there is one entry for each version, and a search returns one result for each entry that matches. Core reads the document as it is at the snapshot time of the request for each result, and does not use the version of the result. A document with two versions that match comes twice in the result, both times as the same version, and a text that only an earlier version has still finds the document.
Not finished: nothing in a query says which namespace is searched. An LDS serves one namespace
(namespace.default), and a core that several LDS share answers each of them with the entries of all.
QueryConnectionFetcher reads a result from the namespace in its id.
Not finished: fromIdString reads only an id with exactly four /. A version without a zone name (...Z)
or with a zone name that has no / (...Z[UTC]) gives ArrayIndexOutOfBoundsException. A zone name with two
/, or a namespace, an entity type or a document id with a / in it, gives DateTimeParseException. One such
entry among the results fails the whole search.
Not finished: SolrSearchIndexTest passes only where the zone of the machine has exactly one / in its name
(Europe/Oslo, Etc/UTC), because its documents get the version ZonedDateTime.now(). Where the zone is
UTC, the id ends in Z[UTC] and fromIdString cannot read it.
Not finished: the index is not stopped. SearchIndex has no method to close it, UndertowApplication.stop
does not name the search index, and the two clients of Solr are never closed. An addition that is still in the
queue of the update client when LDS stops is not waited for.
Not finished: search runs when it is called and blocks the calling thread, and delete and deleteAll
block the thread that subscribes until Solr has answered. from and size are narrowed from long to int
without a check (from 4294967298 is sent as start=2), and a negative from is sent as it is.
Not finished: highlighting is asked for in every query and its result is thrown away.
Not finished: SearchIndexProvider.configurationKeys() is not called by anything for search.
Not finished: UpdateIndexSagaAdapter and DeleteIndexSagaAdapter are given the Specification and do not
use it.
Not finished: TestSearchIndex and SimpleSearchIndex are in the main code of core, not in its tests.
Not finished: the comment above search.index.provider in application-defaults.properties of core says the
value is the class name of a provider. The value is the name getProviderId() answers.
Not finished: the lint and doclint overrides in both POMs, the missing Javadoc, the Jackson dependency of the interface module that no class uses, its test dependencies that no test uses (TestNG, AssertJ, JSONassert), and the three test documents no test reads.