gateryx 0.1.6

Secure HTTP gateway for IoT and Industrial 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
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114

const isDev = import.meta.env.MODE === "development";

const RPC_URI = "/.gateryx/rpc";

export interface SvcMessage {
  kind: string;
  svc: string;
  message?: string;
  value?: string;
}

export const parse_svc_message = (msg?: string): SvcMessage | null => {
  if (msg && msg.startsWith("|")) {
    let sp = msg.split("|");
    let kind = sp[1];
    if (kind) {
      let result: SvcMessage = { kind: kind, svc: sp[2] };
      let svc_msg = sp[3];
      if (svc_msg) {
        let sp_msg = svc_msg.split("=");
        result.message = sp_msg[0];
        result.value = sp_msg[1];
      }
      return result;
    }
  }
  return null;
};

export interface EngineError {
  code: number;
  message: string;
}

export class Engine {
  api_uri: string;
  rpc_call_id;
  constructor() {
    this.api_uri = isDev ? "http://127.0.0.1:3000" : "";
    this.rpc_call_id = 0;
  }
  call(method: string, params?: any): Promise<any> {
    let me = this;
    return new Promise((resolve, reject) => {
      const headers: any = {
        "Content-Type": "application/json"
      };
      const call_id = me.rpc_call_id;
      fetch(`${me.api_uri}${RPC_URI}`, {
        method: "POST",
        headers,
        body: JSON.stringify({
          jsonrpc: "2.0",
          id: call_id,
          method: method,
          params: params || null
        })
      })
        .then((response) => {
          if (response.ok) {
            response
              .json()
              .then((data) => {
                if (!data || typeof data !== "object") {
                  reject({ code: -32010, message: "Invalid server response" });
                  return;
                }
                if (data.jsonrpc !== "2.0") {
                  reject({ code: -32010, message: "Invalid server response" });
                  return;
                }
                if (data.id !== call_id) {
                  reject({ code: -32010, message: "Invalid server response" });
                  return;
                }
                if (data.error) {
                  reject(data.error);
                  return;
                }
                resolve(data.result === undefined ? null : data.result);
              })
              .catch(() => {
                reject({ code: -32010, message: "Invalid server response" });
              });
          } else {
            reject({ code: -32010, message: "Server error" });
          }
        })
        .catch(() => {
          reject({ code: -32010, message: "Server unavailable" });
        });
    });
  }
}

export const engine = new Engine();

export const EngineErrorMessage = ({
  error,
  className
}: {
  error?: EngineError;
  className?: string;
}) => {
  return (
    <div className={`eva-error ${className || ""}`}>
      {error
        ? "Error" +
          (error.message ? ": " + error.message : "") +
          ` (${error.code})`
        : ""}
    </div>
  );
};