Merge pull request #42 from moul/feature/flow-getter-setter

Feature/flow getter setter

examples/flow/output/test/test_grpc_js.js

@@ -1,266 +1,272 @@
 // @flow
 // GENERATED CODE -- DO NOT EDIT!
 
-import grpc from 'grpc'
+import base64 from 'base64-js'
-import pbFile from './pbFile.js'
+import test_pb from './test_pb'
 
 
 export type TestEnum = {|
-  
     ELEMENT_A?: 0;
-  
     ELEMENT_B?: 1;
-  
 |};
 
 
-
-
-
 export type TestMessage$TestNestedEnum = {|
-  
     ELEMENT_C?: 0;
-  
     ELEMENT_D?: 1;
-  
 |};
 
 
+export type TestMessage$TestNestedMessage = {
+    getS?: () => string;
+    setS?: (s: string) => void;
+    getT?: () => number;
+    setT?: (t: number) => void;
+};
 
-export type TestMessage$TestNestedMessage = {|
+export type TestMessage = {
+    getA?: () => string;
+    setA?: (a: string) => void;
+    getB?: () => number;
+    setB?: (b: number) => void;
+    getC?: () => number;
+    setC?: (c: number) => void;
+    getD?: () => number;
+    setD?: (d: number) => void;
+    getE?: () => number;
+    setE?: (e: number) => void;
+    getNList?: () => Array<string>;
+    setNList?: (n: Array<string>) => void;
+    addN?: (n: string) => void;
+    clearNList?: () => void;
+    getOList?: () => Array<number>;
+    setOList?: (o: Array<number>) => void;
+    addO?: (o: number) => void;
+    clearOList?: () => void;
+    getPList?: () => Array<number>;
+    setPList?: (p: Array<number>) => void;
+    addP?: (p: number) => void;
+    clearPList?: () => void;
+    getQList?: () => Array<number>;
+    setQList?: (q: Array<number>) => void;
+    addQ?: (q: number) => void;
+    clearQList?: () => void;
+    getRList?: () => Array<number>;
+    setRList?: (r: Array<number>) => void;
+    addR?: (r: number) => void;
+    clearRList?: () => void;
+    getU?: () => TestEnum;
+    setU?: (u: TestEnum) => void;
+    getV?: () => TestMessage$TestNestedEnum;
+    setV?: (v: TestMessage$TestNestedEnum) => void;
+    getWList?: () => Array<TestMessage$TestNestedMessage>;
+    setWList?: (w: Array<TestMessage$TestNestedMessage>) => void;
+    addW?: (w: TestMessage$TestNestedMessage) => void;
+    clearWList?: () => void;
+};
 
-    s?: string;
 
-    t?: number;
 
-|};
 
 
-export type TestMessage = {|
+export type TestNoStreamRequest = {
+    getMessage?: () => TestMessage;
+    setMessage?: (message: TestMessage) => void;
+    clearMessage?: () => void;
+    hasMessage?: () => boolean;
+};
 
-    a?: string;
 
-    b?: number;
 
-    c?: number;
 
-    d?: number;
 
-    e?: number;
+export type TestNoStreamReply = {
+    getMessage?: () => TestMessage;
+    setMessage?: (message: TestMessage) => void;
+    clearMessage?: () => void;
+    hasMessage?: () => boolean;
+    getErrMsg?: () => string;
+    setErrMsg?: (err_msg: string) => void;
+};
 
-    n?: Array<string>;
 
-    o?: Array<number>;
 
-    p?: Array<number>;
 
-    q?: Array<number>;
 
-    r?: Array<number>;
+export type TestStreamRequestRequest = {
+    getMessage?: () => TestMessage;
+    setMessage?: (message: TestMessage) => void;
+    clearMessage?: () => void;
+    hasMessage?: () => boolean;
+};
 
-    u?: TestEnum;
 
-    v?: TestMessage$TestNestedEnum;
 
-    w?: Array<TestMessage$TestNestedMessage>;
 
-|};
 
+export type TestStreamRequestReply = {
+    getMessage?: () => TestMessage;
+    setMessage?: (message: TestMessage) => void;
+    clearMessage?: () => void;
+    hasMessage?: () => boolean;
+    getErrMsg?: () => string;
+    setErrMsg?: (err_msg: string) => void;
+};
 
 
 
 
 
-export type TestNoStreamRequest = {|
+export type TestStreamReplyRequest = {
+    getMessage?: () => TestMessage;
+    setMessage?: (message: TestMessage) => void;
+    clearMessage?: () => void;
+    hasMessage?: () => boolean;
+};
 
-    message?: TestMessage;
 
-|};
 
 
 
+export type TestStreamReplyReply = {
+    getMessage?: () => TestMessage;
+    setMessage?: (message: TestMessage) => void;
+    clearMessage?: () => void;
+    hasMessage?: () => boolean;
+    getErrMsg?: () => string;
+    setErrMsg?: (err_msg: string) => void;
+};
 
 
 
-export type TestNoStreamReply = {|
 
-    message?: TestMessage;
 
-    err_msg?: string;
+export type TestStreamBothRequest = {
+    getMessage?: () => TestMessage;
+    setMessage?: (message: TestMessage) => void;
+    clearMessage?: () => void;
+    hasMessage?: () => boolean;
+};
 
-|};
 
 
 
 
+export type TestStreamBothReply = {
+    getMessage?: () => TestMessage;
+    setMessage?: (message: TestMessage) => void;
+    clearMessage?: () => void;
+    hasMessage?: () => boolean;
+    getErrMsg?: () => string;
+    setErrMsg?: (err_msg: string) => void;
+};
 
+const serializeToBase64 = (byteArray: Uint8Array): string => base64.fromByteArray(byteArray)
+const deserializeFromBase64 = (base64Encoded: string): Uint8Array => new Uint8Array(base64.toByteArray(base64Encoded))
 
-export type TestStreamRequestRequest = {|
 
-    message?: TestMessage;
+function serialize_test_TestNoStreamRequest(arg : TestNoStreamRequest): string {
-  
+  if (!(arg instanceof test_pb.TestNoStreamRequest)) {
-|};
-
-
-
-
-
-
-export type TestStreamRequestReply = {|
-  
-    message?: TestMessage;
-  
-    err_msg?: string;
-  
-|};
-
-
-
-
-
-
-export type TestStreamReplyRequest = {|
-  
-    message?: TestMessage;
-  
-|};
-
-
-
-
-
-
-export type TestStreamReplyReply = {|
-  
-    message?: TestMessage;
-  
-    err_msg?: string;
-  
-|};
-
-
-
-
-
-
-export type TestStreamBothRequest = {|
-  
-    message?: TestMessage;
-  
-|};
-
-
-
-
-
-
-export type TestStreamBothReply = {|
-  
-    message?: TestMessage;
-  
-    err_msg?: string;
-  
-|};
-
-
-
-function serialize_test_TestNoStreamRequest(arg: TestNoStreamRequest) {
-  if (!(arg instanceof pbFile.TestNoStreamRequest)) {
     throw new Error('Expected argument of type TestNoStreamRequest')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_test_TestNoStreamRequest(buffer_arg: Array<number>) {
+function deserialize_test_TestNoStreamRequest(base64Encoded: string): TestNoStreamRequest {
-  return pbFile.TestNoStreamRequest.deserializeBinary(new Uint8Array(buffer_arg))
+  return test_pb.TestNoStreamRequest.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
-function serialize_test_TestNoStreamReply(arg: TestNoStreamReply) {
+function serialize_test_TestNoStreamReply(arg : TestNoStreamReply): string {
-  if (!(arg instanceof pbFile.TestNoStreamReply)) {
+  if (!(arg instanceof test_pb.TestNoStreamReply)) {
     throw new Error('Expected argument of type TestNoStreamReply')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_test_TestNoStreamReply(buffer_arg: Array<number>) {
+function deserialize_test_TestNoStreamReply(base64Encoded: string): TestNoStreamReply {
-  return pbFile.TestNoStreamReply.deserializeBinary(new Uint8Array(buffer_arg))
+  return test_pb.TestNoStreamReply.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
-function serialize_test_TestStreamRequestRequest(arg: TestStreamRequestRequest) {
+
-  if (!(arg instanceof pbFile.TestStreamRequestRequest)) {
+function serialize_test_TestStreamRequestRequest(arg : TestStreamRequestRequest): string {
+  if (!(arg instanceof test_pb.TestStreamRequestRequest)) {
     throw new Error('Expected argument of type TestStreamRequestRequest')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_test_TestStreamRequestRequest(buffer_arg: Array<number>) {
+function deserialize_test_TestStreamRequestRequest(base64Encoded: string): TestStreamRequestRequest {
-  return pbFile.TestStreamRequestRequest.deserializeBinary(new Uint8Array(buffer_arg))
+  return test_pb.TestStreamRequestRequest.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
-function serialize_test_TestStreamRequestReply(arg: TestStreamRequestReply) {
+function serialize_test_TestStreamRequestReply(arg : TestStreamRequestReply): string {
-  if (!(arg instanceof pbFile.TestStreamRequestReply)) {
+  if (!(arg instanceof test_pb.TestStreamRequestReply)) {
     throw new Error('Expected argument of type TestStreamRequestReply')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_test_TestStreamRequestReply(buffer_arg: Array<number>) {
+function deserialize_test_TestStreamRequestReply(base64Encoded: string): TestStreamRequestReply {
-  return pbFile.TestStreamRequestReply.deserializeBinary(new Uint8Array(buffer_arg))
+  return test_pb.TestStreamRequestReply.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
-function serialize_test_TestStreamReplyRequest(arg: TestStreamReplyRequest) {
+
-  if (!(arg instanceof pbFile.TestStreamReplyRequest)) {
+function serialize_test_TestStreamReplyRequest(arg : TestStreamReplyRequest): string {
+  if (!(arg instanceof test_pb.TestStreamReplyRequest)) {
     throw new Error('Expected argument of type TestStreamReplyRequest')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_test_TestStreamReplyRequest(buffer_arg: Array<number>) {
+function deserialize_test_TestStreamReplyRequest(base64Encoded: string): TestStreamReplyRequest {
-  return pbFile.TestStreamReplyRequest.deserializeBinary(new Uint8Array(buffer_arg))
+  return test_pb.TestStreamReplyRequest.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
-function serialize_test_TestStreamReplyReply(arg: TestStreamReplyReply) {
+function serialize_test_TestStreamReplyReply(arg : TestStreamReplyReply): string {
-  if (!(arg instanceof pbFile.TestStreamReplyReply)) {
+  if (!(arg instanceof test_pb.TestStreamReplyReply)) {
     throw new Error('Expected argument of type TestStreamReplyReply')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_test_TestStreamReplyReply(buffer_arg: Array<number>) {
+function deserialize_test_TestStreamReplyReply(base64Encoded: string): TestStreamReplyReply {
-  return pbFile.TestStreamReplyReply.deserializeBinary(new Uint8Array(buffer_arg))
+  return test_pb.TestStreamReplyReply.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
-function serialize_test_TestStreamBothRequest(arg: TestStreamBothRequest) {
+
-  if (!(arg instanceof pbFile.TestStreamBothRequest)) {
+function serialize_test_TestStreamBothRequest(arg : TestStreamBothRequest): string {
+  if (!(arg instanceof test_pb.TestStreamBothRequest)) {
     throw new Error('Expected argument of type TestStreamBothRequest')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_test_TestStreamBothRequest(buffer_arg: Array<number>) {
+function deserialize_test_TestStreamBothRequest(base64Encoded: string): TestStreamBothRequest {
-  return pbFile.TestStreamBothRequest.deserializeBinary(new Uint8Array(buffer_arg))
+  return test_pb.TestStreamBothRequest.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
-function serialize_test_TestStreamBothReply(arg: TestStreamBothReply) {
+function serialize_test_TestStreamBothReply(arg : TestStreamBothReply): string {
-  if (!(arg instanceof pbFile.TestStreamBothReply)) {
+  if (!(arg instanceof test_pb.TestStreamBothReply)) {
     throw new Error('Expected argument of type TestStreamBothReply')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_test_TestStreamBothReply(buffer_arg: Array<number>) {
+function deserialize_test_TestStreamBothReply(base64Encoded: string): TestStreamBothReply {
-  return pbFile.TestStreamBothReply.deserializeBinary(new Uint8Array(buffer_arg))
+  return test_pb.TestStreamBothReply.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
 
-export const TestServiceService = {
+export default {
+  
+  TestService: {
   
     testNoStream: {
       path: '/test.TestService/TestNoStream',
       requestStream: false,
       responseStream: false,
-    requestType: pbFile.TestNoStreamRequest,
+      requestType: test_pb.TestNoStreamRequest,
-    responseType: pbFile.TestNoStreamReply,
+      responseType: test_pb.TestNoStreamReply,
       requestSerialize: serialize_test_TestNoStreamRequest,
       requestDeserialize: deserialize_test_TestNoStreamRequest,
       responseSerialize: serialize_test_TestNoStreamReply,
@@ -270,8 +276,8 @@ export const TestServiceService = {
       path: '/test.TestService/TestStreamRequest',
       requestStream: true,
       responseStream: false,
-    requestType: pbFile.TestStreamRequestRequest,
+      requestType: test_pb.TestStreamRequestRequest,
-    responseType: pbFile.TestStreamRequestReply,
+      responseType: test_pb.TestStreamRequestReply,
       requestSerialize: serialize_test_TestStreamRequestRequest,
       requestDeserialize: deserialize_test_TestStreamRequestRequest,
       responseSerialize: serialize_test_TestStreamRequestReply,
@@ -281,8 +287,8 @@ export const TestServiceService = {
       path: '/test.TestService/TestStreamReply',
       requestStream: false,
       responseStream: true,
-    requestType: pbFile.TestStreamReplyRequest,
+      requestType: test_pb.TestStreamReplyRequest,
-    responseType: pbFile.TestStreamReplyReply,
+      responseType: test_pb.TestStreamReplyReply,
       requestSerialize: serialize_test_TestStreamReplyRequest,
       requestDeserialize: deserialize_test_TestStreamReplyRequest,
       responseSerialize: serialize_test_TestStreamReplyReply,
@@ -292,8 +298,8 @@ export const TestServiceService = {
       path: '/test.TestService/TestStreamBoth',
       requestStream: true,
       responseStream: true,
-    requestType: pbFile.TestStreamBothRequest,
+      requestType: test_pb.TestStreamBothRequest,
-    responseType: pbFile.TestStreamBothReply,
+      responseType: test_pb.TestStreamBothReply,
       requestSerialize: serialize_test_TestStreamBothRequest,
       requestDeserialize: deserialize_test_TestStreamBothRequest,
       responseSerialize: serialize_test_TestStreamBothReply,
@@ -302,4 +308,4 @@ export const TestServiceService = {
     
   }
   
-export const TestServiceClient = grpc.makeGenericClientConstructor(TestServiceService)
+}

examples/flow/templates/{{.File.Package}}/{{.File.Package}}_grpc_js.js.tmpl

@@ -1,74 +1,104 @@
 // @flow
 // GENERATED CODE -- DO NOT EDIT!
-{{$Package:=.File.Package}}
+
-import grpc from 'grpc'
+{{- $Package:=.File.Package}}
-import pbFile from './pbFile.js'
+
+import base64 from 'base64-js'
+import {{$Package}}_pb from './{{$Package}}_pb'
+
+{{- range .File.Dependency}}
+import {{. | replace "/" "_" | trimSuffix ".proto" }}_pb from '../{{. | trimSuffix ".proto" }}_pb'
+{{- end}}
+
+{{- define "fieldMethods"}}
+  {{- if isFieldRepeated .}}
+    get{{.Name | camelCase}}List?: () => {{. | jsType}};
+    set{{.Name | camelCase}}List?: ({{.Name}}: {{. | jsType}}) => void;
+    add{{.Name | camelCase}}?: ({{.Name}}: {{. | jsType | trimPrefix "Array<" | trimSuffix ">"}}) => void;
+    clear{{.Name | camelCase}}List?: () => void;
+  {{- else}}
+    get{{.Name | camelCase}}?: () => {{. | jsType}};
+    set{{.Name | camelCase}}?: ({{.Name}}: {{. | jsType}}) => void;
+
+    {{- if isFieldMessage .}}
+    clear{{.Name | camelCase}}?: () => void;
+    has{{.Name | camelCase}}?: () => boolean;
+    {{- end}}
+  {{- end}}
+{{- end}}
 
 {{range .File.EnumType}}
 export type {{.Name}} = {|
-  {{range .Value}}
+  {{- range .Value}}
     {{.Name}}?: {{.Number}};
-  {{end}}
+  {{- end}}
 |};
-{{end}}
+{{- end}}
+
+{{- range .File.MessageType}}
+{{- $MessageType := .Name}}
 
-{{range .File.MessageType}}
-{{$MessageType := .Name}}
 {{range .EnumType}}
 export type {{$MessageType}}${{.Name}} = {|
-  {{range .Value}}
+  {{- range .Value}}
     {{.Name}}?: {{.Number}};
-  {{end}}
+  {{- end}}
 |};
-{{end}}
+{{- end}}
 
 {{range .NestedType}}
-export type {{$MessageType}}${{.Name}} = {|
+export type {{$MessageType}}${{.Name}} = {
-  {{range .Field}}
+  {{- range .Field}}
-    {{.Name}}?: {{. | jsType}};
+    {{- template "fieldMethods" .}}
-  {{end}}
+  {{- end}}
-|};
+};
-{{end}}
+{{- end}}
 
-export type {{.Name}} = {|
+export type {{.Name}} = {
-  {{range .Field}}
+  {{- range .Field}}
-    {{.Name}}?: {{. | jsType}};
+    {{- template "fieldMethods" .}}
-  {{end}}
+  {{- end}}
-|};
+};
-{{end}}
+
+{{- end}}
+
+const serializeToBase64 = (byteArray: Uint8Array): string => base64.fromByteArray(byteArray)
+const deserializeFromBase64 = (base64Encoded: string): Uint8Array => new Uint8Array(base64.toByteArray(base64Encoded))
 
 {{range .File.Service}}{{range .Method}}
-function serialize_{{$Package}}_{{.InputType | shortType}}(arg: {{.InputType | shortType}}) {
+function serialize_{{$Package}}_{{.InputType | shortType}}(arg : {{.InputType | shortType}}): string {
-  if (!(arg instanceof pbFile.{{.InputType | shortType}})) {
+  if (!(arg instanceof {{$Package}}_pb.{{.InputType | shortType}})) {
     throw new Error('Expected argument of type {{.InputType | shortType}}')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_{{$Package}}_{{.InputType | shortType}}(buffer_arg: Array<number>) {
+function deserialize_{{$Package}}_{{.InputType | shortType}}(base64Encoded: string): {{.InputType | shortType}} {
-  return pbFile.{{.InputType | shortType}}.deserializeBinary(new Uint8Array(buffer_arg))
+  return {{$Package}}_pb.{{.InputType | shortType}}.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
 
-function serialize_{{$Package}}_{{.OutputType | shortType}}(arg: {{.OutputType | shortType}}) {
+function serialize_{{$Package}}_{{.OutputType | shortType}}(arg : {{.OutputType | shortType}}): string {
-  if (!(arg instanceof pbFile.{{.OutputType | shortType}})) {
+  if (!(arg instanceof {{$Package}}_pb.{{.OutputType | shortType}})) {
     throw new Error('Expected argument of type {{.OutputType | shortType}}')
   }
-  return new Buffer(arg.serializeBinary())
+  return serializeToBase64(arg.serializeBinary())
 }
 
-function deserialize_{{$Package}}_{{.OutputType | shortType}}(buffer_arg: Array<number>) {
+function deserialize_{{$Package}}_{{.OutputType | shortType}}(base64Encoded: string): {{.OutputType | shortType}} {
-  return pbFile.{{.OutputType | shortType}}.deserializeBinary(new Uint8Array(buffer_arg))
+  return {{$Package}}_pb.{{.OutputType | shortType}}.deserializeBinary(deserializeFromBase64(base64Encoded))
 }
+
 {{end}}{{end}}
+export default {
   {{range .File.Service}}
-export const {{.Name}}Service = {
+  {{.Name}}: {
   {{$serviceName:=.Name}}
     {{range .Method}}{{.Name | lowerCamelCase}}: {
       path: '/{{$Package}}.{{$serviceName}}/{{.Name}}',
       requestStream: {{.ClientStreaming | default "false"}},
       responseStream: {{.ServerStreaming | default "false"}},
-    requestType: pbFile.{{.InputType | shortType}},
+      requestType: {{$Package}}_pb.{{.InputType | shortType}},
-    responseType: pbFile.{{.OutputType | shortType}},
+      responseType: {{$Package}}_pb.{{.OutputType | shortType}},
       requestSerialize: serialize_{{$Package}}_{{.InputType | shortType}},
       requestDeserialize: deserialize_{{$Package}}_{{.InputType | shortType}},
       responseSerialize: serialize_{{$Package}}_{{.OutputType | shortType}},
@@ -76,5 +106,5 @@ export const {{.Name}}Service = {
     },
     {{end}}
   }
-
+  {{end}}
-export const {{.Name}}Client = grpc.makeGenericClientConstructor({{.Name}}Service){{end}}
+}

helpers.go

@@ -57,12 +57,10 @@ var ProtoHelpersFuncMap = template.FuncMap{
 
 		return strings.ToLower(s[:1]) + s[1:]
 	},
-	"snakeCase": func(s string) string {
-		return xstrings.ToSnakeCase(s)
-	},
 	"kebabCase": func(s string) string {
 		return strings.Replace(xstrings.ToSnakeCase(s), "_", "-", -1)
 	},
+	"snakeCase":       xstrings.ToSnakeCase,
 	"getMessageType":  getMessageType,
 	"isFieldMessage":  isFieldMessage,
 	"isFieldRepeated": isFieldRepeated,
@@ -167,7 +165,7 @@ func jsType(f *descriptor.FieldDescriptorProto) string {
 	case descriptor.FieldDescriptorProto_TYPE_BOOL:
 		return fmt.Sprintf(template, "boolean")
 	case descriptor.FieldDescriptorProto_TYPE_BYTES:
-		return fmt.Sprintf(template, "Array<number>")
+		return fmt.Sprintf(template, "Uint8Array")
 	case descriptor.FieldDescriptorProto_TYPE_STRING:
 		return fmt.Sprintf(template, "string")
 	default: