antarctic 0.6.0 → 0.7.0

package/dist/providers/etsy.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://www.etsy.com/oauth/connect";
 const tokenEndpoint = "https://api.etsy.com/v3/public/oauth/token";
 const meEndpoint = "https://openapi.etsy.com/v3/application/users/me";
@@ -9,7 +9,7 @@ const defaultScopes = ["email_r"];
 export class Etsy {
     client;
     auth = null;
-    constructor(clientIdOrOptions, redirectURI) {
+    constructor(clientIdOrOptions = {}, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { redirectURI: true });
             this.client = new OAuth2Client(this.auth.clientId, null, this.auth.redirectURI);
@@ -36,13 +36,12 @@ export class Etsy {
         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);
         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/facebook.d.ts

@@ -7,10 +7,10 @@ export declare class Facebook {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: FacebookOptions);
+    constructor(options?: FacebookOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     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/facebook.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.facebook.com/v16.0/dialog/oauth";
 const tokenEndpoint = "https://graph.facebook.com/v16.0/oauth/access_token";
 const userEndpoint = "https://graph.facebook.com/v16.0/me";
@@ -10,7 +10,7 @@ export class Facebook {
     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 Facebook {
         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(userEndpoint);
         url.searchParams.set("fields", "id,name,email,picture.width(256)");

package/dist/providers/figma.d.ts

@@ -5,11 +5,11 @@ export interface FigmaOptions extends ProviderOptions {
 export declare class Figma {
     private client;
     private auth;
-    constructor(options: FigmaOptions);
+    constructor(options?: FigmaOptions);
     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/figma.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.figma.com/oauth";
 const tokenEndpoint = "https://api.figma.com/v1/oauth/token";
 const refreshEndpoint = "https://api.figma.com/v1/oauth/refresh";
@@ -9,7 +9,7 @@ const defaultScopes = ["current_user:read"];
 export class Figma {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -38,13 +38,12 @@ export class Figma {
         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/gitea.d.ts

@@ -9,11 +9,11 @@ export declare class Gitea {
     private baseURL;
     private client;
     private auth;
-    constructor(options: GiteaOptions);
+    constructor(options?: GiteaOptions);
     constructor(baseURL: 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>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/gitea.js

@@ -1,6 +1,6 @@
 import { CodeChallengeMethod, OAuth2Client } 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 = "GITEA";
 const defaultScopes = ["read:user"];
 export class Gitea {
@@ -9,7 +9,7 @@ export class Gitea {
     baseURL;
     client;
     auth = null;
-    constructor(baseURLOrOptions, clientId, clientSecret, redirectURI) {
+    constructor(baseURLOrOptions = {}, clientId, clientSecret, redirectURI) {
         if (typeof baseURLOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, baseURLOrOptions, { redirectURI: true });
             this.baseURL = requireProviderOption(baseURLOrOptions.baseURL, envPrefix, "BASE_URL", "baseURL");
@@ -40,13 +40,12 @@ export class Gitea {
         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/github.d.ts

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

@@ -1,6 +1,6 @@
 import { ArcticFetchError, createOAuth2Request, createOAuth2RequestError, encodeBasicCredentials, UnexpectedErrorResponseBodyError, UnexpectedResponseError } from "../request.js";
 import { OAuth2Tokens } from "../oauth2.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://github.com/login/oauth/authorize";
 const tokenEndpoint = "https://github.com/login/oauth/access_token";
 const userEndpoint = "https://api.github.com/user";
@@ -12,7 +12,7 @@ export class GitHub {
     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;
@@ -66,13 +66,12 @@ export class GitHub {
         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 accessToken = tokens.accessToken();
         const profile = await fetchUserProfile(userEndpoint, accessToken);

package/dist/providers/gitlab.d.ts

@@ -10,12 +10,12 @@ export declare class GitLab {
     private baseURL;
     private client;
     private auth;
-    constructor(options: GitLabOptions);
+    constructor(options?: GitLabOptions);
     constructor(baseURL: string, clientId: string, clientSecret: string | null, redirectURI: string);
     createAuthorizationURL(state: string, scopes: string[]): URL;
     validateAuthorizationCode(code: 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/gitlab.js

@@ -1,6 +1,6 @@
 import { OAuth2Client } from "../client.js";
 import { joinURIAndPath } from "../request.js";
-import { extractOAuthTokens, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthState, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const envPrefix = "GITLAB";
 const defaultScopes = ["openid", "profile", "email"];
 export class GitLab {
@@ -10,7 +10,7 @@ export class GitLab {
     baseURL;
     client;
     auth = null;
-    constructor(baseURLOrOptions, clientId, clientSecret, redirectURI) {
+    constructor(baseURLOrOptions = {}, clientId, clientSecret, redirectURI) {
         if (typeof baseURLOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, baseURLOrOptions, { redirectURI: true });
             this.baseURL = requireProviderOption(baseURLOrOptions.baseURL, envPrefix, "BASE_URL", "baseURL");
@@ -44,13 +44,12 @@ export class GitLab {
         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);
         // GitLab id_tokens omit profile claims, so always use the OIDC userinfo endpoint.
         const userinfoEndpoint = joinURIAndPath(this.baseURL, "/oauth/userinfo");

package/dist/providers/google.d.ts

@@ -5,12 +5,12 @@ export interface GoogleOptions extends ProviderOptions {
 export declare class Google {
     private client;
     private auth;
-    constructor(options: GoogleOptions);
+    constructor(options?: GoogleOptions);
     constructor(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): 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/google.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://accounts.google.com/o/oauth2/v2/auth";
 const tokenEndpoint = "https://oauth2.googleapis.com/token";
 const tokenRevocationEndpoint = "https://oauth2.googleapis.com/revoke";
@@ -10,7 +10,7 @@ const defaultScopes = ["openid", "profile", "email"];
 export class Google {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -43,13 +43,12 @@ export class Google {
         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/intuit.d.ts

@@ -5,12 +5,12 @@ export interface IntuitOptions extends ProviderOptions {
 export declare class Intuit {
     private client;
     private auth;
-    constructor(options: IntuitOptions);
+    constructor(options?: IntuitOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     createAuthorizationURL(state: string, scopes: string[]): URL;
     validateAuthorizationCode(code: 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/intuit.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://appcenter.intuit.com/connect/oauth2";
 const tokenEndpoint = "https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer";
 const tokenRevocationEndpoint = "https://developer.API.intuit.com/v2/oauth2/tokens/revoke";
@@ -9,7 +9,7 @@ const defaultScopes = ["openid", "profile", "email"];
 export class Intuit {
     client;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -41,13 +41,12 @@ export class Intuit {
         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);
         // Intuit id_tokens omit profile claims, so always use the OIDC userinfo endpoint.
         const claims = await fetchUserProfile(userinfoEndpoint, tokens.accessToken());

package/dist/providers/kakao.d.ts

@@ -7,11 +7,11 @@ export declare class Kakao {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: KakaoOptions);
+    constructor(options?: KakaoOptions);
     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/kakao.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://kauth.kakao.com/oauth/authorize";
 const tokenEndpoint = "https://kauth.kakao.com/oauth/token";
 const userEndpoint = "https://kapi.kakao.com/v2/user/me";
@@ -10,7 +10,7 @@ export class Kakao {
     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 Kakao {
         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 name = null;

package/dist/providers/keycloak.d.ts

@@ -10,12 +10,12 @@ export declare class KeyCloak {
     private userinfoEndpoint;
     private client;
     private auth;
-    constructor(options: KeyCloakOptions);
+    constructor(options?: KeyCloakOptions);
     constructor(realmURL: 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/keycloak.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, resolveScopes, saveOAuthState } from "../auth.js";
+import { extractOAuthTokens, fetchUserProfile, generateOAuthCodeVerifier, generateOAuthState, InvalidOAuthCallbackError, parseCallbackQuery, profileId, profileString, requireAuthConfig, requireProviderOption, resolveAuthConfig, resolveOAuthState, resolveScopes } from "../auth.js";
 const envPrefix = "KEYCLOAK";
 const defaultScopes = ["openid", "profile", "email"];
 export class KeyCloak {
@@ -10,7 +10,7 @@ export class KeyCloak {
     userinfoEndpoint;
     client;
     auth = null;
-    constructor(realmURLOrOptions, clientId, clientSecret, redirectURI) {
+    constructor(realmURLOrOptions = {}, clientId, clientSecret, redirectURI) {
         let realmURL;
         if (typeof realmURLOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, realmURLOrOptions, { redirectURI: true });
@@ -47,13 +47,12 @@ export class KeyCloak {
         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/kick.d.ts

@@ -7,12 +7,12 @@ export declare class Kick {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: KickOptions);
+    constructor(options?: KickOptions);
     constructor(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): 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/kick.js

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

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

@@ -1,5 +1,5 @@
 import { OAuth2Client, CodeChallengeMethod } 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://lichess.org/oauth";
 const tokenEndpoint = "https://lichess.org/api/token";
 const accountEndpoint = "https://lichess.org/api/account";
@@ -9,7 +9,7 @@ const defaultScopes = ["email:read"];
 export class Lichess {
     client;
     auth = null;
-    constructor(clientIdOrOptions, redirectURI) {
+    constructor(clientIdOrOptions = {}, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, { redirectURI: true });
             this.client = new OAuth2Client(this.auth.clientId, null, this.auth.redirectURI);
@@ -32,13 +32,12 @@ export class Lichess {
         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/line.d.ts

@@ -7,11 +7,11 @@ export declare class Line {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: LineOptions);
+    constructor(options?: LineOptions);
     constructor(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): Promise<OAuth2Tokens>;
     getAuthorizationURL(scopes?: string[]): Promise<AuthorizationRequest>;
-    getUser(query: OAuthCallbackQuery, saved?: SavedOAuthState): Promise<OAuthUser>;
+    getUser(query: OAuthCallbackQuery, saved: SavedOAuthState): Promise<OAuthUser>;
 }

package/dist/providers/line.js

@@ -1,7 +1,7 @@
 import { createS256CodeChallenge } from "../oauth2.js";
 import { createOAuth2Request, sendTokenRequest } from "../request.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://access.line.me/oauth2/v2.1/authorize";
 const tokenEndpoint = "https://api.line.me/oauth2/v2.1/token";
 const userinfoEndpoint = "https://api.line.me/oauth2/v2.1/userinfo";
@@ -12,7 +12,7 @@ export class Line {
     clientSecret;
     redirectURI;
     auth = null;
-    constructor(clientIdOrOptions, clientSecret, redirectURI) {
+    constructor(clientIdOrOptions = {}, clientSecret, redirectURI) {
         if (typeof clientIdOrOptions === "object") {
             this.auth = resolveAuthConfig(envPrefix, clientIdOrOptions, {
                 clientSecret: true,
@@ -70,13 +70,12 @@ export class Line {
         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/linear.d.ts

@@ -7,10 +7,10 @@ export declare class Linear {
     private clientSecret;
     private redirectURI;
     private auth;
-    constructor(options: LinearOptions);
+    constructor(options?: LinearOptions);
     constructor(clientId: string, clientSecret: string, redirectURI: string);
     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>;
 }