@bufbuild/protobuf 1.9.0 → 2.0.0-alpha.2

package/dist/esm/reflect/reflect.js

@@ -0,0 +1,428 @@
+// 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.
+import { checkField, checkListItem, checkMapEntry } from "./reflect-check.js";
+import { FieldError } from "./error.js";
+import { unsafeAddListItem, unsafeClear, unsafeGet, unsafeIsSet, unsafeLocal, unsafeOneofCase, unsafeSet, unsafeSetMapEntry, } from "./unsafe.js";
+import { create } from "../create.js";
+import { isWrapper, isWrapperDesc } from "../wkt/wrappers.js";
+import { LongType, ScalarType, scalarZeroValue } from "./scalar.js";
+import { protoInt64 } from "../proto-int64.js";
+import { isReflectList, isReflectMap, isReflectMessage } from "./guard.js";
+/**
+ * Create a ReflectMessage.
+ */
+export 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);
+}
+class ReflectMessageImpl {
+    get sortedFields() {
+        var _a;
+        return ((_a = this._sortedFields) !== null && _a !== void 0 ? _a : (this._sortedFields = this.desc.fields
+            .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) {
+        this.check = check;
+        this.desc = messageDesc;
+        this.message = this[unsafeLocal] = message !== null && message !== void 0 ? message : create(messageDesc);
+        this.fields = messageDesc.fields;
+        this.oneofs = messageDesc.oneofs;
+        this.members = messageDesc.members;
+    }
+    findNumber(number) {
+        if (!this._fieldsByNumber) {
+            this._fieldsByNumber = new Map(this.desc.fields.map((f) => [f.number, f]));
+        }
+        return this._fieldsByNumber.get(number);
+    }
+    oneofCase(oneof) {
+        assertOwn(this.message, oneof);
+        return unsafeOneofCase(this.message, oneof);
+    }
+    isSet(field) {
+        assertOwn(this.message, field);
+        return unsafeIsSet(this.message, field);
+    }
+    clear(field) {
+        assertOwn(this.message, field);
+        unsafeClear(this.message, field);
+    }
+    get(field) {
+        assertOwn(this.message, field);
+        let value = unsafeGet(this.message, field);
+        switch (field.fieldKind) {
+            case "list":
+                return new ReflectListImpl(field, value, this.check);
+            case "map":
+                // TODO fix types
+                // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+                return reflectMap(field, value, this.check); // eslint-disable-line @typescript-eslint/no-explicit-any, @typescript-eslint/no-unsafe-return
+            case "message":
+                if (value !== undefined &&
+                    !field.oneof &&
+                    isWrapperDesc(field.message)) {
+                    value = {
+                        $typeName: field.message.typeName,
+                        value: longToReflect(field.message.fields[0], value),
+                    };
+                }
+                return new ReflectMessageImpl(field.message, value, this.check);
+            case "scalar":
+                return (value === undefined
+                    ? scalarZeroValue(field.scalar, LongType.BIGINT)
+                    : longToReflect(field, value));
+            case "enum":
+                return (value !== null && value !== void 0 ? value : field.enum.values[0].number);
+        }
+    }
+    set(field, value) {
+        assertOwn(this.message, field);
+        if (this.check) {
+            const err = checkField(field, value);
+            if (err) {
+                return err;
+            }
+        }
+        let local = value;
+        if (isReflectMap(value) || isReflectList(value)) {
+            local = value[unsafeLocal];
+        }
+        else if (isReflectMessage(value)) {
+            const msg = value.message;
+            local = !field.oneof && isWrapper(msg) ? msg.value : msg;
+        }
+        else {
+            local = longToLocal(field, value);
+        }
+        unsafeSet(this.message, field, local);
+        return undefined;
+    }
+    addListItem(field, value) {
+        assertOwn(this.message, field);
+        assertKind(field, "list");
+        if (this.check) {
+            if (checkListItem(field, 0, value)) {
+                const arr = unsafeGet(this.message, field);
+                return checkListItem(field, arr.length, value);
+            }
+        }
+        unsafeAddListItem(this.message, field, listItemToLocal(field, value));
+        return undefined;
+    }
+    setMapEntry(field, key, value) {
+        assertOwn(this.message, field);
+        assertKind(field, "map");
+        if (this.check) {
+            const err = checkMapEntry(field, key, value);
+            if (err) {
+                return err;
+            }
+        }
+        unsafeSetMapEntry(this.message, field, mapKeyToLocal(key), mapValueToLocal(field, value));
+        return undefined;
+    }
+    getUnknown() {
+        return this.message.$unknown;
+    }
+    setUnknown(value) {
+        this.message.$unknown = value;
+    }
+}
+function assertKind(field, kind) {
+    if (field.fieldKind != kind) {
+        throw new FieldError(field, `${field.toString()} is ${field.fieldKind}`, "ForeignFieldError");
+    }
+}
+function assertOwn(owner, member) {
+    if (member.parent.typeName !== owner.$typeName) {
+        throw new FieldError(member, `cannot use ${member.toString()} with message ${owner.$typeName}`, "ForeignFieldError");
+    }
+}
+/**
+ * Create a ReflectList.
+ */
+export function reflectList(field, unsafeInput, check = true) {
+    return new ReflectListImpl(field, unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : [], check);
+}
+class ReflectListImpl {
+    field() {
+        return this._field;
+    }
+    get size() {
+        return this._arr.length;
+    }
+    constructor(field, unsafeInput, check) {
+        this._field = field;
+        this._arr = this[unsafeLocal] = unsafeInput;
+        this.check = check;
+    }
+    get(index) {
+        const item = this._arr[index];
+        return item === undefined
+            ? undefined
+            : listItemToReflect(this._field, item, this.check);
+    }
+    set(index, item) {
+        if (index < 0 || index >= this._arr.length) {
+            return new FieldError(this._field, `list item #${index + 1}: out of range`);
+        }
+        if (this.check) {
+            const err = checkListItem(this._field, index, item);
+            if (err) {
+                return err;
+            }
+        }
+        this._arr[index] = listItemToLocal(this._field, item);
+        return undefined;
+    }
+    add(...items) {
+        if (this.check) {
+            for (let i = 0; i < items.length; i++) {
+                const err = checkListItem(this._field, this._arr.length + i, items[i]);
+                if (err) {
+                    return err;
+                }
+            }
+        }
+        for (const item of items) {
+            this._arr.push(listItemToLocal(this._field, item));
+        }
+        return undefined;
+    }
+    clear() {
+        this._arr.splice(0, this._arr.length);
+    }
+    [Symbol.iterator]() {
+        return this.values();
+    }
+    keys() {
+        return this._arr.keys();
+    }
+    *values() {
+        for (const item of this._arr) {
+            yield listItemToReflect(this._field, item, this.check);
+        }
+    }
+    *entries() {
+        for (let i = 0; i < this._arr.length; i++) {
+            yield [i, listItemToReflect(this._field, this._arr[i], this.check)];
+        }
+    }
+}
+/**
+ * Create a ReflectMap.
+ */
+export function reflectMap(field, unsafeInput, check = true) {
+    return new ReflectMapImpl(field, unsafeInput, check);
+}
+class ReflectMapImpl {
+    constructor(field, unsafeInput, check = true) {
+        this.obj = this[unsafeLocal] = unsafeInput !== null && unsafeInput !== void 0 ? unsafeInput : {};
+        this.check = check;
+        this._field = field;
+    }
+    field() {
+        return this._field;
+    }
+    set(key, value) {
+        if (this.check) {
+            const err = checkMapEntry(this._field, key, value);
+            if (err) {
+                return err;
+            }
+        }
+        this.obj[mapKeyToLocal(key)] = mapValueToLocal(this._field, value);
+        return undefined;
+    }
+    delete(key) {
+        const k = mapKeyToLocal(key);
+        const has = Object.prototype.hasOwnProperty.call(this.obj, k);
+        if (has) {
+            delete this.obj[k];
+        }
+        return has;
+    }
+    clear() {
+        for (const key of Object.keys(this.obj)) {
+            delete this.obj[key];
+        }
+    }
+    get(key) {
+        let val = this.obj[mapKeyToLocal(key)];
+        if (val !== undefined) {
+            val = mapValueToReflect(this._field, val, this.check);
+        }
+        return val;
+    }
+    has(key) {
+        return Object.prototype.hasOwnProperty.call(this.obj, mapKeyToLocal(key));
+    }
+    *keys() {
+        for (const objKey of Object.keys(this.obj)) {
+            yield mapKeyToReflect(objKey, this._field.mapKey);
+        }
+    }
+    *entries() {
+        for (const objEntry of Object.entries(this.obj)) {
+            yield [
+                mapKeyToReflect(objEntry[0], this._field.mapKey),
+                mapValueToReflect(this._field, objEntry[1], this.check),
+            ];
+        }
+    }
+    [Symbol.iterator]() {
+        return this.entries();
+    }
+    get size() {
+        return Object.keys(this.obj).length;
+    }
+    *values() {
+        for (const val of Object.values(this.obj)) {
+            yield mapValueToReflect(this._field, val, this.check);
+        }
+    }
+    forEach(callbackfn, thisArg) {
+        for (const mapEntry of this.entries()) {
+            callbackfn.call(thisArg, mapEntry[1], mapEntry[0], this);
+        }
+    }
+}
+function listItemToLocal(field, value) {
+    if (isReflectMessage(value)) {
+        return value.message;
+    }
+    return longToLocal(field, value);
+}
+function listItemToReflect(field, value, check) {
+    if (field.listKind == "message") {
+        return new ReflectMessageImpl(field.message, value, check);
+    }
+    return longToReflect(field, value);
+}
+function mapValueToLocal(field, value) {
+    if (isReflectMessage(value)) {
+        return value.message;
+    }
+    return longToLocal(field, value);
+}
+function mapValueToReflect(field, value, check) {
+    if (field.mapKind == "message") {
+        return new ReflectMessageImpl(field.message, value, check);
+    }
+    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 ScalarType.STRING:
+            return key;
+        case ScalarType.INT32:
+        case ScalarType.FIXED32:
+        case ScalarType.UINT32:
+        case ScalarType.SFIXED32:
+        case ScalarType.SINT32: {
+            const n = Number.parseInt(key);
+            if (Number.isFinite(n)) {
+                return n;
+            }
+            break;
+        }
+        case ScalarType.BOOL:
+            switch (key) {
+                case "true":
+                    return true;
+                case "false":
+                    return false;
+            }
+            break;
+        case ScalarType.UINT64:
+        case ScalarType.FIXED64:
+            try {
+                return protoInt64.uParse(key);
+            }
+            catch (_a) {
+                //
+            }
+            break;
+        default:
+            // INT64, SFIXED64, SINT64
+            try {
+                return protoInt64.parse(key);
+            }
+            catch (_b) {
+                //
+            }
+            break;
+    }
+    return key;
+}
+function longToReflect(field, value) {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.scalar) {
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            if ("longType" in field &&
+                field.longType == LongType.STRING &&
+                typeof value == "string") {
+                value = protoInt64.parse(value);
+            }
+            break;
+        case ScalarType.FIXED64:
+        case ScalarType.UINT64:
+            if ("longType" in field &&
+                field.longType == LongType.STRING &&
+                typeof value == "string") {
+                value = protoInt64.uParse(value);
+            }
+            break;
+    }
+    return value;
+}
+function longToLocal(field, value) {
+    // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+    switch (field.scalar) {
+        case ScalarType.INT64:
+        case ScalarType.SFIXED64:
+        case ScalarType.SINT64:
+            if ("longType" in field && field.longType == LongType.STRING) {
+                value = String(value);
+            }
+            else if (typeof value == "string" || typeof value == "number") {
+                value = protoInt64.parse(value);
+            }
+            break;
+        case ScalarType.FIXED64:
+        case ScalarType.UINT64:
+            if ("longType" in field && field.longType == LongType.STRING) {
+                value = String(value);
+            }
+            else if (typeof value == "string" || typeof value == "number") {
+                value = protoInt64.uParse(value);
+            }
+            break;
+    }
+    return value;
+}

package/dist/esm/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;