@bufbuild/protobuf 2.0.0-alpha.4 → 2.0.0-beta.2

package/dist/cjs/reflect/reflect.js

@@ -27,9 +27,15 @@ const guard_js_1 = require("./guard.js");
  * Create a ReflectMessage.
  */
 function reflect(messageDesc, message, 
-// TODO either remove this option, or support it in reflect-list and reflect-map as well
-opt) {
-    return new ReflectMessageImpl(messageDesc, message, (opt === null || opt === void 0 ? void 0 : opt.disableFieldValueCheck) !== true);
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
+    return new ReflectMessageImpl(messageDesc, message, check);
 }
 exports.reflect = reflect;
 class ReflectMessageImpl {
@@ -39,9 +45,7 @@ class ReflectMessageImpl {
             .concat()
             .sort((a, b) => a.number - b.number)));
     }
-    constructor(messageDesc, message, 
-    // TODO either remove this option, or support it in reflect-list and reflect-map as well
-    check = true) {
+    constructor(messageDesc, message, check = true) {
         this.lists = new Map();
         this.maps = new Map();
         this.check = check;
@@ -71,7 +75,7 @@ class ReflectMessageImpl {
     }
     get(field) {
         assertOwn(this.message, field);
-        let value = (0, unsafe_js_1.unsafeGet)(this.message, field);
+        const value = (0, unsafe_js_1.unsafeGet)(this.message, field);
         switch (field.fieldKind) {
             case "list":
                 // eslint-disable-next-line no-case-declarations
@@ -88,15 +92,7 @@ class ReflectMessageImpl {
                 }
                 return map;
             case "message":
-                if (value !== undefined &&
-                    !field.oneof &&
-                    (0, wrappers_js_1.isWrapperDesc)(field.message)) {
-                    value = {
-                        $typeName: field.message.typeName,
-                        value: longToReflect(field.message.fields[0], value),
-                    };
-                }
-                return new ReflectMessageImpl(field.message, value, this.check);
+                return messageToReflect(field, value, this.check);
             case "scalar":
                 return (value === undefined
                     ? (0, scalar_js_1.scalarZeroValue)(field.scalar, false)
@@ -110,22 +106,20 @@ class ReflectMessageImpl {
         if (this.check) {
             const err = (0, reflect_check_js_1.checkField)(field, value);
             if (err) {
-                return err;
+                throw err;
             }
         }
         let local;
-        if ((0, guard_js_1.isReflectMap)(value) || (0, guard_js_1.isReflectList)(value)) {
-            local = value[unsafe_js_1.unsafeLocal];
+        if (field.fieldKind == "message") {
+            local = messageToLocal(field, value);
         }
-        else if ((0, guard_js_1.isReflectMessage)(value)) {
-            const msg = value.message;
-            local = !field.oneof && (0, wrappers_js_1.isWrapper)(msg) ? msg.value : msg;
+        else if ((0, guard_js_1.isReflectMap)(value) || (0, guard_js_1.isReflectList)(value)) {
+            local = value[unsafe_js_1.unsafeLocal];
         }
         else {
             local = longToLocal(field, value);
         }
         (0, unsafe_js_1.unsafeSet)(this.message, field, local);
-        return undefined;
     }
     getUnknown() {
         return this.message.$unknown;
@@ -142,7 +136,15 @@ function assertOwn(owner, member) {
 /**
  * Create a ReflectList.
  */
-function reflectList(field, unsafeInput, check = true) {
+function reflectList(field, unsafeInput, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
     return new ReflectListImpl(field, unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [], check);
 }
 exports.reflectList = reflectList;
@@ -166,29 +168,24 @@ class ReflectListImpl {
     }
     set(index, item) {
         if (index < 0 || index >= this._arr.length) {
-            return new error_js_1.FieldError(this._field, `list item #${index + 1}: out of range`);
+            throw new error_js_1.FieldError(this._field, `list item #${index + 1}: out of range`);
         }
         if (this.check) {
             const err = (0, reflect_check_js_1.checkListItem)(this._field, index, item);
             if (err) {
-                return err;
+                throw err;
             }
         }
         this._arr[index] = listItemToLocal(this._field, item);
-        return undefined;
     }
-    add(...items) {
+    add(item) {
         if (this.check) {
-            for (let i = 0; i < items.length; i++) {
-                const err = (0, reflect_check_js_1.checkListItem)(this._field, this._arr.length + i, items[i]);
-                if (err) {
-                    return err;
-                }
+            const err = (0, reflect_check_js_1.checkListItem)(this._field, this._arr.length, item);
+            if (err) {
+                throw err;
             }
         }
-        for (const item of items) {
-            this._arr.push(listItemToLocal(this._field, item));
-        }
+        this._arr.push(listItemToLocal(this._field, item));
         return undefined;
     }
     clear() {
@@ -214,7 +211,15 @@ class ReflectListImpl {
 /**
  * Create a ReflectMap.
  */
-function reflectMap(field, unsafeInput, check = true) {
+function reflectMap(field, unsafeInput, 
+/**
+ * By default, field values are validated when setting them. For example,
+ * a value for an uint32 field must be a ECMAScript Number >= 0.
+ *
+ * When field values are trusted, performance can be improved by disabling
+ * checks.
+ */
+check = true) {
     return new ReflectMapImpl(field, unsafeInput, check);
 }
 exports.reflectMap = reflectMap;
@@ -231,11 +236,11 @@ class ReflectMapImpl {
         if (this.check) {
             const err = (0, reflect_check_js_1.checkMapEntry)(this._field, key, value);
             if (err) {
-                return err;
+                throw err;
             }
         }
         this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
-        return undefined;
+        return this;
     }
     delete(key) {
         const k = mapKeyToLocal(key);
@@ -290,27 +295,68 @@ class ReflectMapImpl {
         }
     }
 }
+function messageToLocal(field, value) {
+    if (!(0, guard_js_1.isReflectMessage)(value)) {
+        return value;
+    }
+    if ((0, wrappers_js_1.isWrapper)(value.message) &&
+        !field.oneof &&
+        field.fieldKind == "message") {
+        // Types from google/protobuf/wrappers.proto are unwrapped when used in
+        // a singular field that is not part of a oneof group.
+        return value.message.value;
+    }
+    if (value.desc.typeName == "google.protobuf.Struct" &&
+        field.parent.typeName != "google.protobuf.Value") {
+        // google.protobuf.Struct is represented with JsonObject when used in a
+        // field, except when used in google.protobuf.Value.
+        return wktStructToLocal(value.message);
+    }
+    return value.message;
+}
+function messageToReflect(field, value, check) {
+    if (value !== undefined) {
+        if ((0, wrappers_js_1.isWrapperDesc)(field.message) &&
+            !field.oneof &&
+            field.fieldKind == "message") {
+            // Types from google/protobuf/wrappers.proto are unwrapped when used in
+            // a singular field that is not part of a oneof group.
+            value = {
+                $typeName: field.message.typeName,
+                value: longToReflect(field.message.fields[0], value),
+            };
+        }
+        else if (field.message.typeName == "google.protobuf.Struct" &&
+            field.parent.typeName != "google.protobuf.Value" &&
+            (0, guard_js_1.isObject)(value)) {
+            // google.protobuf.Struct is represented with JsonObject when used in a
+            // field, except when used in google.protobuf.Value.
+            value = wktStructToReflect(value);
+        }
+    }
+    return new ReflectMessageImpl(field.message, value, check);
+}
 function listItemToLocal(field, value) {
-    if ((0, guard_js_1.isReflectMessage)(value)) {
-        return value.message;
+    if (field.listKind == "message") {
+        return messageToLocal(field, value);
     }
     return longToLocal(field, value);
 }
 function listItemToReflect(field, value, check) {
     if (field.listKind == "message") {
-        return new ReflectMessageImpl(field.message, value, check);
+        return messageToReflect(field, value, check);
     }
     return longToReflect(field, value);
 }
 function mapValueToLocal(field, value) {
-    if ((0, guard_js_1.isReflectMessage)(value)) {
-        return value.message;
+    if (field.mapKind == "message") {
+        return messageToLocal(field, value);
     }
     return longToLocal(field, value);
 }
 function mapValueToReflect(field, value, check) {
     if (field.mapKind == "message") {
-        return new ReflectMessageImpl(field.message, value, check);
+        return messageToReflect(field, value, check);
     }
     return value;
 }
@@ -414,3 +460,81 @@ function longToLocal(field, value) {
     }
     return value;
 }
+function wktStructToReflect(json) {
+    const struct = {
+        $typeName: "google.protobuf.Struct",
+        fields: {},
+    };
+    if ((0, guard_js_1.isObject)(json)) {
+        for (const [k, v] of Object.entries(json)) {
+            struct.fields[k] = wktValueToReflect(v);
+        }
+    }
+    return struct;
+}
+function wktStructToLocal(val) {
+    const json = {};
+    for (const [k, v] of Object.entries(val.fields)) {
+        json[k] = wktValueToLocal(v);
+    }
+    return json;
+}
+function wktValueToLocal(val) {
+    switch (val.kind.case) {
+        case "structValue":
+            return wktStructToLocal(val.kind.value);
+        case "listValue":
+            return val.kind.value.values.map(wktValueToLocal);
+        case "nullValue":
+        case undefined:
+            return null;
+        default:
+            return val.kind.value;
+    }
+}
+function wktValueToReflect(json) {
+    const value = {
+        $typeName: "google.protobuf.Value",
+        kind: { case: undefined },
+    };
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- invalid input is unselected kind
+    switch (typeof json) {
+        case "number":
+            value.kind = { case: "numberValue", value: json };
+            break;
+        case "string":
+            value.kind = { case: "stringValue", value: json };
+            break;
+        case "boolean":
+            value.kind = { case: "boolValue", value: json };
+            break;
+        case "object":
+            if (json === null) {
+                const nullValue = 0;
+                value.kind = { case: "nullValue", value: nullValue };
+            }
+            else if (Array.isArray(json)) {
+                const listValue = {
+                    $typeName: "google.protobuf.ListValue",
+                    values: [],
+                };
+                if (Array.isArray(json)) {
+                    for (const e of json) {
+                        listValue.values.push(wktValueToReflect(e));
+                    }
+                }
+                value.kind = {
+                    case: "listValue",
+                    value: listValue,
+                };
+            }
+            else {
+                value.kind = {
+                    case: "structValue",
+                    value: wktStructToReflect(json),
+                };
+            }
+            break;
+    }
+    return value;
+}

package/dist/cjs/reflect/scalar.d.ts

@@ -6,7 +6,7 @@ export type ScalarValue<T = ScalarType, LongAsString extends boolean = false> =
 /**
  * Returns true if both scalar values are equal.
  */
-export declare function scalarEquals(type: ScalarType, a: string | boolean | number | bigint | Uint8Array | undefined, b: string | boolean | number | bigint | Uint8Array | undefined): boolean;
+export declare function scalarEquals(type: ScalarType, a: ScalarValue | undefined, b: ScalarValue | undefined): boolean;
 /**
  * Returns the zero value for the given scalar type.
  */

package/dist/cjs/registry.d.ts

@@ -39,8 +39,20 @@ export interface Registry {
     getService(typeName: string): DescService | undefined;
 }
 /**
- * A set of descriptors for messages, enumerations, extensions,
- * and services - and files.
+ * A registry that allows adding and removing descriptors.
+ */
+export interface MutableRegistry extends Registry {
+    /**
+     * Adds the given descriptor - but not types nested within - to the registry.
+     */
+    add(desc: DescMessage | DescEnum | DescExtension | DescService): void;
+    /**
+     * Remove the given descriptor - but not types nested within - from the registry.
+     */
+    remove(desc: DescMessage | DescEnum | DescExtension | DescService): void;
+}
+/**
+ * A registry that includes files.
  */
 export interface FileRegistry extends Registry {
     /**
@@ -64,6 +76,10 @@ export interface FileRegistry extends Registry {
  * For duplicate descriptors (same type name), the one given last wins.
  */
 export declare function createRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): Registry;
+/**
+ * Create a registry that allows adding and removing descriptors.
+ */
+export declare function createMutableRegistry(...input: (Registry | DescFile | DescMessage | DescEnum | DescExtension | DescService)[]): MutableRegistry;
 /**
  * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorSet
  * message.

package/dist/cjs/registry.js

@@ -13,7 +13,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.maximumEdition = exports.minimumEdition = exports.createFileRegistry = exports.createRegistry = void 0;
+exports.maximumEdition = exports.minimumEdition = exports.createFileRegistry = exports.createMutableRegistry = exports.createRegistry = void 0;
 const descriptors_js_1 = require("./descriptors.js");
 const text_format_js_1 = require("./wire/text-format.js");
 const nested_types_js_1 = require("./reflect/nested-types.js");
@@ -31,29 +31,25 @@ const names_js_1 = require("./reflect/names.js");
  * For duplicate descriptors (same type name), the one given last wins.
  */
 function createRegistry(...input) {
-    const reg = createMutableRegistry();
-    for (const i of input) {
-        switch (i.kind) {
-            case "registry":
-                for (const n of i) {
-                    reg.add(n);
-                }
-                break;
-            case "file":
-                for (const n of (0, nested_types_js_1.nestedTypes)(i)) {
-                    reg.add(n);
-                }
-                break;
-            default:
-                reg.add(i);
-                break;
-        }
-    }
-    return reg;
+    return initBaseRegistry(input);
 }
 exports.createRegistry = createRegistry;
+/**
+ * Create a registry that allows adding and removing descriptors.
+ */
+function createMutableRegistry(...input) {
+    const reg = initBaseRegistry(input);
+    return Object.assign(Object.assign({}, reg), { remove(desc) {
+            var _a;
+            if (desc.kind == "extension") {
+                (_a = reg.extendees.get(desc.extendee.typeName)) === null || _a === void 0 ? void 0 : _a.delete(desc.number);
+            }
+            reg.types.delete(desc.typeName);
+        } });
+}
+exports.createMutableRegistry = createMutableRegistry;
 function createFileRegistry(...args) {
-    const registry = createMutableRegistry();
+    const registry = createBaseRegistry();
     if ("$typeName" in args[0] &&
         args[0].$typeName == "google.protobuf.FileDescriptorSet") {
         for (const file of args[0].file) {
@@ -80,14 +76,14 @@ function createFileRegistry(...args) {
                     throw new Error(`Unable to resolve ${protoFileName}, imported by ${file.name}`);
                 }
                 if ("kind" in dep) {
-                    addDescFile(dep, registry);
+                    registry.addFile(dep, false, true);
                 }
                 else {
                     seen.add(dep.name);
                     deps.push(dep);
                 }
             }
-            return [...deps, ...deps.flatMap((dep) => recurseDeps(dep))];
+            return deps.concat(...deps.map(recurseDeps));
         }
         for (const file of [input, ...recurseDeps(input)].reverse()) {
             addFile(file, registry);
@@ -96,10 +92,7 @@ function createFileRegistry(...args) {
     else {
         for (const fileReg of args) {
             for (const file of fileReg.files) {
-                registry.add(file);
-                for (const type of (0, nested_types_js_1.nestedTypes)(file)) {
-                    registry.add(type);
-                }
+                registry.addFile(file);
             }
         }
     }
@@ -107,47 +100,46 @@ function createFileRegistry(...args) {
 }
 exports.createFileRegistry = createFileRegistry;
 /**
- * Create a mutable file registry.
  * @private
  */
-function createMutableRegistry() {
+function createBaseRegistry() {
     const types = new Map();
     const extendees = new Map();
     const files = new Map();
     return {
         kind: "registry",
+        types,
+        extendees,
         [Symbol.iterator]() {
             return types.values();
         },
         get files() {
             return files.values();
         },
-        add(desc) {
-            switch (desc.kind) {
-                case "file":
-                    files.set(desc.proto.name, desc);
-                    break;
-                // @ts-expect-error TS7029
-                case "extension":
-                    // eslint-disable-next-line no-case-declarations
-                    let numberToExt = extendees.get(desc.extendee.typeName);
-                    if (!numberToExt) {
-                        extendees.set(desc.extendee.typeName, (numberToExt = new Map()));
-                    }
-                    numberToExt.set(desc.number, desc);
-                // eslint-disable-next-line no-fallthrough
-                default:
-                    types.set(desc.typeName, desc);
+        addFile(file, skipTypes, withDeps) {
+            files.set(file.proto.name, file);
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (!skipTypes) {
+                for (const type of (0, nested_types_js_1.nestedTypes)(file)) {
+                    this.add(type);
+                }
+            }
+            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+            if (withDeps) {
+                for (const f of file.dependencies) {
+                    this.addFile(f, skipTypes, withDeps);
+                }
             }
         },
-        remove(desc) {
-            switch (desc.kind) {
-                case "file":
-                    files.delete(desc.proto.name);
-                    break;
-                default:
-                    types.delete(desc.typeName);
+        add(desc) {
+            if (desc.kind == "extension") {
+                let numberToExt = extendees.get(desc.extendee.typeName);
+                if (!numberToExt) {
+                    extendees.set(desc.extendee.typeName, (numberToExt = new Map()));
+                }
+                numberToExt.set(desc.number, desc);
             }
+            types.set(desc.typeName, desc);
         },
         get(typeName) {
             return types.get(typeName);
@@ -178,16 +170,26 @@ function createMutableRegistry() {
     };
 }
 /**
- * Add the file descriptor and the types it contains to the registry.
+ * @private
  */
-function addDescFile(file, reg) {
-    reg.add(file);
-    for (const type of (0, nested_types_js_1.nestedTypes)(file)) {
-        reg.add(type);
-    }
-    for (const dep of file.dependencies) {
-        addDescFile(dep, reg);
+function initBaseRegistry(inputs) {
+    const registry = createBaseRegistry();
+    for (const input of inputs) {
+        switch (input.kind) {
+            case "registry":
+                for (const n of input) {
+                    registry.add(n);
+                }
+                break;
+            case "file":
+                registry.addFile(input);
+                break;
+            default:
+                registry.add(input);
+                break;
+        }
     }
+    return registry;
 }
 // bootstrap-inject google.protobuf.Edition.EDITION_PROTO2: const $name: Edition.$localName = $number;
 const EDITION_PROTO2 = 998;
@@ -306,7 +308,7 @@ function addFile(proto, reg) {
         addFields(message, reg, mapEntries);
         addExtensions(message, reg);
     }
-    reg.add(file);
+    reg.addFile(file, true);
 }
 /**
  * Create descriptors for extensions, and add them to the message / file,

package/dist/cjs/to-binary.d.ts

@@ -17,7 +17,7 @@ export interface BinaryWriteOptions {
      */
     writeUnknownFields: boolean;
 }
-export declare function toBinary<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, options?: Partial<BinaryWriteOptions>): Uint8Array;
+export declare function toBinary<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>, options?: Partial<BinaryWriteOptions>): Uint8Array;
 /**
  * @private
  */

package/dist/cjs/to-binary.js

@@ -26,8 +26,8 @@ const writeDefaults = {
 function makeWriteOptions(options) {
     return options ? Object.assign(Object.assign({}, writeDefaults), options) : writeDefaults;
 }
-function toBinary(messageDesc, message, options) {
-    return writeFields(new binary_encoding_js_1.BinaryWriter(), makeWriteOptions(options), (0, reflect_js_1.reflect)(messageDesc, message)).finish();
+function toBinary(schema, message, options) {
+    return writeFields(new binary_encoding_js_1.BinaryWriter(), makeWriteOptions(options), (0, reflect_js_1.reflect)(schema, message)).finish();
 }
 exports.toBinary = toBinary;
 function writeFields(writer, opts, msg) {

package/dist/cjs/to-json.d.ts

@@ -1,7 +1,7 @@
-import { type DescMessage } from "./descriptors.js";
+import { type DescEnum, type DescMessage } from "./descriptors.js";
 import type { JsonValue } from "./json-value.js";
 import type { Registry } from "./registry.js";
-import type { MessageShape } from "./types.js";
+import type { EnumJsonType, EnumShape, MessageJsonType, MessageShape } from "./types.js";
 /**
  * Options for serializing to JSON.
  */
@@ -44,8 +44,18 @@ export interface JsonWriteStringOptions extends JsonWriteOptions {
  * Serialize the message to a JSON value, a JavaScript value that can be
  * passed to JSON.stringify().
  */
-export declare function toJson<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, options?: Partial<JsonWriteOptions>): JsonValue;
+export declare function toJson<Desc extends DescMessage, Opts extends Partial<JsonWriteOptions> | undefined = undefined>(schema: Desc, message: MessageShape<Desc>, options?: Opts): ToJson<Desc, Opts>;
+type ToJson<Desc extends DescMessage, Opts extends undefined | Partial<JsonWriteOptions>> = Opts extends undefined | {
+    alwaysEmitImplicit?: false;
+    enumAsInteger?: false;
+    useProtoFieldName?: false;
+} ? MessageJsonType<Desc> : JsonValue;
 /**
  * Serialize the message to a JSON string.
  */
-export declare function toJsonString<Desc extends DescMessage>(messageDesc: Desc, message: MessageShape<Desc>, options?: Partial<JsonWriteStringOptions>): string;
+export declare function toJsonString<Desc extends DescMessage>(schema: Desc, message: MessageShape<Desc>, options?: Partial<JsonWriteStringOptions>): string;
+/**
+ * Serialize a single enum value to JSON.
+ */
+export declare function enumToJson<Desc extends DescEnum>(descEnum: Desc, value: EnumShape<Desc>): EnumJsonType<Desc>;
+export {};