foomo/gotsrpc
1
0
Fork 0
mirror of https://github.com/foomo/gotsrpc.git synced 2025-10-16 12:35:35 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/foomo/gotsrpc

Browse Source 
* 'master' of https://github.com/foomo/gotsrpc:
  merged slice-args and added test for arg loading
  implemented ServiceList to get determistically sorted code
  reverted code sorting attempts
  yet another codegen reference point
  sorting next iteration
  added target test
  reomved old tests
  alphabeitc order ensured
  code gen demo update
  docs aond demo update
  codegen update
  inline testyaml fixed
  skipping private constants
  removed r and w from php client generator
  next arg handling iteration, by passing in pointers
  back to number casting
  handling of string params
  finetuning slice argument unmarshalling

# Conflicts:
#	Makefile
This commit is contained in:
Stefan Martinov 2017-07-07 14:08:08 +02:00
commit 83962012ea
21 changed files with 327 additions and 449 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
Makefile
View File

@ -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
test: demo
go test $(glide nv)

74
README.md
View File

@ -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
...
```

9
build.go
View File

@ -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 {

4
cmd/demo/demo.go
View File

@ -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))
}

22
demo/config-commonjs.yml Normal file
View File

@ -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
...

4
demo/config.yml
View File

@ -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
...

2
demo/demo.go
View File

@ -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"}
}

104
demo/gorpc.go
View File

@ -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())
}

96
demo/gorpcclient.go
View File

@ -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
}

23
demo/gotsrpc.go
View File

@ -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()

4
demo/gotsrpcclient.go
View File

@ -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
}

46
go.go
View File

@ -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 {

14
gotsrpc.go
View File

@ -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))

25
gotsrpc_test.go Normal file
View File

@ -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")
}
}

3
model.go
View File

@ -50,10 +50,13 @@ type Field struct {
type Service struct {
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 }

15
php.go
View File

@ -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

32
servicereader.go
View File

@ -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{
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

122
test.js
View File

@ -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 = {}));

143
test.ts
View File

@ -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}

14
typescript.go
View File

@ -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
}