server.go.tmpl

{{define "server"}}

{{- $services := .Services -}}
{{- $typeMap := .TypeMap -}}

{{- if $services}}
//
// Server
//

export class WebRPCError extends Error {
    statusCode?: number

    constructor(msg: string = "error", statusCode?: number) {
        super("webrpc error: " + msg);

        Object.setPrototypeOf(this, WebRPCError.prototype);

        this.statusCode = statusCode;
    }
}

import express from 'express'

    {{- range $_, $service := $services }}

        export type {{$service.Name}}Service = {
            {{range $_, $method := $service.Methods}}
                {{$method.Name}}: (args: {{$method.Name}}Args) => {{$method.Name}}Return | Promise<{{$method.Name}}Return>
            {{end}}
        }

        export const create{{$service.Name}}App = (serviceImplementation: {{$service.Name}}Service) => {
            const app = express();

            app.use(express.json())

            app.post('/*', async (req, res) => {
                const requestPath = req.baseUrl + req.path

                res.header(WebrpcHeader, WebrpcHeaderValue);

                if (!req.body) {
                    res.status(400).send("webrpc error: missing body");

                    return
                }

                switch(requestPath) {
                    {{range $_, $method := $service.Methods}}

                    case "/rpc/{{$service.Name}}/{{$method.Name}}": {                        
                        try {
                            {{ range $_, $input := $method.Inputs }}
                                {{- if not $input.Optional}}
                                    if (!("{{ $input.Name }}" in req.body)) {
                                        throw new WebRPCError("Missing Argument `{{ $input.Name }}`")
                                    }
                                {{end -}}

                                if ("{{ $input.Name }}" in req.body && !validateType(req.body["{{ $input.Name }}"], "{{template "jsType" dict "Type" $input.Type "TypeMap" $typeMap}}")) {
                                    throw new WebRPCError("Invalid Argument: {{ $input.Name }}")
                                }
                            {{end}}

                            const response = await serviceImplementation["{{$method.Name}}"](req.body);

                            {{ range $_, $output := $method.Outputs}}
                                if (!("{{ $output.Name }}" in response)) {
                                    throw new WebRPCError("internal", 500);
                                }
                            {{end}}

                            res.status(200).json(response);
                        } catch (err) {
                            if (err instanceof WebRPCError) {
                                const statusCode = err.statusCode || 400
                                const message = err.message

                                res.status(statusCode).json({
                                    msg: message,
                                    status: statusCode,
                                    code: ""
                                });

                                return
                            }

                            if (err.message) {
                                res.status(400).send(err.message);

                                return;
                            }

                            res.status(400).end();
                        }
                    }

                    return;
                    {{end}}

                    default: {
                        res.status(404).end()
                    }
                }
            });

            return app;
        };
    {{- end}}
{{end -}}
{{end}}