wkr 0.0.0

#[worker] macro for wasm workers
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

// Copyright 2022 VMware, Inc.
// SPDX-License-Identifier: Apache-2.0

use crate::args::Args;
use proc_macro::TokenStream;
use quote::quote;
use syn::parse_macro_input;

/// Expand the given input after processing by the macro
pub fn expand_macro(attr: TokenStream, item: TokenStream) -> TokenStream {
    let handler_fn = parse_macro_input!(item as syn::ItemFn);
    let handler_fn_name = &handler_fn.sig.ident;
    let args = parse_macro_input!(attr as Args);

    let mut call_arguments = vec![quote! { input.to_http_request() }];

    if args.has_params() {
        call_arguments.push(quote! { params });
    }

    if args.has_cache() {
        call_arguments.push(quote! { &mut cache });
    }

    let main_fn = quote! {
        use wasm_workers_rs::io::{Input, Output};
        use std::io::stdin;

        fn main() {
            let input = Input::new(stdin());
            let error = Output::new(
                "There was an error running the handler",
                500,
                None,
                None,
                false
            ).to_json().unwrap();

            if let Ok(input) = input {
                let mut cache = input.cache_data();
                let params = input.params();

                if let Ok(response) = #handler_fn_name(#(#call_arguments),*) {
                    match Output::from_response(response, cache).to_json() {
                        Ok(res) => println!("{}", res),
                        Err(_) => println!("{}", error)
                    }
                } else {
                    println!("{}", error)
                }
            } else {
                println!("{}", error)
            }
        }

        #handler_fn
    };

    TokenStream::from(main_fn)
}