supertokens-node/lib/build/recipe/oauth2provider/types.d.ts

NodeJS driver for SuperTokens core

// @ts-nocheck
import type { BaseRequest, BaseResponse } from "../../framework";
import OverrideableBuilder from "supertokens-js-override";
import { GeneralErrorResponse, JSONObject, JSONValue, NonNullableProperties, UserContext } from "../../types";
import { SessionContainerInterface } from "../session/types";
import { OAuth2Client } from "./OAuth2Client";
import { User } from "../../user";
import RecipeUserId from "../../recipeUserId";
export type TypeInput = {
    override?: {
        functions?: (originalImplementation: RecipeInterface, builder: OverrideableBuilder<RecipeInterface>) => RecipeInterface;
        apis?: (originalImplementation: APIInterface, builder: OverrideableBuilder<APIInterface>) => APIInterface;
    };
};
export type TypeNormalisedInput = {
    override: {
        functions: (originalImplementation: RecipeInterface, builder: OverrideableBuilder<RecipeInterface>) => RecipeInterface;
        apis: (originalImplementation: APIInterface, builder: OverrideableBuilder<APIInterface>) => APIInterface;
    };
};
export type APIOptions = {
    recipeImplementation: RecipeInterface;
    config: TypeNormalisedInput;
    recipeId: string;
    isInServerlessEnv: boolean;
    req: BaseRequest;
    res: BaseResponse;
};
export type ErrorOAuth2 = {
    status: "ERROR";
    error: string;
    errorDescription: string;
    statusCode?: number;
};
export type ConsentRequest = {
    acr?: string;
    amr?: string[];
    challenge: string;
    client?: OAuth2Client;
    context?: JSONObject;
    loginChallenge?: string;
    loginSessionId?: string;
    oidcContext?: any;
    requestedAccessTokenAudience?: string[];
    requestedScope?: string[];
    skip?: boolean;
    subject?: string;
};
export type LoginRequest = {
    challenge: string;
    client: OAuth2Client;
    oidcContext?: any;
    requestUrl: string;
    requestedAccessTokenAudience?: string[];
    requestedScope?: string[];
    sessionId?: string;
    skip: boolean;
    subject: string;
};
export type TokenInfo = {
    access_token?: string;
    expires_in: number;
    id_token?: string;
    refresh_token?: string;
    scope: string;
    token_type: string;
};
export type LoginInfo = {
    clientId: string;
    clientName: string;
    tosUri?: string;
    policyUri?: string;
    logoUri?: string;
    clientUri?: string;
    metadata?: Record<string, any> | null;
};
export type UserInfo = {
    sub: string;
    email?: string;
    email_verified?: boolean;
    phoneNumber?: string;
    phoneNumber_verified?: boolean;
    [key: string]: JSONValue;
};
export type InstrospectTokenResponse = {
    active: false;
} | ({
    active: true;
} & JSONObject);
export type RecipeInterface = {
    authorization(input: {
        params: Record<string, string>;
        cookies: string | undefined;
        session: SessionContainerInterface | undefined;
        userContext: UserContext;
    }): Promise<{
        redirectTo: string;
        cookies: string[] | undefined;
    } | ErrorOAuth2>;
    tokenExchange(input: {
        authorizationHeader?: string;
        body: Record<string, string | undefined>;
        userContext: UserContext;
    }): Promise<TokenInfo | ErrorOAuth2>;
    getConsentRequest(input: {
        challenge: string;
        userContext: UserContext;
    }): Promise<ConsentRequest | ErrorOAuth2>;
    acceptConsentRequest(input: {
        challenge: string;
        context?: any;
        grantAccessTokenAudience?: string[];
        grantScope?: string[];
        handledAt?: string;
        tenantId: string;
        rsub: string;
        sessionHandle: string;
        initialAccessTokenPayload: JSONObject | undefined;
        initialIdTokenPayload: JSONObject | undefined;
        userContext: UserContext;
    }): Promise<{
        redirectTo: string;
        status: "OK";
    } | ErrorOAuth2>;
    rejectConsentRequest(input: {
        challenge: string;
        error: ErrorOAuth2;
        userContext: UserContext;
    }): Promise<{
        redirectTo: string;
        status: "OK";
    } | ErrorOAuth2>;
    getLoginRequest(input: {
        challenge: string;
        userContext: UserContext;
    }): Promise<(LoginRequest & {
        status: "OK";
    }) | ErrorOAuth2>;
    acceptLoginRequest(input: {
        challenge: string;
        acr?: string;
        amr?: string[];
        context?: any;
        extendSessionLifespan?: boolean;
        identityProviderSessionId?: string;
        subject: string;
        userContext: UserContext;
    }): Promise<{
        redirectTo: string;
        status: "OK";
    } | ErrorOAuth2>;
    rejectLoginRequest(input: {
        challenge: string;
        error: ErrorOAuth2;
        userContext: UserContext;
    }): Promise<{
        redirectTo: string;
        status: "OK";
    } | ErrorOAuth2>;
    getOAuth2Client(input: {
        clientId: string;
        userContext: UserContext;
    }): Promise<{
        status: "OK";
        client: OAuth2Client;
    } | {
        status: "ERROR";
        error: string;
        errorDescription: string;
    }>;
    getOAuth2Clients(input: GetOAuth2ClientsInput & {
        userContext: UserContext;
    }): Promise<{
        status: "OK";
        clients: Array<OAuth2Client>;
        nextPaginationToken?: string;
    } | {
        status: "ERROR";
        error: string;
        errorDescription: string;
    }>;
    createOAuth2Client(input: CreateOAuth2ClientInput & {
        userContext: UserContext;
    }): Promise<{
        status: "OK";
        client: OAuth2Client;
    } | {
        status: "ERROR";
        error: string;
        errorDescription: string;
    }>;
    updateOAuth2Client(input: UpdateOAuth2ClientInput & {
        userContext: UserContext;
    }): Promise<{
        status: "OK";
        client: OAuth2Client;
    } | {
        status: "ERROR";
        error: string;
        errorDescription: string;
    }>;
    deleteOAuth2Client(input: DeleteOAuth2ClientInput & {
        userContext: UserContext;
    }): Promise<{
        status: "OK";
    } | {
        status: "ERROR";
        error: string;
        errorDescription: string;
    }>;
    validateOAuth2AccessToken(input: {
        token: string;
        requirements?: {
            clientId?: string;
            scopes?: string[];
            audience?: string;
        };
        checkDatabase?: boolean;
        userContext: UserContext;
    }): Promise<{
        status: "OK";
        payload: JSONObject;
    }>;
    getRequestedScopes(input: {
        recipeUserId: RecipeUserId | undefined;
        sessionHandle: string | undefined;
        scopeParam: string[];
        clientId: string;
        userContext: UserContext;
    }): Promise<string[]>;
    buildAccessTokenPayload(input: {
        user: User | undefined;
        client: OAuth2Client;
        sessionHandle: string | undefined;
        scopes: string[];
        userContext: UserContext;
    }): Promise<JSONObject>;
    buildIdTokenPayload(input: {
        user: User | undefined;
        client: OAuth2Client;
        sessionHandle: string | undefined;
        scopes: string[];
        userContext: UserContext;
    }): Promise<JSONObject>;
    buildUserInfo(input: {
        user: User;
        accessTokenPayload: JSONObject;
        scopes: string[];
        tenantId: string;
        userContext: UserContext;
    }): Promise<JSONObject>;
    getFrontendRedirectionURL(input: {
        type: "login";
        loginChallenge: string;
        tenantId: string;
        forceFreshAuth: boolean;
        hint: string | undefined;
        userContext: UserContext;
    } | {
        type: "try-refresh";
        loginChallenge: string;
        userContext: UserContext;
    } | {
        type: "logout-confirmation";
        logoutChallenge: string;
        userContext: UserContext;
    } | {
        type: "post-logout-fallback";
        userContext: UserContext;
    }): Promise<string>;
    revokeToken(input: {
        token: string;
        userContext: UserContext;
    } & ({
        authorizationHeader: string;
    } | {
        clientId: string;
        clientSecret?: string;
    })): Promise<{
        status: "OK";
    } | ErrorOAuth2>;
    revokeTokensByClientId(input: {
        clientId: string;
        userContext: UserContext;
    }): Promise<{
        status: "OK";
    }>;
    revokeTokensBySessionHandle(input: {
        sessionHandle: string;
        userContext: UserContext;
    }): Promise<{
        status: "OK";
    }>;
    introspectToken(input: {
        token: string;
        scopes?: string[];
        userContext: UserContext;
    }): Promise<(InstrospectTokenResponse & {
        status: "OK";
    }) | ErrorOAuth2>;
    endSession(input: {
        params: Record<string, string>;
        session?: SessionContainerInterface;
        shouldTryRefresh: boolean;
        userContext: UserContext;
    }): Promise<{
        redirectTo: string;
    } | ErrorOAuth2>;
    acceptLogoutRequest(input: {
        challenge: string;
        userContext: UserContext;
    }): Promise<{
        redirectTo: string;
    } | ErrorOAuth2>;
    rejectLogoutRequest(input: {
        challenge: string;
        userContext: UserContext;
    }): Promise<{
        status: "OK";
    }>;
};
export type APIInterface = {
    loginGET: undefined | ((input: {
        loginChallenge: string;
        options: APIOptions;
        session?: SessionContainerInterface;
        shouldTryRefresh: boolean;
        userContext: UserContext;
    }) => Promise<{
        frontendRedirectTo: string;
        cookies?: string[];
    } | ErrorOAuth2 | GeneralErrorResponse>);
    authGET: undefined | ((input: {
        params: any;
        cookie: string | undefined;
        session: SessionContainerInterface | undefined;
        shouldTryRefresh: boolean;
        options: APIOptions;
        userContext: UserContext;
    }) => Promise<{
        redirectTo: string;
        cookies?: string[];
    } | ErrorOAuth2 | GeneralErrorResponse>);
    tokenPOST: undefined | ((input: {
        authorizationHeader?: string;
        body: any;
        options: APIOptions;
        userContext: UserContext;
    }) => Promise<TokenInfo | ErrorOAuth2 | GeneralErrorResponse>);
    loginInfoGET: undefined | ((input: {
        loginChallenge: string;
        options: APIOptions;
        userContext: UserContext;
    }) => Promise<{
        status: "OK";
        info: LoginInfo;
    } | ErrorOAuth2 | GeneralErrorResponse>);
    userInfoGET: undefined | ((input: {
        accessTokenPayload: JSONObject;
        user: User;
        scopes: string[];
        tenantId: string;
        options: APIOptions;
        userContext: UserContext;
    }) => Promise<JSONObject | GeneralErrorResponse>);
    revokeTokenPOST: undefined | ((input: {
        token: string;
        options: APIOptions;
        userContext: UserContext;
    } & ({
        authorizationHeader: string;
    } | {
        clientId: string;
        clientSecret?: string;
    })) => Promise<{
        status: "OK";
    } | ErrorOAuth2>);
    introspectTokenPOST: undefined | ((input: {
        token: string;
        scopes?: string[];
        options: APIOptions;
        userContext: UserContext;
    }) => Promise<InstrospectTokenResponse | GeneralErrorResponse | ErrorOAuth2>);
    endSessionGET: undefined | ((input: {
        params: Record<string, string>;
        session?: SessionContainerInterface;
        shouldTryRefresh: boolean;
        options: APIOptions;
        userContext: UserContext;
    }) => Promise<{
        redirectTo: string;
    } | ErrorOAuth2 | GeneralErrorResponse>);
    endSessionPOST: undefined | ((input: {
        params: Record<string, string>;
        session?: SessionContainerInterface;
        shouldTryRefresh: boolean;
        options: APIOptions;
        userContext: UserContext;
    }) => Promise<{
        redirectTo: string;
    } | ErrorOAuth2 | GeneralErrorResponse>);
    logoutPOST: undefined | ((input: {
        logoutChallenge: string;
        options: APIOptions;
        session?: SessionContainerInterface;
        userContext: UserContext;
    }) => Promise<{
        status: "OK";
        frontendRedirectTo: string;
    } | ErrorOAuth2 | GeneralErrorResponse>);
};
export type OAuth2ClientOptions = {
    clientId: string;
    clientSecret?: string;
    createdAt: string;
    updatedAt: string;
    clientName: string;
    scope: string;
    redirectUris?: string[] | null;
    postLogoutRedirectUris?: string[];
    authorizationCodeGrantAccessTokenLifespan?: string | null;
    authorizationCodeGrantIdTokenLifespan?: string | null;
    authorizationCodeGrantRefreshTokenLifespan?: string | null;
    clientCredentialsGrantAccessTokenLifespan?: string | null;
    implicitGrantAccessTokenLifespan?: string | null;
    implicitGrantIdTokenLifespan?: string | null;
    refreshTokenGrantAccessTokenLifespan?: string | null;
    refreshTokenGrantIdTokenLifespan?: string | null;
    refreshTokenGrantRefreshTokenLifespan?: string | null;
    tokenEndpointAuthMethod: string;
    audience?: string[];
    grantTypes?: string[] | null;
    responseTypes?: string[] | null;
    clientUri?: string;
    logoUri?: string;
    policyUri?: string;
    tosUri?: string;
    metadata?: Record<string, any>;
    enableRefreshTokenRotation?: boolean;
};
export type GetOAuth2ClientsInput = {
    /**
     * Items per Page. Defaults to 250.
     */
    pageSize?: number;
    /**
     * Next Page Token. Defaults to "1".
     */
    paginationToken?: string;
    /**
     * The name of the clients to filter by.
     */
    clientName?: string;
};
export type CreateOAuth2ClientInput = Partial<Omit<OAuth2ClientOptions, "createdAt" | "updatedAt">>;
export type UpdateOAuth2ClientInput = NonNullableProperties<Omit<CreateOAuth2ClientInput, "redirectUris" | "grantTypes" | "responseTypes" | "metadata">> & {
    clientId: string;
    redirectUris?: string[] | null;
    grantTypes?: string[] | null;
    responseTypes?: string[] | null;
    metadata?: Record<string, any> | null;
};
export type DeleteOAuth2ClientInput = {
    clientId: string;
};
export type PayloadBuilderFunction = (user: User, scopes: string[], sessionHandle: string, userContext: UserContext) => Promise<JSONObject>;
export type UserInfoBuilderFunction = (user: User, accessTokenPayload: JSONObject, scopes: string[], tenantId: string, userContext: UserContext) => Promise<JSONObject>;