add support for validating vns format json through request

Author: yudonglin

vns-cpp/schema.hpp

@@ -53,6 +53,32 @@ const std::string VNS_SCHEMA = R"(
                             },
                             "type": "array"
                         },
+                        "events": {
+                            "items": {
+                                "properties": {
+                                    "target": {
+                                        "type": "string"
+                                    },
+                                    "type": {
+                                        "type": "string"
+                                    },
+                                    "value": {
+                                        "type": [
+                                            "string",
+                                            "number",
+                                            "boolean"
+                                        ]
+                                    }
+                                },
+                                "required": [
+                                    "target",
+                                    "type",
+                                    "value"
+                                ],
+                                "type": "object"
+                            },
+                            "type": "array"
+                        },
                         "narrator": {
                             "type": "string"
                         },

vns-python/test_server.py

@@ -1,9 +1,13 @@
 import json
+from typing import Any
 
 import requests
 
+# url for the site to make api call
+api_site: str = "https://api.vns.wiki"
+
 # url for getting vns schema
-schema_url: str = "https://api.vns.wiki/get/schema"
+schema_url: str = f"{api_site}/get/schema"
 
 # send request
 schema_response: requests.Response = requests.get(schema_url)
@@ -78,13 +82,30 @@
 """
 
 # url for compiling raw vns script
-compiler_url: str = "https://api.vns.wiki/post/compile"
+compiler_url: str = f"{api_site}/post/compile"
 
 # send request
 compiler_response: requests.Response = requests.post(
     compiler_url, json={"data": raw_vns_content}
 )
 
+# the json data get from compiling the raw vns script
+json_compiled: dict[str, Any] = json.loads(compiler_response.text)
+
 # show result
 print("\nVNS online service responded compiler request with:")
-print(json.loads(compiler_response.text))
+print(json_compiled)
+
+# url for validating compiled vns json file
+validation_url: str = f"{api_site}/post/validate"
+
+# send request
+validation_response: requests.Response = requests.post(
+    validation_url, json=json_compiled
+)
+
+# obtain validation result
+validation_result: dict[str, bool] = json.loads(validation_response.text)
+
+# assert the result is True
+assert validation_result.get("result", False) is True

vns-server/server.cpp

@@ -2,6 +2,7 @@
 #include "extern/vns-cpp/compiler.hpp"
 #include "extern/vns-cpp/schema.hpp"
 #include "extern/vns-cpp/naming.hpp"
+#include "extern/vns-cpp/validator.hpp"
 
 // HTTP
 int main(const int argc, char **argv)
@@ -50,7 +51,8 @@ int main(const int argc, char **argv)
             Naming::update_database(req_j["namings"].get<std::unordered_map<std::string, std::vector<std::string>>>());
 
         // compile raw vns data
-        const std::string compiled = Compiler::load_as_string(req_j["data"].get<std::string>());
+        const std::string compiled = req_j.contains("data") ? Compiler::load_as_string(req_j["data"].get<std::string>())
+                                                            : std::string();
 
         if (DEBUG)
             std::cout << "result: " << compiled << std::endl;
@@ -59,6 +61,16 @@ int main(const int argc, char **argv)
         res.set_content(compiled, "application/json");
     });
 
+    // Define a route for handling vns format json validation request
+    svr.Post("/post/validate", [](const httplib::Request &req, httplib::Response &res) {
+        // Respond with result
+        const nlohmann::json response = {
+                {"result", !req.body.empty() && Validator::validate(nlohmann::json::parse(req.body))}};
+
+        // return result
+        res.set_content(response.dump(), "application/json");
+    });
+
     // Define a route for handling get schema request
     svr.Get("/get/schema", [](const httplib::Request &, httplib::Response &res) {
         res.set_content(VNS_SCHEMA, "application/json");