ts-proto 2.0.4 → 2.2.0

package/README.markdown

@@ -454,7 +454,11 @@ Generated code will be placed in the Gradle build directory.
 
 - With `--ts_proto_opt=annotateFilesWithVersion=false`, the generated files will not contain the versions of `protoc` and `ts-proto` used to generate the file. This option is normally set to `true`, such that files list the versions used.
 
-- With `--ts_proto_opt=outputSchema=true`, meta typings will be generated that can later be used in other code generators. If outputSchema is instead specified to be `no-file-descriptor` then we do not include the file descriptor in the generated schema. This is useful if you are trying to minimize the size of the generated schema.
+- With `--ts_proto_opt=outputSchema=true`, meta typings will be generated that can later be used in other code generators.
+
+- With `--ts_proto_opt=outputSchema=no-file-descriptor`, meta typings will be generated, but we do not include the file descriptor in the generated schema. This is useful if you are trying to minimize the size of the generated schema.
+
+- With `--ts_proto_opt=outputSchema=const`, meta typings will be generated `as const`, allowing type-safe access to all its properties. (only works with TypeScript 4.9 and up, because it also uses the [`satisfies`](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-4-9.html#the-satisfies-operator) operator). Can be combined with the `no-file-descriptor` option (`outputSchema=const,outputSchema=no-file-descriptor`) to not include the file descriptor in the generated schema.
 
 - With `--ts_proto_opt=outputTypeAnnotations=true`, each message will be given a `$type` field containing its fully-qualified name. You can use `--ts_proto_opt=outputTypeAnnotations=static-only` to omit it from the `interface` declaration, or `--ts_proto_opt=outputTypeAnnotations=optional` to make it an optional property on the `interface` definition. The latter option may be useful if you want to use the `$type` field for runtime type checking on responses from a server.
 

package/build/src/main.d.ts

@@ -4,7 +4,7 @@ import { FileDescriptorProto } from "ts-proto-descriptors";
 import { Context } from "./context";
 import { Options } from "./options";
 export declare function generateFile(ctx: Context, fileDesc: FileDescriptorProto): [string, Code];
-export type Utils = ReturnType<typeof makeDeepPartial> & ReturnType<typeof makeObjectIdMethods> & ReturnType<typeof makeTimestampMethods> & ReturnType<typeof makeByteUtils> & ReturnType<typeof makeLongUtils> & ReturnType<typeof makeComparisonUtils> & ReturnType<typeof makeNiceGrpcServerStreamingMethodResult> & ReturnType<typeof makeGrpcWebErrorClass> & ReturnType<typeof makeExtensionClass> & ReturnType<typeof makeAssertionUtils>;
+export type Utils = ReturnType<typeof makeDeepPartial> & ReturnType<typeof makeObjectIdMethods> & ReturnType<typeof makeTimestampMethods> & ReturnType<typeof makeByteUtils> & ReturnType<typeof makeLongUtils> & ReturnType<typeof makeComparisonUtils> & ReturnType<typeof makeNiceGrpcServerStreamingMethodResult> & ReturnType<typeof makeGrpcWebErrorClass> & ReturnType<typeof makeExtensionClass> & ReturnType<typeof makeAssertionUtils> & ReturnType<typeof makeMessageFns>;
 /** These are runtime utility methods used by the generated code. */
 export declare function makeUtils(options: Options): Utils;
 declare function makeLongUtils(options: Options, bytes: ReturnType<typeof makeByteUtils>): {
@@ -22,6 +22,15 @@ declare function makeDeepPartial(options: Options, longs: ReturnType<typeof make
     DeepPartial: ConditionalOutput;
     Exact: ConditionalOutput;
 };
+declare function makeMessageFns(options: Options, deepPartial: ReturnType<typeof makeDeepPartial>, extension: ReturnType<typeof makeExtensionClass>): {
+    MessageFns: ConditionalOutput;
+    ExtensionFns: ConditionalOutput;
+    ExtensionHolder: ConditionalOutput;
+    StructWrapperFns: ConditionalOutput;
+    AnyValueWrapperFns: ConditionalOutput;
+    ListValueWrapperFns: ConditionalOutput;
+    FieldMaskWrapperFns: ConditionalOutput;
+};
 declare function makeObjectIdMethods(): {
     fromJsonObjectId: ConditionalOutput;
     fromProtoObjectId: ConditionalOutput;

package/build/src/main.js

@@ -96,7 +96,8 @@ function generateFile(ctx, fileDesc) {
                 chunks.push(generateBaseInstanceFactory(ctx, fullName, message, fullTypeName));
             }
             const staticMembers = [];
-            if (options.outputTypeAnnotations || options.outputTypeRegistry) {
+            const hasTypeMember = options.outputTypeAnnotations || options.outputTypeRegistry;
+            if (hasTypeMember) {
                 staticMembers.push((0, ts_poet_1.code) `$type: '${fullTypeName}' as const`);
             }
             if (options.outputExtensions) {
@@ -153,8 +154,37 @@ function generateFile(ctx, fileDesc) {
                 staticMembers.push(...(0, generate_struct_wrappers_1.generateUnwrapShallow)(ctx, fullTypeName, structFieldNames));
             }
             if (staticMembers.length > 0) {
+                const messageFnsTypeParameters = [fullName, hasTypeMember && `'${fullTypeName}'`]
+                    .filter((p) => !!p)
+                    .join(", ");
+                const interfaces = [(0, ts_poet_1.code) `${utils.MessageFns}<${messageFnsTypeParameters}>`];
+                if (options.outputEncodeMethods &&
+                    options.outputExtensions &&
+                    options.unknownFields &&
+                    message.extensionRange.length) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.ExtensionFns}<${fullName}>`);
+                }
+                if ((0, types_1.isStructTypeName)(fullTypeName)) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.StructWrapperFns}`);
+                }
+                else if ((0, types_1.isAnyValueTypeName)(fullTypeName)) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.AnyValueWrapperFns}`);
+                }
+                else if ((0, types_1.isListValueTypeName)(fullTypeName)) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.ListValueWrapperFns}`);
+                }
+                else if ((0, types_1.isFieldMaskTypeName)(fullTypeName)) {
+                    interfaces.push((0, ts_poet_1.code) `${utils.FieldMaskWrapperFns}`);
+                }
+                if (options.outputExtensions) {
+                    for (const extension of message.extension) {
+                        const name = (0, case_1.maybeSnakeToCamel)(extension.name, ctx.options);
+                        const type = (0, types_1.toTypeName)(ctx, message, extension);
+                        interfaces.push((0, ts_poet_1.code) `${utils.ExtensionHolder}<"${name}", ${type}>`);
+                    }
+                }
                 chunks.push((0, ts_poet_1.code) `
-            export const ${(0, ts_poet_1.def)(fullName)} = {
+            export const ${(0, ts_poet_1.def)(fullName)}: ${(0, ts_poet_1.joinCode)(interfaces, { on: " & " })} = {
               ${(0, ts_poet_1.joinCode)(staticMembers, { on: ",\n\n" })}
             };
           `);
@@ -281,17 +311,20 @@ function generateFile(ctx, fileDesc) {
 function makeUtils(options) {
     const bytes = makeByteUtils(options);
     const longs = makeLongUtils(options, bytes);
+    const deepPartial = makeDeepPartial(options, longs);
+    const extension = makeExtensionClass(options);
     return {
         ...bytes,
-        ...makeDeepPartial(options, longs),
+        ...deepPartial,
         ...makeObjectIdMethods(),
         ...makeTimestampMethods(options, longs, bytes),
         ...longs,
         ...makeComparisonUtils(),
         ...makeNiceGrpcServerStreamingMethodResult(options),
         ...makeGrpcWebErrorClass(bytes),
-        ...makeExtensionClass(options),
+        ...extension,
         ...makeAssertionUtils(bytes),
+        ...makeMessageFns(options, deepPartial, extension),
     };
 }
 function makeProtobufTimestampWrapper() {
@@ -461,6 +494,121 @@ function makeDeepPartial(options, longs) {
     `);
     return { Builtin, DeepPartial, Exact };
 }
+function makeMessageFns(options, deepPartial, extension) {
+    const BinaryWriter = (0, ts_poet_1.imp)("BinaryWriter@@bufbuild/protobuf/wire");
+    const BinaryReader = (0, ts_poet_1.imp)("BinaryReader@@bufbuild/protobuf/wire");
+    const { Exact, DeepPartial } = deepPartial;
+    const { Extension } = extension;
+    const commonStaticMembers = [];
+    const extensionStaticMembers = [];
+    const hasTypeMember = options.outputTypeAnnotations || options.outputTypeRegistry;
+    if (hasTypeMember) {
+        commonStaticMembers.push((0, ts_poet_1.code) `readonly $type: V;`);
+    }
+    if (options.outputEncodeMethods) {
+        if (options.outputEncodeMethods === true ||
+            options.outputEncodeMethods === "encode-only" ||
+            options.outputEncodeMethods === "encode-no-creation") {
+            commonStaticMembers.push((0, ts_poet_1.code) `
+        encode(message: T, writer?: ${BinaryWriter}): ${BinaryWriter};
+      `);
+            if (options.outputExtensions && options.unknownFields) {
+                extensionStaticMembers.push((0, ts_poet_1.code) `
+          setExtension<E>(message: T, extension: ${Extension}<E>, value: E): void;
+        `);
+            }
+        }
+        if (options.outputEncodeMethods === true || options.outputEncodeMethods === "decode-only") {
+            commonStaticMembers.push((0, ts_poet_1.code) `
+        decode(input: ${BinaryReader} | Uint8Array, length?: number): T;
+      `);
+            if (options.outputExtensions && options.unknownFields) {
+                extensionStaticMembers.push((0, ts_poet_1.code) `
+          getExtension<E>(message: T, extension: ${Extension}<E>): E | undefined;
+        `);
+            }
+        }
+    }
+    if (options.useAsyncIterable) {
+        commonStaticMembers.push((0, ts_poet_1.code) `
+      encodeTransform(
+        source: AsyncIterable<T | T[]> | Iterable<T | T[]>
+      ): AsyncIterable<Uint8Array>;
+    `);
+        commonStaticMembers.push((0, ts_poet_1.code) `
+      decodeTransform(
+        source: AsyncIterable<Uint8Array | Uint8Array[]> | Iterable<Uint8Array | Uint8Array[]>
+      ): AsyncIterable<T>;
+    `);
+    }
+    if (options.outputJsonMethods) {
+        if (options.outputJsonMethods === true || options.outputJsonMethods === "from-only") {
+            commonStaticMembers.push((0, ts_poet_1.code) `fromJSON(object: any): T;`);
+        }
+        if (options.outputJsonMethods === true || options.outputJsonMethods === "to-only") {
+            commonStaticMembers.push((0, ts_poet_1.code) `toJSON(message: T): unknown;`);
+        }
+    }
+    if (options.outputPartialMethods) {
+        if (options.useExactTypes) {
+            commonStaticMembers.push((0, ts_poet_1.code) `create<I extends ${Exact}<${DeepPartial}<T>, I>>(base?: I): T;`);
+            commonStaticMembers.push((0, ts_poet_1.code) `fromPartial<I extends ${Exact}<${DeepPartial}<T>, I>>(object: I): T;`);
+        }
+        else {
+            commonStaticMembers.push((0, ts_poet_1.code) `create(base?: DeepPartial<T>): T;`);
+            commonStaticMembers.push((0, ts_poet_1.code) `fromPartial(object: DeepPartial<T>): T;`);
+        }
+    }
+    const maybeExport = options.exportCommonSymbols ? "export" : "";
+    const MessageFns = (0, ts_poet_1.conditionalOutput)("MessageFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface MessageFns<T${hasTypeMember ? ", V extends string" : ""}> {
+        ${(0, ts_poet_1.joinCode)(commonStaticMembers, { on: "\n" })}
+      }
+    `);
+    const ExtensionFns = (0, ts_poet_1.conditionalOutput)("ExtensionFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface ExtensionFns<T> {
+        ${(0, ts_poet_1.joinCode)(extensionStaticMembers, { on: "\n" })}
+      }
+    `);
+    const ExtensionHolder = (0, ts_poet_1.conditionalOutput)("ExtensionHolder", (0, ts_poet_1.code) `
+      ${maybeExport} type ExtensionHolder<T extends string, V> = {
+        [key in T]: Extension<V>;
+      }
+    `);
+    const StructWrapperFns = (0, ts_poet_1.conditionalOutput)("StructWrapperFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface StructWrapperFns {
+        wrap(object: {[key: string]: any} | undefined): Struct;
+        unwrap(message: Struct): {[key: string]: any};
+      }
+    `);
+    const AnyValueWrapperFns = (0, ts_poet_1.conditionalOutput)("AnyValueWrapperFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface AnyValueWrapperFns {
+        wrap(value: any): Value;
+        unwrap(message: any): string | number | boolean | Object | null | Array<any> | undefined;
+      }
+    `);
+    const ListValueWrapperFns = (0, ts_poet_1.conditionalOutput)("ListValueWrapperFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface ListValueWrapperFns {
+        wrap(array: ${options.useReadonlyTypes ? "Readonly" : ""}Array<any> | undefined): ListValue;
+        unwrap(message: ${options.useReadonlyTypes ? "any" : "ListValue"}): Array<any>;
+      }
+    `);
+    const FieldMaskWrapperFns = (0, ts_poet_1.conditionalOutput)("FieldMaskWrapperFns", (0, ts_poet_1.code) `
+      ${maybeExport} interface FieldMaskWrapperFns {
+        wrap(paths: ${options.useReadonlyTypes ? "readonly" : ""} string[]): FieldMask;
+        unwrap(message: ${options.useReadonlyTypes ? "any" : "FieldMask"}): string[] ${options.useOptionals === "all" ? "| undefined" : ""};
+      }
+    `);
+    return {
+        MessageFns,
+        ExtensionFns,
+        ExtensionHolder,
+        StructWrapperFns,
+        AnyValueWrapperFns,
+        ListValueWrapperFns,
+        FieldMaskWrapperFns,
+    };
+}
 function makeObjectIdMethods() {
     const mongodb = (0, ts_poet_1.imp)("mongodb*mongodb");
     const fromProtoObjectId = (0, ts_poet_1.conditionalOutput)("fromProtoObjectId", (0, ts_poet_1.code) `

package/build/src/options.d.ts

@@ -32,6 +32,11 @@ export declare enum ServiceOption {
     DEFAULT = "default",
     NONE = "none"
 }
+export declare enum OutputSchemaOption {
+    TRUE = "true",
+    NO_FILE_DESCRIPTOR = "no-file-descriptor",
+    CONST = "const"
+}
 export type Options = {
     context: boolean;
     snakeToCamel: Array<"json" | "keys">;
@@ -69,7 +74,7 @@ export type Options = {
     unrecognizedEnumName: string;
     unrecognizedEnumValue: number;
     exportCommonSymbols: boolean;
-    outputSchema: boolean | "no-file-descriptor";
+    outputSchema: false | OutputSchemaOption[];
     onlyTypes: boolean;
     emitImportedFiles: boolean;
     useAbortSignal: boolean;

package/build/src/options.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ServiceOption = exports.OneofOption = exports.EnvOption = exports.JsonTimestampOption = exports.DateOption = exports.LongOption = void 0;
+exports.OutputSchemaOption = exports.ServiceOption = exports.OneofOption = exports.EnvOption = exports.JsonTimestampOption = exports.DateOption = exports.LongOption = void 0;
 exports.defaultOptions = defaultOptions;
 exports.optionsFromParameter = optionsFromParameter;
 exports.getTsPoetOpts = getTsPoetOpts;
@@ -44,6 +44,12 @@ var ServiceOption;
     ServiceOption["DEFAULT"] = "default";
     ServiceOption["NONE"] = "none";
 })(ServiceOption || (exports.ServiceOption = ServiceOption = {}));
+var OutputSchemaOption;
+(function (OutputSchemaOption) {
+    OutputSchemaOption["TRUE"] = "true";
+    OutputSchemaOption["NO_FILE_DESCRIPTOR"] = "no-file-descriptor";
+    OutputSchemaOption["CONST"] = "const";
+})(OutputSchemaOption || (exports.OutputSchemaOption = OutputSchemaOption = {}));
 function defaultOptions() {
     return {
         context: false,
@@ -165,6 +171,13 @@ function optionsFromParameter(parameter) {
     if (options.nestJs && options.outputServices.length > 0) {
         options.outputEncodeMethods = true;
     }
+    // Handle outputSchema=true
+    if (options.outputSchema === true) {
+        options.outputSchema = [];
+    }
+    if (typeof options.outputSchema === "string") {
+        options.outputSchema = [options.outputSchema];
+    }
     if (options.useDate === true) {
         // Treat useDate=true as DATE
         options.useDate = DateOption.DATE;

package/build/src/schema.js

@@ -7,6 +7,7 @@ const visit_1 = require("./visit");
 const utils_1 = require("./utils");
 const types_1 = require("./types");
 const wire_1 = require("@bufbuild/protobuf/wire");
+const options_1 = require("./options");
 const fileDescriptorProto = (0, ts_poet_1.imp)("FileDescriptorProto@ts-proto-descriptors");
 const extensionCache = {};
 function generateSchema(ctx, fileDesc, sourceInfo) {
@@ -18,6 +19,9 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
         }
         extensionCache[extension.extendee][extension.number] = extension;
     });
+    const outputSchemaOptions = ctx.options.outputSchema ? ctx.options.outputSchema : [];
+    const outputFileDescriptor = !outputSchemaOptions.includes(options_1.OutputSchemaOption.NO_FILE_DESCRIPTOR);
+    const outputAsConst = outputSchemaOptions.includes(options_1.OutputSchemaOption.CONST);
     chunks.push((0, ts_poet_1.code) `
     type ProtoMetaMessageOptions = {
       options?: { [key: string]: any };
@@ -27,7 +31,7 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
     };
 
     export interface ProtoMetadata {
-      ${ctx.options.outputSchema !== "no-file-descriptor" ? (0, ts_poet_1.code) `fileDescriptor: ${fileDescriptorProto};\n` : ""}references: { [key: string]: any };
+      ${outputFileDescriptor ? (0, ts_poet_1.code) `fileDescriptor: ${fileDescriptorProto};\n` : ""}references: { [key: string]: any };
       dependencies?: ProtoMetadata[];
       options?: {
         options?: { [key: string]: any };
@@ -106,7 +110,7 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
         if (methodsOptions.length > 0 || serviceOptions) {
             servicesOptions.push((0, ts_poet_1.code) `
         '${service.name}': {
-          options: ${serviceOptions},
+          ${serviceOptions ? (0, ts_poet_1.code) `options: ${serviceOptions},` : ""}
           methods: {${(0, ts_poet_1.joinCode)(methodsOptions, { on: "," })}}
         }
       `);
@@ -132,17 +136,17 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
         if (valuesOptions.length > 0 || enumOptions) {
             enumsOptions.push((0, ts_poet_1.code) `
         '${Enum.name}': {
-          options: ${enumOptions},
+          ${enumOptions ? (0, ts_poet_1.code) `options: ${enumOptions},` : ""}
           values: {${(0, ts_poet_1.joinCode)(valuesOptions, { on: "," })}}
         }
       `);
         }
     });
     chunks.push((0, ts_poet_1.code) `
-    export const ${(0, ts_poet_1.def)("protoMetadata")}: ProtoMetadata = {
-      ${ctx.options.outputSchema !== "no-file-descriptor"
-        ? (0, ts_poet_1.code) `fileDescriptor: ${fileDescriptorProto}.fromPartial(${descriptor}),\n`
-        : ""}references: { ${(0, ts_poet_1.joinCode)(references, { on: "," })} },
+    export const ${(0, ts_poet_1.def)("protoMetadata")}${outputAsConst ? "" : ": ProtoMetadata"} = {
+      ${outputFileDescriptor ? (0, ts_poet_1.code) `fileDescriptor: ${descriptor},\n` : ""}references: { ${(0, ts_poet_1.joinCode)(references, {
+        on: ",",
+    })} },
       dependencies: [${(0, ts_poet_1.joinCode)(dependencies, { on: "," })}],
       ${fileOptions || messagesOptions.length > 0 || servicesOptions.length > 0 || enumsOptions.length > 0
         ? (0, ts_poet_1.code) `options: {
@@ -152,7 +156,7 @@ function generateSchema(ctx, fileDesc, sourceInfo) {
           ${enumsOptions.length > 0 ? (0, ts_poet_1.code) `enums: {${(0, ts_poet_1.joinCode)(enumsOptions, { on: "," })}}` : ""}
         }`
         : ""}
-    }
+    }${outputAsConst ? " as const satisfies ProtoMetadata" : ""}
   `);
     return chunks;
 }

package/package.json

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