@trimble-oss/trimble-id-react 0.0.1-rc.1

package/dist/TIDClient/storage/cache-storage/CacheManager.d.ts

@@ -0,0 +1,70 @@
+import { TIDAuthToken, TIDUser } from '../../interfaces';
+export type PersistentStore = 'in-memory' | 'localStorage' | 'sessionStorage';
+export interface CacheManagerOptions {
+    /**
+     * Client id of the application created in trimble developer console
+     * @type {string}
+     */
+    clientId: string;
+    /**
+     * Type persistent you want the user and token to be store
+     * in-memory - This one will only persist will the user stays in the page
+     * localStorage - This persistent doesn't have expiration date
+     * sessionStorage - This one is cleared when the page session ends
+     * @type {PersistentStore}
+     */
+    persistentStore: PersistentStore;
+}
+/** Class to manage the store types */
+export declare class CacheManager {
+    /**
+     * Type persistent you want the user and token to be store
+     * in-memory - This one will only persist will the user stays in the page
+     * localStorage - This persistent doesn't have expiration date
+     * sessionStorage - This one is cleared when the page session ends
+     * @type {PersistentStore}
+     */
+    private readonly persistentStore;
+    /**
+     * Cache option selected
+     * @type {CacheStorage}
+     */
+    private readonly cacheStorage;
+    /**
+     * The cache key represents the keys for storing and retrieving user and token from auth
+     * @type {CacheKey}
+     */
+    private readonly cacheKey;
+    /**
+     * Create a cache manager to extract or save the user, and token
+     * @param {CacheManagerOptions} options - Configuration for the managing the caching
+     */
+    constructor(options: CacheManagerOptions);
+    /**
+     * Store token in cache
+     * @param {TIDAuthToken} token - Token that you want to store in cache
+     * @return {Promise<void>} Empty promise
+     */
+    setToken(token: TIDAuthToken): Promise<void>;
+    /**
+     * Store user in cache
+     * @param {TIDUser} user - User that you want to store in cache
+     * @return {Promise<void>} Empty promise
+     */
+    setUser(user: TIDUser): Promise<void>;
+    /**
+     * Get user store in cache
+     * @return {Promise<TIDUser | undefined>} Key for the user
+     */
+    getUser(): Promise<TIDUser | undefined>;
+    /**
+     * Get token store in cache
+     * @return {Promise<TIDAuthToken | undefined>} Key for the user
+     */
+    getToken(): Promise<TIDAuthToken | undefined>;
+    /**
+     * The clear the cache from the storage
+     * @return {Promise<void>} Empty promise
+     */
+    clear(): Promise<void>;
+}

package/dist/TIDClient/storage/cache-storage/InMemoryCache.d.ts

@@ -0,0 +1,12 @@
+import { CacheStorage } from '../../interfaces';
+/** Class representing in-memory caching store */
+export declare class InMemoryCache {
+    /**
+     * This function generate a encapsulation function to store
+     * the user and token information in a secure way disabled the
+     * access from the outside
+     * @see {https://medium.com/javascript-scene/encapsulation-in-javascript-26be60e325b4} Encapsulation
+     * @return {CacheStorage} Key for the token
+     */
+    generateCache: CacheStorage;
+}

package/dist/TIDClient/storage/cache-storage/LocalStorageCache.d.ts

@@ -0,0 +1,67 @@
+import { CacheStorage, TIDAuthToken, TIDUser } from '../../interfaces';
+import { CacheKey } from './CacheKey';
+export interface LocalStorageCacheOptions {
+    /**
+     * The cache key represents the keys for storing and retrieving user and token from auth
+     * @type {CacheKey}
+     */
+    cacheKey: CacheKey;
+}
+/**
+ * Class representing localstorage caching
+ * NOTE: This type storage do not expired so it will persist even if the user close the browser
+ */
+export declare class LocalStorageCache implements CacheStorage {
+    /**
+     * Local storage from the browser
+     * @type {Storage}
+     */
+    private readonly localStorage;
+    /**
+     * The cache key represents the keys for storing and retrieving user and token from auth
+     * @type {CacheKey}
+     */
+    private readonly cacheKey;
+    /**
+     * Initialized configuration to store information into local storage
+     * @param {LocalStorageCacheOptions} options - Configuration for caching in localstorage
+     */
+    constructor(options: LocalStorageCacheOptions);
+    /**
+     * Get token store in localstorage
+     * @return {Promise<TIDAuthToken | undefined>} - Token store in localstorage
+     */
+    getToken(): Promise<TIDAuthToken | undefined>;
+    /**
+     * Get user store in localstorage
+     * @return {Promise<TIDUser | undefined>}  - User store in localstorage
+     */
+    getUser(): Promise<TIDUser | undefined>;
+    /**
+     * Store token in localstorage
+     * @param {TIDAuthToken} token - Token that you want to store in localstorage
+     * @return {Promise<void>} Empty promise
+     */
+    storeToken(authToken: TIDAuthToken): Promise<void>;
+    /**
+     * Store user in cache
+     * @param {TIDUser} user - User that you want to store in localstorage
+     * @return {Promise<void>} Empty promise
+     */
+    storeUser(user: TIDUser): Promise<void>;
+    /**
+     * Get the full key from the cachekey for the user
+     * @return {string} - Full key to get the token from the localstorage
+     */
+    getUserKey(): string;
+    /**
+     * Get the full key from the cachekey for the token
+     * @return {string} - Full key to get the token from the localstorage
+     */
+    getAuthKey(): string;
+    /**
+     * The clear the cache from the localstorage
+     * @return {Promise<void>} Empty promise
+     */
+    clear(): Promise<void>;
+}

package/dist/TIDClient/storage/cache-storage/SessionStorageCache.d.ts

@@ -0,0 +1,67 @@
+import { CacheStorage, TIDAuthToken, TIDUser } from '../../interfaces';
+import { CacheKey } from './CacheKey';
+export interface SessionStorageCacheOptions {
+    /**
+     * The cache key represents the keys for storing and retrieving user and token from auth
+     * @type {CacheKey}
+     */
+    cacheKey: CacheKey;
+}
+/**
+ * Class representing session storage caching
+ * NOTE: This type storage is cleared when the page session ends
+ */
+export declare class SessionStorageCache implements CacheStorage {
+    /**
+     * Session storage from the browser
+     * @type {Storage}
+     */
+    private readonly sessionStorage;
+    /**
+     * The cache key represents the keys for storing and retrieving user and token from auth
+     * @type {CacheKey}
+     */
+    private readonly cacheKey;
+    /**
+     * Initialized configuration to store information into session storage
+     * @param {SessionStorageCacheOptions} options - Configuration for caching in session storage
+     */
+    constructor(options: SessionStorageCacheOptions);
+    /**
+     * Get token store in session storage
+     * @return {Promise<TIDAuthToken | undefined>} - Token store in session storage
+     */
+    getToken(): Promise<TIDAuthToken | undefined>;
+    /**
+     * Get user store in session storage
+     * @return {Promise<TIDUser | undefined>}  - User store in session storage
+     */
+    getUser(): Promise<TIDUser | undefined>;
+    /**
+     * Store token in session storage
+     * @param {TIDAuthToken} authToken - Token that you want to store in session storage
+     * @return {Promise<void>} Empty promise
+     */
+    storeToken(authToken: TIDAuthToken): Promise<void>;
+    /**
+     * Store user in cache
+     * @param {TIDUser} user - User that you want to store in session storage
+     * @return {Promise<void>} Empty promise
+     */
+    storeUser(user: TIDUser): Promise<void>;
+    /**
+     * Get the full key from the cachekey for the user
+     * @return {string} - Full key to get the token from the session storage
+     */
+    getUserKey(): string;
+    /**
+     * Get the full key from the cachekey for the token
+     * @return {string} - Full key to get the token from the session storage
+     */
+    getAuthKey(): string;
+    /**
+     * The clear the cache from the session storage
+     * @return {Promise<void>} Empty promise
+     */
+    clear(): Promise<void>;
+}

package/dist/TIDClient/storage/cache-storage/constants.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Default value of the prefix key use it to store the token and the user
+ * @type {string}
+ */
+export declare const PREFIX_KEY: string;
+/**
+ * Default value of the suffix key use it to store the token
+ * @type {string}
+ */
+export declare const AUTH_KEY: string;
+/**
+ * Default value of the suffix key use it to store the user
+ * @type {string}
+ */
+export declare const USER_KEY: string;

package/dist/TIDClient/storage/cookies/CookiesManager.d.ts

@@ -0,0 +1,48 @@
+interface CookiesManagerOptions {
+    /**
+     * Client id of the application created in trimble developer console
+     * @type {string}
+     */
+    clientId: string;
+}
+interface CookieValue {
+    /**
+     * Code verifier used for the PKCE workflow
+     * @see {https://docs.trimblecloud.com/identity_v4.0/how-to/grant-flows/authorization-code-pkce/} Authorization Code with PKCE
+     * @type {string}
+     */
+    code_verifier: string;
+}
+/** Class to manage cookies */
+export declare class CookiesManager {
+    /**
+     * Cookie full key to store and retrieve the information from cookies
+     * @type {string}
+     */
+    private readonly cookieKey;
+    /**
+     * Cookie storage. This object contain all functions necessary to retrieve and store tokens using cookies
+     * @type {CookiesStorage}
+     */
+    private readonly cookiesStorage;
+    /**
+     * Create a cookies manager to extract or save cookies in the browser
+     * @param {CookiesManagerOptions} options - Configuration for the managing the cookies
+     */
+    constructor(options: CookiesManagerOptions);
+    /**
+     * Store cookies in the browser
+     * @param {CookieValue} value - information to store
+     */
+    save(value: CookieValue): void;
+    /**
+     * Retrieve cookies in the browser
+     * @return {CookieValue | undefined}  - Cookies from the browser
+     */
+    get(): CookieValue | undefined;
+    /**
+     * Clear information about the cookies stored in the browser
+     */
+    clear(): void;
+}
+export {};

package/dist/TIDClient/storage/cookies/CookiesStorage.d.ts

@@ -0,0 +1,42 @@
+interface CookiesOptions {
+    /**
+     * Number of days until the cookies expire
+     * @type {number}
+     */
+    expires?: number;
+    /**
+     * Domain name to registry the cookies for. By default, is the name of the site
+     * @type {string}
+     */
+    domain?: string;
+}
+/** Class to store cookies in the browser */
+export declare class CookiesStorage {
+    /**
+     * Retrieve a cookie from the browser
+     * @param {string} key - Key to retrieve the cookies
+     */
+    get(key: string): any;
+    /**
+     * Store cookies in the browser
+     * @param {string} key - Key to save and retrieve the cookies
+     * @param {any} value - Information you want to store in cookies
+     * @param {CookiesOptions} options - Additional options you want to add to the cookies.
+     * @example Save cookies with one day of expiration
+     * cookiesStorage.set('key',{data:{...}},{expires:1})
+     * @example Save cookies with a custom domain
+     * cookiesStorage.set('key',{data:{...}},{domain:'https://example.com/subpath'})
+     */
+    set(key: string, value: any, options: CookiesOptions): void;
+    /**
+     * Remove a cookie from the browser
+     * @param {string} key - Key to remove the cookies from the browser
+     * @param {CookiesOptions} options - Additional options used when the cookie was declared
+     * @example Remove cookies without additional information
+     * cookiesStorage.remove('key')
+     * @example Remove cookies with custom domain
+     * cookiesStorage.remove('key',{domain:'https://example.com/subpath'})
+     */
+    remove(key: string, options?: CookiesOptions): void;
+}
+export {};

package/dist/TIDClient/storage/cookies/constants.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Default value of the prefix key use it to store the cookies
+ * @type {string}
+ */
+export declare const PREFIX_KEY: string;

package/dist/TIDClient/utils.d.ts

@@ -0,0 +1,61 @@
+import { TIDJWTUser, TIDUser } from './interfaces';
+/**
+ * Remove the search params from the url
+ * @param {string} url - Url to remove the search params
+ * @return {string} - Url without the search params
+ * @example
+ * removeSearchParams('https://example.com/test?state=fake_state&another_prop=fake_prop')
+ * // will return https://example.com/test
+ * @example
+ * removeSearchParams('https://example.com/test')
+ * // will return https://example.com/test
+ * @example
+ * removeSearchParams('https://example.com/test?state=fake_state&another_prop=fake_prop#hash')
+ * // will return https://example.com/test
+ */
+export declare const removeSearchParams: (url: string) => string;
+/**
+ * Extract the params from the URL.
+ * @param {string} url - Url to extract information
+ * @return {string} - Params of the url
+ * @example
+ * getQueryParams('https://example.com/test?state=fake_state&another_prop=fake_prop')
+ * // will return ?state=fake_state&another_prop=fake_prop
+ */
+export declare const getQueryParams: (url: string) => string;
+/**
+ * Receives an url and converted into URLSearchParams
+ * @param {string} url - Url to extract information
+ * @return {URLSearchParams} - URLSearchParams containing the parameters from the URL
+ * @example Full url
+ * getSearchParams('https://example.com/test?state=fake_state&another_prop=fake_prop')
+ * @example Only params
+ * getSearchParams('?state=fake_state&another_prop=fake_prop')
+ */
+export declare const getSearchParams: (url: string) => URLSearchParams;
+/**
+ * Compare if the url contains the necessary information for the authentication
+ *
+ * Note: The required parameters that the url should contain are the following:
+ * * code
+ * * state
+ * * identity_provider
+ * @param redirectUrl - If the redirect url is provided, it will check if the url starts with the redirect url provided. If not, it will return false
+ * @param {string} url - Url to determined if it has the requirement auth params. By default, takes the url of the browser
+ * @return {boolean} - True or false if the url is valid
+ * @example No url
+ * hasAuthParams() // This will take the url from the browser
+ * @example Valid url
+ * getSearchParams('https://example.com/test?code=fake_code&state=fake_state')
+ * // return true
+ * @example Invalid url
+ * getSearchParams('https://example.com/test?code=fake_code')
+ * // return true
+ */
+export declare const hasAuthParams: (url?: string, redirectUrl?: string) => boolean;
+/**
+ * Converts the raw JWT user returned from TID and converted into a TIDUser
+ * @param {TIDJWTUser} jwtUser - TIDJWTUser to convert
+ * @return {TIDUser} - TIDJWTUser converted into a TIDUser
+ */
+export declare const transformToTIDUser: (jwtUser: TIDJWTUser) => TIDUser;

package/dist/TIDProvider/TIDContext.d.ts

@@ -0,0 +1,83 @@
+import { TIDAuthState } from './state';
+import { AuthState } from '../TIDClient';
+export interface LoginWithRedirectOptions {
+    /**
+     * Function called when the user redirection is occurring
+     * If you send this function you will need to handle the redirection
+     * @param {string} url - Redirect url to TID with the necessary information to log in the user
+     */
+    onRedirect?: (url: string) => void;
+}
+export interface LogoutOptions {
+    /**
+     * Function called when the user redirection is occurring
+     * If you send this function you will need to handle the redirection
+     * @param {string} url - Redirect url to TID with the necessary information to log out the user
+     */
+    onRedirect?: (url: string) => void;
+    /**
+     * If you want to disable the auto redirect to TID after the logout is successful you can set this to true
+     * If you set this to true you will need to handle the redirection and the provider will clear the user information from the context
+     *
+     * **IMPORTANT**: If you set this to true the user information will be cleared from the context and isAuthenticated will be false
+     * if you are using the AuthenticationGuard component it will redirect the user to the login page automatically
+     * @default false
+     * @type {boolean}
+     * @example
+     * logout({disabledAutoRedirect: true})
+     */
+    disabledAutoRedirect?: boolean;
+}
+export interface TIDContextState extends TIDAuthState {
+    /**
+     * Authenticated the user using the url callback params,
+     * After the login is successful will load the user in TIDProvider context
+     * That way it can be access thought the whole react application
+     * @param {string} url - Custom configuration for teh redirection
+     * @return {Promise<AuthState>} Object contain the state returned from TID
+     * @throws {CodeVerifierNotFoundException} Will throw an exception if the session doesn't contain the code verifier
+     * @example No configuration
+     * handleCallback()
+     * // Will automatically take the url from the browser and try to log in the user
+     * @example Custom url
+     * handleCallback('https://example.com?code=code....')
+     * // Will try to log in the user with the url assign by the developer
+     */
+    handleCallback: (url?: string) => Promise<AuthState>;
+    /**
+     * Gets the access token from cache if the token already expired,
+     * will try to refresh it using the refresh token.
+     * In case that the user change it store the new user information in context
+     * @return {Promise<string>} Access token
+     * @throws {TokenNotFoundException} Will throw an exception there are not access token in cache
+     * @throws {TokenExpiredException} Will throw an if the user token expired
+     */
+    getAccessTokenSilently: () => Promise<string>;
+    /**
+     * Redirect the user to TID using the browser
+     * @param {LoginWithRedirectOptions} options - Custom configuration for teh redirection
+     * @return {Promise<void>} Empty promise
+     * @example No configuration
+     * loginWithRedirect()
+     * // Automatically redirects the user to TID with all necessary parameters
+     * @example Custom redirect
+     * loginWithRedirect({onRedirect: (url) => router.navigate(url)})
+     * // Redirect calls the onRedirect and pass through the url for TID redirection to the function
+     * // So it can be handled by the developer
+     */
+    loginWithRedirect: (options?: LoginWithRedirectOptions) => Promise<void>;
+    /**
+     * Redirect the user to TID using the browser
+     * @param {LogoutOptions} options - Custom configuration for teh redirection
+     * @return {Promise<void>} Empty promise
+     * @example No configuration
+     * logout()
+     * // Automatically redirects the user to TID to log out
+     * @example Custom redirect
+     * logout({onRedirect: (url) => router.navigate(url)})
+     * // Redirect calls the onRedirect and pass through the log-out url for TID to the function
+     * // So it can be handled by the developer
+     */
+    logout: (options?: LogoutOptions) => Promise<void>;
+}
+export declare const TIDContext: import("react").Context<TIDContextState | null>;

package/dist/TIDProvider/TIDProvider.d.ts

@@ -0,0 +1,90 @@
+import React, { PropsWithChildren } from 'react';
+import { TIDClient, PersistentStore, AuthState } from '../TIDClient';
+export interface TIDProviderProps extends PropsWithChildren {
+    /**
+     * The URL for the Trimble Identity OpenID well known configuration endpoint
+     * Staging: https://stage.id.trimblecloud.com/.well-known/openid-configuration
+     * Production: https://id.trimble.com/.well-known/openid-configuration
+     * @type {string}
+     */
+    configurationEndpoint?: string;
+    /**
+     * Client id of the application created in trimble developer console
+     * @type {string}
+     */
+    clientId?: string;
+    /**
+     * The URL to which Trimble Identity should redirect after successfully authenticating a user
+     * @type {string}
+     */
+    redirectUrl?: string;
+    /**
+     * The URL to which Trimble Identity should redirect after successfully logout a user
+     * @type {string}
+     */
+    logoutRedirectUrl?: string;
+    /**
+     * The type of credentials you want (openID, or application_name)
+     * @type {string[]}
+     */
+    scopes?: string[];
+    /**
+     * Type persistent you want the user and token to be store
+     * in-memory - This one will only persist will the user stays in the page
+     * localStorage - This persistent doesn't have expiration date
+     * sessionStorage - This one is cleared when the page session ends
+     * @type {PersistentStore}
+     */
+    persistentStore?: PersistentStore;
+    /**
+     * TID client instance. You can send an instance of the TID Client
+     * if you want to handle the initialization yourself
+     * @type {TIDClient}
+     */
+    tidClient?: TIDClient;
+    /**
+     * When the redirect callback occur this function will be call once the user is login
+     * using the TIDClient.
+     * This could allow you to redirect the user into another page after the login happen
+     * @param {AuthState} authState - Object contain the state returned from TID
+     * @example Redirect the user into the dashboard page
+     * <TIDProvider onRedirectCallback={()=>{router.navigate('/dashboard')}}>
+     */
+    onRedirectCallback?: (authState: AuthState) => void;
+    /**
+     * When the redirect callback occur if this flag is set to true the TIDProvider will
+     * check if the redirect url match the current url, if it doesn't match it will not
+     * authenticate the user.
+     * If this flag is set to false the TIDProvider will just check if the url contain the
+     * auth params and will authenticate the user.
+     * @type {boolean}
+     *
+     * @example Flag set to true and the url doesn't match
+     * <TIDProvider checkRedirectUrlMatch={true}>
+     * // url: https://localhost:3000/dashboard
+     * This will not authenticate the user or try to handle the callback
+     *
+     * @example Flag set to true and the url match but doesn't contain the auth params
+     * <TIDProvider checkRedirectUrlMatch={true}>
+     * // url: https://localhost:3000/dashboard?state=123
+     * This will not authenticate the user or try to handle the callback
+     *
+     * @example Flag set to true and the url match and contain the auth params
+     * <TIDProvider checkRedirectUrlMatch={true}>
+     * // url: https://localhost:3000/dashboard?code=123&state=123
+     * This will authenticate the user and try to handle the callback
+     *
+     * @example Flag set to false
+     * <TIDProvider checkRedirectUrlMatch={false}>
+     * // url: https://localhost:3000/dashboard
+     * This will not authenticate the user because the url contain does contain the auth params
+     *
+     * @example Flag set to false
+     * <TIDProvider checkRedirectUrlMatch={false}>
+     * // url: https://localhost:3000/dashboard?code=123&state=123
+     * This will authenticate the user and try to handle the callback
+     */
+    checkRedirectUrlMatch?: boolean;
+}
+declare const TIDProvider: (props: TIDProviderProps) => React.JSX.Element;
+export default TIDProvider;

package/dist/TIDProvider/index.d.ts

@@ -0,0 +1,4 @@
+export * from './TIDContext';
+export declare const useAuth: () => import("./TIDContext").TIDContextState;
+export declare const TIDProvider: (props: import("./TIDProvider").TIDProviderProps) => import("react").JSX.Element;
+export type { TIDProviderProps } from './TIDProvider';

package/dist/TIDProvider/reducer.d.ts

@@ -0,0 +1,28 @@
+import { TIDAuthState } from './state';
+import { TIDUser } from '../TIDClient';
+/**
+ * Actions available to manage the state of the TID Provider
+ */
+type Action = {
+    type: 'INIT';
+    user?: TIDUser;
+} | {
+    type: 'LOGOUT';
+} | {
+    type: 'GET_ACCESS_TOKEN_COMPLETE';
+    user?: TIDUser;
+} | {
+    type: 'HANDLE_CALLBACK_COMPLETE';
+    user?: TIDUser;
+} | {
+    type: 'ERROR';
+    error: Error;
+};
+/**
+ * This function manage the state and logic of the TID Provider
+ * @param {TIDAuthState} state - Current state of the application
+ * @param {Action} action - Action to execute
+ * @return {TIDAuthState} Empty promise
+ */
+export declare const reducer: (state: TIDAuthState, action: Action) => TIDAuthState;
+export {};

package/dist/TIDProvider/state.d.ts

@@ -0,0 +1,26 @@
+import { TIDUser } from '../TIDClient';
+export interface TIDAuthState {
+    /**
+     * True or false if the user is authenticated
+     * @type {boolean}
+     */
+    isAuthenticated: boolean;
+    /**
+     * This property will indicate the developer that the TID Provider is still loading information from the cache
+     * By default, this state will be true, this will allow the developers to handle async functionality
+     * Note: This property will only be true the first time that the app executes
+     * @type {boolean}
+     */
+    isLoading: boolean;
+    /**
+     * Information of the user in session
+     * @type {TIDUser}
+     */
+    user?: TIDUser;
+    /**
+     * Property that let the developer know if an error happen during the authentication
+     * @type {Error}
+     */
+    error?: Error;
+}
+export declare const initialTIDAuthState: TIDAuthState;

package/dist/TIDProvider/useAuth.d.ts

@@ -0,0 +1,16 @@
+import { TIDContextState } from './TIDContext';
+/**
+ * This hook will allow you to access all functions and properties available in the TIDProvider
+ * Functions and properties available:
+ * * handleCallback
+ * * getAccessTokenSilently
+ * * loginWithRedirect
+ * * logout
+ * * isAuthenticated
+ * * isLoading
+ * * user
+ * * error
+ * @return {TIDContextState}
+ */
+declare const useAuth: () => TIDContextState;
+export default useAuth;

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { TIDClient } from './TIDClient';
+export { TIDContext, useAuth, TIDProvider } from './TIDProvider';
+export { AuthenticationGuard } from './AuthenticationGuard/AuthenticationGuard';
+export type { PersistentStore } from './TIDClient';