disney/groovity

Groovity is a scripting language and runtime built upon a mature open-source foundation including Java, Groovy and Maven.

groovity's Issues

http tag should serialize data to XML according to content type

The http tag recognizes already recognizes XML data types like Document, Element and GPathResult and serializes them to XML, but if the Content-Type header is set to XML it should also serialize arbitrary objects to XML. For example

@Canonical
class MyData{
	String name
	int length
}

http(method: 'POST', url: 'http://somewhere', data: new MyData(name: 'hello', length:123)){
  header(name: 'Content-Type', value: 'application/xml')
}

produces a request body of MyData(hello,123), which is just the toString output of the object, and not valid XML. XML handling should be consistent with JSON: just changing the content type

http(method: 'POST', url: 'http://somewhere', data: new MyData(name: 'hello', length:123)){
  header(name: 'Content-Type', value: 'application/json')
}

generates an appropriate request body of {"length":123,"name":"hello"}

groovity-events.js uses es6 features

groovity-events.js, the browser side API for the groovity-events websocket multiplexing library, uses es6 features and is not compatible with IE11. It would be great to transpile the file during build to be compatible with es5; it would also be helpful to publish the JS independently to npm to make it easy to integrate into front-end builds. We should be able to accomplish both these tasks by leveraging the maven-frontend-plugin.

DataModel Attachments should be devolved inline before passing to data source store()

Right now, Attachments are gathered before storage by AttachmentCollector as a separate collection available in the StorePayload, to make it easy for stores to deal with binary attachments. However the Attachment instances are still left in the model, so that if the store performs a basic JSON serialization of the model including attachments, implementation details of the attachment leak into the serialized model - for example a bytes field or file field shows up in the JSON for byte and file attachments respectively.

We should devolve the model view of attachments into Maps or some form of empty Attachment in AttachmentCollector to prevent leaking of attachment implementations into persisted metadata, while leaving the implementations intact in the StorePayload for persisting the actual binary data outside the model.

close websockets on http session close

If a groovity websocket is opened with an active HTTP session, the websocket remains open when the HTTP session ends, which can be problematic for example if the session is tied to authentication and the websocket enables certain authorized actions; those activities would still be exposed to a user agent that held an open websocket connection after HTTP logout.

We should perform a server-side close on websockets affiliated with an HTTP session when that session ends. The client is free to attempt a reconnect and the application may deny the request with proper 401 response, or establish a new HTTP session, or allow a new websocket connection without an HTTP session according to business rules.

ModelJsonWriter produces invalid JSON with NaN

When encountering a numeric NaN value, the Json serializer produces the naive toString representation NaN which is not valid json and fails to parse in many parsers. We should rectify this so that NaN and Infinity are converted to null values when serialized to json.

HTTP signatures don't always work on standard ports (80, 443)

When attempting to sign an HTTP request to a URL on default protocol port, the signature does not always validate correctly.

There appears to be more than one underlying issue at play

1. When attempting to sign with no specific port, e.g. http://some.domain/some/endpoint, the client generated signing string includes host: some.domain:-1 which does not match the server signing string host: some.domain; this is a bug plain and simple.

2. When signing with an explicit default port, e.g. http://some.domain:80/some/endpoint, the client signing string drops the port so the signing string includes host: some.domain, but the host header still contains the port; when traversing a load balancer the default port can get stripped off the host header and the signature resolves correctly, but when connecting directly to an application without a load balancer in the path the signature fails as the server signing string has host: some.domain:80

There is no clean way to deal with 2) except to strip default ports off of URLs before issuing HTTP requests; if the port is not in the URL than the HOST header generated by Apache HTTP Client also omits the port, and it is received consistently by the server whether there is a load balancer in the path or not. This is also consistent with browser behavior; all browsers omit the default protocol port in the HOST header. But because Apache HTTP client will create a host header with the default port if that is how the URL is constructed, we have to sanitize the URL before passing it in.

support for environment variables in conf

It would be nice if the the groovity configuration mechanism was able to resolve environment variables as a fallback to system properties for increased configuration flexibility.

Add tags to control binding

Groovity provides an args mechanism for defaulting and coercing user input into bound variables; it would be helpful if a similar mechanism was available for use with variables from sources other than user input. It would also be helpful to have means to limit the scope of binding changes to reduce pollution and possible name collisions in complex projects.

Four new tags are proposed to address these needs and present a coherent approach for managing binding scope.

bind(a: b, c: d)

* place all attribute name/value pairs into binding
* no body
* use case: shorthand for 
        binding.setVariable('a', b)
        binding.setVariable('c', d)

rebind(a: b, c: d){ … }

* place all attribute name/value pairs into binding while body executes
* restore prior bound value or unbound state of named attributes after body completes
* allows unspecified modifications to binding to flow from body to calling context (i.e. changes to variables not defined as attributes)
* use case: temporary override of variables, e.g. out
        def writer = new CharArrayWriter()
        rebind(out: writer){
            write{<~Hello~>}
        }

unbind(a: b, c: d){ … }

* place all attribute name/value pairs into binding while body executes
* restore entire binding to prior state after body executes
* prevents any binding modifications in body from reaching calling code
* use case: safe calls to arbitrary libraries with no binding pollution
        unbind{
            norm(viewPath: '/normalView')
            run(viewPath)
        }

norm(a: 123, b: null, c: Long.class)

* define binding variables with normal/default values and/or type coercion
* if binding variables already have values, norm values are used for type coercion
* if norm value is a class, a convertible value must be found in the binding
* similar to using args, but does not resolve user input, only relies on binding
* Use case: simplify management of variable defaults and type conversion
        unbind{
            norm(viewPath: '/normalView', writeResults: false)
            results = run(viewPath)
            if(writeResults){
                write(value: results)
            }
        }

Groovity won't startup without source or jar locations configured

Right now GroovityBuilder throws an exception if neither source or jar locations configured, preventing startup. This is a remnant of an earlier era; Groovity can now can pick up packaged classes from the class path based on /groovity/manifest. This issue does not impact groovity-servlet since that sets a default jar location of WEB-INF/groovity-classes, but will prevent groovity from starting up outside of a servlet if it is only relying on packaged groovity scripts.

No groovity source locators or jar directories configured: java.lang.IllegalArgumentException
java.lang.IllegalArgumentException: No groovity source locators or jar directories configured
	at com.disney.groovity.GroovityBuilder.build(GroovityBuilder.java:310)
	at com.disney.groovity.GroovityBuilder.build(GroovityBuilder.java:251)

Elasticsearch scroll deletion fails when scroll IDs are large

ElasticSearch, at least as run in AWS, will sometimes return very large scroll IDs that cause a 413 response on the request to DELETE the scroll used for dateRange queries, since the scroll ID is in the URL. We need to move the scroll ID to the body of the delete request, which will require working around limitations in the apache http client.

add option to customize XML namespace prefixes when writing XML

XML namespace prefixes are automatically generated for JAXB elements when using the write tag; it would be nice to be able to customize them.

Example code:

import javax.xml.bind.annotation.XmlRootElement

static web=[
	path:'/sampleXml',
	output:'application/xml'
]

@XmlRootElement(namespace="http://sample.com/") 
class Doc{
	def a = 1
	def b = 2
}

write(value: new Doc())

generates

<ns1:doc xmlns:ns1="http://sample.com/">
<a>1</a>
<b>2</b>
</ns1:doc>

Since we don't have package declarations in groovity, we can't directly use @XmlSchema and @xmlns annotations unless the JAXB types are written in java; perhaps we could support an alternative mechanism to pass custom namespaces to the write() tag, e.g.

write(value: new Doc(), namespaces:[sample:'http://sample.com'])

to generate

<sample:doc xmlns:sample="http://sample.com/">
<a>1</a>
<b>2</b>
</sample:doc>

Groovity servlet admin docs page is broken when using groovity-error-page module

The default custom error page shell is missing a required tag annotation element, which in turn causes an exception that prevents the documentation API from rendering. We should fill in the missing element, but also make the documentation feed more resilient so errors like these have less impact and are easier to track down.

Traits in multimodule project sometimes fail instanceof check

We have observed that in a multimodule groovity-data project, sometimes classes implementing certain traits fail an instanceof check for the trait; this does not occur for all traits or consistently on different developer machines.

Compiling large project with complex trait hierarchies can be slow

In a large project with complex trait and type hierarchies, we have noticed overly long pauses during builds. It seems there are two easy, safe things we can do to speed it up

1. pass any traits loaded from dependencies to the compiler the first time to avoid possible extra compiler looping

2. attempt to complete compilation of sources containing traits before processing other sources, to shorten compiler loops

boundary parameter to content type header missing for multipart form submission using http tag

When using the http tag with a Content-Type of multipart/form-data and an appropriately constructed map of data, a MultipartEntity is constructed; however the Content-Type header sent via the http client is missing the boundary parameter required for successful multipart processing on the receiving end. We should make sure to propagate the boundary from the constructed entity to the request header for proper compatibility.

groovity-events-client fails npm install

The babel transpilation step is failing when attempting to install groovity-events-client in another project using npm; the install script should be moved to prepare so that it is only invoked before publishing, not by installers.

groovity-elasticsearch dateRange can go into unbounded loop

It appears that a race condition can emerge in certain data update/access pattern scenarios where the dateRange method in the elasticsearch data source implementation can go into an unbounded loop, presumably because the number of results for the query changes between calls; we should investigate changing this implementation to use the elasticsearch scroll API which provide a snapshot for reliably iterating through results

Add automatic closing of AsyncChannel on script class destroy

By convention, long-lived async channels are established by calling accept() in a static init() or static start() method; by convention, the AsyncChannel reference returned by accept needs to be tracked and closed manually in static destroy(); this makes sure for example during local development that as the source is modified and recompiled, older versions of the channel don't remain open. It would be nice if groovity automatically tracked static async channels and closed them during destroy to remove the need for this boilerplate destruction code in scripts.

ModelFilters and closures should be able to replace an object with a list

When evaluating closures for deferred resolution of model branches in XML and JSON writers, and when using ModelFilter.transform() or ModelFilter.invoke() to substitute values in a model, it should be possible to replace an object value with a list or null value. However this currently does not work as all these cases only support passing a non-null Object on to their consumer; we should add support and tests for the list and null use cases.

System properties should be able to override properties files for application conf

Right now it is possible to provide a groovity configuration property one of two standard ways, by system properties or in a properties file (default location /groovity.properties on the classpath, or can itself be changed using -Dgroovity.propsFile). Either way works independently; currently when the same setting is specified BOTH ways, the precedence is inconsistent; for groovity-servlet properties system properties take precedence over properties file, but for application-defined properties (e.g. static conf=[myKey:123]), the properties file takes precedence over system properties.

These should be made consistent, and it makes sense to standardize on system properties taking precedence over properties file - this makes more sense for example with an application that has embedded properties files, at deploy time to override those settings via the environment. The application would still be able to override system properties at runtime via a custom Configurator that might pull live configuration from a database or configuration service.

write tag cannot write to string with escape option

When writing to a string with an escape option set, currently a bogus string is generated reflecting the identity of the escaping writer; we need to make sure the return value is based on the underlying char writer and not the escape writer. A workaround is to use nested write tags; the outer writes to a string, and the inner escapes to out.

Minify tag throws ArrayIndexOutOfBoundsException after IOException

If the underlying writer throws an IOException during flush and calling code attempts to call write() again, the minifying writer throws an ArrayIndexOutOfBoundsException because the buffer failed to clear. It should instead act like a normal Writer and throw IOException again.

Add support for async data transfers

It would be nice if the groovity-data module provided generalized support for performing asynchronous transfers of data between types, e.g. for copying data from primary storage to a separate search index, or for using distinct types to represent data lifecycle stages.

Allow per-data-type 'http.timeout' configuration using http data source

It would be nice if it were possible for a data type leveraging the HTTP data source to specify its own timeout that would override the globally configured default http timeout.

Add type configuration options and persistence support for http data source

Currently the HTTP data source in groovity-data is only useful for retrieving domain models from fully formed URLs that don't require authentication. We should add support for some type-specific configuration options to make it more useful

• baseurl - specify a custom baseurl for the type, so for example with a typical REST GET API we could just pass in the ID to the factory and not the URL prefix for the endpoint

• decorator - specify a custom decorator script for the http call, to allow arbitrary authentication against the http endpoint, e.g. using basic, digest or signature authentication, or some other security parameter or header.

The http data source also currently is read-only; it would make sense for it to support PUT/POST and DELETE semantics for CRUD APIs that follow standard patterns (e.g. POST to baseurl to create, parse 201 response for new ID, PUT to baseurl+ID to update, DELETE baseurl+ID to remove)

Error executing elasticsearch watch for document by ID

Attempting to perform a watch on a single elasticsearch document results in a 400 response from elasticsearch.

factory.watch('someType','someId')

results in

SEVERE: HTTP/1.1 400 Bad Request ElasticSearch Error Message: {"error":{"root_cause":[{"type":"illegal_argument_exception","reason":"request [\/content-index\/someType\/someId] contains unrecognized parameter: [sort]"}],"type":"illegal_argument_exception","reason":"request [\/content-preview-read\/configuration\/53303512] contains unrecognized parameter: [sort]"},"status":400}

There appears to be a bug in the rest query URL construction for single document watching; it works as expected when just watching by type

factory.watch('someType'){ ptr->
    //do something
}

Source code editor support

Groovity should provide an implementation of language server protocol to enable syntax highlighting and code completion support in multiple developer tools.

https://langserver.org

Null pointer in GroovityScriptView when running with case insensitivity

With case sensitivity disabled and groovity mapped to the default servlet, we see null pointers

java.lang.NullPointerException
	at com.disney.groovity.servlet.GroovityScriptView$Processor.process(GroovityScriptView.java:527)

It appears the other sections of the servlet code have a fallback check that is missing here, to use ServletPath when PathInfo is null.

support @ModelSkip on classes

Currently the @ModelSkip annotation is supported on fields and getters to exclude them from iteration via Model.each(), which affects copying and serialization. This is useful especially when building models from Traits, so the trait can define @ModelSkip as appropriate on its own members. However it also makes sense to support @ModelSkip with an array of property names at the class level, for example if a composite model wants to skip one or more properties of traits or subclasses it inherits from.

Support more complex ElasticSearch queries and responses in groovity-elasticsearch

The current elasticsearch data source supports ElasticSearch query string syntax, but this does not allow for aggregations or highlighting among other features. We should support a full JSON search request as an elasticsearch key.

Since the response format may contain hits and/or aggregations depending on the query, the data source should simply produce the entire search response as a single document; it would be up the user to define a data type that will absorb hits or aggregations, and decide whether they should be Shared, etc., and whether or how to pre or post process the aggregations.

So you would not be able to run aggregations against typical data types, but you could create ancillary types, e.g. for a 'story' type defining story fields like title, description and body, you might have a 'storyQuery' type that shares the same ES index/type configuration as story, but just defines the fields hits and aggregations, and can be used to capture the full results of JSON queries.

Move gpg signing to maven profile for easier building

Currently the maven build is set up to perform GPG signing, which is good for releasing, but not convenient for building for local testing and exploration. While this can be skipped using mvn install -Dgpg.skip, it would make more sense to skip by default and require a specific release profile to enable signing.

add ModelTemplateWriter for string templated Model serialization

Groovity currently provides specialized ModelWalkers to generate JSON and XML from Models (ModelJsonWriter and ModelXmlWriter). It might also make sense to provide a ModelTemplateWriter that could be used to generate string-templated output, e.g. HTML or Markdown, from a Model.

One possible design approach would be to exclusively serialize templates and rely on ModelFilter.transforms to insert templates at the appropriate places while walking a logical Model.

It would make sense to be able to leverage this solution using the write tag the way json and xml are accessible formats.

This might be a more flexible approach to templating for models with mixed collections of types or composed of traits for which ModelFilter transforms can be independently specified and composed together as needed.

To express the concept in pseudo-code, something like this

model = [new Story(...), new Video(...), new Video(...)]

def filters = [
	ModelFilter.transform(Story.class){m-> <~<li>Story ${m.title} - ${m.wordCount} words</li>~>},
	ModelFilter.transform(Video.class){m-> <~<li>Video ${m.title} - ${m.duration} seconds</li>~>}
]

<~
<html>
<ul>
<g:write value"${model}" filter="${filters}" format="~" />
</ul>
</html>
~>

Simplify server-side programming model in groovity-events

The groovity-events module provides a lightweight robust messaging framework on top of websockets and the groovity AsyncChannel construct. While it works effectively, the server programming model requires raw use of accept and offer with conventions for how the channel keys are structured, as well as requiring explicit error handling and invocation of a callback function.

We should provide a groovity-events specific abstraction on top of accept and offer to hide the complexity of structured channel keys, as well as provide automatic error handling and mapping of return values to callback functions. We can make the server model align more closely with the client model by calling these extensions on and emit respectively, mirroring the socket function names on the client side for consuming and producing events.

Hash and Hmac tags should support InputStreams

The core Hash and Hmac tags currently support String, byte[] or template values for generating hashes and signatures respectively; we should also support InputStream for efficient handling of arbitrarily large payloads (e.g. groovity-data Attachment). It would also be fairly trivial to add File support as a convenience as well.

Data module should offer change notifications

The Stored trait in groovity-data implements store() and delete() methods that can be extended by other traits in a DataModel. It would be nice if those base implementations also offered asynchronous change notifications on a well-known broadcast channel to enable more integration patterns.

Data service unsafe modification of Shared models

The data service does not check whether a Model is Shared before updating the model for storage; this could result in dirty reads from the factory cache if the modifications are POSTed directly to a Shared DataModel. Before performing any mutations of a loaded model, data service should check if the model is Shared and if so, create a copy which will be used to perform mutations and storage. The act of storing will invalidate the cache and force a fresh load of the updated data into cache.

Ws tag prevents startup outside servlet-container environment

The Ws websocket client tag depends on the java websocket API and will break startup if that API is not present, which may be the case outside of a servlet container.

com.disney.groovity.Taggable: Provider com.disney.groovity.tags.Ws could not be instantiated: java.util.ServiceConfigurationError
java.util.ServiceConfigurationError: com.disney.groovity.Taggable: Provider com.disney.groovity.tags.Ws could not be instantiated
	at java.util.ServiceLoader.fail(ServiceLoader.java:232)
	at java.util.ServiceLoader.access$100(ServiceLoader.java:185)
	at java.util.ServiceLoader$LazyIterator.nextService(ServiceLoader.java:384)
	at java.util.ServiceLoader$LazyIterator.next(ServiceLoader.java:404)
	at java.util.ServiceLoader$1.next(ServiceLoader.java:480)
	at com.disney.groovity.Taggables.init(Taggables.java:75)
	at com.disney.groovity.Groovity.init(Groovity.java:381)
	at com.disney.groovity.Groovity.start(Groovity.java:441)
	at com.disney.groovity.GroovityBuilder.build(GroovityBuilder.java:342)
	at com.disney.groovity.GroovityBuilder.build(GroovityBuilder.java:251)
	at com.disney.groovity.aws.lambda.GroovityAwsLambda.<init>(GroovityAwsLambda.java:70)
	at com.disney.groovity.aws.lambda.GroovityAwsLambda.<init>(GroovityAwsLambda.java:32)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance0(Native Method)
	at sun.reflect.NativeConstructorAccessorImpl.newInstance(NativeConstructorAccessorImpl.java:62)
	at sun.reflect.DelegatingConstructorAccessorImpl.newInstance(DelegatingConstructorAccessorImpl.java:45)
	at java.lang.reflect.Constructor.newInstance(Constructor.java:423)
Caused by: java.lang.NoClassDefFoundError: javax/websocket/ClientEndpointConfig$Configurator
	at java.lang.Class.getDeclaredConstructors0(Native Method)
	at java.lang.Class.privateGetDeclaredConstructors(Class.java:2671)
	at java.lang.Class.getConstructor0(Class.java:3075)
	at java.lang.Class.newInstance(Class.java:412)
	at java.util.ServiceLoader$LazyIterator.nextService(ServiceLoader.java:380)
	... 13 more
Caused by: java.lang.ClassNotFoundException: javax.websocket.ClientEndpointConfig$Configurator
	at java.net.URLClassLoader.findClass(URLClassLoader.java:381)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:424)
	at java.lang.ClassLoader.loadClass(ClassLoader.java:357)
	... 18 more

While this can be worked around by explicitly importing javax.websocket-client-api as a dependency, it might make sense to move the Ws tag out of groovity-core, either into groovity-servlet or a standalone module.

File data source should protect against concurrent writes/reads

The current implementation of the file data source writes files directly to their final storage location without any locking; this could lead to dirty reads or even garbled writes. We should modify it to perform a write-and-rename operation; this should prevent partial dirty reads and guarantee write consistency.

Error when performing mvn install without clean

When performing a mvn install command on groovity-sql after a previous build, the following error occurs:

No signature of method: static HasRowId.$init$() is applicable for argument types: (Wagon) values: [<Wagon@3dc39459>]

This appears to be due to the classloader view of a trait from jar loading being overridden by the startup compiled trait ... we should only add missing traits to a class loader instead of replacing them all at init time.

Await, async blocks and channels don't register groovity stats

It can be difficult to measure the performance of asynchronous computing in Groovity because asynchronous handlers don't register a parent groovity statistics execution to capture the overall execution time and breakdown of those async blocks and channels. We should make sure that it is easy to determine the overall execution time of async commands in groovity stats, as well as how much time is spent in other threads waiting for those async commands to complete.

Elasticsearch JSON source queries fail with ES 6.x

Recently added support for JSON format queries in the groovity-elasticsearch module only works with ElasticSearch 5.x; in version 6 they have added a new required parameter source_content_type that we need to add to the URL. Starting with ES6 it is also no longer allowed to create multiple type mappings in one index; we should update unit tests accordingly.

http tag does not honor content-type header charset

when using a raw string or object model as data for an http POST or PUT, characters are always transmitted as ISO-8859-1 even if the content type header specifies a different encoding; this breaks reading on the receiving side. For example a simple echo endpoint will fail with this test

http(
	url: "${host}/charCheck",
	method: 'POST',
	data:[ message: 'åéü' ]
){
	header(name:'Content-Type', value:'application/json; charset=UTF-8')
	handler{ resp ->
		def message = parse(value:resp).message
		assert message == 'åéü'
	}
}

We appear to be relying on default behavior of Apache HTTP Client StringEntity, which defaults to ISO-8859-1; we should parse the Content-Type header if present and use the charset defined there if available.

HTTP tag wraps pre-generated json string body in quotes

When passing an already formulated JSON string to the HTTP tag, it get's re-encoded as a JSON string value in quotes; this is inconsistent with the behavior for XML bodies where pre-formulated strings are treated as valid XML, and makes it difficult to pre-compute the body for purposes like generating a valid Content-MD5 header. For example

def body = write(value:[abc:123],to:"")
http(method:'PUT', url:'...', data: body)){
  header(name:'Content-Type',value:'application/json')
}

generates an actual post body of

"{\"abc\":123}"

whereas it works fine when allowing the http tag to do the serialization

http(method:'PUT', url:'...', data: [abc:123]){
  header(name:'Content-Type',value:'application/json')
}

produces the expected body of

{"abc":123}

We should allow string (or CharSequence) bodies to flow through to the request without modification regardless of content type; we should only perform serialization logic according to content-type when the body is some other object type like a Map, Model or Bean.

Improve usability of Attachments

For building APIs that use binary attachments to DataModels, it would be helpful to add some additional functionality

• calculate MD5 hash of payload
• use MD5 hash to determine when payload needs to be updated, and to determine when modified date should change
• Allow storing updates to attachment metadata without accessing/modifying the payload

Add cache management page to groovity-servlet-admin

We expose cache statistics and clearing methods through JMX; for environments where JMX is not easily accessible it would be nice to expose the same information and methods via the web administration UI.

Allow configuration of max cache entries per data type in groovity-data

We should pass through max from the conf of a data type to the factory cache for that type, to allow more complete control over cache behavior

Watcher error logging can be very verbose

When there is an error condition in a frequently running watcher it can create large volumes of log statements; it would be nice if after the first stack trace, repeated errors were logged without the stack trace, unless the stack trace changes.

File data source should allow control over serialization format

The file data source should allow a data type to configure XML or JSON as a serialization format; currently it defaults to JSON but can be fooled into generating XML if there's an incoming http request that accepts XML responses. The JSON default should be made strict irrespective of http requests, and should support strict XML if the type explicitly declares it.

413 error with large elasticsearch queries

when using complex queries (greater than 4 KB of query json), and running inside an AWS VPC, a 413 error prevents execution. This is likely a limitation of using the GET method and some additional infrastructure running in the VPC must enforce stricter rules since outside the VPC the same version of ES accepts the queries via query string in URL fine; we should change to use POST for JSON queries to avoid hitting this limit. It would also be helpful if error logging was a little more clear in these circumstances, as the visible effect was a JSON parse exception.

Add general purpose REST API for groovity-data

Because groovity-data defines conventions for storing and retrieving data from heterogeneous data sources according to type, it should be relatively straightforward to produce a general-purpose groovity-data REST api that would work with any user-defined groovity-data types, just by making the type a path parameter in the REST api.