@restatedev/restate-sdk 0.7.3-worker → 0.8.1

package/src/generated/dev/restate/events.ts

@@ -0,0 +1,430 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { FileDescriptorProto as FileDescriptorProto1 } from "ts-proto-descriptors";
+import { protoMetadata as protoMetadata1 } from "./ext";
+
+export const protobufPackage = "dev.restate";
+
+export interface Event {
+  orderingKey: string;
+  key: Buffer;
+  payload: Buffer;
+  attributes: { [key: string]: string };
+}
+
+export interface Event_AttributesEntry {
+  key: string;
+  value: string;
+}
+
+function createBaseEvent(): Event {
+  return { orderingKey: "", key: Buffer.alloc(0), payload: Buffer.alloc(0), attributes: {} };
+}
+
+export const Event = {
+  encode(message: Event, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.orderingKey !== "") {
+      writer.uint32(10).string(message.orderingKey);
+    }
+    if (message.key.length !== 0) {
+      writer.uint32(18).bytes(message.key);
+    }
+    if (message.payload.length !== 0) {
+      writer.uint32(26).bytes(message.payload);
+    }
+    Object.entries(message.attributes).forEach(([key, value]) => {
+      Event_AttributesEntry.encode({ key: key as any, value }, writer.uint32(122).fork()).ldelim();
+    });
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): Event {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEvent();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.orderingKey = reader.string();
+          continue;
+        case 2:
+          if (tag !== 18) {
+            break;
+          }
+
+          message.key = reader.bytes() as Buffer;
+          continue;
+        case 3:
+          if (tag !== 26) {
+            break;
+          }
+
+          message.payload = reader.bytes() as Buffer;
+          continue;
+        case 15:
+          if (tag !== 122) {
+            break;
+          }
+
+          const entry15 = Event_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): Event {
+    return {
+      orderingKey: isSet(object.orderingKey) ? globalThis.String(object.orderingKey) : "",
+      key: isSet(object.key) ? Buffer.from(bytesFromBase64(object.key)) : Buffer.alloc(0),
+      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: Event): unknown {
+    const obj: any = {};
+    if (message.orderingKey !== "") {
+      obj.orderingKey = message.orderingKey;
+    }
+    if (message.key.length !== 0) {
+      obj.key = base64FromBytes(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<Event>): Event {
+    return Event.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Event>): Event {
+    const message = createBaseEvent();
+    message.orderingKey = object.orderingKey ?? "";
+    message.key = object.key ?? Buffer.alloc(0);
+    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 createBaseEvent_AttributesEntry(): Event_AttributesEntry {
+  return { key: "", value: "" };
+}
+
+export const Event_AttributesEntry = {
+  encode(message: Event_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): Event_AttributesEntry {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseEvent_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): Event_AttributesEntry {
+    return {
+      key: isSet(object.key) ? globalThis.String(object.key) : "",
+      value: isSet(object.value) ? globalThis.String(object.value) : "",
+    };
+  },
+
+  toJSON(message: Event_AttributesEntry): unknown {
+    const obj: any = {};
+    if (message.key !== "") {
+      obj.key = message.key;
+    }
+    if (message.value !== "") {
+      obj.value = message.value;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<Event_AttributesEntry>): Event_AttributesEntry {
+    return Event_AttributesEntry.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<Event_AttributesEntry>): Event_AttributesEntry {
+    const message = createBaseEvent_AttributesEntry();
+    message.key = object.key ?? "";
+    message.value = object.value ?? "";
+    return message;
+  },
+};
+
+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": "dev/restate/events.proto",
+    "package": "dev.restate",
+    "dependency": ["dev/restate/ext.proto"],
+    "publicDependency": [],
+    "weakDependency": [],
+    "messageType": [{
+      "name": "Event",
+      "field": [{
+        "name": "ordering_key",
+        "number": 1,
+        "label": 1,
+        "type": 9,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "orderingKey",
+        "options": {
+          "ctype": 0,
+          "packed": false,
+          "jstype": 0,
+          "lazy": false,
+          "deprecated": false,
+          "weak": false,
+          "uninterpretedOption": [],
+        },
+        "proto3Optional": false,
+      }, {
+        "name": "key",
+        "number": 2,
+        "label": 1,
+        "type": 12,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "key",
+        "options": undefined,
+        "proto3Optional": false,
+      }, {
+        "name": "payload",
+        "number": 3,
+        "label": 1,
+        "type": 12,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "payload",
+        "options": undefined,
+        "proto3Optional": false,
+      }, {
+        "name": "attributes",
+        "number": 15,
+        "label": 3,
+        "type": 11,
+        "typeName": ".dev.restate.Event.AttributesEntry",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "attributes",
+        "options": undefined,
+        "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": [],
+    }],
+    "enumType": [],
+    "service": [],
+    "extension": [],
+    "options": {
+      "javaPackage": "com.dev.restate",
+      "javaOuterClassname": "EventsProto",
+      "javaMultipleFiles": true,
+      "javaGenerateEqualsAndHash": false,
+      "javaStringCheckUtf8": false,
+      "optimizeFor": 1,
+      "goPackage": "restate.dev/sdk-go/pb",
+      "ccGenericServices": false,
+      "javaGenericServices": false,
+      "pyGenericServices": false,
+      "phpGenericServices": false,
+      "deprecated": false,
+      "ccEnableArenas": false,
+      "objcClassPrefix": "DRX",
+      "csharpNamespace": "Dev.Restate",
+      "swiftPrefix": "",
+      "phpClassPrefix": "",
+      "phpNamespace": "Dev\\Restate",
+      "phpMetadataNamespace": "Dev\\Restate\\GPBMetadata",
+      "rubyPackage": "Dev::Restate",
+      "uninterpretedOption": [],
+    },
+    "sourceCodeInfo": { "location": [] },
+    "syntax": "proto3",
+  }),
+  references: { ".dev.restate.Event": Event, ".dev.restate.Event.AttributesEntry": Event_AttributesEntry },
+  dependencies: [protoMetadata1],
+  options: { messages: { "Event": { fields: { "ordering_key": { "field": 0 } } } } },
+};
+
+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;
+}

package/src/generated/dev/restate/ext.ts

@@ -0,0 +1,238 @@
+/* eslint-disable */
+import { FileDescriptorProto as FileDescriptorProto1 } from "ts-proto-descriptors";
+import { protoMetadata as protoMetadata1 } from "../../google/protobuf/descriptor";
+
+export const protobufPackage = "dev.restate.ext";
+
+export enum ServiceType {
+  /** UNKEYED - protolint:disable:next ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH */
+  UNKEYED = 0,
+  KEYED = 1,
+  SINGLETON = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function serviceTypeFromJSON(object: any): ServiceType {
+  switch (object) {
+    case 0:
+    case "UNKEYED":
+      return ServiceType.UNKEYED;
+    case 1:
+    case "KEYED":
+      return ServiceType.KEYED;
+    case 2:
+    case "SINGLETON":
+      return ServiceType.SINGLETON;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return ServiceType.UNRECOGNIZED;
+  }
+}
+
+export function serviceTypeToJSON(object: ServiceType): string {
+  switch (object) {
+    case ServiceType.UNKEYED:
+      return "UNKEYED";
+    case ServiceType.KEYED:
+      return "KEYED";
+    case ServiceType.SINGLETON:
+      return "SINGLETON";
+    case ServiceType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+export enum FieldType {
+  /**
+   * KEY - protolint:disable:next ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH
+   * Note: only string fields can be used for service key fields
+   */
+  KEY = 0,
+  /**
+   * EVENT_PAYLOAD - Flag a field as event payload. When receiving events, this field will be filled with the event payload.
+   * Note: only string fields can be used for event payload fields
+   */
+  EVENT_PAYLOAD = 1,
+  /**
+   * EVENT_METADATA - Flag a field as event metadata. When receiving events, this field will be filled with the event metadata.
+   * Note: only type map<string, string> can be used for event payload fields
+   */
+  EVENT_METADATA = 2,
+  UNRECOGNIZED = -1,
+}
+
+export function fieldTypeFromJSON(object: any): FieldType {
+  switch (object) {
+    case 0:
+    case "KEY":
+      return FieldType.KEY;
+    case 1:
+    case "EVENT_PAYLOAD":
+      return FieldType.EVENT_PAYLOAD;
+    case 2:
+    case "EVENT_METADATA":
+      return FieldType.EVENT_METADATA;
+    case -1:
+    case "UNRECOGNIZED":
+    default:
+      return FieldType.UNRECOGNIZED;
+  }
+}
+
+export function fieldTypeToJSON(object: FieldType): string {
+  switch (object) {
+    case FieldType.KEY:
+      return "KEY";
+    case FieldType.EVENT_PAYLOAD:
+      return "EVENT_PAYLOAD";
+    case FieldType.EVENT_METADATA:
+      return "EVENT_METADATA";
+    case FieldType.UNRECOGNIZED:
+    default:
+      return "UNRECOGNIZED";
+  }
+}
+
+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": "dev/restate/ext.proto",
+    "package": "dev.restate.ext",
+    "dependency": ["google/protobuf/descriptor.proto"],
+    "publicDependency": [],
+    "weakDependency": [],
+    "messageType": [],
+    "enumType": [{
+      "name": "ServiceType",
+      "value": [{ "name": "UNKEYED", "number": 0, "options": undefined }, {
+        "name": "KEYED",
+        "number": 1,
+        "options": undefined,
+      }, { "name": "SINGLETON", "number": 2, "options": undefined }],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }, {
+      "name": "FieldType",
+      "value": [{ "name": "KEY", "number": 0, "options": undefined }, {
+        "name": "EVENT_PAYLOAD",
+        "number": 1,
+        "options": undefined,
+      }, { "name": "EVENT_METADATA", "number": 2, "options": undefined }],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }],
+    "service": [],
+    "extension": [{
+      "name": "service_type",
+      "number": 51234,
+      "label": 1,
+      "type": 14,
+      "typeName": ".dev.restate.ext.ServiceType",
+      "extendee": ".google.protobuf.ServiceOptions",
+      "defaultValue": "",
+      "oneofIndex": 0,
+      "jsonName": "serviceType",
+      "options": undefined,
+      "proto3Optional": true,
+    }, {
+      "name": "field",
+      "number": 51234,
+      "label": 1,
+      "type": 14,
+      "typeName": ".dev.restate.ext.FieldType",
+      "extendee": ".google.protobuf.FieldOptions",
+      "defaultValue": "",
+      "oneofIndex": 0,
+      "jsonName": "field",
+      "options": undefined,
+      "proto3Optional": true,
+    }],
+    "options": {
+      "javaPackage": "com.dev.restate.ext",
+      "javaOuterClassname": "ExtProto",
+      "javaMultipleFiles": true,
+      "javaGenerateEqualsAndHash": false,
+      "javaStringCheckUtf8": false,
+      "optimizeFor": 1,
+      "goPackage": "restate.dev/sdk-go/pb/ext",
+      "ccGenericServices": false,
+      "javaGenericServices": false,
+      "pyGenericServices": false,
+      "phpGenericServices": false,
+      "deprecated": false,
+      "ccEnableArenas": false,
+      "objcClassPrefix": "DRE",
+      "csharpNamespace": "Dev.Restate.Ext",
+      "swiftPrefix": "",
+      "phpClassPrefix": "",
+      "phpNamespace": "Dev\\Restate\\Ext",
+      "phpMetadataNamespace": "Dev\\Restate\\Ext\\GPBMetadata",
+      "rubyPackage": "Dev::Restate::Ext",
+      "uninterpretedOption": [],
+    },
+    "sourceCodeInfo": {
+      "location": [{
+        "path": [2],
+        "span": [14, 0, 24],
+        "leadingComments":
+          " Restate extensions.\n This package contains the definition of the protobuf extensions to define Restate services.\n For more details, check out the documentation: https://docs.restate.dev/services/service_type\n",
+        "trailingComments": "",
+        "leadingDetachedComments": [],
+      }, {
+        "path": [5, 0, 2, 0],
+        "span": [24, 2, 14],
+        "leadingComments": " protolint:disable:next ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH\n",
+        "trailingComments": "",
+        "leadingDetachedComments": [],
+      }, {
+        "path": [5, 1, 2, 0],
+        "span": [32, 2, 10],
+        "leadingComments":
+          " protolint:disable:next ENUM_FIELD_NAMES_ZERO_VALUE_END_WITH\n Note: only string fields can be used for service key fields\n",
+        "trailingComments": "",
+        "leadingDetachedComments": [],
+      }, {
+        "path": [5, 1, 2, 1],
+        "span": [36, 2, 20],
+        "leadingComments":
+          " Flag a field as event payload. When receiving events, this field will be filled with the event payload.\n Note: only string fields can be used for event payload fields\n",
+        "trailingComments": "",
+        "leadingDetachedComments": [],
+      }, {
+        "path": [5, 1, 2, 2],
+        "span": [39, 2, 21],
+        "leadingComments":
+          " Flag a field as event metadata. When receiving events, this field will be filled with the event metadata.\n Note: only type map<string, string> can be used for event payload fields\n",
+        "trailingComments": "",
+        "leadingDetachedComments": [],
+      }],
+    },
+    "syntax": "proto3",
+  }),
+  references: { ".dev.restate.ext.ServiceType": ServiceType, ".dev.restate.ext.FieldType": FieldType },
+  dependencies: [protoMetadata1],
+};