@qikdev/sdk 0.1.14 → 0.1.18

package/src/api/qik.api.js

@@ -54,6 +54,18 @@ var QikAPI = function(qik) {
     const defaultAdapter = axios.defaults.adapter
     // console.log('DEFAULT ADAPTER', defaultAdapter)
 
+    /////////////////////////////////////////////////////
+
+    function getRequestCacheKey(config) {
+
+        var key = _.compact([
+            config.method,
+            config.url,
+            JSON.stringify({ user: qik.auth.getCurrentUser(), params: config.params, data: config.data }),
+        ]).join('-')
+
+        return key;
+    }
 
     ///////////////////////////////////////
 
@@ -96,7 +108,7 @@ var QikAPI = function(qik) {
                 if (useCache) {
 
                     //Generate the cache key from the request
-                    var cacheKey = getCacheKeyFromConfig(config);
+                    var cacheKey = getRequestCacheKey(config);
 
                     //If we have the cachedResponse version
                     cachedResponse = useCache.get(cacheKey);
@@ -146,6 +158,26 @@ var QikAPI = function(qik) {
 
     //////////////////////////////////////////////////////////////////////////////
 
+    service.generateEndpointURL = function(endpoint, params, options) {
+        options = options || {}
+
+        //Append the access token to the url
+        if(!options.withoutToken) {
+            params.access_token = qik.auth.getCurrentToken();
+        }
+
+        var stripLeadingTag = endpoint[0] == '/' ? endpoint.slice(1) : endpoint;
+        return `${qik.apiURL}${endpoint}?${qik.utils.mapParameters(params)}`
+    }
+
+    //////////////////////////////////////////////////////////////////////////////
+
+    service.wasCancelled = function(err) {
+        return axios.isCancel(err);
+    }
+
+    //////////////////////////////////////////////////////////////////////////////
+
     function createNewAxios(adapter) {
 
         var instance = axios.create({
@@ -165,6 +197,10 @@ var QikAPI = function(qik) {
         // Add relative date and timezone to every request
         instance.interceptors.request.use(function(config) {
 
+            if (config.withoutToken) {
+                return config;
+            }
+
             config.headers['qik-request-date'] = new Date().getTime();
             if (Intl) {
                 config.headers['qik-request-timezone'] = Intl.DateTimeFormat().resolvedOptions().timeZone;
@@ -172,8 +208,18 @@ var QikAPI = function(qik) {
 
             config.headers['qik-api-version'] = version;
 
-            return config;
 
+            var token = qik.auth.getCurrentToken();
+
+            if (token) {
+                config.headers['Authorization'] = `Bearer ${token}`;
+
+                if (config.params && config.params.access_token) {
+                    delete config.params.access_token;
+                }
+            }
+
+            return config;
         });
 
         /////////////////////////////////////////////////////
@@ -184,7 +230,6 @@ var QikAPI = function(qik) {
         }, function(err) {
 
             if (axios.isCancel(err)) {
-                console.log('Request cancelled');
                 return Promise.reject(err);
             }
 
@@ -199,7 +244,7 @@ var QikAPI = function(qik) {
                 case 502:
                 case 504:
                     //Retry until it works
-                    console.log(`qik.api > ${status} connection error retrying`)
+                    // console.log(`qik.api > ${status} connection error retrying`)
                     return instance.request(err.config);
                     break;
                 case 404:
@@ -207,7 +252,7 @@ var QikAPI = function(qik) {
                     break;
                 default:
                     //Some other error, likely a problem connecting to the server
-                    console.log('qik.api > connection error', status, err);
+                    // console.log('qik.api > connection error', status, err);
                     break;
             }
 
@@ -302,67 +347,7 @@ var QikAPI = function(qik) {
      */
 
 
-
-    ///////////////////////////////////////////////////
-
-    /**
-     * A helper function for generating an authenticated url for the current user
-     * @param  {string} endpoint The id of the asset, or the asset object you want to download
-     * @alias api.generateEndpointURL
-     * @param  {object} params   
-     * @return {string}          A full URL with relevant parameters included
-     * @example
-     * // returns 'https://api.qik.io/something?access_token=2352345...'
-     * qik.api.generateEndpointURL('/something');
-     */
-
-    service.generateEndpointURL = function(path, params) {
-
-        if (!path || !String(path).length) {
-            return;
-        }
-
-        if (!params) {
-            params = {};
-        }
-
-        var url = `${qik.apiURL}${path}`;
-
-        ////////////////////////////////////////
-
-        url = parameterDefaults(url, params);
-
-        ////////////////////////////////////////
-
-        //Map the parameters to a query string
-        var queryParameters = qik.utils.mapParameters(params);
-
-        if (queryParameters.length) {
-            url += '?' + queryParameters;
-        }
-
-        return url;
-
-    }
-
-    ///////////////////////////////////////////////////////
-
-    function parameterDefaults(url, params) {
-
-        //If we haven't requested without token
-        if (!params.withoutToken) {
-            //Get the current token from QikAuth
-            var CurrentQikToken = qik.auth.getCurrentToken();
-
-            //Check to see if we have a token and none has been explicity set
-            if (!params['access_token'] && CurrentQikToken) {
-                //Use the current token by default
-                params['access_token'] = CurrentQikToken;
-            }
-        }
-
-        return url;
-    }
+    
 
 
     /////////////////////////////////////////////////////

package/src/api/qik.auth.js

@@ -1,5 +1,4 @@
 import axios from 'axios';
-import _ from 'lodash';
 import { EventDispatcher } from './qik.utils.js';
 
 ///////////////////////////////////////////////////
@@ -25,6 +24,7 @@ var QikAuth = function(qik) {
 
     var defaultStore = {};
     var store = defaultStore;
+    const tokenBufferSeconds = 10;
 
     ///////////////////////////////////////////////////
     ///////////////////////////////////////////////////
@@ -43,7 +43,6 @@ var QikAuth = function(qik) {
     var dispatcher = new EventDispatcher();
     dispatcher.bootstrap(service);
 
-    // console.log('New Dispatcher!', dispatcher)
 
     ///////////////////////////////////////////////////
     ///////////////////////////////////////////////////
@@ -62,13 +61,6 @@ var QikAuth = function(qik) {
         dispatcher.dispatch('change', user, parameters);
     }
 
-    ///////////////////////////////////////////////////
-
-    function log(message) {
-        if (service.debug) {
-            console.log(message);
-        }
-    }
 
     ///////////////////////////////////////////////////
 
@@ -86,12 +78,11 @@ var QikAuth = function(qik) {
 
         store.user = user;
 
-        log('qik.auth > user set');
+        
         return dispatch(parameters)
     }
 
 
-
     ///////////////////////////////////////////////////
 
     /**
@@ -114,7 +105,7 @@ var QikAuth = function(qik) {
 
 
 
-        log('qik.auth > user logout');
+        
 
 
         if (qik.withCredentials) {
@@ -262,7 +253,7 @@ var QikAuth = function(qik) {
      * @param  {Object} options.disableAutoAuthentication Disable automatic authentication, if true, will not set the current user session
      * @return {Promise}             Returns a promise that either resolves with the logged in user session, or rejects with the responding error from the server
      */
-    service.login = function(credentials, options) {
+    service.login = async function(credentials, options) {
 
         if (!options) {
             options = {};
@@ -324,7 +315,7 @@ var QikAuth = function(qik) {
 
                 if (autoAuthenticate) {
                     store.user = res.data;
-                    // console.log('Persist user', store.user)
+                    
                     dispatch();
                     // if (service.onChange) {
                     //     service.onChange(store.user);
@@ -359,7 +350,7 @@ var QikAuth = function(qik) {
      * @param  {Object} options     Extra options and configuration for the request
      * @return {Promise}            Returns a promise that either resolves to the new authenticated session, or rejects with the responding error from the server
      */
-    service.signup = function(credentials, options) {
+    service.signup = async function(credentials, options) {
 
         if (!options) {
             options = {};
@@ -479,7 +470,7 @@ var QikAuth = function(qik) {
      * If not specified or false, will assume it's a Qik global user that is resetting their password.
      * @return {Promise}            Returns a promise that resolves with the reset session details
      */
-    service.retrieveUserFromResetToken = function(resetToken, options) {
+    service.retrieveUserFromResetToken = async function(resetToken, options) {
 
         if (!options) {
             options = {};
@@ -526,7 +517,7 @@ var QikAuth = function(qik) {
      * @param  {Object} options other options for the request
      * @return {Promise}            Returns a promise that resolves with the reset session details
      */
-    service.updateUserWithToken = function(resetToken, body, options) {
+    service.updateUserWithToken = async function(resetToken, body, options) {
 
         if (!options) {
             options = {};
@@ -653,6 +644,49 @@ var QikAuth = function(qik) {
     }
 
 
+    ///////////////////////////////////////////////////
+
+    service.ensureValidToken = async function() {
+
+                
+
+            var currentUser = service.getCurrentUser();
+            if (!currentUser) {
+                
+                return Promise.reject('No user');
+            }
+
+            var { token } = currentUser;
+            if (!token) {
+                 
+                return Promise.reject('No token');
+            }
+
+            /////////////////////////////////////////////////////
+
+            //Check our date
+            var now = new Date();
+
+            //Give us a bit of buffer so that the backend doesn't beat us to
+            //retiring the token
+            now.setSeconds(now.getSeconds() + tokenBufferSeconds);
+
+            /////////////////////////////////////////////////////
+
+            var expires = new Date(token.expires);
+
+            //If the token is still fresh
+            if (now < expires) {
+                 
+                return token;
+            } else {
+
+                return await service.refreshAccessToken(token.refreshToken);
+            }
+
+        
+    }
+
     ///////////////////////////////////////////////////
 
     /**
@@ -666,57 +700,55 @@ var QikAuth = function(qik) {
 
     const refreshContext = {};
 
-
-    service.refreshAccessToken = function(refreshToken) {
+    service.refreshAccessToken = async function(refreshToken) {
 
         // /////////////////////////////////////////////
 
         // if (appContext) {
-        //     console.log('refresh token in app context')
+        
         // } else {
-        //     console.log('refresh token in normal context')
+        
         // }
 
         // /////////////////////////////////////////////
 
         //If there is already a request in progress
         if (refreshContext.inflightRefreshRequest) {
-            log(`qik.auth > use inflight request`);
+            
             return refreshContext.inflightRefreshRequest;
         }
 
         /////////////////////////////////////////////////////
 
         //Create an refresh request
-        log(`qik.auth > refresh token new request`);
+        
         refreshContext.inflightRefreshRequest = new Promise(function(resolve, reject) {
 
 
-            log(`qik.auth > refresh token ${refreshToken}`);
+            
 
             //Bypass the interceptor on all token refresh calls
             //Because we don't need to add the access token etc onto it
+
             qik.api.post(`/user/refresh`, {
                     refreshToken: refreshToken
                 }, {
                     bypassInterceptor: true,
+                    withoutToken: true,
                 })
                 .then(function tokenRefreshComplete(res) {
 
                     //Update the user with any changes 
                     //returned back from the refresh request
                     if (!res) {
-                        log('qik.auth > no res');
+                        
                         refreshContext.inflightRefreshRequest = null;
                         return reject();
 
                     } else {
-                        if (store.user) {
-                            Object.assign(store.user, res.data);
-                        } else {
-                            store.user = res.data;
-                        }
-                        log(`qik.auth > token refreshed > ${res.data}`);
+                        //Update with our new session
+                        store.user = res.data;
+                        
 
                         dispatch();
                     }
@@ -732,11 +764,11 @@ var QikAuth = function(qik) {
 
                 })
                 .catch(function(err) {
-                    console.log('TOKEN REFRESH FAILED', err);
+                    
 
                     //TODO Check if invalid_refresh_token
 
-                    //console.log('Refresh request Failed')
+                    
                     setTimeout(function() {
                         refreshContext.inflightRefreshRequest = null;
                     });
@@ -769,32 +801,31 @@ var QikAuth = function(qik) {
 
     service.sync = function() {
 
-        // console.log('Sync with server', store.user)
         return qik.api.get('/user')
             .then(function(res) {
 
-                // console.log('sync response', res);
 
                 if (res.data) {
                     if (store.user) {
-                        Object.assign(store.user, res.data);
+                        Object.assign(store.user.session, res.data);
                     }
                 } else {
                     store.user = null;
                 }
-                log('qik.auth > server session refreshed');
+
+                
                 retryCount = 0;
 
                 dispatch();
             })
             .catch(function(err) {
+
                 // if (retryCount > 2) {
-                console.log('auth sync not logged in');
                 store.user = null;
                 retryCount = 0;
                 dispatch();
                 // } else {
-                // console.log('Retry sync')
+                
                 // retryCount++;
                 // service.sync();
                 // }
@@ -815,104 +846,129 @@ var QikAuth = function(qik) {
     }
 
 
-    service.getCurrentToken = function() {
-        return service.getCurrentUser().accessToken;
+    service.getCurrentToken = function(ensureFresh) {
+
+        var details = service.getCurrentUser();
+
+        if (!details) {
+            return;
+        }
+
+        var { token } = details;
+        if (!token) {
+            return;
+        }
+
+        return token.accessToken;
+
     }
 
     /////////////////////////////////////////////////////
 
-    qik.api.interceptors.request.use(function(config) {
+    qik.api.interceptors.request.use(async function(config) {
 
-        //If we want to bypass the interceptor
-        //then just return the request
-        if (config.bypassInterceptor) {
-            console.log('auth interceptor was bypassed');
-            return config;
-        }
+            //If we want to bypass the interceptor
+            //then just return the request
+            if (config.bypassInterceptor) {
+                return config;
+            }
 
-        //////////////////////////////
-        //////////////////////////////
-        //////////////////////////////
-        //////////////////////////////
+            //////////////////////////////
+            //////////////////////////////
+            //////////////////////////////
+            //////////////////////////////
 
-        //Get the original request
-        var originalRequest = config;
+            //Get the original request
+            var originalRequest = config;
 
-        //If we aren't logged in or don't have a token
-        var accessToken = _.get(store, 'user.accessToken');
-        var refreshToken =  _.get(store, 'user.refreshToken');
+            //////////////////////////////
 
-        //////////////////////////////
+            var userDetails = await service.getCurrentUser();
+            var accessToken;
+            var refreshToken;
+            var expiryDate;
 
-        //If there is a user token
-        if (accessToken) {
-            //Set the token of the request as the user's access token
-            originalRequest.headers['Authorization'] = `Bearer ${accessToken}`;
-            log('qik.auth > using user token');
+            if (userDetails) {
+                var { token } = userDetails;
+                if (token) {
+                    accessToken = token.accessToken;
+                    refreshToken = token.refreshToken;
+                    expiryDate = token.expires;
+                }
+            }
 
-        } else {
-            //Return the original request without a token
-            log('qik.auth > no token');
-            return originalRequest;
-        }
+            //////////////////////////////
 
-        /////////////////////////////////////////////////////
+            //If there is a user token
+            if (accessToken) {
+                //Set the token of the request as the user's access token
+                originalRequest.headers['Authorization'] = `Bearer ${accessToken}`;
+                
 
-        //If no refresh token
-        if (!refreshToken) {
-            log('qik.auth > no refresh token');
+            } else {
+                //Return the original request without a token
+                
+                return originalRequest;
+            }
 
-            //Continue with the original request
-            return originalRequest;
-        }
+            /////////////////////////////////////////////////////
 
-        /////////////////////////////////////////////////////
+            //If no refresh token
+            if (!refreshToken) {
+                
 
-        //We have a refresh token so we need to check
-        //whether our access token is stale and needs to be refreshed
-        var now = new Date();
+                //Continue with the original request
+                return originalRequest;
+            }
 
-        //Give us a bit of buffer incase some of our images
-        //are still loading
-        now.setSeconds(now.getSeconds() + 10);
+            /////////////////////////////////////////////////////
 
-        /////////////////////////////////////////////////////
+            //We have a refresh token so we need to check
+            //whether our access token is stale and needs to be refreshed
+            var now = new Date();
 
-        var expiryDate = _.get(store, 'user.expires');
-        var expires = new Date(expiryDate);
+            //Give us a bit of buffer so that the backend doesn't beat us to
+            //retiring the token
+            now.setSeconds(now.getSeconds() + tokenBufferSeconds);
 
-        //If the token is still fresh
-        if (now < expires) {
-            //Return the original request
-            return originalRequest;
-        }
-    
-        /////////////////////////////////////////////////////
+            /////////////////////////////////////////////////////
 
-        log('qik.auth > token expired');
+            var expires = new Date(expiryDate);
 
-        return new Promise(function(resolve, reject) {
+            //If the token is still fresh
+            if (now < expires) {
+                //Return the original request
+                return originalRequest;
+            }
 
-            //Refresh the token
-            service.refreshAccessToken(refreshToken)
-                .then(function(newToken) {
-                    log('qik.auth > token refreshed', isManagedUser);
-                    //Update the original request with our new token
-                    originalRequest.headers['Authorization'] = `Bearer ${newToken}`;
-                    //And continue onward
-                    return resolve(originalRequest);
-                })
-                .catch(function(err) {
-                    console.log('ERRRRRR', err);
-                    log('qik.auth > token refresh rejected', err);
-                    return reject(err);
-                });
-        });
+            /////////////////////////////////////////////////////
+
+            
+
+            return new Promise(async function(resolve, reject) {
+
+                //Refresh the token
+                await service.refreshAccessToken(refreshToken)
+                    .then(function(newToken) {
+                        
+                        //Update the original request with our new token
+                        originalRequest.headers['Authorization'] = `Bearer ${newToken}`;
+                        //And continue onward
+                        return resolve(originalRequest);
+                    })
+                    .catch(function(err) {
+                        
+                        return reject(err);
+                    });
+            });
+
+
+        },
+        function(error) {
+            return Promise.reject(error);
+        })
 
 
-    }, function(error) {
-        return Promise.reject(error);
-    })
 
     /////////////////////////////////////////////////////
 
@@ -923,12 +979,11 @@ var QikAuth = function(qik) {
         //////////////////////////////
 
         //Get the response status
-        var status = _.get(err, 'response.status') || err.status;
+        var status = (err && err.response && err.response.status) || err.status;
 
-        log('qik.auth > error', status);
+        
         switch (status) {
             case 401:
-                console.log('logout from 401')
                 service.logout();
                 break;
             default: