JLio

JLio (jay-lio) is a structured language definition for transforming JSON objects using a transformation script with a JSON notation.

JLio can create and alter JSON data objects. It allows the transformation of objects, without having the need to code or develop logic. Simply writing the desired commands as a JSON object. Executing the script on a data object will transform the data object following the script commands.

Designed with extensibility in mind, commands, and functions can be added to support the desired functionality. The core functionalities provide commands like add, set, copy, move, remove.

Lowering the number of commands and functions reduces memory consumption and improves performance. The .NET implementation of JLio supports flexible configurations limiting the resources needed.

The extension packs provide additional commands. Functionalities like compare, merge, schema filtering can be added. Writing your own command is a simple task as well as the possibility to override existing ones.

Import-Export function packs give the possibility to transform an JSON object into another structure. The exchange between the different types will be a string notation. Parsing the string notations can convert the string into a proper JSON object.

Getting Started

The start point could be a script. To transform into an executable set of commands, it needs to be parsed.

Adding JLio to your project.

Adding Jlio to your projects is just adding a NuGet package to them.

 dotnet add package JLio.Client

Sample parsing

When you need to parse a JSON string into an executable, you need to use the JlioConver.Parse implementation. The JlioConvert.Parse function will return you a JlioScript that can be executed.

var script = JLioConvert.Parse(scriptText);

Fluent API

Alternatively, the script can be composed using the fluent API.

 var script = new JLioScript()
                    .Add(new JValue("new Value"))
                    .OnPath("$.demo")
                    .Add(new Datetime())
                    .OnPath("$.this.is.a.long.path.with.a.date");

Execution

Executing the script will alter the object you provide according to the script commands. The script itself has an Execute function to invoke the transformation. The data object has to be a JToken. Converting a String to

var data = JToken.Parse("{\"demoText\":\"Hello World\"}");
var result = script.Execute(JToken.Parse(data));

Complete Samples

Fluent api sample

var script = new JLioScript()
                    .Add(new JValue("new Value"))
                    .OnPath("$.demo")
                    .Add(new Datetime())
                    .OnPath("$.this.is.a.long.path.with.a.date");
   
var data = JToken.Parse("{\"demoText\":\"Hello World\"}");             
var result = script.Execute(data);

parse script sample

var script = JLioConvert.Parse("[{\"path\":\"$.myObject.newProperty\",\"value\":\"new value\",\"command\":\"add\"}]");
var data = JToken.Parse("{\"demoText\":\"Hello World\"}");
var result = script.Execute(data);

JsonPath

Jsonpath is used to select the items in the data objects. It uses a simple notation to indicate which element needs to be selected.

See: JSONPath expressions - https://goessner.net/