antarctic 0.6.0 → 0.7.0

package/dist/providers/linear.js

@@ -1,5 +1,5 @@
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
-import { extractOAuthTokens, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const authorizationEndpoint = "https://linear.app/oauth/authorize";
 const tokenEndpoint = "https://api.linear.app/oauth/token";
 const graphqlEndpoint = "https://api.linear.app/graphql";
@@ -10,7 +10,7 @@ export class Linear {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -53,13 +53,12 @@ export class Linear {
         const state = generateOAuthState();
         const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
         const payload = {};
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        await resolveOAuthState(auth.store, state, saved);
+        resolveOAuthState(state, saved);
         const tokens = await this.validateAuthorizationCode(code);
         const viewer = await fetchViewer(tokens.accessToken());
         return {

package/dist/providers/linkedin.d.ts

@@ -7,11 +7,11 @@ export declare class LinkedIn {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: LinkedInOptions);
+    constructor(options?: LinkedInOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string, scopes: string[]): URL;
     validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/linkedin.js

@@ -1,7 +1,7 @@
 // LinkedIn doesn't seem to support HTTP Basic Auth
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
 import { decodeIdToken } from "../oidc.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const authorizationEndpoint = "https://www.linkedin.com/oauth/v2/authorization";
 const tokenEndpoint = "https://www.linkedin.com/oauth/v2/accessToken";
 const userinfoEndpoint = "https://api.linkedin.com/v2/userinfo";
@@ -12,7 +12,7 @@ export class LinkedIn {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -65,13 +65,12 @@ export class LinkedIn {
         const state = generateOAuthState();
         const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
         const payload = {};
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        await resolveOAuthState(auth.store, state, saved);
+        resolveOAuthState(state, saved);
         const tokens = await this.validateAuthorizationCode(code);
         let claims;
         if ("id_token" in tokens.data) {

package/dist/providers/mastodon.d.ts

@@ -10,11 +10,11 @@ export declare class Mastodon {
     private userEndpoint;
     private client;
     private auth;
-    constructor(options: MastodonOptions);
+    constructor(options?: MastodonOptions);
     constructor(baseURL: string, clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/mastodon.js

@@ -1,6 +1,6 @@
 import { OAuth2Client, CodeChallengeMethod } from "../client.js";
 import { joinURIAndPath } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const envPrefix = "MASTODON";
 const defaultScopes = ["read:accounts"];
 export class Mastodon {
@@ -10,7 +10,7 @@ export class Mastodon {
     userEndpoint;
     client;
     auth = null;
-    constructor(baseURLOrOptions, clientId, clientSecret, redirectURI) {
+    constructor(baseURLOrOptions = {}, clientId, clientSecret, redirectURI) {
         let baseURL;
         if (typeof baseURLOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, baseURLOrOptions, {
@@ -46,13 +46,12 @@ export class Mastodon {
         const codeVerifier = generateOAuthCodeVerifier();
         const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         const payload = { codeVerifier };
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        const stored = await resolveOAuthState(auth.store, state, saved);
+        const stored = resolveOAuthState(state, saved);
         if (typeof stored.codeVerifier !== "string") {
             throw new InvalidOAuthCallbackError("Missing PKCE code verifier for OAuth state");
         }

package/dist/providers/mercadolibre.d.ts

@@ -7,11 +7,11 @@ export declare class MercadoLibre {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: MercadoLibreOptions);
+    constructor(options?: MercadoLibreOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string, codeVerifier: string): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(_scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/mercadolibre.js

@@ -1,6 +1,6 @@
 import { createS256CodeChallenge } from "../oauth2.js";
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState } from "../auth.js";
 const authorizationEndpoint = "https://auth.mercadolibre.com/authorization";
 const tokenEndpoint = "https://api.mercadolibre.com/oauth/token";
 const userEndpoint = "https://api.mercadolibre.com/users/me";
@@ -10,7 +10,7 @@ export class MercadoLibre {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -62,18 +62,17 @@ export class MercadoLibre {
     }
     // Scopes are defined in the application settings, so the argument is ignored.
     async getAuthorizationURL(_scopes) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
         const url = await this.createAuthorizationURL(state, codeVerifier);
         const payload = { codeVerifier };
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        const stored = await resolveOAuthState(auth.store, state, saved);
+        const stored = resolveOAuthState(state, saved);
         if (typeof stored.codeVerifier !== "string") {
             throw new InvalidOAuthCallbackError("Missing PKCE code verifier for OAuth state");
         }

package/dist/providers/mercadopago.d.ts

@@ -7,11 +7,11 @@ export declare class MercadoPago {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: MercadoPagoOptions);
+    constructor(options?: MercadoPagoOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string, codeVerifier: string): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(_scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/mercadopago.js

@@ -1,6 +1,6 @@
 import { createS256CodeChallenge } from "../oauth2.js";
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState } from "../auth.js";
 const authorizationEndpoint = "https://auth.mercadopago.com/authorization";
 const tokenEndpoint = "https://api.mercadopago.com/oauth/token";
 const userEndpoint = "https://api.mercadopago.com/users/me";
@@ -10,7 +10,7 @@ export class MercadoPago {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -62,18 +62,17 @@ export class MercadoPago {
     }
     // Scopes are defined in the application settings, so the argument is ignored.
     async getAuthorizationURL(_scopes) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
         const url = await this.createAuthorizationURL(state, codeVerifier);
         const payload = { codeVerifier };
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        const stored = await resolveOAuthState(auth.store, state, saved);
+        const stored = resolveOAuthState(state, saved);
         if (typeof stored.codeVerifier !== "string") {
             throw new InvalidOAuthCallbackError("Missing PKCE code verifier for OAuth state");
         }

package/dist/providers/microsoft-entra-id.d.ts

@@ -10,11 +10,11 @@ export declare class MicrosoftEntraId {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: MicrosoftEntraIdOptions);
+    constructor(options?: MicrosoftEntraIdOptions);
     constructor(tenant: string, clientId: string, clientSecret: string | null, redirectURI: string);
     createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string, scopes: string[]): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/microsoft-entra-id.js

@@ -1,7 +1,7 @@
 import { createS256CodeChallenge } from "../oauth2.js";
 import { createOAuth2Request, encodeBasicCredentials, joinURIAndPath, sendTokenRequest } from "../request.js";
 import { decodeIdToken } from "../oidc.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const userinfoEndpoint = "https://graph.microsoft.com/oidc/userinfo";
 const envPrefix = "MICROSOFT_ENTRA_ID";
 const defaultScopes = ["openid", "profile", "email"];
@@ -12,7 +12,7 @@ export class MicrosoftEntraId {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(tenantOrOptions, clientId, clientSecret, redirectURI) {
+    constructor(tenantOrOptions = {}, clientId, clientSecret, redirectURI) {
         let tenant;
         if (typeof tenantOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, tenantOrOptions, { redirectURI: true });
@@ -93,13 +93,12 @@ export class MicrosoftEntraId {
         const codeVerifier = generateOAuthCodeVerifier();
         const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         const payload = { codeVerifier };
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        const stored = await resolveOAuthState(auth.store, state, saved);
+        const stored = resolveOAuthState(state, saved);
         if (typeof stored.codeVerifier !== "string") {
             throw new InvalidOAuthCallbackError("Missing PKCE code verifier for OAuth state");
         }

package/dist/providers/myanimelist.d.ts

@@ -5,11 +5,11 @@ export interface MyAnimeListOptions extends ProviderOptions {
 export declare class MyAnimeList {
     private client;
     private auth;
-    constructor(options: MyAnimeListOptions);
+    constructor(options?: MyAnimeListOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string | null);
     createAuthorizationURL(state: string, codeVerifier: string): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(_scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/myanimelist.js

@@ -1,5 +1,5 @@
 import { OAuth2Client, CodeChallengeMethod } from "../client.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState } from "../auth.js";
 const authorizationEndpoint = "https://myanimelist.net/v1/oauth2/authorize";
 const tokenEndpoint = "https://myanimelist.net/v1/oauth2/token";
 const userEndpoint = "https://api.myanimelist.net/v2/users/@me";
@@ -7,7 +7,7 @@ const envPrefix = "MY_ANIME_LIST";
 export class MyAnimeList {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { clientSecret: true });
             this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
@@ -30,18 +30,17 @@ export class MyAnimeList {
     }
     // MyAnimeList does not use scopes, so the argument is ignored.
     async getAuthorizationURL(_scopes) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const codeVerifier = generateOAuthCodeVerifier();
         const url = await this.createAuthorizationURL(state, codeVerifier);
         const payload = { codeVerifier };
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        const stored = await resolveOAuthState(auth.store, state, saved);
+        const stored = resolveOAuthState(state, saved);
         if (typeof stored.codeVerifier !== "string") {
             throw new InvalidOAuthCallbackError("Missing PKCE code verifier for OAuth state");
         }

package/dist/providers/naver.d.ts

@@ -7,11 +7,11 @@ export declare class Naver {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: NaverOptions);
+    constructor(options?: NaverOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(): URL;
     validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(_scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/naver.js

@@ -1,5 +1,5 @@
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState } from "../auth.js";
 const authorizationEndpoint = "https://nid.naver.com/oauth2.0/authorize";
 const tokenEndpoint = "https://nid.naver.com/oauth2.0/token";
 const userEndpoint = "https://openapi.naver.com/v1/nid/me";
@@ -9,7 +9,7 @@ export class Naver {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -55,18 +55,17 @@ export class Naver {
     }
     // Naver scopes are configured in the application settings, so the argument is ignored.
     async getAuthorizationURL(_scopes) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const url = this.createAuthorizationURL();
         url.searchParams.set("state", state);
         const payload = {};
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        await resolveOAuthState(auth.store, state, saved);
+        resolveOAuthState(state, saved);
         const tokens = await this.validateAuthorizationCode(code);
         const profile = await fetchUserProfile(userEndpoint, tokens.accessToken());
         const response = profile.response;

package/dist/providers/notion.d.ts

@@ -5,10 +5,10 @@ export interface NotionOptions extends ProviderOptions {
 export declare class Notion {
     private client;
     private auth;
-    constructor(options: NotionOptions);
+    constructor(options?: NotionOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string): URL;
     validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(_scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/notion.js

@@ -1,12 +1,12 @@
 import { OAuth2Client } from "../client.js";
-import { extractOAuthTokens, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState } from "../auth.js";
 const authorizationEndpoint = "https://api.notion.com/v1/oauth/authorize";
 const tokenEndpoint = "https://api.notion.com/v1/oauth/token";
 const envPrefix = "NOTION";
 export class Notion {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -29,17 +29,16 @@ export class Notion {
     }
     // Notion does not use scopes, so the argument is ignored.
     async getAuthorizationURL(_scopes) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const state = generateOAuthState();
         const url = this.createAuthorizationURL(state);
         const payload = {};
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        await resolveOAuthState(auth.store, state, saved);
+        resolveOAuthState(state, saved);
         const tokens = await this.validateAuthorizationCode(code);
         // Notion returns the authorizing user inside the token response.
         const data = tokens.data;

package/dist/providers/okta.d.ts

@@ -11,12 +11,12 @@ export declare class Okta {
     private userinfoEndpoint;
     private client;
     private auth;
-    constructor(options: OktaOptions);
+    constructor(options?: OktaOptions);
     constructor(domain: string, authorizationServerId: string | null, clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string, scopes: string[]): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/okta.js

@@ -1,6 +1,6 @@
 import { CodeChallengeMethod, OAuth2Client } from "../client.js";
 import { decodeIdToken } from "../oidc.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveProviderOption, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveProviderOption, resolveScopes } from "../auth.js";
 import { joinURIAndPath } from "../request.js";
 const envPrefix = "OKTA";
 const defaultScopes = ["openid", "profile", "email"];
@@ -11,7 +11,7 @@ export class Okta {
     userinfoEndpoint;
     client;
     auth = null;
-    constructor(domainOrOptions, authorizationServerId, clientId, clientSecret, redirectURI) {
+    constructor(domainOrOptions = {}, authorizationServerId, clientId, clientSecret, redirectURI) {
         let domain;
         let serverId;
         if (typeof domainOrOptions === "object") {
@@ -58,13 +58,12 @@ export class Okta {
         const codeVerifier = generateOAuthCodeVerifier();
         const url = await this.createAuthorizationURL(state, codeVerifier, resolveScopes(scopes, auth, defaultScopes));
         const payload = { codeVerifier };
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        const stored = await resolveOAuthState(auth.store, state, saved);
+        const stored = resolveOAuthState(state, saved);
         if (typeof stored.codeVerifier !== "string") {
             throw new InvalidOAuthCallbackError("Missing PKCE code verifier for OAuth state");
         }

package/dist/providers/osu.d.ts

@@ -7,11 +7,11 @@ export declare class Osu {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: OsuOptions);
+    constructor(options?: OsuOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string | null);
     createAuthorizationURL(state: string, scopes: string[]): URL;
     validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/osu.js

@@ -1,5 +1,5 @@
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const authorizationEndpoint = "https://osu.ppy.sh/oauth/authorize";
 const tokenEndpoint = "https://osu.ppy.sh/oauth/token";
 const userEndpoint = "https://osu.ppy.sh/api/v2/me";
@@ -10,7 +10,7 @@ export class Osu {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { clientSecret: true });
             this.clientId = this.auth.clientId;
@@ -64,13 +64,12 @@ export class Osu {
         const state = generateOAuthState();
         const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
         const payload = {};
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        await resolveOAuthState(auth.store, state, saved);
+        resolveOAuthState(state, saved);
         const tokens = await this.validateAuthorizationCode(code);
         const profile = await fetchUserProfile(userEndpoint, tokens.accessToken());
         return {

package/dist/providers/patreon.d.ts

@@ -7,11 +7,11 @@ export declare class Patreon {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: PatreonOptions);
+    constructor(options?: PatreonOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string, scopes: string[]): URL;
     validateAuthorizationCode(code: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/patreon.js

@@ -1,5 +1,5 @@
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthState, OAuthProviderError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const authorizationEndpoint = "https://www.patreon.com/oauth2/authorize";
 const tokenEndpoint = "https://www.patreon.com/api/oauth2/token";
 const identityEndpoint = "https://www.patreon.com/api/oauth2/v2/identity";
@@ -10,7 +10,7 @@ export class Patreon {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -63,13 +63,12 @@ export class Patreon {
         const state = generateOAuthState();
         const url = this.createAuthorizationURL(state, resolveScopes(scopes, auth, defaultScopes));
         const payload = {};
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
-        const auth = requireAuthConfig(this.auth);
+        requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        await resolveOAuthState(auth.store, state, saved);
+        resolveOAuthState(state, saved);
         const tokens = await this.validateAuthorizationCode(code);
         const url = new URL(identityEndpoint);
         url.searchParams.set("fields[user]", "email,full_name,image_url");

package/dist/providers/polar.d.ts

@@ -7,12 +7,12 @@ export declare class Polar {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: PolarOptions);
+    constructor(options?: PolarOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
     createAuthorizationURL(state: string, codeVerifier: string, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string): Promise<OAuth2Tokens>;
     refreshAccessToken(refreshToken: string): Promise<OAuth2Tokens>;
     revokeToken(token: string): Promise<void>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }