@bufbuild/protobuf 0.0.1-alpha.1

package/dist/cjs/descriptor-registry.js

@@ -0,0 +1,518 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescriptorRegistry = 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 field_js_1 = require("./field.js");
+const descriptor_set_js_1 = require("./descriptor-set.js");
+const proto_int64_js_1 = require("./proto-int64.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");
+// 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)];
+/**
+ * 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.ds = descriptorSet ?? new descriptor_set_js_1.DescriptorSet();
+    if (replaceWkt) {
+      for (const mt of wkMessages) {
+        this.messages["." + mt.typeName] = mt;
+      }
+      for (const et of wkEnums) {
+        this.enums["." + et.typeName] = et;
+      }
+    }
+  }
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  add(...files) {
+    this.ds.add(...files);
+  }
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  findEnum(typeName) {
+    const protoTypeName = "." + typeName;
+    const existing = this.enums[protoTypeName];
+    if (existing) {
+      return existing;
+    }
+    const raw = this.ds.enums[protoTypeName];
+    if (!raw) {
+      return undefined;
+    }
+    const runtime =
+      raw.file.syntax == "proto3" ? proto3_js_1.proto3 : proto2_js_1.proto2;
+    const type = runtime.makeEnumType(
+      typeName,
+      raw.values.map((u) => ({
+        no: u.number,
+        name: u.name,
+      })),
+      {}
+    );
+    this.enums[protoTypeName] = type;
+    return type;
+  }
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  findMessage(typeName) {
+    const protoTypeName = "." + typeName;
+    const existing = this.messages[protoTypeName];
+    if (existing) {
+      return existing;
+    }
+    const raw = this.ds.messages[protoTypeName];
+    if (!raw) {
+      return undefined;
+    }
+    const runtime =
+      raw.file.syntax == "proto3" ? proto3_js_1.proto3 : proto2_js_1.proto2;
+    const fields = [];
+    const type = runtime.makeMessageType(typeName, () => fields, {
+      localName: makeTypeLocalName(raw),
+    });
+    this.messages[protoTypeName] = type;
+    for (const field of raw.fields.map((f) => f.resolve(this.ds))) {
+      const fieldInfo = makeFieldInfo(field, this);
+      fields.push(fieldInfo);
+    }
+    return type;
+  }
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  findService(typeName) {
+    const protoTypeName = "." + typeName;
+    const existing = this.services[protoTypeName];
+    if (existing) {
+      return existing;
+    }
+    const raw = this.ds.services[protoTypeName];
+    if (!raw) {
+      return undefined;
+    }
+    const methods = {};
+    for (const u of raw.methods) {
+      const it = this.findMessage(u.inputTypeName);
+      const ot = this.findMessage(u.outputTypeName);
+      (0, assert_js_1.assert)(
+        it,
+        `message "${u.inputTypeName}" for ${u.toString()} not found`
+      );
+      (0, assert_js_1.assert)(
+        ot,
+        `output message "${u.outputTypeName}" for ${u.toString()} not found`
+      );
+      const m = {
+        name: u.name,
+        localName: (0, names_js_1.makeMethodName)(u.name),
+        I: it,
+        O: ot,
+        kind: u.kind,
+        idempotency: u.idempotency,
+        options: {},
+      };
+      methods[m.localName] = m;
+    }
+    return (this.services[protoTypeName] = {
+      typeName: raw.typeName,
+      methods,
+    });
+  }
+}
+exports.DescriptorRegistry = DescriptorRegistry;
+function makeTypeLocalName(type) {
+  const typeName = type.typeName;
+  const packagePrefix = (type.file.proto.package ?? "") + ".";
+  if (!typeName.startsWith(packagePrefix)) {
+    return type.name;
+  }
+  return typeName.substring(packagePrefix.length).split(".").join("_");
+}
+function makeFieldInfo(field, resolver) {
+  if (field.map !== undefined) {
+    return makeMapFieldInfo(field, resolver);
+  }
+  if (field.message) {
+    return makeMessageFieldInfo(field, resolver);
+  }
+  const fi = field.enum
+    ? makeEnumFieldInfo(field, resolver)
+    : makeScalarFieldInfo(field);
+  fi.default = parseDefaultValue(field);
+  return fi;
+}
+function makeMapFieldInfo(field, resolver) {
+  const base = {
+    kind: "map",
+    name: field.name,
+    no: field.number,
+    K: field.map.key,
+  };
+  if (field.map.value.message) {
+    const messageType = resolver.findMessage(field.map.value.message.typeName);
+    (0, assert_js_1.assert)(
+      messageType,
+      `message "${
+        field.map.value.message.typeName
+      }" for ${field.toString()} not found`
+    );
+    return {
+      ...base,
+      V: {
+        kind: "message",
+        T: messageType,
+      },
+    };
+  }
+  if (field.map.value.enum) {
+    const enumType = resolver.findEnum(field.map.value.enum.typeName);
+    (0, assert_js_1.assert)(
+      enumType,
+      `enum "${
+        field.map.value.enum.typeName
+      }" for ${field.toString()} not found`
+    );
+    return {
+      ...base,
+      V: {
+        kind: "enum",
+        T: enumType,
+      },
+    };
+  }
+  return {
+    ...base,
+    V: {
+      kind: "scalar",
+      T: field.map.value.scalarType,
+    },
+  };
+}
+function makeScalarFieldInfo(field) {
+  const base = {
+    no: field.number,
+    name: field.name,
+    kind: "scalar",
+    T: field.scalarType,
+  };
+  if (field.repeated) {
+    return {
+      ...base,
+      repeated: true,
+      packed: field.packed,
+      oneof: undefined,
+      T: field.scalarType,
+    };
+  }
+  if (field.oneof) {
+    return {
+      ...base,
+      oneof: field.oneof.name,
+    };
+  }
+  if (field.optional) {
+    return {
+      ...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 {
+      ...base,
+      repeated: true,
+      packed: field.packed,
+      oneof: undefined,
+    };
+  }
+  if (field.oneof) {
+    return {
+      ...base,
+      oneof: field.oneof.name,
+    };
+  }
+  if (field.optional) {
+    return {
+      ...base,
+      opt: true,
+    };
+  }
+  return base;
+}
+function makeEnumFieldInfo(field, resolver) {
+  const enumType = resolver.findEnum(field.enum.typeName);
+  (0, assert_js_1.assert)(
+    enumType,
+    `message "${field.enum.typeName}" for ${field.toString()} not found`
+  );
+  const base = {
+    no: field.number,
+    name: field.name,
+    kind: "enum",
+    T: enumType,
+  };
+  if (field.repeated) {
+    return {
+      ...base,
+      repeated: true,
+      packed: field.packed,
+      oneof: undefined,
+    };
+  }
+  if (field.oneof) {
+    return {
+      ...base,
+      oneof: field.oneof.name,
+    };
+  }
+  if (field.optional) {
+    return {
+      ...base,
+      opt: true,
+    };
+  }
+  return base;
+}
+function parseDefaultValue(field) {
+  const d = field.proto.defaultValue;
+  if (d === undefined) {
+    return undefined;
+  }
+  if (field.enum) {
+    const enumValue = field.enum.values.find((v) => v.name === d);
+    (0, assert_js_1.assert)(
+      enumValue,
+      `cannot parse ${field.toString()} default value: ${d}`
+    );
+    return enumValue.number;
+  }
+  if (field.scalarType) {
+    switch (field.scalarType) {
+      case field_js_1.ScalarType.STRING:
+        return d;
+      case field_js_1.ScalarType.BYTES: {
+        const u = unescapeBytesDefaultValue(d);
+        if (u === false) {
+          throw new Error(
+            `cannot parse ${field.toString()} default value: ${d}`
+          );
+        }
+        return u;
+      }
+      case field_js_1.ScalarType.INT64:
+      case field_js_1.ScalarType.SFIXED64:
+      case field_js_1.ScalarType.SINT64:
+        return proto_int64_js_1.protoInt64.parse(d);
+      case field_js_1.ScalarType.UINT64:
+      case field_js_1.ScalarType.FIXED64:
+        return proto_int64_js_1.protoInt64.uParse(d);
+      case field_js_1.ScalarType.DOUBLE:
+      case field_js_1.ScalarType.FLOAT:
+        switch (d) {
+          case "inf":
+            return Number.POSITIVE_INFINITY;
+          case "-inf":
+            return Number.NEGATIVE_INFINITY;
+          case "nan":
+            return Number.NaN;
+          default:
+            return parseFloat(d);
+        }
+      case field_js_1.ScalarType.BOOL:
+        return Boolean(d);
+      case field_js_1.ScalarType.INT32:
+      case field_js_1.ScalarType.UINT32:
+      case field_js_1.ScalarType.SINT32:
+      case field_js_1.ScalarType.FIXED32:
+      case field_js_1.ScalarType.SFIXED32:
+        return parseInt(d, 10);
+    }
+  }
+  return undefined;
+}
+// unescapeBytesDefaultValue parses a text-encoded default value (proto2) of a
+// BYTES field.
+function unescapeBytesDefaultValue(str) {
+  const b = [];
+  const input = {
+    tail: str,
+    c: "",
+    next() {
+      if (this.tail.length == 0) {
+        return false;
+      }
+      this.c = this.tail[0];
+      this.tail = this.tail.substring(1);
+      return true;
+    },
+    take(n) {
+      if (this.tail.length >= n) {
+        const r = this.tail.substring(0, n);
+        this.tail = this.tail.substring(n);
+        return r;
+      }
+      return false;
+    },
+  };
+  while (input.next()) {
+    switch (input.c) {
+      case "\\":
+        if (input.next()) {
+          switch (input.c) {
+            case "\\":
+              b.push(input.c.charCodeAt(0));
+              break;
+            case "b":
+              b.push(0x08);
+              break;
+            case "f":
+              b.push(0x0c);
+              break;
+            case "n":
+              b.push(0x0a);
+              break;
+            case "r":
+              b.push(0x0d);
+              break;
+            case "t":
+              b.push(0x09);
+              break;
+            case "v":
+              b.push(0x0b);
+              break;
+            case "0":
+            case "1":
+            case "2":
+            case "3":
+            case "4":
+            case "5":
+            case "6":
+            case "7": {
+              const s = input.c;
+              const t = input.take(2);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 8);
+              if (isNaN(n)) {
+                return false;
+              }
+              b.push(n);
+              break;
+            }
+            case "x": {
+              const s = input.c;
+              const t = input.take(2);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 16);
+              if (isNaN(n)) {
+                return false;
+              }
+              b.push(n);
+              break;
+            }
+            case "u": {
+              const s = input.c;
+              const t = input.take(4);
+              if (t === false) {
+                return false;
+              }
+              const n = parseInt(s + t, 16);
+              if (isNaN(n)) {
+                return false;
+              }
+              const chunk = new Uint8Array(4);
+              const view = new DataView(chunk.buffer);
+              view.setInt32(0, n, true);
+              b.push(chunk[0], chunk[1], chunk[2], chunk[3]);
+              break;
+            }
+            case "U": {
+              const s = input.c;
+              const t = input.take(8);
+              if (t === false) {
+                return false;
+              }
+              const tc = proto_int64_js_1.protoInt64.uEnc(s + t);
+              const chunk = new Uint8Array(8);
+              const view = new DataView(chunk.buffer);
+              view.setInt32(0, tc.lo, true);
+              view.setInt32(4, tc.hi, true);
+              b.push(
+                chunk[0],
+                chunk[1],
+                chunk[2],
+                chunk[3],
+                chunk[4],
+                chunk[5],
+                chunk[6],
+                chunk[7]
+              );
+              break;
+            }
+          }
+        }
+        break;
+      default:
+        b.push(input.c.charCodeAt(0));
+    }
+  }
+  return new Uint8Array(b);
+}