@restatedev/restate-sdk 0.8.0 → 0.9.0

package/dist/{context.d.ts → src/context.d.ts}

@@ -1,7 +1,27 @@
 /// <reference types="node" />
 /// <reference types="node" />
-import { RetrySettings } from "./utils/public_utils";
-import { Client, SendClient } from "./types/router";
+import { Client, SendClient, ServiceDefinition, VirtualObjectDefinition } from "./types/rpc";
+/**
+ * Represents the original request as sent to this handler.
+ *
+ * A request object includes the request headers, and the raw unparsed
+ * request body.
+ */
+export interface Request {
+    /**
+     * The unique id that identifies the current function invocation. This id is guaranteed to be
+     * unique across invocations, but constant across reties and suspensions.
+     */
+    readonly id: Buffer;
+    /**
+     * Request headers
+     */
+    readonly headers: ReadonlyMap<string, string>;
+    /**
+     * Raw unparsed request body
+     */
+    readonly body: Uint8Array;
+}
 /**
  * Key value store operations. Only keyed services have an attached key-value store.
  */
@@ -15,7 +35,6 @@ export interface KeyValueStore {
      * @returns a Promise that is resolved with the value of the state key
      *
      * @example
-     * const ctx = restate.useContext(this);
      * const state = await ctx.get<string>("STATE");
      */
     get<T>(name: string): Promise<T | null>;
@@ -29,7 +48,6 @@ export interface KeyValueStore {
      * @param value value to set
      *
      * @example
-     * const ctx = restate.useContext(this);
      * ctx.set("STATE", "Hello");
      */
     set<T>(name: string, value: T): void;
@@ -38,7 +56,6 @@ export interface KeyValueStore {
      * @param name key of the state to delete
      *
      * @example
-     * const ctx = restate.useContext(this);
      * ctx.clear("STATE");
      */
     clear(name: string): void;
@@ -46,40 +63,76 @@ export interface KeyValueStore {
      * Clear/delete all the state entries in the Restate runtime.
      *
      * @example
-     * const ctx = restate.useContext(this);
      * ctx.clearAll();
      */
     clearAll(): void;
 }
+export interface SendOptions {
+    /**
+     * Makes a type-safe one-way RPC to the specified target service, after a delay specified by the
+     * milliseconds' argument.
+     * This method is like setting up a fault-tolerant cron job that enqueues the message in a
+     * message queue.
+     * The handler calling this function does not have to stay active for the delay time.
+     *
+     * Both the delay timer and the message are durably stored in Restate and guaranteed to be reliably
+     * delivered. The delivery happens no earlier than specified through the delay, but may happen
+     * later, if the target service is down, or backpressuring the system.
+     *
+     * The delay message is journaled for durable execution and will thus not be duplicated when the
+     * handler is re-invoked for retries or after suspending.
+     *
+     * This call will return immediately; the message sending happens asynchronously in the background.
+     * Despite that, the message is guaranteed to be sent, because the completion of the invocation that
+     * triggers the send (calls this function) happens logically after the sending. That means that any
+     * failure where the message does not reach Restate also cannot complete this invocation, and will
+     * hence recover this handler and (through the durable execution) recover the message to be sent.
+     *
+     * @example
+     * *Service Side:*
+     * ```ts
+     * const service = restate.service({
+     *      ...
+     *  });
+     *
+     * ```
+     * **Client side:**
+     * ```ts
+     * ctx.send(service, {delay: 60_000}).anotherAction(1337);
+     * ```
+     */
+    delay?: number;
+}
+export interface ContextDate {
+    /** Returns the number of milliseconds elapsed since midnight, January 1, 1970 Universal Coordinated Time (UTC).
+     *  This is equivalent to Date.now()
+     */
+    now(): Promise<number>;
+    /** Returns the JSON represention of the current date.
+     * This is equivalent to new Date().toJSON()
+     **/
+    toJSON(): Promise<string>;
+}
+export type RunAction<T> = (() => Promise<T>) | (() => T);
 /**
  * The context that gives access to all Restate-backed operations, for example
  *   - sending reliable messages / RPC through Restate
- *   - side effects
+ *   - execute non-deterministic closures and memoize their result
  *   - sleeps and delayed calls
  *   - awakeables
  *   - ...
  *
- * Keyed services can also access their key-value store using the {@link KeyedContext}.
+ * Virtual objects can also access their key-value store using the {@link ObjectContext}.
  *
- * In gRPC-based API, to access this context, use {@link useContext}.
  */
 export interface Context {
-    /**
-     * The unique id that identifies the current function invocation. This id is guaranteed to be
-     * unique across invocations, but constant across reties and suspensions.
-     */
-    id: Buffer;
-    /**
-     * Name of the service.
-     */
-    serviceName: string;
     /**
      * Deterministic random methods; these are inherently predictable (seeded on the invocation ID, which is not secret)
      * and so should not be used for any cryptographic purposes. They are useful for identifiers, idempotency keys,
      * and for uniform sampling from a set of options. If a cryptographically secure value is needed, please generate that
      * externally and capture the result with a side effect.
      *
-     * Calls to these methods from inside side effects are disallowed and will fail - side effects must be idempotent, and
+     * Calls to these methods from inside `ctx.run` are disallowed and will fail - side effects must be idempotent, and
      * these calls are not.
      */
     rand: Rand;
@@ -89,47 +142,54 @@ export interface Context {
      */
     console: Console;
     /**
-     * Execute a side effect and store the result in Restate. The side effect will thus not
-     * be re-executed during a later replay, but take the durable result from Restate.
+     * Deterministic date.
+     */
+    date: ContextDate;
+    /**
+     * Run an operation and store the result in Restate. The operation will thus not
+     * be re-run during a later replay, but take the durable result from Restate.
      *
-     * Side effects let you capture potentially non-deterministic computation and interaction
+     * This let you capture potentially non-deterministic computation and interaction
      * with external systems in a safe way.
      *
-     * Failure semantics of side effects are:
-     *   - If a side effect executed and persisted before, the result (value or Error) will be
+     * Failure semantics are:
+     *   - If an operation has run and persisted before, the result (value or Error) will be
      *     taken from the Restate journal.
-     *   - There is a small window where a side effect may be re-executed twice, if a failure
-     *     occurred between execution and persisting the result.
-     *   - No second side effect will be executed while a previous side effect's result is not
-     *     yet durable. That way, side effects that build on top of each other can assume
-     *     deterministic results from previous effects, and at most one side effect will be
+     *   - There is a small window where an action may be re-run, if a failure
+     *     occurred between a successful run and persisting the result.
+     *   - No second action will be run while a previous run's result is not
+     *     yet durable. That way, effects that build on top of each other can assume
+     *     deterministic results from previous runs, and at most one run will be
      *     re-executed on replay (the latest, if the failure happened in the small windows
      *     described above).
      *
-     * This function takes an optional retry policy, that determines what happens if the
-     * side effect throws an error. The default retry policy retries infinitely, with exponential
-     * backoff and uses suspending sleep for the wait times between retries.
-     *
      * @example
-     * const ctx = restate.useContext(this);
-     * const result = await ctx.sideEffect(async () => someExternalAction() )
+     * const result = await ctx.run(someExternalAction)
      *
      * @example
      * const paymentAction = async () => {
      *   const result = await paymentClient.call(txId, methodIdentifier, amount);
-     *   if (result.error) {
-     *     throw result.error;
+     *   if (!result.ok) {
+     *     throw result.cause;
      *   } else {
      *     return result.payment_accepted;
      *   }
      * }
      * const paymentAccepted: boolean =
-     *   await ctx.sideEffect(paymentAction, { maxRetries: 10});
+     *   await ctx.run("paymentAction", paymentAction);
      *
-     * @param fn The function to run as a side effect.
-     * @param retryPolicy The optional policy describing how retries happen.
+     * @param action The function to run.
+     * @param nameOrOptions the operation's name or a run configuration
      */
-    sideEffect<T>(fn: () => Promise<T>, retryPolicy?: RetrySettings): Promise<T>;
+    run<T>(action: RunAction<T>): Promise<T>;
+    /**
+     * Run an operation and store the result in Restate. The operation will thus not
+     * be re-run during a later replay, but take the durable result from Restate.
+     *
+     * @param name the action's name
+     * @param action the action to run.
+     */
+    run<T>(name: string, action: RunAction<T>): Promise<T>;
     /**
      * Register an awakeable and pause the processing until the awakeable ID (and optional payload) have been returned to the service
      * (via ctx.completeAwakeable(...)). The SDK deserializes the payload with `JSON.parse(result.toString()) as T`.
@@ -138,7 +198,6 @@ export interface Context {
      * - promise: the Promise that needs to be awaited and that is resolved with the payload that was supplied by the service which completed the awakeable
      *
      * @example
-     * const ctx = restate.useContext(this);
      * const awakeable = ctx.awakeable<string>();
      *
      * // send the awakeable ID to some external service that will wake this one back up
@@ -155,7 +214,7 @@ export interface Context {
         promise: CombineablePromise<T>;
     };
     /**
-     * Resolve an awakeable of another service.
+     * Resolve an awakeable.
      * @param id the string ID of the awakeable.
      * This is supplied by the service that needs to be woken up.
      * @param payload the payload to pass to the service that is woken up.
@@ -163,19 +222,17 @@ export interface Context {
      * and deserializes it in the receiving service with `JSON.parse(result.toString()) as T`.
      *
      * @example
-     * const ctx = restate.useContext(this);
      * // The sleeping service should have sent the awakeableIdentifier string to this service.
      * ctx.resolveAwakeable(awakeableIdentifier, "hello");
      */
     resolveAwakeable<T>(id: string, payload?: T): void;
     /**
-     * Reject an awakeable of another service. When rejecting, the service waiting on this awakeable will be woken up with a terminal error with the provided reason.
+     * Reject an awakeable. When rejecting, the service waiting on this awakeable will be woken up with a terminal error with the provided reason.
      * @param id the string ID of the awakeable.
      * This is supplied by the service that needs to be woken up.
      * @param reason the reason of the rejection.
      *
      * @example
-     * const ctx = restate.useContext(this);
      * // The sleeping service should have sent the awakeableIdentifier string to this service.
      * ctx.rejectAwakeable(awakeableIdentifier, "super bad error");
      */
@@ -186,7 +243,6 @@ export interface Context {
      * This is a lower-bound.
      *
      * @example
-     * const ctx = restate.useContext(this);
      * await ctx.sleep(1000);
      */
     sleep(millis: number): CombineablePromise<void>;
@@ -206,29 +262,38 @@ export interface Context {
      * @example
      * *Service Side:*
      * ```ts
-     * const router = restate.router({
-     *   someAction:    async(ctx: restate.RpcContext, req: string) => { ... },
-     *   anotherAction: async(ctx: restate.RpcContext, count: number) => { ... }
+     * const service = restate.service(
+     *   name: "myservice",
+     *   handlers: {
+     *    someAction:    async(ctx: restate.RpcContext, req: string) => { ... },
+     *    anotherAction: async(ctx: restate.RpcContext, count: number) => { ... }
      * });
      *
      * // option 1: export only the type signature of the router
-     * export type myApiType = typeof router;
+     * export type MyApi = typeof service;
      *
-     * // option 2: export the API definition with type and name (path)
-     * export const myApi: restate.ServiceApi<typeof router> = { path : "myservice" };
+     * // option 2: export the API definition with type and name (name)
+     * const MyService: MyApi = { name: "myservice" };
      *
-     * restate.createServer().bindRouter("myservice", router).listen(9080);
+     * restate.createServer().bind(service).listen(9080);
      * ```
      * **Client side:**
      * ```ts
      * // option 1: use only types and supply service name separately
-     * const result1 = await ctx.rpc<myApiType>({path: "myservice"}).someAction("hello!");
+     * const result1 = await ctx.serviceClient<MyApi>({name: "myservice"}).someAction("hello!");
      *
      * // option 2: use full API spec
-     * const result2 = await ctx.rpc(myApi).anotherAction(1337);
+     * const result2 = await ctx.serviceClient(MyService).anotherAction(1337);
      * ```
      */
-    rpc<M>(opts: ServiceApi<M>): Client<M>;
+    serviceClient<P extends string, M>(opts: ServiceDefinition<P, M>): Client<M>;
+    /**
+     * Same as {@link serviceClient} but for virtual objects.
+     *
+     * @param opts
+     * @param key the virtual object key
+     */
+    objectClient<P extends string, M>(opts: VirtualObjectDefinition<P, M>, key: string): Client<M>;
     /**
      * Makes a type-safe one-way RPC to the specified target service. This method effectively behaves
      * like enqueuing the message in a message queue.
@@ -246,94 +311,59 @@ export interface Context {
      * @example
      * *Service Side:*
      * ```ts
-     * const router = restate.router({
-     *   someAction:    async(ctx: restate.RpcContext, req: string) => { ... },
-     *   anotherAction: async(ctx: restate.RpcContext, count: number) => { ... }
+     * const service = restate.service(
+     *   name: "myservice",
+     *   handlers: {
+     *    someAction:    async(ctx: restate.RpcContext, req: string) => { ... },
+     *    anotherAction: async(ctx: restate.RpcContext, count: number) => { ... }
      * });
      *
      * // option 1: export only the type signature of the router
-     * export type myApiType = typeof router;
+     * export type MyApi = typeof service;
      *
-     * // option 2: export the API definition with type and name (path)
-     * export const myApi: restate.ServiceApi<typeof router> = { path : "myservice" };
+     * // option 2: export the API definition with type and name (name)
+     * const MyService: MyApi = { name: "myservice" };
      *
-     * restate.createServer().bindRouter("myservice", router).listen(9080);
+     * restate.createServer().bind(service).listen(9080);
      * ```
      * **Client side:**
      * ```ts
      * // option 1: use only types and supply service name separately
-     * ctx.send<myApiType>({path: "myservice"}).someAction("hello!");
+     * ctx.serviceSendClient<MyApi>({name: "myservice"}).someAction("hello!");
      *
      * // option 2: use full API spec
-     * ctx.send(myApi).anotherAction(1337);
+     * ctx.serviceSendClient(MyService).anotherAction(1337);
      * ```
      */
-    send<M>(opts: ServiceApi<M>): SendClient<M>;
+    serviceSendClient<P extends string, M>(service: ServiceDefinition<P, M>, opts?: SendOptions): SendClient<M>;
     /**
-     * Makes a type-safe one-way RPC to the specified target service, after a delay specified by the
-     * milliseconds' argument.
-     * This method is like stetting up a fault-tolerant cron job that enqueues the message in a
-     * message queue.
-     * The handler calling this function does not have to stay active for the delay time.
+     * Same as {@link serviceSendClient} but for virtual objects.
      *
-     * Both the delay timer and the message are durably stored in Restate and guaranteed to be reliably
-     * delivered. The delivery happens no earlier than specified through the delay, but may happen
-     * later, if the target service is down, or backpressuring the system.
-     *
-     * The delay message is journaled for durable execution and will thus not be duplicated when the
-     * handler is re-invoked for retries or after suspending.
-     *
-     * This call will return immediately; the message sending happens asynchronously in the background.
-     * Despite that, the message is guaranteed to be sent, because the completion of the invocation that
-     * triggers the send (calls this function) happens logically after the sending. That means that any
-     * failure where the message does not reach Restate also cannot complete this invocation, and will
-     * hence recover this handler and (through the durable execution) recover the message to be sent.
-     *
-     * @example
-     * *Service Side:*
-     * ```ts
-     * const router = restate.router({
-     *   someAction:    async(ctx: restate.RpcContext, req: string) => { ... },
-     *   anotherAction: async(ctx: restate.RpcContext, count: number) => { ... }
-     * });
-     *
-     * // option 1: export only the type signature of the router
-     * export type myApiType = typeof router;
-     *
-     * // option 2: export the API definition with type and name (path)
-     * export const myApi: restate.ServiceApi<typeof router> = { path : "myservice" };
-     *
-     * restate.createServer().bindRouter("myservice", router).listen(9080);
-     * ```
-     * **Client side:**
-     * ```ts
-     * // option 1: use only types and supply service name separately
-     * ctx.sendDelayed<myApiType>({path: "myservice"}, 60_000).someAction("hello!");
-     *
-     * // option 2: use full API spec
-     * ctx.sendDelayed(myApi, 60_000).anotherAction(1337);
-     * ```
+     * @param obj
+     * @param key the virtual object key
+     * @param opts Send options
      */
-    sendDelayed<M>(opts: ServiceApi<M>, delay: number): SendClient<M>;
+    objectSendClient<P extends string, M>(obj: VirtualObjectDefinition<P, M>, key: string, opts?: SendOptions): SendClient<M>;
     /**
-     * Get the {@link RestateGrpcChannel} to invoke gRPC based services.
+     * Returns the raw request that triggered that handler.
+     * Use that object to inspect the original request headers
      */
-    grpcChannel(): RestateGrpcChannel;
+    request(): Request;
 }
 /**
  * The context that gives access to all Restate-backed operations, for example
  *   - sending reliable messages / RPC through Restate
  *   - access/update state
- *   - side effects
+ *   - execute non-deterministic closures and memoize their result
  *   - sleeps and delayed calls
  *   - awakeables
  *   - ...
  *
- * This context can be used only within keyed services/routers.
+ * This context can be used only within virtual objects.
  *
- * In gRPC-based API, to access this context, use {@link useKeyedContext}.
  */
-export interface KeyedContext extends Context, KeyValueStore {
+export interface ObjectContext extends Context, KeyValueStore {
+    key: string;
 }
 export interface Rand {
     /**
@@ -351,7 +381,6 @@ export interface Rand {
  * A promise that can be combined using Promise combinators in RestateContext.
  */
 export type CombineablePromise<T> = Promise<T> & {
-    __restate_context: Context;
     /**
      * Creates a promise that awaits for the current promise up to the specified timeout duration.
      * If the timeout is fired, this Promise will be rejected with a {@link TimeoutError}.
@@ -404,111 +433,4 @@ export declare const CombineablePromise: {
      */
     allSettled<T_3 extends [] | readonly CombineablePromise<unknown>[]>(values: T_3): Promise<{ -readonly [P_1 in keyof T_3]: PromiseSettledResult<Awaited<T_3[P_1]>>; }>;
 };
-/**
- * Interface to interact with **gRPC** based services. You can use this interface to instantiate a gRPC generated client.
- */
-export interface RestateGrpcChannel {
-    /**
-     * Unidirectional call to other Restate services ( = in background / async / not waiting on response).
-     * To do this, wrap the call via the proto-ts client with oneWayCall, as shown in the example.
-     *
-     * NOTE: this returns a Promise because we override the gRPC clients provided by proto-ts.
-     * So we are required to return a Promise.
-     *
-     * @param call Invoke another service by using the generated proto-ts client.
-     * @example
-     * const ctx = restate.useContext(this);
-     * const client = new GreeterClientImpl(ctx);
-     * await ctx.oneWayCall(() =>
-     *   client.greet(Request.create({ name: "Peter" }))
-     * )
-     */
-    oneWayCall(call: () => Promise<any>): Promise<void>;
-    /**
-     * Delayed unidirectional call to other Restate services ( = in background / async / not waiting on response).
-     * To do this, wrap the call via the proto-ts client with delayedCall, as shown in the example.
-     * Add the delay in millis as the second parameter.
-     *
-     * NOTE: this returns a Promise because we override the gRPC clients provided by proto-ts.
-     * So we are required to return a Promise.
-     *
-     * @param call Invoke another service by using the generated proto-ts client.
-     * @param delayMillis millisecond delay duration to delay the execution of the call
-     * @example
-     * const ctx = restate.useContext(this);
-     * const client = new GreeterClientImpl(ctx);
-     * await ctx.delayedCall(() =>
-     *   client.greet(Request.create({ name: "Peter" })),
-     *   5000
-     * )
-     */
-    delayedCall(call: () => Promise<any>, delayMillis?: number): Promise<void>;
-    /**
-     * Call another Restate service and await the response.
-     *
-     * This function is not recommended to be called directly. Instead, use the generated gRPC client
-     * that was generated based on the Protobuf service definitions (which internally use this method):
-     *
-     * @example
-     * ```
-     * const ctx = restate.useContext(this);
-     * const client = new GreeterClientImpl(ctx);
-     * client.greet(Request.create({ name: "Peter" }))
-     * ```
-     *
-     * @param service name of the service to call
-     * @param method name of the method to call
-     * @param data payload as Uint8Array
-     * @returns a Promise that is resolved with the response of the called service
-     */
-    request(service: string, method: string, data: Uint8Array): Promise<Uint8Array>;
-}
-/**
- * @deprecated use {@link KeyedContext}.
- */
-export type RestateContext = KeyedContext;
-/**
- * Returns the {@link Context} which is the entrypoint for all interaction with Restate.
- * Use this from within a method to retrieve the {@link Context}.
- * The context is bounded to a single invocation.
- *
- * @example
- * const ctx = restate.useContext(this);
- *
- */
-export declare function useContext<T>(instance: T): Context;
-/**
- * Returns the {@link KeyedContext} which is the entrypoint for all interaction with Restate.
- * Use this from within a method of a keyed service to retrieve the {@link KeyedContext}.
- * The context is bounded to a single invocation.
- *
- * @example
- * const ctx = restate.useKeyedContext(this);
- *
- */
-export declare function useKeyedContext<T>(instance: T): KeyedContext;
-/**
- * ServiceApi captures the type and parameters to make RPC calls and send messages to
- * a set of RPC handlers in a router.
- *
- * @example
- * **Service Side:**
- * ```ts
- * const router = restate.router({
- *   someAction:    async(ctx: restate.RpcContext, req: string) => { ... },
- *   anotherAction: async(ctx: restate.RpcContext, count: number) => { ... }
- * });
- *
- * export const myApi: restate.ServiceApi<typeof router> = { path : "myservice" };
- *
- * restate.createServer().bindRouter("myservice", router).listen(9080);
- * ```
- * **Client side:**
- * ```ts
- * ctx.rpc(myApi).someAction("hello!");
- * ```
- */
-export type ServiceApi<_M = unknown> = {
-    path: string;
-};
 //# sourceMappingURL=context.d.ts.map

package/dist/src/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../../src/context.ts"],"names":[],"mappings":"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"}

package/dist/{context.js → src/context.js}

@@ -10,7 +10,8 @@
  * https://github.com/restatedev/sdk-typescript/blob/main/LICENSE
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.useKeyedContext = exports.useContext = exports.CombineablePromise = void 0;
+exports.CombineablePromise = void 0;
+const context_impl_1 = require("./context_impl");
 exports.CombineablePromise = {
     /**
      * Creates a Promise that is resolved with an array of results when all of the provided Promises
@@ -25,7 +26,7 @@ exports.CombineablePromise = {
         if (values.length == 0) {
             return Promise.all(values);
         }
-        return values[0].__restate_context.createCombinator(Promise.all.bind(Promise), values);
+        return context_impl_1.ContextImpl.createCombinator(Promise.all.bind(Promise), values);
     },
     /**
      * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
@@ -40,7 +41,7 @@ exports.CombineablePromise = {
         if (values.length == 0) {
             return Promise.race(values);
         }
-        return values[0].__restate_context.createCombinator(Promise.race.bind(Promise), values);
+        return context_impl_1.ContextImpl.createCombinator(Promise.race.bind(Promise), values);
     },
     /**
      * Creates a promise that fulfills when any of the input's promises fulfills, with this first fulfillment value.
@@ -56,7 +57,7 @@ exports.CombineablePromise = {
         if (values.length == 0) {
             return Promise.any(values);
         }
-        return values[0].__restate_context.createCombinator(Promise.any.bind(Promise), values);
+        return context_impl_1.ContextImpl.createCombinator(Promise.any.bind(Promise), values);
     },
     /**
      * Creates a promise that fulfills when all the input's promises settle (including when an empty iterable is passed),
@@ -71,43 +72,7 @@ exports.CombineablePromise = {
         if (values.length == 0) {
             return Promise.allSettled(values);
         }
-        return values[0].__restate_context.createCombinator(Promise.allSettled.bind(Promise), values);
+        return context_impl_1.ContextImpl.createCombinator(Promise.allSettled.bind(Promise), values);
     },
 };
-/**
- * Returns the {@link Context} which is the entrypoint for all interaction with Restate.
- * Use this from within a method to retrieve the {@link Context}.
- * The context is bounded to a single invocation.
- *
- * @example
- * const ctx = restate.useContext(this);
- *
- */
-function useContext(instance) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const wrapper = instance;
-    if (wrapper.$$restate === undefined || wrapper.$$restate === null) {
-        throw new Error(`not running within a Restate call.`);
-    }
-    return wrapper.$$restate;
-}
-exports.useContext = useContext;
-/**
- * Returns the {@link KeyedContext} which is the entrypoint for all interaction with Restate.
- * Use this from within a method of a keyed service to retrieve the {@link KeyedContext}.
- * The context is bounded to a single invocation.
- *
- * @example
- * const ctx = restate.useKeyedContext(this);
- *
- */
-function useKeyedContext(instance) {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    const wrapper = instance;
-    if (wrapper.$$restate === undefined || wrapper.$$restate === null) {
-        throw new Error(`not running within a Restate call.`);
-    }
-    return wrapper.$$restate;
-}
-exports.useKeyedContext = useKeyedContext;
 //# sourceMappingURL=context.js.map

package/dist/src/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../../src/context.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAQH,iDAA6C;AA2ahC,QAAA,kBAAkB,GAAG;IAChC;;;;;;;;OAQG;IACH,GAAG,CACD,MAAS;QAET,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE;YACtB,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;SAC5B;QACD,OAAO,0BAAW,CAAC,gBAAgB,CACjC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,EACzB,MAAM,CAGN,CAAC;IACL,CAAC;IAED;;;;;;;;OAQG;IACH,IAAI,CACF,MAAS;QAET,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE;YACtB,OAAO,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;SAC7B;QACD,OAAO,0BAAW,CAAC,gBAAgB,CACjC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,EAC1B,MAAM,CACwB,CAAC;IACnC,CAAC;IAED;;;;;;;;;OASG;IACH,GAAG,CACD,MAAS;QAET,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE;YACtB,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;SAC5B;QACD,OAAO,0BAAW,CAAC,gBAAgB,CACjC,OAAO,CAAC,GAAG,CAAC,IAAI,CAAC,OAAO,CAAC,EACzB,MAAM,CACwB,CAAC;IACnC,CAAC;IAED;;;;;;;;OAQG;IACH,UAAU,CACR,MAAS;QAIT,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,EAAE;YACtB,OAAO,OAAO,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC;SACnC;QACD,OAAO,0BAAW,CAAC,gBAAgB,CACjC,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAChC,MAAM,CAGN,CAAC;IACL,CAAC;CACF,CAAC"}