@restatedev/restate-sdk 0.7.3-worker → 0.8.1

package/src/generated/proto/test.ts

@@ -0,0 +1,387 @@
+/* eslint-disable */
+import _m0 from "protobufjs/minimal";
+import { FileDescriptorProto as FileDescriptorProto1 } from "ts-proto-descriptors";
+import { protoMetadata as protoMetadata1 } from "../dev/restate/ext";
+import { Empty, protoMetadata as protoMetadata2 } from "../google/protobuf/empty";
+
+export const protobufPackage = "test";
+
+export interface TestRequest {
+  name: string;
+}
+
+export interface TestResponse {
+  greeting: string;
+}
+
+export interface TestEmpty {
+  greeting: Empty | undefined;
+}
+
+function createBaseTestRequest(): TestRequest {
+  return { name: "" };
+}
+
+export const TestRequest = {
+  encode(message: TestRequest, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.name !== "") {
+      writer.uint32(10).string(message.name);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TestRequest {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTestRequest();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.name = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TestRequest {
+    return { name: isSet(object.name) ? globalThis.String(object.name) : "" };
+  },
+
+  toJSON(message: TestRequest): unknown {
+    const obj: any = {};
+    if (message.name !== "") {
+      obj.name = message.name;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TestRequest>): TestRequest {
+    return TestRequest.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TestRequest>): TestRequest {
+    const message = createBaseTestRequest();
+    message.name = object.name ?? "";
+    return message;
+  },
+};
+
+function createBaseTestResponse(): TestResponse {
+  return { greeting: "" };
+}
+
+export const TestResponse = {
+  encode(message: TestResponse, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.greeting !== "") {
+      writer.uint32(10).string(message.greeting);
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TestResponse {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTestResponse();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.greeting = reader.string();
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TestResponse {
+    return { greeting: isSet(object.greeting) ? globalThis.String(object.greeting) : "" };
+  },
+
+  toJSON(message: TestResponse): unknown {
+    const obj: any = {};
+    if (message.greeting !== "") {
+      obj.greeting = message.greeting;
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TestResponse>): TestResponse {
+    return TestResponse.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TestResponse>): TestResponse {
+    const message = createBaseTestResponse();
+    message.greeting = object.greeting ?? "";
+    return message;
+  },
+};
+
+function createBaseTestEmpty(): TestEmpty {
+  return { greeting: undefined };
+}
+
+export const TestEmpty = {
+  encode(message: TestEmpty, writer: _m0.Writer = _m0.Writer.create()): _m0.Writer {
+    if (message.greeting !== undefined) {
+      Empty.encode(message.greeting, writer.uint32(10).fork()).ldelim();
+    }
+    return writer;
+  },
+
+  decode(input: _m0.Reader | Uint8Array, length?: number): TestEmpty {
+    const reader = input instanceof _m0.Reader ? input : _m0.Reader.create(input);
+    let end = length === undefined ? reader.len : reader.pos + length;
+    const message = createBaseTestEmpty();
+    while (reader.pos < end) {
+      const tag = reader.uint32();
+      switch (tag >>> 3) {
+        case 1:
+          if (tag !== 10) {
+            break;
+          }
+
+          message.greeting = Empty.decode(reader, reader.uint32());
+          continue;
+      }
+      if ((tag & 7) === 4 || tag === 0) {
+        break;
+      }
+      reader.skipType(tag & 7);
+    }
+    return message;
+  },
+
+  fromJSON(object: any): TestEmpty {
+    return { greeting: isSet(object.greeting) ? Empty.fromJSON(object.greeting) : undefined };
+  },
+
+  toJSON(message: TestEmpty): unknown {
+    const obj: any = {};
+    if (message.greeting !== undefined) {
+      obj.greeting = Empty.toJSON(message.greeting);
+    }
+    return obj;
+  },
+
+  create(base?: DeepPartial<TestEmpty>): TestEmpty {
+    return TestEmpty.fromPartial(base ?? {});
+  },
+  fromPartial(object: DeepPartial<TestEmpty>): TestEmpty {
+    const message = createBaseTestEmpty();
+    message.greeting = (object.greeting !== undefined && object.greeting !== null)
+      ? Empty.fromPartial(object.greeting)
+      : undefined;
+    return message;
+  },
+};
+
+export interface TestGreeter {
+  greet(request: TestRequest): Promise<TestResponse>;
+}
+
+export const TestGreeterServiceName = "test.TestGreeter";
+export class TestGreeterClientImpl implements TestGreeter {
+  private readonly rpc: Rpc;
+  private readonly service: string;
+  constructor(rpc: Rpc, opts?: { service?: string }) {
+    this.service = opts?.service || TestGreeterServiceName;
+    this.rpc = rpc;
+    this.greet = this.greet.bind(this);
+  }
+  greet(request: TestRequest): Promise<TestResponse> {
+    const data = TestRequest.encode(request).finish();
+    const promise = this.rpc.request(this.service, "Greet", data);
+    return promise.then((data) => TestResponse.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/test.proto",
+    "package": "test",
+    "dependency": ["dev/restate/ext.proto", "google/protobuf/empty.proto"],
+    "publicDependency": [],
+    "weakDependency": [],
+    "messageType": [{
+      "name": "TestRequest",
+      "field": [{
+        "name": "name",
+        "number": 1,
+        "label": 1,
+        "type": 9,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "name",
+        "options": {
+          "ctype": 0,
+          "packed": false,
+          "jstype": 0,
+          "lazy": false,
+          "deprecated": false,
+          "weak": false,
+          "uninterpretedOption": [],
+        },
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }, {
+      "name": "TestResponse",
+      "field": [{
+        "name": "greeting",
+        "number": 1,
+        "label": 1,
+        "type": 9,
+        "typeName": "",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "greeting",
+        "options": undefined,
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }, {
+      "name": "TestEmpty",
+      "field": [{
+        "name": "greeting",
+        "number": 1,
+        "label": 1,
+        "type": 11,
+        "typeName": ".google.protobuf.Empty",
+        "extendee": "",
+        "defaultValue": "",
+        "oneofIndex": 0,
+        "jsonName": "greeting",
+        "options": undefined,
+        "proto3Optional": false,
+      }],
+      "extension": [],
+      "nestedType": [],
+      "enumType": [],
+      "extensionRange": [],
+      "oneofDecl": [],
+      "options": undefined,
+      "reservedRange": [],
+      "reservedName": [],
+    }],
+    "enumType": [],
+    "service": [{
+      "name": "TestGreeter",
+      "method": [{
+        "name": "Greet",
+        "inputType": ".test.TestRequest",
+        "outputType": ".test.TestResponse",
+        "options": { "deprecated": false, "idempotencyLevel": 0, "uninterpretedOption": [] },
+        "clientStreaming": false,
+        "serverStreaming": false,
+      }],
+      "options": { "deprecated": false, "uninterpretedOption": [] },
+    }],
+    "extension": [],
+    "options": {
+      "javaPackage": "com.test",
+      "javaOuterClassname": "TestProto",
+      "javaMultipleFiles": true,
+      "javaGenerateEqualsAndHash": false,
+      "javaStringCheckUtf8": false,
+      "optimizeFor": 1,
+      "goPackage": "",
+      "ccGenericServices": false,
+      "javaGenericServices": false,
+      "pyGenericServices": false,
+      "phpGenericServices": false,
+      "deprecated": false,
+      "ccEnableArenas": false,
+      "objcClassPrefix": "TXX",
+      "csharpNamespace": "Test",
+      "swiftPrefix": "",
+      "phpClassPrefix": "",
+      "phpNamespace": "Test",
+      "phpMetadataNamespace": "Test\\GPBMetadata",
+      "rubyPackage": "Test",
+      "uninterpretedOption": [],
+    },
+    "sourceCodeInfo": { "location": [] },
+    "syntax": "proto3",
+  }),
+  references: {
+    ".test.TestRequest": TestRequest,
+    ".test.TestResponse": TestResponse,
+    ".test.TestEmpty": TestEmpty,
+    ".test.TestGreeter": TestGreeterClientImpl,
+  },
+  dependencies: [protoMetadata1, protoMetadata2],
+  options: {
+    messages: { "TestRequest": { fields: { "name": { "field": 0 } } } },
+    services: { "TestGreeter": { options: { "service_type": 1 }, methods: {} } },
+  },
+};
+
+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 isSet(value: any): boolean {
+  return value !== null && value !== undefined;
+}

package/src/invocation.ts

@@ -0,0 +1,212 @@
+/*
+ * Copyright (c) 2023-2024 - Restate Software, Inc., Restate GmbH
+ *
+ * This file is part of the Restate SDK for Node.js/TypeScript,
+ * which is released under the MIT license.
+ *
+ * You can find a copy of the license in file LICENSE in the root
+ * directory of this repository or package, or at
+ * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
+ */
+
+/*eslint-disable @typescript-eslint/no-non-null-assertion*/
+
+import { Message } from "./types/types";
+import { HostedGrpcServiceMethod } from "./types/grpc";
+import {
+  Failure,
+  PollInputStreamEntryMessage,
+  StartMessage,
+} from "./generated/proto/protocol";
+import { formatMessageAsJson } from "./utils/utils";
+import {
+  POLL_INPUT_STREAM_ENTRY_MESSAGE_TYPE,
+  START_MESSAGE_TYPE,
+} from "./types/protocol";
+import { RestateStreamConsumer } from "./connection/connection";
+import { LocalStateStore } from "./local_state_store";
+import { ensureError } from "./types/errors";
+import { LoggerContext } from "./logger";
+import { CompletablePromise } from "./utils/promises";
+
+enum State {
+  ExpectingStart = 0,
+  ExpectingInput = 1,
+  ExpectingFurtherReplay = 2,
+  Complete = 3,
+}
+
+type InvocationValue =
+  | { kind: "value"; value: Buffer }
+  | { kind: "failure"; failure: Failure };
+
+export class InvocationBuilder<I, O> implements RestateStreamConsumer {
+  private readonly complete = new CompletablePromise<void>();
+
+  private state: State = State.ExpectingStart;
+
+  private runtimeReplayIndex = 0;
+  private replayEntries = new Map<number, Message>();
+  private id?: Buffer = undefined;
+  private debugId?: string = undefined;
+  private invocationValue?: InvocationValue = undefined;
+  private nbEntriesToReplay?: number = undefined;
+  private localStateStore?: LocalStateStore;
+
+  constructor(private readonly method: HostedGrpcServiceMethod<I, O>) {}
+
+  public handleMessage(m: Message): boolean {
+    try {
+      switch (this.state) {
+        case State.ExpectingStart:
+          checkState(State.ExpectingStart, START_MESSAGE_TYPE, m);
+          this.handleStartMessage(m.message as StartMessage);
+          this.state = State.ExpectingInput;
+          return false;
+
+        case State.ExpectingInput:
+          checkState(
+            State.ExpectingInput,
+            POLL_INPUT_STREAM_ENTRY_MESSAGE_TYPE,
+            m
+          );
+
+          this.handlePollInputStreamEntry(m);
+          this.addReplayEntry(m);
+          break;
+
+        case State.ExpectingFurtherReplay:
+          this.addReplayEntry(m);
+          break;
+
+        case State.Complete:
+          throw new Error(
+            `Journal builder is getting a message after the journal was complete. entries-to-replay: ${
+              this.nbEntriesToReplay
+            }, message: ${formatMessageAsJson(m)}`
+          );
+      }
+
+      this.state =
+        this.replayEntries.size === this.nbEntriesToReplay
+          ? State.Complete
+          : State.ExpectingFurtherReplay;
+
+      if (this.state === State.Complete) {
+        this.complete.resolve();
+        return true;
+      }
+
+      return false;
+    } catch (e) {
+      const error = ensureError(e);
+      this.complete.reject(error);
+      return true; // we want no further messages
+    }
+  }
+
+  private handlePollInputStreamEntry(m: Message) {
+    const pollInputStreamMessage = m.message as PollInputStreamEntryMessage;
+
+    if (pollInputStreamMessage.value !== undefined) {
+      this.invocationValue = {
+        kind: "value",
+        value: pollInputStreamMessage.value,
+      };
+    } else if (pollInputStreamMessage.failure !== undefined) {
+      this.invocationValue = {
+        kind: "failure",
+        failure: pollInputStreamMessage.failure,
+      };
+    } else {
+      throw new Error(
+        `PollInputStreamEntry neither contains value nor failure: ${formatMessageAsJson(
+          m
+        )}`
+      );
+    }
+  }
+
+  public handleStreamError(e: Error): void {
+    this.complete.reject(e);
+  }
+  public handleInputClosed(): void {
+    this.complete.reject(new Error("Input closed before journal is complete"));
+  }
+
+  public completion(): Promise<void> {
+    return this.complete.promise;
+  }
+
+  private handleStartMessage(m: StartMessage): InvocationBuilder<I, O> {
+    this.nbEntriesToReplay = m.knownEntries;
+    this.id = m.id;
+    this.debugId = m.debugId;
+    this.localStateStore = new LocalStateStore(m.partialState, m.stateMap);
+    return this;
+  }
+
+  private addReplayEntry(m: Message): InvocationBuilder<I, O> {
+    // Will be retrieved when the user code reaches this point
+    this.replayEntries.set(this.runtimeReplayIndex, m);
+    this.incrementRuntimeReplayIndex();
+    return this;
+  }
+
+  private incrementRuntimeReplayIndex() {
+    this.runtimeReplayIndex++;
+  }
+
+  public isComplete(): boolean {
+    return this.state === State.Complete;
+  }
+
+  public build(): Invocation<I, O> {
+    if (!this.isComplete()) {
+      throw new Error(
+        `Cannot build invocation. Not all data present: ${JSON.stringify(this)}`
+      );
+    }
+    return new Invocation(
+      this.method!,
+      this.id!,
+      this.debugId!,
+      this.nbEntriesToReplay!,
+      this.replayEntries!,
+      this.invocationValue!,
+      this.localStateStore!
+    );
+  }
+}
+
+export class Invocation<I, O> {
+  constructor(
+    public readonly method: HostedGrpcServiceMethod<I, O>,
+    public readonly id: Buffer,
+    public readonly debugId: string,
+    public readonly nbEntriesToReplay: number,
+    public readonly replayEntries: Map<number, Message>,
+    public readonly invocationValue: InvocationValue,
+    public readonly localStateStore: LocalStateStore
+  ) {}
+
+  public inferLoggerContext(additionalContext?: {
+    [name: string]: string;
+  }): LoggerContext {
+    return new LoggerContext(
+      this.debugId,
+      this.method.pkg,
+      this.method.service,
+      this.method.method.name,
+      additionalContext
+    );
+  }
+}
+
+function checkState(state: State, expected: bigint, m: Message) {
+  if (m.messageType !== expected) {
+    throw new Error(
+      `Unexpected message in state ${state}: ${formatMessageAsJson(m)}`
+    );
+  }
+}