diff --git a/Makefile b/Makefile index 503f412..cb4d45f 100644 --- a/Makefile +++ b/Makefile @@ -10,9 +10,11 @@ install: build: goreleaser goreleaser - goreleaser: @go get github.com/goreleaser/goreleaser && go install github.com/goreleaser/goreleaser glide: - @go get github.com/Masterminds/glide && glide install \ No newline at end of file + @go get github.com/Masterminds/glide && glide install + +test: demo + go test $(glide nv) diff --git a/README.md b/README.md index 65cdbc6..f0cceba 100644 --- a/README.md +++ b/README.md @@ -1,23 +1,69 @@ -# Go TypeScript RPC - -Where to define this ?! +# Go / TypeScript and Go / Go RPC ```bash -gotsrpc -ts-target path/to/local/whatever.ts -ts-module My.Module.Foo my/package/path ServiceStructA [ServiceStructB ...] -gotsrpc build gotsrpc.yml +gotsrpc gotsrpc.yml ``` +Will generate client and server side go and TypeScript code. Have fun! + +## config expamples + +### commonjs + +[demo/config.yml](demo/config-commonjs.yml) + ```yaml --- -# gotsrpc.yml +modulekind: commonjs targets: - - - package: my/package/path - expose: - - ServiceStructA - - ServiceStructB - ts: - module: My.Module.Foo - target: path/to/local/whatever.ts - + demo: + services: + /service/foo: Foo + /service/demo: Demo + package: github.com/foomo/gotsrpc/demo + out: /tmp/test.ts + gorpc: + - Foo + - Demo + tsrpc: + - Foo + - Demo + +mappings: + github.com/foomo/gotsrpc/demo: + out: /tmp/test-files-demo.ts + github.com/foomo/gotsrpc/demo/nested: + out: /tmp/test-files-demo-nested.ts +... +``` + +### oldschool TypeScript + +[demo/config.yml](demo/config.yml) + +```yaml +--- +targets: + demo: + module: GoTSRPC.Demo + services: + /service/foo: Foo + /service/demo: Demo + package: github.com/foomo/gotsrpc/demo + out: /tmp/test.ts + gorpc: + - Foo + - Demo + tsrpc: + - Foo + - Demo + +mappings: + github.com/foomo/gotsrpc/demo: + module: GoTSRPC.Demo + out: /tmp/test-files-demo.ts + github.com/foomo/gotsrpc/demo/nested: + module: GoTSRPC.Demo.Nested + out: /tmp/test-files-demo-nested.ts +... ``` \ No newline at end of file diff --git a/build.go b/build.go index e8de492..25f0a72 100644 --- a/build.go +++ b/build.go @@ -53,6 +53,14 @@ func Build(conf *config.Config, goPath string) { } mappedTypeScript := map[string]map[string]*code{} + + // preserve alphabetic order + names := []string{} + for name := range conf.Targets { + names = append(names, name) + } + sort.Strings(names) + for name, target := range conf.Targets { fmt.Fprintln(os.Stderr, "building target", name) @@ -179,6 +187,7 @@ func Build(conf *config.Config, goPath string) { } // spew.Dump(mappedTypeScript) + for goPackage, mappedStructsMap := range mappedTypeScript { mapping, ok := conf.Mappings[goPackage] if !ok { diff --git a/cmd/demo/demo.go b/cmd/demo/demo.go index e7bb9ac..c21f691 100644 --- a/cmd/demo/demo.go +++ b/cmd/demo/demo.go @@ -10,7 +10,7 @@ import ( ) type Demo struct { - proxy *demo.ServiceGoTSRPCProxy + proxy *demo.DemoGoTSRPCProxy } func (d *Demo) ServeHTTP(w http.ResponseWriter, r *http.Request) { @@ -39,7 +39,7 @@ func serveFile(name string, w http.ResponseWriter) { func main() { d := &Demo{ - proxy: demo.NewServiceGoTSRPCProxy(&demo.Demo{}, "/service"), + proxy: demo.NewDefaultDemoGoTSRPCProxy(&demo.Demo{}, []string{}), } fmt.Println(http.ListenAndServe(":8080", d)) } diff --git a/config/config_test.go b/config/config_test.go index 7cb1d8d..0c9434e 100644 --- a/config/config_test.go +++ b/config/config_test.go @@ -9,7 +9,7 @@ targets: /service/demo: Service package: github.com/foomo/gotsrpc/demo module: My.Service - modulekind: commonjs + modulekind: commonjs out: /tmp/my-service.ts mappings: foo/bar: diff --git a/demo/config-commonjs.yml b/demo/config-commonjs.yml new file mode 100644 index 0000000..1780ad7 --- /dev/null +++ b/demo/config-commonjs.yml @@ -0,0 +1,22 @@ +--- +modulekind: commonjs +targets: + demo: + services: + /service/foo: Foo + /service/demo: Demo + package: github.com/foomo/gotsrpc/demo + out: /tmp/test.ts + gorpc: + - Foo + - Demo + tsrpc: + - Foo + - Demo + +mappings: + github.com/foomo/gotsrpc/demo: + out: /tmp/test-files-demo.ts + github.com/foomo/gotsrpc/demo/nested: + out: /tmp/test-files-demo-nested.ts +... \ No newline at end of file diff --git a/demo/config.yml b/demo/config.yml index 8bacaf5..1b4824d 100644 --- a/demo/config.yml +++ b/demo/config.yml @@ -10,6 +10,9 @@ targets: gorpc: - Foo - Demo + tsrpc: + - Foo + - Demo mappings: github.com/foomo/gotsrpc/demo: @@ -18,3 +21,4 @@ mappings: github.com/foomo/gotsrpc/demo/nested: module: GoTSRPC.Demo.Nested out: /tmp/test-files-demo-nested.ts +... \ No newline at end of file diff --git a/demo/demo.go b/demo/demo.go index 16714f0..ee417ff 100644 --- a/demo/demo.go +++ b/demo/demo.go @@ -10,7 +10,7 @@ type Demo struct { Bla bool } -func (d *Demo) Hello(name string) (reply string, err *Err) { +func (d *Demo) Hello(name string) (string, *Err) { if name == "Peter" { return "", &Err{"fuck you Peter I do not like you"} } diff --git a/demo/gorpc.go b/demo/gorpc.go index 1e8d6f6..cc4dba7 100644 --- a/demo/gorpc.go +++ b/demo/gorpc.go @@ -20,17 +20,17 @@ type ( callStatsHandler gotsrpc.GoRPCCallStatsHandlerFun } - HelloRequest struct { + FooHelloRequest struct { Number int64 } - HelloResponse struct { + FooHelloResponse struct { RetHello_0 int } ) func init() { - gob.Register(HelloRequest{}) - gob.Register(HelloResponse{}) + gob.Register(FooHelloRequest{}) + gob.Register(FooHelloResponse{}) } func NewFooGoRPCProxy(addr string, service *Foo, tlsConfig *tls.Config) *FooGoRPCProxy { @@ -51,6 +51,10 @@ func (p *FooGoRPCProxy) Start() error { return p.server.Start() } +func (p *FooGoRPCProxy) Serve() error { + return p.server.Serve() +} + func (p *FooGoRPCProxy) Stop() { p.server.Stop() } @@ -67,10 +71,10 @@ func (p *FooGoRPCProxy) handler(clientAddr string, request interface{}) (respons funcName := funcNameParts[len(funcNameParts)-1] switch funcName { - case "HelloRequest": - req := request.(HelloRequest) + case "FooHelloRequest": + req := request.(FooHelloRequest) retHello_0 := p.service.Hello(req.Number) - response = HelloResponse{RetHello_0: retHello_0} + response = FooHelloResponse{RetHello_0: retHello_0} default: fmt.Println("Unkown request type", reflect.TypeOf(request).String()) } @@ -94,62 +98,62 @@ type ( callStatsHandler gotsrpc.GoRPCCallStatsHandlerFun } - ExtractAddressRequest struct { + DemoExtractAddressRequest struct { Person *Person } - ExtractAddressResponse struct { + DemoExtractAddressResponse struct { Addr *Address E *Err } - GiveMeAScalarRequest struct { + DemoGiveMeAScalarRequest struct { } - GiveMeAScalarResponse struct { + DemoGiveMeAScalarResponse struct { Amount nested.Amount Wahr nested.True Hier ScalarInPlace } - HelloRequest struct { + DemoHelloRequest struct { Name string } - HelloResponse struct { - Reply string - Err *Err + DemoHelloResponse struct { + RetHello_0 string + RetHello_1 *Err } - MapCrapRequest struct { + DemoMapCrapRequest struct { } - MapCrapResponse struct { + DemoMapCrapResponse struct { Crap map[string][]int } - NestRequest struct { + DemoNestRequest struct { } - NestResponse struct { + DemoNestResponse struct { RetNest_0 *nested.Nested } - TestScalarInPlaceRequest struct { + DemoTestScalarInPlaceRequest struct { } - TestScalarInPlaceResponse struct { + DemoTestScalarInPlaceResponse struct { RetTestScalarInPlace_0 ScalarInPlace } ) func init() { - gob.Register(ExtractAddressRequest{}) - gob.Register(ExtractAddressResponse{}) - gob.Register(GiveMeAScalarRequest{}) - gob.Register(GiveMeAScalarResponse{}) - gob.Register(HelloRequest{}) - gob.Register(HelloResponse{}) - gob.Register(MapCrapRequest{}) - gob.Register(MapCrapResponse{}) - gob.Register(NestRequest{}) - gob.Register(NestResponse{}) - gob.Register(TestScalarInPlaceRequest{}) - gob.Register(TestScalarInPlaceResponse{}) + gob.Register(DemoExtractAddressRequest{}) + gob.Register(DemoExtractAddressResponse{}) + gob.Register(DemoGiveMeAScalarRequest{}) + gob.Register(DemoGiveMeAScalarResponse{}) + gob.Register(DemoHelloRequest{}) + gob.Register(DemoHelloResponse{}) + gob.Register(DemoMapCrapRequest{}) + gob.Register(DemoMapCrapResponse{}) + gob.Register(DemoNestRequest{}) + gob.Register(DemoNestResponse{}) + gob.Register(DemoTestScalarInPlaceRequest{}) + gob.Register(DemoTestScalarInPlaceResponse{}) } func NewDemoGoRPCProxy(addr string, service *Demo, tlsConfig *tls.Config) *DemoGoRPCProxy { @@ -170,6 +174,10 @@ func (p *DemoGoRPCProxy) Start() error { return p.server.Start() } +func (p *DemoGoRPCProxy) Serve() error { + return p.server.Serve() +} + func (p *DemoGoRPCProxy) Stop() { p.server.Stop() } @@ -186,26 +194,26 @@ func (p *DemoGoRPCProxy) handler(clientAddr string, request interface{}) (respon funcName := funcNameParts[len(funcNameParts)-1] switch funcName { - case "ExtractAddressRequest": - req := request.(ExtractAddressRequest) + case "DemoExtractAddressRequest": + req := request.(DemoExtractAddressRequest) addr, e := p.service.ExtractAddress(req.Person) - response = ExtractAddressResponse{Addr: addr, E: e} - case "GiveMeAScalarRequest": + response = DemoExtractAddressResponse{Addr: addr, E: e} + case "DemoGiveMeAScalarRequest": amount, wahr, hier := p.service.GiveMeAScalar() - response = GiveMeAScalarResponse{Amount: amount, Wahr: wahr, Hier: hier} - case "HelloRequest": - req := request.(HelloRequest) - reply, err := p.service.Hello(req.Name) - response = HelloResponse{Reply: reply, Err: err} - case "MapCrapRequest": + response = DemoGiveMeAScalarResponse{Amount: amount, Wahr: wahr, Hier: hier} + case "DemoHelloRequest": + req := request.(DemoHelloRequest) + retHello_0, retHello_1 := p.service.Hello(req.Name) + response = DemoHelloResponse{RetHello_0: retHello_0, RetHello_1: retHello_1} + case "DemoMapCrapRequest": crap := p.service.MapCrap() - response = MapCrapResponse{Crap: crap} - case "NestRequest": + response = DemoMapCrapResponse{Crap: crap} + case "DemoNestRequest": retNest_0 := p.service.Nest() - response = NestResponse{RetNest_0: retNest_0} - case "TestScalarInPlaceRequest": + response = DemoNestResponse{RetNest_0: retNest_0} + case "DemoTestScalarInPlaceRequest": retTestScalarInPlace_0 := p.service.TestScalarInPlace() - response = TestScalarInPlaceResponse{RetTestScalarInPlace_0: retTestScalarInPlace_0} + response = DemoTestScalarInPlaceResponse{RetTestScalarInPlace_0: retTestScalarInPlace_0} default: fmt.Println("Unkown request type", reflect.TypeOf(request).String()) } diff --git a/demo/gorpcclient.go b/demo/gorpcclient.go index 09118a6..ae13b25 100644 --- a/demo/gorpcclient.go +++ b/demo/gorpcclient.go @@ -8,124 +8,122 @@ import ( ) type FooGoRPCClient struct { - client *gorpc.Client + Client *gorpc.Client } func NewFooGoRPCClient(addr string, tlsConfig *tls.Config) *FooGoRPCClient { client := &FooGoRPCClient{} if tlsConfig == nil { - client.client = gorpc.NewTCPClient(addr) + client.Client = gorpc.NewTCPClient(addr) } else { - client.client = gorpc.NewTLSClient(addr, tlsConfig) + client.Client = gorpc.NewTLSClient(addr, tlsConfig) } - client.Start() return client } func (c *FooGoRPCClient) Start() { - c.client.Start() + c.Client.Start() } func (c *FooGoRPCClient) Stop() { - c.client.Stop() + c.Client.Stop() } func (c *FooGoRPCClient) Hello(number int64) (retHello_0 int, clientErr error) { - req := HelloRequest{Number: number} - res, err := c.client.Call(req) - if err != nil { - clientErr = err + req := FooHelloRequest{Number: number} + rpcCallRes, rpcCallErr := c.Client.Call(req) + if rpcCallErr != nil { + clientErr = rpcCallErr return } - response := res.(HelloResponse) + response := rpcCallRes.(FooHelloResponse) return response.RetHello_0, nil } type DemoGoRPCClient struct { - client *gorpc.Client + Client *gorpc.Client } func NewDemoGoRPCClient(addr string, tlsConfig *tls.Config) *DemoGoRPCClient { client := &DemoGoRPCClient{} if tlsConfig == nil { - client.client = gorpc.NewTCPClient(addr) + client.Client = gorpc.NewTCPClient(addr) } else { - client.client = gorpc.NewTLSClient(addr, tlsConfig) + client.Client = gorpc.NewTLSClient(addr, tlsConfig) } - client.Start() return client } func (c *DemoGoRPCClient) Start() { - c.client.Start() + c.Client.Start() } func (c *DemoGoRPCClient) Stop() { - c.client.Stop() + c.Client.Stop() } func (c *DemoGoRPCClient) ExtractAddress(person *Person) (addr *Address, e *Err, clientErr error) { - req := ExtractAddressRequest{Person: person} - res, err := c.client.Call(req) - if err != nil { - clientErr = err + req := DemoExtractAddressRequest{Person: person} + rpcCallRes, rpcCallErr := c.Client.Call(req) + if rpcCallErr != nil { + clientErr = rpcCallErr return } - response := res.(ExtractAddressResponse) + response := rpcCallRes.(DemoExtractAddressResponse) return response.Addr, response.E, nil } func (c *DemoGoRPCClient) GiveMeAScalar() (amount nested.Amount, wahr nested.True, hier ScalarInPlace, clientErr error) { - req := GiveMeAScalarRequest{} - res, err := c.client.Call(req) - if err != nil { - clientErr = err + req := DemoGiveMeAScalarRequest{} + rpcCallRes, rpcCallErr := c.Client.Call(req) + if rpcCallErr != nil { + clientErr = rpcCallErr return } - response := res.(GiveMeAScalarResponse) + response := rpcCallRes.(DemoGiveMeAScalarResponse) return response.Amount, response.Wahr, response.Hier, nil } -func (c *DemoGoRPCClient) Hello(name string) (reply string, err *Err, clientErr error) { - req := HelloRequest{Name: name} - res, err := c.client.Call(req) - if err != nil { - clientErr = err +func (c *DemoGoRPCClient) Hello(name string) (retHello_0 string, retHello_1 *Err, clientErr error) { + req := DemoHelloRequest{Name: name} + rpcCallRes, rpcCallErr := c.Client.Call(req) + if rpcCallErr != nil { + clientErr = rpcCallErr return } - response := res.(HelloResponse) - return response.Reply, response.Err, nil + response := rpcCallRes.(DemoHelloResponse) + return response.RetHello_0, response.RetHello_1, nil } func (c *DemoGoRPCClient) MapCrap() (crap map[string][]int, clientErr error) { - req := MapCrapRequest{} - res, err := c.client.Call(req) - if err != nil { - clientErr = err + req := DemoMapCrapRequest{} + rpcCallRes, rpcCallErr := c.Client.Call(req) + if rpcCallErr != nil { + clientErr = rpcCallErr return } - response := res.(MapCrapResponse) + response := rpcCallRes.(DemoMapCrapResponse) return response.Crap, nil } func (c *DemoGoRPCClient) Nest() (retNest_0 *nested.Nested, clientErr error) { - req := NestRequest{} - res, err := c.client.Call(req) - if err != nil { - clientErr = err + req := DemoNestRequest{} + rpcCallRes, rpcCallErr := c.Client.Call(req) + if rpcCallErr != nil { + clientErr = rpcCallErr return } - response := res.(NestResponse) + response := rpcCallRes.(DemoNestResponse) return response.RetNest_0, nil } func (c *DemoGoRPCClient) TestScalarInPlace() (retTestScalarInPlace_0 ScalarInPlace, clientErr error) { - req := TestScalarInPlaceRequest{} - res, err := c.client.Call(req) - if err != nil { - clientErr = err + req := DemoTestScalarInPlaceRequest{} + rpcCallRes, rpcCallErr := c.Client.Call(req) + if rpcCallErr != nil { + clientErr = rpcCallErr return } - response := res.(TestScalarInPlaceResponse) + response := rpcCallRes.(DemoTestScalarInPlaceResponse) return response.RetTestScalarInPlace_0, nil } diff --git a/demo/gotsrpc.go b/demo/gotsrpc.go index 803fc89..218460f 100644 --- a/demo/gotsrpc.go +++ b/demo/gotsrpc.go @@ -55,14 +55,15 @@ func (p *FooGoTSRPCProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { } switch funcName { case "Hello": - args = []interface{}{int64(0)} - err := gotsrpc.LoadArgs(args, callStats, r) + arg_number := int64(0) + args = []interface{}{&arg_number} + err := gotsrpc.LoadArgs(&args, callStats, r) if err != nil { gotsrpc.ErrorCouldNotLoadArgs(w) return } executionStart := time.Now() - helloRet := p.service.Hello(int64(args[0].(float64))) + helloRet := p.service.Hello(arg_number) if callStats != nil { callStats.Execution = time.Now().Sub(executionStart) } @@ -121,14 +122,15 @@ func (p *DemoGoTSRPCProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { } switch funcName { case "ExtractAddress": - args = []interface{}{&Person{}} - err := gotsrpc.LoadArgs(args, callStats, r) + arg_person := &Person{} + args = []interface{}{&arg_person} + err := gotsrpc.LoadArgs(&args, callStats, r) if err != nil { gotsrpc.ErrorCouldNotLoadArgs(w) return } executionStart := time.Now() - extractAddressAddr, extractAddressE := p.service.ExtractAddress(args[0].(*Person)) + extractAddressAddr, extractAddressE := p.service.ExtractAddress(arg_person) if callStats != nil { callStats.Execution = time.Now().Sub(executionStart) } @@ -143,18 +145,19 @@ func (p *DemoGoTSRPCProxy) ServeHTTP(w http.ResponseWriter, r *http.Request) { gotsrpc.Reply([]interface{}{giveMeAScalarAmount, giveMeAScalarWahr, giveMeAScalarHier}, callStats, r, w) return case "Hello": - args = []interface{}{""} - err := gotsrpc.LoadArgs(args, callStats, r) + arg_name := "" + args = []interface{}{&arg_name} + err := gotsrpc.LoadArgs(&args, callStats, r) if err != nil { gotsrpc.ErrorCouldNotLoadArgs(w) return } executionStart := time.Now() - helloReply, helloErr := p.service.Hello(args[0].(string)) + helloRet, helloRet_1 := p.service.Hello(arg_name) if callStats != nil { callStats.Execution = time.Now().Sub(executionStart) } - gotsrpc.Reply([]interface{}{helloReply, helloErr}, callStats, r, w) + gotsrpc.Reply([]interface{}{helloRet, helloRet_1}, callStats, r, w) return case "MapCrap": executionStart := time.Now() diff --git a/demo/gotsrpcclient.go b/demo/gotsrpcclient.go index e4afe3a..18087a2 100644 --- a/demo/gotsrpcclient.go +++ b/demo/gotsrpcclient.go @@ -59,9 +59,9 @@ func (c *DemoGoTSRPCClient) GiveMeAScalar() (amount nested.Amount, wahr nested.T return } -func (c *DemoGoTSRPCClient) Hello(name string) (reply string, err *Err, clientErr error) { +func (c *DemoGoTSRPCClient) Hello(name string) (retHello_0 string, retHello_1 *Err, clientErr error) { args := []interface{}{name} - reply := []interface{}{&reply, &err} + reply := []interface{}{&retHello_0, &retHello_1} clientErr = gotsrpc.CallClient(c.URL, c.EndPoint, "Hello", args, reply) return } diff --git a/go.go b/go.go index a642a87..14f3fac 100644 --- a/go.go +++ b/go.go @@ -163,7 +163,7 @@ func extractImports(fields []*Field, fullPackageName string, aliases map[string] } } -func renderTSRPCServiceProxies(services map[string]*Service, fullPackageName string, packageName string, config *config.Target, g *code) error { +func renderTSRPCServiceProxies(services ServiceList, fullPackageName string, packageName string, config *config.Target, g *code) error { aliases := map[string]string{ "time": "time", "net/http": "http", @@ -171,7 +171,7 @@ func renderTSRPCServiceProxies(services map[string]*Service, fullPackageName str } for _, service := range services { - // Check if we should render this service as ts rcp + // Check if we should render this service as ts rpc // Note: remove once there's a separate gorcp generator if !config.IsTSRPC(service.Name) { continue @@ -193,7 +193,7 @@ func renderTSRPCServiceProxies(services map[string]*Service, fullPackageName str ` + imports + ` ) `) - for endpoint, service := range services { + for _, service := range services { // Check if we should render this service as ts rcp // Note: remove once there's a separate gorcp generator if !config.IsTSRPC(service.Name) { @@ -210,7 +210,7 @@ func renderTSRPCServiceProxies(services map[string]*Service, fullPackageName str func NewDefault` + proxyName + `(service *` + service.Name + `, allowOrigin []string) *` + proxyName + ` { return &` + proxyName + `{ - EndPoint: "` + endpoint + `", + EndPoint: "` + service.Endpoint + `", allowOrigin : allowOrigin, service: service, } @@ -274,11 +274,14 @@ func renderTSRPCServiceProxies(services map[string]*Service, fullPackageName str if len(method.Args) > 0 { args := []string{} + argsDecls := []string{} skipArgI := 0 for argI, arg := range method.Args { + argName := "arg_" + arg.Name //strconv.Itoa(argI) + if argI == 0 && arg.Value.isHTTPResponseWriter() { continue } @@ -287,19 +290,16 @@ func renderTSRPCServiceProxies(services map[string]*Service, fullPackageName str continue } - args = append(args, arg.Value.emptyLiteral(aliases)) - switch arg.Value.GoScalarType { - case "int", "int8", "int16", "int32", "int64", - "uint", "uint8", "uint16", "uint32", "uint64": - callArgs = append(callArgs, fmt.Sprint(arg.Value.GoScalarType+"(args[", skipArgI, "].(float64))")) - default: - // assert - callArgs = append(callArgs, fmt.Sprint("args[", skipArgI, "].("+arg.Value.goType(aliases, fullPackageName)+")")) - } + argsDecls = append(argsDecls, argName+" := "+arg.Value.emptyLiteral(aliases)) + args = append(args, "&"+argName) + callArgs = append(callArgs, argName) skipArgI++ } + for _, argDecl := range argsDecls { + g.l(argDecl) + } g.l("args = []interface{}{" + strings.Join(args, ", ") + "}") - g.l("err := gotsrpc.LoadArgs(args, callStats, r)") + g.l("err := gotsrpc.LoadArgs(&args, callStats, r)") g.l("if err != nil {") g.ind(1) g.l("gotsrpc.ErrorCouldNotLoadArgs(w)") @@ -344,7 +344,7 @@ func renderTSRPCServiceProxies(services map[string]*Service, fullPackageName str return nil } -func renderTSRPCServiceClients(services map[string]*Service, fullPackageName string, packageName string, config *config.Target, g *code) error { +func renderTSRPCServiceClients(services ServiceList, fullPackageName string, packageName string, config *config.Target, g *code) error { aliases := map[string]string{ "github.com/foomo/gotsrpc": "gotsrpc", } @@ -373,7 +373,7 @@ func renderTSRPCServiceClients(services map[string]*Service, fullPackageName str ` + imports + ` ) `) - for endpoint, service := range services { + for _, service := range services { // Check if we should render this service as ts rcp // Note: remove once there's a separate gorcp generator if !config.IsTSRPC(service.Name) { @@ -388,7 +388,7 @@ func renderTSRPCServiceClients(services map[string]*Service, fullPackageName str } func NewDefault` + clientName + `(url string) *` + clientName + ` { - return New` + clientName + `(url, "` + endpoint + `") + return New` + clientName + `(url, "` + service.Endpoint + `") } func New` + clientName + `(url string, endpoint string) *` + clientName + ` { @@ -428,7 +428,7 @@ func renderTSRPCServiceClients(services map[string]*Service, fullPackageName str return nil } -func renderGoRPCServiceProxies(services map[string]*Service, fullPackageName string, packageName string, config *config.Target, g *code) error { +func renderGoRPCServiceProxies(services ServiceList, fullPackageName string, packageName string, config *config.Target, g *code) error { aliases := map[string]string{ "fmt": "fmt", "time": "time", @@ -596,7 +596,7 @@ func renderGoRPCServiceProxies(services map[string]*Service, fullPackageName str return nil } -func renderGoRPCServiceClients(services map[string]*Service, fullPackageName string, packageName string, config *config.Target, g *code) error { +func renderGoRPCServiceClients(services ServiceList, fullPackageName string, packageName string, config *config.Target, g *code) error { aliases := map[string]string{ "crypto/tls": "tls", "github.com/valyala/gorpc": "gorpc", @@ -699,7 +699,7 @@ func renderGoRPCServiceClients(services map[string]*Service, fullPackageName str return nil } -func RenderGoTSRPCProxies(services map[string]*Service, longPackageName, packageName string, config *config.Target) (gocode string, err error) { +func RenderGoTSRPCProxies(services ServiceList, longPackageName, packageName string, config *config.Target) (gocode string, err error) { g := newCode(" ") err = renderTSRPCServiceProxies(services, longPackageName, packageName, config, g) if err != nil { @@ -709,7 +709,7 @@ func RenderGoTSRPCProxies(services map[string]*Service, longPackageName, package return } -func RenderGoTSRPCClients(services map[string]*Service, longPackageName, packageName string, config *config.Target) (gocode string, err error) { +func RenderGoTSRPCClients(services ServiceList, longPackageName, packageName string, config *config.Target) (gocode string, err error) { g := newCode(" ") err = renderTSRPCServiceClients(services, longPackageName, packageName, config, g) if err != nil { @@ -719,7 +719,7 @@ func RenderGoTSRPCClients(services map[string]*Service, longPackageName, package return } -func RenderGoRPCProxies(services map[string]*Service, longPackageName, packageName string, config *config.Target) (gocode string, err error) { +func RenderGoRPCProxies(services ServiceList, longPackageName, packageName string, config *config.Target) (gocode string, err error) { g := newCode(" ") err = renderGoRPCServiceProxies(services, longPackageName, packageName, config, g) if err != nil { @@ -729,7 +729,7 @@ func RenderGoRPCProxies(services map[string]*Service, longPackageName, packageNa return } -func RenderGoRPCClients(services map[string]*Service, longPackageName, packageName string, config *config.Target) (gocode string, err error) { +func RenderGoRPCClients(services ServiceList, longPackageName, packageName string, config *config.Target) (gocode string, err error) { g := newCode(" ") err = renderGoRPCServiceClients(services, longPackageName, packageName, config, g) if err != nil { diff --git a/gotsrpc.go b/gotsrpc.go index 277fb20..bab5567 100644 --- a/gotsrpc.go +++ b/gotsrpc.go @@ -36,15 +36,16 @@ func ErrorMethodNotAllowed(w http.ResponseWriter) { w.Write([]byte("you gotta POST")) } -func LoadArgs(args []interface{}, callStats *CallStats, r *http.Request) error { +func LoadArgs(args interface{}, callStats *CallStats, r *http.Request) error { start := time.Now() body, err := ioutil.ReadAll(r.Body) if err != nil { return err } - if err := json.Unmarshal(body, &args); err != nil { - return err + errLoad := loadArgs(&args, body) + if errLoad != nil { + return errLoad } if callStats != nil { callStats.Unmarshalling = time.Now().Sub(start) @@ -53,6 +54,13 @@ func LoadArgs(args []interface{}, callStats *CallStats, r *http.Request) error { return nil } +func loadArgs(args interface{}, jsonBytes []byte) error { + if err := json.Unmarshal(jsonBytes, &args); err != nil { + return err + } + return nil +} + func RequestWithStatsContext(r *http.Request) *http.Request { stats := &CallStats{} return r.WithContext(context.WithValue(r.Context(), contextStatsKey, stats)) @@ -100,7 +108,7 @@ func parseDir(goPaths []string, packageName string) (map[string]*ast.Package, er fset := token.NewFileSet() var dir string if strings.HasSuffix(goPath, "vendor") { - dir = path.Join(goPath,packageName) + dir = path.Join(goPath, packageName) } else { dir = path.Join(goPath, "src", packageName) } diff --git a/gotsrpc_test.go b/gotsrpc_test.go new file mode 100644 index 0000000..9de187c --- /dev/null +++ b/gotsrpc_test.go @@ -0,0 +1,25 @@ +package gotsrpc + +import ( + "testing" +) + +func TestLoadArgs(t *testing.T) { + jsonBytes := []byte(`["a", ["a", "b", "c"]]`) + foo := "" + bar := []string{} + args := []interface{}{&foo, &bar} + errLoad := loadArgs(&args, jsonBytes) + if errLoad != nil { + t.Fatal(errLoad) + } + if foo != "a" { + t.Fatal("foo should have been a") + } + if len(bar) != 3 { + t.Fatal("bar len wrong", len(bar), "!=", len(bar)) + } + if bar[1] != "b" { + t.Fatal("bar[1] (", bar[1], ") != b") + } +} diff --git a/model.go b/model.go index 8a761ac..7085e18 100644 --- a/model.go +++ b/model.go @@ -48,12 +48,15 @@ type Field struct { } type Service struct { - Name string - Methods ServiceMethods + Name string + Methods ServiceMethods + Endpoint string } type ServiceMethods []*Method +type ServiceList []*Service + func (sm ServiceMethods) Len() int { return len(sm) } func (sm ServiceMethods) Swap(i, j int) { sm[i], sm[j] = sm[j], sm[i] } func (sm ServiceMethods) Less(i, j int) bool { return sm[i].Name < sm[j].Name } diff --git a/php.go b/php.go index 3fa0efa..5a227ac 100644 --- a/php.go +++ b/php.go @@ -1,8 +1,9 @@ package gotsrpc import ( - "github.com/foomo/gotsrpc/config" "strings" + + "github.com/foomo/gotsrpc/config" ) func renderPHPRPCServiceClients(service *Service, namespce string, g *code) error { @@ -39,12 +40,16 @@ func renderPHPRPCServiceClients(service *Service, namespce string, g *code) erro // Service methods for _, method := range service.Methods { - args := []string{} params := []string{} g.l(`/**`) - for _, a := range method.Args { - args = append(args, "$"+a.Name) + for i, a := range method.Args { + if i == 0 && a.Value.isHTTPResponseWriter() { + continue + } + if i == 1 && a.Value.isHTTPRequest() { + continue + } params = append(params, "$"+a.Name) g.l(` * @param $` + a.Name) } @@ -88,7 +93,7 @@ func renderPHPRPCServiceClients(service *Service, namespce string, g *code) erro return nil } -func RenderPHPRPCClients(services map[string]*Service, config *config.Target) (code map[string]string, err error) { +func RenderPHPRPCClients(services ServiceList, config *config.Target) (code map[string]string, err error) { code = map[string]string{} for _, service := range services { // Check if we should render this service as ts rcp diff --git a/servicereader.go b/servicereader.go index 06414b1..bbb3967 100644 --- a/servicereader.go +++ b/servicereader.go @@ -10,7 +10,11 @@ import ( "strings" ) -func readServiceFile(file *ast.File, packageName string, services map[string]*Service) error { +func (sl ServiceList) Len() int { return len(sl) } +func (sl ServiceList) Swap(i, j int) { sl[i], sl[j] = sl[j], sl[i] } +func (sl ServiceList) Less(i, j int) bool { return strings.Compare(sl[i].Name, sl[j].Name) > 0 } + +func readServiceFile(file *ast.File, packageName string, services ServiceList) error { findService := func(serviceName string) (service *Service, ok bool) { for _, service := range services { if service.Name == serviceName { @@ -132,13 +136,14 @@ func readFields(fieldList *ast.FieldList, fileImports fileImportSpecMap) (fields } -func readServicesInPackage(pkg *ast.Package, packageName string, serviceMap map[string]string) (services map[string]*Service, err error) { - services = map[string]*Service{} +func readServicesInPackage(pkg *ast.Package, packageName string, serviceMap map[string]string) (services ServiceList, err error) { + services = ServiceList{} for endpoint, serviceName := range serviceMap { - services[endpoint] = &Service{ - Name: serviceName, - Methods: []*Method{}, - } + services = append(services, &Service{ + Name: serviceName, + Methods: []*Method{}, + Endpoint: endpoint, + }) } for _, file := range pkg.Files { err = readServiceFile(file, packageName, services) @@ -147,6 +152,7 @@ func readServicesInPackage(pkg *ast.Package, packageName string, serviceMap map[ } } + sort.Sort(services) return } @@ -163,13 +169,17 @@ func loadConstants(pkg *ast.Package) map[string]*ast.BasicLit { spec := spec.(*ast.ValueSpec) for _, val := range spec.Values { if reflect.ValueOf(val).Type().String() == "*ast.BasicLit" { - firstValueLit := val.(*ast.BasicLit) - //fmt.Println("a value spec", spec.Names[0], firstValueLit.Kind, firstValueLit.Value) - constants[spec.Names[0].String()] = firstValueLit //.Value - + constName := spec.Names[0].String() + for indexRune, r := range constName { + if indexRune == 0 { + if string(r) == strings.ToUpper(string(r)) { + constants[constName] = firstValueLit + } + break + } + } } - } } } @@ -181,7 +191,7 @@ func loadConstants(pkg *ast.Package) map[string]*ast.BasicLit { } -func Read(goPaths []string, packageName string, serviceMap map[string]string) (services map[string]*Service, structs map[string]*Struct, scalars map[string]*Scalar, constants map[string]map[string]*ast.BasicLit, err error) { +func Read(goPaths []string, packageName string, serviceMap map[string]string) (services ServiceList, structs map[string]*Struct, scalars map[string]*Scalar, constants map[string]map[string]*ast.BasicLit, err error) { if len(serviceMap) == 0 { err = errors.New("nothing to do service names are empty") return diff --git a/test.js b/test.js deleted file mode 100644 index 6084e68..0000000 --- a/test.js +++ /dev/null @@ -1,122 +0,0 @@ -var GoTSRPC; -(function (GoTSRPC) { - function call(endPoint, method, args, success, err) { - var request = new XMLHttpRequest(); - request.withCredentials = true; - request.open('POST', endPoint + "/" + encodeURIComponent(method), true); - request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8'); - request.send(JSON.stringify(args)); - request.onload = function () { - if (request.status == 200) { - try { - var data = JSON.parse(request.responseText); - success.apply(null, data); - } - catch (e) { - err(request); - } - } - else { - err(request); - } - }; - request.onerror = function () { - err(request); - }; - } - GoTSRPC.call = call; -})(GoTSRPC || (GoTSRPC = {})); -var MZG; -(function (MZG) { - var Services; - (function (Services) { - var Order; - (function (Order) { - var ServiceClient = (function () { - function ServiceClient(endPoint) { - if (endPoint === void 0) { endPoint = "/service"; } - this.endPoint = endPoint; - } - ServiceClient.prototype.validateOrder = function (success, err) { - GoTSRPC.call(this.endPoint, "ValidateOrder", [], success, err); - }; - ServiceClient.prototype.confirmOrder = function (success, err) { - GoTSRPC.call(this.endPoint, "ConfirmOrder", [], success, err); - }; - ServiceClient.prototype.flushPaymentInfo = function (success, err) { - GoTSRPC.call(this.endPoint, "FlushPaymentInfo", [], success, err); - }; - ServiceClient.prototype.setPositionSize = function (oldItemID, newItemID, success, err) { - GoTSRPC.call(this.endPoint, "SetPositionSize", [oldItemID, newItemID], success, err); - }; - ServiceClient.prototype.setPositionCount = function (itemID, count, success, err) { - GoTSRPC.call(this.endPoint, "SetPositionCount", [itemID, count], success, err); - }; - ServiceClient.prototype.getOrder = function (success, err) { - GoTSRPC.call(this.endPoint, "GetOrder", [], success, err); - }; - ServiceClient.prototype.setBillingAddress = function (addressId, success, err) { - GoTSRPC.call(this.endPoint, "SetBillingAddress", [addressId], success, err); - }; - ServiceClient.prototype.setShippingAddress = function (addressId, success, err) { - GoTSRPC.call(this.endPoint, "SetShippingAddress", [addressId], success, err); - }; - ServiceClient.prototype.setBilling = function (billing, success, err) { - GoTSRPC.call(this.endPoint, "SetBilling", [billing], success, err); - }; - ServiceClient.prototype.setShipping = function (shipping, success, err) { - GoTSRPC.call(this.endPoint, "SetShipping", [shipping], success, err); - }; - ServiceClient.prototype.setPayment = function (payment, success, err) { - GoTSRPC.call(this.endPoint, "SetPayment", [payment], success, err); - }; - ServiceClient.prototype.setPage = function (page, success, err) { - GoTSRPC.call(this.endPoint, "SetPage", [page], success, err); - }; - ServiceClient.prototype.getOrderSummary = function (success, err) { - GoTSRPC.call(this.endPoint, "GetOrderSummary", [], success, err); - }; - ServiceClient.defaultInst = new ServiceClient; - return ServiceClient; - }()); - Order.ServiceClient = ServiceClient; - })(Order = Services.Order || (Services.Order = {})); - })(Services = MZG.Services || (MZG.Services = {})); -})(MZG || (MZG = {})); -// ----------------- MZG.Services -------------------- -var MZG; -(function (MZG) { - var Services; - (function (Services) { - var Profile; - (function (Profile) { - var ServiceClient = (function () { - function ServiceClient(endPoint) { - if (endPoint === void 0) { endPoint = "/service"; } - this.endPoint = endPoint; - } - ServiceClient.prototype.validateLogin = function (email, success, err) { - GoTSRPC.call(this.endPoint, "ValidateLogin", [email], success, err); - }; - ServiceClient.prototype.newCustomer = function (email, success, err) { - GoTSRPC.call(this.endPoint, "NewCustomer", [email], success, err); - }; - ServiceClient.prototype.newGuestCustomer = function (email, success, err) { - GoTSRPC.call(this.endPoint, "NewGuestCustomer", [email], success, err); - }; - ServiceClient.prototype.addShippingAddress = function (address, success, err) { - GoTSRPC.call(this.endPoint, "AddShippingAddress", [address], success, err); - }; - ServiceClient.prototype.addBillingAddress = function (address, success, err) { - GoTSRPC.call(this.endPoint, "AddBillingAddress", [address], success, err); - }; - ServiceClient.prototype.setProfileData = function (profileData, success, err) { - GoTSRPC.call(this.endPoint, "SetProfileData", [profileData], success, err); - }; - ServiceClient.defaultInst = new ServiceClient; - return ServiceClient; - }()); - Profile.ServiceClient = ServiceClient; - })(Profile = Services.Profile || (Services.Profile = {})); - })(Services = MZG.Services || (MZG.Services = {})); -})(MZG || (MZG = {})); diff --git a/test.ts b/test.ts deleted file mode 100644 index 851d253..0000000 --- a/test.ts +++ /dev/null @@ -1,143 +0,0 @@ -module GoTSRPC { - export function call(endPoint:string, method:string, args:any[], success:any, err:any) { - var request = new XMLHttpRequest(); - request.withCredentials = true; - request.open('POST', endPoint + "/" + encodeURIComponent(method), true); - request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8'); - request.send(JSON.stringify(args)); - request.onload = function() { - if (request.status == 200) { - try { - var data = JSON.parse(request.responseText); - success.apply(null, data); - } catch(e) { - err(request); - } - } else { - err(request); - } - }; - request.onerror = function() { - err(request); - }; - } -} -module MZG.Services.Order { - export class ServiceClient { - static defaultInst = new ServiceClient; - constructor(public endPoint:string = "/service") { } - validateOrder(success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "ValidateOrder", [], success, err); - } - confirmOrder(success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "ConfirmOrder", [], success, err); - } - flushPaymentInfo(success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "FlushPaymentInfo", [], success, err); - } - setPositionSize(oldItemID:string, newItemID:string, success:(order:MZG.Services.Order.Order, err:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetPositionSize", [oldItemID, newItemID], success, err); - } - setPositionCount(itemID:string, count:number, success:(order:MZG.Services.Order.Order, err:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetPositionCount", [itemID, count], success, err); - } - getOrder(success:(order:MZG.Services.Order.Order, err:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "GetOrder", [], success, err); - } - setBillingAddress(addressId:string, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetBillingAddress", [addressId], success, err); - } - setShippingAddress(addressId:string, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetShippingAddress", [addressId], success, err); - } - setBilling(billing:MZG.Services.Order.Billing, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetBilling", [billing], success, err); - } - setShipping(shipping:MZG.Services.Order.Shipping, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetShipping", [shipping], success, err); - } - setPayment(payment:MZG.Services.Order.Payment, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetPayment", [payment], success, err); - } - setPage(page:string, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetPage", [page], success, err); - } - getOrderSummary(success:(summary:MZG.Services.Order.OrderSummary, err:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "GetOrderSummary", [], success, err); - } - } -} -// ----------------- MZG.Services.Order -------------------- -OrderSummary &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.OrderSummary export interface OrderSummary { numberOfItems:number; subTotal:string; promotionAmount:string; hasPromotions:boolean; vat:string; total:string; totalRappen:string; shippingCosts:string; hasShippingCosts:boolean; amountUntilFreeShipping:string; }] 1} -// ----------------- MZG.Services.Order -------------------- -OrderPosition &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.OrderPosition export interface OrderPosition { id:string; name:string; brand:string; imageURL:string; size:string; style:string; quantity:number; pricePerUnit:any; price:any; availability:any; sizes:any[]; }] 1} -// ----------------- MZG.Services.Order -------------------- -AddressFormValue &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.AddressFormValue export interface AddressFormValue { salutation:string; firstName:string; title:string; lastName:string; company:string; street:string; streetNumber:string; zip:string; city:string; }] 1} -// ----------------- MZG.Services.Order -------------------- -Billing &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.Billing export interface Billing { newAddress?:MZG.Services.Order.AddressFormValue; tacAgree:boolean; email:string; phone:string; birthday:string; }] 1} -// ----------------- MZG.Services.Order -------------------- -PaymentInfo &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.PaymentInfo export interface PaymentInfo { method:string; status:string; feedback:string; complete:boolean; amount:string; }] 1} -// ----------------- MZG.Services.Order -------------------- -Session &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.Session export interface Session { billing?:MZG.Services.Order.Billing; shipping?:MZG.Services.Order.Shipping; payment?:MZG.Services.Order.Payment; page:string; }] 1} -// ----------------- MZG.Services.Order -------------------- -Order &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.Order export interface Order { id:string; positions:MZG.Services.Order.OrderPosition[]; summary?:MZG.Services.Order.OrderSummary; paymentInfo:MZG.Services.Order.PaymentInfo[]; session?:MZG.Services.Order.Session; }] 1} -// ----------------- MZG.Services.Order -------------------- -Shipping &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.Shipping export interface Shipping { useBilling:boolean; newAddress?:MZG.Services.Order.AddressFormValue; }] 1} -// ----------------- MZG.Services.Order -------------------- -Payment &{ [ // git.bestbytes.net/Project-Globus-Services/services/order.Payment export interface Payment { paymentType:string; coupons:string[]; }] 1} -// ----------------- MZG.Services -------------------- -ServiceError &{ [ // git.bestbytes.net/Project-Globus-Services/services.ServiceError export interface ServiceError { error:string; }] 1} -module GoTSRPC { - export function call(endPoint:string, method:string, args:any[], success:any, err:any) { - var request = new XMLHttpRequest(); - request.withCredentials = true; - request.open('POST', endPoint + "/" + encodeURIComponent(method), true); - request.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded; charset=UTF-8'); - request.send(JSON.stringify(args)); - request.onload = function() { - if (request.status == 200) { - try { - var data = JSON.parse(request.responseText); - success.apply(null, data); - } catch(e) { - err(request); - } - } else { - err(request); - } - }; - request.onerror = function() { - err(request); - }; - } -} -module MZG.Services.Profile { - export class ServiceClient { - static defaultInst = new ServiceClient; - constructor(public endPoint:string = "/service") { } - validateLogin(email:string, success:(valid:boolean) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "ValidateLogin", [email], success, err); - } - newCustomer(email:string, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "NewCustomer", [email], success, err); - } - newGuestCustomer(email:string, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "NewGuestCustomer", [email], success, err); - } - addShippingAddress(address:MZG.Services.Profile.AddressFormValue, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "AddShippingAddress", [address], success, err); - } - addBillingAddress(address:MZG.Services.Profile.AddressFormValue, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "AddBillingAddress", [address], success, err); - } - setProfileData(profileData:MZG.Services.Profile.ProfileData, success:(ret:MZG.Services.ServiceError) => void, err:(request:XMLHttpRequest) => void) { - GoTSRPC.call(this.endPoint, "SetProfileData", [profileData], success, err); - } - } -} -// ----------------- MZG.Services -------------------- -ServiceError &{ [ // git.bestbytes.net/Project-Globus-Services/services.ServiceError export interface ServiceError { error:string; }] 1} -// ----------------- MZG.Services.Profile -------------------- -AddressFormValue &{ [ // git.bestbytes.net/Project-Globus-Services/services/profile.AddressFormValue export interface AddressFormValue { salutation:string; firstName:string; title:string; lastName:string; company:string; street:string; streetNumber:string; zip:string; city:string; }] 1} -// ----------------- MZG.Services.Profile -------------------- -ProfileData &{ [ // git.bestbytes.net/Project-Globus-Services/services/profile.ProfileData export interface ProfileData { tacAgree:boolean; PhoneMobile:string; Birthday:string; }] 1} diff --git a/typescript.go b/typescript.go index 804984f..2ee5af3 100644 --- a/typescript.go +++ b/typescript.go @@ -99,22 +99,22 @@ func renderStruct(str *Struct, mappings config.TypeScriptMappings, scalarTypes m return nil } -func renderService(skipGoTSRPC bool, moduleKind config.ModuleKind, service *Service, endpoint string, mappings config.TypeScriptMappings, scalarTypes map[string]*Scalar, ts *code) error { +func renderService(skipGoTSRPC bool, moduleKind config.ModuleKind, service *Service, mappings config.TypeScriptMappings, scalarTypes map[string]*Scalar, ts *code) error { clientName := service.Name + "Client" ts.l("export class " + clientName + " {").ind(1) if moduleKind == config.ModuleKindCommonJS { if skipGoTSRPC { - ts.l("constructor(public endPoint:string = \"" + endpoint + "\", public transport:(endPoint:string, method:string, args:any[], success:any, err:any) => void) { }") + ts.l("constructor(public endPoint:string = \"" + service.Endpoint + "\", public transport:(endPoint:string, method:string, args:any[], success:any, err:any) => void) { }") } else { ts.l("static defaultInst = new " + clientName + ";") - ts.l("constructor(public endPoint:string = \"" + endpoint + "\", public transport = call) { }") + ts.l("constructor(public endPoint:string = \"" + service.Endpoint + "\", public transport = call) { }") } } else { ts.l("static defaultInst = new " + clientName + ";") - ts.l("constructor(public endPoint:string = \"" + endpoint + "\", public transport = GoTSRPC.call) { }") + ts.l("constructor(public endPoint:string = \"" + service.Endpoint + "\", public transport = GoTSRPC.call) { }") } for _, method := range service.Methods { @@ -285,7 +285,7 @@ func ucFirst(str string) string { return constPrefix } -func RenderTypeScriptServices(moduleKind config.ModuleKind, services map[string]*Service, mappings config.TypeScriptMappings, scalarTypes map[string]*Scalar, target *config.Target) (typeScript string, err error) { +func RenderTypeScriptServices(moduleKind config.ModuleKind, services ServiceList, mappings config.TypeScriptMappings, scalarTypes map[string]*Scalar, target *config.Target) (typeScript string, err error) { ts := newCode(" ") if !SkipGoTSRPC { @@ -327,13 +327,13 @@ func RenderTypeScriptServices(moduleKind config.ModuleKind, services map[string] ts.ind(1) } - for endPoint, service := range services { + for _, service := range services { // Check if we should render this service as ts rcp // Note: remove once there's a separate gorcp generator if !target.IsTSRPC(service.Name) { continue } - err = renderService(SkipGoTSRPC, moduleKind, service, endPoint, mappings, scalarTypes, ts) + err = renderService(SkipGoTSRPC, moduleKind, service, mappings, scalarTypes, ts) if err != nil { return }