Add support for oneof custom options

MANUAL.md

@@ -1030,7 +1030,7 @@ operations.
 
 ## Custom options
 
-`protobuf-ts` supports custom options for messages, fields, services 
+`protobuf-ts` supports custom options for messages, oneofs, fields, services 
 and methods and will add them to the reflection information. 
 
 For example, consider the following service definition in 
@@ -1110,6 +1110,7 @@ let rule: JsonValue | undefined = readMethodOption(AnnotatedService, "get", "goo
 | Options for | stored in                             | access with                                         |
 |-------------|---------------------------------------|-----------------------------------------------------|
 | Messages    | `AnnotatedMessage.options`            | `readMessageOption()` from @protobuf-ts/runtime     |
+| Oneofs      | `AnnotatedMessage.oneofOptions[name]` | `readOneofOption()` from @protobuf-ts/runtime       |
 | Fields      | `AnnotatedMessage.field[0].options`   | `readFieldOption()` from @protobuf-ts/runtime       |
 | Services    | `AnnotatedService.options`            | `readServiceOption()` from @protobuf-ts/runtime-rpc |
 | Methods     | `AnnotatedService.methods[0].options` | `readMethodOption()` from @protobuf-ts/runtime-rpc  |

packages/plugin/src/code-gen/message-type-generator.ts

@@ -92,11 +92,23 @@ export class MessageTypeGenerator extends GeneratorBase {
                 this.fieldInfoGenerator.createFieldInfoLiterals(source, interpreterType.fields)
             ];
 
-        // if present, add message options in json format to MessageType CTOR args
-        if (Object.keys(interpreterType.options).length) {
+        const hasMessageOptions = Object.keys(interpreterType.options).length;
+        const hasOneofOptions = Object.keys(interpreterType.oneofOptions).length;
+        // if present, add message/oneof options in json format to MessageType CTOR args
+        if (hasMessageOptions) {
             classDecSuperArgs.push(
                 typescriptLiteralFromValue(interpreterType.options)
             );
+            if (hasOneofOptions) {
+                classDecSuperArgs.push(
+                    typescriptLiteralFromValue(interpreterType.oneofOptions)
+                );
+            }
+        } else if (hasOneofOptions) {
+            classDecSuperArgs.push(
+                typescriptLiteralFromValue({}),
+                typescriptLiteralFromValue(interpreterType.oneofOptions)
+            );
         }
 
         // "MyMessage$Type" constructor() { super(...) }

packages/plugin/src/interpreter.ts

@@ -1,7 +1,9 @@
 import {
+    AnyDescriptorProto,
     DescriptorProto,
     DescriptorRegistry,
     EnumDescriptorProto,
+    EnumValueDescriptorProto,
     FieldDescriptorProto,
     FieldOptions_JSType,
     FileDescriptorProto,
@@ -17,11 +19,6 @@ import { FieldInfoGenerator } from "./code-gen/field-info-generator";
 import {OurFileOptions, OurServiceOptions, readOurFileOptions, readOurServiceOptions} from "./our-options";
 
 
-type JsonOptionsMap = {
-    [extensionName: string]: rt.JsonValue
-}
-
-
 /**
  * The protobuf-ts plugin generates code for message types from descriptor
  * protos. This class also creates message types from descriptor protos, but
@@ -86,7 +83,19 @@ export class Interpreter {
      * Note that options on options (google.protobuf.*Options) are not
      * supported.
      */
-    readOptions(descriptor: FieldDescriptorProto | MethodDescriptorProto | FileDescriptorProto | ServiceDescriptorProto | DescriptorProto, excludeOptions: readonly string[]): JsonOptionsMap | undefined {
+    readOptions(descriptor: FileDescriptorProto, excludeOptions: readonly string[], knownOptionTypeName: 'FileOptions'): rt.JsonOptionsMap | undefined
+    readOptions(descriptor: DescriptorProto, excludeOptions: readonly string[], knownOptionTypeName: 'MessageOptions'): rt.JsonOptionsMap | undefined
+    readOptions(descriptor: FieldDescriptorProto, excludeOptions: readonly string[], knownOptionTypeName: 'FieldOptions'): rt.JsonOptionsMap | undefined
+    readOptions(descriptor: OneofDescriptorProto, excludeOptions: readonly string[], knownOptionTypeName: 'OneofOptions'): rt.JsonOptionsMap | undefined
+    readOptions(descriptor: EnumDescriptorProto, excludeOptions: readonly string[], knownOptionTypeName: 'EnumOptions'): rt.JsonOptionsMap | undefined
+    readOptions(descriptor: EnumValueDescriptorProto, excludeOptions: readonly string[], knownOptionTypeName: 'EnumValueOptions'): rt.JsonOptionsMap | undefined
+    readOptions(descriptor: ServiceDescriptorProto, excludeOptions: readonly string[], knownOptionTypeName: 'ServiceOptions'): rt.JsonOptionsMap | undefined
+    readOptions(descriptor: MethodDescriptorProto, excludeOptions: readonly string[], knownOptionTypeName: 'MethodOptions'): rt.JsonOptionsMap | undefined
+    readOptions(
+        descriptor: AnyDescriptorProto,
+        excludeOptions: readonly string[],
+        knownOptionTypeName?: 'FileOptions' | 'MessageOptions' | 'FieldOptions' | 'OneofOptions' | 'EnumOptions' | 'EnumValueOptions' | 'ServiceOptions' | 'MethodOptions'
+    ): rt.JsonOptionsMap | undefined {
 
         // the option to force exclude all options takes precedence
         if (this.options.forceExcludeAllOptions) {
@@ -105,7 +114,11 @@ export class Interpreter {
         }
 
         let optionsTypeName: string;
-        if (FieldDescriptorProto.is(descriptor) && DescriptorProto.is(this.registry.parentOf(descriptor))) {
+        if (knownOptionTypeName) {
+            optionsTypeName = `google.protobuf.${knownOptionTypeName}`;
+        } else if (OneofDescriptorProto.is(descriptor) && DescriptorProto.is(this.registry.parentOf(descriptor))) {
+            optionsTypeName = 'google.protobuf.OneofOptions';
+        } else if (FieldDescriptorProto.is(descriptor) && DescriptorProto.is(this.registry.parentOf(descriptor))) {
             optionsTypeName = 'google.protobuf.FieldOptions';
         } else if (MethodDescriptorProto.is(descriptor)) {
             optionsTypeName = 'google.protobuf.MethodOptions';
@@ -201,29 +214,41 @@ export class Interpreter {
         if (!type) {
 
             // Create and store the message type
-            const optionsPlaceholder: JsonOptionsMap = {};
+            const oneofOptions: {[oneof: string]: rt.JsonOptionsMap} = {};
+            const optionsPlaceholder: rt.JsonOptionsMap = {};
             type = new rt.MessageType(
                 typeName,
                 this.buildFieldInfos(descriptor.field),
-                optionsPlaceholder
+                optionsPlaceholder,
+                oneofOptions
             );
             this.messageTypes.set(typeName, type);
 
             const ourFileOptions = this.readOurFileOptions(this.registry.fileOf(descriptor));
+            const excludeOptions = ourFileOptions["ts.exclude_options"];
 
             // add message options *after* storing, so that the option can refer to itself
-            const messageOptions = this.readOptions(descriptor, ourFileOptions["ts.exclude_options"]);
+            const messageOptions = this.readOptions(descriptor, excludeOptions, 'MessageOptions');
             if (messageOptions) {
                 for (let key of Object.keys(messageOptions)) {
                     optionsPlaceholder[key] = messageOptions[key];
                 }
             }
 
+            // same for oneof options
+            for (let i = 0; i < descriptor.oneofDecl.length; i++) {
+                const od = descriptor.oneofDecl[i];
+                const oneofOpt = this.readOptions(od, excludeOptions, 'OneofOptions');
+                if (oneofOpt) {
+                    oneofOptions[this.createTypescriptNameForField(od)] = oneofOpt;
+                }
+            }
+
             // same for field options
             for (let i = 0; i < type.fields.length; i++) {
                 const fd = descriptor.field[i];
                 const fi = type.fields[i];
-                fi.options = this.readOptions(fd, ourFileOptions["ts.exclude_options"]);
+                fi.options = this.readOptions(fd, excludeOptions, 'FieldOptions');
             }
 
         }
@@ -295,7 +320,7 @@ export class Interpreter {
         return new rpc.ServiceType(
             typeName,
             methods.map(m => this.buildMethodInfo(m, excludeOptions)),
-            this.readOptions(desc, excludeOptions)
+            this.readOptions(desc, excludeOptions, 'ServiceOptions')
         );
     }
 
@@ -340,7 +365,7 @@ export class Interpreter {
         info.O = this.getMessageType(methodDescriptor.outputType);
 
         // options: Contains custom method options from the .proto source in JSON format.
-        info.options = this.readOptions(methodDescriptor, excludeOptions);
+        info.options = this.readOptions(methodDescriptor, excludeOptions, 'MethodOptions');
 
         return info as rpc.PartialMethodInfo;
     }

packages/proto/msg-annotated.proto

@@ -35,6 +35,10 @@ extend google.protobuf.MessageOptions {
 
 }
 
+extend google.protobuf.OneofOptions {
+    int32 opt_oneof = 1501;
+}
+
 
 // Used for options
 enum OptionEnum {
@@ -91,5 +95,12 @@ message AnnotatedMessage {
     // annotated with a field option defined right in the message
     int32 ann_local = 10 [(spec.AnnotatedMessage.local_opt) = true];
 
+    oneof ann_oneof {
+
+        option (spec.opt_oneof) = -99;
+
+        bool example = 11;
+    }
+
 }
 

packages/runtime/spec/reflection-merge-partial.spec.ts

@@ -98,6 +98,7 @@ describe('reflectionMergePartial()', () => {
                     normalizeFieldInfo({kind: "message", T: () => childHandler, no: 1, name: 'child'}),
                     normalizeFieldInfo({kind: "message", T: () => childHandler, no: 2, name: 'children', repeat: RepeatType.UNPACKED}),
                 ],
+                oneofOptions: {},
                 options: {}
             };
         });

packages/runtime/spec/support/helpers.ts

@@ -58,6 +58,7 @@ export function stubMessageType(name = '.test.Message'): IMessageType<any> {
         typeName: name,
         fields: [],
         options: {},
+        oneofOptions: {},
         create(value?: any): any {
             throw new Error('just a stub');
         },

packages/runtime/src/index.ts

@@ -48,13 +48,16 @@ export {
     LongType,
     RepeatType,
     MessageInfo,
+    JsonOptionsMap,
+    OneofOptions,
     EnumInfo,
     FieldInfo,
     PartialFieldInfo,
     normalizeFieldInfo,
     readFieldOptions,
     readFieldOption,
-    readMessageOption
+    readMessageOption,
+    readOneofOption
 } from './reflection-info';
 
 // Types for messsage objects type at runtime, when concrete type is unknown.

packages/runtime/src/message-type-contract.ts

@@ -1,4 +1,4 @@
-import type {FieldInfo, MessageInfo} from "./reflection-info";
+import type {FieldInfo, MessageInfo, JsonOptionsMap, OneofOptions} from "./reflection-info";
 import type {BinaryReadOptions, BinaryWriteOptions, IBinaryReader, IBinaryWriter} from "./binary-format-contract";
 import type {JsonValue} from "./json-typings";
 import type {JsonReadOptions, JsonWriteOptions, JsonWriteStringOptions} from "./json-format-contract";
@@ -56,7 +56,13 @@ export interface IMessageType<T extends object> extends MessageInfo {
     /**
      * Contains custom message options from the .proto source in JSON format.
      */
-    readonly options: { [extensionName: string]: JsonValue };
+    readonly options: JsonOptionsMap;
+
+    /**
+     * Contains custom oneof options from the .proto source in JSON format
+     * indexed by oneof name.
+     */
+    readonly oneofOptions: OneofOptions;
 
 
     /**

packages/runtime/src/message-type.ts

@@ -1,5 +1,5 @@
 import type {IMessageType, PartialMessage} from "./message-type-contract";
-import type {FieldInfo, PartialFieldInfo} from "./reflection-info";
+import type {JsonOptionsMap, OneofOptions, FieldInfo, PartialFieldInfo} from "./reflection-info";
 import {normalizeFieldInfo} from "./reflection-info";
 import {ReflectionTypeCheck} from "./reflection-type-check";
 import {ReflectionJsonReader} from "./reflection-json-reader";
@@ -45,10 +45,16 @@ export class MessageType<T extends object> implements IMessageType<T> {
     readonly fields: readonly FieldInfo[];
 
     /**
-     * Contains custom service options from the .proto source in JSON format.
+     * Contains custom message options from the .proto source in JSON format.
      */
     readonly options: JsonOptionsMap;
 
+    /**
+     * Contains custom oneof options from the .proto source in JSON format
+     * indexed by oneof name.
+     */
+    readonly oneofOptions: OneofOptions;
+
 
     protected readonly defaultCheckDepth = 16;
     protected readonly refTypeCheck: ReflectionTypeCheck;
@@ -57,10 +63,11 @@ export class MessageType<T extends object> implements IMessageType<T> {
     protected readonly refBinReader: ReflectionBinaryReader;
     protected readonly refBinWriter: ReflectionBinaryWriter;
 
-    constructor(name: string, fields: readonly PartialFieldInfo[], options?: JsonOptionsMap) {
+    constructor(name: string, fields: readonly PartialFieldInfo[], options?: JsonOptionsMap, oneofOptions?: OneofOptions) {
         this.typeName = name;
         this.fields = fields.map(normalizeFieldInfo);
         this.options = options ?? {};
+        this.oneofOptions = oneofOptions ?? {};
         this.refTypeCheck = new ReflectionTypeCheck(this);
         this.refJsonReader = new ReflectionJsonReader(this);
         this.refJsonWriter = new ReflectionJsonWriter(this);
@@ -258,8 +265,3 @@ export class MessageType<T extends object> implements IMessageType<T> {
     }
 
 }
-
-
-type JsonOptionsMap = {
-    [extensionName: string]: JsonValue;
-};

packages/runtime/src/reflection-info.ts

@@ -60,6 +60,21 @@ export type EnumInfo = readonly [
     string?
 ];
 
+/**
+ * Contains custom options from the .proto source in JSON format
+ * indexed by extension name.
+ */
+export interface JsonOptionsMap {
+    [extensionName: string]: JsonValue;
+}
+
+/**
+ * Contains custom oneof options from the .proto source in JSON format
+ * indexed by oneof name.
+ */
+export interface OneofOptions {
+    readonly [oneof: string]: JsonOptionsMap | undefined;
+}
 
 /**
  * Describes a protobuf message for runtime reflection.
@@ -89,7 +104,13 @@ export interface MessageInfo {
     /**
      * Contains custom message options from the .proto source in JSON format.
      */
-    readonly options: { [extensionName: string]: JsonValue };
+    readonly options: JsonOptionsMap;
+
+    /**
+     * Contains custom oneof options from the .proto source in JSON format
+     * indexed by oneof name.
+     */
+    readonly oneofOptions: OneofOptions;
 
 }
 
@@ -99,8 +120,9 @@ export interface MessageInfo {
  * to be omitted:
  * - "fields": omitting means the message has no fields
  * - "options": omitting means the message has no options
+ * - "oneofOptions": omitting means the message has no oneof options
  */
-export type PartialMessageInfo = PartialPartial<MessageInfo, "fields" | "options">;
+export type PartialMessageInfo = PartialPartial<MessageInfo, "fields" | "options" | "oneofOptions">;
 
 // Make all properties in T optional, except those whose keys are in the union K.
 type PartialPartial<T, K extends keyof T> = Partial<Pick<T, K>> & Omit<T, K>;
@@ -193,7 +215,7 @@ interface fiShared {
     /**
      * Contains custom field options from the .proto source in JSON format.
      */
-    options?: { [extensionName: string]: JsonValue };
+    options?: JsonOptionsMap;
 
 }
 
@@ -494,3 +516,33 @@ export function readMessageOption<T extends object>(messageType: MessageInfo, ex
     }
     return extensionType ? extensionType.fromJson(optionVal) : optionVal;
 }
+
+/**
+ * Read a custom oneof option.
+ *
+ * ```proto
+ * message MyMessage {
+ *   oneof my_oneof {
+ *     option (acme.oneof_opt) = true;
+ *     int32 my_field = 1;
+ *   }
+ * }
+ * ```
+ *
+ * ```typescript
+ * let val = readOneofOption(MyMessage, 'my_oneof', 'acme.oneof_opt')
+ * ```
+ */
+export function readOneofOption<T extends object>(messageType: MessageInfo, oneofName: string, extensionName: string): JsonValue | undefined;
+export function readOneofOption<T extends object>(messageType: MessageInfo, oneofName: string, extensionName: string, extensionType: IMessageType<T>): T | undefined;
+export function readOneofOption<T extends object>(messageType: MessageInfo, oneofName: string, extensionName: string, extensionType?: IMessageType<T>): T | JsonValue | undefined {
+    const options = messageType.oneofOptions[oneofName];
+    if (!options) {
+        return undefined;
+    }
+    const optionVal = options[extensionName];
+    if (optionVal === undefined) {
+        return optionVal;
+    }
+    return extensionType ? extensionType.fromJson(optionVal) : optionVal;
+}