@restatedev/restate-sdk 0.7.3-worker → 0.8.1

package/src/generated/proto/dynrpc.ts

@@ -0,0 +1,768 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { FileDescriptorProto as FileDescriptorProto1 } from "ts-proto-descriptors";
+import { protoMetadata as protoMetadata2 } from "../dev/restate/events";
+import { protoMetadata as protoMetadata1 } from "../dev/restate/ext";
+import { Empty, protoMetadata as protoMetadata4 } from "../google/protobuf/empty";
+import { protoMetadata as protoMetadata3, Value } from "../google/protobuf/struct";
+
+export const protobufPackage = "";
+
+export interface KeyedEvent {
+  key: string;
+  payload: Buffer;
+  attributes: { [key: string]: string };
+}
+
+export interface KeyedEvent_AttributesEntry {
+  key: string;
+  value: string;
+}
+
+export interface RpcRequest {
+  key: string;
+  request:
+    | any
+    | undefined;
+  /** internal: see src/utils/assumptions.ts */
+  senderAssumes: number;
+}
+
+export interface RpcResponse {
+  response: any | undefined;
+}
+
+function createBaseKeyedEvent(): KeyedEvent {
+  return { key: "", payload: Buffer.alloc(0), attributes: {} };
+}
+
+export const KeyedEvent = {
+  encode(message: KeyedEvent, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.payload.length !== 0) {
+      writer.uint32(26).bytes(message.payload);
+    }
+    Object.entries(message.attributes).forEach(([key, value]) => {
+      KeyedEvent_AttributesEntry.encode({ key: key as any, value }, writer.uint32(122).fork()).ldelim();
+    });
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): KeyedEvent {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseKeyedEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.payload = reader.bytes() as Buffer;
+          continue;
+        case 15:
+          if (tag !== 122) {
+            break;
+          }
+
+          const entry15 = KeyedEvent_AttributesEntry.decode(reader, reader.uint32());
+          if (entry15.value !== undefined) {
+            message.attributes[entry15.key] = entry15.value;
+          }
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): KeyedEvent {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      payload: isSet(object.payload) ? Buffer.from(bytesFromBase64(object.payload)) : Buffer.alloc(0),
+      attributes: isObject(object.attributes)
+        ? Object.entries(object.attributes).reduce<{ [key: string]: string }>((acc, [key, value]) => {
+          acc[key] = String(value);
+          return acc;
+        }, {})
+        : {},
+    };
+  },
+
+  toJSON(message: KeyedEvent): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.payload.length !== 0) {
+      obj.payload = base64FromBytes(message.payload);
+    }
+    if (message.attributes) {
+      const entries = Object.entries(message.attributes);
+      if (entries.length > 0) {
+        obj.attributes = {};
+        entries.forEach(([k, v]) => {
+          obj.attributes[k] = v;
+        });
+      }
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<KeyedEvent>): KeyedEvent {
+    return KeyedEvent.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<KeyedEvent>): KeyedEvent {
+    const message = createBaseKeyedEvent();
+    message.key = object.key ?? "";
+    message.payload = object.payload ?? Buffer.alloc(0);
+    message.attributes = Object.entries(object.attributes ?? {}).reduce<{ [key: string]: string }>(
+      (acc, [key, value]) => {
+        if (value !== undefined) {
+          acc[key] = globalThis.String(value);
+        }
+        return acc;
+      },
+      {},
+    );
+    return message;
+  },
+};
+
+function createBaseKeyedEvent_AttributesEntry(): KeyedEvent_AttributesEntry {
+  return { key: "", value: "" };
+}
+
+export const KeyedEvent_AttributesEntry = {
+  encode(message: KeyedEvent_AttributesEntry, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.value !== "") {
+      writer.uint32(18).string(message.value);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): KeyedEvent_AttributesEntry {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseKeyedEvent_AttributesEntry();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.value = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): KeyedEvent_AttributesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: KeyedEvent_AttributesEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<KeyedEvent_AttributesEntry>): KeyedEvent_AttributesEntry {
+    return KeyedEvent_AttributesEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<KeyedEvent_AttributesEntry>): KeyedEvent_AttributesEntry {
+    const message = createBaseKeyedEvent_AttributesEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+function createBaseRpcRequest(): RpcRequest {
+  return { key: "", request: undefined, senderAssumes: 0 };
+}
+
+export const RpcRequest = {
+  encode(message: RpcRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.key !== "") {
+      writer.uint32(10).string(message.key);
+    }
+    if (message.request !== undefined) {
+      Value.encode(Value.wrap(message.request), writer.uint32(18).fork()).ldelim();
+    }
+    if (message.senderAssumes !== 0) {
+      writer.uint32(808).int32(message.senderAssumes);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): RpcRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRpcRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.key = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.request = Value.unwrap(Value.decode(reader, reader.uint32()));
+          continue;
+        case 101:
+          if (tag !== 808) {
+            break;
+          }
+
+          message.senderAssumes = reader.int32();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RpcRequest {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      request: isSet(object?.request) ? object.request : undefined,
+      senderAssumes: isSet(object.senderAssumes) ? globalThis.Number(object.senderAssumes) : 0,
+    };
+  },
+
+  toJSON(message: RpcRequest): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.request !== undefined) {
+      obj.request = message.request;
+    }
+    if (message.senderAssumes !== 0) {
+      obj.senderAssumes = Math.round(message.senderAssumes);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RpcRequest>): RpcRequest {
+    return RpcRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RpcRequest>): RpcRequest {
+    const message = createBaseRpcRequest();
+    message.key = object.key ?? "";
+    message.request = object.request ?? undefined;
+    message.senderAssumes = object.senderAssumes ?? 0;
+    return message;
+  },
+};
+
+function createBaseRpcResponse(): RpcResponse {
+  return { response: undefined };
+}
+
+export const RpcResponse = {
+  encode(message: RpcResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.response !== undefined) {
+      Value.encode(Value.wrap(message.response), writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): RpcResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseRpcResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.response = Value.unwrap(Value.decode(reader, reader.uint32()));
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): RpcResponse {
+    return { response: isSet(object?.response) ? object.response : undefined };
+  },
+
+  toJSON(message: RpcResponse): unknown {
+    const obj: any = {};
+    if (message.response !== undefined) {
+      obj.response = message.response;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<RpcResponse>): RpcResponse {
+    return RpcResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<RpcResponse>): RpcResponse {
+    const message = createBaseRpcResponse();
+    message.response = object.response ?? undefined;
+    return message;
+  },
+};
+
+export interface RpcEndpoint {
+  call(request: RpcRequest): Promise<RpcResponse>;
+  handle(request: KeyedEvent): Promise<Empty>;
+}
+
+export const RpcEndpointServiceName = "RpcEndpoint";
+export class RpcEndpointClientImpl implements RpcEndpoint {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || RpcEndpointServiceName;
+    this.rpc = rpc;
+    this.call = this.call.bind(this);
+    this.handle = this.handle.bind(this);
+  }
+  call(request: RpcRequest): Promise<RpcResponse> {
+    const data = RpcRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "call", data);
+    return promise.then((data) => RpcResponse.decode(_m0.Reader.create(data)));
+  }
+
+  handle(request: KeyedEvent): Promise<Empty> {
+    const data = KeyedEvent.encode(request).finish();
+    const promise = this.rpc.request(this.service, "handle", data);
+    return promise.then((data) => Empty.decode(_m0.Reader.create(data)));
+  }
+}
+
+export interface UnkeyedRpcEndpoint {
+  call(request: RpcRequest): Promise<RpcResponse>;
+}
+
+export const UnkeyedRpcEndpointServiceName = "UnkeyedRpcEndpoint";
+export class UnkeyedRpcEndpointClientImpl implements UnkeyedRpcEndpoint {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || UnkeyedRpcEndpointServiceName;
+    this.rpc = rpc;
+    this.call = this.call.bind(this);
+  }
+  call(request: RpcRequest): Promise<RpcResponse> {
+    const data = RpcRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "call", data);
+    return promise.then((data) => RpcResponse.decode(_m0.Reader.create(data)));
+  }
+}
+
+interface Rpc {
+  request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
+}
+
+type ProtoMetaMessageOptions = {
+  options?: { [key: string]: any };
+  fields?: { [key: string]: { [key: string]: any } };
+  oneof?: { [key: string]: { [key: string]: any } };
+  nested?: { [key: string]: ProtoMetaMessageOptions };
+};
+
+export interface ProtoMetadata {
+  fileDescriptor: FileDescriptorProto1;
+  references: { [key: string]: any };
+  dependencies?: ProtoMetadata[];
+  options?: {
+    options?: { [key: string]: any };
+    services?: {
+      [key: string]: { options?: { [key: string]: any }; methods?: { [key: string]: { [key: string]: any } } };
+    };
+    messages?: { [key: string]: ProtoMetaMessageOptions };
+    enums?: { [key: string]: { options?: { [key: string]: any }; values?: { [key: string]: { [key: string]: any } } } };
+  };
+}
+
+export const protoMetadata: ProtoMetadata = {
+  fileDescriptor: FileDescriptorProto1.fromPartial({
+    "name": "proto/dynrpc.proto",
+    "package": "",
+    "dependency": [
+      "dev/restate/ext.proto",
+      "dev/restate/events.proto",
+      "google/protobuf/struct.proto",
+      "google/protobuf/empty.proto",
+    ],
+    "publicDependency": [],
+    "weakDependency": [],
+    "messageType": [{
+      "name": "KeyedEvent",
+      "field": [{
+        "name": "key",
+        "number": 1,
+        "label": 1,
+        "type": 9,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "key",
+        "options": {
+          "ctype": 0,
+          "packed": false,
+          "jstype": 0,
+          "lazy": false,
+          "deprecated": false,
+          "weak": false,
+          "uninterpretedOption": [],
+        },
+        "proto3Optional": false,
+      }, {
+        "name": "payload",
+        "number": 3,
+        "label": 1,
+        "type": 12,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "payload",
+        "options": {
+          "ctype": 0,
+          "packed": false,
+          "jstype": 0,
+          "lazy": false,
+          "deprecated": false,
+          "weak": false,
+          "uninterpretedOption": [],
+        },
+        "proto3Optional": false,
+      }, {
+        "name": "attributes",
+        "number": 15,
+        "label": 3,
+        "type": 11,
+        "typeName": ".KeyedEvent.AttributesEntry",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "attributes",
+        "options": {
+          "ctype": 0,
+          "packed": false,
+          "jstype": 0,
+          "lazy": false,
+          "deprecated": false,
+          "weak": false,
+          "uninterpretedOption": [],
+        },
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [{
+        "name": "AttributesEntry",
+        "field": [{
+          "name": "key",
+          "number": 1,
+          "label": 1,
+          "type": 9,
+          "typeName": "",
+          "extendee": "",
+          "defaultValue": "",
+          "oneofIndex": 0,
+          "jsonName": "key",
+          "options": undefined,
+          "proto3Optional": false,
+        }, {
+          "name": "value",
+          "number": 2,
+          "label": 1,
+          "type": 9,
+          "typeName": "",
+          "extendee": "",
+          "defaultValue": "",
+          "oneofIndex": 0,
+          "jsonName": "value",
+          "options": undefined,
+          "proto3Optional": false,
+        }],
+        "extension": [],
+        "nestedType": [],
+        "enumType": [],
+        "extensionRange": [],
+        "oneofDecl": [],
+        "options": {
+          "messageSetWireFormat": false,
+          "noStandardDescriptorAccessor": false,
+          "deprecated": false,
+          "mapEntry": true,
+          "uninterpretedOption": [],
+        },
+        "reservedRange": [],
+        "reservedName": [],
+      }],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }, {
+      "name": "RpcRequest",
+      "field": [{
+        "name": "key",
+        "number": 1,
+        "label": 1,
+        "type": 9,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "key",
+        "options": {
+          "ctype": 0,
+          "packed": false,
+          "jstype": 0,
+          "lazy": false,
+          "deprecated": false,
+          "weak": false,
+          "uninterpretedOption": [],
+        },
+        "proto3Optional": false,
+      }, {
+        "name": "request",
+        "number": 2,
+        "label": 1,
+        "type": 11,
+        "typeName": ".google.protobuf.Value",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "request",
+        "options": undefined,
+        "proto3Optional": false,
+      }, {
+        "name": "sender_assumes",
+        "number": 101,
+        "label": 1,
+        "type": 5,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "senderAssumes",
+        "options": undefined,
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }, {
+      "name": "RpcResponse",
+      "field": [{
+        "name": "response",
+        "number": 1,
+        "label": 1,
+        "type": 11,
+        "typeName": ".google.protobuf.Value",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "response",
+        "options": undefined,
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }],
+    "enumType": [],
+    "service": [{
+      "name": "RpcEndpoint",
+      "method": [{
+        "name": "call",
+        "inputType": ".RpcRequest",
+        "outputType": ".RpcResponse",
+        "options": { "deprecated": false, "idempotencyLevel": 0, "uninterpretedOption": [] },
+        "clientStreaming": false,
+        "serverStreaming": false,
+      }, {
+        "name": "handle",
+        "inputType": ".KeyedEvent",
+        "outputType": ".google.protobuf.Empty",
+        "options": { "deprecated": false, "idempotencyLevel": 0, "uninterpretedOption": [] },
+        "clientStreaming": false,
+        "serverStreaming": false,
+      }],
+      "options": { "deprecated": false, "uninterpretedOption": [] },
+    }, {
+      "name": "UnkeyedRpcEndpoint",
+      "method": [{
+        "name": "call",
+        "inputType": ".RpcRequest",
+        "outputType": ".RpcResponse",
+        "options": { "deprecated": false, "idempotencyLevel": 0, "uninterpretedOption": [] },
+        "clientStreaming": false,
+        "serverStreaming": false,
+      }],
+      "options": { "deprecated": false, "uninterpretedOption": [] },
+    }],
+    "extension": [],
+    "options": {
+      "javaPackage": "",
+      "javaOuterClassname": "DynrpcProto",
+      "javaMultipleFiles": true,
+      "javaGenerateEqualsAndHash": false,
+      "javaStringCheckUtf8": false,
+      "optimizeFor": 1,
+      "goPackage": "",
+      "ccGenericServices": false,
+      "javaGenericServices": false,
+      "pyGenericServices": false,
+      "phpGenericServices": false,
+      "deprecated": false,
+      "ccEnableArenas": false,
+      "objcClassPrefix": "",
+      "csharpNamespace": "",
+      "swiftPrefix": "",
+      "phpClassPrefix": "",
+      "phpNamespace": "",
+      "phpMetadataNamespace": "",
+      "rubyPackage": "",
+      "uninterpretedOption": [],
+    },
+    "sourceCodeInfo": {
+      "location": [{
+        "path": [4, 1, 2, 2],
+        "span": [43, 2, 29],
+        "leadingComments": " internal: see src/utils/assumptions.ts\n",
+        "trailingComments": "",
+        "leadingDetachedComments": [],
+      }],
+    },
+    "syntax": "proto3",
+  }),
+  references: {
+    ".KeyedEvent": KeyedEvent,
+    ".KeyedEvent.AttributesEntry": KeyedEvent_AttributesEntry,
+    ".RpcRequest": RpcRequest,
+    ".RpcResponse": RpcResponse,
+    ".RpcEndpoint": RpcEndpointClientImpl,
+    ".UnkeyedRpcEndpoint": UnkeyedRpcEndpointClientImpl,
+  },
+  dependencies: [protoMetadata1, protoMetadata2, protoMetadata3, protoMetadata4],
+  options: {
+    messages: {
+      "KeyedEvent": { fields: { "key": { "field": 0 }, "payload": { "field": 1 }, "attributes": { "field": 2 } } },
+      "RpcRequest": { fields: { "key": { "field": 0 } } },
+    },
+    services: {
+      "RpcEndpoint": { options: { "service_type": 1 }, methods: {} },
+      "UnkeyedRpcEndpoint": { options: { "service_type": 0 }, methods: {} },
+    },
+  },
+};
+
+function bytesFromBase64(b64: string): Uint8Array {
+  if (globalThis.Buffer) {
+    return Uint8Array.from(globalThis.Buffer.from(b64, "base64"));
+  } else {
+    const bin = globalThis.atob(b64);
+    const arr = new Uint8Array(bin.length);
+    for (let i = 0; i < bin.length; ++i) {
+      arr[i] = bin.charCodeAt(i);
+    }
+    return arr;
+  }
+}
+
+function base64FromBytes(arr: Uint8Array): string {
+  if (globalThis.Buffer) {
+    return globalThis.Buffer.from(arr).toString("base64");
+  } else {
+    const bin: string[] = [];
+    arr.forEach((byte) => {
+      bin.push(globalThis.String.fromCharCode(byte));
+    });
+    return globalThis.btoa(bin.join(""));
+  }
+}
+
+type Builtin = Date | Function | Uint8Array | string | number | boolean | undefined;
+
+export type DeepPartial<T> = T extends Builtin ? T
+  : T extends globalThis.Array<infer U> ? globalThis.Array<DeepPartial<U>>
+  : T extends ReadonlyArray<infer U> ? ReadonlyArray<DeepPartial<U>>
+  : T extends {} ? { [K in keyof T]?: DeepPartial<T[K]> }
+  : Partial<T>;
+
+function isObject(value: any): boolean {
+  return typeof value === "object" && value !== null;
+}
+
+function isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}