Custom Code With SDK Hooks

package hooks

func initHooks(h *Hooks) {
    myHook := &ExampleHook{}
    h.registerBeforeRequestHook(myHook)
}

from .types import Hooks

def init_hooks(hooks: Hooks):
    my_hook = ExampleHook()
    hooks.register_before_request_hook(my_hook)

import { Hooks } from "./types";

export function initHooks(hooks: Hooks) {
    const myHook = new ExampleHook();
    hooks.registerBeforeRequestHook(myHook);
}

package com.package.hooks;

public final class SDKHooks {

    public static final void initialize(com.package.utils.Hooks hooks) {
        ExampleHook exampleHook = new ExampleHook();
        hooks.registerBeforeRequestHook(exampleHook);
    }

}

namespace <namespace>
{
    public static class HookRegistration
    {
        public static void InitHooks(IHooks hooks)
        {
            var exampleHook = new ExampleHook();
            hooks.RegisterBeforeRequestHook(exampleHook);
        }
    }
}

package hooks

import (
	"net/http"
)

type ExampleHook struct{}

var (
	_ sdkInitHook       = (*ExampleHook)(nil)
	_ beforeRequestHook = (*ExampleHook)(nil)
	_ afterSuccessHook  = (*ExampleHook)(nil)
	_ afterErrorHook    = (*ExampleHook)(nil)
)

func (i *ExampleHook) SDKInit(baseURL string, client HTTPClient) (string, HTTPClient) {
	// modify the baseURL or wrap the client used by the SDK here and return the updated values
	return baseURL, client
}

func (i *ExampleHook) BeforeRequest(hookCtx BeforeRequestContext, req *http.Request) (*http.Request, error) {
	// modify the request object before it is sent, such as adding headers or query parameters, or return an error to stop the request from being sent
	return req, nil
}

func (i *ExampleHook) AfterSuccess(hookCtx AfterSuccessContext, res *http.Response) (*http.Response, error) {
	// modify the response object before deserialization or return an error to stop the response from being deserialized
	return res, nil
}

func (i *ExampleHook) AfterError(hookCtx AfterErrorContext, res *http.Response, err error) (*http.Response, error) {
	// modify the response before it is deserialized as a custom error or the error object before it is returned or return an error wrapped in the FailEarly error in this package to exit from the hook chain early
	return res, err
}

import requests
from typing import Optional, Tuple, Union
from .types import BeforeRequestContext, BeforeRequestHook, AfterSuccessContext, AfterSuccessHook, AfterErrorContext, AfterErrorHook, SDKInitHook
from requests.structures import CaseInsensitiveDict
from urllib.parse import urlparse, parse_qs, urlencode, urlunparse


class ExampleHook(SDKInitHook, BeforeRequestHook, AfterSuccessHook, AfterErrorHook):
    def sdk_init(self, base_url: str, client: requests.Session) -> Tuple[str, requests.Session]:
        # modify the base_url or wrap the client used by the SDK here and return the updated values
        return base_url, client

    def before_request(self, hook_ctx: BeforeRequestContext, request: requests.PreparedRequest) -> Union[requests.PreparedRequest, Exception]:
        # modify the request object before it is sent, such as adding headers or query parameters, or raise an exception to stop the request

        return request

    def after_success(self, hook_ctx: AfterSuccessContext, response: requests.Response) -> Union[requests.Response, Exception]:
        # modify the response object before deserialization or raise an exception to stop the response from being returned

        return response

    def after_error(self, hook_ctx: AfterErrorContext, response: Optional[requests.Response], error: Optional[Exception]) -> Union[Tuple[Optional[requests.Response], Optional[Exception]], Exception]:
        # modify the response before it is deserialized as a custom error or the error object before it is returned or raise an exception to stop processing of other error hooks and return early

        return (response, error)

import { HTTPClient } from "../lib/http";
import {
  AfterErrorContext,
  AfterErrorHook,
  AfterSuccessContext,
  AfterSuccessHook,
  BeforeRequestContext,
  BeforeRequestHook,
  SDKInitHook,
  SDKInitOptions,
} from "./types";

export class ExampleHook
  implements SDKInitHook, BeforeRequestHook, AfterSuccessHook, AfterErrorHook
{
  sdkInit(opts: SDKInitOptions): SDKInitOptions {
    const { baseURL, client } = opts;

    // modify the baseURL or wrap the client used by the SDK here and return the updated values
    return { baseURL: baseURL, client: client };
  }

  beforeRequest(hookCtx: BeforeRequestContext, request: Request): Request {
    // modify the request object before it is sent, such as adding headers or query parameters, or throw an error to stop the request from being sent
    return request;
  }

  afterSuccess(hookCtx: AfterSuccessContext, response: Response): Response {
    // modify the response object before deserialization or throw an error to stop the response from being deserialized
    return response;
  }

  afterError(
    hookCtx: AfterErrorContext,
    response: Response | null,
    error: unknown,
  ): { response: Response | null; error: unknown } {
    // modify the response before it is deserialized as a custom error or the error object before it is returned or throw an error to stop processing of other error hooks and return early
    return { response, error };
  }
}

package dev.speakeasyapi.speakeasy.hooks;

import dev.speakeasyapi.speakeasy.utils.Utils;
import dev.speakeasyapi.speakeasy.utils.Hook.AfterError;
import dev.speakeasyapi.speakeasy.utils.Hook.AfterErrorContext;
import dev.speakeasyapi.speakeasy.utils.Hook.AfterSuccess;
import dev.speakeasyapi.speakeasy.utils.Hook.AfterSuccessContext;
import dev.speakeasyapi.speakeasy.utils.Hook.BeforeRequest;
import dev.speakeasyapi.speakeasy.utils.Hook.BeforeRequestContext;
import dev.speakeasyapi.speakeasy.utils.Hook.SdkInit;
import dev.speakeasyapi.speakeasy.utils.Hook.SdkInitData;

import java.io.InputStream;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.util.Optional;

final class ExampleHook implements BeforeRequest, AfterError, AfterSuccess, SdkInit {

    @Override
    public SdkInitData sdkInit(SdkInitData data) {
        // modify the baseURL or wrap the client used by the SDK here and return the updated values
        return new SdkInitData(data.baseUrl(), data.client());
    }

    @Override
    public HttpRequest beforeRequest(BeforeRequestContext context, HttpRequest request) throws Exception {
        // modify the request object before it is sent, such as adding headers or query parameters
        // or throw an error to stop the request from being sent

        // Note that HttpRequest is immutable. With JDK 16 and later you can use
        // `HttpRequest.newBuilder(HttpRequest, BiPredicate<String, String>)` to copy the request
        // and modify it (the predicate is for filtering headers). If that method is not
        // available then use `Helpers.copy` in the generated `utils` package.

        return request;
    }

    @Override
    public HttpResponse<InputStream> afterSuccess(AfterSuccessContext context, HttpResponse<InputStream> response)
            throws Exception {
        // modify the response object before deserialization or throw an exception to stop the
        // response from being deserialized
        return response;
    }

    @Override
    public HttpResponse<InputStream> afterError(AfterErrorContext context,
            Optional<HttpResponse<InputStream>> response, Optional<Exception> error) throws Exception {
        // modify the response before it is deserialized as a custom error or the exception
        // object before it is thrown or throw a  FailEarlyException to stop processing of
        // other error hooks and return early
        return response;
    }
}

namespace Speakeasy.Hooks
{
    using Speakeasy.Utils;
    using Speakeasy.Models.Components;

    public class ExampleHook : ISDKInitHook, IBeforeRequestHook, IAfterSuccessHook, IAfterErrorHook
    {
        public (string, ISpeakeasyHttpClient) SDKInit(string baseURL, ISpeakeasyHttpClient client)
        {
            // modify the baseURL or wrap the client used by the SDK here and return the updated values
            return (baseURL, client);
        }

        public async Task<HttpRequestMessage> BeforeRequestAsync(BeforeRequestContext hookCtx, HttpRequestMessage request)
        {
            // modify the request object before it is sent, such as adding headers or query parameters, or throw an exception to stop the request from being sent
            return request;
        }

        public async Task<HttpResponseMessage> AfterSuccessAsync(AfterSuccessContext hookCtx, HttpResponseMessage response)
        {
            // modify the response object before deserialization or throw an exception to stop the response from being returned
            return response;
        }

        public async Task<(HttpResponseMessage?, Exception?)> AfterErrorAsync(AfterErrorContext hookCtx, HttpResponseMessage? response, Exception error)
        {
            // modify the response before it is deserialized as a custom error
            // return (response, null);

            // OR modify the exception object before it is thrown
            // return (null, error);

            // OR abort the processing of subsequent AfterError hooks
            // throw new FailEarlyException("return early", error);

            // response and error cannot both be null
            return (response, error);
        }
    }
}

configVersion: 2.0.0
go:
additionalDependencies:
  # Pass a map of Go package names to the version to be added to the `go.mod` file of the SDK.
  "github.com/google/uuid": v1.6.0

configVersion: 2.0.0
python:
  additionalDependencies:
    dev:
      - "pytest>=6.0.0"
      - "flake8>=3.9.0"
    main:
      - "requests>=2.25.0"
      - "pydantic>=1.8.0"

configVersion: 2.0.0
python:
additionalDependencies:
  dependencies:
    # Pass a map of core Python package names to their version pattern under the `dependencies` key, and then add dependencies under `extraDependencies`
    "uuid-utils": ">=0.6.1"
  extraDependencies:
    dev: {}

typescript:
additionalDependencies:
  #  Pass a map of npm package names to their version pattern for `dependencies`, `devDependencies`, or `peerDependencies`.
  dependencies:
    uuid: ^9.0.1
  devDependencies:
    "@types/uuid": "^9.0.8"
  peerDependencies: {}

java:
additionalDependencies:
  # Pass an array of `scope:groupId:artifactId:version` strings, for example, `implementation:com.fasterxml.jackson.core:jackson-databind:2.16.2`.
  - implementation:com.fasterxml.jackson.core:jackson-databind:2.16.0
  - api:org.apache.commons:commons-compress:1.26.1

csharp:
  additionalDependencies:
    - package: RestSharp
      version: 106.12.0
      includeAssets: all
      privateAssets: contentFiles; build; native; analyzers; buildTransitive
      excludeAssets: none