@restatedev/restate-sdk 0.7.3-worker → 0.8.1

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

@@ -1,33 +1,11 @@
 /// <reference types="node" />
-import "./utils/logger";
+/// <reference types="node" />
 import { RetrySettings } from "./utils/public_utils";
 import { Client, SendClient } from "./types/router";
 /**
- * Base Restate context, which contains all operations that are the same in the gRPC-based API
- * as in the dynamic rpc-handler-based API.
- *
- * Those operations include state access/updates, side-effects, awakeables, or sleeps.
+ * Key value store operations. Only keyed services have an attached key-value store.
  */
-export interface RestateBaseContext {
-    /**
-     * 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
-     * these calls are not.
-     */
-    rand: Rand;
+export interface KeyValueStore {
     /**
      * Get/retrieve state from the Restate runtime.
      * Note that state objects are serialized with `Buffer.from(JSON.stringify(theObject))`
@@ -41,6 +19,7 @@ export interface RestateBaseContext {
      * const state = await ctx.get<string>("STATE");
      */
     get<T>(name: string): Promise<T | null>;
+    stateKeys(): Promise<Array<string>>;
     /**
      * Set/store state in the Restate runtime.
      * Note that state objects are serialized with `Buffer.from(JSON.stringify(theObject))`
@@ -51,7 +30,7 @@ export interface RestateBaseContext {
      *
      * @example
      * const ctx = restate.useContext(this);
-     * const state = ctx.set("STATE", "Hello");
+     * ctx.set("STATE", "Hello");
      */
     set<T>(name: string, value: T): void;
     /**
@@ -60,9 +39,55 @@ export interface RestateBaseContext {
      *
      * @example
      * const ctx = restate.useContext(this);
-     * const state = ctx.clear("STATE");
+     * ctx.clear("STATE");
      */
     clear(name: string): void;
+    /**
+     * Clear/delete all the state entries in the Restate runtime.
+     *
+     * @example
+     * const ctx = restate.useContext(this);
+     * ctx.clearAll();
+     */
+    clearAll(): void;
+}
+/**
+ * The context that gives access to all Restate-backed operations, for example
+ *   - sending reliable messages / RPC through Restate
+ *   - side effects
+ *   - sleeps and delayed calls
+ *   - awakeables
+ *   - ...
+ *
+ * Keyed services can also access their key-value store using the {@link KeyedContext}.
+ *
+ * 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
+     * these calls are not.
+     */
+    rand: Rand;
+    /**
+     * Console to use for logging. It attaches to each log message some contextual information,
+     * such as invoked service method and invocation id, and automatically excludes logs during replay.
+     */
+    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.
@@ -127,7 +152,7 @@ export interface RestateBaseContext {
      */
     awakeable<T>(): {
         id: string;
-        promise: Promise<T>;
+        promise: CombineablePromise<T>;
     };
     /**
      * Resolve an awakeable of another service.
@@ -142,7 +167,7 @@ export interface RestateBaseContext {
      * // The sleeping service should have sent the awakeableIdentifier string to this service.
      * ctx.resolveAwakeable(awakeableIdentifier, "hello");
      */
-    resolveAwakeable<T>(id: string, payload: T): void;
+    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.
      * @param id the string ID of the awakeable.
@@ -164,140 +189,7 @@ export interface RestateBaseContext {
      * const ctx = restate.useContext(this);
      * await ctx.sleep(1000);
      */
-    sleep(millis: number): Promise<void>;
-}
-export interface Rand {
-    /**
-     * Equivalent of JS `Math.random()` but deterministic; seeded by the invocation ID of the current invocation,
-     * each call will return a new pseudorandom float within the range [0,1)
-     */
-    random(): number;
-    /**
-     * Using the same random source and seed as random(), produce a UUID version 4 string. This is inherently predictable
-     * based on the invocation ID and should not be used in cryptographic contexts
-     */
-    uuidv4(): string;
-}
-/**
- * Interface to interact with **gRPC** based services.
- */
-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>;
-}
-/**
- * The context that gives access to all Restate-backed operations, for example
- *   - sending reliable messages / rpc through Restate
- *   - access/update state (for keyed services)
- *   - side effects
- *   - sleeps and delayed calls
- *   - awakeables
- *   - ...
- *
- * This context is for use in **gRPC service** implementations.
- * For the rpc-handler API, use the {@link RpcContext} instead.
- */
-export interface RestateGrpcContext extends RestateBaseContext, RestateGrpcChannel {
-    /**
-     * Get the {@link RpcGateway} to invoke Handler-API based services.
-     */
-    rpcGateway(): RpcGateway;
-}
-/**
- * For compatibility, we make the support 'RestateContext' as the type for the Grpc-based API context.
- */
-export type RestateContext = RestateGrpcContext;
-/**
- * Returns the RestateContext which is the entrypoint for all interaction with Restate.
- * Use this from within a method to retrieve the RestateContext.
- * The context is bounded to a single invocation.
- *
- * @example
- * const ctx = restate.useContext(this);
- *
- */
-export declare function useContext<T>(instance: T): RestateGrpcContext;
-export declare function setContext<T>(instance: T, context: RestateGrpcContext): T;
-/**
- * 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;
-};
-/**
- * Interface to interact with **rpc-handler API** based services.
- */
-export interface RpcGateway {
+    sleep(millis: number): CombineablePromise<void>;
     /**
      * Makes a type-safe request/response RPC to the specified target service.
      *
@@ -423,23 +315,200 @@ export interface RpcGateway {
      * ```
      */
     sendDelayed<M>(opts: ServiceApi<M>, delay: number): SendClient<M>;
+    /**
+     * Get the {@link RestateGrpcChannel} to invoke gRPC based services.
+     */
+    grpcChannel(): RestateGrpcChannel;
 }
 /**
  * The context that gives access to all Restate-backed operations, for example
  *   - sending reliable messages / RPC through Restate
- *   - access/update state (for keyed services)
+ *   - access/update state
  *   - side effects
  *   - sleeps and delayed calls
  *   - awakeables
  *   - ...
  *
- * This context is for use with the **rpc-handler API**.
- * For gRPC-based API, use the {@link RestateContext} instead.
+ * This context can be used only within keyed services/routers.
+ *
+ * In gRPC-based API, to access this context, use {@link useKeyedContext}.
  */
-export interface RpcContext extends RestateBaseContext, RpcGateway {
+export interface KeyedContext extends Context, KeyValueStore {
+}
+export interface Rand {
     /**
-     * Get the {@link RestateGrpcChannel} to invoke gRPC based services.
+     * Equivalent of JS `Math.random()` but deterministic; seeded by the invocation ID of the current invocation,
+     * each call will return a new pseudorandom float within the range [0,1)
      */
-    grpcChannel(): RestateGrpcChannel;
+    random(): number;
+    /**
+     * Using the same random source and seed as random(), produce a UUID version 4 string. This is inherently predictable
+     * based on the invocation ID and should not be used in cryptographic contexts
+     */
+    uuidv4(): string;
 }
-//# sourceMappingURL=restate_context.d.ts.map
+/**
+ * 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}.
+     *
+     * @param millis duration of the sleep in millis.
+     * This is a lower-bound.
+     */
+    orTimeout(millis: number): Promise<T>;
+};
+export declare const CombineablePromise: {
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     *
+     * See {@link Promise.all} for more details.
+     *
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    all<T extends [] | readonly CombineablePromise<unknown>[]>(values: T): Promise<{ -readonly [P in keyof T]: Awaited<T[P]>; }>;
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     *
+     * See {@link Promise.race} for more details.
+     *
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    race<T_1 extends [] | readonly CombineablePromise<unknown>[]>(values: T_1): Promise<Awaited<T_1[number]>>;
+    /**
+     * Creates a promise that fulfills when any of the input's promises fulfills, with this first fulfillment value.
+     * It rejects when all the input's promises reject (including when an empty iterable is passed),
+     * with an AggregateError containing an array of rejection reasons.
+     *
+     * See {@link Promise.any} for more details.
+     *
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    any<T_2 extends [] | readonly CombineablePromise<unknown>[]>(values: T_2): Promise<Awaited<T_2[number]>>;
+    /**
+     * Creates a promise that fulfills when all the input's promises settle (including when an empty iterable is passed),
+     * with an array of objects that describe the outcome of each promise.
+     *
+     * See {@link Promise.allSettled} for more details.
+     *
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    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/context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.d.ts","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":";;AAWA,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,gBAAgB,CAAC;AAGpD;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAExC,SAAS,IAAI,OAAO,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,CAAC;IAEpC;;;;;;;;;;;OAWG;IACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI,CAAC;IAErC;;;;;;;OAOG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAE1B;;;;;;OAMG;IACH,QAAQ,IAAI,IAAI,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,OAAO;IACtB;;;OAGG;IACH,EAAE,EAAE,MAAM,CAAC;IAEX;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IAEpB;;;;;;;;OAQG;IACH,IAAI,EAAE,IAAI,CAAC;IAEX;;;OAGG;IACH,OAAO,EAAE,OAAO,CAAC;IAEjB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAwCG;IACH,UAAU,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,EAAE,WAAW,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;IAE7E;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAAS,CAAC,CAAC,KAAK;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,OAAO,EAAE,kBAAkB,CAAC,CAAC,CAAC,CAAA;KAAE,CAAC;IAE/D;;;;;;;;;;;;OAYG;IACH,gBAAgB,CAAC,CAAC,EAAE,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,IAAI,CAAC;IAEnD;;;;;;;;;;OAUG;IACH,eAAe,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAElD;;;;;;;;OAQG;IACH,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,kBAAkB,CAAC,IAAI,CAAC,CAAC;IAEhD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IAEvC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAsCG;IACH,IAAI,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA4CG;IACH,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,CAAC;IAElE;;OAEG;IACH,WAAW,IAAI,kBAAkB,CAAC;CACnC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,YAAa,SAAQ,OAAO,EAAE,aAAa;CAAG;AAE/D,MAAM,WAAW,IAAI;IACnB;;;OAGG;IACH,MAAM,IAAI,MAAM,CAAC;IAEjB;;;OAGG;IACH,MAAM,IAAI,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,MAAM,kBAAkB,CAAC,CAAC,IAAI,OAAO,CAAC,CAAC,CAAC,GAAG;IAC/C,iBAAiB,EAAE,OAAO,CAAC;IAE3B;;;;;;OAMG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;CACvC,CAAC;AAEF,eAAO,MAAM,kBAAkB;IAC7B;;;;;;;;OAQG;;IAgBH;;;;;;;;OAQG;;IAcH;;;;;;;;;OASG;;IAcH;;;;;;;;OAQG;;CAiBJ,CAAC;AAMF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;;;;;;OAcG;IAEH,UAAU,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpD;;;;;;;;;;;;;;;;;OAiBG;IAEH,WAAW,CAAC,IAAI,EAAE,MAAM,OAAO,CAAC,GAAG,CAAC,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAE3E;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CACL,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,MAAM,EACd,IAAI,EAAE,UAAU,GACf,OAAO,CAAC,UAAU,CAAC,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,MAAM,cAAc,GAAG,YAAY,CAAC;AAE1C;;;;;;;;GAQG;AACH,wBAAgB,UAAU,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,OAAO,CAOlD;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAAE,QAAQ,EAAE,CAAC,GAAG,YAAY,CAO5D;AAQD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,MAAM,UAAU,CAAC,EAAE,GAAG,OAAO,IAAI;IACrC,IAAI,EAAE,MAAM,CAAC;CACd,CAAC"}

package/dist/context.js

@@ -0,0 +1,113 @@
+"use strict";
+/*
+ * 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
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useKeyedContext = exports.useContext = exports.CombineablePromise = void 0;
+exports.CombineablePromise = {
+    /**
+     * Creates a Promise that is resolved with an array of results when all of the provided Promises
+     * resolve, or rejected when any Promise is rejected.
+     *
+     * See {@link Promise.all} for more details.
+     *
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    all(values) {
+        if (values.length == 0) {
+            return Promise.all(values);
+        }
+        return values[0].__restate_context.createCombinator(Promise.all.bind(Promise), values);
+    },
+    /**
+     * Creates a Promise that is resolved or rejected when any of the provided Promises are resolved
+     * or rejected.
+     *
+     * See {@link Promise.race} for more details.
+     *
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    race(values) {
+        if (values.length == 0) {
+            return Promise.race(values);
+        }
+        return values[0].__restate_context.createCombinator(Promise.race.bind(Promise), values);
+    },
+    /**
+     * Creates a promise that fulfills when any of the input's promises fulfills, with this first fulfillment value.
+     * It rejects when all the input's promises reject (including when an empty iterable is passed),
+     * with an AggregateError containing an array of rejection reasons.
+     *
+     * See {@link Promise.any} for more details.
+     *
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    any(values) {
+        if (values.length == 0) {
+            return Promise.any(values);
+        }
+        return values[0].__restate_context.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),
+     * with an array of objects that describe the outcome of each promise.
+     *
+     * See {@link Promise.allSettled} for more details.
+     *
+     * @param values An iterable of Promises.
+     * @returns A new Promise.
+     */
+    allSettled(values) {
+        if (values.length == 0) {
+            return Promise.allSettled(values);
+        }
+        return values[0].__restate_context.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/context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"context.js","sourceRoot":"","sources":["../src/context.ts"],"names":[],"mappings":";AAAA;;;;;;;;;GASG;;;AAgYU,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;QAED,OAAQ,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiC,CAAC,gBAAgB,CAClE,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;QAED,OAAQ,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiC,CAAC,gBAAgB,CAClE,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;QAED,OAAQ,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiC,CAAC,gBAAgB,CAClE,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;QAED,OAAQ,MAAM,CAAC,CAAC,CAAC,CAAC,iBAAiC,CAAC,gBAAgB,CAClE,OAAO,CAAC,UAAU,CAAC,IAAI,CAAC,OAAO,CAAC,EAChC,MAAM,CAGN,CAAC;IACL,CAAC;CACF,CAAC;AA+EF;;;;;;;;GAQG;AACH,SAAgB,UAAU,CAAI,QAAW;IACvC,8DAA8D;IAC9D,MAAM,OAAO,GAAG,QAAe,CAAC;IAChC,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,CAAC,SAAS,KAAK,IAAI,EAAE;QACjE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;KACvD;IACD,OAAO,OAAO,CAAC,SAAS,CAAC;AAC3B,CAAC;AAPD,gCAOC;AAED;;;;;;;;GAQG;AACH,SAAgB,eAAe,CAAI,QAAW;IAC5C,8DAA8D;IAC9D,MAAM,OAAO,GAAG,QAAe,CAAC;IAChC,IAAI,OAAO,CAAC,SAAS,KAAK,SAAS,IAAI,OAAO,CAAC,SAAS,KAAK,IAAI,EAAE;QACjE,MAAM,IAAI,KAAK,CAAC,oCAAoC,CAAC,CAAC;KACvD;IACD,OAAO,OAAO,CAAC,SAAS,CAAC;AAC3B,CAAC;AAPD,0CAOC"}