@bufbuild/protobuf 0.0.8 → 0.0.9

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

@@ -0,0 +1,376 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescriptorRegistry = exports.createRegistryFromDescriptors = void 0;
+const assert_js_1 = require("./private/assert.js");
+const proto3_js_1 = require("./proto3.js");
+const proto2_js_1 = require("./proto2.js");
+const names_js_1 = require("./private/names.js");
+const timestamp_pb_js_1 = require("./google/protobuf/timestamp_pb.js");
+const duration_pb_js_1 = require("./google/protobuf/duration_pb.js");
+const any_pb_js_1 = require("./google/protobuf/any_pb.js");
+const empty_pb_js_1 = require("./google/protobuf/empty_pb.js");
+const field_mask_pb_js_1 = require("./google/protobuf/field_mask_pb.js");
+const struct_pb_js_1 = require("./google/protobuf/struct_pb.js");
+const enum_js_1 = require("./private/enum.js");
+const wrappers_pb_js_1 = require("./google/protobuf/wrappers_pb.js");
+const descriptor_pb_js_1 = require("./google/protobuf/descriptor_pb.js");
+const create_descriptor_set_js_1 = require("./create-descriptor-set.js");
+// well-known message types with specialized JSON representation
+const wkMessages = [
+    any_pb_js_1.Any,
+    duration_pb_js_1.Duration,
+    empty_pb_js_1.Empty,
+    field_mask_pb_js_1.FieldMask,
+    struct_pb_js_1.Struct,
+    struct_pb_js_1.Value,
+    struct_pb_js_1.ListValue,
+    timestamp_pb_js_1.Timestamp,
+    duration_pb_js_1.Duration,
+    wrappers_pb_js_1.DoubleValue,
+    wrappers_pb_js_1.FloatValue,
+    wrappers_pb_js_1.Int64Value,
+    wrappers_pb_js_1.Int32Value,
+    wrappers_pb_js_1.UInt32Value,
+    wrappers_pb_js_1.UInt64Value,
+    wrappers_pb_js_1.BoolValue,
+    wrappers_pb_js_1.StringValue,
+    wrappers_pb_js_1.BytesValue,
+];
+// well-known enum types with specialized JSON representation
+const wkEnums = [(0, enum_js_1.getEnumType)(struct_pb_js_1.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.
+ */
+function createRegistryFromDescriptors(input, replaceWkt = true) {
+    const set = input instanceof Uint8Array || input instanceof descriptor_pb_js_1.FileDescriptorSet
+        ? (0, create_descriptor_set_js_1.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_js_1.proto3 : proto2_js_1.proto2;
+            const type = runtime.makeEnumType(typeName, desc.values.map((u) => ({
+                no: u.number,
+                name: u.name,
+                localName: (0, names_js_1.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_js_1.proto3 : proto2_js_1.proto2;
+            const fields = [];
+            const type = runtime.makeMessageType(typeName, () => fields, {
+                localName: (0, names_js_1.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);
+                (0, assert_js_1.assert)(I, `message "${method.input.typeName}" for ${method.toString()} not found`);
+                (0, assert_js_1.assert)(O, `output message "${method.output.typeName}" for ${method.toString()} not found`);
+                const m = {
+                    name: method.name,
+                    localName: (0, names_js_1.localName)(method),
+                    I,
+                    O,
+                    kind: method.methodKind,
+                    idempotency: method.idempotency,
+                    options: {},
+                };
+                methods[m.localName] = m;
+            }
+            return (services[typeName] = {
+                typeName: desc.typeName,
+                methods,
+            });
+        },
+    };
+}
+exports.createRegistryFromDescriptors = createRegistryFromDescriptors;
+/**
+ * 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.
+ */
+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((0, create_descriptor_set_js_1.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_js_1.proto3 : proto2_js_1.proto2;
+        const type = runtime.makeEnumType(typeName, desc.values.map((u) => ({
+            no: u.number,
+            name: u.name,
+            localName: (0, names_js_1.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_js_1.proto3 : proto2_js_1.proto2;
+        const fields = [];
+        const type = runtime.makeMessageType(typeName, () => fields, {
+            localName: (0, names_js_1.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);
+            (0, assert_js_1.assert)(I, `message "${method.input.typeName}" for ${method.toString()} not found`);
+            (0, assert_js_1.assert)(O, `output message "${method.output.typeName}" for ${method.toString()} not found`);
+            const m = {
+                name: method.name,
+                localName: (0, names_js_1.localName)(method),
+                I,
+                O,
+                kind: method.methodKind,
+                idempotency: method.idempotency,
+                options: {},
+            };
+            methods[m.localName] = m;
+        }
+        return (this.services[typeName] = {
+            typeName: desc.typeName,
+            methods,
+        });
+    }
+}
+exports.DescriptorRegistry = DescriptorRegistry;
+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",
+        name: field.name,
+        no: field.number,
+        K: field.mapKey,
+    };
+    if (field.mapValue.message) {
+        const messageType = resolver.findMessage(field.mapValue.message.typeName);
+        (0, assert_js_1.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);
+        (0, assert_js_1.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 = {
+        no: field.number,
+        name: field.name,
+        kind: "scalar",
+        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);
+    (0, assert_js_1.assert)(messageType, `message "${field.message.typeName}" for ${field.toString()} not found`);
+    const base = {
+        no: field.number,
+        name: field.name,
+        kind: "message",
+        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);
+    (0, assert_js_1.assert)(enumType, `enum "${field.enum.typeName}" for ${field.toString()} not found`);
+    const base = {
+        no: field.number,
+        name: field.name,
+        kind: "enum",
+        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/cjs/create-registry.js

@@ -0,0 +1,75 @@
+"use strict";
+// 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.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRegistry = void 0;
+/**
+ * Create a new registry from the given types. Note that
+ */
+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;
+}
+exports.createRegistry = createRegistry;