@bufbuild/protobuf 0.0.7 → 0.0.10

package/dist/esm/create-registry-from-desc.js

@@ -0,0 +1,375 @@
+// Copyright 2021-2022 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 { assert } from "./private/assert.js";
+import { proto3 } from "./proto3.js";
+import { proto2 } from "./proto2.js";
+import { localName } from "./private/names.js";
+import { Timestamp } from "./google/protobuf/timestamp_pb.js";
+import { Duration } from "./google/protobuf/duration_pb.js";
+import { Any } from "./google/protobuf/any_pb.js";
+import { Empty } from "./google/protobuf/empty_pb.js";
+import { FieldMask } from "./google/protobuf/field_mask_pb.js";
+import { ListValue, NullValue, Struct, Value, } from "./google/protobuf/struct_pb.js";
+import { getEnumType } from "./private/enum.js";
+import { BoolValue, BytesValue, DoubleValue, FloatValue, Int32Value, Int64Value, StringValue, UInt32Value, UInt64Value, } from "./google/protobuf/wrappers_pb.js";
+import { FileDescriptorSet } from "./google/protobuf/descriptor_pb.js";
+import { createDescriptorSet } from "./create-descriptor-set.js";
+// well-known message types with specialized JSON representation
+const wkMessages = [
+    Any,
+    Duration,
+    Empty,
+    FieldMask,
+    Struct,
+    Value,
+    ListValue,
+    Timestamp,
+    Duration,
+    DoubleValue,
+    FloatValue,
+    Int64Value,
+    Int32Value,
+    UInt32Value,
+    UInt64Value,
+    BoolValue,
+    StringValue,
+    BytesValue,
+];
+// well-known enum types with specialized JSON representation
+const wkEnums = [getEnumType(NullValue)];
+/**
+ * Create a registry from a set of descriptors. The types returned by this
+ * registry behave exactly like types from generated code.
+ *
+ * This function accepts google.protobuf.FileDescriptorSet in serialized or
+ * deserialized form. Alternatively, it also accepts a DescriptorSet (see
+ * createDescriptorSet()).
+ *
+ * By default, all well-known types with a specialized JSON representation
+ * are replaced with their generated counterpart in this package.
+ */
+export function createRegistryFromDescriptors(input, replaceWkt = true) {
+    const set = input instanceof Uint8Array || input instanceof FileDescriptorSet
+        ? createDescriptorSet(input)
+        : input;
+    const enums = {};
+    const messages = {};
+    const services = {};
+    if (replaceWkt) {
+        for (const mt of wkMessages) {
+            messages[mt.typeName] = mt;
+        }
+        for (const et of wkEnums) {
+            enums[et.typeName] = et;
+        }
+    }
+    return {
+        /**
+         * May raise an error on invalid descriptors.
+         */
+        findEnum(typeName) {
+            const existing = enums[typeName];
+            if (existing) {
+                return existing;
+            }
+            const desc = set.enums.get(typeName);
+            if (!desc) {
+                return undefined;
+            }
+            const runtime = desc.file.syntax == "proto3" ? proto3 : proto2;
+            const type = runtime.makeEnumType(typeName, desc.values.map((u) => ({
+                no: u.number,
+                name: u.name,
+                localName: localName(u),
+            })), {});
+            enums[typeName] = type;
+            return type;
+        },
+        /**
+         * May raise an error on invalid descriptors.
+         */
+        findMessage(typeName) {
+            const existing = messages[typeName];
+            if (existing) {
+                return existing;
+            }
+            const desc = set.messages.get(typeName);
+            if (!desc) {
+                return undefined;
+            }
+            const runtime = desc.file.syntax == "proto3" ? proto3 : proto2;
+            const fields = [];
+            const type = runtime.makeMessageType(typeName, () => fields, {
+                localName: localName(desc),
+            });
+            messages[typeName] = type;
+            for (const field of desc.fields) {
+                const fieldInfo = makeFieldInfo(field, this);
+                fields.push(fieldInfo);
+            }
+            return type;
+        },
+        /**
+         * May raise an error on invalid descriptors.
+         */
+        findService(typeName) {
+            const existing = services[typeName];
+            if (existing) {
+                return existing;
+            }
+            const desc = set.services.get(typeName);
+            if (!desc) {
+                return undefined;
+            }
+            const methods = {};
+            for (const method of desc.methods) {
+                const I = this.findMessage(method.input.typeName);
+                const O = this.findMessage(method.input.typeName);
+                assert(I, `message "${method.input.typeName}" for ${method.toString()} not found`);
+                assert(O, `output message "${method.output.typeName}" for ${method.toString()} not found`);
+                const m = {
+                    name: method.name,
+                    localName: localName(method),
+                    I,
+                    O,
+                    kind: method.methodKind,
+                    idempotency: method.idempotency,
+                    options: {},
+                };
+                methods[m.localName] = m;
+            }
+            return (services[typeName] = {
+                typeName: desc.typeName,
+                methods,
+            });
+        },
+    };
+}
+/**
+ * DescriptorRegistry is a type registry that dynamically creates types
+ * from a set of google.protobuf.FileDescriptorProto.
+ *
+ * By default, all well-known types with a specialized JSON representation
+ * are replaced with their generated counterpart in this package.
+ */
+export class DescriptorRegistry {
+    constructor(descriptorSet, replaceWkt = true) {
+        this.enums = {};
+        this.messages = {};
+        this.services = {};
+        this.desc = descriptorSet;
+        if (replaceWkt) {
+            for (const mt of wkMessages) {
+                this.messages[mt.typeName] = mt;
+            }
+            for (const et of wkEnums) {
+                this.enums[et.typeName] = et;
+            }
+        }
+    }
+    /**
+     * Conveniently create a DescriptorRegistry from a FileDescriptorSet,
+     * or a FileDescriptorSet in binary format.
+     */
+    static fromFileDescriptorSet(input) {
+        return new DescriptorRegistry(createDescriptorSet(input));
+    }
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    findEnum(typeName) {
+        const existing = this.enums[typeName];
+        if (existing) {
+            return existing;
+        }
+        const desc = this.desc.enums.get(typeName);
+        if (!desc) {
+            return undefined;
+        }
+        const runtime = desc.file.syntax == "proto3" ? proto3 : proto2;
+        const type = runtime.makeEnumType(typeName, desc.values.map((u) => ({
+            no: u.number,
+            name: u.name,
+            localName: localName(u),
+        })), {});
+        this.enums[typeName] = type;
+        return type;
+    }
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    findMessage(typeName) {
+        const existing = this.messages[typeName];
+        if (existing) {
+            return existing;
+        }
+        const desc = this.desc.messages.get(typeName);
+        if (!desc) {
+            return undefined;
+        }
+        const runtime = desc.file.syntax == "proto3" ? proto3 : proto2;
+        const fields = [];
+        const type = runtime.makeMessageType(typeName, () => fields, {
+            localName: localName(desc),
+        });
+        this.messages[typeName] = type;
+        for (const field of desc.fields) {
+            const fieldInfo = makeFieldInfo(field, this);
+            fields.push(fieldInfo);
+        }
+        return type;
+    }
+    /**
+     * May raise an error on invalid descriptors.
+     */
+    findService(typeName) {
+        const existing = this.services[typeName];
+        if (existing) {
+            return existing;
+        }
+        const desc = this.desc.services.get(typeName);
+        if (!desc) {
+            return undefined;
+        }
+        const methods = {};
+        for (const method of desc.methods) {
+            const I = this.findMessage(method.input.typeName);
+            const O = this.findMessage(method.input.typeName);
+            assert(I, `message "${method.input.typeName}" for ${method.toString()} not found`);
+            assert(O, `output message "${method.output.typeName}" for ${method.toString()} not found`);
+            const m = {
+                name: method.name,
+                localName: localName(method),
+                I,
+                O,
+                kind: method.methodKind,
+                idempotency: method.idempotency,
+                options: {},
+            };
+            methods[m.localName] = m;
+        }
+        return (this.services[typeName] = {
+            typeName: desc.typeName,
+            methods,
+        });
+    }
+}
+function makeFieldInfo(desc, resolver) {
+    switch (desc.kind) {
+        case "map_field":
+            return makeMapFieldInfo(desc, resolver);
+        case "message_field":
+            return makeMessageFieldInfo(desc, resolver);
+        case "enum_field": {
+            const fi = makeEnumFieldInfo(desc, resolver);
+            fi.default = desc.getDefaultValue();
+            return fi;
+        }
+        case "scalar_field": {
+            const fi = makeScalarFieldInfo(desc);
+            fi.default = desc.getDefaultValue();
+            return fi;
+        }
+    }
+}
+function makeMapFieldInfo(field, resolver) {
+    const base = {
+        kind: "map",
+        no: field.number,
+        name: field.name,
+        jsonName: field.jsonName,
+        K: field.mapKey,
+    };
+    if (field.mapValue.message) {
+        const messageType = resolver.findMessage(field.mapValue.message.typeName);
+        assert(messageType, `message "${field.mapValue.message.typeName}" for ${field.toString()} not found`);
+        return Object.assign(Object.assign({}, base), { V: {
+                kind: "message",
+                T: messageType,
+            } });
+    }
+    if (field.mapValue.enum) {
+        const enumType = resolver.findEnum(field.mapValue.enum.typeName);
+        assert(enumType, `enum "${field.mapValue.enum.typeName}" for ${field.toString()} not found`);
+        return Object.assign(Object.assign({}, base), { V: {
+                kind: "enum",
+                T: enumType,
+            } });
+    }
+    return Object.assign(Object.assign({}, base), { V: {
+            kind: "scalar",
+            T: field.mapValue.scalar,
+        } });
+}
+function makeScalarFieldInfo(field) {
+    const base = {
+        kind: "scalar",
+        no: field.number,
+        name: field.name,
+        jsonName: field.jsonName,
+        T: field.scalar,
+    };
+    if (field.repeated) {
+        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined, T: field.scalar });
+    }
+    if (field.oneof) {
+        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
+    }
+    if (field.optional) {
+        return Object.assign(Object.assign({}, base), { opt: true });
+    }
+    return base;
+}
+function makeMessageFieldInfo(field, resolver) {
+    const messageType = resolver.findMessage(field.message.typeName);
+    assert(messageType, `message "${field.message.typeName}" for ${field.toString()} not found`);
+    const base = {
+        kind: "message",
+        no: field.number,
+        name: field.name,
+        jsonName: field.jsonName,
+        T: messageType,
+    };
+    if (field.repeated) {
+        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });
+    }
+    if (field.oneof) {
+        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
+    }
+    if (field.optional) {
+        return Object.assign(Object.assign({}, base), { opt: true });
+    }
+    return base;
+}
+function makeEnumFieldInfo(field, resolver) {
+    const enumType = resolver.findEnum(field.enum.typeName);
+    assert(enumType, `enum "${field.enum.typeName}" for ${field.toString()} not found`);
+    const base = {
+        kind: "enum",
+        no: field.number,
+        name: field.name,
+        jsonName: field.jsonName,
+        T: enumType,
+    };
+    if (field.repeated) {
+        return Object.assign(Object.assign({}, base), { repeated: true, packed: field.packed, oneof: undefined });
+    }
+    if (field.oneof) {
+        return Object.assign(Object.assign({}, base), { oneof: field.oneof.name });
+    }
+    if (field.optional) {
+        return Object.assign(Object.assign({}, base), { opt: true });
+    }
+    return base;
+}

package/dist/esm/create-registry.js

@@ -0,0 +1,71 @@
+// Copyright 2021-2022 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.
+/**
+ * Create a new registry from the given types. Note that
+ */
+export function createRegistry(...types) {
+    const messages = {};
+    const enums = {};
+    const services = {};
+    const registry = {
+        /**
+         * Add a type to the registry. For messages, the types used in message
+         * fields are added recursively. For services, the message types used
+         * for requests and responses are added recursively.
+         */
+        add(type) {
+            if ("fields" in type) {
+                if (!this.findMessage(type.typeName)) {
+                    messages[type.typeName] = type;
+                    for (const field of type.fields.list()) {
+                        if (field.kind == "message") {
+                            this.add(field.T);
+                        }
+                        else if (field.kind == "map" && field.V.kind == "message") {
+                            this.add(field.V.T);
+                        }
+                        else if (field.kind == "enum") {
+                            this.add(field.T);
+                        }
+                    }
+                }
+            }
+            else if ("methods" in type) {
+                if (!this.findService(type.typeName)) {
+                    services[type.typeName] = type;
+                    for (const method of Object.values(type.methods)) {
+                        this.add(method.I);
+                        this.add(method.O);
+                    }
+                }
+            }
+            else {
+                enums[type.typeName] = type;
+            }
+        },
+        findMessage(typeName) {
+            return messages[typeName];
+        },
+        findEnum(typeName) {
+            return enums[typeName];
+        },
+        findService(typeName) {
+            return services[typeName];
+        },
+    };
+    for (const type of types) {
+        registry.add(type);
+    }
+    return registry;
+}