@nuskin/contentstack-lib 1.0.0-pur-1208.2

package/jest.config.js

@@ -0,0 +1,16 @@
+module.exports = {
+  transform: {
+    "^.+\\.(js|jsx)?$": "babel-jest"
+  },
+  testURL: "http://localhost/",
+  collectCoverage: true,
+  collectCoverageFrom: ["src/*.js"],
+  coveragePathIgnorePatterns: [
+    "/node_modules/",
+    "package.json",
+    "package-lock.json",
+    "index.js"
+  ],
+  testResultsProcessor: "jest-sonar-reporter",
+  coverageReporters: ["html", "lcov", "text-summary"]
+};

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@nuskin/contentstack-lib",
+  "version": "1.0.0-pur-1208.2",
+  "description": "This project contains configuration and api code to access Contentstack, to be shared between the backend (AWS Lambda) and frontend (Vue, etc).",
+  "main": "src/index.js",
+  "scripts": {
+    "test": "jest --coverage",
+    "lint": "eslint src __tests__"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@code.tls.nuskin.io:ns-am/utility/npm/contentstack-lib.git"
+  },
+  "keywords": [],
+  "author": "Treg Anderson <tsanderson@nuskin.com>",
+  "license": "ISC",
+  "homepage": "https://code.tls.nuskin.io/ns-am/utility/npm/contentstack-lib/blob/master/README.md",
+  "devDependencies": {
+    "eslint": "5.16.0",
+    "eslint-config-google": "0.14.0",
+    "eslint-config-prettier": "4.1.0",
+    "eslint-plugin-json": "2.1.1",
+    "eslint-plugin-prettier": "3.1.2",
+    "jest": "25.1.0",
+    "jest-sonar-reporter": "2.0.0",
+    "prettier": "1.19.1"
+  },
+  "dependencies": {
+    "axios": "1.7.7",
+    "contentstack": "^3.16.0"
+  }
+}

package/src/api.js

@@ -0,0 +1,181 @@
+"use strict";
+
+const Contentstack = require('contentstack');
+let env = null;
+let Stack = null;
+
+let api_key;
+let delivery_token;
+let environment;
+
+const COMMON_LANGUAGES = {
+  'da': 'da-dk',
+  'id': 'id-id',
+  'hu': 'hu-hu',
+  'ro': 'ro-ro',
+  'tk': 'tk-tk',
+  'pl': 'pl-pl',
+  'sk': 'sk-sk',
+  'th': 'th-th',
+  'uk': 'uk-ua',
+  'tr': 'tr-tr'
+};
+
+/**
+ * Convert string from snake case to camel case
+ * @param {string} snakeCasedString
+ * @returns {string} camelCaseString
+ * @private
+ */
+function _snakeToCamel(s) {
+  return s.replace(/(_\w)/g, k => k[1].toUpperCase());
+}
+
+/**
+ * Convert object with snake case properties to camel case
+ * @param {*} obj - object to convert
+ * @returns {*} camelCasedObject
+ * @private
+ */
+function _snakeObjectToCamel(obj) {
+  // If obj is falsy or not an object, return it unchanged
+  if (!obj || typeof obj !== 'object') return obj;
+
+  if (Array.isArray(obj)) {
+    // obj is array; recurse into its children
+    return obj.map(_snakeObjectToCamel);
+  } else {
+    // obj is object; convert its keys and recurse into its values
+    const camelKeyedFields = Object.entries(obj).map(([k, v]) => [
+      _snakeToCamel(k),
+      _snakeObjectToCamel(v)
+    ]);
+
+    return Object.fromEntries(camelKeyedFields);
+  }
+}
+
+/**
+ * Get the environment from the url if we are running in a browser
+ * @return {string} environment
+ * @private
+ */
+function _getEnv() {
+  return (window.location.hostname.includes('dev') || window.location.hostname.includes('localhost')) ? 'dev' :
+    window.location.hostname.includes('test') ? 'test' :
+      window.location.hostname.includes('stage') ? 'stage' : 'prod';
+}
+
+/**
+ * Get entries for a list of content types.
+ * @param {string[]} contentTypeUIDs
+ * @param {string} locale
+ * @param {boolean=} camelcase
+ * @returns {Promise<*>}
+ * @private
+ */
+async function _getSingletonEntries(contentTypeUIDs, locale, camelcase) {
+  const promises = contentTypeUIDs.map(uid => {
+    return Stack
+      .ContentType(uid)
+      .Query()
+      .language(locale)
+      .includeFallback()
+      .toJSON()
+      .findOne();
+  });
+  // Make calls simultaneously but if any fail allow the other calls to finish
+  const result = await Promise.allSettled(promises);
+  // If there is an error getting the strings from CS value will be null, then return an empty {}
+  return result.map(r => {
+    const val = r.value || {};
+    return camelcase ? _snakeObjectToCamel(val) : val;
+  });
+}
+
+/**
+ * Merges the strings for the locale US-en with the fallback strings en
+ * @param {Object[]} fallbackStrings
+ * @param {Object[]} localeStrings
+ * @return {Promise<Object[]>}
+ * @private
+ */
+async function _mergeFallbackStrings(fallbackStrings, localeStrings) {
+  // loop through all the results and merge strings
+  return fallbackStrings.map((strings, index) => {
+    return {...strings, ...localeStrings[index]};
+  });
+}
+
+/**
+ * Get entries for a list of content types.  The content types must be of type single.
+ * Entries are returned in the order they were requested
+ * This function is useful for getting a list of strings from multiple content types at once.
+ *
+ * @param {string[]} options.contentTypeUIDs - list of content types that contains the strings for your application
+ * @param {string} options.language - language you want to get the translations for
+ * @param {string=} options.country
+ * @param {boolean=} options.mergeWithFallback - merges string results of Ex: US-en with en
+ * @param {boolean=} options.camelcase
+ * @returns {Promise<Object[]>} The entries are returned in the order they were requested
+ */
+async function getSingletonEntries(options) {
+  const {contentTypeUIDs, language, country, camelcase, mergeWithFallback} = options;
+  if (!contentTypeUIDs || !contentTypeUIDs.length || !language) {
+    throw new Error('Call to getSingletonEntries: options.contentTypeUIDs and language are required');
+  }
+  const mappedLanguage = language === 'in' ? 'id' : language;
+  const commonLocale = COMMON_LANGUAGES[mappedLanguage] || mappedLanguage;
+  const locale = country ? `${country}-${mappedLanguage}` : commonLocale;
+
+  try {
+    // If we don't have a country or we aren't merging with fallback then there is nothing to merge
+    return (!mergeWithFallback || !country) ?
+      await _getSingletonEntries(contentTypeUIDs, locale, camelcase) :
+      _mergeFallbackStrings(
+        await _getSingletonEntries(contentTypeUIDs, commonLocale, camelcase),  // get fallback strings Ex: en
+        await _getSingletonEntries(contentTypeUIDs, locale, camelcase)  // get locale strings for Ex: US-en
+      );
+  } catch (e) {
+    console.error(e);
+    return [];
+  }
+}
+
+/**
+ * Returns contentstack Stack object initialized with the api key, deliveryToken, and extended with custom functionality
+ * @param {'dev' | 'test' | 'stage' | 'prod'} environment
+ * @return {Object} Stack - contentstack Stack sdk object with additional getStrings function
+ */
+function getStack() {
+  if (!environment) {
+    if (!window || !window.location) {
+      throw new Error('Environment must be passed into getStack');
+    }
+    environment = _getEnv();
+  }
+
+  // If the environment requested hasn't changed return the stack we already have
+  if (environment === env && Stack) {
+    return Stack;
+  }
+
+  env = environment;
+  Stack = Contentstack.Stack({api_key, delivery_token, environment})
+
+  // extend the Stack with a custom function to get translations
+  Stack.getSingletonEntries = getSingletonEntries;
+
+  return Stack;
+}
+
+function init({env, apiKey, deliveryToken}) {
+  environment = env;
+  api_key = apiKey;
+  delivery_token = deliveryToken;
+}
+
+module.exports = {
+  init,
+  getStack
+};

package/src/index.js

@@ -0,0 +1,13 @@
+/**
+ * WARNING: The use of `require` and `module.exports` is because this package has to remain
+ * in CommonJS format. Do not change ANY files here to ES6 standards or it will break usages.
+ */
+
+"use strict";
+
+const {getStack, init} = require("./api.js");
+
+module.exports = {
+  init,
+  getStack
+};