p3: remove body resource

Signed-off-by: Roman Volosatovs <[email protected]>

Author: rvolosatovs

wit-0.3.0-draft/types.wit

@@ -230,79 +230,35 @@ interface types {
   /// Trailers is an alias for Fields.
   type trailers = fields;
 
-  /// Represents an HTTP Request or Response's Body.
-  ///
-  /// A body has both its contents - a stream of bytes - and a (possibly empty)
-  /// set of trailers, indicating that the full contents of the body have been
-  /// received. This resource represents the contents as a `stream<u8>` and the
-  /// delivery of trailers as a `trailers`, and ensures that the user of this
-  /// interface may only be consuming either the body contents or waiting on
-  /// trailers at any given time.
-  resource body {
-
-    /// Construct a new `body` with the specified stream and `finish` future.
-    ///
-    /// The `finish` future must resolve to a result once `stream` has finished.
-    ///
-    /// This function returns a future, which will resolve to an error code if
-    /// transmitting of the request or response this body is a part of fails.
-    ///
-    /// The returned future resolves to success once request or response this
-    /// body is a part of is fully transmitted.
-    new: static func(
-      %stream: stream<u8>,
-      finish: future<result<option<trailers>, error-code>>,
-    ) -> tuple<body, future<result<_, error-code>>>;
-
-    /// Returns the contents of the body, as a stream of bytes.
-    ///
-    /// This method returns a stream and a future, which will resolve
-    /// to an error code if receiving data from stream fails.
-    /// The returned future resolves to success if data section of the
-    /// body is fully consumed.
-    ///
-    /// The handles returned by this method are considered to be child
-    /// handles. Dropping the resource on which this method is called
-    /// will close the handles with an error context, if they are still open.
-    ///
-    /// This method may be called multiple times.
-    /// This method will return an error if it is called while either:
-    /// - a stream or future returned by a previous call to this method is still open
-    /// - `finish` was called on another instance of this `body` resource
-    /// Thus there will always be at most one readable stream open for a given body.
-    /// Each subsequent stream picks up where the last stream left off,
-    /// up until `finish` is called on any of the instances of this `body` resource
-    %stream: func() -> result<tuple<stream<u8>, future<result<_, error-code>>>>;
-
-    /// Takes ownership of `body`, and returns an unresolved optional `trailers` result.
-    ///
-    /// This function will return an error if it is called while either:
-    /// - a stream or future returned by a previous call to `body.stream` is still open
-    /// - `finish` was already called on another instance of this `body` resource
-    finish: static func(this: body) -> result<future<result<option<trailers>, error-code>>>;
-  }
-
   /// Represents an HTTP Request.
   resource request {
 
     /// Construct a new `request` with a default `method` of `GET`, and
     /// `none` values for `path-with-query`, `scheme`, and `authority`.
     ///
-    /// * `headers` is the HTTP Headers for the Response.
-    /// * `body` is the contents of the body, possibly including trailers.
-    /// * `options` is optional `request-options` to be used if the request is
-    ///   sent over a network connection.
+    /// `headers` is the HTTP Headers for the Request.
+    ///
+    /// `contents` is the body content stream. Once it is closed,
+    /// `trailers` future must resolve to a result.
+    /// If `trailers` resolves to an error, underlying connection
+    /// will be closed immediately.
+    ///
+    /// `options` is optional `request-options` resource to be used
+    /// if the request is sent over a network connection.
     ///
     /// It is possible to construct, or manipulate with the accessor functions
-    /// below, an `request` with an invalid combination of `scheme`
+    /// below, a `request` with an invalid combination of `scheme`
     /// and `authority`, or `headers` which are not permitted to be sent.
     /// It is the obligation of the `handler.handle` implementation
     /// to reject invalid constructions of `request`.
-    constructor(
+    ///
+    /// The returned future resolves to result of transmission of this request.
+    new: static func(
       headers: headers,
-      body: body,
+      contents: stream<u8>,
+      trailers: future<result<option<trailers>, error-code>>,
       options: option<request-options>
-    );
+    ) -> tuple<request, future<result<_, error-code>>>;
 
     /// Get the Method for the Request.
     method: func() -> method;
@@ -352,15 +308,26 @@ interface types {
     /// `delete` operations will fail with `header-error.immutable`.
     headers: func() -> headers;
 
-    /// Get the body associated with the Request, if any.
+    /// Get body of the Request.
     ///
-    /// This body resource is a child: it must be dropped or consumed before
-    /// the parent `request` is dropped, or its ownership is transferred
-    /// to another component by e.g. `handler.handle`.
+    /// Stream returned by this method represents the contents of the body.
+    /// Once the stream is reported as closed, callers should await the returned future
+    /// to determine whether the body was received successfully.
+    /// The future will only resolve after the stream is reported as closed.
     ///
-    /// Once `body.finish` is called on a body returned by this method,
-    /// all subsequent calls to this method will return `none`.
-    body: func() -> option<body>;
+    /// The stream and future returned by this method are children:
+    /// they should be closed or consumed before the parent `response`
+    /// is dropped, or its ownership is transferred to another component
+    /// by e.g. `handler.handle`.
+    ///
+    /// This method may be called multiple times.
+    ///
+    /// This method will return `none` if it is called while either:
+    /// - a stream or future returned by a previous call to this method is still open
+    /// - a stream returned by a previous call to this method has reported itself as closed
+    /// Thus there will always be at most one readable stream open for a given body.
+    /// Each subsequent stream picks up where the last stream left off, up until it is finished.
+    body: func() -> option<tuple<stream<u8>, future<result<option<trailers>, error-code>>>>;
   }
 
   /// Parameters for making an HTTP Request. Each of these parameters is
@@ -409,16 +376,23 @@ interface types {
   /// Represents an HTTP Response.
   resource response {
 
-    /// Construct an `response`, with a default `status-code` of `200`.  If a
-    /// different `status-code` is needed, it must be set via the
+    /// Construct a new `response`, with a default `status-code` of `200`.
+    /// If a different `status-code` is needed, it must be set via the
     /// `set-status-code` method.
     ///
-    /// * `headers` is the HTTP Headers for the Response.
-    /// * `body` is the contents of the body, possibly including trailers.
-    constructor(
+    /// `headers` is the HTTP Headers for the Response.
+    ///
+    /// `contents` is the body content stream. Once it is closed,
+    /// `trailers` future must resolve to a result.
+    /// If `trailers` resolves to an error, underlying connection
+    /// will be closed immediately.
+    ///
+    /// The returned future resolves to result of transmission of this response.
+    new: static func(
       headers: headers,
-      body: body,
-    );
+      contents: stream<u8>,
+      trailers: future<result<option<trailers>, error-code>>,
+    ) -> tuple<response, future<result<_, error-code>>>;
 
     /// Get the HTTP Status Code for the Response.
     status-code: func() -> status-code;
@@ -427,20 +401,31 @@ interface types {
     /// given is not a valid http status code.
     set-status-code: func(status-code: status-code) -> result;
 
-    /// Get the headers associated with the Request.
+    /// Get the headers associated with the Response.
     ///
     /// The returned `headers` resource is immutable: `set`, `append`, and
     /// `delete` operations will fail with `header-error.immutable`.
     headers: func() -> headers;
 
-    /// Get the body associated with the Response, if any.
+    /// Get body of the Response.
+    ///
+    /// Stream returned by this method represents the contents of the body.
+    /// Once the stream is reported as closed, callers should await the returned future
+    /// to determine whether the body was received successfully.
+    /// The future will only resolve after the stream is reported as closed.
     ///
-    /// This body resource is a child: it should be dropped or consumed before
-    /// the parent `response` is dropped, or its ownership is transferred
-    /// to another component by e.g. `handler.handle`.
+    /// The stream and future returned by this method are children:
+    /// they should be closed or consumed before the parent `response`
+    /// is dropped, or its ownership is transferred to another component
+    /// by e.g. `handler.handle`.
     ///
-    /// Once `body.finish` is called on a body returned by this method,
-    /// all subsequent calls to this method will return `none`.
-    body: func() -> option<body>;
+    /// This method may be called multiple times.
+    ///
+    /// This method will return `none` if it is called while either:
+    /// - a stream or future returned by a previous call to this method is still open
+    /// - a stream returned by a previous call to this method has reported itself as closed
+    /// Thus there will always be at most one readable stream open for a given body.
+    /// Each subsequent stream picks up where the last stream left off, up until it is finished.
+    body: func() -> option<tuple<stream<u8>, future<result<option<trailers>, error-code>>>>;
   }
 }