@bufbuild/protoc-gen-es 0.0.8 → 0.1.0

package/README.md

@@ -1,12 +1,37 @@
 # @bufbuild/protoc-gen-es
 
-[![npm](https://img.shields.io/npm/v/@bufbuild/protoc-gen-es?style=flat-square)](https://www.npmjs.com/package/@bufbuild/protoc-gen-es)
+This package provides the code generator plugin `protoc-gen-es`. The code it 
+generates depends on [@bufbuild/protobuf](https://www.npmjs.com/package/@bufbuild/protobuf).
 
-A complete implementation of protocol buffers in TypeScript, 
-suitable for web browsers and Node.js.  
-Learn more at [github.com/bufbuild/protobuf-es](https://github.com/bufbuild/protobuf-es).
+## Protocol Buffers for ECMAScript
+
+A complete implementation of [Protocol Buffers](https://developers.google.com/protocol-buffers) 
+in TypeScript, suitable for web browsers and Node.js.  
+
+For example, the following definition:
 
-This is a code generator plugin for `protoc` and [`buf`](https://github.com/bufbuild/buf).
+```protobuf
+message Person {
+  string name = 1;
+  int32 id = 2;  // Unique ID number for this person.
+  string email = 3;
+}
+```
+
+Is compiled to an ECMAScript class that can be used like this:
+
+```typescript
+let pete = new Person({
+  name: "pete",
+  id: 123
+});
+
+let bytes = pete.toBinary();
+pete = Person.fromBinary(bytes);
+pete = Person.fromJsonString('{"name": "pete", "id": 123}');
+```
+
+Learn more at [github.com/bufbuild/protobuf-es](https://github.com/bufbuild/protobuf-es).
 
 
 ## Installation
@@ -24,14 +49,6 @@ Note that npm does not add the executable to your `$PATH`. You can do so with:
 PATH=$PATH:$(pwd)/node_modules/.bin
 ```
 
-Note that `protoc-gen-es` is actually just a simple node script that selects the 
-correct precompiled binary for your platform. For example, if you are on a 32-bit 
-linux machine, the optional dependency `@bufbuild/protoc-gen-es-linux-32` is 
-automatically installed by `npm`, and our node script will run it. Note that this
-means you cannot move your `node_modules` directory to a different platform and
-run it. We recommend you run `npm ci` in CI or your docker images instead.
-
-
 ### With yarn
 
 ```shell
@@ -42,29 +59,12 @@ Note that yarn v2 does not use a `node_modules` directory anymore. To find the p
 where yarn stores the executable, run `yarn bin protoc-gen-es` (it is "unplugged" 
 automatically).
 
-Yarn supports installing dependencies for several platforms at the same time, by 
-adding the configuration field [`supportedArchitectures`](https://yarnpkg.com/configuration/yarnrc#supportedArchitectures)
-in your `.yarnrc.yml`.
-
-
-### With go
-
-Alternatively, you can install the plugin with `go`:
-
-```shell
-go install github.com/bufbuild/protobuf-es/cmd/protoc-gen-es@latest
-```
-
-If your go environment is set up correctly, the executable is now available on 
-your `$PATH`.
-
 You can always confirm successful installation with:
 ```shell
 protoc-gen-es --version
 ```
 
 
-
 ## Plugin options
 
 ### `target`

package/bin/protoc-gen-es

@@ -1,109 +1,6 @@
 #!/usr/bin/env node
 
-// 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.
+const {runNodeJs} = require("@bufbuild/protoplugin");
+const {protocGenEs} = require("../dist/cjs/src/protoc-gen-es-plugin.js");
 
-const {basename, join, dirname} = require("path");
-const {existsSync, readFileSync} = require("fs");
-const {execFileSync} = require("child_process");
-
-const baseDir = dirname(__dirname);
-let basePkg;
-try {
-    basePkg = readPackage(baseDir);
-} catch (e) {
-    exitReadBasePackage(e);
-}
-const wantName = findPlatformPackageName(basePkg);
-if (!basePkg.optionalDependencies[wantName]) {
-    exitUnsupportedPlatform(basePkg);
-}
-const binPath = Object.values(basePkg.bin)[0];
-let absBinPath;
-try {
-    absBinPath = require.resolve(join(wantName, binPath));
-} catch (e) {
-    exitMissingPlatformBinary(basePkg);
-}
-execFileSync(absBinPath, process.argv.slice(2), {stdio: 'inherit', cwd: process.cwd(), env: process.env});
-
-function exitReadBasePackage(error) {
-    const message = error instanceof Error ? error.message : String(error);
-    process.stderr.write(`${basename(__filename)}: ${message}\n`);
-    process.exit(1);
-}
-
-function exitUnsupportedPlatform(basePkg) {
-    process.stderr.write(`${basePkg.name}: unsupported platform/architecture: ${process.platform}/${process.arch}\n`);
-    process.exit(1);
-}
-
-function exitMissingPlatformBinary(basePkg) {
-    process.stderr.write(`${basePkg.name}: binary for ${process.platform}/${process.arch} is missing\n`);
-    process.exit(1);
-}
-
-function readPackage(dir) {
-    const pkgPath = join(dir, "package.json");
-    if (!existsSync(pkgPath)) {
-        throw new Error(`invalid npm-base: ${pkgPath} not found`);
-    }
-    const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-    if (!pkg.name) {
-        throw new Error(`${pkgPath} is missing "name"`);
-    }
-    if (!pkg.bin) {
-        throw new Error(`${pkgPath} is missing "bin"`);
-    }
-    if (Object.keys(pkg.bin).length !== 1) {
-        throw new Error(`${pkgPath} is requires exactly one entry in "bin"`);
-    }
-    const binName = Object.keys(pkg.bin)[0];
-    const binValue = Object.values(pkg.bin)[0];
-    if (
-        binName === undefined ||
-        binValue === undefined ||
-        binValue !== `bin/${binName}`
-    ) {
-        throw new Error(
-            `${pkgPath} is missing an entry in "bin" in the form of {"foo": "bin/foo"}`
-        );
-    }
-    return pkg;
-}
-
-function findPlatformPackageName() {
-    // prettier-ignore
-    const platforms = [
-        { name: "darwin-64",     npmOs: "darwin",  npmCpu: "x64",   },
-        { name: "darwin-64",     npmOs: "darwin",  npmCpu: "x64",   },
-        { name: "darwin-arm64",  npmOs: "darwin",  npmCpu: "arm64", },
-        { name: "windows-64",    npmOs: "win32",   npmCpu: "x64",   },
-        { name: "windows-arm64", npmOs: "win32",   npmCpu: "arm64", },
-        { name: "windows-32",    npmOs: "win32",   npmCpu: "ia32",  },
-        { name: "linux-64",      npmOs: "linux",   npmCpu: "x64",   },
-        { name: "linux-32",      npmOs: "linux",   npmCpu: "ia32",  },
-        { name: "linux-arm",     npmOs: "linux",   npmCpu: "arm",   },
-        { name: "linux-arm64",   npmOs: "linux",   npmCpu: "arm64", },
-        { name: "freebsd-64",    npmOs: "freebsd", npmCpu: "x64",   },
-        { name: "freebsd-arm64", npmOs: "freebsd", npmCpu: "arm64", },
-        { name: "netbsd-64",     npmOs: "netbsd",  npmCpu: "x64",   },
-        { name: "openbsd-64",    npmOs: "openbsd", npmCpu: "x64",   },
-    ];
-    const platform = platforms.find(p => p.npmOs === process.platform && p.npmCpu === process.arch);
-    if (!platform) {
-        return undefined;
-    }
-    return `${basePkg.name}-${platform.name}`;
-}
+runNodeJs(protocGenEs);

package/dist/cjs/package.json

@@ -0,0 +1,33 @@
+{
+    "name": "@bufbuild/protoc-gen-es",
+    "version": "0.1.0",
+    "description": "Protocol Buffers code generator for ECMAScript",
+    "license": "Apache-2.0",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/bufbuild/protobuf-es.git",
+        "directory": "packages/protoc-gen-es"
+    },
+    "bin": {
+        "protoc-gen-es": "bin/protoc-gen-es"
+    },
+    "engines": {
+        "node": ">=14"
+    },
+    "scripts": {
+        "clean": "rm -rf ./dist/cjs/*",
+        "build": "../../node_modules/typescript/bin/tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs"
+    },
+    "preferUnplugged": true,
+    "dependencies": {
+        "@bufbuild/protoplugin": "0.1.0"
+    },
+    "peerDependencies": {
+        "@bufbuild/protobuf": "0.1.0"
+    },
+    "peerDependenciesMeta": {
+        "@bufbuild/protobuf": {
+            "optional": true
+        }
+    }
+}

package/dist/cjs/src/declaration.js

@@ -0,0 +1,194 @@
+"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.declaration = void 0;
+const ecmascript_1 = require("@bufbuild/protoplugin/ecmascript");
+const match_wkt_js_1 = require("./match-wkt.js");
+exports.declaration = {
+    target: "dts",
+    extension: "_pb.d.ts",
+    generateEnum,
+    generateMessage,
+};
+// prettier-ignore
+function generateEnum(schema, f, enumeration) {
+    f.print((0, ecmascript_1.makeJsDoc)(enumeration));
+    f.print("export declare enum ", enumeration, " {");
+    for (const value of enumeration.values) {
+        if (enumeration.values.indexOf(value) > 0) {
+            f.print();
+        }
+        f.print((0, ecmascript_1.makeJsDoc)(value, "  "));
+        f.print("  ", (0, ecmascript_1.localName)(value), " = ", value.number, ",");
+    }
+    f.print("}");
+    f.print();
+}
+// prettier-ignore
+function generateMessage(schema, f, message) {
+    const protoN = schema.runtime[message.file.syntax];
+    const { PartialMessage, FieldList, Message, PlainMessage, BinaryReadOptions, JsonReadOptions, JsonValue } = schema.runtime;
+    f.print((0, ecmascript_1.makeJsDoc)(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 = ', (0, ecmascript_1.literalString)(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);
+    }
+    // We do not support extensions at this time
+}
+// prettier-ignore
+function generateOneof(schema, f, oneof) {
+    f.print((0, ecmascript_1.makeJsDoc)(oneof, "  "));
+    f.print("  ", (0, ecmascript_1.localName)(oneof), ": {");
+    for (const field of oneof.fields) {
+        if (oneof.fields.indexOf(field) > 0) {
+            f.print(`  } | {`);
+        }
+        f.print((0, ecmascript_1.makeJsDoc)(field, "    "));
+        const { typing } = (0, ecmascript_1.getFieldTyping)(field, f);
+        f.print(`    value: `, typing, `;`);
+        f.print(`    case: "`, (0, ecmascript_1.localName)(field), `";`);
+    }
+    f.print(`  } | { case: undefined; value?: undefined };`);
+}
+function generateField(schema, f, field) {
+    f.print((0, ecmascript_1.makeJsDoc)(field, "  "));
+    const e = [];
+    e.push("  ", (0, ecmascript_1.localName)(field));
+    const { typing, optional } = (0, ecmascript_1.getFieldTyping)(field, f);
+    if (optional) {
+        e.push("?: ", typing);
+    }
+    else {
+        e.push(": ", typing);
+    }
+    e.push(";");
+    f.print(e);
+}
+// prettier-ignore
+function generateWktMethods(schema, f, message) {
+    const ref = (0, match_wkt_js_1.matchWkt)(message);
+    if (ref === undefined) {
+        return;
+    }
+    const { Message, MessageType, } = 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("  is(type: ", MessageType, "): 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, match_wkt_js_1.matchWkt)(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, ecmascript_1.getFieldTyping)(ref.value, f);
+            f.print("  static readonly fieldWrapper: {");
+            f.print("    wrapField(value: ", typing, " | ", message, "): ", 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;
+    }
+}