@bufbuild/protoc-gen-es 1.8.0 → 2.0.0-alpha.1

package/src/util.ts

@@ -12,18 +12,36 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+import type { DescExtension, DescField } from "@bufbuild/protobuf";
 import {
-  codegenInfo,
-  DescEnumValue,
-  DescExtension,
-  DescField,
-  FieldDescriptorProto_Label,
   LongType,
   ScalarType,
-  ScalarValue,
-} from "@bufbuild/protobuf";
+  scalarTypeScriptType,
+} from "@bufbuild/protobuf/reflect";
+import { Edition, isWrapperDesc } from "@bufbuild/protobuf/wkt";
 import type { Printable } from "@bufbuild/protoplugin/ecmascript";
-import { localName } from "@bufbuild/protoplugin/ecmascript";
+
+/**
+ * Tells whether a field uses the prototype chain for field presence.
+ * Behavior must match with the counterpart in @bufbuild/protobuf.
+ */
+export function fieldUsesPrototype(field: DescField): field is DescField & {
+  fieldKind: "scalar" | "enum";
+  oneof: undefined;
+  repeated: false;
+} {
+  if (field.parent.file.edition != Edition.EDITION_PROTO2) {
+    return false;
+  }
+  if (field.fieldKind != "scalar" && field.fieldKind != "enum") {
+    return false;
+  }
+  if (field.oneof) {
+    return false;
+  }
+  // proto2 singular scalar and enum fields use an initial value on the prototype chain
+  return true;
+}
 
 export function getFieldTypeInfo(field: DescField | DescExtension): {
   typing: Printable;
@@ -36,20 +54,17 @@ export function getFieldTypeInfo(field: DescField | DescExtension): {
   switch (field.fieldKind) {
     case "scalar":
       typing.push(scalarTypeScriptType(field.scalar, field.longType));
-      optional =
-        field.optional ||
-        field.proto.label === FieldDescriptorProto_Label.REQUIRED;
+      optional = field.optional;
       typingInferrableFromZeroValue = true;
       break;
     case "message": {
-      const baseType = codegenInfo.getUnwrappedFieldType(field);
-      if (baseType !== undefined) {
+      if (!field.oneof && isWrapperDesc(field.message)) {
+        const baseType = field.message.fields[0].scalar;
         typing.push(scalarTypeScriptType(baseType, LongType.BIGINT));
       } else {
         typing.push({
-          kind: "es_ref_message",
-          type: field.message,
-          typeOnly: true,
+          kind: "es_shape_ref",
+          desc: field.message,
         });
       }
       optional = true;
@@ -58,15 +73,40 @@ export function getFieldTypeInfo(field: DescField | DescExtension): {
     }
     case "enum":
       typing.push({
-        kind: "es_ref_enum",
-        type: field.enum,
-        typeOnly: true,
+        kind: "es_shape_ref",
+        desc: field.enum,
       });
-      optional =
-        field.optional ||
-        field.proto.label === FieldDescriptorProto_Label.REQUIRED;
+      optional = field.optional;
       typingInferrableFromZeroValue = true;
       break;
+    case "list":
+      optional = false;
+      typingInferrableFromZeroValue = false;
+      switch (field.listKind) {
+        case "enum":
+          typing.push(
+            {
+              kind: "es_shape_ref",
+              desc: field.enum,
+            },
+            "[]",
+          );
+          break;
+        case "scalar":
+          typing.push(scalarTypeScriptType(field.scalar, field.longType), "[]");
+          break;
+        case "message": {
+          typing.push(
+            {
+              kind: "es_shape_ref",
+              desc: field.message,
+            },
+            "[]",
+          );
+          break;
+        }
+      }
+      break;
     case "map": {
       let keyType: string;
       switch (field.mapKey) {
@@ -82,25 +122,20 @@ export function getFieldTypeInfo(field: DescField | DescExtension): {
           break;
       }
       let valueType: Printable;
-      switch (field.mapValue.kind) {
+      switch (field.mapKind) {
         case "scalar":
-          valueType = scalarTypeScriptType(
-            field.mapValue.scalar,
-            LongType.BIGINT,
-          );
+          valueType = scalarTypeScriptType(field.scalar, LongType.BIGINT);
           break;
         case "message":
           valueType = {
-            kind: "es_ref_message",
-            type: field.mapValue.message,
-            typeOnly: true,
+            kind: "es_shape_ref",
+            desc: field.message,
           };
           break;
         case "enum":
           valueType = {
-            kind: "es_ref_enum",
-            type: field.mapValue.enum,
-            typeOnly: true,
+            kind: "es_shape_ref",
+            desc: field.enum,
           };
           break;
       }
@@ -110,206 +145,32 @@ export function getFieldTypeInfo(field: DescField | DescExtension): {
       break;
     }
   }
-  if (field.repeated) {
-    typing.push("[]");
-    optional = false;
-    typingInferrableFromZeroValue = false;
-  }
   return { typing, optional, typingInferrableFromZeroValue };
 }
 
-/**
- * Return a printable expression for the default value of a field.
- * Only applicable for singular scalar and enum fields.
- */
-export function getFieldDefaultValueExpression(
-  field: DescField | DescExtension,
-  enumAs:
-    | "enum_value_as_is"
-    | "enum_value_as_integer"
-    | "enum_value_as_cast_integer" = "enum_value_as_is",
-): Printable | undefined {
-  if (field.repeated) {
-    return undefined;
-  }
-  if (field.fieldKind !== "enum" && field.fieldKind !== "scalar") {
-    return undefined;
-  }
-  const defaultValue = field.getDefaultValue();
-  if (defaultValue === undefined) {
-    return undefined;
-  }
-  switch (field.fieldKind) {
-    case "enum": {
-      const enumValue = field.enum.values.find(
-        (value) => value.number === defaultValue,
-      );
-      if (enumValue === undefined) {
-        throw new Error(
-          `invalid enum default value: ${String(defaultValue)} for ${enumValue}`,
-        );
-      }
-      return literalEnumValue(enumValue, enumAs);
-    }
-    case "scalar":
-      return literalScalarValue(defaultValue, field);
-  }
-}
-
-/**
- * Return a printable expression for the zero value of a field.
- *
- * Returns either:
- * - empty array literal for repeated fields
- * - empty object literal for maps
- * - undefined for message fields
- * - an enums first value
- * - scalar zero value
- */
-export function getFieldZeroValueExpression(
-  field: DescField | DescExtension,
-  enumAs:
-    | "enum_value_as_is"
-    | "enum_value_as_integer"
-    | "enum_value_as_cast_integer" = "enum_value_as_is",
-): Printable | undefined {
-  if (field.repeated) {
-    return "[]";
-  }
-  switch (field.fieldKind) {
-    case "message":
-      return undefined;
-    case "map":
-      return "{}";
-    case "enum": {
-      // In proto3, the first enum value must be zero.
-      // In proto2, protobuf-go returns the first value as the default.
-      if (field.enum.values.length < 1) {
-        throw new Error("invalid enum: missing at least one value");
-      }
-      const zeroValue = field.enum.values[0];
-      return literalEnumValue(zeroValue, enumAs);
-    }
-    case "scalar": {
-      const defaultValue = codegenInfo.scalarZeroValue(
-        field.scalar,
-        field.longType,
-      );
-      return literalScalarValue(defaultValue, field);
-    }
-  }
-}
-
-function literalScalarValue(
-  value: ScalarValue,
-  field: (DescField | DescExtension) & { fieldKind: "scalar" },
+export function functionCall(
+  fn: Printable,
+  args: Printable[],
+  typeParams?: Printable[],
 ): Printable {
-  switch (field.scalar) {
-    case ScalarType.DOUBLE:
-    case ScalarType.FLOAT:
-    case ScalarType.INT32:
-    case ScalarType.FIXED32:
-    case ScalarType.UINT32:
-    case ScalarType.SFIXED32:
-    case ScalarType.SINT32:
-      if (typeof value != "number") {
-        throw new Error(
-          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
-        );
-      }
-      return value;
-    case ScalarType.BOOL:
-      if (typeof value != "boolean") {
-        throw new Error(
-          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
-        );
-      }
-      return value;
-    case ScalarType.STRING:
-      if (typeof value != "string") {
-        throw new Error(
-          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
-        );
-      }
-      return { kind: "es_string", value };
-    case ScalarType.BYTES:
-      if (!(value instanceof Uint8Array)) {
-        throw new Error(
-          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
-        );
-      }
-      return value;
-    case ScalarType.INT64:
-    case ScalarType.SINT64:
-    case ScalarType.SFIXED64:
-    case ScalarType.UINT64:
-    case ScalarType.FIXED64:
-      if (typeof value != "bigint" && typeof value != "string") {
-        throw new Error(
-          `Unexpected value for ${ScalarType[field.scalar]} ${field.toString()}: ${String(value)}`,
-        );
-      }
-      return {
-        kind: "es_proto_int64",
-        type: field.scalar,
-        longType: field.longType,
-        value,
-      };
+  let tp: Printable = [];
+  if (typeParams !== undefined && typeParams.length > 0) {
+    tp = ["<", commaSeparate(typeParams), ">"];
   }
+  return [fn, ...tp, "(", commaSeparate(args), ")"];
 }
 
-function literalEnumValue(
-  value: DescEnumValue,
-  enumAs:
-    | "enum_value_as_is"
-    | "enum_value_as_integer"
-    | "enum_value_as_cast_integer",
-): Printable {
-  switch (enumAs) {
-    case "enum_value_as_is":
-      return [
-        { kind: "es_ref_enum", type: value.parent, typeOnly: false },
-        ".",
-        localName(value),
-      ];
-    case "enum_value_as_integer":
-      return [
-        value.number,
-        " /* ",
-        value.parent.typeName,
-        ".",
-        value.name,
-        " */",
-      ];
-    case "enum_value_as_cast_integer":
-      return [
-        value.number,
-        " as ",
-        { kind: "es_ref_enum", type: value.parent, typeOnly: true },
-        ".",
-        localName(value),
-      ];
-  }
+export function arrayLiteral(elements: Printable[]): Printable {
+  return ["[", commaSeparate(elements), "]"];
 }
 
-function scalarTypeScriptType(type: ScalarType, longType: LongType): Printable {
-  switch (type) {
-    case ScalarType.STRING:
-      return "string";
-    case ScalarType.BOOL:
-      return "boolean";
-    case ScalarType.UINT64:
-    case ScalarType.SFIXED64:
-    case ScalarType.FIXED64:
-    case ScalarType.SINT64:
-    case ScalarType.INT64:
-      if (longType === LongType.STRING) {
-        return "string";
-      }
-      return "bigint";
-    case ScalarType.BYTES:
-      return "Uint8Array";
-    default:
-      return "number";
+function commaSeparate(elements: Printable[]): Printable {
+  const r: Printable[] = [];
+  for (let i = 0; i < elements.length; i++) {
+    r.push(elements[i]);
+    if (i < elements.length - 1) {
+      r.push(", ");
+    }
   }
+  return r;
 }

package/tsconfig.json

@@ -2,6 +2,11 @@
   "files": ["src/protoc-gen-es-plugin.ts"],
   "extends": "../../tsconfig.base.json",
   "compilerOptions": {
-    "resolveJsonModule": true
+    // We import the plugin's version number from package.json
+    "resolveJsonModule": true,
+    // This package is CommonJS
+    "verbatimModuleSyntax": false,
+    "module": "CommonJS",
+    "moduleResolution": "Node10"
   }
 }

package/dist/cjs/src/declaration.js

@@ -1,216 +0,0 @@
-"use strict";
-// Copyright 2021-2024 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.generateDts = void 0;
-const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
-const editions_js_1 = require("./editions.js");
-const util_js_1 = require("./util.js");
-function generateDts(schema) {
-    for (const file of schema.files) {
-        const f = schema.generateFile(file.name + "_pb.d.ts");
-        f.preamble(file);
-        for (const enumeration of file.enums) {
-            generateEnum(schema, f, enumeration);
-        }
-        for (const message of file.messages) {
-            generateMessage(schema, f, message);
-        }
-        for (const extension of file.extensions) {
-            generateExtension(schema, f, extension);
-        }
-        // We do not generate anything for services
-    }
-}
-exports.generateDts = generateDts;
-// prettier-ignore
-function generateEnum(schema, f, enumeration) {
-    f.print(f.jsDoc(enumeration));
-    f.print("export declare enum ", enumeration, " {");
-    for (const value of enumeration.values) {
-        if (enumeration.values.indexOf(value) > 0) {
-            f.print();
-        }
-        f.print(f.jsDoc(value, "  "));
-        f.print("  ", (0, ecmascript_1.localName)(value), " = ", value.number, ",");
-    }
-    f.print("}");
-    f.print();
-}
-// prettier-ignore
-function generateMessage(schema, f, message) {
-    const protoN = (0, editions_js_1.getNonEditionRuntime)(schema, message.file);
-    const { PartialMessage, FieldList, Message, PlainMessage, BinaryReadOptions, JsonReadOptions, JsonValue } = schema.runtime;
-    f.print(f.jsDoc(message));
-    f.print("export declare class ", message, " extends ", Message, "<", message, "> {");
-    for (const member of message.members) {
-        switch (member.kind) {
-            case "oneof":
-                generateOneof(schema, f, member);
-                break;
-            default:
-                generateField(schema, f, member);
-                break;
-        }
-        f.print();
-    }
-    f.print("  constructor(data?: ", PartialMessage, "<", message, ">);");
-    f.print();
-    generateWktMethods(schema, f, message);
-    f.print("  static readonly runtime: typeof ", protoN, ";");
-    f.print('  static readonly typeName = ', f.string(message.typeName), ';');
-    f.print("  static readonly fields: ", FieldList, ";");
-    // In case we start supporting options, we have to surface them here
-    //f.print("  static readonly options: { readonly [extensionName: string]: ", rt.JsonValue, " } = {};")
-    f.print();
-    generateWktStaticMethods(schema, f, message);
-    f.print("  static fromBinary(bytes: Uint8Array, options?: Partial<", BinaryReadOptions, ">): ", message, ";");
-    f.print();
-    f.print("  static fromJson(jsonValue: ", JsonValue, ", options?: Partial<", JsonReadOptions, ">): ", message, ";");
-    f.print();
-    f.print("  static fromJsonString(jsonString: string, options?: Partial<", JsonReadOptions, ">): ", message, ";");
-    f.print();
-    f.print("  static equals(a: ", message, " | ", PlainMessage, "<", message, "> | undefined, b: ", message, " | ", PlainMessage, "<", message, "> | undefined): boolean;");
-    f.print("}");
-    f.print();
-    for (const nestedEnum of message.nestedEnums) {
-        generateEnum(schema, f, nestedEnum);
-    }
-    for (const nestedMessage of message.nestedMessages) {
-        generateMessage(schema, f, nestedMessage);
-    }
-    for (const nestedExtension of message.nestedExtensions) {
-        generateExtension(schema, f, nestedExtension);
-    }
-}
-// prettier-ignore
-function generateOneof(schema, f, oneof) {
-    f.print(f.jsDoc(oneof, "  "));
-    f.print("  ", (0, ecmascript_1.localName)(oneof), ": {");
-    for (const field of oneof.fields) {
-        if (oneof.fields.indexOf(field) > 0) {
-            f.print(`  } | {`);
-        }
-        f.print(f.jsDoc(field, "    "));
-        const { typing } = (0, util_js_1.getFieldTypeInfo)(field);
-        f.print(`    value: `, typing, `;`);
-        f.print(`    case: "`, (0, ecmascript_1.localName)(field), `";`);
-    }
-    f.print(`  } | { case: undefined; value?: undefined };`);
-}
-// prettier-ignore
-function generateField(schema, f, field) {
-    f.print(f.jsDoc(field, "  "));
-    const e = [];
-    const { typing, optional } = (0, util_js_1.getFieldTypeInfo)(field);
-    if (!optional) {
-        e.push("  ", (0, ecmascript_1.localName)(field), ": ", typing, ";");
-    }
-    else {
-        e.push("  ", (0, ecmascript_1.localName)(field), "?: ", typing, ";");
-    }
-    f.print(e);
-}
-// prettier-ignore
-function generateExtension(schema, f, ext) {
-    const { typing } = (0, util_js_1.getFieldTypeInfo)(ext);
-    f.print(f.jsDoc(ext));
-    f.print(f.exportDecl("declare const", ext), ": ", schema.runtime.Extension, "<", ext.extendee, ", ", typing, ">;");
-    f.print();
-}
-// prettier-ignore
-function generateWktMethods(schema, f, message) {
-    const ref = (0, ecmascript_1.reifyWkt)(message);
-    if (ref === undefined) {
-        return;
-    }
-    const { Message, MessageType, IMessageTypeRegistry } = schema.runtime;
-    switch (ref.typeName) {
-        case "google.protobuf.Any":
-            f.print("  packFrom(message: ", Message, "): void;");
-            f.print();
-            f.print("  unpackTo(target: ", Message, "): boolean;");
-            f.print();
-            f.print("  unpack(registry: ", IMessageTypeRegistry, "): Message | undefined;");
-            f.print();
-            f.print("  is(type: ", MessageType, " | string): boolean;");
-            f.print();
-            f.print("  private typeNameToUrl(name: string): string;");
-            f.print();
-            f.print("  private typeUrlToName(url: string): string;");
-            f.print();
-            break;
-        case "google.protobuf.Timestamp":
-            f.print("  toDate(): Date;");
-            f.print();
-            break;
-        case "google.protobuf.Duration":
-        case "google.protobuf.Struct":
-        case "google.protobuf.Value":
-        case "google.protobuf.ListValue":
-        case "google.protobuf.FieldMask":
-        case "google.protobuf.DoubleValue":
-        case "google.protobuf.FloatValue":
-        case "google.protobuf.Int64Value":
-        case "google.protobuf.UInt64Value":
-        case "google.protobuf.Int32Value":
-        case "google.protobuf.UInt32Value":
-        case "google.protobuf.BoolValue":
-        case "google.protobuf.StringValue":
-        case "google.protobuf.BytesValue":
-            break;
-    }
-}
-// prettier-ignore
-function generateWktStaticMethods(schema, f, message) {
-    const ref = (0, ecmascript_1.reifyWkt)(message);
-    if (ref === undefined) {
-        return;
-    }
-    switch (ref.typeName) {
-        case "google.protobuf.Any":
-            f.print("  static pack(message: Message): ", message, ";");
-            f.print();
-            break;
-        case "google.protobuf.Timestamp":
-            f.print("  static now(): ", message, ";");
-            f.print();
-            f.print("  static fromDate(date: Date): ", message, ";");
-            f.print();
-            break;
-        case "google.protobuf.DoubleValue":
-        case "google.protobuf.FloatValue":
-        case "google.protobuf.Int64Value":
-        case "google.protobuf.UInt64Value":
-        case "google.protobuf.Int32Value":
-        case "google.protobuf.UInt32Value":
-        case "google.protobuf.BoolValue":
-        case "google.protobuf.StringValue":
-        case "google.protobuf.BytesValue": {
-            const { typing } = (0, util_js_1.getFieldTypeInfo)(ref.value);
-            f.print("  static readonly fieldWrapper: {");
-            f.print("    wrapField(value: ", typing, "): ", message, ",");
-            f.print("    unwrapField(value: ", message, "): ", typing, ",");
-            f.print("  };");
-            f.print();
-            break;
-        }
-        case "google.protobuf.Duration":
-        case "google.protobuf.Struct":
-        case "google.protobuf.Value":
-        case "google.protobuf.ListValue":
-        case "google.protobuf.FieldMask":
-            break;
-    }
-}

package/dist/cjs/src/editions.js

@@ -1,34 +0,0 @@
-"use strict";
-// Copyright 2021-2024 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.getNonEditionRuntime = void 0;
-/**
- * Temporary function to retrieve the import symbol for the proto2 or proto3
- * runtime.
- *
- * For syntax "editions", this function raises and error.
- *
- * Once support for "editions" is implemented in the runtime, this function can
- * be removed.
- */
-function getNonEditionRuntime(schema, file) {
-    var _a;
-    if (file.syntax === "editions") {
-        // TODO support editions
-        throw new Error(`${(_a = file.proto.name) !== null && _a !== void 0 ? _a : ""}: syntax "editions" is not supported yet`);
-    }
-    return schema.runtime[file.syntax];
-}
-exports.getNonEditionRuntime = getNonEditionRuntime;