@bufbuild/protobuf 0.0.1-alpha.1

package/dist/esm/private/json-format-common.js

@@ -0,0 +1,473 @@
+import { unwrapField, wrapField } from "./field-wrapper.js";
+import { ScalarType } from "../field.js";
+import { assert, assertFloat32, assertInt32, assertUInt32 } from "./assert.js";
+import { protoInt64 } from "../proto-int64.js";
+import { base64decode, base64encode } from "./base64.js";
+/* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
+// Default options for parsing JSON.
+const jsonReadDefaults = {
+  ignoreUnknownFields: false,
+};
+// Default options for serializing to JSON.
+const jsonWriteDefaults = {
+  emitDefaultValues: false,
+  enumAsInteger: false,
+  useProtoFieldName: false,
+  prettySpaces: 0,
+};
+function makeReadOptions(options) {
+  return options ? { ...jsonReadDefaults, ...options } : jsonReadDefaults;
+}
+function makeWriteOptions(options) {
+  return options ? { ...jsonWriteDefaults, ...options } : jsonWriteDefaults;
+}
+export function makeJsonFormatCommon(makeWriteField) {
+  const writeField = makeWriteField(writeEnum, writeScalar);
+  return {
+    makeReadOptions,
+    makeWriteOptions,
+    readMessage(type, json, options, message) {
+      if (json == null || Array.isArray(json) || typeof json != "object") {
+        throw new Error(
+          `cannot decode message ${type.typeName} from JSON: ${this.debug(
+            json
+          )}`
+        );
+      }
+      message = message ?? new type();
+      const oneofSeen = {};
+      for (const [jsonKey, jsonValue] of Object.entries(json)) {
+        const field = type.fields.findJsonName(jsonKey);
+        if (!field) {
+          if (!options.ignoreUnknownFields) {
+            throw new Error(
+              `cannot decode message ${type.typeName} from JSON: key "${jsonKey}" is unknown`
+            );
+          }
+          continue;
+        }
+        let localName = field.localName;
+        let target = message;
+        if (field.oneof) {
+          if (jsonValue === null && field.kind == "scalar") {
+            // see conformance test Required.Proto3.JsonInput.OneofFieldNull{First,Second}
+            continue;
+          }
+          const seen = oneofSeen[field.oneof.localName];
+          if (seen) {
+            throw new Error(
+              `cannot decode message ${type.typeName} from JSON: multiple keys for oneof "${field.oneof.name}" present: "${seen}", "${jsonKey}"`
+            );
+          }
+          oneofSeen[field.oneof.localName] = jsonKey;
+          target = target[field.oneof.localName] = { case: localName };
+          localName = "value";
+        }
+        if (field.repeated) {
+          if (jsonValue === null) {
+            continue;
+          }
+          if (!Array.isArray(jsonValue)) {
+            throw new Error(
+              `cannot decode field ${type.typeName}.${
+                field.name
+              } from JSON: "${this.debug(jsonValue)}"`
+            );
+          }
+          const targetArray = target[localName];
+          for (const jsonItem of jsonValue) {
+            if (jsonItem === null) {
+              throw new Error(
+                `cannot decode field ${type.typeName}.${
+                  field.name
+                } from JSON: "${this.debug(jsonItem)}"`
+              );
+            }
+            let val;
+            // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check -- "map" is invalid for repeated fields
+            switch (field.kind) {
+              case "message":
+                val = field.T.fromJson(jsonItem, options);
+                break;
+              case "enum":
+                val = readEnum(field.T, jsonItem, options.ignoreUnknownFields);
+                if (val === undefined) continue;
+                break;
+              case "scalar":
+                try {
+                  val = readScalar(field.T, jsonItem);
+                } catch (e) {
+                  let m = `cannot decode field ${type.typeName}.${
+                    field.name
+                  } from JSON: "${this.debug(jsonItem)}"`;
+                  if (e instanceof Error && e.message.length > 0) {
+                    m += `: ${e.message}`;
+                  }
+                  throw new Error(m);
+                }
+                break;
+            }
+            targetArray.push(val);
+          }
+        } else if (field.kind == "map") {
+          if (jsonValue === null) {
+            continue;
+          }
+          if (Array.isArray(jsonValue) || typeof jsonValue != "object") {
+            throw new Error(
+              `cannot decode field ${type.typeName}.${
+                field.name
+              } from JSON: ${this.debug(jsonValue)}`
+            );
+          }
+          const targetMap = target[localName];
+          for (const [jsonMapKey, jsonMapValue] of Object.entries(jsonValue)) {
+            if (jsonMapValue === null) {
+              throw new Error(
+                `cannot decode field ${type.typeName}.${field.name} from JSON: map value null`
+              );
+            }
+            let val;
+            switch (field.V.kind) {
+              case "message":
+                val = field.V.T.fromJson(jsonMapValue, options);
+                break;
+              case "enum":
+                val = readEnum(
+                  field.V.T,
+                  jsonMapValue,
+                  options.ignoreUnknownFields
+                );
+                if (val === undefined) continue;
+                break;
+              case "scalar":
+                try {
+                  val = readScalar(field.V.T, jsonMapValue);
+                } catch (e) {
+                  let m = `cannot decode map value for field ${type.typeName}.${
+                    field.name
+                  } from JSON: "${this.debug(jsonValue)}"`;
+                  if (e instanceof Error && e.message.length > 0) {
+                    m += `: ${e.message}`;
+                  }
+                  throw new Error(m);
+                }
+                break;
+            }
+            try {
+              targetMap[
+                readScalar(
+                  field.K,
+                  field.K == ScalarType.BOOL
+                    ? jsonMapKey == "true"
+                      ? true
+                      : jsonMapKey == "false"
+                      ? false
+                      : jsonMapKey
+                    : jsonMapKey
+                ).toString()
+              ] = val;
+            } catch (e) {
+              let m = `cannot decode map key for field ${type.typeName}.${
+                field.name
+              } from JSON: "${this.debug(jsonValue)}"`;
+              if (e instanceof Error && e.message.length > 0) {
+                m += `: ${e.message}`;
+              }
+              throw new Error(m);
+            }
+          }
+        } else {
+          switch (field.kind) {
+            case "message":
+              const messageType = field.T;
+              if (
+                jsonValue === null &&
+                messageType.typeName != "google.protobuf.Value"
+              ) {
+                if (field.oneof) {
+                  throw new Error(
+                    `cannot decode field ${type.typeName}.${field.name} from JSON: null is invalid for oneof field "${jsonKey}"`
+                  );
+                }
+                continue;
+              }
+              const targetMessage =
+                target[localName] === undefined
+                  ? new messageType()
+                  : wrapField(messageType, target[localName]);
+              target[localName] = unwrapField(
+                messageType,
+                targetMessage.fromJson(jsonValue, options)
+              );
+              break;
+            case "enum":
+              const enumValue = readEnum(
+                field.T,
+                jsonValue,
+                options.ignoreUnknownFields
+              );
+              if (enumValue !== undefined) {
+                target[localName] = enumValue;
+              }
+              break;
+            case "scalar":
+              try {
+                target[localName] = readScalar(field.T, jsonValue);
+              } catch (e) {
+                let m = `cannot decode field ${type.typeName}.${
+                  field.name
+                } from JSON: "${this.debug(jsonValue)}"`;
+                if (e instanceof Error && e.message.length > 0) {
+                  m += `: ${e.message}`;
+                }
+                throw new Error(m);
+              }
+              break;
+          }
+        }
+      }
+      return message;
+    },
+    writeMessage(message, options) {
+      const type = message.getType();
+      const json = {};
+      let field;
+      try {
+        for (const member of type.fields.byMember()) {
+          let jsonValue;
+          if (member.kind == "oneof") {
+            const oneof = message[member.localName];
+            if (oneof.value === undefined) {
+              continue;
+            }
+            field = member.findField(oneof.case);
+            if (!field) {
+              throw "oneof case not found: " + oneof.case;
+            }
+            jsonValue = writeField(field, oneof.value, options);
+          } else {
+            field = member;
+            jsonValue = writeField(field, message[field.localName], options);
+          }
+          if (jsonValue !== undefined) {
+            json[options.useProtoFieldName ? field.name : field.jsonName] =
+              jsonValue;
+          }
+        }
+      } catch (e) {
+        const m = field
+          ? `cannot encode field ${type.typeName}.${field.name} to JSON`
+          : `cannot encode message ${type.typeName} to JSON`;
+        const r = e instanceof Error ? e.message : String(e);
+        throw new Error(m + (r.length > 0 ? `: ${r}` : ""));
+      }
+      return json;
+    },
+    readScalar,
+    writeScalar,
+    debug: debugJsonValue,
+  };
+}
+function debugJsonValue(json) {
+  if (json === null) {
+    return "null";
+  }
+  switch (typeof json) {
+    case "object":
+      return Array.isArray(json) ? "array" : "object";
+    case "string":
+      return json.length > 100 ? "string" : `"${json.split('"').join('\\"')}"`;
+    default:
+      return json.toString();
+  }
+}
+// May throw an error. If the error message is non-blank, it should be shown.
+// It is up to the caller to provide context.
+function readScalar(type, json) {
+  // every valid case in the switch below returns, and every fall
+  // through is regarded as a failure.
+  switch (type) {
+    // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
+    // Either numbers or strings are accepted. Exponent notation is also accepted.
+    case ScalarType.DOUBLE:
+    case ScalarType.FLOAT:
+      if (json === null) return 0.0;
+      if (json === "NaN") return Number.NaN;
+      if (json === "Infinity") return Number.POSITIVE_INFINITY;
+      if (json === "-Infinity") return Number.NEGATIVE_INFINITY;
+      if (json === "") {
+        // empty string is not a number
+        break;
+      }
+      if (typeof json == "string" && json.trim().length !== json.length) {
+        // extra whitespace
+        break;
+      }
+      if (typeof json != "string" && typeof json != "number") {
+        break;
+      }
+      const float = Number(json);
+      if (Number.isNaN(float)) {
+        // not a number
+        break;
+      }
+      if (!Number.isFinite(float)) {
+        // infinity and -infinity are handled by string representation above, so this is an error
+        break;
+      }
+      if (type == ScalarType.FLOAT) assertFloat32(float);
+      return float;
+    // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+    case ScalarType.INT32:
+    case ScalarType.FIXED32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+    case ScalarType.UINT32:
+      if (json === null) return 0;
+      let int32;
+      if (typeof json == "number") int32 = json;
+      else if (typeof json == "string" && json.length > 0) {
+        if (json.trim().length === json.length) int32 = Number(json);
+      }
+      if (int32 === undefined) break;
+      if (type == ScalarType.UINT32) assertUInt32(int32);
+      else assertInt32(int32);
+      return int32;
+    // int64, fixed64, uint64: JSON value will be a decimal string. Either numbers or strings are accepted.
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      if (json === null) return protoInt64.zero;
+      if (typeof json != "number" && typeof json != "string") break;
+      return protoInt64.parse(json);
+    case ScalarType.FIXED64:
+    case ScalarType.UINT64:
+      if (json === null) return protoInt64.zero;
+      if (typeof json != "number" && typeof json != "string") break;
+      return protoInt64.uParse(json);
+    // bool:
+    case ScalarType.BOOL:
+      if (json === null) return false;
+      if (typeof json !== "boolean") break;
+      return json;
+    // string:
+    case ScalarType.STRING:
+      if (json === null) return "";
+      if (typeof json !== "string") {
+        break;
+      }
+      // A string must always contain UTF-8 encoded or 7-bit ASCII.
+      // We validate with encodeURIComponent, which appears to be the fastest widely available option.
+      try {
+        encodeURIComponent(json);
+      } catch (e) {
+        throw new Error("invalid UTF8");
+      }
+      return json;
+    // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
+    // Either standard or URL-safe base64 encoding with/without paddings are accepted.
+    case ScalarType.BYTES:
+      if (json === null || json === "") return new Uint8Array(0);
+      if (typeof json !== "string") break;
+      return base64decode(json);
+  }
+  throw new Error();
+}
+function readEnum(type, json, ignoreUnknownFields) {
+  if (json === null) {
+    // proto3 requires 0 to be default value for all enums
+    return 0;
+  }
+  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check
+  switch (typeof json) {
+    case "number":
+      if (Number.isInteger(json)) {
+        return json;
+      }
+      break;
+    case "string":
+      const value = type.findName(json);
+      if (value || ignoreUnknownFields) {
+        return value?.no;
+      }
+      break;
+  }
+  throw new Error(
+    `cannot decode enum ${type.typeName} from JSON: ${debugJsonValue(json)}`
+  );
+}
+function writeEnum(type, value, emitIntrinsicDefault, enumAsInteger) {
+  if (value === undefined) {
+    return value;
+  }
+  if (value === 0 && !emitIntrinsicDefault) {
+    // proto3 requires 0 to be default value for all enums
+    return undefined;
+  }
+  if (enumAsInteger) {
+    return value;
+  }
+  if (type.typeName == "google.protobuf.NullValue") {
+    return null;
+  }
+  const val = type.findNumber(value);
+  return val?.name ?? value; // if we don't know the enum value, just return the number
+}
+function writeScalar(type, value, emitIntrinsicDefault) {
+  if (value === undefined) {
+    return undefined;
+  }
+  switch (type) {
+    // int32, fixed32, uint32: JSON value will be a decimal number. Either numbers or strings are accepted.
+    case ScalarType.INT32:
+    case ScalarType.SFIXED32:
+    case ScalarType.SINT32:
+    case ScalarType.FIXED32:
+    case ScalarType.UINT32:
+      assert(typeof value == "number");
+      return value != 0 || emitIntrinsicDefault ? value : undefined;
+    // float, double: JSON value will be a number or one of the special string values "NaN", "Infinity", and "-Infinity".
+    // Either numbers or strings are accepted. Exponent notation is also accepted.
+    case ScalarType.FLOAT:
+    // assertFloat32(value);
+    case ScalarType.DOUBLE: // eslint-disable-line no-fallthrough
+      assert(typeof value == "number");
+      if (Number.isNaN(value)) return "NaN";
+      if (value === Number.POSITIVE_INFINITY) return "Infinity";
+      if (value === Number.NEGATIVE_INFINITY) return "-Infinity";
+      return value !== 0 || emitIntrinsicDefault ? value : undefined;
+    // string:
+    case ScalarType.STRING:
+      assert(typeof value == "string");
+      return value.length > 0 || emitIntrinsicDefault ? value : undefined;
+    // bool:
+    case ScalarType.BOOL:
+      assert(typeof value == "boolean");
+      return value || emitIntrinsicDefault ? value : undefined;
+    // JSON value will be a decimal string. Either numbers or strings are accepted.
+    case ScalarType.UINT64:
+    case ScalarType.FIXED64:
+    case ScalarType.INT64:
+    case ScalarType.SFIXED64:
+    case ScalarType.SINT64:
+      assert(
+        typeof value == "bigint" ||
+          typeof value == "string" ||
+          typeof value == "number"
+      );
+      // We use implicit conversion with `value != 0` to catch both 0n and "0"
+      // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+      // @ts-ignore
+      return emitIntrinsicDefault || value != 0
+        ? value.toString(10)
+        : undefined;
+    // bytes: JSON value will be the data encoded as a string using standard base64 encoding with paddings.
+    // Either standard or URL-safe base64 encoding with/without paddings are accepted.
+    case ScalarType.BYTES:
+      assert(value instanceof Uint8Array);
+      return emitIntrinsicDefault || value.byteLength > 0
+        ? base64encode(value)
+        : undefined;
+  }
+}

package/dist/esm/private/json-format-proto2.js

@@ -0,0 +1,90 @@
+import { wrapField } from "./field-wrapper.js";
+import { assert } from "./assert.js";
+import { makeJsonFormatCommon } from "./json-format-common.js";
+/* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
+export function makeJsonFormatProto2() {
+  return makeJsonFormatCommon((writeEnum, writeScalar) => {
+    return function writeField(field, value, options) {
+      if (field.kind == "map") {
+        const jsonObj = {};
+        switch (field.V.kind) {
+          case "scalar":
+            for (const [entryKey, entryValue] of Object.entries(value)) {
+              const val = writeScalar(field.V.T, entryValue, true);
+              assert(val !== undefined);
+              jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+            }
+            break;
+          case "message":
+            for (const [entryKey, entryValue] of Object.entries(value)) {
+              // JSON standard allows only (double quoted) string as property key
+              jsonObj[entryKey.toString()] = entryValue.toJson(options);
+            }
+            break;
+          case "enum":
+            const enumType = field.V.T;
+            for (const [entryKey, entryValue] of Object.entries(value)) {
+              assert(entryValue === undefined || typeof entryValue == "number");
+              const val = writeEnum(
+                enumType,
+                entryValue,
+                true,
+                options.enumAsInteger
+              );
+              assert(val !== undefined);
+              jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+            }
+            break;
+        }
+        return options.emitDefaultValues || Object.keys(jsonObj).length > 0
+          ? jsonObj
+          : undefined;
+      } else if (field.repeated) {
+        const jsonArr = [];
+        switch (field.kind) {
+          case "scalar":
+            for (let i = 0; i < value.length; i++) {
+              jsonArr.push(writeScalar(field.T, value[i], true));
+            }
+            break;
+          case "enum":
+            for (let i = 0; i < value.length; i++) {
+              jsonArr.push(
+                writeEnum(field.T, value[i], true, options.enumAsInteger)
+              );
+            }
+            break;
+          case "message":
+            for (let i = 0; i < value.length; i++) {
+              jsonArr.push(value[i].toJson(options));
+            }
+            break;
+        }
+        return options.emitDefaultValues || jsonArr.length > 0
+          ? jsonArr
+          : undefined;
+      } else {
+        // In contrast to proto3, we raise an error if a non-optional (proto2 required)
+        // field is missing a value.
+        if (value === undefined) {
+          if (!field.oneof && !field.opt) {
+            throw `required field not set`;
+          }
+          return undefined;
+        }
+        switch (field.kind) {
+          case "scalar":
+            // In contrast to proto3, we do not skip intrinsic default values.
+            // Explicit default values are not special cased either.
+            return writeScalar(field.T, value, true);
+          case "enum":
+            // In contrast to proto3, we do not skip intrinsic default values.
+            // Explicit default values are not special cased either.
+            return writeEnum(field.T, value, true, options.enumAsInteger);
+          case "message":
+            return wrapField(field.T, value).toJson(options);
+        }
+      }
+    };
+  });
+}

package/dist/esm/private/json-format-proto3.js

@@ -0,0 +1,89 @@
+import { wrapField } from "./field-wrapper.js";
+import { assert } from "./assert.js";
+import { makeJsonFormatCommon } from "./json-format-common.js";
+/* eslint-disable no-case-declarations, @typescript-eslint/restrict-plus-operands,@typescript-eslint/no-explicit-any,@typescript-eslint/no-unsafe-return,@typescript-eslint/no-unsafe-assignment,@typescript-eslint/no-unsafe-call,@typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-unsafe-argument */
+export function makeJsonFormatProto3() {
+  return makeJsonFormatCommon((writeEnum, writeScalar) => {
+    return function writeField(field, value, options) {
+      if (field.kind == "map") {
+        const jsonObj = {};
+        switch (field.V.kind) {
+          case "scalar":
+            for (const [entryKey, entryValue] of Object.entries(value)) {
+              const val = writeScalar(field.V.T, entryValue, true);
+              assert(val !== undefined);
+              jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+            }
+            break;
+          case "message":
+            for (const [entryKey, entryValue] of Object.entries(value)) {
+              // JSON standard allows only (double quoted) string as property key
+              jsonObj[entryKey.toString()] = entryValue.toJson(options);
+            }
+            break;
+          case "enum":
+            const enumType = field.V.T;
+            for (const [entryKey, entryValue] of Object.entries(value)) {
+              assert(entryValue === undefined || typeof entryValue == "number");
+              const val = writeEnum(
+                enumType,
+                entryValue,
+                true,
+                options.enumAsInteger
+              );
+              assert(val !== undefined);
+              jsonObj[entryKey.toString()] = val; // JSON standard allows only (double quoted) string as property key
+            }
+            break;
+        }
+        return options.emitDefaultValues || Object.keys(jsonObj).length > 0
+          ? jsonObj
+          : undefined;
+      } else if (field.repeated) {
+        const jsonArr = [];
+        switch (field.kind) {
+          case "scalar":
+            for (let i = 0; i < value.length; i++) {
+              jsonArr.push(writeScalar(field.T, value[i], true));
+            }
+            break;
+          case "enum":
+            for (let i = 0; i < value.length; i++) {
+              jsonArr.push(
+                writeEnum(field.T, value[i], true, options.enumAsInteger)
+              );
+            }
+            break;
+          case "message":
+            for (let i = 0; i < value.length; i++) {
+              jsonArr.push(wrapField(field.T, value[i]).toJson(options));
+            }
+            break;
+        }
+        return options.emitDefaultValues || jsonArr.length > 0
+          ? jsonArr
+          : undefined;
+      } else {
+        switch (field.kind) {
+          case "scalar":
+            return writeScalar(
+              field.T,
+              value,
+              !!field.oneof || field.opt || options.emitDefaultValues
+            );
+          case "enum":
+            return writeEnum(
+              field.T,
+              value,
+              !!field.oneof || field.opt || options.emitDefaultValues,
+              options.enumAsInteger
+            );
+          case "message":
+            return value !== undefined
+              ? wrapField(field.T, value).toJson(options)
+              : undefined;
+        }
+      }
+    };
+  });
+}

package/dist/esm/private/message-type.js

@@ -0,0 +1,33 @@
+import { Message } from "../message.js";
+/**
+ * Create a new message type using the given runtime.
+ */
+export function makeMessageType(runtime, typeName, fields, opt) {
+  const localName =
+    opt?.localName ?? typeName.substring(typeName.lastIndexOf(".") + 1);
+  const type = {
+    [localName]: function (data) {
+      runtime.util.initFields(this);
+      runtime.util.initPartial(data, this);
+    },
+  }[localName];
+  Object.setPrototypeOf(type.prototype, new Message());
+  Object.assign(type, {
+    runtime,
+    typeName,
+    fields: runtime.util.newFieldList(fields),
+    fromBinary(bytes, options) {
+      return new type().fromBinary(bytes, options);
+    },
+    fromJson(jsonValue, options) {
+      return new type().fromJson(jsonValue, options);
+    },
+    fromJsonString(jsonString, options) {
+      return new type().fromJsonString(jsonString, options);
+    },
+    equals(a, b) {
+      return runtime.util.equals(type, a, b);
+    },
+  });
+  return type;
+}