ts-proto 1.151.1 → 1.152.0

package/build/integration/codegen.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts_proto_descriptors_1 = require("ts-proto-descriptors");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const util_1 = require("util");
+const main_1 = require("../src/main");
+const types_1 = require("../src/types");
+const utils_1 = require("../src/utils");
+const options_1 = require("../src/options");
+const generate_type_registry_1 = require("../src/generate-type-registry");
+/**
+ * Generates output for our integration tests from their example proto files.
+ *
+ * We use snapshots of the protoc CodeGeneratorRequest's that are captured
+ * by running ./update_proto_bins.sh, just because various machines/CI/etc
+ * may not have the `protoc` compiler on their path.
+ */
+async function main() {
+    const dir = process.argv[2];
+    const file = process.argv[3];
+    const param = process.argv[4];
+    await generate(file, dir, param);
+}
+async function generate(binFile, baseDir, parameter) {
+    const stdin = await (0, util_1.promisify)(fs_1.readFile)(binFile);
+    const request = ts_proto_descriptors_1.CodeGeneratorRequest.decode(stdin);
+    request.parameter = parameter;
+    const options = (0, options_1.optionsFromParameter)(parameter || "");
+    const typeMap = (0, types_1.createTypeMap)(request, options);
+    for (let file of request.protoFile) {
+        // Make a different utils per file to track per-file usage
+        if (options.M[file.name]) {
+            continue;
+        }
+        const utils = (0, main_1.makeUtils)(options);
+        const ctx = { options, typeMap, utils };
+        const [path, code] = (0, main_1.generateFile)(ctx, file);
+        const filePath = `${baseDir}/${path}`;
+        const dirPath = (0, path_1.parse)(filePath).dir;
+        await (0, util_1.promisify)(fs_1.mkdir)(dirPath, { recursive: true }).catch(() => { });
+        await (0, util_1.promisify)(fs_1.writeFile)(filePath, code.toString({ ...(0, options_1.getTsPoetOpts)(options), path }));
+    }
+    if (options.outputTypeRegistry) {
+        const utils = (0, main_1.makeUtils)(options);
+        const ctx = { options, typeMap, utils };
+        const path = "typeRegistry.ts";
+        const code = (0, generate_type_registry_1.generateTypeRegistry)(ctx);
+        const filePath = `${baseDir}/${path}`;
+        await (0, util_1.promisify)(fs_1.writeFile)(filePath, code.toString({ ...(0, options_1.getTsPoetOpts)(options), path }));
+    }
+    if (options.outputIndex) {
+        for (const [path, code] of (0, utils_1.generateIndexFiles)(request.protoFile, options)) {
+            const filePath = `${baseDir}/${path}`;
+            const dirPath = (0, path_1.parse)(filePath).dir;
+            await (0, util_1.promisify)(fs_1.mkdir)(dirPath, { recursive: true }).catch(() => { });
+            await (0, util_1.promisify)(fs_1.writeFile)(filePath, code.toString({ ...(0, options_1.getTsPoetOpts)(options), path }));
+        }
+    }
+}
+main().then(() => {
+    console.log(`${process.argv[3]}: Done`);
+});

package/build/{generate-grpc-web.js → src/generate-grpc-web.js}

@@ -227,17 +227,16 @@ function createPromiseUnaryMethod(ctx) {
       ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): Promise<any> {
       const request = { ..._request, ...methodDesc.requestType };
-      const maybeCombinedMetadata =
-        metadata && this.options.metadata
-          ? new ${BrowserHeaders}({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
-          : metadata || this.options.metadata;
+      const maybeCombinedMetadata = metadata && this.options.metadata
+        ? new ${BrowserHeaders}({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
+        : metadata ?? this.options.metadata;
       return new Promise((resolve, reject) => {
         ${useAbortSignal ? `const client =` : ""} ${grpc}.unary(methodDesc, {
           request,
           host: this.host,
-          metadata: maybeCombinedMetadata,
-          transport: this.options.transport,
-          debug: this.options.debug,
+          metadata: maybeCombinedMetadata ?? {},
+          ...(this.options.transport !== undefined ? {transport: this.options.transport} : {}),
+          debug: this.options.debug ?? false,
           onEnd: function (response) {
             if (response.status === grpc.Code.OK) {
               resolve(response.message!.toObject());
@@ -271,17 +270,16 @@ function createObservableUnaryMethod(ctx) {
       ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): ${(0, types_1.observableType)(ctx)}<any> {
       const request = { ..._request, ...methodDesc.requestType };
-      const maybeCombinedMetadata =
-        metadata && this.options.metadata
-          ? new ${BrowserHeaders}({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
-          : metadata || this.options.metadata;
+      const maybeCombinedMetadata = metadata && this.options.metadata
+        ? new ${BrowserHeaders}({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
+        : metadata ?? this.options.metadata;
       return new Observable(observer => {
         ${useAbortSignal ? `const client =` : ""} ${grpc}.unary(methodDesc, {
           request,
           host: this.host,
-          metadata: maybeCombinedMetadata,
-          transport: this.options.transport,
-          debug: this.options.debug,
+          metadata: maybeCombinedMetadata ?? {},
+          ...(this.options.transport !== undefined ? {transport: this.options.transport} : {}),
+          debug: this.options.debug ?? false,
           onEnd: (next) => {
             if (next.status !== 0) {
               const err = new ${ctx.utils.GrpcWebError}(next.statusMessage, next.status, next.trailers);
@@ -317,21 +315,21 @@ function createInvokeMethod(ctx) {
       metadata: grpc.Metadata | undefined,
       ${useAbortSignal ? "abortSignal?: AbortSignal," : ""}
     ): ${(0, types_1.observableType)(ctx)}<any> {
-      const upStreamCodes = this.options.upStreamRetryCodes || [];
+      const upStreamCodes = this.options.upStreamRetryCodes ?? [];
       const DEFAULT_TIMEOUT_TIME: number = 3_000;
       const request = { ..._request, ...methodDesc.requestType };
-      const maybeCombinedMetadata =
-      metadata && this.options.metadata
+      const transport = this.options.streamingTransport ?? this.options.transport;
+      const maybeCombinedMetadata = metadata && this.options.metadata
         ? new ${BrowserHeaders}({ ...this.options?.metadata.headersMap, ...metadata?.headersMap })
-        : metadata || this.options.metadata;
+        : metadata ?? this.options.metadata;
       return new Observable(observer => {
         const upStream = (() => {
           const client = ${grpc}.invoke(methodDesc, {
             host: this.host,
             request,
-            transport: this.options.streamingTransport || this.options.transport,
-            metadata: maybeCombinedMetadata,
-            debug: this.options.debug,
+            ...(transport !== undefined ? {transport} : {}),
+            metadata: maybeCombinedMetadata ?? {},
+            debug: this.options.debug ?? false,
             onMessage: (next) => observer.next(next),
             onEnd: (code: ${grpc}.Code, message: string, trailers: ${grpc}.Metadata) => {
               if (code === 0) {

package/build/{generate-services.js → src/generate-services.js}

@@ -206,7 +206,7 @@ function generateBatchingRpcMethod(ctx, batchMethod) {
         // If the return type is a map, lookup each key in the result
         lambda.push((0, ts_poet_1.code) `
       return this.${methodDesc.formattedName}(ctx, request).then(res => {
-        return ${inputFieldName}.map(key => res.${outputFieldName}[key])
+        return ${inputFieldName}.map(key => res.${outputFieldName}[key] ?? ${ctx.utils.fail}())
       });
     `);
     }

package/build/{main.js → src/main.js}

@@ -279,6 +279,7 @@ function makeUtils(options) {
         ...makeNiceGrpcServerStreamingMethodResult(),
         ...makeGrpcWebErrorClass(bytes),
         ...makeExtensionClass(options),
+        ...makeAssertionUtils(),
     };
 }
 exports.makeUtils = makeUtils;
@@ -365,10 +366,10 @@ function makeLongUtils(options, bytes) {
 }
 function makeByteUtils() {
     const globalThis = (0, ts_poet_1.conditionalOutput)("tsProtoGlobalThis", (0, ts_poet_1.code) `
-      declare var self: any | undefined;
-      declare var window: any | undefined;
-      declare var global: any | undefined;
-      var tsProtoGlobalThis: any = (() => {
+      declare const self: any | undefined;
+      declare const window: any | undefined;
+      declare const global: any | undefined;
+      const tsProtoGlobalThis: any = (() => {
         if (typeof globalThis !== "undefined") return globalThis;
         if (typeof self !== "undefined") return self;
         if (typeof window !== "undefined") return window;
@@ -589,6 +590,14 @@ function makeExtensionClass(options) {
     `);
     return { Extension };
 }
+function makeAssertionUtils() {
+    const fail = (0, ts_poet_1.conditionalOutput)("fail", (0, ts_poet_1.code) `
+      function fail(message?: string): never {
+        throw new Error(message ?? "Failed");
+      }
+    `);
+    return { fail };
+}
 // Create the interface with properties
 function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fullTypeName) {
     var _a;
@@ -615,12 +624,15 @@ function generateInterfaceDeclaration(ctx, fullName, messageDesc, sourceInfo, fu
         const info = sourceInfo.lookup(sourceInfo_1.Fields.message.field, index);
         (0, utils_1.maybeAddComment)(info, chunks, (_a = fieldDesc.options) === null || _a === void 0 ? void 0 : _a.deprecated);
         const name = (0, case_1.maybeSnakeToCamel)(fieldDesc.name, options);
-        const type = (0, types_1.toTypeName)(ctx, messageDesc, fieldDesc);
-        const q = (0, types_1.isOptionalProperty)(fieldDesc, messageDesc.options, options) ? "?" : "";
-        chunks.push((0, ts_poet_1.code) `${maybeReadonly(options)}${name}${q}: ${type}, `);
+        const isOptional = (0, types_1.isOptionalProperty)(fieldDesc, messageDesc.options, options);
+        const type = (0, types_1.toTypeName)(ctx, messageDesc, fieldDesc, isOptional);
+        if (isOptional && !type.toString().includes("undefined")) {
+            console.warn(name, type);
+        }
+        chunks.push((0, ts_poet_1.code) `${maybeReadonly(options)}${name}${isOptional ? "?" : ""}: ${type}, `);
     });
     if (ctx.options.unknownFields) {
-        chunks.push((0, ts_poet_1.code) `_unknownFields?: {[key: number]: Uint8Array[]},`);
+        chunks.push((0, ts_poet_1.code) `_unknownFields?: {[key: number]: Uint8Array[]} | undefined,`);
     }
     chunks.push((0, ts_poet_1.code) `}`);
     return (0, ts_poet_1.joinCode)(chunks, { on: "\n" });
@@ -635,7 +647,7 @@ function generateOneofProperty(ctx, messageDesc, oneofIndex, sourceInfo) {
         return (0, ts_poet_1.code) `{ ${mbReadonly}$case: '${fieldName}', ${mbReadonly}${fieldName}: ${typeName} }`;
     }), { on: " | " });
     const name = (0, case_1.maybeSnakeToCamel)(messageDesc.oneofDecl[oneofIndex].name, options);
-    return (0, ts_poet_1.code) `${mbReadonly}${name}?: ${unionType},`;
+    return (0, ts_poet_1.code) `${mbReadonly}${name}?: ${unionType} | undefined,`;
     /*
     // Ideally we'd put the comments for each oneof field next to the anonymous
     // type we've created in the type union above, but ts-poet currently lacks
@@ -1135,8 +1147,7 @@ function generateEncode(ctx, fullName, messageDesc) {
     });
     if (options.unknownFields) {
         chunks.push((0, ts_poet_1.code) `if (message._unknownFields !== undefined) {
-      for (const key in message._unknownFields) {
-        const values = message._unknownFields[key];
+      for (const [key, values] of Object.entries(message._unknownFields)) {
         const tag = parseInt(key, 10);
         for (const value of values) {
           writer.uint32(tag);
@@ -1330,7 +1341,7 @@ function generateExtension(ctx, message, extension) {
             chunks.push((0, ts_poet_1.code) `const values: ${type} = [];`);
             // start loop over all buffers
             chunks.push((0, ts_poet_1.code) `
-        for (var buffer of input) {
+        for (const buffer of input) {
           const reader = ${Reader}.create(buffer);
       `);
             if ((0, types_1.packedType)(extension.type) === undefined) {
@@ -1360,7 +1371,7 @@ function generateExtension(ctx, message, extension) {
         else {
             // pick the last entry, since it overrides all previous entries if not repeated
             chunks.push((0, ts_poet_1.code) `
-          const reader = ${Reader}.create(input[input.length -1]);
+          const reader = ${Reader}.create(input[input.length -1] ?? ${ctx.utils.fail}());
           return ${readSnippet};
         },
       `);

package/build/{types.js → src/types.js}

@@ -531,19 +531,15 @@ function longTypeName(ctx) {
 }
 /** Maps `.some_proto_namespace.Message` to a TypeName. */
 function messageToTypeName(ctx, protoType, typeOptions = {}) {
+    var _a;
     const { options, typeMap } = ctx;
     // Watch for the wrapper types `.google.protobuf.*Value`. If we're mapping
     // them to basic built-in types, we union the type with undefined to
     // indicate the value is optional. Exceptions:
     // - If the field is repeated, values cannot be undefined.
-    // - If useOptionals='messages' or useOptionals='all', all non-scalar types
-    //   are already optional properties, so there's no need for that union.
     let valueType = valueTypeName(ctx, protoType);
     if (!typeOptions.keepValueType && valueType) {
-        if (!!typeOptions.repeated ||
-            options.useOptionals === true ||
-            options.useOptionals === "messages" ||
-            options.useOptionals === "all") {
+        if ((_a = typeOptions.repeated) !== null && _a !== void 0 ? _a : false) {
             return valueType;
         }
         return (0, ts_poet_1.code) `${valueType} | undefined`;
@@ -575,26 +571,32 @@ function getEnumMethod(ctx, enumProtoType, methodSuffix) {
 }
 exports.getEnumMethod = getEnumMethod;
 /** Return the TypeName for any field (primitive/message/etc.) as exposed in the interface. */
-function toTypeName(ctx, messageDesc, field) {
+function toTypeName(ctx, messageDesc, field, ensureOptional = false) {
+    function finalize(type, isOptional) {
+        if (isOptional) {
+            return (0, ts_poet_1.code) `${type} | undefined`;
+        }
+        return type;
+    }
     let type = basicTypeName(ctx, field, { keepValueType: false });
     if (isRepeated(field)) {
         const mapType = messageDesc ? detectMapType(ctx, messageDesc, field) : false;
         if (mapType) {
             const { keyType, valueType } = mapType;
             if (ctx.options.useMapType) {
-                return (0, ts_poet_1.code) `Map<${keyType}, ${valueType}>`;
+                return finalize((0, ts_poet_1.code) `Map<${keyType}, ${valueType}>`, ensureOptional);
             }
-            return (0, ts_poet_1.code) `{ [key: ${keyType} ]: ${valueType} }`;
+            return finalize((0, ts_poet_1.code) `{ [key: ${keyType} ]: ${valueType} }`, ensureOptional);
         }
         if (ctx.options.useReadonlyTypes) {
-            return (0, ts_poet_1.code) `readonly ${type}[]`;
+            return finalize((0, ts_poet_1.code) `readonly ${type}[]`, ensureOptional);
         }
-        return (0, ts_poet_1.code) `${type}[]`;
+        return finalize((0, ts_poet_1.code) `${type}[]`, ensureOptional);
     }
     if (isValueType(ctx, field)) {
         // google.protobuf.*Value types are already unioned with `undefined`
         // in messageToTypeName, so no need to consider them for that here.
-        return type;
+        return finalize(type, false);
     }
     // By default (useOptionals='none', oneof=properties), non-scalar fields
     // outside oneofs and all fields within a oneof clause need to be unioned
@@ -608,14 +610,12 @@ function toTypeName(ctx, messageDesc, field) {
     // clause, spelling each option out inside a large type union. No need for
     // union with `undefined` here, either.
     const { options } = ctx;
-    if ((!isWithinOneOf(field) &&
+    return finalize(type, (!isWithinOneOf(field) &&
         isMessage(field) &&
         (options.useOptionals === false || options.useOptionals === "none")) ||
         (isWithinOneOf(field) && options.oneof === options_1.OneofOption.PROPERTIES) ||
-        (isWithinOneOf(field) && field.proto3Optional)) {
-        return (0, ts_poet_1.code) `${type} | undefined`;
-    }
-    return type;
+        (isWithinOneOf(field) && field.proto3Optional) ||
+        ensureOptional);
 }
 exports.toTypeName = toTypeName;
 function detectMapType(ctx, messageDesc, fieldDesc) {

package/build/tests/case-test.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const case_1 = require("../src/case");
+const options_1 = require("../src/options");
+const utils_1 = require("../src/utils");
+const keys = (0, options_1.optionsFromParameter)("snakeToCamel=keys");
+describe("case", () => {
+    it("converts snake to camel by default", () => {
+        expect((0, case_1.maybeSnakeToCamel)("foo_bar", (0, options_1.optionsFromParameter)(undefined))).toEqual("fooBar");
+    });
+    it("leaves as-is if snakeToCamel is false", () => {
+        expect((0, case_1.maybeSnakeToCamel)("foo_bar", (0, options_1.optionsFromParameter)("snakeToCamel=false"))).toEqual("foo_bar");
+    });
+    it("de-upper cases", () => {
+        expect((0, case_1.maybeSnakeToCamel)("FOO_BAR", keys)).toEqual("fooBar");
+    });
+    it("leaves existing mixed cases", () => {
+        expect((0, case_1.maybeSnakeToCamel)("clientI_d", keys)).toEqual("clientID");
+        expect((0, case_1.maybeSnakeToCamel)("menu_calendarI_d", keys)).toEqual("menuCalendarID");
+        expect((0, case_1.maybeSnakeToCamel)("display_nameI18n", keys)).toEqual("displayNameI18n");
+    });
+    it("leaves the first character as it was", () => {
+        expect((0, case_1.maybeSnakeToCamel)("Foo_Bar", keys)).toEqual("FooBar");
+    });
+    it("does nothing is already camel", () => {
+        expect((0, case_1.maybeSnakeToCamel)("FooBar", keys)).toEqual("FooBar");
+    });
+    // deal with original protoc which converts
+    // _uuid -> Uuid
+    // __uuid -> Uuid
+    // _uuid_foo -> UuidFoo
+    it("converts snake to camel with first underscore", () => {
+        expect((0, case_1.maybeSnakeToCamel)("_uuid", { snakeToCamel: ["keys"] })).toEqual("Uuid");
+    });
+    it("converts snake to camel with first double underscore", () => {
+        expect((0, case_1.maybeSnakeToCamel)("__uuid", { snakeToCamel: ["keys"] })).toEqual("Uuid");
+    });
+    it("converts snake to camel with first underscore and camelize other", () => {
+        expect((0, case_1.maybeSnakeToCamel)("_uuid_foo", { snakeToCamel: ["keys"] })).toEqual("UuidFoo");
+    });
+    it("converts string to camel case respecting word separation, getAPIValue === getApiValue", () => {
+        expect((0, case_1.camelCaseGrpc)("GetAPIValue")).toEqual("getApiValue");
+    });
+    describe("getFieldJsonName", () => {
+        it("keeps snake case when jsonName is probably not set", () => {
+            expect((0, utils_1.getFieldJsonName)({ name: "foo_bar", jsonName: "fooBar" }, { snakeToCamel: [] })).toBe("foo_bar");
+        });
+        it("uses jsonName when it is set", () => {
+            expect((0, utils_1.getFieldJsonName)({ name: "foo_bar", jsonName: "foo" }, { snakeToCamel: [] })).toBe("foo");
+        });
+    });
+});

package/build/tests/options-test.js

@@ -0,0 +1,148 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = require("../src/options");
+describe("options", () => {
+    it("can set outputJsonMethods with nestJs=true", () => {
+        expect((0, options_1.optionsFromParameter)("nestJs=true,outputJsonMethods=true")).toMatchInlineSnapshot(`
+      {
+        "M": {},
+        "addGrpcMetadata": false,
+        "addNestjsRestParameter": false,
+        "constEnums": false,
+        "context": false,
+        "emitImportedFiles": true,
+        "enumsAsLiterals": false,
+        "env": "both",
+        "esModuleInterop": false,
+        "exportCommonSymbols": true,
+        "fileSuffix": "",
+        "forceLong": "number",
+        "importSuffix": "",
+        "initializeFieldsAsUndefined": false,
+        "lowerCaseServiceMethods": true,
+        "metadataType": undefined,
+        "nestJs": true,
+        "oneof": "properties",
+        "onlyTypes": false,
+        "outputClientImpl": false,
+        "outputEncodeMethods": false,
+        "outputExtensions": false,
+        "outputIndex": false,
+        "outputJsonMethods": true,
+        "outputPartialMethods": false,
+        "outputSchema": false,
+        "outputServices": [
+          "default",
+        ],
+        "outputTypeAnnotations": false,
+        "outputTypeRegistry": false,
+        "removeEnumPrefix": false,
+        "returnObservable": false,
+        "snakeToCamel": [
+          "json",
+          "keys",
+        ],
+        "stringEnums": false,
+        "unknownFields": false,
+        "unrecognizedEnum": true,
+        "useAbortSignal": false,
+        "useAsyncIterable": false,
+        "useDate": "timestamp",
+        "useExactTypes": true,
+        "useJsonWireFormat": false,
+        "useMapType": false,
+        "useMongoObjectId": false,
+        "useNumericEnumForJson": false,
+        "useOptionals": "none",
+        "usePrototypeForDefaults": false,
+        "useReadonlyTypes": false,
+        "useSnakeTypeName": true,
+      }
+    `);
+    });
+    it("can set outputJsonMethods with nestJs=true", () => {
+        const options = (0, options_1.optionsFromParameter)("outputClientImpl=grpc-web,addGrpcMetadata=false");
+        expect(options).toMatchObject({
+            outputClientImpl: "grpc-web",
+            addGrpcMetadata: false,
+        });
+    });
+    it("can set fileSuffix", () => {
+        const options = (0, options_1.optionsFromParameter)("fileSuffix=.pb");
+        expect(options).toMatchObject({
+            fileSuffix: ".pb",
+        });
+    });
+    it("can set outputServices to false", () => {
+        const options = (0, options_1.optionsFromParameter)("outputServices=false");
+        expect(options).toMatchObject({
+            outputServices: [options_1.ServiceOption.NONE],
+        });
+    });
+    it("can set outputServices to grpc", () => {
+        const options = (0, options_1.optionsFromParameter)("outputServices=grpc-js");
+        expect(options).toMatchObject({
+            outputServices: [options_1.ServiceOption.GRPC],
+        });
+    });
+    it("can set useOptionals to boolean", () => {
+        const options = (0, options_1.optionsFromParameter)("useOptionals=true");
+        expect(options).toMatchObject({
+            useOptionals: true,
+        });
+    });
+    it("can set useOptionals to string", () => {
+        const options = (0, options_1.optionsFromParameter)("useOptionals=messages");
+        expect(options).toMatchObject({
+            useOptionals: "messages",
+        });
+    });
+    it("can set snakeToCamel as string", () => {
+        const options = (0, options_1.optionsFromParameter)("snakeToCamel=keys");
+        expect(options).toMatchObject({ snakeToCamel: ["keys"] });
+    });
+    it("can set snakeToCamel as two values", () => {
+        const options = (0, options_1.optionsFromParameter)("snakeToCamel=keys_json");
+        expect(options).toMatchObject({ snakeToCamel: ["keys", "json"] });
+    });
+    it("can set multiple values as an array", () => {
+        const options = (0, options_1.optionsFromParameter)("foo=one,foo=two");
+        expect(options).toMatchObject({ foo: ["one", "two"] });
+    });
+    it("´output*=false implies onlyTypes", () => {
+        const options = (0, options_1.optionsFromParameter)("outputJsonMethods=false,outputEncodeMethods=false,outputClientImpl=false");
+        expect(options).toMatchObject({
+            onlyTypes: true,
+        });
+    });
+    it("onlyTypes implies output*=false", () => {
+        const options = (0, options_1.optionsFromParameter)("onlyTypes=true");
+        expect(options).toMatchObject({
+            outputJsonMethods: false,
+            outputEncodeMethods: false,
+            outputClientImpl: false,
+            nestJs: false,
+        });
+    });
+    it("useJsonWireFormat requires onlyTypes", () => {
+        const options = (0, options_1.optionsFromParameter)("useJsonWireFormat=true");
+        expect(options).toMatchObject({
+            useJsonWireFormat: false,
+        });
+    });
+    it("useSnakeTypeName", () => {
+        const options = (0, options_1.optionsFromParameter)("useSnakeTypeName=false");
+        expect(options).toMatchObject({
+            useSnakeTypeName: false,
+        });
+    });
+    it("useJsonWireFormat implies useDate=string and stringEnums=true", () => {
+        const options = (0, options_1.optionsFromParameter)("useJsonWireFormat=true,onlyTypes=true");
+        expect(options).toMatchObject({
+            useJsonWireFormat: true,
+            onlyTypes: true,
+            stringEnums: true,
+            useDate: options_1.DateOption.STRING,
+        });
+    });
+});

package/build/tests/types-test.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const options_1 = require("../src/options");
+const types_1 = require("../src/types");
+const ts_poet_1 = require("ts-poet");
+const fakeProto = undefined;
+describe("types", () => {
+    describe("messageToTypeName", () => {
+        const testCases = [
+            {
+                descr: "top-level messages",
+                typeMap: new Map([[".namespace.Message", ["namespace", "Message", fakeProto]]]),
+                protoType: ".namespace.Message",
+                expected: (0, ts_poet_1.code) `${(0, ts_poet_1.imp)("Message@./namespace")}`,
+            },
+            {
+                descr: "nested messages",
+                typeMap: new Map([[".namespace.Message.Inner", ["namespace", "Message_Inner", fakeProto]]]),
+                protoType: ".namespace.Message.Inner",
+                expected: (0, ts_poet_1.code) `${(0, ts_poet_1.imp)("Message_Inner@./namespace")}`,
+            },
+            {
+                descr: "nested messages: .js import suffix",
+                typeMap: new Map([[".namespace.Message.Inner", ["namespace", "Message_Inner", fakeProto]]]),
+                protoType: ".namespace.Message.Inner",
+                options: { ...(0, options_1.defaultOptions)(), importSuffix: ".js" },
+                expected: (0, ts_poet_1.code) `${(0, ts_poet_1.imp)("Message_Inner@./namespace.js")}`,
+            },
+            {
+                descr: "value types",
+                typeMap: new Map(),
+                protoType: ".google.protobuf.StringValue",
+                expected: (0, ts_poet_1.code) `string | undefined`,
+            },
+            {
+                descr: "value types (useOptionals=true)",
+                typeMap: new Map(),
+                protoType: ".google.protobuf.StringValue",
+                options: { ...(0, options_1.defaultOptions)(), useOptionals: true },
+                expected: (0, ts_poet_1.code) `string | undefined`,
+            },
+            {
+                descr: 'value types (useOptionals="all")',
+                typeMap: new Map(),
+                protoType: ".google.protobuf.StringValue",
+                options: { ...(0, options_1.defaultOptions)(), useOptionals: "all" },
+                expected: (0, ts_poet_1.code) `string | undefined`,
+            },
+        ];
+        testCases.forEach((t) => it(t.descr, async () => {
+            const ctx = { options: (0, options_1.defaultOptions)(), utils: undefined, ...t };
+            const got = (0, types_1.messageToTypeName)(ctx, t.protoType);
+            expect(got.toString()).toEqual(t.expected.toString());
+        }));
+    });
+});

package/build/tests/utils-test.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../src/utils");
+const ts_poet_1 = require("ts-poet");
+describe("utils", () => {
+    describe("maybeAddComment", () => {
+        it("handles single-line impl comments", () => {
+            // Foo
+            const chunks = [];
+            (0, utils_1.maybeAddComment)({ leadingComments: " Foo\n" }, chunks);
+            expect((0, ts_poet_1.joinCode)(chunks).toString()).toMatchInlineSnapshot(`
+        "/** Foo */
+        "
+      `);
+        });
+        it("handles single-dot star comments", () => {
+            // /* Foo */
+            const chunks = [];
+            (0, utils_1.maybeAddComment)({ leadingComments: " Foo " }, chunks);
+            expect((0, ts_poet_1.joinCode)(chunks).toString()).toMatchInlineSnapshot(`
+        "/** Foo */
+        "
+      `);
+        });
+        it("handles single-line double-dot star comments", () => {
+            // /** Foo */
+            const chunks = [];
+            (0, utils_1.maybeAddComment)({ leadingComments: " * Foo " }, chunks);
+            expect((0, ts_poet_1.joinCode)(chunks).toString()).toMatchInlineSnapshot(`
+        "/** Foo */
+        "
+      `);
+        });
+        it("handles double-line double-dot star comments", () => {
+            // /**
+            //  * Foo
+            //  *
+            //  * bar.
+            //  */
+            const chunks = [];
+            (0, utils_1.maybeAddComment)({ leadingComments: "*\n Foo\n \n bar.\n" }, chunks);
+            expect((0, ts_poet_1.joinCode)(chunks).toString()).toMatchInlineSnapshot(`
+        "/**
+         * Foo
+         *
+         * bar.
+         */
+        "
+      `);
+        });
+        it("handles double-line impl comments", () => {
+            // // Foo
+            // // Bar
+            const chunks = [];
+            (0, utils_1.maybeAddComment)({ leadingComments: " Foo\n Bar\n" }, chunks);
+            expect((0, ts_poet_1.joinCode)(chunks).toString()).toMatchInlineSnapshot(`
+        "/**
+         * Foo
+         * Bar
+         */
+        "
+      `);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ts-proto",
-  "version": "1.151.1",
+  "version": "1.152.0",
   "description": "",
   "main": "build/plugin.js",
   "repository": "github:stephenh/ts-proto",
@@ -16,6 +16,7 @@
     "proto2pbjs": "docker compose run --rm protoc pbjs.sh",
     "bin2ts": "docker compose run --rm protoc codegen.sh",
     "test": "yarn jest -c jest.config.js --maxWorkers=2",
+    "tsc:check": "./tsc-check.sh tsconfig.json integration/tsconfig.json integration/tsconfig.proto.json protos/tsconfig.json",
     "format": "prettier --write {src,tests}/**/*.ts integration/*.ts",
     "format:check": "prettier --list-different {src,tests}/**/*.ts",
     "setup:docker": "docker compose build",
@@ -42,8 +43,9 @@
     "@semantic-release/github": "^9.0.2",
     "@semantic-release/npm": "^10.0.3",
     "@semantic-release/release-notes-generator": "^11.0.2",
+    "@tsconfig/strictest": "^2.0.1",
     "@types/jest": "^29.5.2",
-    "@types/node": "^14.14.37",
+    "@types/node": "^16.18.38",
     "chokidar": "^3.5.3",
     "jest": "^29.5.0",
     "jest-ts-webcompat-resolver": "^1.0.0",