@autometa/http 2.0.0-rc.1 → 2.0.0-rc.2

package/dist/http.d.ts

@@ -181,6 +181,14 @@ export declare class HTTP {
         from: StatusCode;
         to: StatusCode;
     }[]): HTTP;
+    /**
+     * Transforms the resolved response into another shape.
+     *
+     * The response has already been parsed and schema-validated before the
+     * transformer runs. This is a convenient way to project a response into
+     * a domain model while keeping type inference on the return value.
+     */
+    transform<TResponse, TResult>(transformer: (response: HTTPResponse<TResponse>) => TResult | Promise<TResult>): HTTPTransformClient<TResponse, TResult>;
     /**
      * Sets a shared query parameter for all future requests.
      */
@@ -298,3 +306,20 @@ export declare class HTTP {
     private delayRetry;
     private derive;
 }
+declare class HTTPTransformClient<TResponse, TResult> {
+    private base;
+    private transform;
+    constructor(base: HTTP, transform: (response: HTTPResponse<TResponse>) => TResult | Promise<TResult>);
+    fetchWith(method: HTTPMethod | Lowercase<HTTPMethod>, options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    get(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    post(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    put(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    patch(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    delete(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    head(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    options(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    trace(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    connect(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+    stream(options?: HTTPAdditionalOptions<unknown>): Promise<TResult>;
+}
+export {};

package/dist/index.cjs

@@ -1126,6 +1126,16 @@ var _HTTP = class _HTTP {
       meta.schema(parser, ...args);
     });
   }
+  /**
+   * Transforms the resolved response into another shape.
+   *
+   * The response has already been parsed and schema-validated before the
+   * transformer runs. This is a convenient way to project a response into
+   * a domain model while keeping type inference on the return value.
+   */
+  transform(transformer) {
+    return new HTTPTransformClient(this, transformer);
+  }
   sharedParam(name, value, ...rest) {
     this.builder.param(name, toParamValue(value, rest));
     return this;
@@ -1519,6 +1529,56 @@ var _HTTP = class _HTTP {
 };
 _HTTP.sharedPlugins = [];
 var HTTP = _HTTP;
+var HTTPTransformClient = class {
+  constructor(base, transform) {
+    this.base = base;
+    this.transform = transform;
+  }
+  async fetchWith(method, options) {
+    const response = await this.base.fetchWith(method, options);
+    return this.transform(response);
+  }
+  async get(options) {
+    const response = await this.base.get(options);
+    return this.transform(response);
+  }
+  async post(options) {
+    const response = await this.base.post(options);
+    return this.transform(response);
+  }
+  async put(options) {
+    const response = await this.base.put(options);
+    return this.transform(response);
+  }
+  async patch(options) {
+    const response = await this.base.patch(options);
+    return this.transform(response);
+  }
+  async delete(options) {
+    const response = await this.base.delete(options);
+    return this.transform(response);
+  }
+  async head(options) {
+    const response = await this.base.head(options);
+    return this.transform(response);
+  }
+  async options(options) {
+    const response = await this.base.options(options);
+    return this.transform(response);
+  }
+  async trace(options) {
+    const response = await this.base.trace(options);
+    return this.transform(response);
+  }
+  async connect(options) {
+    const response = await this.base.connect(options);
+    return this.transform(response);
+  }
+  async stream(options) {
+    const response = await this.base.stream(options);
+    return this.transform(response);
+  }
+};
 function mergeOptions2(base, overrides) {
   if (!overrides) {
     return { ...base };