@schibsted/account-sdk-browser 6.0.0-alpha.1 → 6.0.0-alpha.3

package/dist/identity.d.ts

@@ -0,0 +1,323 @@
+import { TinyEmitter } from 'tiny-emitter';
+import { default as Cache } from './cache.js';
+import { default as RESTClient } from './rest-client.js';
+import { LogFunction } from './types/common.js';
+import { IdentityBeforeRedirectCallback, IdentityOptions, VarnishCookieOptions } from './types/identity.js';
+import { LoginOptions, OpenSimplifiedLoginWidget, SimplifiedLoginData, SimplifiedLoginWidgetLoginOptions, SimplifiedLoginWidgetOptions } from './types/login.js';
+import { ConnectedSessionResponse, SessionObjectResponse, SessionResponse } from './types/session.js';
+export { isConnectedSessionResponse, isSessionSuccessResponse } from './session-response.js';
+export type { ConnectedSessionResponse, SessionFailureResponse, SessionObjectResponse, SessionResponse, SessionSuccessResponse, SessionUserId, } from './types/session.js';
+declare global {
+    interface Window {
+        openSimplifiedLoginWidget?: OpenSimplifiedLoginWidget;
+    }
+}
+/**
+ * Provides Identity functionalty to a web page
+ */
+export declare class Identity extends TinyEmitter {
+    _sessionInitiatedSent: boolean;
+    window: Window;
+    clientId: string;
+    sessionStorageCache: Cache;
+    localStorageCache: Cache;
+    redirectUri: string;
+    env: string;
+    log?: LogFunction;
+    callbackBeforeRedirect: IdentityBeforeRedirectCallback;
+    _sessionDomain: string;
+    _enableSessionCaching: boolean;
+    /**
+     * @internal Starts as `{}` before the first `hasSession()` call, then stores the latest
+     * object response from hasSession().
+     */
+    _session: SessionObjectResponse;
+    _spid: RESTClient;
+    _oauthService: RESTClient;
+    _bffService: RESTClient;
+    _sessionService: RESTClient;
+    _globalSessionService: RESTClient;
+    _usedSessionServiceGetSessionEndpoint: 'v2/session' | 'session';
+    _hasSessionInProgress?: false | Promise<SessionResponse>;
+    popup?: Window | null;
+    setVarnishCookie?: boolean;
+    varnishExpiresIn?: number;
+    varnishCookieDomain?: string;
+    /**
+     * @param options
+     * @param options.clientId - Example: "1234567890abcdef12345678"
+     * @param options.sessionDomain - Example: "https://id.site.com"
+     * @param options.redirectUri - Example: "https://site.com"
+     * @param options.env - Schibsted account environment: `PRE` (default), `PRO`, `PRO_NO`, `PRO_FI` or `PRO_DK`
+     * @param options.log - A function that receives debug log information. If not set,
+     * no logging will be done
+     * @param options.window - window object
+     * @param options.callbackBeforeRedirect - callback triggered before session refresh redirect happen
+     * @throws {SDKError} - If any of options are invalid
+     */
+    constructor({ clientId, redirectUri, sessionDomain, env, log, window, callbackBeforeRedirect, }: IdentityOptions);
+    /**
+     * Read tabId from session storage
+     * @private
+     */
+    _getTabId(): number | undefined;
+    /**
+     * Checks if getting session is blocked
+     * @private
+     *
+     */
+    _isSessionCallBlocked(): boolean;
+    /**
+     * Block calls to get session
+     * @private
+     *
+     */
+    _blockSessionCall(): void;
+    /**
+     * Unblocks calls to get session
+     * @private
+     *
+     */
+    _unblockSessionCall(): void;
+    /**
+     * Emits the relevant events based on the previous and new reply from hasSession
+     * @private
+     * @param previous
+     * @param current
+     */
+    _emitSessionEvent(previous: object, current: object): void;
+    /**
+     * Close this.popup if it exists and is open
+     * @private
+     */
+    _closePopup(): void;
+    /**
+     * Set the Varnish cookie (`SP_ID`) when hasSession() is called. Note that most browsers require
+     * that you are on a "real domain" for this to work — so, **not** `localhost`
+     * @param options
+     * @param options.expiresIn Override this to set number of seconds before the varnish
+     * cookie expires. The default is to use the same time that hasSession responses are cached for
+     * @param options.domain Override cookie domain. E.g. «vg.no» instead of «www.vg.no»
+     */
+    enableVarnishCookie(options: VarnishCookieOptions): void;
+    /**
+     * Set the Varnish cookie if configured
+     * @private
+     * @param sessionData
+     */
+    _maybeSetVarnishCookie(sessionData: object): void;
+    /**
+     * Clear the Varnish cookie if configured
+     * @private
+     */
+    _maybeClearVarnishCookie(): void;
+    /**
+     * Clear the Varnish cookie
+     * @private
+     */
+    _clearVarnishCookie(): void;
+    /**
+     * Log used settings and version
+     * @throws {SDKError} - If log method is not provided
+     */
+    logSettings(): void;
+    /**
+     * @summary Queries the hassession endpoint and returns information about the status of the user
+     * @remarks When we send a request to this endpoint, cookies sent along with the request
+     * determines the status of the user.
+     * @throws {SDKError} - If the call to the hasSession service fails in any way (this will happen
+     * if, say, the user is not logged in)
+     * @fires Identity#login
+     * @fires Identity#logout
+     * @fires Identity#userChange
+     * @fires Identity#sessionChange
+     * @fires Identity#notLoggedin
+     * @fires Identity#sessionInit
+     * @fires Identity#statusChange
+     * @fires Identity#error
+     */
+    hasSession(): Promise<SessionResponse>;
+    /**
+     * @summary Allows the client app to check if the user is logged in to Schibsted account
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     */
+    isLoggedIn(): Promise<boolean>;
+    /**
+     * Removes the cached user session.
+     */
+    clearCachedUserSession(): void;
+    /**
+     * @summary Allows the caller to check if the current user is connected to the client_id in
+     * Schibsted account. Being connected means that the user has agreed for their account to be
+     * used by your web app and have accepted the required terms
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @summary Check if the user is connected to the client_id
+     */
+    isConnected(): Promise<boolean>;
+    /**
+     * @summary Returns information about the user
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @throws {SDKError} If the user isn't connected to the merchant
+     * @throws {SDKError} If we couldn't get the user
+     */
+    getUser(): Promise<ConnectedSessionResponse>;
+    /**
+     * @summary
+     * In Schibsted account, there are multiple ways of identifying a user; the `userId`,
+     * `uuid` and `externalId` used for identifying a user-merchant pair (see {@link Identity#getExternalId}).
+     * There are reasons for them all to exist. The `userId` is a numeric identifier, but
+     * since Schibsted account is deployed separately in Norway and Sweden, there are a lot of
+     * duplicates. The `userId` was introduced early, so many sites still need to use them for
+     * legacy reasons. The `uuid` is universally unique, and so — if we could disregard a lot of
+     * Schibsted components depending on the numeric `userId` — it would be a good identifier to use
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @throws {SDKError} If the user isn't connected to the merchant
+     * @return The `userId` field (not to be confused with the `uuid`)
+     */
+    getUserId(): Promise<string>;
+    /**
+     * @function
+     * @summary
+     * Retrieves the external identifier (`externalId`) for the authenticated user.
+     *
+     * In Schibsted Account there are multiple ways of identifying users, however for integrations with
+     * third-parties it's recommended to use `externalId` as it does not disclose
+     * any critical data whilst allowing for user identification.
+     *
+     * `externalId` is merchant-scoped using a pairwise identifier (`pairId`),
+     * meaning the same user's ID will differ between merchants.
+     * Additionally, this identifier is bound to the external party provided as argument.
+     *
+     * @param externalParty
+     * @param optionalSuffix
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @throws {SDKError} If the `pairId` is missing in user session.
+     * @throws {SDKError} If the `externalParty` is not defined
+     * @return The merchant- and 3rd-party-specific `externalId`
+     */
+    getExternalId(externalParty: string, optionalSuffix?: string): Promise<string>;
+    /**
+     * @summary Enables brands to programmatically get the current the SDRN based on the user's session.
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @throws {SDKError} If the SDRN is missing in user session object.
+     */
+    getUserSDRN(): Promise<string>;
+    /**
+     * @summary In Schibsted account, there are two ways of identifying a user; the `userId` and the
+     * `uuid`. There are reasons for them both existing. The `userId` is a numeric identifier, but
+     * since Schibsted account is deployed separately in Norway and Sweden, there are a lot of
+     * duplicates. The `userId` was introduced early, so many sites still need to use them for
+     * legacy reasons. The `uuid` is universally unique, and so — if we could disregard a lot of
+     * Schibsted components depending on the numeric `userId` — it would be a good identifier to use
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @throws {SDKError} If the user isn't connected to the merchant
+     * @return The `uuid` field (not to be confused with the `userId`)
+     */
+    getUserUuid(): Promise<string>;
+    /**
+     * @summary Get basic information about any user currently logged-in to their Schibsted account
+     * in this browser. Can be used to provide context in a continue-as prompt.
+     * @remarks This function relies on the global Schibsted account user session cookie, which
+     * is a third-party cookie and hence might be blocked by the browser (for example due to ITP in
+     * Safari). So there's no guarantee any data is returned, even though a user is logged-in in
+     * the current browser.
+     */
+    getUserContextData(): Promise<SimplifiedLoginData | null>;
+    /**
+     * If a popup is desired, this function needs to be called in response to a user event (like
+     * click or tap) in order to work correctly. Otherwise the popup will be blocked by the
+     * browser's popup blockers and has to be explicitly authorized to be shown.
+     * @summary Perform a login, either using a full-page redirect or a popup
+     * @see https://tools.ietf.org/html/rfc6749#section-4.1.1
+     *
+     * @param options
+     * @param options.state
+     * @param options.acrValues
+     * @param options.scope
+     * @param options.redirectUri
+     * @param options.preferPopup
+     * @param options.loginHint
+     * @param options.tag
+     * @param options.teaser
+     * @param options.maxAge
+     * @param options.locale
+     * @param options.oneStepLogin
+     * @param options.prompt
+     * @param options.xDomainId
+     * @param options.xEnvironmentId
+     * @param options.originCampaign
+     * @return - Reference to popup window if created (or `null` otherwise)
+     */
+    login({ state, acrValues, scope, redirectUri, preferPopup, loginHint, tag, teaser, maxAge, locale, oneStepLogin, prompt, xDomainId, xEnvironmentId, originCampaign, }: LoginOptions): Window | null;
+    /**
+     * @summary Retrieve the sp_id (Varnish ID)
+     * @remarks This function calls {@link Identity#hasSession} internally and thus has the side
+     * effect that it might perform an auto-login on the user
+     * @return - The sp_id string or null (if the server didn't return it)
+     */
+    getSpId(): Promise<string | null>;
+    /**
+     * @summary Logs the user out from the Identity platform
+     * @param redirectUri - Where to redirect the browser after logging out of Schibsted
+     * account
+     */
+    logout(redirectUri?: string): void;
+    /**
+     * Generates the link to the new login page that'll be used in the popup or redirect flow
+     * @param options
+     * @param options.state
+     * @param options.acrValues
+     * @param options.scope
+     * @param options.redirectUri
+     * @param options.loginHint
+     * @param options.tag
+     * @param options.teaser
+     * @param options.maxAge
+     * @param options.locale
+     * @param options.oneStepLogin
+     * @param options.prompt
+     * @param options.xDomainId
+     * @param options.xEnvironmentId
+     * @param options.originCampaign
+     * @return - The url
+     */
+    loginUrl({ state, acrValues, scope, redirectUri, loginHint, tag, teaser, maxAge, locale, oneStepLogin, prompt, xDomainId, xEnvironmentId, originCampaign, }: LoginOptions): string;
+    /**
+     * The url for logging the user out
+     * @param redirectUri
+     * @return url
+     */
+    logoutUrl(redirectUri?: string): string;
+    /**
+     * The account summary page url
+     * @param redirectUri
+     */
+    accountUrl(redirectUri?: string): string;
+    /**
+     * The phone editing page url
+     * @param redirectUri
+     */
+    phonesUrl(redirectUri?: string): string;
+    /**
+     * Function responsible for loading and displaying simplified login widget. How often
+     * widget will be display is up to you. Preferred way would be to show it once per user,
+     * and store that info in localStorage. Widget will be display only if user is logged in to SSO.
+     *
+     * @param loginParams - the same as `options` param for login function. Login will be called on user
+     * continue action. `state` might be string or async function.
+     * @param options - additional configuration of Simplified Login Widget
+     * @fires Identity#simplifiedLoginOpened
+     * @fires Identity#simplifiedLoginCancelled
+     * @throws {SDKError} - If user context data is missing or the widget script cannot be loaded
+     * @return - will resolve to true if widget will be displayed
+     */
+    showSimplifiedLoginWidget(loginParams: SimplifiedLoginWidgetLoginOptions, options?: SimplifiedLoginWidgetOptions): Promise<boolean>;
+}
+export default Identity;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { Account } from './account.js';
+export { createAccountSdk, getAccountSdk } from './account-sdk.js';
+export { default as SDKError } from './sdk-error.js';
+export type { AccountConfig, AccountEventHandler, AccountEventName, AccountSessionEventName, } from './types/account.js';
+export type { AccountEnvironment, LogFunction } from './types/common.js';
+export type { LoginOptions, SimplifiedLoginData, SimplifiedLoginWidgetLoginOptions, SimplifiedLoginWidgetOptions, } from './types/login.js';
+export type { HasAccessResult } from './types/monetization.js';
+export type { ConnectedSessionResponse, ConnectedSessionWithUserIdResponse, RedirectSessionResponse, SessionFailureResponse, SessionResponse, SessionSuccessResponse, SessionUserId, } from './types/session.js';