grpc/src/compiler/ts_generator.cc - third_party/flatbuffers - Git at Google

 /*
  * Copyright 2020 Google Inc. All rights reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *     http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 /*
  * NOTE: The following implementation is a translation for the Swift-grpc
  * generator since flatbuffers doesnt allow plugins for now. if an issue arises
  * please open an issue in the flatbuffers repository. This file should always
  * be maintained according to the Swift-grpc repository
  */

 #include "src/compiler/ts_generator.h"

 #include <map>
 #include <sstream>

 #include "flatbuffers/util.h"
 #include "src/compiler/schema_interface.h"

 namespace grpc_ts_generator {
 namespace {

 static grpc::string GenerateNamespace(const std::vector<std::string> ns,
                                const std::string filename,
                                const bool include_separator) {
   grpc::string path = "";
   if (include_separator) path += ".";

   for (auto it = ns.begin(); it < ns.end(); it++) {
     if (include_separator) path += "/";
     path += include_separator
                 ? flatbuffers::ConvertCase(*it, flatbuffers::Case::kDasher,
                                            flatbuffers::Case::kUpperCamel)
                 : *it + "_";
   }

   if (include_separator) path += "/";
   path += include_separator
               ? flatbuffers::ConvertCase(filename, flatbuffers::Case::kDasher,
                                          flatbuffers::Case::kUpperCamel)
               : filename;
   return path;
 }

 // MARK: - Shared code

 static void GenerateImports(const grpc_generator::Service *service,
                      grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> *dictonary,
                      const bool grpc_var_import) {
   auto vars = *dictonary;
   printer->Print(
       "// Generated GRPC code for FlatBuffers TS *** DO NOT EDIT ***\n");
   printer->Print("import * as flatbuffers from 'flatbuffers';\n");

   std::set<grpc::string> generated_imports;

   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     auto output = method->get_output_type_name();
     auto input = method->get_input_type_name();
     auto input_namespace = method->get_input_namespace_parts();

     vars["OUTPUT"] = output;
     vars["INPUT"] = input;

     if (generated_imports.find(output) == generated_imports.end()) {
       generated_imports.insert(output);
       vars["OUTPUT_DIR"] =
           GenerateNamespace(method->get_output_namespace_parts(), output, true);
       vars["Output_alias"] = GenerateNamespace(
           method->get_output_namespace_parts(), output, false);
       printer->Print(
           vars, "import { $OUTPUT$ as $Output_alias$ } from '$OUTPUT_DIR$';\n");
     }
     if (generated_imports.find(input) == generated_imports.end()) {
       generated_imports.insert(input);
       vars["INPUT_DIR"] =
           GenerateNamespace(method->get_output_namespace_parts(), input, true);
       vars["Input_alias"] =
           GenerateNamespace(method->get_output_namespace_parts(), input, false);
       printer->Print(
           vars, "import { $INPUT$ as $Input_alias$ } from '$INPUT_DIR$';\n");
     }
   }
   printer->Print("\n");
   if (grpc_var_import)
     printer->Print("var grpc = require('@grpc/grpc-js');\n");
   else
     printer->Print("import * as grpc from '@grpc/grpc-js';\n");
   printer->Print("\n");
 }

 // MARK: - Generate Main GRPC Code

 static void GetStreamType(grpc_generator::Printer *printer,
                    const grpc_generator::Method *method,
                    std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   auto client_streaming = method->ClientStreaming() || method->BidiStreaming();
   auto server_streaming = method->ServerStreaming() || method->BidiStreaming();
   vars["ClientStreaming"] = client_streaming ? "true" : "false";
   vars["ServerStreaming"] = server_streaming ? "true" : "false";
   printer->Print(vars, "requestStream: $ClientStreaming$,\n");
   printer->Print(vars, "responseStream: $ServerStreaming$,\n");
 }

 static void GenerateSerializeMethod(grpc_generator::Printer *printer,
                              std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars, "function serialize_$Type$(buffer_args) {\n");
   printer->Indent();
   printer->Print(vars, "if (!(buffer_args instanceof $Type$)) {\n");
   printer->Indent();
   printer->Print(vars,
                  "throw new Error('Expected argument of type $VALUE$');\n");
   printer->Outdent();
   printer->Print("}\n");
   printer->Print(vars, "return Buffer.from(buffer_args.serialize());\n");
   printer->Outdent();
   printer->Print("}\n\n");
 }

 static void GenerateDeserializeMethod(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars, "function deserialize_$Type$(buffer) {\n");
   printer->Indent();
   printer->Print(vars,
                  "return $Type$.getRootAs$VALUE$(new "
                  "flatbuffers.ByteBuffer(buffer))\n");
   printer->Outdent();
   printer->Print("}\n\n");
 }

 static void GenerateMethods(const grpc_generator::Service *service,
                      grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;

   std::set<grpc::string> generated_functions;

   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     auto output = method->get_output_type_name();
     auto input = method->get_input_type_name();

     if (generated_functions.find(output) == generated_functions.end()) {
       generated_functions.insert(output);
       vars["VALUE"] = output;
       vars["Type"] = GenerateNamespace(method->get_output_namespace_parts(),
                                        output, false);
       GenerateSerializeMethod(printer, &vars);
       GenerateDeserializeMethod(printer, &vars);
     }
     printer->Print("\n");
     if (generated_functions.find(input) == generated_functions.end()) {
       generated_functions.insert(input);
       vars["VALUE"] = input;
       vars["Type"] =
           GenerateNamespace(method->get_input_namespace_parts(), input, false);
       GenerateSerializeMethod(printer, &vars);
       GenerateDeserializeMethod(printer, &vars);
     }
   }
 }

 static void GenerateService(const grpc_generator::Service *service,
                      grpc_generator::Printer *printer,
                      std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   vars["NAME"] = service->name() + "Service";

   printer->Print(vars, "var $NAME$ = exports.$NAME$ = {\n");
   printer->Indent();
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["MethodName"] = method->name();
     vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
                                        method->get_output_type_name(), false);
     vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
                                       method->get_input_type_name(), false);
     printer->Print(vars, "$MethodName$: {\n");
     printer->Indent();
     printer->Print(vars, "path: '/$PATH$$ServiceName$/$MethodName$',\n");
     GetStreamType(printer, &*method, &vars);
     printer->Print(vars, "requestType: flatbuffers.ByteBuffer,\n");
     printer->Print(vars, "responseType: $OUTPUT$,\n");
     printer->Print(vars, "requestSerialize: serialize_$INPUT$,\n");
     printer->Print(vars, "requestDeserialize: deserialize_$INPUT$,\n");
     printer->Print(vars, "responseSerialize: serialize_$OUTPUT$,\n");
     printer->Print(vars, "responseDeserialize: deserialize_$OUTPUT$,\n");
     printer->Outdent();
     printer->Print("},\n");
   }
   printer->Outdent();
   printer->Print("};\n");
   printer->Print(vars,
                  "exports.$ServiceName$Client = "
                  "grpc.makeGenericClientConstructor($NAME$);");
 }

 } // namespace

 grpc::string Generate(grpc_generator::File *file,
                       const grpc_generator::Service *service,
                       const grpc::string &filename) {
   grpc::string output;
   std::map<grpc::string, grpc::string> vars;

   vars["PATH"] = file->package();

   if (!file->package().empty()) { vars["PATH"].append("."); }

   vars["ServiceName"] = service->name();
   vars["FBSFile"] = service->name() + "_fbs";
   vars["Filename"] = filename;
   auto printer = file->CreatePrinter(&output);

   GenerateImports(service, &*printer, &vars, true);
   GenerateMethods(service, &*printer, &vars);
   GenerateService(service, &*printer, &vars);
   return output;
 }

 namespace {

 // MARK: - Generate Interface

 static void FillInterface(grpc_generator::Printer *printer,
                    std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars,
                  "interface I$ServiceName$Service_I$MethodName$ extends "
                  "grpc.MethodDefinition<$INPUT$, $OUTPUT$> {\n");
   printer->Indent();
   printer->Print(vars, "path: string; // /$PATH$$ServiceName$/$MethodName$\n");
   printer->Print(vars, "requestStream: boolean; // $ClientStreaming$\n");
   printer->Print(vars, "responseStream: boolean; // $ServerStreaming$\n");
   printer->Print(vars, "requestSerialize: grpc.serialize<$INPUT$>;\n");
   printer->Print(vars, "requestDeserialize: grpc.deserialize<$INPUT$>;\n");
   printer->Print(vars, "responseSerialize: grpc.serialize<$OUTPUT$>;\n");
   printer->Print(vars, "responseDeserialize: grpc.deserialize<$OUTPUT$>;\n");
   printer->Outdent();
   printer->Print("}\n");
 }

 static void GenerateInterfaces(const grpc_generator::Service *service,
                         grpc_generator::Printer *printer,
                         std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     auto client_streaming =
         method->ClientStreaming() || method->BidiStreaming();
     auto server_streaming =
         method->ServerStreaming() || method->BidiStreaming();
     vars["ClientStreaming"] = client_streaming ? "true" : "false";
     vars["ServerStreaming"] = server_streaming ? "true" : "false";
     vars["MethodName"] = method->name();
     vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
                                        method->get_output_type_name(), false);
     vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
                                       method->get_input_type_name(), false);
     FillInterface(printer, &vars);
     printer->Print("\n");
   }
 }

 static void GenerateExportedInterface(
     const grpc_generator::Service *service, grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars,
                  "export interface I$ServiceName$Server extends "
                  "grpc.UntypedServiceImplementation {\n");
   printer->Indent();
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["Name"] = method->name();
     vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
                                        method->get_output_type_name(), false);
     vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
                                       method->get_input_type_name(), false);
     if (method->BidiStreaming()) {
       printer->Print(vars,
                      "$Name$: grpc.handleBidiStreamingCall<$INPUT$, "
                      "$OUTPUT$>;\n");
       continue;
     }
     if (method->NoStreaming()) {
       printer->Print(vars,
                      "$Name$: grpc.handleUnaryCall<$INPUT$, "
                      "$OUTPUT$>;\n");
       continue;
     }
     if (method->ClientStreaming()) {
       printer->Print(vars,
                      "$Name$: grpc.handleClientStreamingCall<$INPUT$, "
                      "$OUTPUT$>;\n");
       continue;
     }
     if (method->ServerStreaming()) {
       printer->Print(vars,
                      "$Name$: grpc.handleServerStreamingCall<$INPUT$, "
                      "$OUTPUT$>;\n");
       continue;
     }
   }
   printer->Outdent();
   printer->Print("}\n");
 }

 static void GenerateMainInterface(const grpc_generator::Service *service,
                            grpc_generator::Printer *printer,
                            std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(
       vars,
       "interface I$ServiceName$Service extends "
       "grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {\n");
   printer->Indent();
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["MethodName"] = method->name();
     printer->Print(vars,
                    "$MethodName$: I$ServiceName$Service_I$MethodName$;\n");
   }
   printer->Outdent();
   printer->Print("}\n");
   GenerateInterfaces(service, printer, &vars);
   printer->Print("\n");
   printer->Print(vars,
                  "export const $ServiceName$Service: I$ServiceName$Service;\n");
   printer->Print("\n");
   GenerateExportedInterface(service, printer, &vars);
 }

 static grpc::string GenerateMetaData() { return "metadata: grpc.Metadata"; }

 static grpc::string GenerateOptions() { return "options: Partial<grpc.CallOptions>"; }

 static void GenerateUnaryClientInterface(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   grpc::string main = "$ISPUBLIC$$MethodName$(request: $INPUT$, ";
   grpc::string callback =
       "callback: (error: grpc.ServiceError | null, response: "
       "$OUTPUT$) => void): grpc.ClientUnaryCall;\n";
   auto meta_data = GenerateMetaData() + ", ";
   auto options = GenerateOptions() + ", ";
   printer->Print(vars, (main + callback).c_str());
   printer->Print(vars, (main + meta_data + callback).c_str());
   printer->Print(vars, (main + meta_data + options + callback).c_str());
 }

 static void GenerateClientWriteStreamInterface(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   grpc::string main = "$ISPUBLIC$$MethodName$(";
   grpc::string callback =
       "callback: (error: grpc.ServiceError | null, response: "
       "$INPUT$) => void): "
       "grpc.ClientWritableStream<$OUTPUT$>;\n";
   auto meta_data = GenerateMetaData() + ", ";
   auto options = GenerateOptions() + ", ";
   printer->Print(vars, (main + callback).c_str());
   printer->Print(vars, (main + meta_data + callback).c_str());
   printer->Print(vars, (main + options + callback).c_str());
   printer->Print(vars, (main + meta_data + options + callback).c_str());
 }

 static void GenerateClientReadableStreamInterface(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   grpc::string main = "$ISPUBLIC$$MethodName$(request: $INPUT$, ";
   grpc::string end_function = "): grpc.ClientReadableStream<$OUTPUT$>;\n";
   auto meta_data = GenerateMetaData();
   auto options = GenerateOptions();
   printer->Print(vars, (main + meta_data + end_function).c_str());
   printer->Print(vars, (main + options + end_function).c_str());
 }

 static void GenerateDepluxStreamInterface(
     grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   grpc::string main = "$ISPUBLIC$$MethodName$(";
   grpc::string end_function =
       "): grpc.ClientDuplexStream<$INPUT$, $OUTPUT$>;\n";
   auto meta_data = GenerateMetaData();
   auto options = GenerateOptions();
   printer->Print(vars, (main + end_function).c_str());
   printer->Print(vars, (main + options + end_function).c_str());
   printer->Print(vars, (main + meta_data +
                         ", options?: Partial<grpc.CallOptions>" + end_function)
                            .c_str());
 }

 static void GenerateClientInterface(const grpc_generator::Service *service,
                              grpc_generator::Printer *printer,
                              std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars, "export interface I$ServiceName$Client {\n");
   printer->Indent();
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["MethodName"] = method->name();
     vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
                                        method->get_output_type_name(), false);
     vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
                                       method->get_input_type_name(), false);
     vars["ISPUBLIC"] = "";

     if (method->NoStreaming()) {
       GenerateUnaryClientInterface(printer, &vars);
       continue;
     }
     if (method->BidiStreaming()) {
       GenerateDepluxStreamInterface(printer, &vars);
       continue;
     }

     if (method->ClientStreaming()) {
       GenerateClientWriteStreamInterface(printer, &vars);
       continue;
     }

     if (method->ServerStreaming()) {
       GenerateClientReadableStreamInterface(printer, &vars);
       continue;
     }
   }
   printer->Outdent();
   printer->Print("}\n");
 }

 static void GenerateClientClassInterface(
     const grpc_generator::Service *service, grpc_generator::Printer *printer,
     std::map<grpc::string, grpc::string> *dictonary) {
   auto vars = *dictonary;
   printer->Print(vars,
                  "export class $ServiceName$Client extends grpc.Client "
                  "implements I$ServiceName$Client {\n");
   printer->Indent();
   printer->Print(
       "constructor(address: string, credentials: grpc.ChannelCredentials, "
       "options?: object);\n");
   for (auto it = 0; it < service->method_count(); it++) {
     auto method = service->method(it);
     vars["MethodName"] = method->name();
     vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
                                        method->get_output_type_name(), false);
     vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
                                       method->get_input_type_name(), false);
     vars["ISPUBLIC"] = "public ";
     if (method->NoStreaming()) {
       GenerateUnaryClientInterface(printer, &vars);
       continue;
     }
     if (method->BidiStreaming()) {
       GenerateDepluxStreamInterface(printer, &vars);
       continue;
     }

     if (method->ClientStreaming()) {
       GenerateClientWriteStreamInterface(printer, &vars);
       continue;
     }

     if (method->ServerStreaming()) {
       GenerateClientReadableStreamInterface(printer, &vars);
       continue;
     }
   }
   printer->Outdent();
   printer->Print("}\n");
 }
 } // namespace


 grpc::string GenerateInterface(grpc_generator::File *file,
                                const grpc_generator::Service *service,
                                const grpc::string &filename) {
   grpc::string output;

   std::set<grpc::string> generated_functions;
   std::map<grpc::string, grpc::string> vars;

   vars["PATH"] = file->package();

   if (!file->package().empty()) { vars["PATH"].append("."); }

   vars["ServiceName"] = service->name();
   vars["FBSFile"] = service->name() + "_fbs";
   vars["Filename"] = filename;
   auto printer = file->CreatePrinter(&output);

   GenerateImports(service, &*printer, &vars, false);
   GenerateMainInterface(service, &*printer, &vars);
   printer->Print("\n");
   GenerateClientInterface(service, &*printer, &vars);
   printer->Print("\n");
   GenerateClientClassInterface(service, &*printer, &vars);
   return output;
 }
 }  // namespace grpc_ts_generator
	/*
	* Copyright 2020 Google Inc. All rights reserved.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	/*
	* NOTE: The following implementation is a translation for the Swift-grpc
	* generator since flatbuffers doesnt allow plugins for now. if an issue arises
	* please open an issue in the flatbuffers repository. This file should always
	* be maintained according to the Swift-grpc repository
	*/

	#include "src/compiler/ts_generator.h"

	#include <map>
	#include <sstream>

	#include "flatbuffers/util.h"
	#include "src/compiler/schema_interface.h"

	namespace grpc_ts_generator {
	namespace {

	static grpc::string GenerateNamespace(const std::vector<std::string> ns,
	const std::string filename,
	const bool include_separator) {
	grpc::string path = "";
	if (include_separator) path += ".";

	for (auto it = ns.begin(); it < ns.end(); it++) {
	if (include_separator) path += "/";
	path += include_separator
	? flatbuffers::ConvertCase(*it, flatbuffers::Case::kDasher,
	flatbuffers::Case::kUpperCamel)
	: *it + "_";
	}

	if (include_separator) path += "/";
	path += include_separator
	? flatbuffers::ConvertCase(filename, flatbuffers::Case::kDasher,
	flatbuffers::Case::kUpperCamel)
	: filename;
	return path;
	}

	// MARK: - Shared code

	static void GenerateImports(const grpc_generator::Service *service,
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary,
	const bool grpc_var_import) {
	auto vars = *dictonary;
	printer->Print(
	"// Generated GRPC code for FlatBuffers TS * DO NOT EDIT *\n");
	printer->Print("import * as flatbuffers from 'flatbuffers';\n");

	std::set<grpc::string> generated_imports;

	for (auto it = 0; it < service->method_count(); it++) {
	auto method = service->method(it);
	auto output = method->get_output_type_name();
	auto input = method->get_input_type_name();
	auto input_namespace = method->get_input_namespace_parts();

	vars["OUTPUT"] = output;
	vars["INPUT"] = input;

	if (generated_imports.find(output) == generated_imports.end()) {
	generated_imports.insert(output);
	vars["OUTPUT_DIR"] =
	GenerateNamespace(method->get_output_namespace_parts(), output, true);
	vars["Output_alias"] = GenerateNamespace(
	method->get_output_namespace_parts(), output, false);
	printer->Print(
	vars, "import { $OUTPUT$ as $Output_alias$ } from '$OUTPUT_DIR$';\n");
	}
	if (generated_imports.find(input) == generated_imports.end()) {
	generated_imports.insert(input);
	vars["INPUT_DIR"] =
	GenerateNamespace(method->get_output_namespace_parts(), input, true);
	vars["Input_alias"] =
	GenerateNamespace(method->get_output_namespace_parts(), input, false);
	printer->Print(
	vars, "import { $INPUT$ as $Input_alias$ } from '$INPUT_DIR$';\n");
	}
	}
	printer->Print("\n");
	if (grpc_var_import)
	printer->Print("var grpc = require('@grpc/grpc-js');\n");
	else
	printer->Print("import * as grpc from '@grpc/grpc-js';\n");
	printer->Print("\n");
	}

	// MARK: - Generate Main GRPC Code

	static void GetStreamType(grpc_generator::Printer *printer,
	const grpc_generator::Method *method,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	auto client_streaming = method->ClientStreaming() \|\| method->BidiStreaming();
	auto server_streaming = method->ServerStreaming() \|\| method->BidiStreaming();
	vars["ClientStreaming"] = client_streaming ? "true" : "false";
	vars["ServerStreaming"] = server_streaming ? "true" : "false";
	printer->Print(vars, "requestStream: $ClientStreaming$,\n");
	printer->Print(vars, "responseStream: $ServerStreaming$,\n");
	}

	static void GenerateSerializeMethod(grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	printer->Print(vars, "function serialize_$Type$(buffer_args) {\n");
	printer->Indent();
	printer->Print(vars, "if (!(buffer_args instanceof $Type$)) {\n");
	printer->Indent();
	printer->Print(vars,
	"throw new Error('Expected argument of type $VALUE$');\n");
	printer->Outdent();
	printer->Print("}\n");
	printer->Print(vars, "return Buffer.from(buffer_args.serialize());\n");
	printer->Outdent();
	printer->Print("}\n\n");
	}

	static void GenerateDeserializeMethod(
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	printer->Print(vars, "function deserialize_$Type$(buffer) {\n");
	printer->Indent();
	printer->Print(vars,
	"return $Type$.getRootAs$VALUE$(new "
	"flatbuffers.ByteBuffer(buffer))\n");
	printer->Outdent();
	printer->Print("}\n\n");
	}

	static void GenerateMethods(const grpc_generator::Service *service,
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;

	std::set<grpc::string> generated_functions;

	for (auto it = 0; it < service->method_count(); it++) {
	auto method = service->method(it);
	auto output = method->get_output_type_name();
	auto input = method->get_input_type_name();

	if (generated_functions.find(output) == generated_functions.end()) {
	generated_functions.insert(output);
	vars["VALUE"] = output;
	vars["Type"] = GenerateNamespace(method->get_output_namespace_parts(),
	output, false);
	GenerateSerializeMethod(printer, &vars);
	GenerateDeserializeMethod(printer, &vars);
	}
	printer->Print("\n");
	if (generated_functions.find(input) == generated_functions.end()) {
	generated_functions.insert(input);
	vars["VALUE"] = input;
	vars["Type"] =
	GenerateNamespace(method->get_input_namespace_parts(), input, false);
	GenerateSerializeMethod(printer, &vars);
	GenerateDeserializeMethod(printer, &vars);
	}
	}
	}

	static void GenerateService(const grpc_generator::Service *service,
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	vars["NAME"] = service->name() + "Service";

	printer->Print(vars, "var $NAME$ = exports.$NAME$ = {\n");
	printer->Indent();
	for (auto it = 0; it < service->method_count(); it++) {
	auto method = service->method(it);
	vars["MethodName"] = method->name();
	vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
	method->get_output_type_name(), false);
	vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
	method->get_input_type_name(), false);
	printer->Print(vars, "$MethodName$: {\n");
	printer->Indent();
	printer->Print(vars, "path: '/$PATH$$ServiceName$/$MethodName$',\n");
	GetStreamType(printer, &*method, &vars);
	printer->Print(vars, "requestType: flatbuffers.ByteBuffer,\n");
	printer->Print(vars, "responseType: $OUTPUT$,\n");
	printer->Print(vars, "requestSerialize: serialize_$INPUT$,\n");
	printer->Print(vars, "requestDeserialize: deserialize_$INPUT$,\n");
	printer->Print(vars, "responseSerialize: serialize_$OUTPUT$,\n");
	printer->Print(vars, "responseDeserialize: deserialize_$OUTPUT$,\n");
	printer->Outdent();
	printer->Print("},\n");
	}
	printer->Outdent();
	printer->Print("};\n");
	printer->Print(vars,
	"exports.$ServiceName$Client = "
	"grpc.makeGenericClientConstructor($NAME$);");
	}

	} // namespace

	grpc::string Generate(grpc_generator::File *file,
	const grpc_generator::Service *service,
	const grpc::string &filename) {
	grpc::string output;
	std::map<grpc::string, grpc::string> vars;

	vars["PATH"] = file->package();

	if (!file->package().empty()) { vars["PATH"].append("."); }

	vars["ServiceName"] = service->name();
	vars["FBSFile"] = service->name() + "_fbs";
	vars["Filename"] = filename;
	auto printer = file->CreatePrinter(&output);

	GenerateImports(service, &*printer, &vars, true);
	GenerateMethods(service, &*printer, &vars);
	GenerateService(service, &*printer, &vars);
	return output;
	}

	namespace {

	// MARK: - Generate Interface

	static void FillInterface(grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	printer->Print(vars,
	"interface I$ServiceName$Service_I$MethodName$ extends "
	"grpc.MethodDefinition<$INPUT$, $OUTPUT$> {\n");
	printer->Indent();
	printer->Print(vars, "path: string; // /$PATH$$ServiceName$/$MethodName$\n");
	printer->Print(vars, "requestStream: boolean; // $ClientStreaming$\n");
	printer->Print(vars, "responseStream: boolean; // $ServerStreaming$\n");
	printer->Print(vars, "requestSerialize: grpc.serialize<$INPUT$>;\n");
	printer->Print(vars, "requestDeserialize: grpc.deserialize<$INPUT$>;\n");
	printer->Print(vars, "responseSerialize: grpc.serialize<$OUTPUT$>;\n");
	printer->Print(vars, "responseDeserialize: grpc.deserialize<$OUTPUT$>;\n");
	printer->Outdent();
	printer->Print("}\n");
	}

	static void GenerateInterfaces(const grpc_generator::Service *service,
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	for (auto it = 0; it < service->method_count(); it++) {
	auto method = service->method(it);
	auto client_streaming =
	method->ClientStreaming() \|\| method->BidiStreaming();
	auto server_streaming =
	method->ServerStreaming() \|\| method->BidiStreaming();
	vars["ClientStreaming"] = client_streaming ? "true" : "false";
	vars["ServerStreaming"] = server_streaming ? "true" : "false";
	vars["MethodName"] = method->name();
	vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
	method->get_output_type_name(), false);
	vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
	method->get_input_type_name(), false);
	FillInterface(printer, &vars);
	printer->Print("\n");
	}
	}

	static void GenerateExportedInterface(
	const grpc_generator::Service service, grpc_generator::Printer printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	printer->Print(vars,
	"export interface I$ServiceName$Server extends "
	"grpc.UntypedServiceImplementation {\n");
	printer->Indent();
	for (auto it = 0; it < service->method_count(); it++) {
	auto method = service->method(it);
	vars["Name"] = method->name();
	vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
	method->get_output_type_name(), false);
	vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
	method->get_input_type_name(), false);
	if (method->BidiStreaming()) {
	printer->Print(vars,
	"$Name$: grpc.handleBidiStreamingCall<$INPUT$, "
	"$OUTPUT$>;\n");
	continue;
	}
	if (method->NoStreaming()) {
	printer->Print(vars,
	"$Name$: grpc.handleUnaryCall<$INPUT$, "
	"$OUTPUT$>;\n");
	continue;
	}
	if (method->ClientStreaming()) {
	printer->Print(vars,
	"$Name$: grpc.handleClientStreamingCall<$INPUT$, "
	"$OUTPUT$>;\n");
	continue;
	}
	if (method->ServerStreaming()) {
	printer->Print(vars,
	"$Name$: grpc.handleServerStreamingCall<$INPUT$, "
	"$OUTPUT$>;\n");
	continue;
	}
	}
	printer->Outdent();
	printer->Print("}\n");
	}

	static void GenerateMainInterface(const grpc_generator::Service *service,
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	printer->Print(
	vars,
	"interface I$ServiceName$Service extends "
	"grpc.ServiceDefinition<grpc.UntypedServiceImplementation> {\n");
	printer->Indent();
	for (auto it = 0; it < service->method_count(); it++) {
	auto method = service->method(it);
	vars["MethodName"] = method->name();
	printer->Print(vars,
	"$MethodName$: I$ServiceName$Service_I$MethodName$;\n");
	}
	printer->Outdent();
	printer->Print("}\n");
	GenerateInterfaces(service, printer, &vars);
	printer->Print("\n");
	printer->Print(vars,
	"export const $ServiceName$Service: I$ServiceName$Service;\n");
	printer->Print("\n");
	GenerateExportedInterface(service, printer, &vars);
	}

	static grpc::string GenerateMetaData() { return "metadata: grpc.Metadata"; }

	static grpc::string GenerateOptions() { return "options: Partial<grpc.CallOptions>"; }

	static void GenerateUnaryClientInterface(
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	grpc::string main = "$ISPUBLIC$$MethodName$(request: $INPUT$, ";
	grpc::string callback =
	"callback: (error: grpc.ServiceError \| null, response: "
	"$OUTPUT$) => void): grpc.ClientUnaryCall;\n";
	auto meta_data = GenerateMetaData() + ", ";
	auto options = GenerateOptions() + ", ";
	printer->Print(vars, (main + callback).c_str());
	printer->Print(vars, (main + meta_data + callback).c_str());
	printer->Print(vars, (main + meta_data + options + callback).c_str());
	}

	static void GenerateClientWriteStreamInterface(
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	grpc::string main = "$ISPUBLIC$$MethodName$(";
	grpc::string callback =
	"callback: (error: grpc.ServiceError \| null, response: "
	"$INPUT$) => void): "
	"grpc.ClientWritableStream<$OUTPUT$>;\n";
	auto meta_data = GenerateMetaData() + ", ";
	auto options = GenerateOptions() + ", ";
	printer->Print(vars, (main + callback).c_str());
	printer->Print(vars, (main + meta_data + callback).c_str());
	printer->Print(vars, (main + options + callback).c_str());
	printer->Print(vars, (main + meta_data + options + callback).c_str());
	}

	static void GenerateClientReadableStreamInterface(
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	grpc::string main = "$ISPUBLIC$$MethodName$(request: $INPUT$, ";
	grpc::string end_function = "): grpc.ClientReadableStream<$OUTPUT$>;\n";
	auto meta_data = GenerateMetaData();
	auto options = GenerateOptions();
	printer->Print(vars, (main + meta_data + end_function).c_str());
	printer->Print(vars, (main + options + end_function).c_str());
	}

	static void GenerateDepluxStreamInterface(
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	grpc::string main = "$ISPUBLIC$$MethodName$(";
	grpc::string end_function =
	"): grpc.ClientDuplexStream<$INPUT$, $OUTPUT$>;\n";
	auto meta_data = GenerateMetaData();
	auto options = GenerateOptions();
	printer->Print(vars, (main + end_function).c_str());
	printer->Print(vars, (main + options + end_function).c_str());
	printer->Print(vars, (main + meta_data +
	", options?: Partial<grpc.CallOptions>" + end_function)
	.c_str());
	}

	static void GenerateClientInterface(const grpc_generator::Service *service,
	grpc_generator::Printer *printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	printer->Print(vars, "export interface I$ServiceName$Client {\n");
	printer->Indent();
	for (auto it = 0; it < service->method_count(); it++) {
	auto method = service->method(it);
	vars["MethodName"] = method->name();
	vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
	method->get_output_type_name(), false);
	vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
	method->get_input_type_name(), false);
	vars["ISPUBLIC"] = "";

	if (method->NoStreaming()) {
	GenerateUnaryClientInterface(printer, &vars);
	continue;
	}
	if (method->BidiStreaming()) {
	GenerateDepluxStreamInterface(printer, &vars);
	continue;
	}

	if (method->ClientStreaming()) {
	GenerateClientWriteStreamInterface(printer, &vars);
	continue;
	}

	if (method->ServerStreaming()) {
	GenerateClientReadableStreamInterface(printer, &vars);
	continue;
	}
	}
	printer->Outdent();
	printer->Print("}\n");
	}

	static void GenerateClientClassInterface(
	const grpc_generator::Service service, grpc_generator::Printer printer,
	std::map<grpc::string, grpc::string> *dictonary) {
	auto vars = *dictonary;
	printer->Print(vars,
	"export class $ServiceName$Client extends grpc.Client "
	"implements I$ServiceName$Client {\n");
	printer->Indent();
	printer->Print(
	"constructor(address: string, credentials: grpc.ChannelCredentials, "
	"options?: object);\n");
	for (auto it = 0; it < service->method_count(); it++) {
	auto method = service->method(it);
	vars["MethodName"] = method->name();
	vars["OUTPUT"] = GenerateNamespace(method->get_output_namespace_parts(),
	method->get_output_type_name(), false);
	vars["INPUT"] = GenerateNamespace(method->get_input_namespace_parts(),
	method->get_input_type_name(), false);
	vars["ISPUBLIC"] = "public ";
	if (method->NoStreaming()) {
	GenerateUnaryClientInterface(printer, &vars);
	continue;
	}
	if (method->BidiStreaming()) {
	GenerateDepluxStreamInterface(printer, &vars);
	continue;
	}

	if (method->ClientStreaming()) {
	GenerateClientWriteStreamInterface(printer, &vars);
	continue;
	}

	if (method->ServerStreaming()) {
	GenerateClientReadableStreamInterface(printer, &vars);
	continue;
	}
	}
	printer->Outdent();
	printer->Print("}\n");
	}
	} // namespace


	grpc::string GenerateInterface(grpc_generator::File *file,
	const grpc_generator::Service *service,
	const grpc::string &filename) {
	grpc::string output;

	std::set<grpc::string> generated_functions;
	std::map<grpc::string, grpc::string> vars;

	vars["PATH"] = file->package();

	if (!file->package().empty()) { vars["PATH"].append("."); }

	vars["ServiceName"] = service->name();
	vars["FBSFile"] = service->name() + "_fbs";
	vars["Filename"] = filename;
	auto printer = file->CreatePrinter(&output);

	GenerateImports(service, &*printer, &vars, false);
	GenerateMainInterface(service, &*printer, &vars);
	printer->Print("\n");
	GenerateClientInterface(service, &*printer, &vars);
	printer->Print("\n");
	GenerateClientClassInterface(service, &*printer, &vars);
	return output;
	}
	} // namespace grpc_ts_generator