ts-proto 2.1.0 → 2.2.0

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/package.json

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