@bufbuild/protobuf 0.0.1-alpha.1

package/dist/cjs/descriptor-set.js

@@ -0,0 +1,557 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DescriptorSet = void 0;
+const descriptor_pb_js_1 = require("./google/protobuf/descriptor_pb.js");
+const assert_js_1 = require("./private/assert.js");
+const field_js_1 = require("./field.js");
+const service_type_js_1 = require("./service-type.js");
+/**
+ * DescriptorSet wraps a set of google.protobuf.FileDescriptorProto,
+ * asserting basic expectations and providing hierarchical information.
+ *
+ * Note that all types are kept by their fully qualified type name
+ * with a leading dot.
+ */
+class DescriptorSet {
+  constructor() {
+    this.enums = {};
+    this.messages = {};
+    this.services = {};
+  }
+  /**
+   * May raise an error on invalid descriptors.
+   */
+  add(...files) {
+    for (const file of files) {
+      newFile(file, this);
+    }
+  }
+  listEnums() {
+    return Object.values(this.enums).filter(isDefined);
+  }
+  listMessages() {
+    return Object.values(this.messages).filter(isDefined);
+  }
+  listServices() {
+    return Object.values(this.services).filter(isDefined);
+  }
+}
+exports.DescriptorSet = DescriptorSet;
+function isDefined(v) {
+  return v !== undefined;
+}
+const fieldTypeToScalarType = {
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.DOUBLE]:
+    field_js_1.ScalarType.DOUBLE,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.FLOAT]:
+    field_js_1.ScalarType.FLOAT,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.INT64]:
+    field_js_1.ScalarType.INT64,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.UINT64]:
+    field_js_1.ScalarType.UINT64,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.INT32]:
+    field_js_1.ScalarType.INT32,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.FIXED64]:
+    field_js_1.ScalarType.FIXED64,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.FIXED32]:
+    field_js_1.ScalarType.FIXED32,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.BOOL]:
+    field_js_1.ScalarType.BOOL,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.STRING]:
+    field_js_1.ScalarType.STRING,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP]: undefined,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE]: undefined,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.BYTES]:
+    field_js_1.ScalarType.BYTES,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.UINT32]:
+    field_js_1.ScalarType.UINT32,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.ENUM]: undefined,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.SFIXED32]:
+    field_js_1.ScalarType.SFIXED32,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.SFIXED64]:
+    field_js_1.ScalarType.SFIXED64,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.SINT32]:
+    field_js_1.ScalarType.SINT32,
+  [descriptor_pb_js_1.FieldDescriptorProto_Type.SINT64]:
+    field_js_1.ScalarType.SINT64,
+};
+function newFile(proto, ds) {
+  (0, assert_js_1.assert)(proto.name, `missing file descriptor name`);
+  if (proto.syntax !== undefined && proto.syntax !== "proto3") {
+    throw new Error(`invalid descriptor: unsupported syntax: ${proto.syntax}`);
+  }
+  const file = {
+    proto,
+    syntax: proto.syntax === "proto3" ? "proto3" : "proto2",
+    name: proto.name.endsWith(".proto")
+      ? proto.name.substring(-".proto".length)
+      : proto.name,
+    toString() {
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+      return `file ${this.proto.name}`;
+    },
+  };
+  for (const messageType of proto.messageType) {
+    newMessage(messageType, undefined, file, ds);
+  }
+  for (const enumType of proto.enumType) {
+    newEnum(enumType, undefined, file, ds);
+  }
+  for (const extension of proto.extension) {
+    newExtension(extension, undefined, file, ds);
+  }
+  for (const service of proto.service) {
+    newService(service, file, ds);
+  }
+  return file;
+}
+function newEnum(proto, parent, file, us) {
+  (0, assert_js_1.assert)(
+    proto.name,
+    `invalid descriptor: missing enum descriptor name`
+  );
+  let protoTypeName;
+  if (parent) {
+    protoTypeName = `${parent.protoTypeName}.${proto.name}`;
+  } else if (file.proto.package !== undefined) {
+    protoTypeName = `.${file.proto.package}.${proto.name}`;
+  } else {
+    protoTypeName = `.${proto.name}`;
+  }
+  const values = [];
+  const enumT = {
+    proto,
+    file,
+    parent,
+    name: proto.name,
+    protoTypeName,
+    typeName: protoTypeName.startsWith(".")
+      ? protoTypeName.substring(1)
+      : protoTypeName,
+    values,
+    toString() {
+      return `enum ${this.typeName}`;
+    },
+  };
+  us.enums[enumT.protoTypeName] = enumT;
+  for (const value of proto.value) {
+    values.push(newEnumValue(value, enumT));
+  }
+  return enumT;
+}
+function newEnumValue(proto, parent) {
+  (0, assert_js_1.assert)(
+    proto.name,
+    `invalid descriptor: missing enum value descriptor name`
+  );
+  (0, assert_js_1.assert)(
+    proto.number !== undefined,
+    `invalid descriptor: missing enum value descriptor number`
+  );
+  return {
+    proto,
+    name: proto.name,
+    number: proto.number,
+    parent,
+    toString() {
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+      return `enum value ${this.parent.typeName}.${this.proto.name}`;
+    },
+  };
+}
+function newMessage(proto, parent, file, us) {
+  (0, assert_js_1.assert)(proto.name, `invalid descriptor: missing name`);
+  const nestedMessages = [];
+  const fields = [];
+  const oneofs = [];
+  const nestedEnums = [];
+  const nestedExtensions = [];
+  let protoTypeName;
+  if (parent) {
+    protoTypeName = `${parent.protoTypeName}.${proto.name}`;
+  } else if (file.proto.package !== undefined) {
+    protoTypeName = `.${file.proto.package}.${proto.name}`;
+  } else {
+    protoTypeName = `.${proto.name}`;
+  }
+  const message = {
+    proto,
+    file,
+    parent,
+    name: proto.name,
+    typeName: protoTypeName.startsWith(".")
+      ? protoTypeName.substring(1)
+      : protoTypeName,
+    protoTypeName,
+    fields,
+    oneofs,
+    nestedEnums,
+    nestedMessages,
+    nestedExtensions,
+    toString() {
+      return `message ${this.typeName}`;
+    },
+  };
+  us.messages[message.protoTypeName] = message;
+  for (const nestedType of proto.nestedType) {
+    nestedMessages.push(newMessage(nestedType, message, file, us));
+  }
+  for (const oneofDecl of proto.oneofDecl) {
+    oneofs.push(newOneof(oneofDecl, message, file));
+  }
+  for (const field of proto.field) {
+    let oneof = undefined;
+    if (field.oneofIndex !== undefined) {
+      oneof = oneofs[field.oneofIndex];
+      (0, assert_js_1.assert)(
+        oneof,
+        `invalid descriptor: oneof declaration index ${
+          field.oneofIndex
+        } specified by field #${field.number ?? -1} not found`
+      );
+    }
+    fields.push(newField(field, message, oneof));
+  }
+  for (const enumType of proto.enumType) {
+    nestedEnums.push(newEnum(enumType, message, file, us));
+  }
+  for (const extension of proto.extension) {
+    nestedExtensions.push(newExtension(extension, message, file, us));
+  }
+  return message;
+}
+function newField(proto, parent, oneof) {
+  (0, assert_js_1.assert)(proto.name, `invalid descriptor: missing name`);
+  (0, assert_js_1.assert)(proto.number, `invalid descriptor: missing number`);
+  (0, assert_js_1.assert)(proto.type, `invalid descriptor: missing type`);
+  let optional = false;
+  let packed = proto.options?.packed === true;
+  switch (parent.file.syntax) {
+    case "proto2":
+      optional =
+        oneof === undefined &&
+        proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.OPTIONAL;
+      break;
+    case "proto3":
+      optional = proto.proto3Optional === true;
+      switch (proto.type) {
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.DOUBLE:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.FLOAT:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.INT64:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.UINT64:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.INT32:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.FIXED64:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.FIXED32:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.UINT32:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.SFIXED32:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.SFIXED64:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.SINT32:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.SINT64:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.BOOL:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.ENUM:
+          // From the proto3 language guide:
+          // > In proto3, repeated fields of scalar numeric types are packed by default.
+          // This information is incomplete - according to the conformance tests, BOOL
+          // and ENUM are packed by default as well. This means only STRING and BYTES
+          // are not packed by default, which makes sense because they are length-delimited.
+          packed = true;
+          break;
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.STRING:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE:
+        case descriptor_pb_js_1.FieldDescriptorProto_Type.BYTES:
+          (0, assert_js_1.assert)(
+            !packed,
+            `invalid descriptor: ${
+              descriptor_pb_js_1.FieldDescriptorProto_Type[proto.type]
+            } cannot be packed`
+          );
+          break;
+      }
+      break;
+  }
+  const field = {
+    proto,
+    name: proto.name,
+    number: proto.number,
+    type: proto.type,
+    parent,
+    oneof: proto.proto3Optional === true ? undefined : oneof,
+    optional,
+    packed,
+    toString() {
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+      return `field ${parent.typeName}.${proto.name}`;
+    },
+    resolve(us) {
+      return resolveField(this, us);
+    },
+  };
+  if (oneof) {
+    oneof.fields.push(field);
+  }
+  return field;
+}
+function resolveField(u, us) {
+  const repeated =
+    u.proto.label === descriptor_pb_js_1.FieldDescriptorProto_Label.REPEATED;
+  switch (u.type) {
+    case descriptor_pb_js_1.FieldDescriptorProto_Type.MESSAGE:
+    case descriptor_pb_js_1.FieldDescriptorProto_Type.GROUP: {
+      (0, assert_js_1.assert)(
+        u.proto.typeName,
+        `invalid descriptor: ${u.toString()} has type ${
+          descriptor_pb_js_1.FieldDescriptorProto_Type[u.type]
+        }, but type_name is unset`
+      );
+      const refMessage = us.messages[u.proto.typeName];
+      (0, assert_js_1.assert)(
+        refMessage,
+        `invalid descriptor: cannot find type_name "${
+          u.proto.typeName
+        }" specified by ${u.toString()}`
+      );
+      if (refMessage.proto.options?.mapEntry !== undefined) {
+        return {
+          ...u,
+          repeated: false,
+          scalarType: undefined,
+          message: undefined,
+          enum: undefined,
+          map: resolveMap(refMessage, us),
+        };
+      }
+      return {
+        ...u,
+        repeated,
+        scalarType: undefined,
+        message: refMessage,
+        enum: undefined,
+        map: undefined,
+      };
+    }
+    case descriptor_pb_js_1.FieldDescriptorProto_Type.ENUM: {
+      (0, assert_js_1.assert)(
+        u.proto.typeName,
+        `invalid descriptor: ${u.toString()} has type ${
+          descriptor_pb_js_1.FieldDescriptorProto_Type[u.type]
+        }, but type_name is unset`
+      );
+      const refEnum = us.enums[u.proto.typeName];
+      (0, assert_js_1.assert)(
+        refEnum,
+        `invalid descriptor: cannot find type_name "${
+          u.proto.typeName
+        }" specified by ${u.toString()}`
+      );
+      return {
+        ...u,
+        repeated,
+        scalarType: undefined,
+        message: undefined,
+        enum: refEnum,
+        map: undefined,
+      };
+    }
+    default: {
+      const scalarType = fieldTypeToScalarType[u.type];
+      (0, assert_js_1.assert)(
+        scalarType,
+        `invalid descriptor: unable to convert google.protobuf.FieldDescriptorProto.Type ${
+          descriptor_pb_js_1.FieldDescriptorProto_Type[u.type]
+        } to ScalarType`
+      );
+      return {
+        ...u,
+        repeated,
+        scalarType,
+        message: undefined,
+        enum: undefined,
+        map: undefined,
+      };
+    }
+  }
+}
+function resolveMap(mapEntry, us) {
+  (0, assert_js_1.assert)(
+    mapEntry.proto.options?.mapEntry,
+    `invalid descriptor: expected ${mapEntry.toString()} to be a map entry`
+  );
+  (0, assert_js_1.assert)(
+    mapEntry.fields.length === 2,
+    `invalid descriptor: map entry ${mapEntry.toString()} has ${
+      mapEntry.fields.length
+    } fields`
+  );
+  const uKeyField = mapEntry.fields.find((f) => f.proto.number === 1);
+  (0, assert_js_1.assert)(
+    uKeyField,
+    `invalid descriptor: map entry ${mapEntry.toString()} is missing key field`
+  );
+  const keyField = resolveField(uKeyField, us);
+  (0, assert_js_1.assert)(
+    keyField.scalarType !== undefined &&
+      keyField.scalarType !== field_js_1.ScalarType.BYTES &&
+      keyField.scalarType !== field_js_1.ScalarType.FLOAT &&
+      keyField.scalarType !== field_js_1.ScalarType.DOUBLE,
+    `invalid descriptor: map entry ${mapEntry.toString()} has unexpected key type ${
+      descriptor_pb_js_1.FieldDescriptorProto_Type[keyField.type]
+    }`
+  );
+  const uValueField = mapEntry.fields.find((f) => f.proto.number === 2);
+  (0, assert_js_1.assert)(
+    uValueField,
+    `invalid descriptor: map entry ${mapEntry.toString()} is missing value field`
+  );
+  const valueField = resolveField(uValueField, us);
+  if (valueField.scalarType !== undefined) {
+    return {
+      key: keyField.scalarType,
+      value: {
+        scalarType: valueField.scalarType,
+        enum: undefined,
+        message: undefined,
+      },
+    };
+  }
+  if (valueField.enum !== undefined) {
+    return {
+      key: keyField.scalarType,
+      value: { scalar: undefined, enum: valueField.enum, message: undefined },
+    };
+  }
+  if (valueField.message !== undefined) {
+    return {
+      key: keyField.scalarType,
+      value: {
+        scalar: undefined,
+        enum: undefined,
+        message: valueField.message,
+      },
+    };
+  }
+  throw new Error(
+    `invalid descriptor: map entry ${mapEntry.toString()} has unexpected value type ${
+      descriptor_pb_js_1.FieldDescriptorProto_Type[keyField.type]
+    }`
+  );
+}
+function newOneof(proto, parent, file) {
+  (0, assert_js_1.assert)(
+    proto.name,
+    `invalid descriptor: missing oneof descriptor name`
+  );
+  return {
+    proto,
+    parent,
+    file,
+    fields: [],
+    name: proto.name,
+    toString() {
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+      return `oneof ${parent.typeName}.${proto.name}`;
+    },
+  };
+}
+function newExtension(
+  proto,
+  parent,
+  file,
+  us // eslint-disable-line @typescript-eslint/no-unused-vars
+) {
+  (0, assert_js_1.assert)(
+    proto.name,
+    `invalid descriptor: missing field descriptor name`
+  );
+  return {
+    proto,
+    file,
+    parent,
+  };
+}
+function newService(proto, file, us) {
+  (0, assert_js_1.assert)(
+    proto.name,
+    `invalid descriptor: missing service descriptor name`
+  );
+  let protoTypeName;
+  if (file.proto.package !== undefined) {
+    protoTypeName = `.${file.proto.package}.${proto.name}`;
+  } else {
+    protoTypeName = `.${proto.name}`;
+  }
+  const methods = [];
+  const service = {
+    proto,
+    file,
+    typeName: protoTypeName.startsWith(".")
+      ? protoTypeName.substring(1)
+      : protoTypeName,
+    protoTypeName,
+    methods,
+    toString() {
+      return `service ${this.typeName}`;
+    },
+  };
+  for (const method of proto.method) {
+    methods.push(newMethod(method, service));
+  }
+  us.services[service.protoTypeName] = service;
+  return service;
+}
+function newMethod(proto, parent) {
+  (0, assert_js_1.assert)(
+    proto.name,
+    `invalid descriptor: missing method descriptor name`
+  );
+  (0, assert_js_1.assert)(
+    proto.inputType,
+    `invalid descriptor: missing method input type`
+  );
+  (0, assert_js_1.assert)(
+    proto.outputType,
+    `invalid descriptor: missing method output type`
+  );
+  let kind;
+  if (proto.clientStreaming === true && proto.serverStreaming === true) {
+    kind = service_type_js_1.MethodKind.BiDiStreaming;
+  } else if (proto.clientStreaming === true) {
+    kind = service_type_js_1.MethodKind.ClientStreaming;
+  } else if (proto.serverStreaming === true) {
+    kind = service_type_js_1.MethodKind.ServerStreaming;
+  } else {
+    kind = service_type_js_1.MethodKind.Unary;
+  }
+  let idempotency;
+  switch (proto.options?.idempotencyLevel) {
+    case descriptor_pb_js_1.MethodOptions_IdempotencyLevel.IDEMPOTENT:
+      idempotency = service_type_js_1.MethodIdempotency.Idempotent;
+      break;
+    case descriptor_pb_js_1.MethodOptions_IdempotencyLevel.NO_SIDE_EFFECTS:
+      idempotency = service_type_js_1.MethodIdempotency.NoSideEffects;
+      break;
+    case descriptor_pb_js_1.MethodOptions_IdempotencyLevel.IDEMPOTENCY_UNKNOWN:
+    case undefined:
+      idempotency = undefined;
+      break;
+  }
+  const inputTypeName = proto.inputType.startsWith(".")
+    ? proto.inputType.substring(1)
+    : proto.inputType;
+  const outputTypeName = proto.outputType.startsWith(".")
+    ? proto.outputType.substring(1)
+    : proto.outputType;
+  return {
+    proto,
+    parent,
+    name: proto.name,
+    kind,
+    idempotency,
+    inputTypeName,
+    outputTypeName,
+    toString() {
+      // eslint-disable-next-line @typescript-eslint/restrict-template-expressions -- we asserted above
+      return `rpc ${this.parent.typeName}.${proto.name}`;
+    },
+  };
+}

package/dist/cjs/enum.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/field-list.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/cjs/field.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ScalarType = void 0;
+/**
+ * Scalar value types. This is a subset of field types declared by protobuf
+ * enum google.protobuf.FieldDescriptorProto.Type The types GROUP and MESSAGE
+ * are omitted, but the numerical values are identical.
+ */
+var ScalarType;
+(function (ScalarType) {
+  // 0 is reserved for errors.
+  // Order is weird for historical reasons.
+  ScalarType[(ScalarType["DOUBLE"] = 1)] = "DOUBLE";
+  ScalarType[(ScalarType["FLOAT"] = 2)] = "FLOAT";
+  // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT64 if
+  // negative values are likely.
+  ScalarType[(ScalarType["INT64"] = 3)] = "INT64";
+  ScalarType[(ScalarType["UINT64"] = 4)] = "UINT64";
+  // Not ZigZag encoded.  Negative numbers take 10 bytes.  Use TYPE_SINT32 if
+  // negative values are likely.
+  ScalarType[(ScalarType["INT32"] = 5)] = "INT32";
+  ScalarType[(ScalarType["FIXED64"] = 6)] = "FIXED64";
+  ScalarType[(ScalarType["FIXED32"] = 7)] = "FIXED32";
+  ScalarType[(ScalarType["BOOL"] = 8)] = "BOOL";
+  ScalarType[(ScalarType["STRING"] = 9)] = "STRING";
+  // Tag-delimited aggregate.
+  // Group type is deprecated and not supported in proto3. However, Proto3
+  // implementations should still be able to parse the group wire format and
+  // treat group fields as unknown fields.
+  // TYPE_GROUP = 10,
+  // TYPE_MESSAGE = 11,  // Length-delimited aggregate.
+  // New in version 2.
+  ScalarType[(ScalarType["BYTES"] = 12)] = "BYTES";
+  ScalarType[(ScalarType["UINT32"] = 13)] = "UINT32";
+  // TYPE_ENUM = 14,
+  ScalarType[(ScalarType["SFIXED32"] = 15)] = "SFIXED32";
+  ScalarType[(ScalarType["SFIXED64"] = 16)] = "SFIXED64";
+  ScalarType[(ScalarType["SINT32"] = 17)] = "SINT32";
+  ScalarType[(ScalarType["SINT64"] = 18)] = "SINT64";
+})((ScalarType = exports.ScalarType || (exports.ScalarType = {})));