jsonpath_lib

Build Status crates.io Crates.io

Rust 버전 JsonPath 구현이다. Webassembly와 Javascript에서도 역시 동일한 API 인터페이스를 제공 한다.

It is an implementation for JsonPath written in Rust. it provide the same API interface in Webassembly andJavascript also.

Why?

To enjoy Rust!

API

With Javascript

With Rust (as library)

With AWS API Gateway

Simple time check - webassembly

Simple time check - native addon for NodeJs

With Javascript

jsonpath-wasm library

(not yet published jsonpath-wasm) javascript // browser import * as jsonpath from "jsonpath-wasm"; // NodeJs const jsonpath = require('jsonpath-wasm');

jsonpath-rs library (Only NodeJS)

jsonpath-rs is native addon for NodeJs

javascript const jsonpath = require('jsonpath-rs');

javascript - jsonpath.select(json: string|object, jsonpath: string)

```javascript let jsonObj = { "school": { "friends": [{"id": 0}, {"id": 1}] }, "friends": [{"id": 0}, {"id": 1}] }; let ret = [{"id": 0}, {"id": 0}];

let a = jsonpath.select(JSON.stringify(jsonObj), "$..friends[0]"); let b = jsonpath.select(jsonObj, "$..friends[0]"); console.log( JSON.stringify(ret) == JSON.stringify(a), JSON.stringify(a) == JSON.stringify(b) ); ```

javascript - jsonpath.compile(jsonpath: string)

```javascript let template = jsonpath.compile("$..friends[0]");

let jsonObj = { "school": { "friends": [ {"id": 0}, {"id": 1} ] }, "friends": [ {"id": 0}, {"id": 1} ] };

let ret = JSON.stringify([ {"id": 0}, {"id": 0} ]);

// 1. read as json object console.log(JSON.stringify(template(jsonObj)) == ret); // 2. read as json string console.log(JSON.stringify(template(JSON.stringify(jsonObj))) == ret);

let jsonObj2 = { "school": { "friends": [ {"name": "Millicent Norman"}, {"name": "Vincent Cannon"} ] }, "friends": [ {"id": 0}, {"id": 1} ] };

let ret2 = JSON.stringify([ {"id": 0}, {"name": "Millicent Norman"} ]);

// 1. read as json object console.log(JSON.stringify(template(jsonObj2)) == ret2); // 2. read as json string console.log(JSON.stringify(template(JSON.stringify(jsonObj2))) == ret2); ```

javascript - jsonpath.selector(json: string|object)

```javascript let jsonObj = { "school": { "friends": [{"id": 0}, {"id": 1}] }, "friends": [{"id": 0},{"id": 1}] };

let ret1 = JSON.stringify([ {"id": 0}, {"id": 0} ]); let ret2 = JSON.stringify([ {"id": 1}, {"id": 1} ]);

// 1. read as json object let selector = jsonpath.selector(jsonObj); console.log(JSON.stringify(selector("$..friends[0]")) == ret1); console.log(JSON.stringify(selector("$..friends[1]")) == ret2);

// 2. read as json string let selector = jsonpath.selector(JSON.stringify(jsonObj)); console.log(JSON.stringify(selector("$..friends[0]")) == ret1); console.log(JSON.stringify(selector("$..friends[1]")) == ret2); ```

javascript - allocjson, deallocjson

(not supported in jsonpath-rs)

wasm-bindgen은 Javascript와 Webassembly 간 값을 주고받을 때 JSON 객체는 String으로 변환되기 때문에, 반복해서 사용되는 JSON 객체를 Webassembly 영역에 생성해 두면 성능에 도움이 된다.

Since wasm-bindgen converts JSON objects to String when exchanging values between Javascript and Webassembly, it is helpful to create repeated Json objects in Webassembly area.

```javascript let jsonObj = { "school": { "friends": [{"id": 0}, {"id": 1}] }, "friends": [{"id": 0},{"id": 1}] };

let path = '$..friends[0]'; let template = jsonpath.compile(path); let selector = jsonpath.selector(jsonObj);

let ptr = jsonpath.alloc_json(jsonObj); if(ptr == 0) console.error('invalid ptr'); // 0 is invalid pointer let selector2 = jsonpath.selector(ptr);

let ret1 = selector(path) let ret2 = selector2(path) let ret3 = template(jsonObj); let ret4 = template(ptr); let ret5 = jsonpath.select(jsonObj, path); let ret6 = jsonpath.select(ptr, path);

console.log( JSON.stringify(ret1) == JSON.stringify(ret2),// true JSON.stringify(ret1) == JSON.stringify(ret3),// true JSON.stringify(ret1) == JSON.stringify(ret4),// true JSON.stringify(ret1) == JSON.stringify(ret5),// true JSON.stringify(ret1) == JSON.stringify(ret6));// true

jsonpath.dealloc_json(ptr); ```

With Rust (as library)

jsonpath_lib library

```rust extern crate jsonpath_lib as jsonpath;

[macro_use]

extern crate serde_json; ```

rust - jsonpath::select(json: &serde_json::value::Value, jsonpath: &str)

```rust let json_obj = json!({ "school": { "friends": [ {"name": "친구1", "age": 20}, {"name": "친구2", "age": 20} ] }, "friends": [ {"name": "친구3", "age": 30}, {"name": "친구4"} ]});

let json = jsonpath::select(&json_obj, "$..friends[0]").unwrap();

let ret = json!([ {"name": "친구3", "age": 30}, {"name": "친구1", "age": 20} ]); assert_eq!(json, ret); ```

rust - jsonpath::selectasstr(json: &str, jsonpath: &str)

```rust let ret = jsonpath::selectasstr(r#" { "school": { "friends": [ {"name": "친구1", "age": 20}, {"name": "친구2", "age": 20} ] }, "friends": [ {"name": "친구3", "age": 30}, {"name": "친구4"} ] } "#, "$..friends[0]").unwrap();

assert_eq!(ret, r#"[{"name":"친구3","age":30},{"name":"친구1","age":20}]"#); ```

rust - jsonpath::select_as\serde::de::DeserializeOwned>(json: &str, jsonpath: &str)

```rust

[derive(Deserialize, PartialEq, Debug)]

struct Person { name: String, age: u8, phones: Vec, }

let ret: Person = jsonpath::select_as(r#" { "person": { "name": "Doe John", "age": 44, "phones": [ "+44 1234567", "+44 2345678" ] } } "#, "$.person").unwrap();

let person = Person { name: "Doe John".tostring(), age: 44, phones: vec!["+44 1234567".tostring(), "+44 2345678".to_string()], };

assert_eq!(person, ret); ```

rust - jsonpath::compile(jsonpath: &str)

```rust let mut template = jsonpath::compile("$..friends[0]");

let json_obj = json!({ "school": { "friends": [ {"name": "친구1", "age": 20}, {"name": "친구2", "age": 20} ] }, "friends": [ {"name": "친구3", "age": 30}, {"name": "친구4"} ]});

let json = template(&json_obj).unwrap();

let ret = json!([ {"name": "친구3", "age": 30}, {"name": "친구1", "age": 20} ]);

assert_eq!(json, ret); ```

rust - jsonpath::selector(json: &serde_json::value::Value)

```rust let json_obj = json!({ "school": { "friends": [ {"name": "친구1", "age": 20}, {"name": "친구2", "age": 20} ] }, "friends": [ {"name": "친구3", "age": 30}, {"name": "친구4"} ]});

let mut selector = jsonpath::selector(&json_obj);

let json = selector("$..friends[0]").unwrap();

let ret = json!([ {"name": "친구3", "age": 30}, {"name": "친구1", "age": 20} ]);

assert_eq!(json, ret);

let json = selector("$..friends[1]").unwrap();

let ret = json!([ {"name": "친구4"}, {"name": "친구2", "age": 20} ]);

assert_eq!(json, ret); ```

rust - jsonpath::selectoras\serde::de::DeserializeOwned>(json: &serdejson::value::Value)

```rust let json_obj = json!({ "school": { "friends": [ {"name": "친구1", "age": 20}, {"name": "친구2", "age": 20} ] }, "friends": [ {"name": "친구3", "age": 30}, {"name": "친구4"} ]});

[derive(Serialize, Deserialize, PartialEq, Debug)]

struct Friend { name: String, age: Option, }

let mut selector = jsonpath::selectoras::>(&jsonobj);

let json = selector("$..friends[0]").unwrap();

let ret = vec!( Friend { name: "친구3".tostring(), age: Some(30) }, Friend { name: "친구1".tostring(), age: Some(20) } ); assert_eq!(json, ret);

let json = selector("$..friends[1]").unwrap();

let ret = vec!( Friend { name: "친구4".tostring(), age: None }, Friend { name: "친구2".tostring(), age: Some(20) } );

assert_eq!(json, ret); ```