@bufbuild/protobuf 0.0.1-alpha.1

package/dist/types/service-type.d.ts

@@ -0,0 +1,118 @@
+import type { AnyMessage, Message } from "./message.js";
+import type { MessageType } from "./message-type.js";
+/**
+ * ServiceType represents a protobuf services. It provides metadata for
+ * reflection-based operations.
+ */
+export interface ServiceType {
+  /**
+   * The fully qualified name of the service.
+   */
+  readonly typeName: string;
+  /**
+   * A map of local name (safe to use in ECMAScript) to method.
+   */
+  readonly methods: {
+    [localName: string]: MethodInfo;
+  };
+}
+/**
+ * MethodInfo represents a method of a protobuf service, a remote procedure
+ * call. All methods provide the following properties:
+ *
+ * - "name": The original name of the protobuf rpc.
+ * - "localName": A variation of the name that follows the lowerCamelCase
+ *    naming convention in ECMAScript.
+ * - "I": The input message type.
+ * - "O": The output message type.
+ * - "kind": The method type.
+ * - "idempotency": User-provided indication whether the method will cause
+ *   the same effect every time it is called.
+ */
+export declare type MethodInfo<
+  I extends Message<I> = AnyMessage,
+  O extends Message<O> = AnyMessage
+> =
+  | MethodInfoUnary<I, O>
+  | MethodInfoServerStreaming<I, O>
+  | MethodInfoClientStreaming<I, O>
+  | MethodInfoBiDiStreaming<I, O>;
+/**
+ * A unary method: rpc (Input) returns (Output)
+ */
+export interface MethodInfoUnary<I extends Message<I>, O extends Message<O>>
+  extends miShared<I, O> {
+  readonly kind: MethodKind.Unary;
+}
+/**
+ * A server streaming method: rpc (Input) returns (stream Output)
+ */
+export interface MethodInfoServerStreaming<
+  I extends Message<I>,
+  O extends Message<O>
+> extends miShared<I, O> {
+  readonly kind: MethodKind.ServerStreaming;
+}
+/**
+ * A client streaming method: rpc (stream Input) returns (Output)
+ */
+export interface MethodInfoClientStreaming<
+  I extends Message<I>,
+  O extends Message<O>
+> extends miShared<I, O> {
+  readonly kind: MethodKind.ClientStreaming;
+}
+/**
+ * A method that streams bi-directionally: rpc (stream Input) returns (stream Output)
+ */
+export interface MethodInfoBiDiStreaming<
+  I extends Message<I>,
+  O extends Message<O>
+> extends miShared<I, O> {
+  readonly kind: MethodKind.BiDiStreaming;
+}
+interface miShared<
+  I extends Message<I> = AnyMessage,
+  O extends Message<O> = AnyMessage
+> {
+  readonly name: string;
+  readonly I: MessageType<I>;
+  readonly O: MessageType<O>;
+  readonly idempotency?: MethodIdempotency;
+}
+/**
+ * MethodKind represents the four method types that can be declared in
+ * protobuf with the `stream` keyword:
+ *
+ * 1. Unary:           rpc (Input) returns (Output)
+ * 2. ServerStreaming: rpc (Input) returns (stream Output)
+ * 3. ClientStreaming: rpc (stream Input) returns (Output)
+ * 4. BiDiStreaming:   rpc (stream Input) returns (stream Output)
+ */
+export declare enum MethodKind {
+  Unary = 0,
+  ServerStreaming = 1,
+  ClientStreaming = 2,
+  BiDiStreaming = 3,
+}
+/**
+ * Is this method side-effect-free (or safe in HTTP parlance), or just
+ * idempotent, or neither? HTTP based RPC implementation may choose GET verb
+ * for safe methods, and PUT verb for idempotent methods instead of the
+ * default POST.
+ *
+ * This enum matches the protobuf enum google.protobuf.MethodOptions.IdempotencyLevel,
+ * defined in the well-known type google/protobuf/descriptor.proto, but
+ * drops UNKNOWN.
+ */
+export declare enum MethodIdempotency {
+  /**
+   * Idempotent, no side effects.
+   */
+  NoSideEffects = 1,
+  /**
+   * Idempotent, but may have side effects.
+   */
+  Idempotent = 2,
+}
+export {};

package/dist/types/type-registry.d.ts

@@ -0,0 +1,37 @@
+import type { MessageType } from "./message-type.js";
+import type { EnumType } from "./enum.js";
+import type { ServiceType } from "./service-type.js";
+/**
+ * IMessageTypeRegistry provides look-up for message types.
+ */
+export interface IMessageTypeRegistry {
+  findMessage(typeName: string): MessageType | undefined;
+}
+/**
+ * IEnumTypeRegistry provides look-up for enum types.
+ */
+export interface IEnumTypeRegistry {
+  findEnum(typeName: string): EnumType | undefined;
+}
+/**
+ * IServiceTypeRegistry provides look-up for service types.
+ */
+export interface IServiceTypeRegistry {
+  findService(typeName: string): ServiceType | undefined;
+}
+/**
+ * TypeRegistry is a basic type registry
+ */
+export declare class TypeRegistry
+  implements IMessageTypeRegistry, IEnumTypeRegistry, IServiceTypeRegistry
+{
+  private readonly messages;
+  private readonly enums;
+  private readonly services;
+  findMessage(typeName: string): MessageType | undefined;
+  findEnum(typeName: string): EnumType | undefined;
+  findService(typeName: string): ServiceType | undefined;
+  private add;
+  static fromIterable(types: Iterable<MessageType>): TypeRegistry;
+  static fromTypes(...types: MessageType[]): TypeRegistry;
+}

package/package.json

@@ -0,0 +1,31 @@
+{
+  "name": "@bufbuild/protobuf",
+  "version": "0.0.1-alpha.1",
+  "license": "(Apache-2.0 AND BSD-3-Clause)",
+  "description": "A complete implementation of protocol buffers in TypeScript, suitable for web browsers and Node.js.",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/bufbuild/protobuf-es.git",
+    "directory": "packages/protobuf"
+  },
+  "scripts": {
+    "clean": "rm -rf ./dist/cjs/* ./dist/esm/* ./dist/types/*",
+    "build": "npm run build:cjs && npm run build:esm+types",
+    "build:cjs": "npx tsc --project tsconfig.json --module commonjs --outDir ./dist/cjs",
+    "build:esm+types": "npx tsc --project tsconfig.json --module ES2015 --outDir ./dist/esm --declaration --declarationDir ./dist/types"
+  },
+  "type": "module",
+  "main": "./dist/cjs/index.js",
+  "types": "./dist/types/index.d.ts",
+  "exports": {
+    "import": "./dist/esm/index.js",
+    "require": "./dist/cjs/index.js",
+    "default": "./dist/esm/index.js"
+  },
+  "devDependencies": {
+    "typescript": "^4.5.4"
+  },
+  "files": [
+    "dist/**/"
+  ]
+}