Class ScuteSession`Abstract`

Hierarchy

ScuteSession

Index

Constructors

constructor

Constructors

constructor

new ScuteSession(): ScuteSession
Returns ScuteSession

Properties

`Protected` `Abstract` `Internal` admin

admin: ScuteAdminApi

`Protected` autoRefreshTicker

autoRefreshTicker: null | Timer = null

`Protected` `Abstract` `Internal` config

config: {
    autoRefreshToken: boolean;
    persistSession: undefined | boolean;
    refetchInverval: undefined | number;
    refetchOnWindowFocus: undefined | boolean;
}

Type declaration

autoRefreshToken: boolean
persistSession: undefined | boolean
refetchInverval: undefined | number
refetchOnWindowFocus: undefined | boolean

`Protected` refreshDeferred

refreshDeferred: null | Deferred<{
    data: null;
    error: BaseHttpError;
} | {
    data: Session;
    error: null;
}> = null

`Protected` refreshProxyCallback

refreshProxyCallback: null | (() => Promise<void | Partial<ScuteTokenPayload>>) = null

Type declaration

- (): Promise<void | Partial<ScuteTokenPayload>>
- Returns Promise<void | Partial<ScuteTokenPayload>>

`Protected` `Abstract` `Internal` scuteStorage

scuteStorage: ScuteStorage | ScuteCookieStorage

`Protected` visibilityChangedCallback

visibilityChangedCallback: null | (() => Promise<any>) = null

Type declaration

- (): Promise<any>
- Returns Promise<any>

Methods

`Private` __refresh

__refresh(session): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: Session;
    error: null;
}>
Internal
Parameters
- session: Session
  
  {Session}
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: Session;
    error: null;
}>

See
refreshSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:527

`Private` _autoRefreshTokenTick

_autoRefreshTokenTick(): Promise<void>
Runs the auto refresh token tick.

Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:469

`Private` _expireSession

_expireSession(): Promise<Session>
Expire the current sesion.

Returns Promise<Session>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:344

`Protected` _getAuthToken

_getAuthToken(session): Promise<{
    data: null;
    error: InvalidAuthTokenError;
} | {
    data: {
        access: string;
    };
    error: null;
}>
Internal
Get access token from the current session.
Parameters
- session: Session
  
  {Session}
Returns Promise<{
    data: null;
    error: InvalidAuthTokenError;
} | {
    data: {
        access: string;
    };
    error: null;
}>

See
getAuthToken
- Defined in packages/auth/core/src/lib/ScuteSession.ts:405

`Private` _getCredentialIds

_getCredentialIds(store, userId): string[]
Internal
Parameters
- store: Record<UniqueIdentifier, string[]>
- userId: UniqueIdentifier
Returns string[]

See
getCredentialIds
- Defined in packages/auth/core/src/lib/ScuteSession.ts:790

`Private` _getCredentialStore

_getCredentialStore(): Promise<Record<UniqueIdentifier, string[]>>
Internal
Get credential store for new device checks.

Returns Promise<Record<UniqueIdentifier, string[]>>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:737

`Protected` _getSession

_getSession(fresh?, emitRefetchEvent?): Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
} | {
    data: {
        session: null;
        user: null;
    };
    error: ScuteError;
} | {
    data: {
        session: Session;
        user: null;
    };
    error: null;
}>
Internal
- fresh needs to be set to true to get the latest data from the server.
Parameters
- Optional fresh: boolean
  
  Fetch new data from the server
- emitRefetchEvent: boolean = true
  
  Emit refetch event when getting fresh data
Returns Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
} | {
    data: {
        session: null;
        user: null;
    };
    error: ScuteError;
} | {
    data: {
        session: Session;
        user: null;
    };
    error: null;
}>

See
getSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:87

`Private` _handleGetCurrentUserError

_handleGetCurrentUserError(error): Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: ScuteError;
}>
Internal
Handle refetch session (getCurrentUser) error
Parameters
- error: ScuteError
Returns Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: ScuteError;
}>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:580

`Private` _handleRefreshError

_handleRefreshError(error): Promise<{
data: null;
error: ScuteError;
}>
Internal
Handle refresh session error
Parameters
- error: ScuteError
Returns Promise<{
data: null;
error: ScuteError;
}>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:593

`Protected` `Abstract` _initialize

_initialize(...params): Promise<{
error: null | ScuteError;
}>
Internal
Parameters
- Rest ...params: []
Returns Promise<{
error: null | ScuteError;
}>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:53

`Private` _onVisibilityChanged

_onVisibilityChanged(isInitial): Promise<void>
Callback registered with window.addEventListener('visibilitychange').
Parameters
- isInitial: boolean
Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:658

`Private` _refetchSession

_refetchSession(session, emitEvent?): Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
}>
Internal
Parameters
- session: Session
  
  {Session}
- emitEvent: boolean = true
Returns Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
}>

See
refetchSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:206

`Private` _refresh

_refresh(...params): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: Session;
    error: null;
}>
Internal
Parameters
- Rest ...params: [session: Session]
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: Session;
    error: null;
}>

See
__refresh
- Defined in packages/auth/core/src/lib/ScuteSession.ts:508

`Protected` `Abstract` _refreshRequest

_refreshRequest(...params): Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
Internal
Parameters
- Rest ...params: [jwt: string]
Returns Promise<{
    data: null;
    error: BaseHttpError;
} | {
    data: ScuteTokenPayload;
    error: null;
}>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:43

`Private` _removeVisibilityChangedCallback

_removeVisibilityChangedCallback(): void
Removes any registered visibilitychange callback.

Returns void
See
- startAutoRefresh
- stopAutoRefresh
- Defined in packages/auth/core/src/lib/ScuteSession.ts:646

`Private` _saveCredentialStore

_saveCredentialStore(value): Promise<void>
Internal
Save credential store value string
Parameters
- value: string
  
  Store value string
Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:759

`Private` _saveSession

_saveSession(state): Promise<void>
Internal
Save session to the storage.
Parameters
- state: AuthenticatedSession
  
  {AuthenticatedSession}
Returns Promise<void>

See
setSession
- Defined in packages/auth/core/src/lib/ScuteSession.ts:298

`Protected` _signOut

_signOut(accessToken?): Promise<boolean>
Internal
Sign out.
Parameters
- Optional accessToken: null | string
Returns Promise<boolean>

See
signOut
- Defined in packages/auth/core/src/lib/ScuteSession.ts:361

`Private` _startAutoRefresh

_startAutoRefresh(): Promise<void>
Internal
Returns Promise<void>

See
startAutoRefresh
- Defined in packages/auth/core/src/lib/ScuteSession.ts:434

`Private` _stopAutoRefresh

_stopAutoRefresh(): Promise<void>
Internal
Returns Promise<void>

See
stopAutoRefresh
- Defined in packages/auth/core/src/lib/ScuteSession.ts:455

clearRememberedIdentifier

clearRememberedIdentifier(): Promise<void>
Clear remembered (last logged) identifier.

Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:701

`Protected` `Abstract` debug

debug(...params): void
Internal
Parameters
- Rest ...params: any[]
Returns void
- Defined in packages/auth/core/src/lib/ScuteSession.ts:58

`Protected` deleteCredentialId

deleteCredentialId(userId, credentialId): Promise<void>
Internal
Delete credential id.
Parameters
- userId: UniqueIdentifier
  
  {UniqueIdentifier}
- credentialId: UniqueIdentifier
  
  {UniqueIdentifier}
Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:835

`Protected` `Abstract` emitAuthChangeEvent

emitAuthChangeEvent(...params): void
Internal
Parameters
- Rest ...params: [event: AuthChangeEvent, session?: null | Session, user?: null | ScuteUserData]
Returns void
- Defined in packages/auth/core/src/lib/ScuteSession.ts:48

`Protected` getCredentialIds

getCredentialIds(userId): Promise<string[]>
Internal
Get all stored credential ids as array.
Parameters
- userId: UniqueIdentifier
  
  {UniqueIdentifier}
Returns Promise<string[]>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:777

`Protected` `Abstract` getCurrentUser

getCurrentUser(...params): Promise<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>
Internal
Parameters
- Rest ...params: [accessToken: string]
Returns Promise<{
    data: {
        user: null;
    };
    error: BaseHttpError | InvalidAuthTokenError;
} | {
    data: {
        user: ScuteUserData;
    };
    error: null;
}>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:38

getRememberedIdentifier

getRememberedIdentifier(): Promise<null | string>
Get remembered (last logged) identifier.

Returns Promise<null | string>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:685

getSession

getSession(): Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
} | {
    data: {
        session: null;
        user: null;
    };
    error: ScuteError;
} | {
    data: {
        session: Session;
        user: null;
    };
    error: null;
}>
Get current session.

Returns Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
} | {
    data: {
        session: null;
        user: null;
    };
    error: ScuteError;
} | {
    data: {
        session: Session;
        user: null;
    };
    error: null;
}>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:76

`Protected` initialSessionState

initialSessionState(): Promise<Session>
Internal
Get session state from the storage.

Returns Promise<Session>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:155

refetchSession

refetchSession(): Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
}>
Refetch session.

Returns Promise<{
    data: {
        session: Session;
        user: null;
    };
    error: InvalidAuthTokenError;
} | {
    data: {
        session: Session;
        user: ScuteUserData;
    };
    error: null;
}>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:187

refreshSession

refreshSession(): Promise<{
    data: null;
    error: ScuteError;
} | {
    data: Session;
    error: null;
}>
Refresh and save new auth token with current session.

Returns Promise<{
    data: null;
    error: ScuteError;
} | {
    data: Session;
    error: null;
}>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:239

`Protected` registerRefetchInterval

registerRefetchInterval(): Promise<void>
Register refetch interval
- (browser-only)
Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:625

`Protected` registerVisibilityChange

registerVisibilityChange(): Promise<void>
Register callback for visibilitychange browser event.
- (browser-only)
Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:606

`Protected` removeSession

removeSession(): Promise<void>
Remove session from the storage.

Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:325

setRefreshProxyCallback

setRefreshProxyCallback(callback): Promise<void>
Set refresh proxy callback. This is useful when you do not want to pass the refresh token to the client.

Send request to your backend server to refresh session with secret key in callback function.
- Needs backend server
Parameters
- callback: (() => Promise<void | Partial<ScuteTokenPayload>>)
  
  Callback function to
  - - (): Promise<void | Partial<ScuteTokenPayload>>
    - Returns Promise<void | Partial<ScuteTokenPayload>>
Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:385

`Protected` setRememberedIdentifier

setRememberedIdentifier(identifier): Promise<void>
Internal
Parameters
- identifier: string
  
  {ScuteIdentifier}
Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:718

`Protected` setSession

setSession(payload): Promise<Session>
Set session to the storage. If persistence is not disabled session will remain between hard refreshes.
Parameters
- payload: Partial<ScuteTokenPayload>
  
  {ScuteTokenPayload}
Returns Promise<Session>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:258

startAutoRefresh

startAutoRefresh(): Promise<void>
Start auto refresh interval in the background. The session is checked every few seconds.

Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:417

stopAutoRefresh

stopAutoRefresh(): Promise<void>
Stop auto refresh interval in the background (if any).

Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:425

`Protected` storeCredentialId

storeCredentialId(userId, credentialId): Promise<void>
Internal
Store credential id.
Parameters
- userId: UniqueIdentifier
  
  {UniqueIdentifier}
- credentialId: UniqueIdentifier
  
  {UniqueIdentifier}
Returns Promise<void>
- Defined in packages/auth/core/src/lib/ScuteSession.ts:809

Class ScuteSessionAbstract

Hierarchy

Index

Constructors

Properties

Methods

Constructors

constructor

Returns ScuteSession

Properties

Protected Abstract Internal admin

Protected autoRefreshTicker

Protected Abstract Internal config

Type declaration

autoRefreshToken: boolean

persistSession: undefined | boolean

refetchInverval: undefined | number

refetchOnWindowFocus: undefined | boolean

Protected refreshDeferred

Protected refreshProxyCallback

Type declaration

Returns Promise<void | Partial<ScuteTokenPayload>>

Protected Abstract Internal scuteStorage

Protected visibilityChangedCallback

Type declaration

Returns Promise<any>

Methods

Private __refresh

Parameters

session: Session

Returns Promise<{ data: null; error: BaseHttpError; } | { data: Session; error: null; }>

See

Private _autoRefreshTokenTick

Returns Promise<void>

Private _expireSession

Returns Promise<Session>

Protected _getAuthToken

Parameters

session: Session

Returns Promise<{ data: null; error: InvalidAuthTokenError; } | { data: { access: string; }; error: null; }>

See

Private _getCredentialIds

Parameters

store: Record<UniqueIdentifier, string[]>

userId: UniqueIdentifier

Returns string[]

See

Private _getCredentialStore

Returns Promise<Record<UniqueIdentifier, string[]>>

Protected _getSession

Parameters

Optional fresh: boolean

emitRefetchEvent: boolean = true

Returns Promise<{ data: { session: Session; user: null; }; error: InvalidAuthTokenError; } | { data: { session: Session; user: ScuteUserData; }; error: null; } | { data: { session: null; user: null; }; error: ScuteError; } | { data: { session: Session; user: null; }; error: null; }>

See

Private _handleGetCurrentUserError

Parameters

error: ScuteError

Returns Promise<{ data: { session: Session; user: null; }; error: ScuteError; }>

Private _handleRefreshError

Parameters

error: ScuteError

Returns Promise<{ data: null; error: ScuteError; }>

Protected Abstract _initialize

Parameters

Rest ...params: []

Returns Promise<{ error: null | ScuteError; }>

Private _onVisibilityChanged

Parameters

isInitial: boolean

Returns Promise<void>

Private _refetchSession

Parameters

session: Session

emitEvent: boolean = true

Returns Promise<{ data: { session: Session; user: null; }; error: InvalidAuthTokenError; } | { data: { session: Session; user: ScuteUserData; }; error: null; }>

See

Private _refresh

Parameters

Rest ...params: [session: Session]

Class ScuteSession`Abstract`

`Protected` `Abstract` `Internal` admin

`Protected` autoRefreshTicker

`Protected` `Abstract` `Internal` config

`Protected` refreshDeferred

`Protected` refreshProxyCallback

`Protected` `Abstract` `Internal` scuteStorage

`Protected` visibilityChangedCallback

`Private` __refresh

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: Session;
error: null;
}>

`Private` _autoRefreshTokenTick

`Private` _expireSession

`Protected` _getAuthToken

Returns Promise<{
data: null;
error: InvalidAuthTokenError;
} | {
data: {
access: string;
};
error: null;
}>

`Private` _getCredentialIds

`Private` _getCredentialStore

`Protected` _getSession

`Optional` fresh: boolean

Returns Promise<{
data: {
session: Session;
user: null;
};
error: InvalidAuthTokenError;
} | {
data: {
session: Session;
user: ScuteUserData;
};
error: null;
} | {
data: {
session: null;
user: null;
};
error: ScuteError;
} | {
data: {
session: Session;
user: null;
};
error: null;
}>

`Private` _handleGetCurrentUserError

Returns Promise<{
data: {
session: Session;
user: null;
};
error: ScuteError;
}>

`Private` _handleRefreshError

Returns Promise<{
data: null;
error: ScuteError;
}>

`Protected` `Abstract` _initialize

`Rest` ...params: []

Returns Promise<{
error: null | ScuteError;
}>

`Private` _onVisibilityChanged

`Private` _refetchSession

Returns Promise<{
data: {
session: Session;
user: null;
};
error: InvalidAuthTokenError;
} | {
data: {
session: Session;
user: ScuteUserData;
};
error: null;
}>

`Private` _refresh

`Rest` ...params: [session: Session]

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: Session;
error: null;
}>

`Protected` `Abstract` _refreshRequest

`Rest` ...params: [jwt: string]

Returns Promise<{
data: null;
error: BaseHttpError;
} | {
data: ScuteTokenPayload;
error: null;
}>

`Private` _removeVisibilityChangedCallback

`Private` _saveCredentialStore

`Private` _saveSession

`Protected` _signOut

`Optional` accessToken: null | string

`Private` _startAutoRefresh

`Private` _stopAutoRefresh

`Protected` `Abstract` debug

`Rest` ...params: any[]

`Protected` deleteCredentialId

`Protected` `Abstract` emitAuthChangeEvent

`Rest` ...params: [event: AuthChangeEvent, session?: null | Session, user?: null | ScuteUserData]

`Protected` getCredentialIds

`Protected` `Abstract` getCurrentUser

`Rest` ...params: [accessToken: string]

Returns Promise<{
data: {
user: null;
};
error: BaseHttpError | InvalidAuthTokenError;
} | {
data: {
user: ScuteUserData;
};
error: null;
}>

Returns Promise<{
data: {
session: Session;
user: null;
};
error: InvalidAuthTokenError;
} | {
data: {
session: Session;
user: ScuteUserData;
};
error: null;
} | {
data: {
session: null;
user: null;
};
error: ScuteError;
} | {
data: {
session: Session;
user: null;
};
error: null;
}>

`Protected` initialSessionState

Returns Promise<{
data: {
session: Session;
user: null;
};
error: InvalidAuthTokenError;
} | {
data: {
session: Session;
user: ScuteUserData;
};
error: null;
}>

Returns Promise<{
data: null;
error: ScuteError;
} | {
data: Session;
error: null;
}>

`Protected` registerRefetchInterval

`Protected` registerVisibilityChange

`Protected` removeSession