@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.1

package/dist/cjs/reflect/reflect.js

@@ -0,0 +1,409 @@
+"use strict";
+// Copyright 2021-2024 Buf Technologies, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reflectMap = exports.reflectList = exports.reflect = void 0;
+const reflect_check_js_1 = require("./reflect-check.js");
+const error_js_1 = require("./error.js");
+const unsafe_js_1 = require("./unsafe.js");
+const create_js_1 = require("../create.js");
+const wrappers_js_1 = require("../wkt/wrappers.js");
+const scalar_js_1 = require("./scalar.js");
+const proto_int64_js_1 = require("../proto-int64.js");
+const guard_js_1 = require("./guard.js");
+function reflect(messageDesc, message, 
+// TODO either remove this option, or support it in reflect-list and reflect-map as well
+opt) {
+    message !== null && message !== void 0 ? message : (message = (0, create_js_1.create)(messageDesc));
+    const check = (opt === null || opt === void 0 ? void 0 : opt.disableFieldValueCheck) !== true;
+    let fieldsByNumber;
+    let sortedFields;
+    return {
+        message,
+        [unsafe_js_1.unsafeLocal]: message,
+        desc: messageDesc,
+        fields: messageDesc.fields,
+        oneofs: messageDesc.oneofs,
+        members: messageDesc.members,
+        get sortedFields() {
+            return (sortedFields !== null && sortedFields !== void 0 ? sortedFields : (sortedFields = messageDesc.fields
+                .concat()
+                .sort((a, b) => a.number - b.number)));
+        },
+        findNumber(number) {
+            if (!fieldsByNumber) {
+                fieldsByNumber = new Map(messageDesc.fields.map((f) => [f.number, f]));
+            }
+            return fieldsByNumber.get(number);
+        },
+        oneofCase(oneof) {
+            assertOwn(message, oneof);
+            return (0, unsafe_js_1.unsafeOneofCase)(message, oneof);
+        },
+        isSet(field) {
+            assertOwn(message, field);
+            return (0, unsafe_js_1.unsafeIsSet)(message, field);
+        },
+        clear(field) {
+            assertOwn(message, field);
+            (0, unsafe_js_1.unsafeClear)(message, field);
+        },
+        get(field) {
+            assertOwn(message, field);
+            let value = (0, unsafe_js_1.unsafeGet)(message, field);
+            switch (field.fieldKind) {
+                case "list":
+                    return reflectList(field, value);
+                case "map":
+                    // TODO fix types
+                    // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                    return reflectMap(field, value); // eslint-disable-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
+                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 reflect(field.message, value);
+                case "scalar":
+                    return longToReflect(field, value);
+                case "enum":
+                    return value;
+            }
+        },
+        set(field, value) {
+            assertOwn(message, field);
+            if (check) {
+                const err = (0, reflect_check_js_1.checkField)(field, value);
+                if (err) {
+                    return err;
+                }
+            }
+            let local = value;
+            if ((0, guard_js_1.isReflectMap)(value) || (0, guard_js_1.isReflectList)(value)) {
+                local = value[unsafe_js_1.unsafeLocal];
+            }
+            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 {
+                local = longToLocal(field, value);
+            }
+            (0, unsafe_js_1.unsafeSet)(message, field, local);
+            return undefined;
+        },
+        addListItem(field, value) {
+            assertOwn(message, field);
+            assertKind(field, "list");
+            if (check) {
+                if ((0, reflect_check_js_1.checkListItem)(field, 0, value)) {
+                    const arr = (0, unsafe_js_1.unsafeGet)(message, field);
+                    return (0, reflect_check_js_1.checkListItem)(field, arr.length, value);
+                }
+            }
+            (0, unsafe_js_1.unsafeAddListItem)(message, field, listItemToLocal(field, value));
+            return undefined;
+        },
+        setMapEntry(field, key, value) {
+            assertOwn(message, field);
+            assertKind(field, "map");
+            if (check) {
+                const err = (0, reflect_check_js_1.checkMapEntry)(field, key, value);
+                if (err) {
+                    return err;
+                }
+            }
+            (0, unsafe_js_1.unsafeSetMapEntry)(message, field, mapKeyToLocal(key), mapValueToLocal(field, value));
+            return undefined;
+        },
+        getUnknown() {
+            return message.$unknown;
+        },
+        setUnknown(value) {
+            message.$unknown = value;
+        },
+    };
+}
+exports.reflect = reflect;
+function assertKind(field, kind) {
+    if (field.fieldKind != kind) {
+        throw new error_js_1.FieldError(field, `${field.toString()} is ${field.fieldKind}`, "ForeignFieldError");
+    }
+}
+function assertOwn(owner, member) {
+    if (member.parent.typeName !== owner.$typeName) {
+        throw new error_js_1.FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError");
+    }
+}
+function reflectList(field, unsafeInput) {
+    const arr = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [];
+    return {
+        [unsafe_js_1.unsafeLocal]: arr,
+        field() {
+            return field;
+        },
+        get size() {
+            return arr.length;
+        },
+        get(index) {
+            const item = arr[index];
+            return item === undefined
+                ? undefined
+                : listItemToReflect(field, item);
+        },
+        set(index, item) {
+            if (index < 0 || index >= arr.length) {
+                return new error_js_1.FieldError(field, `list item #${index + 1}: out of range`);
+            }
+            const err = (0, reflect_check_js_1.checkListItem)(field, index, item);
+            if (!err) {
+                arr[index] = listItemToLocal(field, item);
+            }
+            return err;
+        },
+        add(...items) {
+            let err;
+            for (let i = 0; i < items.length && !err; i++) {
+                err = (0, reflect_check_js_1.checkListItem)(field, arr.length + i, items[i]);
+            }
+            if (!err) {
+                for (const item of items) {
+                    arr.push(listItemToLocal(field, item));
+                }
+            }
+            return err;
+        },
+        clear() {
+            arr.splice(0, arr.length);
+        },
+        [Symbol.iterator]() {
+            return this.values();
+        },
+        keys() {
+            return arr.keys();
+        },
+        *values() {
+            for (const item of arr) {
+                yield listItemToReflect(field, item);
+            }
+        },
+        *entries() {
+            for (let i = 0; i < arr.length; i++) {
+                yield [i, listItemToReflect(field, arr[i])];
+            }
+        },
+    };
+}
+exports.reflectList = reflectList;
+function reflectMap(field, unsafeInput) {
+    const obj = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {};
+    return {
+        [unsafe_js_1.unsafeLocal]: obj,
+        field() {
+            return field;
+        },
+        set(key, value) {
+            const err = (0, reflect_check_js_1.checkMapEntry)(field, key, value);
+            if (!err) {
+                obj[mapKeyToLocal(key)] = mapValueToLocal(field, value);
+            }
+            return err;
+        },
+        delete(key) {
+            const k = mapKeyToLocal(key);
+            const has = Object.prototype.hasOwnProperty.call(obj, k);
+            if (has) {
+                delete obj[k];
+            }
+            return has;
+        },
+        clear() {
+            for (const key of Object.keys(obj)) {
+                delete obj[key];
+            }
+        },
+        get(key) {
+            let val = obj[mapKeyToLocal(key)];
+            if (val !== undefined) {
+                val = mapValueToReflect(field, val);
+            }
+            return val;
+        },
+        has(key) {
+            return Object.prototype.hasOwnProperty.call(obj, mapKeyToLocal(key));
+        },
+        *keys() {
+            for (const objKey of Object.keys(obj)) {
+                yield mapKeyToReflect(objKey, field.mapKey);
+            }
+        },
+        *entries() {
+            for (const objEntry of Object.entries(obj)) {
+                yield [
+                    mapKeyToReflect(objEntry[0], field.mapKey),
+                    mapValueToReflect(field, objEntry[1]),
+                ];
+            }
+        },
+        [Symbol.iterator]() {
+            return this.entries();
+        },
+        get size() {
+            return Object.keys(obj).length;
+        },
+        *values() {
+            for (const val of Object.values(obj)) {
+                yield mapValueToReflect(field, val);
+            }
+        },
+        forEach(callbackfn, thisArg) {
+            for (const mapEntry of this.entries()) {
+                callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this);
+            }
+        },
+    };
+}
+exports.reflectMap = reflectMap;
+function listItemToLocal(field, value) {
+    if ((0, guard_js_1.isReflectMessage)(value)) {
+        return value.message;
+    }
+    return longToLocal(field, value);
+}
+function listItemToReflect(field, value) {
+    if (field.listKind == "message") {
+        return reflect(field.message, value);
+    }
+    return longToReflect(field, value);
+}
+function mapValueToLocal(field, value) {
+    if ((0, guard_js_1.isReflectMessage)(value)) {
+        return value.message;
+    }
+    return longToLocal(field, value);
+}
+function mapValueToReflect(field, value) {
+    if (field.mapKind == "message") {
+        return reflect(field.message, value);
+    }
+    return value;
+}
+function mapKeyToLocal(key) {
+    return typeof key == "string" || typeof key == "number" ? key : String(key);
+}
+/**
+ * Converts a map key (any scalar value except float, double, or bytes) from its
+ * representation in a message (string or number, the only possible object key
+ * types) to the closest possible type in ECMAScript.
+ */
+function mapKeyToReflect(key, type) {
+    switch (type) {
+        case scalar_js_1.ScalarType.STRING:
+            return key;
+        case scalar_js_1.ScalarType.INT32:
+        case scalar_js_1.ScalarType.FIXED32:
+        case scalar_js_1.ScalarType.UINT32:
+        case scalar_js_1.ScalarType.SFIXED32:
+        case scalar_js_1.ScalarType.SINT32: {
+            const n = Number.parseInt(key);
+            if (Number.isFinite(n)) {
+                return n;
+            }
+            break;
+        }
+        case scalar_js_1.ScalarType.BOOL:
+            switch (key) {
+                case "true":
+                    return true;
+                case "false":
+                    return false;
+            }
+            break;
+        case scalar_js_1.ScalarType.UINT64:
+        case scalar_js_1.ScalarType.FIXED64:
+            try {
+                return proto_int64_js_1.protoInt64.uParse(key);
+            }
+            catch (_a) {
+                //
+            }
+            break;
+        default:
+            // INT64, SFIXED64, SINT64
+            try {
+                return proto_int64_js_1.protoInt64.parse(key);
+            }
+            catch (_b) {
+                //
+            }
+            break;
+    }
+    return key;
+}
+function longToReflect(field, value) {
+    if (field.scalar !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (field.scalar) {
+            case scalar_js_1.ScalarType.INT64:
+            case scalar_js_1.ScalarType.SFIXED64:
+            case scalar_js_1.ScalarType.SINT64:
+                if ("longType" in field &&
+                    field.longType == scalar_js_1.LongType.STRING &&
+                    typeof value == "string") {
+                    value = proto_int64_js_1.protoInt64.parse(value);
+                }
+                break;
+            case scalar_js_1.ScalarType.FIXED64:
+            case scalar_js_1.ScalarType.UINT64:
+                if ("longType" in field &&
+                    field.longType == scalar_js_1.LongType.STRING &&
+                    typeof value == "string") {
+                    value = proto_int64_js_1.protoInt64.uParse(value);
+                }
+                break;
+        }
+    }
+    return value;
+}
+function longToLocal(field, value) {
+    if (field.scalar !== undefined) {
+        // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+        switch (field.scalar) {
+            case scalar_js_1.ScalarType.INT64:
+            case scalar_js_1.ScalarType.SFIXED64:
+            case scalar_js_1.ScalarType.SINT64:
+                if ("longType" in field && field.longType == scalar_js_1.LongType.STRING) {
+                    value = String(value);
+                }
+                else if (typeof value == "string" || typeof value == "number") {
+                    value = proto_int64_js_1.protoInt64.parse(value);
+                }
+                break;
+            case scalar_js_1.ScalarType.FIXED64:
+            case scalar_js_1.ScalarType.UINT64:
+                if ("longType" in field && field.longType == scalar_js_1.LongType.STRING) {
+                    value = String(value);
+                }
+                else if (typeof value == "string" || typeof value == "number") {
+                    value = proto_int64_js_1.protoInt64.uParse(value);
+                }
+                break;
+        }
+    }
+    return value;
+}

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

@@ -0,0 +1,82 @@
+import type { FileDescriptorProto, FileDescriptorSet } from "../wkt/gen/google/protobuf/descriptor_pb.js";
+import type { DescEnum, DescExtension, DescFile, DescMessage, DescService, SupportedEdition } from "../desc-types.js";
+/**
+ * A set of descriptors for messages, enumerations, extensions,
+ * and services.
+ */
+export interface Registry {
+    readonly kind: "registry";
+    /**
+     * All types (message, enumeration, extension, or service) contained
+     * in this registry.
+     */
+    [Symbol.iterator](): IterableIterator<DescMessage | DescEnum | DescExtension | DescService>;
+    /**
+     * Look up a type (message, enumeration, extension, or service) by
+     * its fully qualified name.
+     */
+    get(typeName: string): DescMessage | DescEnum | DescExtension | DescService | undefined;
+    /**
+     * Look up a message descriptor by its fully qualified name.
+     */
+    getMessage(typeName: string): DescMessage | undefined;
+    /**
+     * Look up an enumeration descriptor by its fully qualified name.
+     */
+    getEnum(typeName: string): DescEnum | undefined;
+    /**
+     * Look up an extension descriptor by its fully qualified name.
+     */
+    getExtension(typeName: string): DescExtension | undefined;
+    /**
+     * Look up an extension by the extendee - the message it extends - and
+     * the extension number.
+     */
+    getExtensionFor(extendee: DescMessage, no: number): DescExtension | undefined;
+    /**
+     * Look up a service descriptor by its fully qualified name.
+     */
+    getService(typeName: string): DescService | undefined;
+}
+/**
+ * A set of descriptors for messages, enumerations, extensions,
+ * and services - and files.
+ */
+export interface FileRegistry extends Registry {
+    /**
+     * All files in this registry.
+     */
+    readonly files: Iterable<DescFile>;
+    /**
+     * Look up a file descriptor by file name.
+     */
+    getFile(fileName: string): DescFile | undefined;
+}
+/**
+ * Create a registry from the given inputs.
+ *
+ * An input can be:
+ * - Any message, enum, service, or extension descriptor, which adds just the
+ *   descriptor for this type.
+ * - A file descriptor, which adds all typed defined in this file.
+ * - A registry, which adds all types from the 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 (including file descriptors) from a google.protobuf.FileDescriptorSet
+ * message.
+ */
+export declare function createFileRegistry(fileDescriptorSet: FileDescriptorSet): FileRegistry;
+/**
+ * Create a registry (including file descriptors) from a google.protobuf.FileDescriptorProto
+ * message. For every import, the given resolver function is called.
+ */
+export declare function createFileRegistry(fileDescriptorProto: FileDescriptorProto, resolve: (protoFileName: string) => FileDescriptorProto | DescFile | undefined): FileRegistry;
+/**
+ * Create a registry (including file descriptors) from one or more registries,
+ * merging them.
+ */
+export declare function createFileRegistry(...registries: FileRegistry[]): FileRegistry;
+export declare const minimumEdition: SupportedEdition, maximumEdition: SupportedEdition;