ts-proto 1.179.0 → 1.180.0

package/README.markdown

@@ -754,7 +754,7 @@ ts-protoc --ts_proto_out=./output -I=./protos ./protoc/*.proto
 # Todo
 
 - Support the string-based encoding of duration in `fromJSON`/`toJSON`
-- Make `oneof=unions` the default behavior in 2.0
+- Make `oneof=unions-value` the default behavior in 2.0
 - Probably change `forceLong` default in 2.0, should default to `forceLong=long`
 - Make `esModuleInterop=true` the default in 2.0
 
@@ -772,11 +772,11 @@ Will generate a `Foo` type with two fields: `field_a: string | undefined;` and `
 
 With this output, you'll have to check both `if object.field_a` and `if object.field_b`, and if you set one, you'll have to remember to unset the other.
 
-Instead, we recommend using the `oneof=unions` option, which will change the output to be an Abstract Data Type/ADT like:
+Instead, we recommend using the `oneof=unions-value` option, which will change the output to be an Abstract Data Type/ADT like:
 
 ```typescript
 interface YourMessage {
-  eitherField?: { $case: "field_a"; field_a: string } | { $case: "field_b"; field_b: string };
+  eitherField?: { $case: "field_a"; value: string } | { $case: "field_b"; value: string };
 }
 ```
 
@@ -784,11 +784,21 @@ As this will automatically enforce only one of `field_a` or `field_b` "being set
 
 (Note that `eitherField` is optional b/c `oneof` in Protobuf means "at most one field" is set, and does not mean one of the fields _must_ be set.)
 
-In ts-proto's currently-unscheduled 2.x release, `oneof=unions` will become the default behavior.
+In ts-proto's currently-unscheduled 2.x release, `oneof=unions-value` will become the default behavior.
+
+There is also a `oneof=unions` option, which generates a union where the field names are included in each option:
+
+```typescript
+interface YourMessage {
+  eitherField?: { $case: "field_a"; field_a: string } | { $case: "field_b"; field_b: string };
+}
+```
+
+This is no longer recommended as it can be difficult to write code and types to handle multiple oneof options:
 
 ## OneOf Type Helpers
 
-The following helper types may make it easier to work with the types generated from `oneof=unions`:
+The following helper types may make it easier to work with the types generated from `oneof=unions`, though they are generally not needed if you use `oneof=unions-value`:
 
 ```ts
 /** Extracts all the case names from a oneOf field. */
@@ -799,19 +809,45 @@ type OneOfValues<T> = T extends { $case: infer U extends string; [key: string]:
 
 /** Extracts the specific type of a oneOf case based on its field name */
 type OneOfCase<T, K extends OneOfCases<T>> = T extends {
+  $case: K;
+  [key: string]: unknown;
+}
+  ? T
+  : never;
+
+/** Extracts the specific type of a value type from a oneOf field */
+type OneOfValue<T, K extends OneOfCases<T>> = T extends {
   $case: infer U extends K;
   [key: string]: unknown;
 }
   ? T[U]
   : never;
+```
 
-/** Extracts the specific type of a value type from a oneOf field */
-export type OneOfValue<T, K extends OneOfCases<T>> = T extends {
+For comparison, the equivalents for `oneof=unions-value`:
+
+```ts
+/** Extracts all the case names from a oneOf field. */
+type OneOfCases<T> = T['$case'];
+
+/** Extracts a union of all the value types from a oneOf field */
+type OneOfValues<T> = T['value'];
+
+/** Extracts the specific type of a oneOf case based on its field name */
+type OneOfCase<T, K extends OneOfCases<T>> = T extends {
   $case: K;
   [key: string]: unknown;
 }
   ? T
   : never;
+
+/** Extracts the specific type of a value type from a oneOf field */
+type OneOfValue<T, K extends OneOfCases<T>> = T extends {
+  $case: infer U extends K;
+  value: unknown;
+}
+  ? T[U]
+  : never;
 ```
 
 # Default values and unset fields

package/build/generate-struct-wrappers.js

@@ -193,6 +193,27 @@ function generateWrapShallow(ctx, fullProtoTypeName, fieldNames) {
           throw new ${ctx.utils.globalThis}.Error('Unsupported any value type: ' + typeof value);
         }
         return result;
+    }`);
+        }
+        else if (ctx.options.oneof === options_1.OneofOption.UNIONS_VALUE) {
+            chunks.push((0, ts_poet_1.code) `wrap(value: any): Value {
+        const result = createBaseValue()${maybeAsAny(ctx.options)};
+        if (value === null) {
+          result.kind = {$case: '${fieldNames.nullValue}', value };
+        } else if (typeof value === 'boolean') {
+          result.kind = {$case: '${fieldNames.boolValue}', value };
+        } else if (typeof value === 'number') {
+          result.kind = {$case: '${fieldNames.numberValue}', value };
+        } else if (typeof value === 'string') {
+          result.kind = {$case: '${fieldNames.stringValue}', value };
+        } else if (${ctx.utils.globalThis}.Array.isArray(value)) {
+          result.kind = {$case: '${fieldNames.listValue}', value };
+        } else if (typeof value === 'object') {
+          result.kind = {$case: '${fieldNames.structValue}', value };
+        } else if (typeof value !== 'undefined') {
+          throw new ${ctx.utils.globalThis}.Error('Unsupported any value type: ' + typeof value);
+        }
+        return result;
     }`);
         }
         else {
@@ -284,6 +305,11 @@ function generateUnwrapShallow(ctx, fullProtoTypeName, fieldNames) {
         } else {
           return undefined;
         }
+      }`);
+        }
+        else if (ctx.options.oneof === options_1.OneofOption.UNIONS_VALUE) {
+            chunks.push((0, ts_poet_1.code) `unwrap(message: Value): string | number | boolean | Object | null | Array<any> | undefined {
+        return message.kind?.value;
       }`);
         }
         else {

package/build/main.js

@@ -448,6 +448,12 @@ function makeDeepPartial(options, longs) {
       ? { [K in keyof Omit<T, '$case'>]?: DeepPartial<T[K]> } & { ${maybeReadonly(options)}$case: T['$case'] }
     `;
     }
+    else if (options.oneof === options_1.OneofOption.UNIONS_VALUE) {
+        oneofCase = `
+      : T extends { ${maybeReadonly(options)}$case: string; value: unknown; }
+      ? { ${maybeReadonly(options)}$case: T['$case']; value?: DeepPartial<T['value']>; }
+    `;
+    }
     const maybeExport = options.exportCommonSymbols ? "export" : "";
     // Allow passing longs as numbers or strings, nad we'll convert them
     const maybeLong = options.forceLong === options_1.LongOption.LONG ? (0, ts_poet_1.code) ` : T extends ${longs.Long} ? string | number | Long ` : "";
@@ -711,7 +717,8 @@ function generateOneofProperty(ctx, messageDesc, oneofIndex, sourceInfo) {
     const unionType = (0, ts_poet_1.joinCode)(fields.map((f) => {
         let fieldName = (0, case_1.maybeSnakeToCamel)(f.name, options);
         let typeName = (0, types_1.toTypeName)(ctx, messageDesc, f);
-        return (0, ts_poet_1.code) `{ ${mbReadonly}$case: '${fieldName}', ${mbReadonly}${fieldName}: ${typeName} }`;
+        let valueName = (0, utils_1.oneofValueName)(fieldName, options);
+        return (0, ts_poet_1.code) `{ ${mbReadonly}$case: '${fieldName}', ${mbReadonly}${valueName}: ${typeName} }`;
     }), { on: " | " });
     const name = (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[oneofIndex].name, options);
     return (0, ts_poet_1.code) `${mbReadonly}${name}?: ${unionType} | ${(0, utils_1.nullOrUndefined)(options)},`;
@@ -979,9 +986,10 @@ function generateDecode(ctx, fullName, messageDesc) {
             const oneofNameWithMessage = options.useJsonName
                 ? messageProperty
                 : (0, utils_1.getPropertyAccessor)("message", (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[field.oneofIndex].name, options));
+            const valueName = (0, utils_1.oneofValueName)(fieldName, options);
             chunks.push((0, ts_poet_1.code) `
         ${tagCheck}
-        ${oneofNameWithMessage} = { $case: '${fieldName}', ${fieldName}: ${readSnippet} };
+        ${oneofNameWithMessage} = { $case: '${fieldName}', ${valueName}: ${readSnippet} };
       `);
         }
         else {
@@ -1267,8 +1275,9 @@ function generateEncode(ctx, fullName, messageDesc) {
                 for (const oneOfField of oneOfFieldsDict[field.oneofIndex]) {
                     const writeSnippet = getEncodeWriteSnippet(ctx, oneOfField);
                     const oneOfFieldName = (0, case_1.maybeSnakeToCamel)(oneOfField.name, ctx.options);
+                    const valueName = (0, utils_1.oneofValueName)(oneOfFieldName, ctx.options);
                     chunks.push((0, ts_poet_1.code) `case "${oneOfFieldName}":
-            ${writeSnippet(`${oneofNameWithMessage}.${oneOfFieldName}`)};
+            ${writeSnippet(`${oneofNameWithMessage}.${valueName}`)};
             break;`);
                 }
                 chunks.push((0, ts_poet_1.code) `}`);
@@ -1761,8 +1770,9 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                 const fieldName = (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[field.oneofIndex].name, options);
                 chunks.push((0, ts_poet_1.code) `${fieldName}: `);
             }
+            const valueName = (0, utils_1.oneofValueName)(fieldKey, options);
             const ternaryIf = (0, ts_poet_1.code) `${ctx.utils.isSet}(${jsonProperty})`;
-            const ternaryThen = (0, ts_poet_1.code) `{ $case: '${fieldName}', ${fieldKey}: ${readSnippet(`${jsonProperty}`)}`;
+            const ternaryThen = (0, ts_poet_1.code) `{ $case: '${fieldName}', ${valueName}: ${readSnippet(`${jsonProperty}`)}`;
             chunks.push((0, ts_poet_1.code) `${ternaryIf} ? ${ternaryThen}} : `);
             if (field === lastCase) {
                 chunks.push((0, ts_poet_1.code) `${(0, utils_1.nullOrUndefined)(options)},`);
@@ -1972,9 +1982,10 @@ function generateToJson(ctx, fullName, fullProtobufTypeName, messageDesc) {
             const oneofNameWithMessage = options.useJsonName
                 ? messageProperty
                 : (0, utils_1.getPropertyAccessor)("message", (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[field.oneofIndex].name, options));
+            const valueName = (0, utils_1.oneofValueName)(fieldName, options);
             chunks.push((0, ts_poet_1.code) `
         if (${oneofNameWithMessage}?.$case === '${fieldName}') {
-          ${jsonProperty} = ${readSnippet(`${oneofNameWithMessage}.${fieldName}`)};
+          ${jsonProperty} = ${readSnippet(`${oneofNameWithMessage}.${valueName}`)};
         }
       `);
         }
@@ -2148,14 +2159,15 @@ function generateFromPartial(ctx, fullName, messageDesc) {
             const oneofName = (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[field.oneofIndex].name, options);
             const oneofNameWithMessage = (0, utils_1.getPropertyAccessor)("message", oneofName);
             const oneofNameWithObject = (0, utils_1.getPropertyAccessor)("object", oneofName);
-            const v = readSnippet(`${oneofNameWithObject}.${fieldName}`);
+            const valueName = (0, utils_1.oneofValueName)(fieldName, options);
+            const v = readSnippet(`${oneofNameWithObject}.${valueName}`);
             chunks.push((0, ts_poet_1.code) `
         if (
           ${oneofNameWithObject}?.$case === '${fieldName}'
-          && ${oneofNameWithObject}?.${fieldName} !== undefined
-          && ${oneofNameWithObject}?.${fieldName} !== null
+          && ${oneofNameWithObject}?.${valueName} !== undefined
+          && ${oneofNameWithObject}?.${valueName} !== null
         ) {
-          ${oneofNameWithMessage} = { $case: '${fieldName}', ${fieldName}: ${v} };
+          ${oneofNameWithMessage} = { $case: '${fieldName}', ${valueName}: ${v} };
         }
       `);
         }

package/build/options.d.ts

@@ -22,7 +22,8 @@ export declare enum EnvOption {
 }
 export declare enum OneofOption {
     PROPERTIES = "properties",
-    UNIONS = "unions"
+    UNIONS = "unions",
+    UNIONS_VALUE = "unions-value"
 }
 export declare enum ServiceOption {
     GRPC = "grpc-js",

package/build/options.js

@@ -30,6 +30,7 @@ var OneofOption;
 (function (OneofOption) {
     OneofOption["PROPERTIES"] = "properties";
     OneofOption["UNIONS"] = "unions";
+    OneofOption["UNIONS_VALUE"] = "unions-value";
 })(OneofOption || (exports.OneofOption = OneofOption = {}));
 var ServiceOption;
 (function (ServiceOption) {

package/build/types.js

@@ -407,7 +407,9 @@ function isWithinOneOf(field) {
 }
 exports.isWithinOneOf = isWithinOneOf;
 function isWithinOneOfThatShouldBeUnion(options, field) {
-    return isWithinOneOf(field) && options.oneof === options_1.OneofOption.UNIONS && !field.proto3Optional;
+    return (isWithinOneOf(field) &&
+        (options.oneof === options_1.OneofOption.UNIONS || options.oneof === options_1.OneofOption.UNIONS_VALUE) &&
+        !field.proto3Optional);
 }
 exports.isWithinOneOfThatShouldBeUnion = isWithinOneOfThatShouldBeUnion;
 function isRepeated(field) {

package/build/utils.d.ts

@@ -73,6 +73,7 @@ export declare function arrowFunction(params: string, body: Code | string, isOne
 export declare function nullOrUndefined(options: Pick<Options, "useNullAsOptional">, hasProto3Optional?: boolean): string;
 export declare function maybeCheckIsNotNull(options: Pick<Options, "useNullAsOptional">, typeName: string, prefix?: string): string;
 export declare function maybeCheckIsNull(options: Pick<Options, "useNullAsOptional">, typeName: string, prefix?: string): string;
+export declare function oneofValueName(fieldName: string, options: Pick<Options, "oneof">): string;
 export declare function withOrMaybeCheckIsNotNull(options: Pick<Options, "useNullAsOptional">, typeName: string): string;
 export declare function withOrMaybeCheckIsNull(options: Pick<Options, "useNullAsOptional">, typeName: string): string;
 export declare function withAndMaybeCheckIsNotNull(options: Pick<Options, "useNullAsOptional">, typeName: string): string;

package/build/utils.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getVersions = exports.withAndMaybeCheckIsNull = exports.withAndMaybeCheckIsNotNull = exports.withOrMaybeCheckIsNull = exports.withOrMaybeCheckIsNotNull = exports.maybeCheckIsNull = exports.maybeCheckIsNotNull = exports.nullOrUndefined = exports.arrowFunction = exports.tryCatchBlock = exports.impProto = exports.impFile = exports.getPropertyAccessor = exports.safeAccessor = exports.getFieldName = exports.getFieldJsonName = exports.FormattedMethodDescriptor = exports.assertInstanceOf = exports.maybePrefixPackage = exports.maybeAddComment = exports.upperFirst = exports.lowerFirst = exports.singular = exports.fail = exports.readToBuffer = exports.generateIndexFiles = exports.protoFilesToGenerate = void 0;
+exports.getVersions = exports.withAndMaybeCheckIsNull = exports.withAndMaybeCheckIsNotNull = exports.withOrMaybeCheckIsNull = exports.withOrMaybeCheckIsNotNull = exports.oneofValueName = exports.maybeCheckIsNull = exports.maybeCheckIsNotNull = exports.nullOrUndefined = exports.arrowFunction = exports.tryCatchBlock = exports.impProto = exports.impFile = exports.getPropertyAccessor = exports.safeAccessor = exports.getFieldName = exports.getFieldJsonName = exports.FormattedMethodDescriptor = exports.assertInstanceOf = exports.maybePrefixPackage = exports.maybeAddComment = exports.upperFirst = exports.lowerFirst = exports.singular = exports.fail = exports.readToBuffer = exports.generateIndexFiles = exports.protoFilesToGenerate = void 0;
 const path = require("path");
 const ts_poet_1 = require("ts-poet");
 const options_1 = require("./options");
@@ -266,6 +266,10 @@ function maybeCheckIsNull(options, typeName, prefix) {
     return options.useNullAsOptional ? ` ${prefix} ${typeName} === null` : "";
 }
 exports.maybeCheckIsNull = maybeCheckIsNull;
+function oneofValueName(fieldName, options) {
+    return options.oneof === options_1.OneofOption.UNIONS ? fieldName : "value";
+}
+exports.oneofValueName = oneofValueName;
 function withOrMaybeCheckIsNotNull(options, typeName) {
     return maybeCheckIsNotNull(options, typeName, "||");
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "1.179.0",
+  "version": "1.180.0",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",