From 6c8c10fbeaa1aedc49dfa59b9740707d44ac4bda Mon Sep 17 00:00:00 2001
From: Andreas Krennmair <andreas.krennmair@fraud0.com>
Date: Mon, 2 Dec 2024 16:37:20 +0100
Subject: [PATCH] Generate dummy encode and decode methods if the MessageFns
 interface requires it

---
 .../request_response.ts                       | 12 ++++
 src/main.ts                                   | 56 +++++++++++++++----
 2 files changed, 56 insertions(+), 12 deletions(-)

diff --git a/integration/output-encode-decode-include-types-combined/request_response.ts b/integration/output-encode-decode-include-types-combined/request_response.ts
index 536c5979b..ddae1aa92 100644
--- a/integration/output-encode-decode-include-types-combined/request_response.ts
+++ b/integration/output-encode-decode-include-types-combined/request_response.ts
@@ -33,6 +33,10 @@ export const Request: MessageFns<Request> = {
     }
     return writer;
   },
+
+  decode(_: BinaryReader | Uint8Array, length?: number): Request {
+    throw new Error("decode not generated for Request");
+  },
 };
 
 function createBaseRequest_Nested(): Request_Nested {
@@ -46,6 +50,10 @@ export const Request_Nested: MessageFns<Request_Nested> = {
     }
     return writer;
   },
+
+  decode(_: BinaryReader | Uint8Array, length?: number): Request_Nested {
+    throw new Error("decode not generated for Request_Nested");
+  },
 };
 
 function createBaseResponse(): Response {
@@ -53,6 +61,10 @@ function createBaseResponse(): Response {
 }
 
 export const Response: MessageFns<Response> = {
+  encode(_: Response, writer: BinaryWriter = new BinaryWriter()): BinaryWriter {
+    throw new Error("encode not generated for Response");
+  },
+
   decode(input: BinaryReader | Uint8Array, length?: number): Response {
     const reader = input instanceof BinaryReader ? input : new BinaryReader(input);
     let end = length === undefined ? reader.len : reader.pos + length;
diff --git a/src/main.ts b/src/main.ts
index b60c71305..d81e7ffb2 100644
--- a/src/main.ts
+++ b/src/main.ts
@@ -236,26 +236,32 @@ export function generateFile(ctx: Context, fileDesc: FileDescriptorProto): [stri
           if (
             (options.outputEncodeMethods === true ||
               options.outputEncodeMethods === "encode-only" ||
-              options.outputEncodeMethods === "encode-no-creation") &&
-            (options.outputEncodeIncludeTypes === "" || new RegExp(options.outputEncodeIncludeTypes).test(fullTypeName))
+              options.outputEncodeMethods === "encode-no-creation")
           ) {
-            staticMembers.push(generateEncode(ctx, fullName, message));
+            if (options.outputEncodeIncludeTypes === "" || new RegExp(options.outputEncodeIncludeTypes).test(fullTypeName)) {
+              staticMembers.push(generateEncode(ctx, fullName, message));
 
-            if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
-              staticMembers.push(generateSetExtension(ctx, fullName));
+              if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
+                staticMembers.push(generateSetExtension(ctx, fullName));
+              }
+            } else if (options.outputEncodeMethods === true) {
+              staticMembers.push(generateEmptyEncode(fullName));
             }
           }
-          if (
-            (options.outputEncodeMethods === true || options.outputEncodeMethods === "decode-only") &&
-            (options.outputDecodeIncludeTypes === "" || new RegExp(options.outputDecodeIncludeTypes).test(fullTypeName))
-          ) {
-            staticMembers.push(generateDecode(ctx, fullName, message));
 
-            if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
-              staticMembers.push(generateGetExtension(ctx, fullName));
+          if (options.outputEncodeMethods === true || options.outputEncodeMethods === "decode-only") {
+            if (options.outputDecodeIncludeTypes === "" || new RegExp(options.outputDecodeIncludeTypes).test(fullTypeName)) {
+              staticMembers.push(generateDecode(ctx, fullName, message));
+
+              if (options.outputExtensions && options.unknownFields && message.extensionRange.length) {
+                staticMembers.push(generateGetExtension(ctx, fullName));
+              }
+            } else if (options.outputEncodeMethods === true) {
+              staticMembers.push(generateEmptyDecode(fullName));
             }
           }
         }
+
         if (options.useAsyncIterable) {
           staticMembers.push(generateEncodeTransform(ctx.utils, fullName));
           staticMembers.push(generateDecodeTransform(ctx.utils, fullName));
@@ -1354,6 +1360,19 @@ function getDecodeReadSnippet(ctx: Context, field: FieldDescriptorProto) {
   return readSnippet;
 }
 
+function generateEmptyDecode(fullName: string): Code {
+  const BinaryReader = imp("BinaryReader@@bufbuild/protobuf/wire");
+
+  return code`
+    decode(
+      _: ${BinaryReader} | Uint8Array,
+      length?: number,
+    ): ${fullName} {
+      throw new Error('decode not generated for ${fullName}');
+    }
+  `;
+}
+
 /** Creates a function to decode a message by loop overing the tags. */
 function generateDecode(ctx: Context, fullName: string, messageDesc: DescriptorProto): Code {
   const { options, currentFile } = ctx;
@@ -1636,6 +1655,19 @@ function getEncodeWriteSnippet(ctx: Context, field: FieldDescriptorProto): (plac
   }
 }
 
+function generateEmptyEncode(fullName: string): Code {
+  const BinaryWriter = imp("BinaryWriter@@bufbuild/protobuf/wire");
+
+  return code`
+  encode(
+    _: ${fullName},
+    writer: ${BinaryWriter} = new ${BinaryWriter}(),
+  ): ${BinaryWriter} {
+    throw new Error('encode not generated for ${fullName}');
+  }
+  `;
+}
+
 /** Creates a function to encode a message by loop overing the tags. */
 function generateEncode(ctx: Context, fullName: string, messageDesc: DescriptorProto): Code {
   const { options, utils, typeMap, currentFile } = ctx;