OAuth 2.0 authentication

import { SDK } from "speakeasy";

async function run() {
  const sdk = new SDK({
    security: {
      clientID: "<YOUR_CLIENT_ID_HERE>",
      clientSecret: "<YOUR_CLIENT_SECRET_HERE>",
    },
  });

  const result = await sdk.drinks.listDrinks();

  // Handle the result
  console.log(result);
}

run();

import speakeasy
from speakeasy.models import components

s = speakeasy.SDK(
    security=components.Security(
        client_id="<YOUR_CLIENT_ID_HERE>",
        client_secret="<YOUR_CLIENT_SECRET_HERE>",
    ),
)


res = s.drinks.list_drinks()

if res.drinks is not None:
    # handle response
    pass

package main

import (
	"context"
	"log"
	"speakeasy"
	"speakeasy/models/components"
)

func main() {
	s := speakeasy.New(
		speakeasy.WithSecurity(components.Security{
			ClientID:     "<YOUR_CLIENT_ID_HERE>",
			ClientSecret: "<YOUR_CLIENT_SECRET_HERE>",
		}),
	)

	ctx := context.Background()
	res, err := s.Drinks.ListDrinks(ctx)
	if err != nil {
		log.Fatal(err)
	}
	if res.Drinks != nil {
		// handle response
	}
}

package hello.world;

import dev.speakeasyapi.speakeasy.SDK;
import dev.speakeasyapi.speakeasy.models.components.*;
import dev.speakeasyapi.speakeasy.models.components.Security;
import dev.speakeasyapi.speakeasy.models.operations.*;
import dev.speakeasyapi.speakeasy.models.operations.ListDrinksResponse;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.LocalDate;
import java.time.OffsetDateTime;
import java.util.Optional;
import static java.util.Map.entry;

public class Application {

    public static void main(String[] args) {
        try {
            SDK sdk = SDK.builder()
                .clientCredentials(ClientCredentials.builder()
                    .clientID("<YOUR_CLIENT_ID_HERE>")
                    .clientSecret("<YOUR_CLIENT_SECRET_HERE>")
                    .build())
                .build();

            ListDrinksResponse res = sdk.drinks().listDrinks()
                .call();

            if (res.drinks().isPresent()) {
                // handle response
            }
        } catch (dev.speakeasyapi.speakeasy.models.errors.SDKError e) {
            // handle exception
        } catch (Exception e) {
            // handle exception
        }
    }
}

using Speakeasy;
using Speakeasy.Models.Components;

var sdk = new SDK(
    security: new Security()
    {
        ClientID = "<YOUR_CLIENT_ID_HERE>",
        ClientSecret = "<YOUR_CLIENT_SECRET_HERE>"
    }
);

try
{
    var res = await sdk.Drinks.ListDrinksAsync();

    if (res.Drinks != null)
    {
        // handle response
    }
}
catch (Exception ex)
{
   // handle exception
}

const sdk = new SDK({
    oauth2: {
      username: "testuser",
      password: "testpassword",
      clientID: "beezy",
      clientSecret: "secret",
    }
  });

const result = await sdk.listProducts();

SDK sdk = SDK.builder() 
    .oauth2(Oauth2Input.of( 
        Oauth2Credentials.builder()
            .username("testuser") 
            .password("testpassword") 
            .clientID("beezy") 
            .clientSecret("secret") 
            .build()))
    .build();
ListProductsResponse res = sdk.listProducts().call();

const sdk = new SDK({
    oauth2: "THE_TOKEN"
}};

const result = await sdk.listProducts();

SDK sdk = SDK.builder() 
    .oauth2(Oauth2Input.of("THE_TOKEN"))
    .build();
ListProductsResponse res = sdk.listProducts().call();

import type {BeforeRequestContext, BeforeRequestHook, Hooks} from "./types.js";
import {GetTokenSecurity} from "../models/operations/gettoken.js";
import {stringToBase64} from "../lib/base64.js";

class OAuthTokenRequestHook implements BeforeRequestHook {
  beforeRequest(hookCtx: BeforeRequestContext, request: Request): Request {
    switch (hookCtx.operationID) {
      case "getToken": {
        let sec = hookCtx.securitySource;
        if (typeof sec === "function") {
          sec = sec();
        }
        if (!sec) {
          throw new Error("security source is not defined");
        }

        const customSec = sec as GetTokenSecurity;
        const encoded = stringToBase64(
          [customSec.Id || "", customSec.Secret || ""].join(":"),
        );
        request.headers.set("Authorization", `Basic ${encoded}`);

        break;
      }
    }

    return request;
  }
}

import { SDK } from "SDK";

const sdk = new SDK();

async function run() {
  const result = await sdk.oAuth2.getToken({
    Id: process.env["SDK_ID"] ?? "",
    Secret: process.env["SDK_SECRET"] ?? "",
  }, {
    grantType: "authorization_code",
    code: "1234567890",
    redirectUri: "https://example.com/oauth/callback",
  });

  // Handle the result
  console.log(result);
}

run();

import * as z from "zod";
import { SDK_METADATA } from "./lib/config";

// TypeScript SDKs use Zod for runtime data validation. We can use Zod
// to describe the shape of the response from the OAuth token endpoint. If the
// response is valid, Speakeasy can safely access the token and its expiration time.
const tokenResponseSchema = z.object({
  access_token: z.string(),
  expires_in: z.number().positive(),
});

// This is a rough value that adjusts when we consider an access token to be
// expired. It accounts for clock drift between the client and server
// and slow or unreliable networks.
const tolerance = 5 * 60 * 1000;

/**
 * A callback function that can be used to obtain an OAuth access token for use
 * with SDKs that require OAuth security. A new token is requested from the
 * OAuth provider when the current token has expired.
 */
export function withAuthorization(
  clientID: string,
  clientSecret: string,
  options: { tokenStore?: TokenStore; url?: string } = {},
) {
  const {
    tokenStore = new InMemoryTokenStore(),
    // Replace this with your default OAuth provider's access token endpoint.
    url = "https://oauth.example.com/token",
  } = options;

  return async (): Promise<string> => {
    const session = await tokenStore.get();

    // Return the current token if it has not expired yet.
    if (session && session.expires > Date.now()) {
      return session.token;
    }

    try {
      const response = await fetch(url, {
        method: "POST",
        headers: {
          "content-type": "application/x-www-form-urlencoded",
          // Include the SDK's user agent in the request so requests can be
          // tracked using observability infrastructure.
          "user-agent": SDK_METADATA.userAgent,
        },
        body: new URLSearchParams({
          client_id: clientID,
          client_secret: clientSecret,
          grant_type: "client_credentials",
        }),
      });

      if (!response.ok) {
        throw new Error("Unexpected status code: " + response.status);
      }

      const json = await response.json();
      const data = tokenResponseSchema.parse(json);

      await tokenStore.set(
        data.access_token,
        Date.now() + data.expires_in * 1000 - tolerance,
      );

      return data.access_token;
    } catch (error) {
      throw new Error("Failed to obtain OAuth token: " + error);
    }
  };
}

/**
 * A TokenStore is used to save and retrieve OAuth tokens for use across SDK
 * method calls. This interface can be implemented to store tokens in memory,
 * a shared cache like Redis or a database table.
 */
export interface TokenStore {
  get(): Promise<{ token: string; expires: number } | undefined>;
  set(token: string, expires: number): Promise<void>;
}

/**
 * InMemoryTokenStore holds OAuth access tokens in memory for use by SDKs and
 * methods that require OAuth security.
 */
export class InMemoryTokenStore implements TokenStore {
  private token = "";
  private expires = Date.now();

  constructor() {}

  async get() {
    return { token: this.token, expires: this.expires };
  }

  async set(token: string, expires: number) {
    this.token = token;
    this.expires = expires;
  }
}

import axios from "axios";

// eslint-disable-next-line @typescript-eslint/no-unused-vars
export function withAuthorization(clientID: string, clientSecret: string) {
  return async (): Promise<{ auth: string }> => {
    const tokenEndpoint = "https://speakeasy.bar/oauth2/token/";
    const data = {
      grant_type: "client_credentials",
      client_id: clientID,
      client_secret: clientSecret,
    };
    try {
      const response = await axios.post(tokenEndpoint, data);
      return { auth: response.data.access_token };
    } catch (error) {
      throw new Error("Failed to obtain OAuth token");
    }
  };
}

import requests
from sdk.components import Security


def with_authorization(client_id: str, client_secret: str) -> Security:
  token_endpoint = 'https://speakeasy.bar/oauth2/token/'
  data = {
      'grant_type': 'client_credentials',
      'client_id': client_id,
      'client_secret': client_secret,
  }
  try:
      response = requests.post(token_endpoint, data=data)
      response.raise_for_status()
      return Security(auth=response.json()['access_token'])
  except Exception as e:
      raise Exception(f'Failed to obtain OAuth token: {str(e)}')

package speakeasy

import (
	"speakeasy/components"
)

func withAuthorization(clientID string, clientSecret string) func(context.Context) (components.Security, error) {
	return func(ctx context.Context) (components.Security, error) {

      // Please implement callback here

      return components.Security{Auth: "<YOUR_OAUTH_TOKEN>"}, nil
	}
}

import dev.speakeasyapi.speakeasy.SecuritySource;
import dev.speakeasyapi.speakeasy.models.components.Security;


class OAuth implements SecuritySource {

    private String clientID;
    private String clientSecret;

    public OAuth(String clientID, String clientSecret) {
        this.clientID = clientID;
        this.clientSecret = clientSecret;
    }

    public Security getSecurity() {

        // Please implement callback here

        return Security.builder()
            .auth("<YOUR_OAUTH_TOKEN>")
            .build();
    }
}

namespace Speakeasy.Callbacks
{
    using Speakeasy;
    using Speakeasy.Models.Components;

    public static class OAuth
    {

        public static Security withAuthorization(string clientID, string clientSecret)
        {
            // Please implement callback here

            return new Security { Auth = "<YOUR_OAUTH_TOKEN>"}
        }
    }
}

import { SDK } from "speakeasy";

const sdk = new SDK({
  security: withAuthorization("client_id", "client_secret"),
});

await s.drinks.listDrinks();

import sdk

s = sdk.SDK(security=with_authorization("<YOUR_CLIENT_ID>", "<YOUR_CLIENT_SECRET>"))
res = s.drinks.list_drinks()

import (
	"context"
  sdk "speakeasy"
)

s := sdk.New(
    sdk.WithSecuritySource(withAuthorization(
        "<YOUR_CLIENT_ID>",
        "<YOUR_CLIENT_SECRET>",
    )),
)
ctx := context.Background()
s.Drinks.ListDrinks(ctx)

import dev.speakeasyapi.speakeasy.OAuth;
import dev.speakeasyapi.speakeasy.SDK;

OAuth securitySource = new OAuth("<YOUR_CLIENT_ID>", "<YOUR_CLIENT_SECRET>");

SDK s = SDK.builder()
    .securitySource(securitySource)
    .build();

ListDrinksResponse res = s.Drinks.listDrinks().call();

using Speakeasy;
using Speakeasy.Callbacks;

var sdk = new SDK(securitySource: OAuth.withAuthorization)

var res = await sdk.Drinks.ListDrinksAsync();