chore(ts-protoc-gen): fix types because lol wtf

src/ts-protoc-gen/ExportMap.ts

@@ -34,22 +34,21 @@ export class ExportMap {
         message: DescriptorProto
     ) {
         const messageEntry: ExportMessageEntry = {
-            pkg: fileDescriptor.getPackage(),
+            pkg: fileDescriptor.getPackage() as string,
-            fileName: fileDescriptor.getName(),
+            fileName: fileDescriptor.getName() as string,
-            messageOptions: message.getOptions(),
+            messageOptions: message.getOptions() as MessageOptions,
-            mapFieldOptions:
+            mapFieldOptions: (message.getOptions() && message.getOptions()?.getMapEntry()
-                message.getOptions() && message.getOptions().getMapEntry()
+                ? {
-                    ? {
+                      key: [
-                          key: [
+                          message.getFieldList()[0].getType(),
-                              message.getFieldList()[0].getType(),
+                          (message.getFieldList()[0].getTypeName() as string).slice(1),
-                              message.getFieldList()[0].getTypeName().slice(1),
+                      ],
-                          ],
+                      value: [
-                          value: [
+                          message.getFieldList()[1].getType(),
-                              message.getFieldList()[1].getType(),
+                          (message.getFieldList()[1].getTypeName() as string).slice(1),
-                              message.getFieldList()[1].getTypeName().slice(1),
+                      ],
-                          ],
+                  }
-                      }
+                : undefined) as any,
-                    : undefined,
         };
 
         const packagePrefix = scope ? scope + '.' : '';
@@ -66,17 +65,19 @@ export class ExportMap {
         });
 
         message.getEnumTypeList().forEach((enumType) => {
-            const identifier = `${packagePrefix}${message.getName()}.${enumType.getName()}`;
+            const identifier = `${packagePrefix}${message.getName() as string}.${
+                enumType.getName() as string
+            }`;
             this.enumMap[identifier] = {
-                pkg: fileDescriptor.getPackage(),
+                pkg: fileDescriptor.getPackage() as string,
-                fileName: fileDescriptor.getName(),
+                fileName: fileDescriptor.getName() as string,
-                enumOptions: enumType.getOptions(),
+                enumOptions: enumType.getOptions() as EnumOptions,
             };
         });
     }
 
     addFileDescriptor(fileDescriptor: FileDescriptorProto) {
-        const scope = fileDescriptor.getPackage();
+        const scope = fileDescriptor.getPackage() as string;
         fileDescriptor.getMessageTypeList().forEach((messageType) => {
             this.exportNested(scope, fileDescriptor, messageType);
         });
@@ -84,9 +85,9 @@ export class ExportMap {
         fileDescriptor.getEnumTypeList().forEach((enumType) => {
             const packagePrefix = scope ? scope + '.' : '';
             this.enumMap[packagePrefix + enumType.getName()] = {
-                pkg: fileDescriptor.getPackage(),
+                pkg: fileDescriptor.getPackage() as string,
-                fileName: fileDescriptor.getName(),
+                fileName: fileDescriptor.getName() as string,
-                enumOptions: enumType.getOptions(),
+                enumOptions: enumType.getOptions() as EnumOptions,
             };
         });
     }

src/ts-protoc-gen/index.ts

@@ -30,13 +30,15 @@ withAllStdIn((inputBuff: Buffer) => {
         const fileNameToDescriptor: { [key: string]: FileDescriptorProto } = {};
 
         const parameter = codeGenRequest.getParameter();
-        const { service, mode } = getParameterEnums(parameter);
+        const { service, mode } = getParameterEnums(parameter as string);
 
         const generateGrpcWebServices = service === ServiceParameter.GrpcWeb;
         const generateGrpcNodeServices = service === ServiceParameter.GrpcNode;
 
         codeGenRequest.getProtoFileList().forEach((protoFileDescriptor) => {
-            fileNameToDescriptor[protoFileDescriptor.getName()] = protoFileDescriptor;
+            fileNameToDescriptor[
+                protoFileDescriptor.getName() as string
+            ] = protoFileDescriptor;
             exportMap.addFileDescriptor(protoFileDescriptor);
         });
 

src/ts-protoc-gen/service/common.ts

@@ -33,13 +33,13 @@ function getCallingTypes(
     return {
         requestType: getFieldType(
             MESSAGE_TYPE,
-            method.getInputType().slice(1),
+            (method.getInputType() as string).slice(1),
             '',
             exportMap
         ),
         responseType: getFieldType(
             MESSAGE_TYPE,
-            method.getOutputType().slice(1),
+            (method.getOutputType() as string).slice(1),
             '',
             exportMap
         ),
@@ -94,7 +94,7 @@ export class RPCDescriptor {
         this.exportMap = exportMap;
     }
     get name(): string {
-        return this.protoService.getName();
+        return this.protoService.getName() as string;
     }
 
     get qualifiedName(): string {
@@ -107,15 +107,15 @@ export class RPCDescriptor {
     get methods(): RPCMethodDescriptor[] {
         return this.protoService.getMethodList().map((method) => {
             const callingTypes = getCallingTypes(method, this.exportMap);
-            const nameAsCamelCase =
+            const name = method.getName() as string;
-                method.getName()[0].toLowerCase() + method.getName().substr(1);
+            const nameAsCamelCase = name[0].toLowerCase() + name.substr(1);
             return {
-                nameAsPascalCase: method.getName(),
+                nameAsPascalCase: name,
                 nameAsCamelCase,
                 functionName: normaliseFieldObjectName(nameAsCamelCase),
                 serviceName: this.name,
-                requestStream: method.getClientStreaming(),
+                requestStream: method.getClientStreaming() as boolean,
-                responseStream: method.getServerStreaming(),
+                responseStream: method.getServerStreaming() as boolean,
                 requestType: callingTypes.requestType,
                 responseType: callingTypes.responseType,
             };
@@ -131,15 +131,15 @@ export class GrpcServiceDescriptor {
     constructor(fileDescriptor: FileDescriptorProto, exportMap: ExportMap) {
         this.fileDescriptor = fileDescriptor;
         this.exportMap = exportMap;
-        this.pathToRoot = getPathToRoot(fileDescriptor.getName());
+        this.pathToRoot = getPathToRoot(fileDescriptor.getName() as string);
     }
 
     get filename(): string {
-        return this.fileDescriptor.getName();
+        return this.fileDescriptor.getName() as string;
     }
 
     get packageName(): string {
-        return this.fileDescriptor.getPackage();
+        return this.fileDescriptor.getPackage() as string;
     }
 
     get imports(): ImportDescriptor[] {

src/ts-protoc-gen/ts/enum.ts

@@ -8,7 +8,7 @@ export function printEnum(enumDescriptor: EnumDescriptorProto, indentLevel: numb
     printer.printLn(`export interface ${enumInterfaceName} {`);
     enumDescriptor.getValueList().forEach((value) => {
         printer.printIndentedLn(
-            `${value.getName().toUpperCase()}: ${value.getNumber()};`
+            `${(value.getName() as string).toUpperCase()}: ${value.getNumber()};`
         );
     });
     printer.printLn(`}`);

src/ts-protoc-gen/ts/extensions.ts

@@ -12,10 +12,10 @@ export function printExtension(
 ): string {
     const printer = new Printer(indentLevel + 1);
     printer.printEmptyLn();
-    const extensionName = snakeToCamel(extension.getName());
+    const extensionName = snakeToCamel(extension.getName() as string);
     const fieldType = getFieldType(
-        extension.getType(),
+        extension.getType() as FieldDescriptorProto.Type,
-        extension.getTypeName().slice(1),
+        (extension.getTypeName() as string).slice(1),
         fileName,
         exportMap
     );

src/ts-protoc-gen/ts/fileDescriptorTSD.ts

@@ -11,8 +11,8 @@ export function printFileDescriptorTSD(
     fileDescriptor: FileDescriptorProto,
     exportMap: ExportMap
 ) {
-    const fileName = fileDescriptor.getName();
+    const fileName = fileDescriptor.getName() as string;
-    const packageName = fileDescriptor.getPackage();
+    const packageName = fileDescriptor.getPackage() as string;
 
     const printer = new Printer(0);
 

src/ts-protoc-gen/ts/message.ts

@@ -77,7 +77,7 @@ export function printMessage(
 
     messageDescriptor.getFieldList().forEach((field) => {
         if (field.hasOneofIndex()) {
-            const oneOfIndex = field.getOneofIndex();
+            const oneOfIndex = field.getOneofIndex() as number;
             let existing = oneOfGroups[oneOfIndex];
             if (existing === undefined) {
                 existing = [];
@@ -85,13 +85,13 @@ export function printMessage(
             }
             existing.push(field);
         }
-        const snakeCaseName = stripPrefix(field.getName().toLowerCase(), '_');
+        const snakeCaseName = stripPrefix((field.getName() as string).toLowerCase(), '_');
         const camelCaseName = snakeToCamel(snakeCaseName);
         const withUppercase = uppercaseFirst(camelCaseName);
         const type = field.getType();
 
         let exportType;
-        const fullTypeName = field.getTypeName().slice(1);
+        const fullTypeName = (field.getTypeName() as string).slice(1);
         if (type === MESSAGE_TYPE) {
             const fieldMessageType = exportMap.getMessage(fullTypeName);
             if (fieldMessageType === undefined) {
@@ -168,8 +168,9 @@ export function printMessage(
             }
             exportType = `${exportType}Map[keyof ${exportType}Map]`;
         } else {
-            if (field.getOptions() && field.getOptions().hasJstype()) {
+            const options = field.getOptions() as FieldOptions;
-                switch (field.getOptions().getJstype()) {
+            if (options && options.hasJstype()) {
+                switch (options.getJstype()) {
                     case JSType.JS_NUMBER:
                         exportType = 'number';
                         break;
@@ -177,10 +178,10 @@ export function printMessage(
                         exportType = 'string';
                         break;
                     default:
-                        exportType = getTypeName(type);
+                        exportType = getTypeName((type as unknown) as number);
                 }
             } else {
-                exportType = getTypeName(type);
+                exportType = getTypeName((type as unknown) as number);
             }
         }
 
@@ -293,10 +294,9 @@ export function printMessage(
     toObjectType.printLn(`}`);
 
     messageDescriptor.getOneofDeclList().forEach((oneOfDecl) => {
+        const name = oneOfDecl.getName() as string;
         printer.printIndentedLn(
-            `get${oneOfName(oneOfDecl.getName())}Case(): ${messageName}.${oneOfName(
+            `get${oneOfName(name)}Case(): ${messageName}.${oneOfName(name)}Case;`
-                oneOfDecl.getName()
-            )}Case;`
         );
     });
 

src/ts-protoc-gen/ts/oneof.ts

@@ -12,11 +12,15 @@ export function printOneOfDecl(
 ) {
     const printer = new Printer(indentLevel);
     printer.printEmptyLn();
-    printer.printLn(`export enum ${oneOfName(oneOfDecl.getName())}Case {`);
+    printer.printLn(`export enum ${oneOfName(oneOfDecl.getName() as string)}Case {`);
-    printer.printIndentedLn(`${oneOfDecl.getName().toUpperCase()}_NOT_SET = 0,`);
+    printer.printIndentedLn(
+        `${(oneOfDecl.getName() as string).toUpperCase()}_NOT_SET = 0,`
+    );
     oneOfFields.forEach((field) => {
         printer.printIndentedLn(
-            `${field.getName().toUpperCase()} = ${field.getNumber()},`
+            `${(field.getName() as string).toUpperCase()} = ${
+                field.getNumber() as number
+            },`
         );
     });
     printer.printLn('}');

src/ts-protoc-gen/util.ts

@@ -76,12 +76,13 @@ export function withAllStdIn(callback: (buffer: Buffer) => void): void {
 
     const stdin = process.stdin;
     stdin.on('readable', function () {
-        let chunk;
+        let chunk = stdin.read();
 
-        while ((chunk = stdin.read())) {
+        while (chunk) {
             if (!(chunk instanceof Buffer)) throw new Error('Did not receive buffer');
             ret.push(chunk);
             len += chunk.length;
+            chunk = stdin.read();
         }
     });
 
@@ -194,7 +195,7 @@ export function getParameterEnums(
 } {
     const { service, mode } = parse(parameter, ',');
     return {
-        service: getServiceParameter(service),
+        service: getServiceParameter(service as string),
-        mode: getModeParameter(mode),
+        mode: getModeParameter(mode as string),
     };
 }