spikard-cli 0.16.0-rc.1

Command-line interface for building and validating Spikard applications
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80

//! `OpenRPC` 1.3.2 specification parsing and code generation
//!
//! This module orchestrates `OpenRPC` spec parsing and code generation across
//! multiple languages. The actual generation logic is delegated to language-specific
//! generators in the `generators/` module.
//!
//! `OpenRPC` is the standard for describing JSON-RPC 2.0 APIs.

pub mod generators;
pub mod spec_parser;

pub use generators::{
    ElixirOpenRpcGenerator, OpenRpcGenerator, PhpOpenRpcGenerator, PythonOpenRpcGenerator, RubyOpenRpcGenerator,
    RustOpenRpcGenerator, TypeScriptOpenRpcGenerator,
};
pub use spec_parser::parse_openrpc_schema;

use anyhow::Result;
use spec_parser::OpenRpcSpec;

/// Generate Python handler scaffolding from `OpenRPC` spec
pub fn generate_python_handler_app(spec: &OpenRpcSpec) -> Result<String> {
    let generator = PythonOpenRpcGenerator;
    generator.generate_handler_app(spec)
}

/// Generate TypeScript handler scaffolding from `OpenRPC` spec
pub fn generate_typescript_handler_app(spec: &OpenRpcSpec) -> Result<String> {
    let generator = TypeScriptOpenRpcGenerator;
    generator.generate_handler_app(spec)
}

/// Generate Ruby handler scaffolding from `OpenRPC` spec
pub fn generate_ruby_handler_app(spec: &OpenRpcSpec) -> Result<String> {
    let generator = RubyOpenRpcGenerator;
    generator.generate_handler_app(spec)
}

/// Generate Rust handler scaffolding from `OpenRPC` spec
pub fn generate_rust_handler_app(spec: &OpenRpcSpec) -> Result<String> {
    let generator = RustOpenRpcGenerator;
    generator.generate_handler_app(spec)
}

/// Generate PHP handler scaffolding from `OpenRPC` spec
pub fn generate_php_handler_app(spec: &OpenRpcSpec) -> Result<String> {
    let generator = PhpOpenRpcGenerator;
    generator.generate_handler_app(spec)
}

/// Generate Elixir handler scaffolding from `OpenRPC` spec
pub fn generate_elixir_handler_app(spec: &OpenRpcSpec) -> Result<String> {
    let generator = ElixirOpenRpcGenerator;
    generator.generate_handler_app(spec)
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_openrpc_module_exports() {
        let _: fn(&OpenRpcSpec) -> Result<String> = generate_python_handler_app;
        let _: fn(&OpenRpcSpec) -> Result<String> = generate_typescript_handler_app;
        let _: fn(&OpenRpcSpec) -> Result<String> = generate_rust_handler_app;
        let _: fn(&OpenRpcSpec) -> Result<String> = generate_ruby_handler_app;
        let _: fn(&OpenRpcSpec) -> Result<String> = generate_php_handler_app;
        let _: fn(&OpenRpcSpec) -> Result<String> = generate_elixir_handler_app;
    }

    #[test]
    fn test_openrpc_module_can_parse_and_generate() {
        let schema_path = std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR"))
            .join("../../testing_data/schemas/user-api.openrpc.json");
        let spec = parse_openrpc_schema(&schema_path).expect("OpenRPC schema should parse");

        let ts = generate_typescript_handler_app(&spec).expect("TypeScript scaffold should generate");
        assert!(ts.contains("handleJsonRpcCall"));
    }
}