@supabase/gotrue-js 1.22.15 → 1.23.0-next.2

package/src/GoTrueClient.ts

@@ -7,6 +7,7 @@ import {
   removeItemAsync,
   getItemSynchronously,
   getItemAsync,
+  Deferred,
 } from './lib/helpers'
 import {
   GOTRUE_URL,
@@ -52,20 +53,32 @@ export default class GoTrueClient {
   api: GoTrueApi
   /**
    * The currently logged in user or null.
+   * @deprecated use `getUser()` instead
    */
   protected currentUser: User | null
   /**
    * The session object for the currently logged in user or null.
+   * @deprecated use `getSession()` instead
    */
   protected currentSession: Session | null
 
+  /**
+   * The session object for the currently logged in user or null.
+   * Only used if persistSession is false.
+   */
+  protected inMemorySession: Session | null
+
   protected autoRefreshToken: boolean
   protected persistSession: boolean
   protected localStorage: SupportedStorage
   protected multiTab: boolean
   protected stateChangeEmitters: Map<string, Subscription> = new Map()
   protected refreshTokenTimer?: ReturnType<typeof setTimeout>
-  protected networkRetries: number = 0
+  protected networkRetries = 0
+  protected refreshingDeferred: Deferred<{
+    data: Session
+    error: null
+  }> | null = null
 
   /**
    * Create a new client for use in the browser.
@@ -93,6 +106,7 @@ export default class GoTrueClient {
     const settings = { ...DEFAULT_OPTIONS, ...options }
     this.currentUser = null
     this.currentSession = null
+    this.inMemorySession = null
     this.autoRefreshToken = settings.autoRefreshToken
     this.persistSession = settings.persistSession
     this.multiTab = settings.multiTab
@@ -201,6 +215,7 @@ export default class GoTrueClient {
       shouldCreateUser?: boolean
       scopes?: string
       captchaToken?: string
+      queryParams?: { [key: string]: string }
     } = {}
   ): Promise<{
     session: Session | null
@@ -250,6 +265,7 @@ export default class GoTrueClient {
         return this._handleProviderSignIn(provider, {
           redirectTo: options.redirectTo,
           scopes: options.scopes,
+          queryParams: options.queryParams,
         })
       }
       if (oidc) {
@@ -318,6 +334,7 @@ export default class GoTrueClient {
    * Inside a browser context, `user()` will return the user data, if there is a logged in user.
    *
    * For server-side management, you can get a user through `auth.api.getUserByCookie()`
+   * @deprecated use `getUser()` instead
    */
   user(): User | null {
     return this.currentUser
@@ -325,11 +342,81 @@ export default class GoTrueClient {
 
   /**
    * Returns the session data, if there is an active session.
+   * @deprecated use `getSession()` instead
    */
   session(): Session | null {
     return this.currentSession
   }
 
+  /**
+   * Returns the session data, refreshing it if necessary.
+   */
+  async getSession(): Promise<
+    | {
+        session: Session
+        error: null
+      }
+    | {
+        session: null
+        error: ApiError
+      }
+    | {
+        session: null
+        error: null
+      }
+  > {
+    const currentSession = this.persistSession
+      ? ((await getItemAsync(this.localStorage, STORAGE_KEY)) as Session | null)
+      : this.inMemorySession
+
+    if (!currentSession) {
+      return { session: null, error: null }
+    }
+
+    const hasExpired = currentSession.expires_at
+      ? currentSession.expires_at <= Date.now() / 1000
+      : false
+    if (!hasExpired) {
+      return { session: currentSession, error: null }
+    }
+
+    const { data: session, error } = await this._callRefreshToken(currentSession.refresh_token)
+    if (error) {
+      return { session: null, error }
+    }
+
+    return { session, error: null }
+  }
+
+  /**
+   * Returns the user data, refreshing the session if necessary.
+   */
+  async getUser(): Promise<
+    | {
+        user: User
+        error: null
+      }
+    | {
+        user: null
+        error: ApiError
+      }
+    | {
+        user: null
+        error: null
+      }
+  > {
+    const { session, error } = await this.getSession()
+    if (error) {
+      return { user: null, error }
+    }
+
+    if (!session) {
+      return { user: null, error: null }
+    }
+
+    return { user: session.user, error: null }
+  }
+
   /**
    * Force refreshes the session including the user data in case it was updated in a different session.
    */
@@ -404,6 +491,7 @@ export default class GoTrueClient {
   /**
    * Overrides the JWT on the current client. The JWT will then be sent in all subsequent network requests.
    * @param access_token a jwt access token
+   * @deprecated you can use `getSession()` instead as it reads from storage every time (always fresh)
    */
   setAuth(access_token: string): Session {
     this.currentSession = {
@@ -559,11 +647,13 @@ export default class GoTrueClient {
     options: {
       redirectTo?: string
       scopes?: string
+      queryParams?: { [key: string]: string }
     } = {}
   ) {
     const url: string = this.api.getUrlForProvider(provider, {
       redirectTo: options.redirectTo,
       scopes: options.scopes,
+      queryParams: options.queryParams,
     })
 
     try {
@@ -681,6 +771,16 @@ export default class GoTrueClient {
 
   private async _callRefreshToken(refresh_token = this.currentSession?.refresh_token) {
     try {
+      // refreshing is already in progress
+      if (this.refreshingDeferred) {
+        return await this.refreshingDeferred.promise
+      }
+
+      this.refreshingDeferred = new Deferred<{
+        data: Session
+        error: null
+      }>()
+
       if (!refresh_token) {
         throw new Error('No current session.')
       }
@@ -692,7 +792,12 @@ export default class GoTrueClient {
       this._notifyAllSubscribers('TOKEN_REFRESHED')
       this._notifyAllSubscribers('SIGNED_IN')
 
-      return { data, error: null }
+      const result = { data, error: null }
+
+      this.refreshingDeferred.resolve(result)
+      this.refreshingDeferred = null
+
+      return result
     } catch (e) {
       return { data: null, error: e as ApiError }
     }
@@ -710,6 +815,10 @@ export default class GoTrueClient {
     this.currentSession = session
     this.currentUser = session.user
 
+    if (!this.persistSession) {
+      this.inMemorySession = session
+    }
+
     const expiresAt = session.expires_at
     if (expiresAt) {
       const timeNow = Math.round(Date.now() / 1000)
@@ -733,8 +842,16 @@ export default class GoTrueClient {
   private async _removeSession() {
     this.currentSession = null
     this.currentUser = null
-    if (this.refreshTokenTimer) clearTimeout(this.refreshTokenTimer)
-    removeItemAsync(this.localStorage, STORAGE_KEY)
+
+    if (this.persistSession) {
+      removeItemAsync(this.localStorage, STORAGE_KEY)
+    } else {
+      this.inMemorySession = null
+    }
+
+    if (this.refreshTokenTimer) {
+      clearTimeout(this.refreshTokenTimer)
+    }
   }
 
   /**

package/src/lib/helpers.ts

@@ -75,3 +75,28 @@ export const getItemSynchronously = (storage: SupportedStorage, key: string): an
 export const removeItemAsync = async (storage: SupportedStorage, key: string): Promise<void> => {
   isBrowser() && (await storage?.removeItem(key))
 }
+
+/**
+ * A deferred represents some asynchronous work that is not yet finished, which
+ * may or may not culminate in a value.
+ * Taken from: https://github.com/mike-north/types/blob/master/src/async.ts
+ */
+export class Deferred<T = any> {
+  public static promiseConstructor: PromiseConstructor = Promise
+
+  public readonly promise!: PromiseLike<T>
+
+  public readonly resolve!: (value?: T | PromiseLike<T>) => void
+
+  public readonly reject!: (reason?: any) => any
+
+  public constructor() {
+    // eslint-disable-next-line @typescript-eslint/no-extra-semi
+    ;(this as any).promise = new Deferred.promiseConstructor((res, rej) => {
+      // eslint-disable-next-line @typescript-eslint/no-extra-semi
+      ;(this as any).resolve = res
+      // eslint-disable-next-line @typescript-eslint/no-extra-semi
+      ;(this as any).reject = rej
+    })
+  }
+}

package/src/lib/version.ts

@@ -1,2 +1,2 @@
 // generated by genversion
-export const version = '1.22.15'
+export const version = '1.23.0-next.2'