@nomad-media/public 1.1.12 → 1.1.14

package/dist/nomad-media-sdk-debug.js

@@ -0,0 +1,1499 @@
+// account
+
+
+
+
+
+
+// admin
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// common
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// portal
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+// helpers
+
+
+
+
+
+/**
+ * @class NomadSDK
+ * @classdesc This class is used to interact with the Nomad API.
+ */
+
+class NomadMediaSDK {
+    constructor(config = {}) {
+        if (NomadMediaSDK.instance) 
+        {
+            return NomadMediaSDK.instance;
+        }
+
+        this.config = config;
+        this.token = null;
+        this.refreshTokenVal = null;
+        this.expirationSeconds = null;
+        this.userSessionId = null;
+        this.id = null
+        this.debug = config.debugMode || false;
+
+        if (this.config.serviceApiUrl[this.config.serviceApiUrl.length - 1] === "/")
+        {
+            this.config.serviceApiUrl = this.config.serviceApiUrl.slice(0, -1);
+        }
+
+        if (this.config.singleton) NomadMediaSDK.instance = this;
+        
+        return this;
+    } 
+
+    /**
+     * @function init
+     * @async
+     * @private
+     * @description Initializes the SDK. Logs in using the username and password from the config. 
+     * Then schedules a token refresh for the duration set by the value returned in the login.
+     * @returns {Promise<void>} - A promise that resolves when the SDK is initialized.
+     * @throws {Error} - An error is thrown if the SDK fails to initialize.
+     */
+    async _init() 
+    {
+        await this.login();
+    }
+    
+    // account functions
+    /**
+     * @function login
+     * @async
+     * @description Logs in using the username and password from the config.
+     * @returns {Promise<void>} - A promise that resolves when the login is successful.
+     * Updates the token, refresh token, expiration seconds, and user session ID class variables. 
+     * @throws {Error} - An error is thrown if the login fails.
+     */ 
+    async login()
+    {
+
+        _printDatetime(`Logging in as ${this.config.username}`);
+
+        try
+        {
+            const LOGIN_INFO = await _login(this);
+            if (!LOGIN_INFO) throw new Error("Login failed");
+            
+            this.token = LOGIN_INFO["token"];
+            this.refreshTokenVal = LOGIN_INFO["refreshToken"];
+            this.expirationSeconds = LOGIN_INFO["expirationSeconds"];
+            this.userSessionId = LOGIN_INFO["userSessionId"];
+            this.id = LOGIN_INFO["id"];
+            _printDatetime(`Login successful`);
+        }
+        catch (error) 
+        {
+            _printDatetime(`Login failed`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function logout
+     * @async
+     * @description Logs out the current user.
+     * @returns {Promise<null>} - A promise that resolves when the logout is successful.
+     * @throws {Error} - An error is thrown if the logout fails.
+     */
+    async logout()
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Logging out`);
+
+        try
+        {
+            await _logout(this);
+            this.token = null;
+            this.refreshTokenVal = null;
+            this.expirationSeconds = null;
+            this.userSessionId = null;
+            this.id = null;
+            
+            _printDatetime(`Logout successful`);
+        }
+        catch (error)
+        {
+            _printDatetime("Logout failed");
+            throw error;
+        }
+    }
+
+    /**
+     * @function refreshToken
+     * @async
+     * @description Refreshes the current token.
+     * @returns {Promise<void>} - A promise that resolves when the token is refreshed.
+     * Updates the token class variable.
+     * @throws {Error} - An error is thrown if the token refresh fails.
+     */ 
+    async refreshToken()
+    {
+        _printDatetime(`Refreshing token`);
+
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        try
+        {
+            const REFRESHED = await _refreshToken(this);
+            if (REFRESHED) _printDatetime(`Token refresh successful`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Token refresh failed`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function forgotPassword
+     * @async
+     * @description Sends a code to the email to the user to be used 
+     * be used to reset the password.
+     * @returns {Promise<void>}
+     * Sends email with code to reset password.
+     * @throws {Error} - An error is thrown if the code fails to send.
+     */  
+    async forgotPassword()
+    {
+        const USERNAME = this.config.username;
+
+         _printDatetime(`Sending code to ${USERNAME}`);
+
+        try
+        {
+            await _forgotPassword(this);
+            _printDatetime(`Code sent to ${USERNAME}`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Code failed to send to ${USERNAME}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function resetPassword
+     * @async
+     * @description Resets the password for the specified username.
+     * @param {string} CODE - The code to use to reset the password. Sent to the user's email
+     * by calling forgotPassword().
+     * @param {string} NEW_PASSWORD - The new password to set.
+     * @returns {Promise<void>}
+     * Resets the password for the specified username.
+     * @throws {Error} - An error is thrown if the password fails to reset.
+     */ 
+    async resetPassword(CODE, NEW_PASSWORD)
+    {
+        const USERNAME = this.config.username;
+
+        _printDatetime(`Resetting password for ${USERNAME}`);
+
+        try
+        {
+            await _resetPassword(this, CODE, NEW_PASSWORD);
+            _printDatetime(`Password reset for ${USERNAME}`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Password failed to reset for ${USERNAME}`);
+            throw error;
+        }
+    }
+
+    // media functions
+    /**
+     * @function clearContinueWatching
+     * @async
+     * @description Delete continue watching markers.
+     * @param {string | null} USER_ID - The user ID of the user to clear the continue watching list.
+     * If not user Id is passed it clears the markers of the logged in user.
+     * @param {string | null} ASSET_ID - The asset ID of the asset to clear the continue watching
+     * list. If not asset Id is passed it clears the markers of all assets.
+     * @returns {Promise<void>} - A promise that resolves when the continue watching list is cleared.
+     * @throws {Error} - An error is thrown if the continue watching list fails to clear.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async clearContinueWatching(USER_ID, ASSET_ID)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal") 
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Clearing continue watching`);
+
+        try
+        {
+            await _clearContinueWatching(this, USER_ID, ASSET_ID);
+            _printDatetime(`Continue watching cleared`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Continue watching failed to clear`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function clearWatchlist
+     * @async
+     * @description Clears the watchlist.
+     * @param {string | null} USER_ID - The user ID of the user to clear the watchlist.
+     * If not user Id is passed it clears the watchlist of the logged in user.
+     * @returns {Promise<void>} - A promise that resolves when the watchlist is cleared.
+     * @throws {Error} - An error is thrown if the watchlist fails to clear.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async clearWatchlist(USER_ID)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {   
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Clearing watchlist`);
+
+        try
+        {
+            USER_ID = USER_ID || this.id;
+
+            await _clearWatchlist(this, USER_ID);
+            _printDatetime(`Watchlist cleared`);
+        }
+        catch (error)
+        {
+            _printDatetime(`Watchlist failed to clear`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function createForm
+     * @async
+     * @description Gets media.
+     * @param {string} CONTENT_DEFINITION_ID - The ID of the content definition the form
+     * is going in.
+     * @param {JSON} FORM_INFO - The information of the form.
+     * JSON format: whatever key value pairs you want to add to the form.
+     * @returns {Promise<JSON>} - A promise that resolves when the from is created.
+     * Returns the id of the form.
+     * @throws {Error} - An error is thrown if the media fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */ 
+    async createForm(CONTENT_DEFINITION_ID, FORM_INFO)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Creating form`);
+
+        try
+        {
+            const GET_FORMS_INFO = await _createForm(this, CONTENT_DEFINITION_ID, FORM_INFO);
+            if (GET_FORMS_INFO) _printDatetime(`Form created`);
+            return GET_FORMS_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Form failed to create`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getContentCookies
+     * @async
+     * @description Gets content cookies.
+     * @param {string} CONTENT_ID - The Id of the content to retrieve the cookies for. 
+     * This can be the ID for the content definition of the LiveChannel, or a folder asset 
+     * ID or a specific Asset ID.
+     * @returns {Promise<JSON>} - A promise that resolves when the content cookies are gotten.
+     * Returns the information of the gotten content cookies.
+     * @throws {Error} - An error is thrown if the content cookies fail to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getContentCookies(CONTENT_ID)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+              throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting content cookies`);
+
+        try
+        {
+            const GET_CONTENT_COOKIES_INFO = await _getContentCookies(this, CONTENT_ID);
+            if (GET_CONTENT_COOKIES_INFO) _printDatetime(`Content cookies gotten`);
+            return GET_CONTENT_COOKIES_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Content cookies failed to get`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getDefaultSiteConfig
+     * @async
+     * @description Gets default site config.
+     * @returns {Promise<Array<JSON>>} - A promise that resolves when the default site config is gotten.
+     * Returns the information of the gotten dynamic content.
+     * @throws {Error} - An error is thrown if the dynamic content fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getDefaultSiteConfig()
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting default site config`);
+
+        try
+        {
+            const GET_DYNAMIC_CONTENTS_INFO = await _getDefaultSiteConfig(this);
+            if (GET_DYNAMIC_CONTENTS_INFO) _printDatetime(`Default site config gotten`);
+            return GET_DYNAMIC_CONTENTS_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Default site config failed to get`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getDynamicContent
+     * @async
+     * @description Gets dynamic content.
+     * @param {string} DYNAMIC_CONTENT_RECORD_ID - The dynamic content record ID.
+     * @returns {Promise<JSON>} - A promise that resolves when the dynamic content is gotten.
+     * Returns the information of the gotten dynamic content.
+     * @throws {Error} - An error is thrown if the dynamic content fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getDynamicContent(DYNAMIC_CONTENT_RECORD_ID)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Getting dynamic content: ${DYNAMIC_CONTENT_RECORD_ID}`);
+
+        try
+        {
+            const GET_DYNAMIC_CONTENT_INFO = await _getDynamicContent(this, DYNAMIC_CONTENT_RECORD_ID);
+            if (GET_DYNAMIC_CONTENT_INFO) _printDatetime(`Dynamic content gotten: ${DYNAMIC_CONTENT_RECORD_ID}`);
+            return GET_DYNAMIC_CONTENT_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Dynamic content failed to get: ${DYNAMIC_CONTENT_RECORD_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getDynamicContents
+     * @async
+     * @description Gets dynamic contents.
+     * @returns {Promise<Array<JSON>>} - A promise that resolves when the dynamic contents is gotten.
+     * Returns the information of the gotten dynamic content.
+     * @throws {Error} - An error is thrown if the dynamic content fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getDynamicContents()
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting dynamic contents`);
+
+        try
+        {
+            const GET_DYNAMIC_CONTENTS_INFO = await _getDynamicContents(this);
+            if (GET_DYNAMIC_CONTENTS_INFO) _printDatetime(`Dynamic contents gotten`);
+            return GET_DYNAMIC_CONTENTS_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Dynamic contents failed to get`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getMediaGroup
+     * @async
+     * @description Gets media group.
+     * @param {string} MEDIA_GROUP_ID - The ID of the media group.
+     * @param { Array<string> } FILTER_IDS - The IDs of the media group items to filter by.
+     * @returns {Promise<JSON>} - A promise that resolves when the media group is gotten.
+     * Returns the information of the gotten media group.
+     * @throws {Error} - An error is thrown if the media group fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getMediaGroup(MEDIA_GROUP_ID, FILTER_IDS)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting media group: ${MEDIA_GROUP_ID}`);
+
+        try
+        {
+            const GET_MEDIA_GROUP_INFO = await _getMediaGroup(this, MEDIA_GROUP_ID, FILTER_IDS);
+            if (GET_MEDIA_GROUP_INFO) _printDatetime(`Media group gotten: ${MEDIA_GROUP_ID}`);
+            return GET_MEDIA_GROUP_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Media group failed to get: ${MEDIA_GROUP_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getMediaItem
+     * @async
+     * @description Gets media item.
+     * @param {string} MEDIA_ITEM_ID - The ID of the media item.
+     * @returns {Promise<JSON>} - A promise that resolves when the media item is gotten.
+     * Returns the information of the gotten media item.
+     * @throws {Error} - An error is thrown if the media item fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getMediaItem(MEDIA_ITEM_ID)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Getting media item: ${MEDIA_ITEM_ID}`);
+
+        try
+        {
+            const GET_MEDIA_ITEM_INFO = await _getMediaItem(this, MEDIA_ITEM_ID);
+            if (GET_MEDIA_ITEM_INFO) _printDatetime(`Media item gotten: ${MEDIA_ITEM_ID}`);
+            return GET_MEDIA_ITEM_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Media item failed to get: ${MEDIA_ITEM_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getMyContent
+     * @async
+     * @description Gets favorites and continue watching lists of IDs for the logged in user.
+     * @returns {Promise<JSON>} - A promise that resolves when the favorites and continue watching
+     * lists of IDs are gotten.
+     * Returns the information of the gotten favorites and continue watching lists of IDs.
+     * @throws {Error} - An error is thrown if the favorites and continue watching lists of IDs fail
+     * to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getMyContent()
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is not available for portal API type.");
+        }
+
+        _printDatetime(`Getting my content`);
+
+        try
+        {
+            const GET_MY_CONTENT_INFO = await _getMyContent(this);
+            if (GET_MY_CONTENT_INFO) _printDatetime(`My content gotten`);
+            return GET_MY_CONTENT_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`My content failed to get`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getMyGroup
+     * @async
+     * @description Gets user's group.
+     * @param {string} GROUP_ID - The ID of the group.
+     * @returns {Promise<JSON>} - A promise that resolves when the user's group is gotten.
+     * Returns the information of the gotten user's group.
+     * @throws {Error} - An error is thrown if the user's group fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getMyGroup(GROUP_ID)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Getting my group: ${GROUP_ID}`);
+
+        try
+        {
+            const GET_MY_GROUP_INFO = await _getMyGroup(this, GROUP_ID);
+            if (GET_MY_GROUP_INFO) _printDatetime(`My group gotten: ${GROUP_ID}`);
+            return GET_MY_GROUP_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`My group failed to get: ${GROUP_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function getSiteConfig
+     * @async
+     * @description Gets site config.
+     * @param {string} SITE_CONFIG_RECORD_ID - The site config record ID.
+     * @returns {Promise<JSON>} - A promise that resolves when the site config is gotten.
+     * Returns the information of the gotten site config.
+     * @throws {Error} - An error is thrown if the site config fails to get.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */
+    async getSiteConfig(SITE_CONFIG_RECORD_ID)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Getting site config: ${SITE_CONFIG_RECORD_ID}`);
+
+        try
+        {
+            const GET_DYNAMIC_CONTENT_INFO = await _getSiteConfig(this, SITE_CONFIG_RECORD_ID);
+            if (GET_DYNAMIC_CONTENT_INFO) _printDatetime(`Site config gotten: ${SITE_CONFIG_RECORD_ID}`);
+            return GET_DYNAMIC_CONTENT_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Site config failed to get: ${SITE_CONFIG_RECORD_ID}`);
+            throw error;
+        }
+    }
+
+    /**
+     * @function mediaSearch
+     * @async
+     * @description Searches for media.
+     * @param {string | null} QUERY - The query of the search.
+     * @param {Array<string> | null} IDS - The IDs of the media to be searched.
+     * @param {Array<JSON> | null} SORT_FIELDS - The sort fields of the search.
+     * JSON format: [{"fieldName": "string", "sortType": ("Ascending" | "Descending")} ...]
+     * @param {number | null} OFFSET - The page offset of the search.
+     * @param {number | null} SIZE - The page size of the search.
+     * @returns {Promise<JSON>} - A promise that resolves when the media are searched.
+     * Returns the information of the searched media.
+     * @throws {Error} - An error is thrown if the media fail to search.
+     * @throws {Error} - An error is thrown if the API type is not portal.
+     */ 
+    async mediaSearch(QUERY, IDS, SORT_FIELDS, OFFSET, SIZE)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        if (this.config.apiType !== "portal")
+        {
+            throw new Error("This function is only available for portal API type.");
+        }
+
+        _printDatetime(`Searching media...`);
+
+        try
+        {
+            const MEDIA_SEARCH_INFO = await _mediaSearch(this, QUERY, IDS, SORT_FIELDS, OFFSET, SIZE);
+            if (MEDIA_SEARCH_INFO) _printDatetime(`Media search complete`);
+            return MEDIA_SEARCH_INFO;
+        }
+        catch (error)
+        {
+            _printDatetime(`Media search failed`);
+            throw error;
+        }
+    }
+
+    // misc functions
+    /**
+     * @function miscFunctions
+     * @async
+     * @description Calls any nomad function given URL method and body.
+     * @param {string} URL_PATH - The URL path of the function.
+     * @param {string} METHOD - The method of the function.
+     * @param {JSON | null} BODY - The body of the api call.
+     * @param {boolean | null} NOT_API_PATH - If the path has /api.
+     * @returns {Promise<JSON>} - A promise that resolves when the function is called.
+     * Returns the information of the called function.
+     * @throws {Error} - An error is thrown if the function fails to call.
+     */
+
+    async miscFunctions(URL_PATH, METHOD, BODY, NOT_API_PATH)
+    {
+        if (this.token === null && this.config.username)
+        {
+            await this._init();
+        }
+
+        _printDatetime(`Calling function: ${URL_PATH}`);
+
+        try
+        {
+            let API_URL = `${this.config.serviceApiUrl}/${URL_PATH}`;
+            if (NOT_API_PATH) {
+                API_URL = API_URL.replace('/api', '');
+                API_URL = API_URL.replace('app-api.', '');
+                API_URL = API_URL.replace('admin-app.', '');
+            }
+
+            const HEADERS = new Headers();
+            HEADERS.append("Content-Type", "application/json");
+
+            if (this.token !== null)
+            {
+                HEADERS.append("Authorization", `Bearer ${this.token}`);
+            }
+
+            if (this.debug) console.log(`URL: ${API_URL}\nMETHOD: ${METHOD}` + (BODY ? `\nBODY: ${JSON.stringify(BODY, null, 4)}` : ""));
+
+            const REQUEST = {
+                method: METHOD,
+                headers: HEADERS
+            };
+            if (BODY) {
+                REQUEST.body = JSON.stringify(BODY);
+            }
+
+            const RESPONSE = await fetch(API_URL, REQUEST);
+
+            const RESPONSE_BODY = await RESPONSE.text();
+            if (!RESPONSE.ok)
+            {
+                try
+                {
+                    throw JSON.parse(RESPONSE_BODY);
+                }
+                catch (error)
+                {
+                    throw RESPONSE_BODY;
+                }
+            }
+
+            try
+            {
+                return JSON.parse(RESPONSE_BODY);
+            }
+            catch (error)
+            {
+                return RESPONSE_BODY;
+            }
+        }
+        catch (error)
+        {
+            _apiExceptionHandler(error, "API call failed");
+        }
+    }
+}
+
+export default NomadMediaSDK;
+
+
+
+async function _forgotPassword(instance) 
+{
+	const API_URL = `${instance.config.serviceApiUrl}/api/account/forgot-password`;
+
+	const BODY = {
+		username: instance.config.username
+	};
+
+	return await _sendRequest(instance, "Forgot Password", API_URL, "POST", undefined, BODY);
+}
+
+
+
+
+async function _login(instance)
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/account/login`;
+
+    const BODY = {
+        "userName": instance.config.username,
+        "password": instance.config.password
+    };
+
+    try
+    {
+        return await _sendRequest(instance, "Login", API_URL, "POST", undefined, BODY);
+    }
+    catch (error)
+    {
+        if (error.message.includes("409"))
+        {
+            throw new Error("Invalid username or password");
+        }
+        else
+        {
+            throw error;
+        }
+    }
+}
+
+
+
+
+
+async function _logout(instance)
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/account/logout`;
+
+    return await _sendRequest(instance, "Logout", API_URL, "POST", undefined, undefined);
+}
+
+
+
+
+
+
+
+async function _refreshToken(instance) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/account/refresh-token`;
+
+    const BODY = {
+        refreshToken: instance.refreshTokenVal
+    };
+
+    const TOKEN_INFO = await _sendRequest(instance, "Refreshing Token", API_URL, "POST", undefined, BODY);
+    instance.token = TOKEN_INFO.token;
+
+    return true;
+}
+
+
+
+
+
+async function _resetPassword(instance, CODE, NEW_PASSWORD) 
+{
+	const API_URL = `${instance.config.serviceApiUrl}/api/account/reset-password`;
+
+  	const BODY = {
+        userName: instance.username,
+        token: CODE,
+        newPassword: NEW_PASSWORD
+    };
+
+	return await _sendRequest(instance, "Reset Password", API_URL, "POST", undefined, BODY);
+}
+
+
+function _apiExceptionHandler(error, message) 
+{
+    // Check if we have a response object and error message
+    if (!error) 
+    {
+        console.error(message);
+    }
+
+    // Check if error is a string
+    if (typeof error === "string") 
+    {
+        console.error(`${message}: ${error}`);
+    }
+    else if (error.errors)
+    {
+        if (Array.isArray(error.errors)) 
+        {
+            let errorString = "";
+            for (let errorIdx = 0; errorIdx < error.errors.length; errorIdx++) 
+            {
+                errorString += `${error.errors[errorIdx].code}: ${error.errors[errorIdx].field}: ${error.errors[errorIdx].message}\n`; 
+            }
+            console.error(`${message}: ${errorString}`);
+        } 
+        else if (typeof error.errors === "object") 
+        {
+            let errorString = "";
+            for (let key in error.errors) 
+            {
+                if (Object.prototype.hasOwnProperty.call(error.errors, key)) 
+                {
+                    errorString += `${key}: ${error.errors[key]}\n`;
+                }
+            }
+            console.error(`${message}: ${errorString}`);
+        }
+    }
+    else
+    {
+        console.error(`${message}: ${error.message}`);
+    }
+
+    return null;
+}
+
+
+import { getRandomValues } from 'crypto';
+
+function _newGuid() 
+{
+    return ([1e7] + -1e3 + -4e3 + -8e3 + -1e11).replace(/[018]/g, (c) =>
+        (c ^ (getRandomValues(new Uint8Array(1))[0] & (15 >> (c / 4)))).toString(16)
+    );
+}
+
+
+
+function _printDatetime(msg)
+{
+    const NOW = new Date();
+    const FORMATTED_TIME = NOW.toLocaleTimeString();
+    console.log(`${FORMATTED_TIME}: ${msg}`);
+}
+
+
+import { promises as fs } from 'fs';
+import path from 'path';
+
+async function _processFile(FILE)
+{
+    let FILE_PATH = null;
+    if (typeof FILE === "string")
+    {
+        // if running in node
+        if (typeof window === "undefined")
+        {
+            FILE_PATH = FILE;
+            FILE = await fs.stat(FILE);
+            FILE.originalName = path.basename(FILE_PATH);
+            if (!FILE.buffer)
+            {
+                FILE.buffer = await fs.readFile(FILE_PATH);
+            }
+        }
+        else
+        {
+            throw new Error("File path is not supported in browser");
+        }
+    }
+    else
+    {
+        FILE.originalName = FILE.name;
+        // if running in browser
+        if (!FILE.buffer)
+        {
+            FILE.buffer = await _readFileAsArrayBuffer(FILE);
+        }
+    }
+
+    return FILE;
+}
+
+async function _readFileAsArrayBuffer(file) 
+{
+    return new Promise((resolve, reject) => 
+    {
+        /* eslint-disable no-undef */
+        const reader = new FileReader();
+        /* eslint-enable no-undef */
+        reader.onload = () => resolve(reader.result);
+        reader.onerror = reject;
+        reader.readAsArrayBuffer(file);
+    });
+}
+
+
+
+
+
+
+import axios from 'axios';
+
+const MAX_RETRIES = 3;
+const TIMEOUT = 10000;
+const SLEEP_TIME = 2;
+
+async function _sendRequest(instance, FUNCTION_NAME, URL, METHOD_TYPE, PARAMS, BODY) 
+{
+    const HEADERS = {
+        "Content-Type": "application/json"
+    };
+
+    if (instance.token) HEADERS["Authorization"] = `Bearer ${instance.token}`;
+
+    if (instance.debug && FUNCTION_NAME !== "Login") console.log(`URL: ${URL}\nMETHOD: ${METHOD_TYPE}` + (PARAMS && PARAMS.size === 0 ? `\nPARAMS: ${JSON.stringify(PARAMS, null, 4)}` : "")  + (BODY ? `\nBODY: ${JSON.stringify(BODY, null, 4)}` : ""));
+
+    let retries = 0;
+    let RESPONSE = null;
+    let refreshedToken = false;
+    do
+    {
+        try 
+        {
+            RESPONSE = await axios({
+                method: METHOD_TYPE,
+                url: URL,
+                headers: HEADERS,
+                params: PARAMS,
+                data: BODY,
+                timeout: TIMEOUT
+            });
+
+            if (RESPONSE.status >= 200 && RESPONSE.status < 300) 
+            {
+                break;
+            }
+
+            throw new Error();
+        } 
+        catch (error) 
+        {
+            if (retries >= MAX_RETRIES)
+            {
+                return _apiExceptionHandler(error.response?.data.message ? error.response.data.message : error.message, `${FUNCTION_NAME} failed`);
+            }
+
+            if (error?.response?.status === 403 && FUNCTION_NAME !== "Refresh Token" && !refreshedToken)
+            {
+                await instance.refreshToken();
+                HEADERS["Authorization"] = `Bearer ${instance.token}`;
+                refreshedToken = true;
+            }
+            else if (error.code === 'ECONNABORTED') 
+            {
+                await _sleep(SLEEP_TIME * 2 ** (retries + 1));
+            }
+            else 
+            {
+                return _apiExceptionHandler(error.response?.data.message ? error.response.data.message : error.message, `${FUNCTION_NAME} failed`);
+            }
+            ++retries;
+        }
+    } while ((!RESPONSE || RESPONSE.status < 200 || RESPONSE.status >= 300) && retries < MAX_RETRIES);
+    try { return RESPONSE.data; }
+    catch (error) { return; }
+}
+
+
+async function _sleep(duration) 
+{
+    // Check for valid duration
+    if (!duration || duration === 0) 
+    {
+        // Ignore
+        return;
+    }
+
+    // Sleep
+    return new Promise((resolve) => {
+        setTimeout(() => {
+            resolve();
+        }, duration * 1000);
+    });
+}
+
+
+
+function _slugify(text) 
+{
+    if (!text || text.trim().length === 0) return "";
+    return text
+        .toString()
+        .normalize("NFD")
+        .replace(/[\u0300-\u036f]/g, "")
+        .toLowerCase()
+        .trim()
+        .replace(/\s+/g, "-")
+        .replace(/[^\w-]+/g, "")
+        .replace(/--+/g, "-");
+}
+
+
+
+
+
+async function _clearContinueWatching(instance, USER_ID, ASSET_ID) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/clear-watching`;
+
+    const PARAMS = {
+        userId: USER_ID,
+        assetId: ASSET_ID
+    };
+
+    return await _sendRequest(instance, "Clear Continue Watching", API_URL, "POST", PARAMS, undefined);
+}
+
+
+
+
+async function _clearWatchlist(instance, USER_ID) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/clear-watchlist?userId=${USER_ID}`;
+
+    return await _sendRequest(instance, "Clear Watchlist", API_URL, "POST", undefined, undefined);
+}
+
+
+
+
+async function _createForm(instance, CONTENT_DEFINITION_ID, FORM_INFO) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/form/${CONTENT_DEFINITION_ID}`;
+
+    const BODY = FORM_INFO;
+
+    return await _sendRequest(instance, "Creating Form", API_URL, "POST", undefined, BODY);
+}
+
+
+
+
+async function _getContentCookies(instance, ID) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/set-cookies/${ID}`;
+
+    return await _sendRequest(instance, "Get Content Cookies", API_URL, "GET", undefined, undefined);
+}
+
+
+
+
+async function _getDefaultSiteConfig(instance) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/config`;
+
+    return await _sendRequest(instance, "Get Default Site Config", API_URL, "GET", undefined, undefined);
+}
+
+
+
+
+async function _getDynamicContent(instance, ID) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/content/${ID}`;
+
+    return await _sendRequest(instance, "Get Dynamic Content", API_URL, "GET", undefined, undefined);
+}
+
+
+
+
+async function _getDynamicContents(instance) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/content`;
+
+    return await _sendRequest(instance, "Get Dynamic Contents", API_URL, "GET", undefined, undefined);
+}
+
+
+
+
+async function _getMediaGroup(instance, ID, FILTER_IDS) 
+{
+    let apiUrl = `${instance.config.serviceApiUrl}/api/media/group/${ID}`;
+    if (FILTER_IDS && FILTER_IDS.length > 0) {
+        apiUrl += '?' + FILTER_IDS.map(id => `filterIds=${id}`).join('&');
+    }
+
+    return await _sendRequest(instance, "Get Media Group", apiUrl, "GET", undefined, undefined);
+}
+
+
+
+
+async function _getMediaItem(instance, ID) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/item/${ID}`;
+
+    return await _sendRequest(instance, "Get Media Item", API_URL, "GET", undefined, undefined);
+}
+
+
+
+
+async function _getMyContent(instance) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/my-content`;
+
+    return await _sendRequest(instance, "Get My Content", API_URL, "GET", undefined, undefined);
+}
+
+
+
+
+async function _getMyGroup(instance, ID) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/my-group/${ID}`;
+
+    return await _sendRequest(instance, "Get My Group", API_URL, "GET", undefined, undefined);
+}
+
+
+
+
+async function _getSiteConfig(instance, ID) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/config/${ID}`;
+
+    return await _sendRequest(instance, "Get Site Config", API_URL, "GET", undefined, undefined);
+}
+
+
+
+
+async function _mediaSearch(instance, SEARCH_QUERY, IDS, SORT_FIELDS, 
+    PAGE_OFFSET, PAGE_SIZE) 
+{
+    const API_URL = `${instance.config.serviceApiUrl}/api/media/search`;
+
+    const BODY = {  
+        searchQuery: SEARCH_QUERY,
+        ids: IDS,
+        sortFields: SORT_FIELDS
+    };
+
+    PAGE_OFFSET ? BODY["pageOffset"] = PAGE_OFFSET : BODY["pageOffset"] = 0;
+    PAGE_SIZE ? BODY["pageSize"] = PAGE_SIZE : BODY["pageSize"] = 100;
+
+    return await _sendRequest(instance, "Media Search", API_URL, "POST", undefined, BODY);
+}
+