@restatedev/restate-sdk 0.8.1 → 0.9.0

package/src/workflows/workflow_state_service.ts

@@ -1,299 +0,0 @@
-/*
- * 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
- */
-
-import * as restate from "../public_api";
-import { LifecycleStatus, WorkflowStartResult } from "./workflow";
-
-const LIFECYCLE_STATUS_STATE_NAME = "status";
-const RESULT_STATE_NAME = "result";
-const RESULT_LISTENERS_NAME = "result_listeners";
-const PROMISE_STATE_PREFIX = "prom_s_";
-const USER_STATE_PREFIX = "state_";
-const PROMISE_AWAKEABLE_PREFIX = "prom_l_";
-
-export type ValueOrError<T> = {
-  value?: T;
-  error?: string;
-};
-
-export const workflowStateService = restate.keyedRouter({
-  startWorkflow: async (
-    ctx: restate.KeyedContext
-  ): Promise<WorkflowStartResult> => {
-    const status =
-      (await ctx.get<LifecycleStatus>(LIFECYCLE_STATUS_STATE_NAME)) ??
-      LifecycleStatus.NOT_STARTED;
-
-    if (status !== LifecycleStatus.NOT_STARTED) {
-      return status === LifecycleStatus.RUNNING
-        ? WorkflowStartResult.ALREADY_STARTED
-        : WorkflowStartResult.ALREADY_FINISHED;
-    }
-
-    ctx.set(LIFECYCLE_STATUS_STATE_NAME, LifecycleStatus.RUNNING);
-    return WorkflowStartResult.STARTED;
-  },
-
-  finishOrFailWorkflow: async <R>(
-    ctx: restate.KeyedContext,
-    _workflowId: string,
-    result: ValueOrError<R>
-  ): Promise<void> => {
-    if (result.error === undefined && result.value === undefined) {
-      throw new restate.TerminalError("Result is undefined");
-    }
-
-    const status =
-      (await ctx.get<LifecycleStatus>(LIFECYCLE_STATUS_STATE_NAME)) ??
-      LifecycleStatus.NOT_STARTED;
-
-    if (status !== LifecycleStatus.RUNNING) {
-      // not sure this can ever happen, but we put this here defensively
-      throw new restate.TerminalError("Unexpected state: " + status);
-    }
-
-    const newStatus = result.error
-      ? LifecycleStatus.FAILED
-      : LifecycleStatus.FINISHED;
-    ctx.set(LIFECYCLE_STATUS_STATE_NAME, newStatus);
-
-    await completePromise(
-      ctx,
-      RESULT_STATE_NAME,
-      RESULT_LISTENERS_NAME,
-      result
-    );
-  },
-
-  getStatus: async (ctx: restate.KeyedContext): Promise<LifecycleStatus> => {
-    return (
-      (await ctx.get<LifecycleStatus>(LIFECYCLE_STATUS_STATE_NAME)) ??
-      LifecycleStatus.NOT_STARTED
-    );
-  },
-
-  completePromise: async <T>(
-    ctx: restate.KeyedContext,
-    _workflowId: string,
-    req: { promiseName: string; completion: ValueOrError<T> }
-  ): Promise<void> => {
-    // we don't accept writes after the workflow is done
-    if (!(await checkIfRunning(ctx))) {
-      return;
-    }
-
-    await completePromise(
-      ctx,
-      PROMISE_STATE_PREFIX + req.promiseName,
-      PROMISE_AWAKEABLE_PREFIX + req.promiseName,
-      req.completion
-    );
-  },
-
-  peekPromise: async <T>(
-    ctx: restate.KeyedContext,
-    _workflowId: string,
-    req: { promiseName: string }
-  ): Promise<ValueOrError<T> | null> => {
-    return peekPromise(ctx, PROMISE_STATE_PREFIX + req.promiseName);
-  },
-
-  subscribePromise: async <T>(
-    ctx: restate.KeyedContext,
-    _workflowId: string,
-    req: { promiseName: string; awkId: string }
-  ): Promise<ValueOrError<T> | null> => {
-    return subscribePromise(
-      ctx,
-      PROMISE_STATE_PREFIX + req.promiseName,
-      PROMISE_AWAKEABLE_PREFIX + req.promiseName,
-      req.awkId
-    );
-  },
-
-  getResult: async <R>(
-    ctx: restate.KeyedContext
-  ): Promise<ValueOrError<R> | null> => {
-    return peekPromise(ctx, RESULT_STATE_NAME);
-  },
-
-  subscribeResult: async <T>(
-    ctx: restate.KeyedContext,
-    workflowId: string,
-    awkId: string
-  ): Promise<ValueOrError<T> | null> => {
-    const status =
-      (await ctx.get(LIFECYCLE_STATUS_STATE_NAME)) ??
-      LifecycleStatus.NOT_STARTED;
-    if (status === LifecycleStatus.NOT_STARTED) {
-      throw new restate.TerminalError(
-        `Workflow with id '${workflowId}' does not exist.`
-      );
-    }
-    return subscribePromise(
-      ctx,
-      RESULT_STATE_NAME,
-      RESULT_LISTENERS_NAME,
-      awkId
-    );
-  },
-
-  getState: async <T>(
-    ctx: restate.KeyedContext,
-    _workflowId: string,
-    stateName: string
-  ): Promise<T | null> => {
-    return ctx.get(USER_STATE_PREFIX + stateName);
-  },
-
-  setState: async <T>(
-    ctx: restate.KeyedContext,
-    _workflowId: string,
-    request: { stateName: string; value: T }
-  ): Promise<void> => {
-    if (!request?.stateName) {
-      throw new restate.TerminalError("missing state name");
-    }
-    if (request.value === undefined || request.value === null) {
-      throw new restate.TerminalError("invalid state value: " + request.value);
-    }
-
-    // if the workflow isn't running (any more) we don't accept state updates
-    // shouldn't be possible anyways (because only workflow method has access to writable state)
-    // but we are defensive here against API errors
-    if (!(await checkIfRunning(ctx))) {
-      return;
-    }
-
-    const stateName = USER_STATE_PREFIX + request.stateName;
-
-    ctx.set(stateName, request.value);
-  },
-
-  clearState: async (
-    ctx: restate.KeyedContext,
-    _workflowId: string,
-    stateName: string
-  ): Promise<void> => {
-    ctx.clear(USER_STATE_PREFIX + stateName);
-  },
-
-  stateKeys: async (ctx: restate.KeyedContext): Promise<Array<string>> => {
-    return (await ctx.stateKeys()).filter((name) =>
-      name.startsWith(USER_STATE_PREFIX)
-    );
-  },
-
-  clearAllState: async (ctx: restate.KeyedContext): Promise<void> => {
-    const stateNames = (await ctx.stateKeys()).filter((name) =>
-      name.startsWith(USER_STATE_PREFIX)
-    );
-    for (const stateName of stateNames) {
-      ctx.clear(stateName);
-    }
-  },
-
-  dispose: async (ctx: restate.KeyedContext): Promise<void> => {
-    ctx.clearAll();
-  },
-});
-
-export type api = typeof workflowStateService;
-
-// ----------------------------------------------------------------------------
-
-async function completePromise<T>(
-  ctx: restate.KeyedContext,
-  stateName: string,
-  awakeableStateName: string,
-  completion: ValueOrError<T>
-): Promise<ValueOrError<T>> {
-  if (completion.value !== undefined && completion.error !== undefined) {
-    throw new restate.TerminalError(
-      "Completion can only be either with value or with error"
-    );
-  }
-  if (completion.value !== undefined && completion.value === null) {
-    throw new restate.TerminalError("promise cannot be completed with null");
-  }
-  if (completion.error !== undefined && completion.error === null) {
-    throw new restate.TerminalError("promise cannot be rejected with null");
-  }
-
-  const currVal = await ctx.get<ValueOrError<T>>(stateName);
-  if (currVal !== null) {
-    // promise already completed
-    return currVal;
-  }
-
-  // first completor
-  // (a) set state
-  ctx.set(stateName, completion);
-
-  // (b) complete awaiting awakeables
-  const listeners = (await ctx.get<string[]>(awakeableStateName)) ?? [];
-  listeners.forEach((awkId: string) => {
-    if (completion.error !== undefined) {
-      ctx.rejectAwakeable(awkId, completion.error);
-    } else {
-      ctx.resolveAwakeable(awkId, completion.value);
-    }
-  });
-  ctx.clear(awakeableStateName);
-
-  return completion;
-}
-
-async function subscribePromise<T>(
-  ctx: restate.KeyedContext,
-  stateName: string,
-  awakeableStateName: string,
-  awakeableId: string
-): Promise<ValueOrError<T> | null> {
-  const currVal = await ctx.get<ValueOrError<T>>(stateName);
-
-  // case (a), we have a value already
-  if (currVal !== null) {
-    if (currVal.error !== undefined) {
-      ctx.rejectAwakeable(awakeableId, currVal.error);
-    } else {
-      ctx.resolveAwakeable(awakeableId, currVal.value);
-    }
-    return currVal;
-  }
-
-  // case (b), we remember the awk Id and get when we have a value
-  // but only if the workflow is still running
-  if (!(await checkIfRunning(ctx))) {
-    const response = {
-      error: "Promised will never resolve because workflow is not running",
-    };
-    ctx.rejectAwakeable(awakeableId, response.error);
-    return response;
-  }
-
-  const listeners = (await ctx.get<string[]>(awakeableStateName)) ?? [];
-  listeners.push(awakeableId);
-  ctx.set(awakeableStateName, listeners);
-  return null;
-}
-
-async function peekPromise<T>(
-  ctx: restate.KeyedContext,
-  stateName: string
-): Promise<ValueOrError<T> | null> {
-  return ctx.get<ValueOrError<T>>(stateName);
-}
-
-async function checkIfRunning(ctx: restate.KeyedContext): Promise<boolean> {
-  const status = await ctx.get<LifecycleStatus>(LIFECYCLE_STATUS_STATE_NAME);
-  return status === LifecycleStatus.RUNNING;
-}

package/src/workflows/workflow_wrapper_service.ts

@@ -1,314 +0,0 @@
-/*
- * 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
- */
-
-import * as restate from "../public_api";
-import * as wf from "./workflow";
-import * as wss from "./workflow_state_service";
-
-const DEFAULT_RETENTION_PERIOD = 7 * 24 * 60 * 60 * 1000; // 1 week
-
-// ----------------------------------------------------------------------------
-//                      Workflow Context Implementations
-// ----------------------------------------------------------------------------
-
-class SharedContextImpl implements wf.SharedWfContext {
-  constructor(
-    protected readonly ctx: restate.Context,
-    protected readonly wfId: string,
-    protected readonly stateServiceApi: restate.ServiceApi<wss.api>
-  ) {}
-
-  workflowId(): string {
-    return this.wfId;
-  }
-
-  get<T>(stateName: string): Promise<T | null> {
-    return this.ctx
-      .rpc(this.stateServiceApi)
-      .getState(this.wfId, stateName) as Promise<T | null>;
-  }
-
-  promise<T = void>(name: string): wf.DurablePromise<T> {
-    // Create the awakeable to complete
-    const awk = this.ctx.awakeable<T>();
-    this.ctx.send(this.stateServiceApi).subscribePromise(this.wfId, {
-      promiseName: name,
-      awkId: awk.id,
-    });
-
-    // Prepare implementation of DurablePromise
-
-    const peek = async (): Promise<T | null> => {
-      const result = await this.ctx
-        .rpc(this.stateServiceApi)
-        .peekPromise(this.wfId, { promiseName: name });
-
-      if (result === null) {
-        return null;
-      }
-      if (result.error !== undefined) {
-        return Promise.reject(new Error(result.error));
-      }
-      return Promise.resolve<T>(result.value as T);
-    };
-
-    const resolve = (value: T) => {
-      const currentValue = value === undefined ? null : value;
-
-      this.ctx.send(this.stateServiceApi).completePromise(this.wfId, {
-        promiseName: name,
-        completion: { value: currentValue },
-      });
-    };
-
-    const reject = (errorMsg: string) => {
-      this.ctx.send(this.stateServiceApi).completePromise(this.wfId, {
-        promiseName: name,
-        completion: { error: errorMsg },
-      });
-    };
-
-    return Object.defineProperties(awk.promise, {
-      peek: {
-        value: peek.bind(this),
-      },
-      resolve: {
-        value: resolve.bind(this),
-      },
-      reject: {
-        value: reject.bind(this),
-      },
-    }) as wf.DurablePromise<T>;
-  }
-}
-
-class ExclusiveContextImpl extends SharedContextImpl implements wf.WfContext {
-  public readonly id: Buffer;
-  public readonly serviceName: string;
-  public readonly rand: restate.Rand;
-  public readonly console: Console;
-
-  constructor(
-    ctx: restate.Context,
-    wfId: string,
-    stateServiceApi: restate.ServiceApi<wss.api>
-  ) {
-    super(ctx, wfId, stateServiceApi);
-    this.id = ctx.id;
-    this.serviceName = ctx.serviceName;
-    this.rand = ctx.rand;
-    this.console = ctx.console;
-  }
-
-  grpcChannel(): restate.RestateGrpcChannel {
-    return this.ctx.grpcChannel();
-  }
-
-  set<T>(stateName: string, value: T): void {
-    if (value === undefined || value === null) {
-      throw new restate.TerminalError("Cannot set state to null or undefined");
-    }
-
-    this.ctx
-      .send(this.stateServiceApi)
-      .setState(this.wfId, { stateName, value });
-  }
-
-  clear(stateName: string): void {
-    this.ctx.send(this.stateServiceApi).clearState(this.wfId, stateName);
-  }
-
-  stateKeys(): Promise<Array<string>> {
-    return this.ctx.rpc(this.stateServiceApi).stateKeys(this.wfId);
-  }
-
-  clearAll(): void {
-    this.ctx.send(this.stateServiceApi).clearAllState(this.wfId);
-  }
-
-  sideEffect<T>(
-    fn: () => Promise<T>,
-    retryPolicy?: restate.RestateUtils.RetrySettings
-  ): Promise<T> {
-    return this.ctx.sideEffect(fn, retryPolicy);
-  }
-
-  awakeable<T>(): { id: string; promise: restate.CombineablePromise<T> } {
-    return this.ctx.awakeable();
-  }
-  resolveAwakeable<T>(id: string, payload: T): void {
-    this.ctx.resolveAwakeable(id, payload);
-  }
-  rejectAwakeable(id: string, reason: string): void {
-    this.ctx.rejectAwakeable(id, reason);
-  }
-
-  sleep(millis: number): restate.CombineablePromise<void> {
-    return this.ctx.sleep(millis);
-  }
-
-  rpc<M>(opts: restate.ServiceApi<M>): restate.Client<M> {
-    return this.ctx.rpc(opts);
-  }
-  send<M>(opts: restate.ServiceApi<M>): restate.SendClient<M> {
-    return this.ctx.send(opts);
-  }
-  sendDelayed<M>(
-    opts: restate.ServiceApi<M>,
-    delay: number
-  ): restate.SendClient<M> {
-    return this.ctx.sendDelayed(opts, delay);
-  }
-}
-
-// ----------------------------------------------------------------------------
-//               the service that wraps the workflow methods
-// ----------------------------------------------------------------------------
-
-export function createWrapperService<R, T, M>(
-  workflow: wf.Workflow<R, T, M>,
-  path: string,
-  stateServiceApi: restate.ServiceApi<wss.api>
-) {
-  const wrapperService = {
-    submit: async (
-      ctx: restate.Context,
-      request: wf.WorkflowRequest<T>
-    ): Promise<wf.WorkflowStartResult> => {
-      checkRequestAndWorkflowId(request);
-
-      const started = await ctx
-        .rpc(stateServiceApi)
-        .startWorkflow(request.workflowId);
-      if (started === wf.WorkflowStartResult.STARTED) {
-        ctx.send(wrapperServiceApi).run(request);
-      }
-      return started;
-    },
-
-    run: async (
-      ctx: restate.Context,
-      request: wf.WorkflowRequest<T>
-    ): Promise<R> => {
-      checkRequestAndWorkflowId(request);
-
-      const wfCtx = new ExclusiveContextImpl(
-        ctx,
-        request.workflowId,
-        stateServiceApi
-      );
-      try {
-        const result = await workflow.run(wfCtx, request);
-        const resultValue = result !== undefined ? result : {};
-        await ctx
-          .rpc(stateServiceApi)
-          .finishOrFailWorkflow(request.workflowId, { value: resultValue });
-        return result;
-      } catch (err) {
-        const msg = stringifyError(err);
-        await ctx
-          .rpc(stateServiceApi)
-          .finishOrFailWorkflow(request.workflowId, { error: msg });
-        throw err;
-      } finally {
-        ctx
-          .sendDelayed(stateServiceApi, DEFAULT_RETENTION_PERIOD)
-          .dispose(request.workflowId);
-      }
-    },
-
-    waitForResult: async (
-      ctx: restate.Context,
-      request: wf.WorkflowRequest<unknown>
-    ): Promise<R> => {
-      checkRequestAndWorkflowId(request);
-
-      const awakeable = ctx.awakeable<R>();
-      await ctx
-        .rpc(stateServiceApi)
-        .subscribeResult(request.workflowId, awakeable.id);
-      return awakeable.promise;
-    },
-
-    status: async (
-      ctx: restate.Context,
-      request: wf.WorkflowRequest<unknown>
-    ): Promise<wf.LifecycleStatus> => {
-      checkRequestAndWorkflowId(request);
-      return ctx.rpc(stateServiceApi).getStatus(request.workflowId);
-    },
-  };
-
-  // add all the interaction methods to the wrapper service
-  for (const [route, handler] of Object.entries(workflow)) {
-    if (typeof handler !== "function" || route === "run") {
-      continue;
-    }
-    if (handler.length < 1 || handler.length > 2) {
-      throw new Error(
-        "Workflow function does not conform to correct signature: must have at least one argument (SharedWfContext) and at most a second argument (the request parameter)"
-      );
-    }
-
-    const wrappingHandler = async <OUT, IN>(
-      ctx: restate.Context,
-      request: wf.WorkflowRequest<IN>
-    ): Promise<OUT> => {
-      checkRequestAndWorkflowId(request);
-      const wfCtx = new SharedContextImpl(
-        ctx,
-        request.workflowId,
-        stateServiceApi
-      );
-
-      // impl. note: we need the extra cast to 'unknown', because the 'run' method is
-      // otherwise incompatible with the cast. we exclude that method in the filter above,
-      // but the compiler doesn't recognize that.
-      return (
-        handler as unknown as (ctx: wf.SharedWfContext, req: IN) => Promise<OUT>
-      )(wfCtx, request);
-    };
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    (wrapperService as any)[route] = wrappingHandler;
-  }
-
-  const wrapperServiceRouter = restate.router(wrapperService);
-  const wrapperServiceApi: restate.ServiceApi<typeof wrapperServiceRouter> = {
-    path,
-  };
-
-  return wrapperServiceRouter;
-}
-
-function checkRequestAndWorkflowId(request: wf.WorkflowRequest<unknown>): void {
-  if (request === undefined) {
-    throw new restate.TerminalError("Request parameter is undefined");
-  }
-  if (request.workflowId === undefined) {
-    throw new restate.TerminalError("Request is missing property 'workflowId'");
-  }
-}
-
-function stringifyError(error: unknown): string {
-  if (typeof error === "string") {
-    return error;
-  }
-  if (error instanceof Error) {
-    const e = error as Error;
-    return `${e.name}: ${e.message}\nStack: ${e.stack}`;
-  }
-  try {
-    return JSON.stringify(error);
-  } catch (err) {
-    return "(cause not stringify-able)";
-  }
-}