@rancher/shell 0.3.13 → 0.3.15

package/store/github.js

@@ -1,252 +1,109 @@
-import dayjs from 'dayjs';
-import { addParam, parseLinkHeader } from '@shell/utils/url';
-import { addObjects, isArray } from '@shell/utils/array';
-import { GITHUB_REPOS, GITHUB_SCOPES, _DATE } from '@shell/config/local-storage';
+const GITHUB_BASE_API = 'https://api.github.com';
+const MAX_RESULTS = 100; // max number of results is 100
 
-const API_BASE = 'https://api.github.com/';
+const fetchGithubAPI = async(endpoint) => {
+  const response = await fetch(`${ GITHUB_BASE_API }/${ endpoint }`);
 
-export const EXTENDED_SCOPES = ['repo'];
+  // If rate-limit is exceeded, we should wait until the rate limit is reset
+  if (response.status === 403) {
+    const resetTime = new Date(response.headers.get('X-RateLimit-Reset') * 1000);
 
-export const DOCKERFILE = /^Dockerfile(\..*)?$/i;
-export const YAML_FILE = /^.*\.ya?ml$/i;
-
-function getFromStorage(key) {
-  if ( process.server ) {
-    return null;
-  }
-
-  const cached = window.localStorage.getItem(key);
-
-  if ( cached ) {
-    try {
-      const parsed = JSON.parse(cached);
-
-      return parsed;
-    } catch (e) {}
+    throw new Error(`Rate limit exceeded. Try again at ${ resetTime }`);
   }
-}
-
-function getCachedRepos() {
-  const cached = getFromStorage(GITHUB_REPOS);
-
-  return cached || [];
-}
-
-function getCachedScopes() {
-  const cached = getFromStorage(GITHUB_SCOPES);
-
-  return cached;
-}
 
-function hasCached() {
-  if ( process.server ) {
-    return false;
+  if (!response.ok) {
+    throw response;
   }
 
-  const cached = window.localStorage.getItem(GITHUB_REPOS);
-
-  return !!cached;
-}
-
-function cacheExpired() {
-  if ( process.server ) {
-    return false;
-  }
-
-  const updated = window.localStorage.getItem(GITHUB_REPOS + _DATE);
-
-  if ( updated && dayjs().diff(updated) <= 60 * 60 * 1000 ) {
-    return false;
-  }
-
-  return true;
-}
-
-function setCache(repos, scopes) {
-  if ( repos ) {
-    window.localStorage.setItem(GITHUB_REPOS, JSON.stringify(repos));
-    window.localStorage.setItem(GITHUB_REPOS + _DATE, (new Date()).toISOString());
-  }
-
-  if ( scopes ) {
-    window.localStorage.setItem(GITHUB_SCOPES, JSON.stringify(scopes));
-  }
-}
-
-function forgetCache() {
-  window.localStorage.removeItem(GITHUB_REPOS);
-  window.localStorage.removeItem(GITHUB_REPOS + _DATE);
-  window.localStorage.removeItem(GITHUB_SCOPES);
-}
-
-function proxifyUrl(url) {
-  // Strip off absolute links to github API
-  if ( url.startsWith(API_BASE) ) {
-    url = url.substr(API_BASE.length);
-  }
-
-  // Add our proxy prefix
-  url = `/v1/github/${ url.replace(/^\/+/, '') }`;
-
-  // Less pages please
-  addParam(url, 'per_page', 100);
-
-  return url;
-}
-
-export const state = function() {
-  return {
-    repos:  [],
-    scopes: []
-  };
+  return await response.json();
 };
 
+export const getters = {};
+
 export const actions = {
-  async apiList({ commit, dispatch }, {
-    url = null,
-    single = false,
-    depaginate = true,
-    onPageFn = null,
-    objectKey = 'items',
-  } = {}) {
-    const out = [];
-
-    url = proxifyUrl(url);
-
-    while ( true ) {
-      console.log('Github Request:', url); // eslint-disable-line no-console
-      const res = await dispatch('rancher/request', { url }, { root: true });
-      const links = parseLinkHeader(res._headers['link']);
-
-      const scopes = res._headers['x-oauth-scopes'];
-
-      if ( scopes ) {
-        commit('setScopes', scopes.split(/\s*,\s*/));
+  async apiList(ctx, {
+    username, endpoint, repo, branch
+  }) {
+    try {
+      switch (endpoint) {
+      case 'branches': {
+        return await fetchGithubAPI(`repos/${ username }/${ repo }/branches?per_page=${ MAX_RESULTS }`);
       }
-
-      if ( single ) {
-        return res;
+      case 'repo': {
+        return await fetchGithubAPI(`repos/${ username }/${ repo }`);
       }
-
-      addObjects(out, isArray(res) ? res : res[objectKey]);
-
-      if ( onPageFn ) {
-        onPageFn(out);
+      case 'commits': {
+        return await fetchGithubAPI(`repos/${ username }/${ repo }/commits?sha=${ branch }&sort=updated&per_page=${ MAX_RESULTS }`);
       }
-
-      if ( depaginate && links.next ) {
-        url = proxifyUrl(links.next);
-      } else {
-        break;
+      case 'recentRepos': {
+        return await fetchGithubAPI(`users/${ username }/repos?per_page=${ MAX_RESULTS }`);
       }
-    }
+      case 'search': {
+        // Fetch for a specific branches
+        if (username && repo && branch) {
+          const response = await fetchGithubAPI(`repos/${ username }/${ repo }/branches/${ branch }`);
 
-    return out;
-  },
-
-  forgetCache() {
-    forgetCache();
-  },
+          return [response];
+        }
 
-  async fetchRecentRepos({ commit, dispatch }, { allowCache = true } = {}) {
-    const cachedScopes = getCachedScopes();
+        // Fetch for repos
+        const response = await fetchGithubAPI(`search/repositories?q=repo:${ username }/${ repo }`);
 
-    if ( cachedScopes ) {
-      commit('setScopes', cachedScopes);
-    }
-
-    if ( allowCache && hasCached() ) {
-      const cached = getCachedRepos();
-
-      if ( cacheExpired() ) {
-        dispatch('fetchRecentRepos', { allowCache: false });
+        if (response) {
+          return response.items;
+        }
       }
-
-      return cached;
+      }
+    } catch (error) {
+      throw await error.json() ?? Error(`Error fetching ${ endpoint }`);
     }
-
-    const res = await dispatch('apiList', { url: '/user/repos?sort=updated', depaginate: false });
-    const more = await dispatch('apiList', { url: '/user/repos?affiliation=owner,collaborator' });
-    const out = [...res, ...more];
-
-    commit('setRepos', out);
-
-    return out;
   },
 
-  async searchRepos({ state, dispatch }, { search }) {
-    if ( !search ) {
-      return state.repos.slice();
-    }
-
-    const res = await dispatch('apiList', {
-      url:        `/search/repositories?q=${ escape(search) }`,
-      depaginate: false
-    });
+  async fetchRecentRepos({ commit, dispatch }, { username } = {}) {
+    const res = await dispatch('apiList', { username, endpoint: 'recentRepos' });
 
     return res;
   },
 
-  async fetchRepoByUrl({ dispatch }, url) {
-    url = url.replace(/.git$/i, '');
-    url = url.replace(/https:\/\/github.com\//, '');
-    url = `/repos/${ url }`;
-    const res = await dispatch('apiList', { url, single: true });
+  async fetchRepoDetails({ commit, dispatch }, { username, repo } = {}) {
+    const res = await dispatch('apiList', {
+      username, endpoint: 'repo', repo: repo.name
+    });
 
     return res;
   },
 
-  async fetchBranches({ dispatch }, { repo }) {
-    const url = repo.branches_url.replace('{/branch}', '');
-    const res = await dispatch('apiList', { url });
+  async fetchBranches({ commit, dispatch }, { repo, username }) {
+    const res = await dispatch('apiList', {
+      username, endpoint: 'branches', repo: repo.name
+    });
 
     return res;
   },
 
-  async fetchBranch({ dispatch }, { repo, name }) {
-    name = name || 'master';
-
-    const url = repo.branches_url.replace('{/branch}', `/${ name }`);
-    const res = await dispatch('apiList', { url, single: true });
+  async fetchCommits(ctx, { repo, username, branch }) {
+    const { dispatch } = ctx;
+    const res = await dispatch('apiList', {
+      username, endpoint: 'commits', repo: repo.name, branch: branch.name
+    });
 
     return res;
   },
-
-  async fetchFiles({ dispatch }, { repo, branch, pattern = null }) {
-    let url = repo.trees_url.replace('{/sha}', `/${ branch.commit.sha }`);
-
-    url = addParam(url, 'recursive', 1);
-
-    const res = await dispatch('apiList', { url, objectKey: 'tree' });
-
-    if ( !pattern ) {
-      return res;
+  async search({ dispatch }, { repo, username, branch }) {
+    try {
+      const res = await dispatch('apiList', {
+        username, endpoint: 'search', repo: repo?.name, branch: branch?.name
+      });
+
+      return {
+        ...res,
+        hasError: false,
+      };
+    } catch (error) {
+      return {
+        message:  error.message,
+        hasError: true
+      };
     }
-
-    const out = res.filter(file => file.type === 'blob' && file.path.match(pattern));
-
-    return out;
-  },
-
-  async fetchFile({ dispatch }, { repo, branch, file }) {
-    let url = repo.contents_url.replace('{+path}', file);
-
-    url = addParam(url, 'ref', branch.commit.sha);
-
-    const res = await dispatch('apiList', { url, single: true });
-
-    return res;
-  },
-};
-
-export const mutations = {
-  setScopes(state, scopes) {
-    state.scopes = scopes;
-    setCache(null, scopes);
-  },
-
-  setRepos(state, repos) {
-    state.repos = repos;
-    setCache(repos);
   },
 };

package/store/gitlab.js

@@ -0,0 +1,159 @@
+import { isArray } from '@shell/utils/array';
+
+const API_VERSION = 'v4';
+const GITLAB_BASE_API = 'https://gitlab.com/api';
+const TOKEN = '';
+const MAX_RESULTS = 100; // max number of results is 100
+
+const getResponse = (endpoint) => fetch(`${ GITLAB_BASE_API }/${ API_VERSION }/${ endpoint }${ TOKEN }`);
+
+function fetchUserOrOrganization(endpoint) {
+  return Promise.all([
+    getResponse(`users/${ endpoint }`),
+    getResponse(`groups/${ endpoint }`),
+  ]).then((responses) => {
+    const found = responses.find((r) => r.ok);
+
+    if (!found) {
+      throw responses[0];
+    }
+
+    return found.json();
+  });
+}
+
+const fetchGitLabAPI = async(endpoint) => {
+  const response = await getResponse(endpoint);
+
+  // If rate-limit is exceeded, we should wait until the rate limit is reset
+  if (response.status === 403) {
+    const resetTime = new Date(response.headers.get('X-RateLimit-Reset') * 1000);
+
+    throw new Error(`Rate limit exceeded. Try again at ${ resetTime }`);
+  }
+
+  if (!response.ok) {
+    throw response;
+  }
+
+  return await response.json();
+};
+
+export const getters = {};
+
+export const actions = {
+  async apiList(ctx, {
+    username, email, endpoint, repo, branch
+  }) {
+    try {
+      switch (endpoint) {
+      case 'branches': {
+        return await fetchGitLabAPI(`projects/${ username }%2F${ repo }/repository/branches?per_page=${ MAX_RESULTS }`);
+      }
+      case 'repo': {
+        return await fetchGitLabAPI(`projects/${ username }%2F${ repo }`);
+      }
+      case 'commits': {
+        return await fetchGitLabAPI(`projects/${ username }%2F${ repo }/repository/commits?ref_name=${ branch }&order_by=updated_at&per_page=${ MAX_RESULTS }`);
+      }
+      case 'recentRepos': {
+        return await fetchUserOrOrganization(`${ username }/projects?order_by=name&sort=asc&per_page=${ MAX_RESULTS }`);
+      }
+      case 'avatar': {
+        return await fetchGitLabAPI(`avatar?email=${ email }`);
+      }
+      case 'search': {
+        // Fetch for a specific branches
+        if (username && repo && branch) {
+          const response = await fetchGitLabAPI(`projects/${ repo }/repository/branches/${ branch }`);
+
+          return [response];
+        }
+
+        // Fetch for repos
+        const response = await fetchGitLabAPI(`search/repositories?q=repo:${ username }/${ repo }`);
+
+        if (response) {
+          return response.items;
+        }
+      }
+      }
+    } catch (error) {
+      throw await error.json() ?? Error(`Error fetching ${ endpoint }`);
+    }
+  },
+
+  async fetchRecentRepos({ commit, dispatch }, { username } = {}) {
+    const res = await dispatch('apiList', { username, endpoint: 'recentRepos' });
+
+    return res;
+  },
+
+  async fetchRepoDetails({ commit, dispatch }, { username, repo } = {}) {
+    const res = await dispatch('apiList', {
+      username, endpoint: 'repo', repo: repo.name
+    });
+
+    return res;
+  },
+
+  async fetchBranches({ commit, dispatch }, { repo, username }) {
+    const res = await dispatch('apiList', {
+      username, endpoint: 'branches', repo: repo.name
+    });
+
+    return res;
+  },
+
+  async fetchCommits(ctx, { repo, username, branch }) {
+    const { dispatch } = ctx;
+
+    const res = await dispatch('apiList', {
+      username, endpoint: 'commits', repo: repo.name, branch: branch.name
+    });
+
+    let commits = [];
+
+    // Get and cache Avatar URLs
+    if (res) {
+      commits = isArray(res) ? res : [res];
+
+      const avatars = {};
+
+      for (const c of commits) {
+        const found = avatars[c.author_email];
+
+        if (found) {
+          c.avatar_url = found;
+        } else {
+          const newAvatar = await dispatch('apiList', {
+            username, endpoint: 'avatar', email: c.author_email
+          });
+
+          c.avatar_url = newAvatar?.avatar_url;
+          avatars[c.author_email] = c.avatar_url;
+        }
+      }
+    }
+
+    return commits;
+  },
+
+  async search({ dispatch }, { repo, username, branch }) {
+    try {
+      const res = await dispatch('apiList', {
+        username, endpoint: 'search', repo: repo?.id, branch: branch?.name
+      });
+
+      return {
+        ...res,
+        hasError: false,
+      };
+    } catch (error) {
+      return {
+        message:  error.message,
+        hasError: true
+      };
+    }
+  }
+};

package/store/growl.js

@@ -11,7 +11,7 @@ export const state = function() {
 };
 
 export const getters = {
-  find: state => ({ key, val }) => {
+  find: (state) => ({ key, val }) => {
     return findBy(state.stack, key, val);
   }
 };

package/store/i18n.js

@@ -58,7 +58,7 @@ export const getters = {
     return out;
   },
 
-  t: state => (key, args, language) => {
+  t: (state) => (key, args, language) => {
     if (state.selected === NONE && !language) {
       return `%${ key }%`;
     }
@@ -110,7 +110,7 @@ export const getters = {
     }
   },
 
-  exists: state => (key, language) => {
+  exists: (state) => (key, language) => {
     const locale = language || state.selected;
     const cacheKey = `${ locale }/${ key }`;
 
@@ -131,11 +131,11 @@ export const getters = {
     return false;
   },
 
-  current: state => () => {
+  current: (state) => () => {
     return state.selected;
   },
 
-  default: state => () => {
+  default: (state) => () => {
     return state.default;
   },
 
@@ -191,7 +191,7 @@ export const mutations = {
 
   // Add a locale to the list of available locales
   addLocale(state, { locale, label }) {
-    const hasLocale = state.available.find(l => l === locale);
+    const hasLocale = state.available.find((l) => l === locale);
 
     if (!hasLocale) {
       state.available.push(locale);
@@ -203,7 +203,7 @@ export const mutations = {
 
   // Remove locale
   removeLocale(state, locale) {
-    const index = state.available.findIndex(l => l === locale);
+    const index = state.available.findIndex((l) => l === locale);
 
     if (index !== -1) {
       state.available.splice(index, 1);
@@ -222,7 +222,7 @@ export const actions = {
     let selected = rootGetters['prefs/get']('locale');
 
     // We might be using a locale that is loaded by a plugin that is no longer loaded
-    const exists = !!state.available.find(loc => loc === selected);
+    const exists = !!state.available.find((loc) => loc === selected);
 
     if ( !selected || !exists) {
       selected = state.default;