antarctic 0.6.0 → 0.7.0

package/dist/providers/polar.js

@@ -1,6 +1,6 @@
 import { createS256CodeChallenge } from "../oauth2.js";
 import { createOAuth2Request, sendTokenRequest, sendTokenRevocationRequest } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const authorizationEndpoint = "https://polar.sh/oauth2/authorize";
 const tokenEndpoint = "https://api.polar.sh/v1/oauth2/token";
 const tokenRevocationEndpoint = "https://api.polar.sh/v1/oauth2/revoke";
@@ -13,7 +13,7 @@ export class Polar {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { redirectURI: true });
             this.clientId = this.auth.clientId;
@@ -78,13 +78,12 @@ export class Polar {
         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/reddit.d.ts

@@ -5,11 +5,11 @@ export interface RedditOptions extends ProviderOptions {
 export declare class Reddit {
     private client;
     private auth;
-    constructor(options: RedditOptions);
+    constructor(options?: RedditOptions);
     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/reddit.js

@@ -1,5 +1,5 @@
 import { OAuth2Client } from "../client.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.reddit.com/api/v1/authorize";
 const tokenEndpoint = "https://www.reddit.com/api/v1/access_token";
 const userEndpoint = "https://oauth.reddit.com/api/v1/me";
@@ -8,7 +8,7 @@ const defaultScopes = ["identity"];
 export class Reddit {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -37,13 +37,12 @@ export class Reddit {
         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/roblox.d.ts

@@ -5,12 +5,12 @@ export interface RobloxOptions extends ProviderOptions {
 export declare class Roblox {
     private client;
     private auth;
-    constructor(options: RobloxOptions);
+    constructor(options?: RobloxOptions);
     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>;
 }

package/dist/providers/roblox.js

@@ -1,6 +1,6 @@
 import { OAuth2Client, CodeChallengeMethod } from "../client.js";
 import { decodeIdToken } from "../oidc.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const authorizationEndpoint = "https://apis.roblox.com/oauth/v1/authorize";
 const tokenEndpoint = "https://apis.roblox.com/oauth/v1/token";
 const tokenRevocationEndpoint = "https://apis.roblox.com/oauth/v1/token/revoke";
@@ -10,7 +10,7 @@ const defaultScopes = ["openid", "profile"];
 export class Roblox {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { redirectURI: true });
             this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
@@ -40,13 +40,12 @@ export class Roblox {
         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/salesforce.d.ts

@@ -10,12 +10,12 @@ export declare class Salesforce {
     private userinfoEndpoint;
     private client;
     private auth;
-    constructor(options: SalesforceOptions);
+    constructor(options?: SalesforceOptions);
     constructor(domain: 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): 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/salesforce.js

@@ -1,6 +1,6 @@
 import { OAuth2Client, CodeChallengeMethod } from "../client.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 envPrefix = "SALESFORCE";
 const defaultScopes = ["openid", "profile", "email"];
 export class Salesforce {
@@ -10,7 +10,7 @@ export class Salesforce {
     userinfoEndpoint;
     client;
     auth = null;
-    constructor(domainOrOptions, clientId, clientSecret, redirectURI) {
+    constructor(domainOrOptions = {}, clientId, clientSecret, redirectURI) {
         let domain;
         if (typeof domainOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, domainOrOptions, { redirectURI: true });
@@ -47,13 +47,12 @@ export class Salesforce {
         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/shikimori.d.ts

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

package/dist/providers/shikimori.js

@@ -1,5 +1,5 @@
 import { createOAuth2Request, sendTokenRequest } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState } from "../auth.js";
 const authorizationEndpoint = "https://shikimori.one/oauth/authorize";
 const tokenEndpoint = "https://shikimori.one/oauth/token";
 const userEndpoint = "https://shikimori.one/api/users/whoami";
@@ -9,7 +9,7 @@ export class Shikimori {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -55,17 +55,16 @@ export class Shikimori {
         return tokens;
     }
     async getAuthorizationURL() {
-        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);
         const profile = await fetchUserProfile(userEndpoint, tokens.accessToken());
         let image = null;

package/dist/providers/slack.d.ts

@@ -5,10 +5,10 @@ export interface SlackOptions extends ProviderOptions {
 export declare class Slack {
     private client;
     private auth;
-    constructor(options: SlackOptions);
+    constructor(options?: SlackOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string | null);
     createAuthorizationURL(state: string, scopes: 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/slack.js

@@ -1,6 +1,6 @@
 import { OAuth2Client } from "../client.js";
 import { decodeIdToken } from "../oidc.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://slack.com/openid/connect/authorize";
 const tokenEndpoint = "https://slack.com/api/openid.connect.token";
 const userinfoEndpoint = "https://slack.com/api/openid.connect.userInfo";
@@ -9,7 +9,7 @@ const defaultScopes = ["openid", "profile", "email"];
 export class Slack {
     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);
@@ -31,13 +31,12 @@ export class Slack {
         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/spotify.d.ts

@@ -5,11 +5,11 @@ export interface SpotifyOptions extends ProviderOptions {
 export declare class Spotify {
     private client;
     private auth;
-    constructor(options: SpotifyOptions);
+    constructor(options?: SpotifyOptions);
     constructor(clientId: string, clientSecret: string | null, redirectURI: string);
     createAuthorizationURL(state: string, codeVerifier: string | null, scopes: string[]): Promise<URL>;
     validateAuthorizationCode(code: string, codeVerifier: string | null): 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/spotify.js

@@ -1,5 +1,5 @@
 import { CodeChallengeMethod, OAuth2Client } from "../client.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const authorizationEndpoint = "https://accounts.spotify.com/authorize";
 const tokenEndpoint = "https://accounts.spotify.com/api/token";
 const userEndpoint = "https://api.spotify.com/v1/me";
@@ -8,7 +8,7 @@ const defaultScopes = ["user-read-email", "user-read-private"];
 export class Spotify {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { redirectURI: true });
             this.client = new OAuth2Client(this.auth.clientId, this.auth.clientSecret, this.auth.redirectURI);
@@ -41,13 +41,12 @@ export class Spotify {
         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/startgg.d.ts

@@ -7,11 +7,11 @@ export declare class StartGG {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: StartGGOptions);
+    constructor(options?: StartGGOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string, scopes: string[]): URL;
     validateAuthorizationCode(code: string, scopes: 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/startgg.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://start.gg/oauth/authorize";
 const tokenEndpoint = "https://api.start.gg/oauth/access_token";
 const refreshEndpoint = "https://api.start.gg/oauth/refresh";
@@ -59,7 +59,7 @@ export class StartGG {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -120,13 +120,12 @@ export class StartGG {
         const resolved = resolveScopes(scopes, auth, defaultScopes);
         const url = this.createAuthorizationURL(state, resolved);
         const payload = { scopes: resolved };
-        await saveOAuthState(auth.store, state, payload);
         return { url, state, payload };
     }
     async getUser(query, saved) {
         const auth = requireAuthConfig(this.auth);
         const { code, state } = parseCallbackQuery(query);
-        const stored = await resolveOAuthState(auth.store, state, saved);
+        const stored = resolveOAuthState(state, saved);
         const tokens = await this.validateAuthorizationCode(code, stored.scopes ?? resolveScopes(undefined, auth, defaultScopes));
         const profile = await fetchCurrentUser(tokens.accessToken());
         let image = null;

package/dist/providers/strava.d.ts

@@ -7,11 +7,11 @@ export declare class Strava {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: StravaOptions);
+    constructor(options?: StravaOptions);
     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/strava.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://www.strava.com/oauth/authorize";
 const tokenEndpoint = "https://www.strava.com/api/v3/oauth/token";
 const userEndpoint = "https://www.strava.com/api/v3/athlete";
@@ -10,7 +10,7 @@ export class Strava {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -64,13 +64,12 @@ export class Strava {
         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());
         const firstName = profileString(profile.firstname);

package/dist/providers/tiktok.d.ts

@@ -7,12 +7,12 @@ export declare class TikTok {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: TikTokOptions);
+    constructor(options?: TikTokOptions);
     constructor(clientKey: string, clientSecret: string, 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>;
 }

package/dist/providers/tiktok.js

@@ -1,6 +1,6 @@
 import { createS256CodeChallenge } from "../oauth2.js";
 import { createOAuth2Request, sendTokenRequest, sendTokenRevocationRequest } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const authorizationEndpoint = "https://www.tiktok.com/v2/auth/authorize";
 const tokenEndpoint = "https://open.tiktokapis.com/v2/oauth/token/";
 const tokenRevocationEndpoint = "https://open.tiktokapis.com/v2/oauth/revoke/";
@@ -12,7 +12,7 @@ export class TikTok {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientKeyOrOptions, clientSecret, redirectURI) {
+    constructor(clientKeyOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientKeyOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientKeyOrOptions, {
                 clientSecret: true,
@@ -78,13 +78,12 @@ export class TikTok {
         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/tiltify.d.ts

@@ -7,11 +7,11 @@ export declare class Tiltify {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: TiltifyOptions);
+    constructor(options?: TiltifyOptions);
     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/tiltify.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://v5api.tiltify.com/oauth/authorize";
 const tokenEndpoint = "https://v5api.tiltify.com/oauth/token";
 const userEndpoint = "https://v5api.tiltify.com/api/public/current-user";
@@ -10,7 +10,7 @@ export class Tiltify {
     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 Tiltify {
         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());
         let user = {};

package/dist/providers/tumblr.d.ts

@@ -5,11 +5,11 @@ export interface TumblrOptions extends ProviderOptions {
 export declare class Tumblr {
     private client;
     private auth;
-    constructor(options: TumblrOptions);
+    constructor(options?: TumblrOptions);
     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/tumblr.js

@@ -1,5 +1,5 @@
 import { OAuth2Client } from "../client.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.tumblr.com/oauth2/authorize";
 const tokenEndpoint = "https://api.tumblr.com/v2/oauth2/token";
 const userEndpoint = "https://api.tumblr.com/v2/user/info";
@@ -8,7 +8,7 @@ const defaultScopes = ["basic"];
 export class Tumblr {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -37,13 +37,12 @@ export class Tumblr {
         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());
         let user = {};

package/dist/providers/twitch.d.ts

@@ -7,11 +7,11 @@ export declare class Twitch {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: TwitchOptions);
+    constructor(options?: TwitchOptions);
     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/twitch.js

@@ -1,6 +1,6 @@
 // Does not support HTTP Basic Auth scheme.
 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://id.twitch.tv/oauth2/authorize";
 const tokenEndpoint = "https://id.twitch.tv/oauth2/token";
 const userEndpoint = "https://api.twitch.tv/helix/users";
@@ -11,7 +11,7 @@ export class Twitch {
     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 Twitch {
         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);
         // Helix requires the Client-Id header alongside the user access token.
         const profile = await fetchUserProfile(userEndpoint, tokens.accessToken(), {