What’s next with JayData

Author: Peter Aron Zentai May 28th, 2013

One year of existence

In the past year JayData has gone through a lot of improvements – in a huge part driven by you – dear visitor. For example, the added support for some key OData 3.0 features like GEO data types and actions/operations turned JayData into a full featured complex service client – well beyond simple CRUD capabilities. And there is the JayData Server for the NodeJS platform to let you not just consume but also service rich semantic data on an elegant and standards based way, with purely JavaScript skills. And also we just reached a level of maturity to be able to offer our commercial editions – the PRO product line, that targets specific business use cases, like the need for a non-open-source licence, or the Transactions and Schema Evolutions modules, or developer support. And these improvements are really just a few to mention, the complete list of new features can be checked from the release notes page at http://jaydata.org/blog/release-notes.

But there are lot of things undelivered, features that we even promised. My personal regret goes for the OData V3 inheritance feature. We needed to cut out the whole feature because it was not compatible with the new value conversion pipeline– that on the other hand allows for a much more developer friendly way to express complex values like GEO Points or a GUIDs in queries.

So here is our new list of ‘What’s next’

JayData 1.3.1 – June the 7th

  • The big thing will be the QueryCache module – subsequent queries are resolved from the cache.
  • Fixes and small performance improvements for JayData 1.3 and JayData Server 1.1.

JayData 2.0 alpha – end of June

Read below to discover what is that we internally call the JayData Next

JayData 1.3.2 – midst of July

  • A comprehensive JayData Book and it’s online version. No more blog reading hell!
  • Inheritance support in WebSQL, IndexedDB and OData.
  • Support for querying local data with geo queries.
  • JayData ClientFront module.

JayData 1.3.3 – Aug

OData V4 style aggregations over WebSQL, IndexedDB, OData and MongoDB.

JayData 2.0 beta – end of Sept

JayData 2.0 released – Q4 2013

What is JayData Next – the 2.0 version

Our primary goal with the new version is to give you an architecture that provides total modularity, and customization and configuration capabilities not currently possible. JayData 2.0 will be your pluggable data pipeline engine that transmits data back and force from online and offline sources, for example synchronizing data just when it’s needed, while allowing you to hook this data flow into your client environment of any kind – Kendo UI, AngularJS, Knockout, you name it.

Data flow engine versus EntityManagers and EntityContexts

The way JayData currently works – by providing an EntityContext/EntityManager  class (that is such a know it all), and a rather complex DataProvider interface to create custom data source implementations – is just too monolithic. You can query for data, and then you receive that data – that’s it. On a way the JayData EntityContext and the providers see it fit. Most things are really under the hood. But what if you want to fiddle with the result before handing it to the client code, or just want the result be of a specific UI library type, let’s say a Knockout observable? Or what if you want to return a totally shaped result, but also want this result to be updateable – even if it does not even resembles the format of the original information. Or want to have and automatic save/update to happen when an item changes (a very typical thing in a mobile application settings screen, for example)? Or what if you want to be able to work with a custom HTTP  REST API that implements only a small subset of the full JayData functionality and it does it on it’s very own way?

All these examples show that instead of a monolithic manager class, that provides all the functionality as a compact unit, what we indeed need is an open data flow platform, that provides plugin points to each and every step of the long journey of the data while it get’s to you, or while a modified item gets stored.  And to fill the plugs also we need a lot of ready made plugins – to work with data as we did it before – JayData 2.0 will be 95% compatible with the 1.x versions, most of the time you will not have to change a thing. But on top of this, you’ll get the ability to integrate your data flow to any UI/App frameworks or storage options – with a couple of line of codes, on a JavaScript native way. Forget EntityManagers, and embrace openness, a clean data flow vision, and unseen capabilities to interact and integrate. Ahh jeah, and we will also let you think reactive! Work with live arrays and items…

CommonJS and AMD Modules, JayData Core under 25Kb.

With the new pluggable architecture you will be able to do the most common data managements tasks (CRUD) toward WebSQL, IndexedDB and OData with a ridiculously small library part under 25Kb. Albeit the speed of the typical internet connection renders the question of a client library size seemingly unimportant – there is one important aspect: a two times, three times bigger library means 200-300% longer startup time: yeah that annoying ‘browser loading’ state nowadays mostly come from the parsing of that several libraries your app is built from, rather then their download time – which usually takes less time then the parsing.

Native support for TypeScript with Generics<T>

There are two ways to support TypeScript: one is when you are provided an API surface in some ambient declaration files so that your TypeScript code can interact with the JavaScript library. And the other way is when the library actually let’s you use TypeScript language features to use it– not just allowing you consume the JavaScript API with some added sugar.