Fix broken links

Author: gvdongen

src/context/mod.rs

@@ -216,7 +216,7 @@ impl<'ctx> WorkflowContext<'ctx> {
 ///
 /// ## Scheduling Async Tasks
 ///
-/// To schedule a handler to be called at a later time, have a look at the documentation on [delayed calls][service_communication#delayed-calls].
+/// To schedule a handler to be called at a later time, have a look at the documentation on [delayed calls][crate::context::ContextClient#delayed-calls].
 ///
 ///
 /// ## Durable sleep
@@ -577,7 +577,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextClient<'ctx> for CTX {}
 /// ## Completing awakeables
 ///
 /// The external process completes the awakeable by either resolving it with an optional payload or by rejecting it
-/// with its ID and a reason for the failure. This throws [a terminal error][error_handling] in the waiting handler.
+/// with its ID and a reason for the failure. This throws [a terminal error][crate::errors] in the waiting handler.
 ///
 /// - Resolving over HTTP with its ID and an optional payload:
 ///
@@ -609,7 +609,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextClient<'ctx> for CTX {}
 /// # }
 /// ```
 ///
-/// **Note**: You can return any payload that implements the `serde::Serialize` and `serde::Deserialize` traits ([see serialization docs][serialization]).
+/// **Note**: You can return any payload that implements the `serde::Serialize` and `serde::Deserialize` traits ([see serialization docs][crate::serde]).
 ///
 /// **Note**: When running on Function-as-a-Service platforms, such as AWS Lambda, Restate suspends the handler while waiting for the awakeable to be completed.
 /// Since you only pay for the time that the handler is actually running, you don't pay while waiting for the external process to return.
@@ -644,8 +644,8 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextAwakeables<'ctx> for CTX {}
 /// Restate uses an execution log for replay after failures and suspensions.
 /// This means that non-deterministic results (e.g. database responses, UUID generation) need to be stored in the execution log.
 /// The SDK offers some functionalities to help you with this:
-/// 1. **[Journaled actions][journaling_results#journaled-actions]**: Run any block of code and store the result in Restate. Restate replays the result instead of re-executing the block on retries.
-/// 3. **[Random generators][journaling_results#generating-randoms]**: Built-in helpers for generating stable UUIDs and random numbers.
+/// 1. **[Journaled actions][crate::context::ContextSideEffects#journaled-actions]**: Run any block of code and store the result in Restate. Restate replays the result instead of re-executing the block on retries.
+/// 3. **[Random generators][crate::context::ContextSideEffects#generating-randoms]**: Built-in helpers for generating stable UUIDs and random numbers.
 ///
 /// ## Journaled actions
 /// You can store the result of a (non-deterministic) operation in the Restate execution log (e.g. database requests, HTTP calls, etc).
@@ -666,7 +666,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextAwakeables<'ctx> for CTX {}
 /// You cannot use the Restate context within `ctx.run`.
 /// This includes actions such as getting state, calling another service, and nesting other journaled actions.
 ///
-/// You can store any result value that implements the `Serialize` and `Deserialize` trait ([see serialization docs][serialization]).
+/// You can store any result value that implements the `Serialize` and `Deserialize` trait ([see serialization docs][crate::serde]).
 ///
 /// **Caution: Immediately await journaled actions:**
 /// Always immediately await `ctx.run`, before doing any other context calls.
@@ -755,7 +755,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx>> ContextSideEffects<'ctx> for CTX {
 /// Have a look at the [introspection docs](https://docs.restate.dev//operate/introspection#inspecting-application-state) for more information.
 ///
 /// **Info: Serializing state**:
-/// You can store any type of value that that implements the `serde::Serialize` and `serde::Deserialize` traits ([see serialization docs][serialization]).
+/// You can store any type of value that that implements the `serde::Serialize` and `serde::Deserialize` traits ([see serialization docs][crate::serde]).
 ///
 /// ```
 /// # use restate_sdk::prelude::*;
@@ -818,7 +818,7 @@ impl<'ctx, CTX: private::SealedContext<'ctx> + private::SealedCanReadState> Cont
 /// Have a look at the [introspection docs](https://docs.restate.dev//operate/introspection#inspecting-application-state) for more information.
 ///
 /// **Info: Serializing state**:
-/// You can store any type of value that that implements the `serde::Serialize` and `serde::Deserialize` traits ([see serialization docs][serialization]).
+/// You can store any type of value that that implements the `serde::Serialize` and `serde::Deserialize` traits ([see serialization docs][crate::serde]).
 ///
 /// ```
 /// # use restate_sdk::prelude::*;

src/errors.rs

@@ -15,7 +15,7 @@
 //! # }
 //! ```
 //!
-//! You can catch terminal exceptions. For example, you can catch the terminal exception that comes out of a [call to another service][service_communication#request-response-calls], and build your control flow around it.
+//! You can catch terminal exceptions. For example, you can catch the terminal exception that comes out of a [call to another service][crate::context::ContextClient], and build your control flow around it.
 use restate_sdk_shared_core::Failure;
 use std::error::Error as StdError;
 use std::fmt;

src/lib.rs

@@ -40,14 +40,17 @@
 //! - [Workflow](workflow)
 //!
 //! ## Features
-//! - [Service Communication][crate::context::ContextClient]
-//! - [Journaling Results][crate::context::ContextSideEffects]
-//! - State: [read][crate::context::ContextReadState] and [write](crate::context::ContextWriteState)
-//! - [Scheduling & Timers][crate::context::ContextTimers]
-//! - [Awakeables][crate::context::ContextAwakeables]
-//! - [Error Handling][crate::errors]
-//! - [Serialization][crate::serde]
-//! - [Serving][crate::http_server]
+//!
+//! Have a look at the following SDK capabilities:
+//!
+//! - [Service Communication][crate::context::ContextClient]: Durable RPC and messaging between services (optionally with a delay).
+//! - [Journaling Results][crate::context::ContextSideEffects]: Persist results in Restate's log to avoid re-execution on retries
+//! - State: [read][crate::context::ContextReadState] and [write](crate::context::ContextWriteState): Store and retrieve state in Restate's key-value store
+//! - [Scheduling & Timers][crate::context::ContextTimers]: Let a handler pause for a certain amount of time. Restate durably tracks the timer across failures.
+//! - [Awakeables][crate::context::ContextAwakeables]: Durable Futures to wait for events and the completion of external tasks.
+//! - [Error Handling][crate::errors]: Restate retries failures infinitely. Use `TerminalError` to stop retries.
+//! - [Serialization][crate::serde]: The SDK serializes results to send them to the Server.
+//! - [Serving][crate::http_server]: Start an HTTP server to expose services.
 //!
 //!
 //! # Logging
@@ -204,11 +207,11 @@ pub use restate_sdk_macros::object;
 /// - Each workflow definition has a `run` handler that implements the workflow logic.
 /// - The `run` handler executes exactly one time for each workflow instance (object / key).
 /// - A workflow definition can implement other handlers that can be called multiple times, and can interact with the workflow.
-/// - Workflows have access to the `WorkflowContext` and `SharedWorkflowContext`, giving them some extra functionality, for example [Durable Promises][workflows#signaling-workflows] to signal workflows.
+/// - Workflows have access to the `WorkflowContext` and `SharedWorkflowContext`, giving them some extra functionality, for example Durable Promises to signal workflows.
 ///
 /// **Note: Workflow retention time**:
 /// The retention time of a workflow execution is 24 hours after the finishing of the `run` handler.
-/// After this timeout any [K/V state][state] is cleared, the workflow's shared handlers cannot be called anymore, and the [Durable Promises][workflows#signaling-workflows] are discarded.
+/// After this timeout any [K/V state][crate::context::ContextReadState] is cleared, the workflow's shared handlers cannot be called anymore, and the Durable Promises are discarded.
 /// The retention time can be configured via the [Admin API](https://docs.restate.dev//references/admin-api/#tag/service/operation/modify_service) per Workflow definition by setting `workflow_completion_retention`.
 ///
 /// ## Implementing workflows
@@ -265,7 +268,7 @@ pub use restate_sdk_macros::object;
 ///
 /// Every workflow needs a `run` handler.
 /// This handler has access to the same SDK features as Service and Virtual Object handlers.
-/// In the example above, we use [`ctx.run`][journaling_results] to log the sending of the email in Restate and avoid re-execution on replay.
+/// In the example above, we use [`ctx.run`][crate::context::ContextSideEffects] to log the sending of the email in Restate and avoid re-execution on replay.
 ///
 ///
 /// ## Shared handlers
@@ -274,7 +277,7 @@ pub use restate_sdk_macros::object;
 ///
 /// ### Querying workflows
 ///
-/// Similar to Virtual Objects, you can retrieve the [K/V state][state] of workflows via the other handlers defined in the workflow definition,
+/// Similar to Virtual Objects, you can retrieve the [K/V state][crate::context::ContextReadState] of workflows via the other handlers defined in the workflow definition,
 /// In the example we expose the status of the workflow to external clients.
 /// Every workflow execution can be seen as a new object, so the state is isolated to a single workflow execution.
 /// The state can only be mutated by the `run` handler of the workflow. The other handlers can only read the state.
@@ -294,18 +297,18 @@ pub use restate_sdk_macros::object;
 ///
 /// ### Serving and registering workflows
 ///
-/// You serve workflows in the same way as Services and Virtual Objects. Have a look at the [Serving docs][serving].
+/// You serve workflows in the same way as Services and Virtual Objects. Have a look at the [Serving docs][crate::http_server].
 /// Make sure you [register the endpoint or Lambda handler](https://docs.restate.dev/operate/registration) in Restate before invoking it.
 ///
 /// **Tip: Workflows-as-code with Restate**:
 /// [Check out some examples of workflows-as-code with Restate on the use case page](https://docs.restate.dev/use-cases/workflows).
 ///
 ///
 /// ## Submitting workflows from a Restate service
-/// [**Submit/query/signal**][service_communication]:
+/// [**Submit/query/signal**][crate::context::ContextClient]:
 /// Call the workflow handlers in the same way as for Services and Virtual Objects.
 /// You can only call the `run` handler (submit) once per workflow ID (here `"someone"`).
-/// Check out the [Service Communication docs][service_communication] for more information.
+/// Check out the [Service Communication docs][crate::context::ContextClient] for more information.
 ///
 /// ## Submitting workflows over HTTP
 /// [**Submit/query/signal**](https://docs.restate.dev/invoke/http#request-response-calls-over-http):