ts-proto 1.112.0 → 1.113.0

package/CHANGELOG.md

@@ -1,3 +1,24 @@
+# [1.113.0](https://github.com/stephenh/ts-proto/compare/v1.112.2...v1.113.0) (2022-05-27)
+
+
+### Features
+
+* add options to schema output ([#437](https://github.com/stephenh/ts-proto/issues/437)) ([e8e4e39](https://github.com/stephenh/ts-proto/commit/e8e4e3937292e07280f5154b584e60124118f093))
+
+## [1.112.2](https://github.com/stephenh/ts-proto/compare/v1.112.1...v1.112.2) (2022-05-18)
+
+
+### Bug Fixes
+
+* enum type returns 'UNRECOGNIZED' or '-1' in xxxToJSON/xxxToNumber ([#566](https://github.com/stephenh/ts-proto/issues/566)) ([19911a1](https://github.com/stephenh/ts-proto/commit/19911a1c62e3fe5c8a0eb0a795489340512898da))
+
+## [1.112.1](https://github.com/stephenh/ts-proto/compare/v1.112.0...v1.112.1) (2022-05-06)
+
+
+### Bug Fixes
+
+* use Long.fromValue instead of Long.fromString ([#562](https://github.com/stephenh/ts-proto/issues/562)) ([c99891e](https://github.com/stephenh/ts-proto/commit/c99891e0fec6d9b7225025eb0c5bd7393e80af36))
+
 # [1.112.0](https://github.com/stephenh/ts-proto/compare/v1.111.0...v1.112.0) (2022-05-02)
 
 

package/build/enums.js

@@ -43,11 +43,11 @@ function generateEnum(ctx, fullName, enumDesc, sourceInfo) {
     }
     if (options.outputJsonMethods) {
         chunks.push(ts_poet_1.code `\n`);
-        chunks.push(generateEnumToJson(fullName, enumDesc));
+        chunks.push(generateEnumToJson(ctx, fullName, enumDesc));
     }
     if (options.stringEnums && options.outputEncodeMethods) {
         chunks.push(ts_poet_1.code `\n`);
-        chunks.push(generateEnumToNumber(fullName, enumDesc));
+        chunks.push(generateEnumToNumber(ctx, fullName, enumDesc));
     }
     return ts_poet_1.joinCode(chunks, { on: '\n' });
 }
@@ -87,7 +87,8 @@ function generateEnumFromJson(ctx, fullName, enumDesc) {
 }
 exports.generateEnumFromJson = generateEnumFromJson;
 /** Generates a function with a big switch statement to encode our enum -> JSON. */
-function generateEnumToJson(fullName, enumDesc) {
+function generateEnumToJson(ctx, fullName, enumDesc) {
+    const { options, utils } = ctx;
     const chunks = [];
     const functionName = case_1.camelCase(fullName) + 'ToJSON';
     chunks.push(ts_poet_1.code `export function ${ts_poet_1.def(functionName)}(object: ${fullName}): string {`);
@@ -95,14 +96,28 @@ function generateEnumToJson(fullName, enumDesc) {
     for (const valueDesc of enumDesc.value) {
         chunks.push(ts_poet_1.code `case ${fullName}.${valueDesc.name}: return "${valueDesc.name}";`);
     }
-    chunks.push(ts_poet_1.code `default: return "UNKNOWN";`);
+    if (options.unrecognizedEnum) {
+        chunks.push(ts_poet_1.code `
+      case ${fullName}.${UNRECOGNIZED_ENUM_NAME}:
+      default:
+        return "${UNRECOGNIZED_ENUM_NAME}";
+    `);
+    }
+    else {
+        // We use globalThis to avoid conflicts on protobuf types named `Error`.
+        chunks.push(ts_poet_1.code `
+      default:
+        throw new ${utils.globalThis}.Error("Unrecognized enum value " + object + " for enum ${fullName}");
+    `);
+    }
     chunks.push(ts_poet_1.code `}`);
     chunks.push(ts_poet_1.code `}`);
     return ts_poet_1.joinCode(chunks, { on: '\n' });
 }
 exports.generateEnumToJson = generateEnumToJson;
 /** Generates a function with a big switch statement to encode our string enum -> int value. */
-function generateEnumToNumber(fullName, enumDesc) {
+function generateEnumToNumber(ctx, fullName, enumDesc) {
+    const { options, utils } = ctx;
     const chunks = [];
     const functionName = case_1.camelCase(fullName) + 'ToNumber';
     chunks.push(ts_poet_1.code `export function ${ts_poet_1.def(functionName)}(object: ${fullName}): number {`);
@@ -110,7 +125,20 @@ function generateEnumToNumber(fullName, enumDesc) {
     for (const valueDesc of enumDesc.value) {
         chunks.push(ts_poet_1.code `case ${fullName}.${valueDesc.name}: return ${valueDesc.number};`);
     }
-    chunks.push(ts_poet_1.code `default: return 0;`);
+    if (options.unrecognizedEnum) {
+        chunks.push(ts_poet_1.code `
+      case ${fullName}.${UNRECOGNIZED_ENUM_NAME}:
+      default:
+        return ${UNRECOGNIZED_ENUM_VALUE};
+    `);
+    }
+    else {
+        // We use globalThis to avoid conflicts on protobuf types named `Error`.
+        chunks.push(ts_poet_1.code `
+      default:
+        throw new ${utils.globalThis}.Error("Unrecognized enum value " + object + " for enum ${fullName}");
+    `);
+    }
     chunks.push(ts_poet_1.code `}`);
     chunks.push(ts_poet_1.code `}`);
     return ts_poet_1.joinCode(chunks, { on: '\n' });

package/build/main.js

@@ -948,7 +948,7 @@ function generateFromJson(ctx, fullName, fullTypeName, messageDesc) {
                 }
                 else if (types_1.isLong(field) && options.forceLong === options_1.LongOption.LONG) {
                     const cstr = case_1.capitalize(types_1.basicTypeName(ctx, field, { keepValueType: true }).toCodeString());
-                    return ts_poet_1.code `${cstr}.fromString(${from})`;
+                    return ts_poet_1.code `${cstr}.fromValue(${from})`;
                 }
                 else {
                     const cstr = case_1.capitalize(types_1.basicTypeName(ctx, field, { keepValueType: true }).toCodeString());

package/build/schema.js

@@ -5,16 +5,50 @@ const ts_proto_descriptors_1 = require("ts-proto-descriptors");
 const ts_poet_1 = require("ts-poet");
 const visit_1 = require("./visit");
 const utils_1 = require("./utils");
+const types_1 = require("./types");
+const minimal_1 = require("protobufjs/minimal");
 const fileDescriptorProto = ts_poet_1.imp('FileDescriptorProto@ts-proto-descriptors');
+const extensionCache = {};
 function generateSchema(ctx, fileDesc, sourceInfo) {
     var _a;
     const { options } = ctx;
     const chunks = [];
+    fileDesc.extension.forEach((extension) => {
+        if (!(extension.extendee in extensionCache)) {
+            extensionCache[extension.extendee] = {};
+        }
+        extensionCache[extension.extendee][extension.number] = extension;
+    });
     chunks.push(ts_poet_1.code `
+    type ProtoMetaMessageOptions = {
+      options?: { [key: string]: any };
+      fields?: { [key: string]: { [key: string]: any } };
+      oneof?: { [key: string]: { [key: string]: any } };
+      nested?: { [key: string]: ProtoMetaMessageOptions };
+    };
+
     export interface ProtoMetadata {
       fileDescriptor: ${fileDescriptorProto};
       references: { [key: string]: any };
       dependencies?: ProtoMetadata[];
+      options?: {
+        options?: { [key: string]: any };
+        services?: {
+          [key: string]: {
+            options?: { [key: string]: any };
+            methods?: { [key: string]: { [key: string]: any } };
+          }
+        };
+        messages?: {
+          [key: string]: ProtoMetaMessageOptions;
+        };
+        enums?: {
+          [key: string]: {
+            options?: { [key: string]: any };
+            values?: { [key: string]: { [key: string]: any } };
+          };
+        };
+      };
     }
   `);
     const references = [];
@@ -42,13 +76,167 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
     descriptor.sourceCodeInfo = {
         location: ((_a = descriptor.sourceCodeInfo) === null || _a === void 0 ? void 0 : _a.location.filter((loc) => loc['leadingComments'] || loc['trailingComments'])) || [],
     };
+    let fileOptions;
+    if (fileDesc.options) {
+        fileOptions = encodedOptionsToOptions(ctx, '.google.protobuf.FileOptions', fileDesc.options['_unknownFields']);
+        delete fileDesc.options['_unknownFields'];
+    }
+    const messagesOptions = [];
+    (fileDesc.messageType || []).forEach((message) => {
+        const resolvedMessage = resolveMessageOptions(ctx, message);
+        if (resolvedMessage) {
+            messagesOptions.push(resolvedMessage);
+        }
+    });
+    const servicesOptions = [];
+    (fileDesc.service || []).forEach((service) => {
+        const methodsOptions = [];
+        service.method.forEach((method) => {
+            if (method.options) {
+                const methodOptions = encodedOptionsToOptions(ctx, '.google.protobuf.MethodOptions', method.options['_unknownFields']);
+                delete method.options['_unknownFields'];
+                if (methodOptions) {
+                    methodsOptions.push(ts_poet_1.code `'${method.name}': ${methodOptions}`);
+                }
+            }
+        });
+        let serviceOptions;
+        if (service.options) {
+            serviceOptions = encodedOptionsToOptions(ctx, '.google.protobuf.ServiceOptions', service.options['_unknownFields']);
+            delete service.options['_unknownFields'];
+        }
+        if (methodsOptions.length > 0 || serviceOptions) {
+            servicesOptions.push(ts_poet_1.code `
+        '${service.name}': {
+          options: ${serviceOptions},
+          methods: {${ts_poet_1.joinCode(methodsOptions, { on: ',' })}}
+        }
+      `);
+        }
+    });
+    const enumsOptions = [];
+    (fileDesc.enumType || []).forEach((Enum) => {
+        const valuesOptions = [];
+        Enum.value.forEach((value) => {
+            if (value.options) {
+                const valueOptions = encodedOptionsToOptions(ctx, '.google.protobuf.EnumValueOptions', value.options['_unknownFields']);
+                delete value.options['_unknownFields'];
+                if (valueOptions) {
+                    valuesOptions.push(ts_poet_1.code `'${value.name}': ${valueOptions}`);
+                }
+            }
+        });
+        let enumOptions;
+        if (Enum.options) {
+            enumOptions = encodedOptionsToOptions(ctx, '.google.protobuf.EnumOptions', Enum.options['_unknownFields']);
+            delete Enum.options['_unknownFields'];
+        }
+        if (valuesOptions.length > 0 || enumOptions) {
+            enumsOptions.push(ts_poet_1.code `
+        '${Enum.name}': {
+          options: ${enumOptions},
+          values: {${ts_poet_1.joinCode(valuesOptions, { on: ',' })}}
+        }
+      `);
+        }
+    });
     chunks.push(ts_poet_1.code `
     export const ${ts_poet_1.def('protoMetadata')}: ProtoMetadata = {
       fileDescriptor: ${fileDescriptorProto}.fromPartial(${descriptor}),
       references: { ${ts_poet_1.joinCode(references, { on: ',' })} },
       dependencies: [${ts_poet_1.joinCode(dependencies, { on: ',' })}],
+      ${fileOptions || messagesOptions.length > 0 || servicesOptions.length > 0 || enumsOptions.length > 0
+        ? ts_poet_1.code `options: {
+          ${fileOptions ? ts_poet_1.code `options: ${fileOptions},` : ''}
+          ${messagesOptions.length > 0 ? ts_poet_1.code `messages: {${ts_poet_1.joinCode(messagesOptions, { on: ',' })}},` : ''}
+          ${servicesOptions.length > 0 ? ts_poet_1.code `services: {${ts_poet_1.joinCode(servicesOptions, { on: ',' })}},` : ''}
+          ${enumsOptions.length > 0 ? ts_poet_1.code `enums: {${ts_poet_1.joinCode(enumsOptions, { on: ',' })}}` : ''}
+        }`
+        : ''}
     }
   `);
     return chunks;
 }
 exports.generateSchema = generateSchema;
+function getExtensionValue(ctx, extension, data) {
+    if (extension.type == ts_proto_descriptors_1.FieldDescriptorProto_Type.TYPE_MESSAGE) {
+        const typeName = types_1.basicTypeName(ctx, extension);
+        const resultBuffer = Buffer.concat(data.map((d) => {
+            // Skip length byte
+            const reader = new minimal_1.Reader(d);
+            reader.uint32();
+            return reader.buf.slice(reader.pos);
+        }));
+        const result = resultBuffer.toString('base64');
+        return ts_poet_1.code `'${extension.name}': ${typeName}.decode(Buffer.from('${result}', 'base64'))`;
+    }
+    else {
+        const reader = new minimal_1.Reader(data[0]);
+        let value = reader[types_1.toReaderCall(extension)]();
+        if (typeof value === 'string') {
+            value = ts_poet_1.code `"${value}"`;
+        }
+        return ts_poet_1.code `'${extension.name}': ${value}`;
+    }
+}
+/** Takes the protoc's input of options as proto-encoded messages, and turns them into embedded-able-in-source-code representations. */
+function encodedOptionsToOptions(ctx, extendee, encodedOptions) {
+    if (!encodedOptions) {
+        return undefined;
+    }
+    const resultOptions = [];
+    for (const [key, value] of Object.entries(encodedOptions)) {
+        const extension = extensionCache[extendee][parseInt(key, 10) >>> 3];
+        resultOptions.push(getExtensionValue(ctx, extension, value));
+    }
+    if (resultOptions.length == 0) {
+        return undefined;
+    }
+    return ts_poet_1.code `{${ts_poet_1.joinCode(resultOptions, { on: ',' })}}`;
+}
+function resolveMessageOptions(ctx, message) {
+    const fieldsOptions = [];
+    message.field.forEach((field) => {
+        if (field.options) {
+            const fieldOptions = encodedOptionsToOptions(ctx, '.google.protobuf.FieldOptions', field.options['_unknownFields']);
+            delete field.options['_unknownFields'];
+            if (fieldOptions) {
+                fieldsOptions.push(ts_poet_1.code `'${field.name}': ${fieldOptions}`);
+            }
+        }
+    });
+    const oneOfsOptions = [];
+    message.oneofDecl.forEach((oneOf) => {
+        if (oneOf.options) {
+            const oneOfOptions = encodedOptionsToOptions(ctx, '.google.protobuf.OneofOptions', oneOf.options['_unknownFields']);
+            delete oneOf.options['_unknownFields'];
+            if (oneOfOptions) {
+                oneOfsOptions.push(ts_poet_1.code `'${oneOf.name}': ${oneOfOptions}`);
+            }
+        }
+    });
+    let nestedOptions = [];
+    if (message.nestedType && message.nestedType.length > 0) {
+        message.nestedType.forEach((nested) => {
+            const resolvedMessage = resolveMessageOptions(ctx, nested);
+            if (resolvedMessage) {
+                nestedOptions.push(resolvedMessage);
+            }
+        });
+    }
+    let messageOptions;
+    if (message.options) {
+        messageOptions = encodedOptionsToOptions(ctx, '.google.protobuf.MessageOptions', message.options['_unknownFields']);
+        delete message.options['_unknownFields'];
+    }
+    if (fieldsOptions.length > 0 || oneOfsOptions.length > 0 || nestedOptions.length > 0 || messageOptions) {
+        return ts_poet_1.code `
+      '${message.name}': {
+        ${messageOptions ? ts_poet_1.code `options: ${messageOptions},` : ''}
+        ${fieldsOptions.length > 0 ? ts_poet_1.code `fields: {${ts_poet_1.joinCode(fieldsOptions, { on: ',' })}},` : ''}
+        ${oneOfsOptions.length > 0 ? ts_poet_1.code `oneof: {${ts_poet_1.joinCode(oneOfsOptions, { on: ',' })}},` : ''}
+        ${nestedOptions.length > 0 ? ts_poet_1.code `nested: {${ts_poet_1.joinCode(nestedOptions, { on: ',' })}},` : ''}
+      }
+    `;
+    }
+}

package/package.json

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