Merge pull request #109 from paymog/patch-1

Add docs for classes with attributes

Author: agreatfool

doc/server_impl_signature.md

@@ -99,8 +99,6 @@ const server = new grpc.Server();
 server.addService(BookServiceService, Impl);
 ```
 
-This style is `recommended`. Since you can append more attributes in the `Impl` object, though they are not defined in `IBookServiceServer`, and you don't need to add `[name: string]: grpc.UntypedHandleCall` in your codes.
-
 ### Class Style
 
 ```typescript
@@ -120,4 +118,52 @@ const server = new grpc.Server();
 server.addService(BookServiceService, new Impl());
 ```
 
-This style is `NOT` recommended. Since only those already defined in the `IBookServiceServer` can be existing in this `Impl` class, and `[name: string]: grpc.UntypedHandleCall` is required for Class style.
+Only those already defined in the `IBookServiceServer` can be existing in this `Impl` class, and `[name: string]: grpc.UntypedHandleCall;` is required for Class style.
+
+**Class style with magic generics**
+
+The following is how you can break the restriction above, to add attributes to a class style implementation of a server:
+
+```typescript
+// First we need to set up some magic generics inspired by https://github.com/agreatfool/grpc_tools_node_protoc_ts/issues/79#issuecomment-770173789
+type KnownKeys<T> = {
+  [K in keyof T]: string extends K ? never : number extends K ? never : K
+} extends { [_ in keyof T]: infer U } ? U : never;
+
+type KnownOnly<T extends Record<any, any>> = Pick<T, KnownKeys<T>>;
+
+// Next we declare a new type using the above generics:
+type ITypedBookServer = KnownOnly<IBookServiceServer>;
+
+// Now we declare the class
+class Impl implements ITypedBookServer  {
+    attr: string;
+
+    constructor(attr: string) {
+        this.attr = attr;
+    }
+
+    public getBook(call: grpc.ServerUnaryCall<GetBookRequest, Book>, callback: sendUnaryData<Book>): void {}
+
+    public getBooks(call: grpc.ServerDuplexStream<GetBookRequest, Book>) {}
+
+    public getBooksViaAuthor(call: grpc.ServerWritableStream<GetBookViaAuthor, Book>) {}
+
+    public getGreatestBook(call: grpc.ServerReadableStream<GetBookRequest, Book>, callback: sendUnaryData<Book>) {}
+}
+
+// now we need to initialize the above Impl. First we need to extend grpc.Server
+class TypedServerOverride extends grpc.Server {
+    addTypedService<TypedServiceImplementation extends Record<any,any>>(service: ServiceDefinition, implementation: TypedServiceImplementation): void {
+        this.addService(service, implementation);
+    }
+}
+
+// now perform the actual initialization
+const server = new TypedServerOverride();
+server.addTypedService<ITypedBookServer>(BookServiceService, new Impl("hello world"));
+```
+
+Runnable example could be found here:
+* [examples/bash/grpcjs/server.magic_generics.sh](https://github.com/agreatfool/grpc_tools_node_protoc_ts/blob/v5.3.1/examples/bash/grpcjs/server.magic_generics.sh)
+* [examples/src/grpcjs/server.magic_generics.ts](https://github.com/agreatfool/grpc_tools_node_protoc_ts/blob/v5.3.1/examples/src/grpcjs/server.magic_generics.ts)

examples/bash/grpcjs/server.magic_generics.sh

@@ -0,0 +1,6 @@
+#!/usr/bin/env bash
+
+BASEDIR=$(dirname "$0")
+cd ${BASEDIR}/../../
+
+DEBUG=* node ./build/grpcjs/server.magic_generics.js

examples/build/grpcjs/server.js.map

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+
+import * as debug from "debug";
+import * as grpc from "@grpc/grpc-js";
+
+import {BookServiceService, IBookServiceServer} from "./proto/book_grpc_pb";
+import { Book, GetBookRequest, GetBookViaAuthor } from "./proto/book_pb";
+
+const log = debug("SampleServer");
+
+type KnownKeys<T> = {
+    [K in keyof T]: string extends K ? never : number extends K ? never : K
+} extends { [_ in keyof T]: infer U } ? U : never;
+
+type KnownOnly<T extends Record<any, any>> = Pick<T, KnownKeys<T>>;
+
+type ITypedBookServer = KnownOnly<IBookServiceServer>;
+
+class TypedServerOverride extends grpc.Server {
+    public addTypedService<TypedServiceImplementation extends Record<any, any>>(
+      service: grpc.ServiceDefinition, implementation: TypedServiceImplementation,
+    ): void {
+        this.addService(service, implementation);
+    }
+}
+
+// tslint:disable-next-line:max-classes-per-file
+class ServerImpl implements ITypedBookServer {
+    public attr: string;
+
+    constructor(attr: string) {
+        this.attr = attr;
+    }
+
+    public getBook(call: grpc.ServerUnaryCall<GetBookRequest, Book>, callback: grpc.sendUnaryData<Book>): void {
+        const book = new Book();
+
+        book.setTitle("DefaultBook");
+        book.setAuthor("DefaultAuthor");
+
+        log(`[getBook] Done: ${JSON.stringify(book.toObject())}`);
+        callback(null, book);
+    }
+
+    public getBooks(call: grpc.ServerDuplexStream<GetBookRequest, Book>): void {
+        call.on("data", (request: GetBookRequest) => {
+            const reply = new Book();
+            reply.setTitle(`Book${request.getIsbn()}`);
+            reply.setAuthor(`Author${request.getIsbn()}`);
+            reply.setIsbn(request.getIsbn());
+            log(`[getBooks] Write: ${JSON.stringify(reply.toObject())}`);
+            call.write(reply);
+        });
+        call.on("end", () => {
+            log("[getBooks] Done.");
+            call.end();
+        });
+    }
+
+    public getBooksViaAuthor(call: grpc.ServerWritableStream<GetBookViaAuthor, Book>): void {
+        log(`[getBooksViaAuthor] Request: ${JSON.stringify(call.request.toObject())}`);
+        for (let i = 1; i <= 10; i++) {
+            const reply = new Book();
+            reply.setTitle(`Book${i}`);
+            reply.setAuthor(call.request.getAuthor());
+            reply.setIsbn(i);
+            log(`[getBooksViaAuthor] Write: ${JSON.stringify(reply.toObject())}`);
+            call.write(reply);
+        }
+        log("[getBooksViaAuthor] Done.");
+        call.end();
+    }
+
+    public getGreatestBook(call: grpc.ServerReadableStream<GetBookRequest, Book>, callback: grpc.sendUnaryData<Book>): void {
+        let lastOne: GetBookRequest;
+        call.on("data", (request: GetBookRequest) => {
+            log(`[getGreatestBook] Request: ${JSON.stringify(request.toObject())}`);
+            lastOne = request;
+        });
+        call.on("end", () => {
+            const reply = new Book();
+            reply.setIsbn(lastOne.getIsbn());
+            reply.setTitle("LastOne");
+            reply.setAuthor("LastOne");
+            log(`[getGreatestBook] Done: ${JSON.stringify(reply.toObject())}`);
+            callback(null, reply);
+        });
+    }
+}
+
+function startServer() {
+    const server = new TypedServerOverride();
+
+    server.addTypedService<ITypedBookServer>(BookServiceService, new ServerImpl("hello world"));
+    server.bindAsync("127.0.0.1:50051", grpc.ServerCredentials.createInsecure(), (err, port) => {
+        if (err) {
+            throw err;
+        }
+        log(`Server started, listening: 127.0.0.1:${port}`);
+        server.start();
+    });
+}
+
+startServer();
+
+process.on("uncaughtException", (err) => {
+    log(`process on uncaughtException error: ${err}`);
+});
+
+process.on("unhandledRejection", (err) => {
+    log(`process on unhandledRejection error: ${err}`);
+});