@veritree/services 0.0.2 → 0.3.0

package/index.js

@@ -0,0 +1,13 @@
+import { createSponsorsApiService } from './src/services/sponsors.js';
+import { createOrgsApiService } from './src/services/orgs.js';
+import { createForestTypesApiService } from './src/services/forestTypes.js';
+import { createSubdomainsApiService } from './src/services/subdomains.js';
+import { createCountriesApiService } from './src/services/countries.js';
+
+export {
+  createSponsorsApiService,
+  createOrgsApiService,
+  createForestTypesApiService,
+  createSubdomainsApiService,
+  createCountriesApiService
+}

package/package-lock.json

@@ -0,0 +1,5 @@
+{
+  "name": "@veritree/services",
+  "version": "0.2.0",
+  "lockfileVersion": 1
+}

package/package.json

@@ -1,7 +1,8 @@
 {
   "name": "@veritree/services",
-  "version": "0.0.2",
+  "version": "0.3.0",
   "description": "A collection of javascript functions/services to talk to veritree API",
+  "type": "module",
   "main": "index.js",
   "repository": "https://github.com/tentree-org/veritree-services.git",
   "author": "cyroveritree <cyro@veritree.com>",

package/src/helpers/api.js

@@ -0,0 +1,77 @@
+import { getCookie } from './cookies';
+
+const Api = {
+  baseUrl: `${process.env.API_VERITREE_URL}/api`,
+  forceEnvelopeResponse: true, // TODO: remove when API is fully migrated to envelopes
+
+  async get(url) {
+    return await this.unWrap(url);
+  },
+
+  async post(url, data) {
+    return await this.unWrap(url, 'post', data);
+  },
+
+  async update(url, data) {
+    return await this.unWrap(url, 'put', data);
+  },
+
+  /**
+   * Deals with all fetch requests
+   *
+   * @param {string} url
+   * @param {string} method
+   * @param {object} data
+   * @returns {object} envelope
+   */
+  async unWrap(url, method = 'get', data) {
+    if (this.forceEnvelopeResponse) url = this.addEvenlopeArgToUrl(url); // TODO: remove when API is fully migrated to envelopes
+    const config = this.getConfig(method, data);
+
+    try {
+      const response = await fetch(url, config);
+      const envelope = await response.json();
+
+      return envelope;
+    } catch (err) {
+      throw new Error(err);
+    }
+  },
+
+  /**
+   * Handles how the data should be sent in the fetch method
+   *
+   * @param {string} method
+   * @param {object} body
+   * @returns {object} data
+   */
+  getConfig(method, data) {
+    const config = {
+      method,
+      headers: {
+        'Content-Type': 'application/json',
+        Authorization: `Bearer ${getCookie('access_token')}`,
+      },
+    };
+
+    if (method !== 'get') config.body = JSON.stringify(data);
+
+    return config;
+  },
+
+  /**
+   * Adds the envelope argument to the url
+   *
+   * @param {string} url
+   * @returns {string} url
+   */
+  addEvenlopeArgToUrl(url) {
+    if (!url || url.includes('_result=1')) return;
+    const urlHasArgs = url.includes('?');
+    const urlEvenlopeArg = urlHasArgs ? '&_result=1' : '?_result=1';
+
+    return `${url}${urlEvenlopeArg}`;
+  },
+};
+
+export default Api;

package/src/helpers/cookies.js

@@ -0,0 +1,36 @@
+const converter = {
+  read(value) {
+    if (value[0] === '"') {
+      value = value.slice(1, -1);
+    }
+
+    return value.replace(/(%[\dA-F]{2})+/gi, decodeURIComponent);
+  },
+};
+
+export function getCookie(name) {
+  if (typeof document === 'undefined' || (arguments.length && !name)) {
+    return;
+  }
+
+  // To prevent the for loop in the first place assign an empty array
+  // in case there are no cookies at all.
+  const cookies = document.cookie ? document.cookie.split('; ') : [];
+
+  const jar = {};
+  for (let i = 0; i < cookies.length; i++) {
+    const parts = cookies[i].split('=');
+    const value = parts.slice(1).join('=');
+
+    try {
+      const found = decodeURIComponent(parts[0]);
+      jar[found] = converter.read(value, found);
+
+      if (name === found) {
+        break;
+      }
+    } catch (e) {}
+  }
+
+  return name ? jar[name] : jar;
+}

package/src/services/countries.js

@@ -0,0 +1,23 @@
+import Api from '../helpers/api';
+
+export const createCountriesApiService = (countryId) => {
+
+  const resource = 'countries';
+
+  const stats = {
+    async get() {
+      // Look for a country ID if none provided global stats will be sent
+      const type = countryId ? `${countryId}` : 'global';
+      const url = _getUrl(type +'/stats');
+      return await Api.get(url);
+    }
+  }
+
+  const _getUrl = (endpoint) => {
+    return `${Api.baseUrl}/${resource}/${endpoint}`;
+  };
+
+  return {
+    stats
+  };
+};

package/src/services/forestTypes.js

@@ -0,0 +1,41 @@
+import Api from '../helpers/api';
+
+// TODO: Add all possible parameters as in API
+export const createForestTypesApiService = () => {
+  /**
+   * Gets the right resource for the request based on the isPublic flag.
+   *
+   * @param {boolean} isPublic
+   * @returns {string} resource
+   */
+  const _getResource = (isPublic) => {
+    return isPublic ? 'forest-type-profiles' : `forest-types`;
+  };
+
+  const get = {
+    async all(isPublic = false) {
+      const url = _handleUrl(isPublic);
+      return await Api.get(url);
+    },
+
+    async specific(id, isPublic = false) {
+      const url = _handleUrl(isPublic, id);
+      return await Api.get(url);
+    },
+  };
+
+  function _handleUrl(isPublic, id) {
+    const resource = _getResource(isPublic);
+    return _getUrl(resource, id);
+  }
+
+  function _getUrl(resource, id) {
+    return id
+      ? `${Api.baseUrl}/${resource}/${id}`
+      : `${Api.baseUrl}/${resource}`;
+  }
+
+  return {
+    get,
+  };
+};

package/src/services/orgs.js

@@ -0,0 +1,27 @@
+import Api from '../helpers/api';
+
+export const createOrgsApiService = (orgId, orgType) => {
+  if (!orgId && !orgType) throw new Error('No org id and/or type provided');
+  const resource = 'orgs';
+  
+  // filter for stats data
+  const stats = {
+    async get(isPublic) {
+      const endpoint = _getStatsEndpoint(isPublic);
+      const url = _getUrl(endpoint);
+      return await Api.get(url);
+    },
+  };
+
+  const _getStatsEndpoint = (isPublic) => {
+    return isPublic ? 'pstats' : 'stats';
+  }
+
+  const _getUrl = (endpoint) => {
+    return `${Api.baseUrl}/${resource}/${endpoint}?org_id=${orgId}&org_type=${orgType}`;
+  };
+
+  return {
+    stats,
+  };
+};

package/src/services/sponsors.js

@@ -0,0 +1,31 @@
+import Api from '../helpers/api';
+
+export const createSponsorsApiService = (orgId) => {
+  if (!orgId) throw new Error('No org id provided');
+  const resource = 'sponsors';
+
+  // filter for map data
+  const map = {
+    async get() {
+      const url = _getUrl('map-data');
+      return await Api.get(url);
+    },
+  };
+
+  // filter for profile
+  const profile = {
+    async get() {
+      const url = _getUrl('profile');
+      return await Api.get(url);
+    },
+  };
+
+  const _getUrl = (endpoint) => {
+    return `${Api.baseUrl}/${resource}/${orgId}/${endpoint}`;
+  };
+
+  return {
+    map,
+    profile,
+  };
+};

package/src/services/subdomains.js

@@ -0,0 +1,24 @@
+import Api from '../helpers/api';
+
+export const createSubdomainsApiService = () => {
+  const resource = 'subdomains';
+
+  const get = {
+    /**
+     * @param {string} id (name or id)
+     * @returns {object} evenlop
+     */
+    async specific(id) {
+      const url = _getUrl(id);
+      return await Api.get(url);
+    },
+  };
+
+  function _getUrl(id) {
+    return `${Api.baseUrl}/${resource}/${id}`;
+  }
+
+  return {
+    get,
+  };
+};