@thirstie/thirstieservices 0.1.0

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@thirstie/thirstieservices",
+  "version": "0.1.0",
+  "description": "Service layer for Thirstie ecommerce API",
+  "author": "Thirstie, Inc. <technology@thirstie.com>",
+  "license": "MIT",
+  "type": "module",
+  "source": "src/index.js",
+  "main": "dist/bundle.cjs",
+  "module": "dist/bundle.mjs",
+  "exports": {
+    "require": "./dist/bundle.cjs",
+    "import": "./dist/bundle.mjs"
+  },
+  "scripts": {
+    "dev": "rollup -c -w",
+    "build": "rollup -c",
+    "lint": "eslint src/",
+    "test:int": "node --experimental-vm-modules ../../node_modules/.bin/jest int --no-cache",
+    "test:func": "node --experimental-vm-modules ../../node_modules/.bin/jest func --no-cache",
+    "test:coverage": "node --experimental-vm-modules ../../node_modules/.bin/jest unit --coverage",
+    "test": "concurrently \"npm run lint\" \"npm run test:coverage\"",
+    "test:watch": "node --experimental-vm-modules ../../node_modules/.bin/jest unit --watch"
+  },
+  "dependencies": {
+    "ramda": "^0.29.1"
+  },
+  "jest": {
+    "moduleFileExtensions": [
+      "js",
+      "json"
+    ],
+    "testEnvironment": "jsdom",
+    "transform": {}
+  },
+  "gitHead": "3e6f54e763d04240e244a4c085488c2b4a61ff4b"
+}

package/rollup.config.mjs

@@ -0,0 +1,28 @@
+import resolve from '@rollup/plugin-node-resolve';
+import terser from '@rollup/plugin-terser';
+
+export default {
+  input: 'src/index.js',
+  output: [
+    {
+      file: 'dist/bundle.mjs',
+      format: 'esm'
+    },
+    {
+      file: 'dist/bundle.cjs',
+      format: 'cjs'
+    },
+    {
+      file: 'dist/bundle.iife.js',
+      format: 'iife',
+      name: 'thirstieclient',
+      plugins: [ terser() ]
+    }
+  ],
+  onwarn (warning, warn) {
+    // suppress meaningless warning, see: https://github.com/reduxjs/redux-toolkit/issues/1466
+    if (warning.code === 'THIS_IS_UNDEFINED') return;
+    warn(warning);
+  },
+  plugins: [ resolve() ]
+};

package/src/geoservice/index.js

@@ -0,0 +1,232 @@
+import * as R from 'ramda';
+
+// helper functions
+const findValueBy = R.curry((src, filterKey, searchStr, key) => {
+  const found = (obj) => R.includes(searchStr, obj[filterKey]);
+  return R.compose(R.prop(key), R.find(found))(src);
+});
+const addressLens = R.lensPath([ 'results', '0', 'address_components' ]);
+
+export const transformPredictionResponse = (predictions, options = {}) => {
+  const { requestCity, requestState, requestZipcode } = options;
+
+  const extractPrediction = (prediction) => {
+    return { description: prediction.description, placeId: prediction.place_id };
+  };
+
+  let scoredPredictions = null;
+  if (!(requestCity || requestState || requestZipcode)) {
+    scoredPredictions = predictions.map(extractPrediction);
+  }
+
+  scoredPredictions = predictions.map((row) => {
+    const result = {
+      description: row.description,
+      place_id: row.place_id
+    };
+    const cityMatch = row.terms.filter((term) => requestCity && term.value === requestCity).length > 0 ? 1 : 0;
+    const stateMatch = row.terms.filter((term) => requestState && term.value === requestState).length > 0 ? 1 : 0;
+    const zipMatch = row.terms.filter((term) => requestZipcode && term.value === requestZipcode).length > 0 ? 1 : 0;
+
+    result.score = cityMatch + stateMatch + zipMatch;
+    result.stateMatch = !requestState || (requestState && stateMatch);
+    result.zipCodeMatch = !requestZipcode || (requestZipcode && zipMatch);
+
+    return result;
+  }).filter(
+    rec => !!rec.stateMatch && !!rec.zipCodeMatch
+  ).sort((a, b) => {
+    if (a.score === b.score) {
+      return 0;
+    }
+    return a.score < b.score ? 1 : -1;
+  }).map(extractPrediction);
+
+  return scoredPredictions;
+};
+
+export const parsePlacesAddress = (res) => {
+  const placeResult = res.results ? res.results[0] : res.result;
+  if (!placeResult || R.isEmpty(placeResult)) {
+    return {};
+  }
+
+  let addressComponents = null;
+  if (res.results) {
+    addressComponents = R.view(addressLens)(res);
+  } else {
+    addressComponents = placeResult.address_components;
+  }
+
+  const findAddressComponentByType = findValueBy(addressComponents, 'types');
+
+  const formattedAddress = placeResult.formatted_address;
+  const latitude =
+    placeResult.geometry &&
+    placeResult.geometry.location &&
+    placeResult.geometry.location.lat
+      ? placeResult.geometry.location.lat
+      : null;
+  const longitude =
+    placeResult.geometry &&
+    placeResult.geometry.location &&
+    placeResult.geometry.location.lng
+      ? placeResult.geometry.location.lng
+      : null;
+
+  const streetNumber = findAddressComponentByType('street_number', 'short_name') || '';
+  const streetRoute = findAddressComponentByType('route', 'long_name') || '';
+  const street1 =
+    (streetNumber || streetRoute) && `${streetNumber} ${streetRoute}`;
+
+  const address = {
+    state: findAddressComponentByType('administrative_area_level_1', 'short_name'),
+    city:
+      findAddressComponentByType('locality', 'short_name') ||
+      findAddressComponentByType('sublocality', 'short_name') ||
+      findAddressComponentByType('neighborhood', 'long_name') ||
+      findAddressComponentByType('administrative_area_level_3', 'long_name') ||
+      findAddressComponentByType('administrative_area_level_2', 'short_name'),
+    street_1: street1.trim(),
+    country: findAddressComponentByType('country', 'short_name'),
+    zipcode: findAddressComponentByType('postal_code', 'long_name'),
+    latitude: latitude && Number(latitude),
+    longitude: longitude && Number(longitude),
+    formattedAddress
+  };
+  return R.filter(Boolean)(address);
+};
+
+class GeoService {
+  constructor (mapsKey) {
+    this.mapsKey = mapsKey;
+  }
+
+  async geocode (address) {
+    const res = await fetch(
+      `https://maps.googleapis.com/maps/api/geocode/json?address=${address}&key=${this.mapsKey}`
+    );
+    const response = await res.json();
+    return parsePlacesAddress(response);
+  }
+
+  async geocodeZip (zipCode) {
+    const res = await fetch(
+      `https://maps.googleapis.com/maps/api/geocode/json?components=country:US|postal_code:${zipCode}&key=${this.mapsKey}`
+    );
+    const response = await res.json();
+    return parsePlacesAddress(response);
+  }
+
+  async reverseGeocode (lat, lng) {
+    const res = await fetch(
+      `https://maps.googleapis.com/maps/api/geocode/json?latlng=${lat},${lng}&key=${this.mapsKey}`
+    );
+    const response = await res.json();
+    return parsePlacesAddress(response);
+  }
+
+  async geoLocate () {
+    // https://developers.google.com/maps/documentation/geolocation/overview
+    // NOTE: also returns accuracy (95% confidence of lat, lng in meters)
+    const url = `https://www.googleapis.com/geolocation/v1/geolocate?key=${this.mapsKey}`;
+    const requestConfig = {
+      method: 'POST',
+      headers: {
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    };
+    const request = await fetch(url, requestConfig);
+    const response = await request.json();
+    const { lat, lng } = response.location;
+    return this.reverseGeocode(lat, lng);
+  }
+
+  async getLocationSuggestions (payload) {
+    /*
+    https://developers.google.com/maps/documentation/places/web-service/autocomplete
+    Component should use session token: https://developers.google.com/maps/documentation/places/web-service/autocomplete#sessiontoken
+    **/
+    const { input, latitude, longitude, radius } = payload;
+    const { requestCity, requestState, requestZipcode } = payload;
+    const location = R.join(',', R.filter(Boolean, [ latitude, longitude ]));
+
+    let { sessiontoken } = payload;
+    if (!sessiontoken) {
+      sessiontoken = crypto.randomUUID().replaceAll('-', '');
+    }
+
+    const params = R.filter(Boolean, {
+      input,
+      sessiontoken,
+      location, // The point around which to retrieve place information.
+      radius, // The radius parameter must also be provided when specifying a location
+      components: 'country:US',
+      types: 'address',
+      key: this.mapsKey
+    });
+
+    let queryString = '';
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      queryString = searchParams.toString();
+    }
+
+    const url = `https://maps.googleapis.com/maps/api/place/autocomplete/json?${queryString}`;
+    const requestConfig = {
+      method: 'GET',
+      headers: {
+        Accept: 'application/json'
+      }
+    };
+    const request = await fetch(url, requestConfig);
+    const response = await request.json();
+
+    let autocompletePredictions = [];
+    if (response.predictions && response.status === 'OK') {
+      const options = { requestCity, requestState, requestZipcode };
+      autocompletePredictions = transformPredictionResponse(response.predictions, options);
+    }
+    return { autocompletePredictions, sessiontoken };
+  }
+
+  async getPlaceId (payload) {
+    const { placeId, sessiontoken } = payload;
+
+    const params = R.filter(Boolean, {
+      place_id: placeId,
+      sessiontoken,
+      key: this.mapsKey
+    });
+    let queryString = '';
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      queryString = searchParams.toString();
+    }
+
+    const url = `https://maps.googleapis.com/maps/api/place/details/json?${queryString}`;
+    const res = await fetch(url);
+    const response = await res.json();
+    return parsePlacesAddress(response);
+  }
+
+  async getNavigatorPosition () {
+    // check if navigator is available
+    // NOTE: also returns accuracy (95% confidence of lat, lng in meters)
+    // TODO: check accuracy and only return if within acceptable limit, provided in payload
+    const handleError = (error) => {
+      console.error(error);
+    };
+    (navigator.geolocation && navigator.geolocation.getCurrentPosition(
+      (position) => {
+        const lat = position.coords.latitude;
+        const lng = position.coords.longitude;
+        return this.reverseGeocode(lat, lng);
+      },
+      handleError
+    )) || handleError({ message: 'geolocation is not enabled.' });
+  }
+}
+
+export default GeoService;

package/src/index.js

@@ -0,0 +1,7 @@
+import ThirstieAPI from './thirstieapi';
+import GeoService from './geoservice';
+
+export {
+  ThirstieAPI,
+  GeoService
+};

package/src/thirstieapi/index.js

@@ -0,0 +1,331 @@
+import apiRequest from './utils/apirequest.js';
+
+/**
+ * Access Thirstie API and manage session information.
+ */
+export default class ThirstieAPI {
+  // private fields
+  #apiKey;
+  #thirstieApiBaseUrl;
+  #_apiState;
+  #emptyState;
+  #environment;
+
+  /**
+   * Initialize Thirstie API with public api key
+   * @param {string} apiKey - The public basic auth key, defines application access
+   * @param {Object=} config - Optional config settings
+   * @param {Object} config.env - Set to 'prod' to use production environment
+   * @param {Object} config.initState - Values to initialize session state
+   */
+  constructor (apiKey, config = {}) {
+    const { env, initState } = config;
+    this.#environment = env;
+    this.#emptyState = {
+      sessionToken: null,
+      application: null,
+      applicationRef: null,
+      sessionRef: null,
+      userRef: null,
+      user: {},
+      message: null
+    };
+    this.#apiKey = apiKey;
+    this.#thirstieApiBaseUrl =
+      env === 'prod'
+        ? 'https://api.thirstie.com'
+        : 'https://api.next.thirstie.com';
+
+    this.#_apiState = Object.seal(this.#emptyState);
+    const { sessionToken, application, applicationRef, sessionRef, userRef } = initState || {};
+    if (sessionToken || application || applicationRef || sessionRef || userRef) {
+      const apiInitState = { sessionToken, application, applicationRef, sessionRef, userRef };
+      this.apiState = apiInitState;
+    }
+  }
+
+  get sessionToken () {
+    return this.#_apiState.sessionToken;
+  }
+
+  get sessionRef () {
+    return this.#_apiState.sessionRef;
+  }
+
+  get userRef () {
+    return this.#_apiState.userRef;
+  }
+
+  get applicationRef () {
+    return this.#_apiState.applicationRef;
+  }
+
+  get application () {
+    return this.#_apiState.application;
+  }
+
+  /**
+   * Getter for session state
+   * This is safe to use for persisting state in localstorage
+   * because it does not contain user information.
+   */
+  get sessionState () {
+    const {
+      sessionToken, application, applicationRef, sessionRef, userRef
+    } = this.#_apiState;
+    return { sessionToken, application, applicationRef, sessionRef, userRef };
+  }
+
+  /**
+   * Getter for general api state, contains user information
+   * Only use for internal comparison.
+   */
+  get apiState () {
+    return this.#_apiState;
+  }
+
+  set apiState (props) {
+    try {
+      return Object.assign(this.#_apiState, props);
+    } catch (error) {
+      console.error('set apiState', error);
+      return this.#_apiState;
+    }
+  }
+
+  #handleSession (data) {
+    const sessionData = {
+      application: data.application_name,
+      applicationRef: data.uuid,
+      sessionToken: data.token,
+      sessionRef: data.session_uuid
+    };
+    if (data.user) {
+      sessionData.userRef = data.user.id;
+      const {
+        birthday, email, prefix, guest,
+        first_name: firstName, last_name: lastName, phone_number: phoneNumber,
+        last_login: lastLogin
+      } = data.user;
+      sessionData.user = {
+        email, birthday, prefix, firstName, lastName, phoneNumber, guest, lastLogin
+      };
+    }
+    this.apiState = sessionData;
+  }
+
+  #handleSessionError (err) {
+    this.apiState = this.#emptyState;
+    console.log('session error', err);
+  }
+
+  /**
+   * Create a new session and retrieve a bearer token.
+   *
+   * Defaults to creating an anonymous session. If userCredentials are
+   *  provided, then a user session will be returned.
+   *
+   * @param {Object=} userCredentials - user email & password
+   * @param {string} userCredentials.email
+   * @param {string} userCredentials.password
+   * @param {boolean} [basicAuth=true] - force use of application basic auth
+   * @returns {response}
+   */
+  async getNewSession (userCredentials = {}, basicAuth = true) {
+    const { email, password } = userCredentials;
+    const options = { basicAuth };
+    if (email && password) {
+      options.data = { email, password };
+    }
+    const url = '/a/v2/sessions';
+    const response = await this.apiCaller('POST', url, options);
+    if (response && response.ok && response.data) {
+      return response.data;
+    } else {
+      return { code: response.status, message: response.message || 'unknown error', response };
+    }
+  }
+
+  /**
+   * Validate an existing session
+   * @param {string} sessionToken - Session JWT to validate
+   * @returns {object} session response
+   */
+  async validateSession (sessionToken) {
+    if (sessionToken) {
+      this.apiState = { sessionToken };
+    }
+    if (!this.sessionToken) {
+      return {};
+    }
+
+    const url = '/a/v2/sessions';
+    const response = await this.apiCaller('GET', url);
+    if (response && response.ok && response.data) {
+      return response.data;
+    } else {
+      return await this.getNewSession();
+    }
+  }
+
+  /**
+   * Create new session, or validates existing session and set apiState
+   * @param {string} [existingToken] If provided, session JWT to be validated
+   * @returns {object} API State
+   */
+  async fetchSession (existingToken = null) {
+    let sessionData = {};
+    if (!this.sessionToken && !existingToken) {
+      sessionData = await this.getNewSession();
+    } else {
+      sessionData = await this.validateSession(existingToken);
+    }
+
+    if (sessionData.token) {
+      this.#handleSession(sessionData);
+    } else {
+      this.#handleSessionError(sessionData);
+    }
+    return this.apiState;
+  }
+
+  /**
+   * Convert an anonymous session to a user session
+   * @param {object} userCredentials - { email, password }
+   * @returns {object} - api state
+   */
+  async loginUser (userCredentials) {
+    const options = {};
+    const { email, password } = userCredentials;
+
+    // force use of existing anonymous session token if a token exists
+    const basicAuth = !this.sessionToken;
+    if (email && password) {
+      options.data = { email, password };
+    } else {
+      throw new Error('Invalid credential payload');
+    }
+
+    const responseData = await this.getNewSession(userCredentials, basicAuth);
+    if (responseData.token) {
+      this.#handleSession(responseData);
+    } else {
+      this.#handleSessionError(responseData);
+      const { response } = responseData;
+      const { data } = response;
+      if (data?.message) {
+        this.apiState.message = data?.message;
+      }
+    }
+    return this.apiState;
+  }
+
+  /**
+   * Create a new user
+   * @param {object} userData - { email, password, birthday, prefix, firstName, lastName, phoneNumber, guestCheck }
+   * @param {Function} [errorHandler] - optional error callback
+   * @returns {object} - api state
+   */
+  async createUser (userData, errorHandler = null) {
+    const options = {};
+    const { email, password } = userData;
+    const { birthday, prefix, firstName, lastName, phoneNumber, guestCheck, emailOptIn } = userData;
+    const requestPayload = {
+      email,
+      birthday,
+      prefix,
+      first_name: firstName,
+      last_name: lastName,
+      phone_number: phoneNumber,
+      guest_check: !!guestCheck // "allow guest checkout for existing user" if set to True
+    };
+
+    if (emailOptIn) {
+      requestPayload.aux_data = {
+        thirstieaccess_email_opt_in: emailOptIn
+      };
+    }
+
+    // force use of existing anonymous session token if a token exists
+    const basicAuth = !this.sessionToken;
+    if (email && password) {
+      requestPayload.password = password;
+    } else {
+      requestPayload.guest = true;
+    }
+    options.data = requestPayload;
+    options.basicAuth = basicAuth;
+
+    const responseData = await this.apiCaller('POST', '/a/v2/users', options, errorHandler);
+    if (responseData.data.token) {
+      this.#handleSession(responseData.data);
+    } else {
+      this.#handleSessionError(responseData);
+    }
+    return this.apiState;
+  }
+
+  /**
+   * Invoke Thirstie API Endpoint
+   * @param {string} method - 'GET', 'POST', 'PUT', 'PATCH', 'DELETE'
+   * @param {string} url - api endpoint url
+   * @param {object} [options] - { data, params, basicAuth }
+   * @param {callback} [errorHandler] - error callback
+   * @returns {object} - api response
+   */
+  async apiCaller (method, url, options = {}, errorHandler = null) {
+    const { data, params, basicAuth } = options;
+    const { sessionRef, application, applicationRef, userRef } = this.apiState;
+
+    if (!this.sessionToken && !basicAuth) {
+      throw new Error('Invalid Authorization');
+    }
+
+    const authHeader = (this.sessionToken && !basicAuth)
+      ? `Bearer ${this.sessionToken}`
+      : `Basic ${btoa(this.#apiKey)}`;
+
+    const requestConfig = {
+      method,
+      headers: {
+        Authorization: authHeader,
+        Accept: 'application/json',
+        'Content-Type': 'application/json'
+      }
+    };
+    if ([ 'POST', 'PUT', 'PATCH' ].includes(method) && !!data) {
+      requestConfig.body = JSON.stringify(data);
+    }
+    let queryString = '';
+    if (params) {
+      const searchParams = new URLSearchParams(params);
+      queryString = searchParams.toString();
+    }
+
+    const telemetryContext = {
+      environment: this.#environment,
+      sessionRef,
+      application,
+      applicationRef,
+      userRef,
+      data,
+      queryString,
+      url
+    };
+    const requestUrl = `${this.#thirstieApiBaseUrl}${url}${queryString}`;
+    try {
+      const response = await apiRequest(requestUrl, requestConfig);
+      if (response) {
+        if (!response.ok && errorHandler) {
+          errorHandler({ code: response.status, message: response.statusText || 'unknown error', response, telemetryContext });
+        }
+        return response;
+      }
+    } catch (error) {
+      if (errorHandler) {
+        errorHandler({ code: 500, message: 'unknown error', error, telemetryContext });
+      }
+      return error;
+    }
+  }
+}

package/src/thirstieapi/utils/apirequest.js

@@ -0,0 +1,34 @@
+export default async function apiRequest (url, requestConfig) {
+  const apiResponse = {
+    ok: null,
+    status: null,
+    statusText: null,
+    data: {}
+  };
+  try {
+    const response = await fetch(url, requestConfig);
+
+    let responseBody = {};
+    const headers = response.headers;
+    const hasBody = headers && headers.get('content-type')?.indexOf('application/json') > -1 && parseInt(headers.get('content-length')) > 0;
+    if (hasBody) {
+      responseBody = await response.json();
+    }
+    return Object.assign(apiResponse, {
+      ok: response.ok,
+      status: response.status,
+      statusText: response.statusText,
+      data: responseBody,
+      url
+    });
+  } catch (error) {
+    console.error('apiRequest error: ', error);
+    return Object.assign(apiResponse, {
+      ok: false,
+      status: 500,
+      statusText: 'ERROR',
+      data: { message: 'Network error', error },
+      url
+    });
+  }
+}

package/tests/env.json.tpl

@@ -0,0 +1,5 @@
+{
+  "APIKEY": "",
+  "MAPSKEY": "",
+  "ADMINKEY": ""
+}