@nuskin/contentstack-lib 2.0.0 → 2.0.2-pa-1190.1

package/.eslintrc.json

@@ -11,7 +11,7 @@
         "SharedArrayBuffer": "readonly"
     },
     "parserOptions": {
-        "ecmaVersion": 2018,
+        "ecmaVersion": 2020,
         "sourceType": "module"
     },
     "extends": [

package/.releaserc

@@ -1,6 +1,6 @@
 {
     "branches": [
-      "master"
+      "master", {"name":"PA-1190", "channel":"prerelease", "prerelease":"pa-1190"}
     ],
     "plugins": [
         "@semantic-release/release-notes-generator",

package/README.md

@@ -10,13 +10,13 @@ FOR COMMON SPANISH AND MX-es FOR EXAMPLE.
 
 ## Installing
 
-Usng npm:
+Using npm:
 
 ```bash
 npm install @nuskin/contentstack-lib
 ```
 
-Usng yarn:
+Using yarn:
 
 ```bash
 yarn add @nuskin/contentstack-lib
@@ -27,8 +27,9 @@ yarn add @nuskin/contentstack-lib
 ```js
 const { getStack } = require('@nuskin/contentstack-lib')
 
-// Call getStack to get the stack object
-const Stack = getStack()
+// Pass an environment explicitly outside the browser.
+// In the browser, getStack() can infer the env from the hostname.
+const Stack = getStack('prod')
 
 // get all languages
 const languages = await Stack.ContentType('supported_language').Query().toJSON().find();
@@ -36,16 +37,6 @@ const languages = await Stack.ContentType('supported_language').Query().toJSON()
 // get all markets
 const markets = await Stack.ContentType('market').Query().toJSON().find();
 
-// Use the extended getStrings function to get translations
-// ==================== Deprecated - Dont use this function ==========================
-const translations = Stack.getStrings({
-    contentTypes: ['checkout_adr_strings', 'checkout_cart_strings'],  // List of content types you want to get translations for
-    language: 'en',
-    country: 'US',
-    merge: true  // Will combine checkout_adr_strings and checkout_cart_strings object with single list of strings
-});
-
-// Use this function instead to get your translations
 // The entries are returned in the order they were requested so you can destructure the array accordingly
 // To get the result in camelcase instead of snake case you can pass in the option.camelcase: true
 // Contentstack does not merge common english strings with en_US strings.  This function allows you to merge the two with mergeWithFallback: true

package/__tests__/api.spec.js

@@ -15,6 +15,9 @@ const {contentstack: prodEnvConfig} = require(`../config/prod.json`);
 const mockPromiseResult = jest.fn();
 const mockSinglePromiseResult = jest.fn();
 const mockStack = jest.fn();
+const mockContainedIn = jest.fn();
+const mockIncludeReference = jest.fn();
+const mockFetch = jest.fn();
 
 function getConfig(env) {
   let config = {};
@@ -42,27 +45,150 @@ function getConfig(env) {
 }
 
 beforeEach(() => {
-  mockStack.mockImplementation(() => ({
-    ContentType: () => ({
-      Query: () => ({
-        language: () => ({
-          includeFallback: () => ({
-            toJSON: () => ({
-              find: mockPromiseResult,
-              findOne: mockSinglePromiseResult
-            })
-          })
+  const mockQuery = {
+    language: jest.fn(() => ({
+      includeFallback: () => ({
+        toJSON: () => ({
+          find: mockPromiseResult,
+          findOne: mockSinglePromiseResult
         })
       })
+    })),
+    containedIn: mockContainedIn,
+    includeReference: mockIncludeReference,
+    toJSON: jest.fn(() => ({
+      find: mockPromiseResult
+    }))
+  };
+
+  mockContainedIn.mockImplementation(() => mockQuery);
+  mockIncludeReference.mockImplementation(() => mockQuery);
+  mockStack.mockImplementation(() => ({
+    ContentType: (contentType) => ({
+      Query: () => mockQuery,
+      fetch: () => mockFetch(contentType)
     })
   }));
 
+  mockFetch.mockImplementation((contentType) => {
+    const schemas = {
+      shipping_address_form: {
+        content_type: {
+          schema: [
+            {
+              uid: 'countries',
+              data_type: 'reference',
+              reference_to: 'market'
+            },
+            {
+              uid: 'details',
+              data_type: 'group',
+              schema: [
+                {
+                  uid: 'address_form',
+                  data_type: 'reference',
+                  reference_to: 'address_form'
+                }
+              ]
+            },
+            {
+              uid: 'promo_blocks',
+              data_type: 'blocks',
+              blocks: [
+                {
+                  uid: 'hero',
+                  schema: [
+                    {
+                      uid: 'banner',
+                      data_type: 'reference',
+                      reference_to: 'banner'
+                    }
+                  ]
+                }
+              ]
+            }
+          ]
+        }
+      },
+      address_form: {
+        content_type: {
+          schema: [
+            {
+              uid: 'address_elements',
+              data_type: 'reference',
+              reference_to: 'address_form_field'
+            }
+          ]
+        }
+      },
+      market: {
+        content_type: {
+          schema: []
+        }
+      },
+      banner: {
+        content_type: {
+          schema: []
+        }
+      },
+      address_form_field: {
+        content_type: {
+          schema: [
+            {
+              uid: 'field_config',
+              data_type: 'reference',
+              reference_to: 'field_config'
+            }
+          ]
+        }
+      },
+      field_config: {
+        content_type: {
+          schema: [
+            {
+              uid: 'validation_rule',
+              data_type: 'reference',
+              reference_to: 'validation_rule'
+            }
+          ]
+        }
+      },
+      validation_rule: {
+        content_type: {
+          schema: [
+            {
+              uid: 'too_deep_reference',
+              data_type: 'reference',
+              reference_to: 'too_deep_reference'
+            }
+          ]
+        }
+      },
+      too_deep_reference: {
+        content_type: {
+          schema: [
+            {
+              uid: 'should_not_be_included',
+              data_type: 'reference',
+              reference_to: 'market'
+            }
+          ]
+        }
+      }
+    };
+
+    return Promise.resolve(schemas[contentType] || {content_type: {schema: []}});
+  });
+
   jest.mock("contentstack", () => ({Stack: mockStack}));
 });
 
 afterEach(() => {
   mockSinglePromiseResult.mockReset();
   mockPromiseResult.mockReset();
+  mockContainedIn.mockReset();
+  mockIncludeReference.mockReset();
+  mockFetch.mockReset();
   //jest.resetAllMocks(); don't reset the mockStack function
 });
 
@@ -71,7 +197,7 @@ const mockResults = () => {
   mockPromiseResult.mockResolvedValueOnce(checkoutAdrStrings);
   mockSinglePromiseResult.mockResolvedValueOnce(singleCheckoutAdrStrings);
   mockSinglePromiseResult.mockResolvedValueOnce(singleCheckoutCartStrings);
-}
+};
 
 describe("ContentstackApi", () => {
   test("getSingletonEntries", async () => {
@@ -133,8 +259,95 @@ describe("ContentstackApi", () => {
       global.window = Object.create(window);
       global.window.location = { hostname };
       const {getStack} = require('../src/api');
-      getStack(env[index]);
+      getStack();
       expect(mockStack).toHaveBeenCalledWith({api_key: csCfg.apiKey, delivery_token: csCfg.deliveryToken, environment: csCfg.environment});
-    })
-  })
+    });
+  });
+
+  test('getSingletonEntries maps language code in to id', async () => {
+    mockSinglePromiseResult.mockResolvedValueOnce(singleCheckoutAdrStrings);
+    const {getStack} = require('../src/api');
+    const Stack = getStack('dev');
+    await Stack.getSingletonEntries({contentTypeUIDs: ['checkout_adr_strings'], language: 'in'});
+    expect(mockSinglePromiseResult).toHaveBeenCalled();
+  });
+
+  test('getMultiEntries does not include references when includeRefs is false', async () => {
+    mockPromiseResult.mockResolvedValueOnce([[{title: 'United States'}]]);
+    const {getStack} = require('../src/api');
+    const Stack = getStack('dev');
+    await Stack.getMultiEntries('market', false, ['United States']);
+    expect(mockContainedIn).toHaveBeenCalledWith('title', ['United States']);
+    expect(mockIncludeReference).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  test('getMultiEntries includes explicit reference paths', async () => {
+    mockPromiseResult.mockResolvedValueOnce([[{title: 'United States'}]]);
+    const {getStack} = require('../src/api');
+    const Stack = getStack('dev');
+    await Stack.getMultiEntries('market', ['countries', 'address_form.address_elements'], ['United States']);
+    expect(mockIncludeReference).toHaveBeenCalledWith(['countries', 'address_form.address_elements']);
+    expect(mockFetch).not.toHaveBeenCalled();
+  });
+
+  test('getMultiEntries discovers reference paths from schema when includeRefs is true', async () => {
+    mockPromiseResult.mockResolvedValueOnce([[{title: 'United States'}]]);
+    const {getStack} = require('../src/api');
+    const Stack = getStack('dev');
+    await Stack.getMultiEntries('shipping_address_form', true, ['United States']);
+    expect(mockFetch).toHaveBeenCalledTimes(6);
+    expect(mockIncludeReference).toHaveBeenCalledWith([
+      'countries',
+      'details.address_form',
+      'details.address_form.address_elements',
+      'details.address_form.address_elements.field_config',
+      'details.address_form.address_elements.field_config.validation_rule',
+      'promo_blocks.hero.banner'
+    ]);
+  });
+
+  test('getMultiEntries caches discovered reference paths per content type', async () => {
+    mockPromiseResult.mockResolvedValue([[{title: 'United States'}]]);
+    const {getStack} = require('../src/api');
+    const Stack = getStack('test');
+    await Stack.getMultiEntries('shipping_address_form', true, ['United States']);
+    await Stack.getMultiEntries('shipping_address_form', true, ['Canada']);
+    expect(mockFetch).toHaveBeenCalledTimes(6);
+    expect(mockIncludeReference).toHaveBeenNthCalledWith(1, [
+      'countries',
+      'details.address_form',
+      'details.address_form.address_elements',
+      'details.address_form.address_elements.field_config',
+      'details.address_form.address_elements.field_config.validation_rule',
+      'promo_blocks.hero.banner'
+    ]);
+    expect(mockIncludeReference).toHaveBeenNthCalledWith(2, [
+      'countries',
+      'details.address_form',
+      'details.address_form.address_elements',
+      'details.address_form.address_elements.field_config',
+      'details.address_form.address_elements.field_config.validation_rule',
+      'promo_blocks.hero.banner'
+    ]);
+  });
+
+  test('getMultiEntries limits automatic reference traversal to four levels deep', async () => {
+    mockPromiseResult.mockResolvedValueOnce([[{title: 'United States'}]]);
+    const {getStack} = require('../src/api');
+    const Stack = getStack('stage');
+    await Stack.getMultiEntries('shipping_address_form', true, ['United States']);
+    expect(mockIncludeReference).toHaveBeenCalledWith([
+      'countries',
+      'details.address_form',
+      'details.address_form.address_elements',
+      'details.address_form.address_elements.field_config',
+      'details.address_form.address_elements.field_config.validation_rule',
+      'promo_blocks.hero.banner'
+    ]);
+    expect(mockIncludeReference).not.toHaveBeenCalledWith(expect.arrayContaining([
+      'details.address_form.address_elements.field_config.validation_rule.too_deep_reference',
+      'details.address_form.address_elements.field_config.validation_rule.too_deep_reference.should_not_be_included'
+    ]));
+  });
 });

package/docs/CHANGELOG.md

@@ -1 +1 @@
-# [2.0.0](https://code.tls.nuskin.io/ns-am/utility/npm/contentstack-lib/compare/v1.0.0...v2.0.0) (2026-03-24)
+## [2.0.2-pa-1190.1](https://code.tls.nuskin.io/ns-am/utility/npm/contentstack-lib/compare/v2.0.1...v2.0.2-pa-1190.1) (2026-06-02)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/contentstack-lib",
-  "version": "2.0.0",
+  "version": "2.0.2-pa-1190.1",
   "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": {
@@ -19,7 +19,7 @@
   "license": "ISC",
   "homepage": "https://code.tls.nuskin.io/ns-am/utility/npm/contentstack-lib/blob/master/README.md",
   "devDependencies": {
-    "eslint": "5.16.0",
+    "eslint": "7.32.0",
     "eslint-config-google": "0.14.0",
     "eslint-config-prettier": "4.1.0",
     "eslint-plugin-json": "2.1.1",

package/src/api.js

@@ -8,6 +8,9 @@ const {contentstack: prodEnvConfig} = require(`../config/prod.json`);
 
 let env = null;
 let Stack = null;
+const referenceFieldCache = new Map();
+const contentTypeSchemaCache = new Map();
+const MAX_REFERENCE_DEPTH = 4;
 
 const COMMON_LANGUAGES = {
   'da': 'da-dk',
@@ -173,10 +176,146 @@ async function getSingletonEntries(options) {
   }
 }
 
+async function _getContentTypeSchema(contentType) {
+  if (contentTypeSchemaCache.has(contentType)) {
+    return contentTypeSchemaCache.get(contentType);
+  }
+
+  const contentTypeSchema = await Stack.ContentType(contentType).fetch();
+  const schema = contentTypeSchema.content_type.schema || [];
+  contentTypeSchemaCache.set(contentType, schema);
+  return schema;
+}
+
+async function _collectReferenceFieldPathsForSchema(schema = [], parentPath = '', visited = new Set(), depth = 0) {
+  const allPaths = [];
+
+  for (const field of schema) {
+    const currentPath = parentPath ? `${parentPath}.${field.uid}` : field.uid;
+
+    if (Array.isArray(field.schema)) {
+      const nestedSchemaPaths = await _collectReferenceFieldPathsForSchema(field.schema, currentPath, visited, depth);
+      allPaths.push(...nestedSchemaPaths);
+    }
+
+    if (field.data_type === 'blocks' && Array.isArray(field.blocks)) {
+      for (const block of field.blocks) {
+        if (Array.isArray(block.schema)) {
+          const blockPaths = await _collectReferenceFieldPathsForSchema(
+            block.schema,
+            `${currentPath}.${block.uid}`,
+            visited,
+            depth
+          );
+          allPaths.push(...blockPaths);
+        }
+      }
+    }
+
+    if (field.data_type === 'reference') {
+      const currentDepth = depth + 1;
+      if (currentDepth > MAX_REFERENCE_DEPTH) {
+        continue;
+      }
+      allPaths.push(currentPath);
+      const referenceTargets = Array.isArray(field.reference_to) ?
+        field.reference_to :
+        field.reference_to ? [field.reference_to] : [];
+
+      if (currentDepth >= MAX_REFERENCE_DEPTH) {
+        continue;
+      }
+
+      for (const referencedContentType of referenceTargets) {
+        const nestedReferencePaths = await _collectReferenceFieldPathsForContentType(
+          referencedContentType,
+          currentPath,
+          visited,
+          currentDepth
+        );
+        allPaths.push(...nestedReferencePaths);
+      }
+    }
+  }
+
+  return [...new Set(allPaths)];
+}
+
+async function _collectReferenceFieldPathsForContentType(contentType, parentPath = '', visited = new Set(), depth = 0) {
+  const visitKey = `${contentType}|${parentPath}|${depth}`;
+  if (visited.has(visitKey)) {
+    return [];
+  }
+  visited.add(visitKey);
+
+  const schema = await _getContentTypeSchema(contentType);
+  return _collectReferenceFieldPathsForSchema(schema, parentPath, visited, depth);
+}
+
+/**
+ * Resolve reference include paths from a boolean, string, or array input.
+ * @param {string} contentType
+ * @param {boolean|string|string[]} includeRefs
+ * @return {Promise<string[]>}
+ * @private
+ */
+async function _resolveIncludeRefs(contentType, includeRefs) {
+  if (!includeRefs) {
+    return [];
+  }
+
+  if (typeof includeRefs === 'string') {
+    return [includeRefs];
+  }
+
+  if (Array.isArray(includeRefs)) {
+    return includeRefs;
+  }
+
+  if (includeRefs !== true) {
+    return [];
+  }
+
+  if (referenceFieldCache.has(contentType)) {
+    return referenceFieldCache.get(contentType);
+  }
+
+  const referenceFields = await _collectReferenceFieldPathsForContentType(contentType);
+  referenceFieldCache.set(contentType, referenceFields);
+  return referenceFields;
+}
+
+/**
+ * Gets all the specified entries for a multiple content type
+ * @param {string} contentType
+ * @param {string[]} values
+ * @return {Promise<{Object}>} config
+ */
+const getMultiEntries = async (contentType, includeRefs, values) => {
+  try {
+    const resolvedIncludeRefs = await _resolveIncludeRefs(contentType, includeRefs);
+
+    let query = Stack
+      .ContentType(contentType)
+      .Query()
+      .containedIn('title', values);
+
+    if (resolvedIncludeRefs.length) {
+      query = query.includeReference(resolvedIncludeRefs);
+    }
+
+    const [results] = await query.toJSON().find();
+
+    return results;
+  } catch(err) {
+    console.error(err);
+  }
+};
+
 /**
  * Returns contentstack Stack object initialized with the api key, deliveryToken, and extended with custom functionality
  * @param {'dev' | 'test' | 'stage' | 'prod'} envrnmnt
- * @return {Object} Stack - contentstack Stack sdk object with additional getStrings function
+ * @return {Object} Stack - contentstack Stack sdk object with additional helper functions
  */
 function getStack(envrnmnt) {
   if (!envrnmnt) {
@@ -192,11 +331,14 @@ function getStack(envrnmnt) {
   }
 
   env = envrnmnt;
-  const {apiKey: api_key, deliveryToken: delivery_token, environment} = getConfig(env)
-  Stack = Contentstack.Stack({api_key, delivery_token, environment})
+  referenceFieldCache.clear();
+  contentTypeSchemaCache.clear();
+  const {apiKey: api_key, deliveryToken: delivery_token, environment} = getConfig(env);
+  Stack = Contentstack.Stack({api_key, delivery_token, environment});
 
   // extend the Stack with a custom function to get translations
   Stack.getSingletonEntries = getSingletonEntries;
+  Stack.getMultiEntries = getMultiEntries;
 
   return Stack;
 }

package/src/index.js

@@ -5,9 +5,8 @@
 
 "use strict";
 
-const {getStack, init} = require("./api.js");
+const {getStack} = require("./api.js");
 
 module.exports = {
-  init,
   getStack
 };