@nuskin/contentstack-lib 2.1.0-pa-1117.9 → 2.1.0-pa-1117.11

package/README.md

@@ -7,7 +7,6 @@ This project extends the Contentstack delivery sdk, to be shared between the bac
 getSingletonEntries TAKES AN OPTION CALLED mergeWithFallback.  IF THAT IS SET TO TRUE THEN IT WILL MERGE THE RESULTS
 FOR COMMON SPANISH AND MX-es FOR EXAMPLE.
 4. getSingletonEntries also allows you to convert the keys from snake case to camel case.
-5. It extends the stack with getAddressForms and getShippingAddressForms for address form content types.
 
 ## Installing
 
@@ -55,82 +54,6 @@ const [
     mergeWithFallback: true
   });
 
-// Get address forms for a list of countries.
-// By default the returned keys are snake_case.
-const addressForms = await Stack.getAddressForms(['United States']);
-
-// Example result:
-// [
-//   {
-//     address_elements: [
-//       {
-//         field: 'address1',
-//         width: 'full',
-//         editable: true,
-//         max_length: 40,
-//         required: true
-//       }
-//     ],
-//     postal_code_regex: '^[0-9]{5}(?:-[0-9]{4})?$',
-//     verify_after_autocomplete: true,
-//     wrap_address1_to_address2: false
-//   }
-// ]
-
-// Pass true as the second parameter to camelCase the returned keys.
-const camelizedAddressForms = await Stack.getAddressForms(['United States'], true);
-
-// Get shipping address forms with referenced address form fields expanded.
-// countries is normalized to a list of { code, name } objects.
-const shippingAddressForms = await Stack.getShippingAddressForms(['United States']);
-
-// Example result:
-// [
-//   {
-//     countries: [
-//       {
-//         code: 'US',
-//         name: 'United States'
-//       }
-//     ],
-//     pre_address_fields: [
-//       {
-//         field: 'givenName',
-//         width: 'half',
-//         editable: true,
-//         max_length: 30,
-//         required: true
-//       }
-//     ],
-//     address_form: {
-//       address_elements: [
-//         {
-//           field: 'address1',
-//           width: 'full',
-//           editable: true,
-//           max_length: 40,
-//           required: true
-//         }
-//       ],
-//       postal_code_regex: '^[0-9]{5}(?:-[0-9]{4})?$',
-//       verify_after_autocomplete: true,
-//       wrap_address1_to_address2: false
-//     },
-//     post_address_fields: [
-//       {
-//         field: 'mobilePhone',
-//         width: 'full',
-//         editable: true,
-//         max_length: 20,
-//         required: true
-//       }
-//     ]
-//   }
-// ]
-
-// Pass true as the second parameter to camelCase the returned keys.
-const camelizedShippingAddressForms = await Stack.getShippingAddressForms(['United States'], true);
-
 // We could possibly add functionality to return the list of regions markets and languages in a single object structure
 ```
 

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,34 +45,76 @@ function getConfig(env) {
 }
 
 beforeEach(() => {
-  mockStack.mockImplementation(() => ({
-    ContentType: () => ({
-      Query: () => ({
-        language: () => ({
-          includeFallback: () => ({
-            toJSON: () => ({
-              find: mockPromiseResult,
-              findOne: mockSinglePromiseResult
-            })
-          })
-        }),
-        containedIn: () => ({
-          includeReference: () => ({
-            toJSON: () => ({
-              find: mockPromiseResult
-            })
-          })
+  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: () => ({
+      Query: () => mockQuery,
+      fetch: mockFetch
     })
   }));
 
+  mockFetch.mockResolvedValue({
+    content_type: {
+      schema: [
+        {
+          uid: 'countries',
+          data_type: 'reference'
+        },
+        {
+          uid: 'details',
+          data_type: 'group',
+          schema: [
+            {
+              uid: 'address_form',
+              data_type: 'reference'
+            }
+          ]
+        },
+        {
+          uid: 'promo_blocks',
+          data_type: 'blocks',
+          blocks: [
+            {
+              uid: 'hero',
+              schema: [
+                {
+                  uid: 'banner',
+                  data_type: 'reference'
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  });
+
   jest.mock("contentstack", () => ({Stack: mockStack}));
 });
 
 afterEach(() => {
   mockSinglePromiseResult.mockReset();
   mockPromiseResult.mockReset();
+  mockContainedIn.mockReset();
+  mockIncludeReference.mockReset();
+  mockFetch.mockReset();
   //jest.resetAllMocks(); don't reset the mockStack function
 });
 
@@ -78,28 +123,7 @@ const mockResults = () => {
   mockPromiseResult.mockResolvedValueOnce(checkoutAdrStrings);
   mockSinglePromiseResult.mockResolvedValueOnce(singleCheckoutAdrStrings);
   mockSinglePromiseResult.mockResolvedValueOnce(singleCheckoutCartStrings);
-}
-
-const addressFormFieldEntries = [
-  {
-    field: 'address1',
-    width: 'full',
-    editable: true,
-    max_length: '40',
-    required: true,
-    api_mappings: ['address1'],
-    autocomplete_token: 'address-line1'
-  },
-  {
-    field: 'postalCode',
-    width: 'half',
-    editable: false,
-    max_length: '10',
-    required: false,
-    api_mappings: ['postalCode'],
-    validation_message: 'Invalid postal code'
-  }
-];
+};
 
 describe("ContentstackApi", () => {
   test("getSingletonEntries", async () => {
@@ -166,380 +190,62 @@ describe("ContentstackApi", () => {
     });
   });
 
-  test('extractAddressFormFields maps address form field entries', () => {
-    const {getStack} = require('../src/api');
-    const Stack = getStack('dev');
-    expect(Stack.extractAddressFormFields(addressFormFieldEntries)).toStrictEqual([
-      {
-        field: 'address1',
-        width: 'full',
-        editable: true,
-        max_length: 40,
-        required: true,
-        api_mappings: ['address1'],
-        autocomplete_token: 'address-line1'
-      },
-      {
-        field: 'postalCode',
-        width: 'half',
-        editable: false,
-        max_length: 10,
-        required: false,
-        api_mappings: ['postalCode'],
-        validation_message: 'Invalid postal code'
-      }
-    ]);
-  });
-
-  test('extractAddressFormFields camelcases address form field entries', () => {
-    const {getStack} = require('../src/api');
-    const Stack = getStack('dev');
-    expect(Stack.extractAddressFormFields(addressFormFieldEntries, true)).toStrictEqual([
-      {
-        field: 'address1',
-        width: 'full',
-        editable: true,
-        maxLength: 40,
-        required: true,
-        apiMappings: ['address1'],
-        autocompleteToken: 'address-line1'
-      },
-      {
-        field: 'postalCode',
-        width: 'half',
-        editable: false,
-        maxLength: 10,
-        required: false,
-        apiMappings: ['postalCode'],
-        validationMessage: 'Invalid postal code'
-      }
-    ]);
-  });
-
-  test('extractAddressFormFields returns an empty list when no entries are provided', () => {
-    const {getStack} = require('../src/api');
-    const Stack = getStack('dev');
-    expect(Stack.extractAddressFormFields()).toStrictEqual([]);
-  });
-
-  test('getAddressForms maps address_elements', async () => {
-    mockPromiseResult.mockResolvedValueOnce([[
-      {
-        title: 'United States',
-        address_elements: addressFormFieldEntries,
-        postal_code_regex: '^[0-9]{5}(?:-[0-9]{4})?$',
-        verify_after_autocomplete: true,
-        wrap_address1_to_address2: false,
-        allowed_countries: ['US', 'CA']
-      }
-    ]]);
-    const {getStack} = require('../src/api');
-    const Stack = getStack('dev');
-    await expect(Stack.getAddressForms(['United States'])).resolves.toStrictEqual([
-      {
-        address_elements: [
-          {
-            field: 'address1',
-            width: 'full',
-            editable: true,
-            max_length: 40,
-            required: true,
-            api_mappings: ['address1'],
-            autocomplete_token: 'address-line1'
-          },
-          {
-            field: 'postalCode',
-            width: 'half',
-            editable: false,
-            max_length: 10,
-            required: false,
-            api_mappings: ['postalCode'],
-            validation_message: 'Invalid postal code'
-          }
-        ],
-        postal_code_regex: '^[0-9]{5}(?:-[0-9]{4})?$',
-        verify_after_autocomplete: true,
-        wrap_address1_to_address2: false,
-        allowed_countries: ['US', 'CA']
-      }
-    ]);
-  });
-
-  test('getAddressForms camelcases returned field names', async () => {
-    mockPromiseResult.mockResolvedValueOnce([[
-      {
-        address_elements: addressFormFieldEntries,
-        postal_code_regex: '^[0-9]{5}(?:-[0-9]{4})?$',
-        verify_after_autocomplete: true,
-        wrap_address1_to_address2: false,
-        allowed_countries: ['US', 'CA']
-      }
-    ]]);
+  test('getSingletonEntries maps language code in to id', async () => {
+    mockSinglePromiseResult.mockResolvedValueOnce(singleCheckoutAdrStrings);
     const {getStack} = require('../src/api');
     const Stack = getStack('dev');
-    await expect(Stack.getAddressForms(['United States'], true)).resolves.toStrictEqual([
-      {
-        addressElements: [
-          {
-            field: 'address1',
-            width: 'full',
-            editable: true,
-            maxLength: 40,
-            required: true,
-            apiMappings: ['address1'],
-            autocompleteToken: 'address-line1'
-          },
-          {
-            field: 'postalCode',
-            width: 'half',
-            editable: false,
-            maxLength: 10,
-            required: false,
-            apiMappings: ['postalCode'],
-            validationMessage: 'Invalid postal code'
-          }
-        ],
-        postalCodeRegex: '^[0-9]{5}(?:-[0-9]{4})?$',
-        verifyAfterAutocomplete: true,
-        wrapAddress1ToAddress2: false,
-        allowedCountries: ['US', 'CA']
-      }
-    ]);
+    await Stack.getSingletonEntries({contentTypeUIDs: ['checkout_adr_strings'], language: 'in'});
+    expect(mockSinglePromiseResult).toHaveBeenCalled();
   });
 
-  test('getAddressForms returns an empty list when no forms are found', async () => {
-    mockPromiseResult.mockResolvedValueOnce([undefined]);
+  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 expect(Stack.getAddressForms(['Unknown'])).resolves.toStrictEqual([]);
+    await Stack.getMultiEntries('market', false, ['United States']);
+    expect(mockContainedIn).toHaveBeenCalledWith('title', ['United States']);
+    expect(mockIncludeReference).not.toHaveBeenCalled();
+    expect(mockFetch).not.toHaveBeenCalled();
   });
 
-  test('getSingletonEntries maps language code in to id', async () => {
-    mockSinglePromiseResult.mockResolvedValueOnce(singleCheckoutAdrStrings);
+  test('getMultiEntries includes explicit reference paths', async () => {
+    mockPromiseResult.mockResolvedValueOnce([[{title: 'United States'}]]);
     const {getStack} = require('../src/api');
     const Stack = getStack('dev');
-    await Stack.getSingletonEntries({contentTypeUIDs: ['checkout_adr_strings'], language: 'in'});
-    expect(mockSinglePromiseResult).toHaveBeenCalled();
+    await Stack.getMultiEntries('market', ['countries', 'address_form.address_elements'], ['United States']);
+    expect(mockIncludeReference).toHaveBeenCalledWith(['countries', 'address_form.address_elements']);
+    expect(mockFetch).not.toHaveBeenCalled();
   });
 
-  test('getShippingAddressForms maps nested address form fields', async () => {
-    mockPromiseResult.mockResolvedValueOnce([[
-      {
-        title: 'United States',
-        countries: [
-          {
-            countries: [
-              {
-                country_code: 'US',
-                country_name: 'United States'
-              },
-              {
-                country_code: 'CA',
-                country_name: 'Canada'
-              }
-            ]
-          }
-        ],
-        pre_address_fields: [addressFormFieldEntries[0]],
-        address_form: [
-          {
-            title: 'default',
-            address_elements: addressFormFieldEntries,
-            postal_code_regex: '^[0-9]{5}(?:-[0-9]{4})?$',
-            verify_after_autocomplete: true,
-            wrap_address1_to_address2: false,
-            allowed_countries: ['US', 'CA']
-          }
-        ],
-        post_address_fields: [addressFormFieldEntries[1]],
-        display_name: 'North America'
-      }
-    ]]);
+  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 expect(Stack.getShippingAddressForms(['United States'])).resolves.toStrictEqual([
-      {
-        countries: [
-          {
-            code: 'US',
-            name: 'United States'
-          },
-          {
-            code: 'CA',
-            name: 'Canada'
-          }
-        ],
-        pre_address_fields: [
-          {
-            field: 'address1',
-            width: 'full',
-            editable: true,
-            max_length: 40,
-            required: true,
-            api_mappings: ['address1'],
-            autocomplete_token: 'address-line1'
-          }
-        ],
-        address_form: {
-          address_elements: [
-            {
-              field: 'address1',
-              width: 'full',
-              editable: true,
-              max_length: 40,
-              required: true,
-              api_mappings: ['address1'],
-              autocomplete_token: 'address-line1'
-            },
-            {
-              field: 'postalCode',
-              width: 'half',
-              editable: false,
-              max_length: 10,
-              required: false,
-              api_mappings: ['postalCode'],
-              validation_message: 'Invalid postal code'
-            }
-          ],
-          postal_code_regex: '^[0-9]{5}(?:-[0-9]{4})?$',
-          verify_after_autocomplete: true,
-          wrap_address1_to_address2: false,
-          allowed_countries: ['US', 'CA']
-        },
-        post_address_fields: [
-          {
-            field: 'postalCode',
-            width: 'half',
-            editable: false,
-            max_length: 10,
-            required: false,
-            api_mappings: ['postalCode'],
-            validation_message: 'Invalid postal code'
-          }
-        ],
-        display_name: 'North America'
-      }
+    await Stack.getMultiEntries('shipping_address_form', true, ['United States']);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockIncludeReference).toHaveBeenCalledWith([
+      'countries',
+      'details.address_form',
+      'promo_blocks.hero.banner'
     ]);
   });
 
-  test('getShippingAddressForms camelcases returned field names', async () => {
-    mockPromiseResult.mockResolvedValueOnce([[
-      {
-        title: 'United States',
-        countries: [
-          {
-            countries: [
-              {
-                country_code: 'US',
-                country_name: 'United States'
-              },
-              {
-                country_code: 'CA',
-                country_name: 'Canada'
-              }
-            ]
-          }
-        ],
-        pre_address_fields: [addressFormFieldEntries[0]],
-        address_form: [
-          {
-            title: 'default',
-            address_elements: addressFormFieldEntries,
-            postal_code_regex: '^[0-9]{5}(?:-[0-9]{4})?$',
-            verify_after_autocomplete: true,
-            wrap_address1_to_address2: false,
-            allowed_countries: ['US', 'CA']
-          }
-        ],
-        post_address_fields: [addressFormFieldEntries[1]],
-        display_name: 'North America'
-      }
-    ]]);
+  test('getMultiEntries caches discovered reference paths per content type', async () => {
+    mockPromiseResult.mockResolvedValue([[{title: 'United States'}]]);
     const {getStack} = require('../src/api');
-    const Stack = getStack('dev');
-    await expect(Stack.getShippingAddressForms(['United States'], true)).resolves.toStrictEqual([
-      {
-        countries: [
-          {
-            code: 'US',
-            name: 'United States'
-          },
-          {
-            code: 'CA',
-            name: 'Canada'
-          }
-        ],
-        preAddressFields: [
-          {
-            field: 'address1',
-            width: 'full',
-            editable: true,
-            maxLength: 40,
-            required: true,
-            apiMappings: ['address1'],
-            autocompleteToken: 'address-line1'
-          }
-        ],
-        addressForm: {
-          addressElements: [
-            {
-              field: 'address1',
-              width: 'full',
-              editable: true,
-              maxLength: 40,
-              required: true,
-              apiMappings: ['address1'],
-              autocompleteToken: 'address-line1'
-            },
-            {
-              field: 'postalCode',
-              width: 'half',
-              editable: false,
-              maxLength: 10,
-              required: false,
-              apiMappings: ['postalCode'],
-              validationMessage: 'Invalid postal code'
-            }
-          ],
-          postalCodeRegex: '^[0-9]{5}(?:-[0-9]{4})?$',
-          verifyAfterAutocomplete: true,
-          wrapAddress1ToAddress2: false,
-          allowedCountries: ['US', 'CA']
-        },
-        postAddressFields: [
-          {
-            field: 'postalCode',
-            width: 'half',
-            editable: false,
-            maxLength: 10,
-            required: false,
-            apiMappings: ['postalCode'],
-            validationMessage: 'Invalid postal code'
-          }
-        ],
-        displayName: 'North America'
-      }
+    const Stack = getStack('test');
+    await Stack.getMultiEntries('shipping_address_form', true, ['United States']);
+    await Stack.getMultiEntries('shipping_address_form', true, ['Canada']);
+    expect(mockFetch).toHaveBeenCalledTimes(1);
+    expect(mockIncludeReference).toHaveBeenNthCalledWith(1, [
+      'countries',
+      'details.address_form',
+      'promo_blocks.hero.banner'
     ]);
-  });
-
-  test('getShippingAddressForms returns empty nested data when optional references are missing', async () => {
-    mockPromiseResult.mockResolvedValueOnce([[
-      {
-        countries: [],
-        pre_address_fields: undefined,
-        address_form: [],
-        post_address_fields: undefined
-      }
-    ]]);
-    const {getStack} = require('../src/api');
-    const Stack = getStack('dev');
-    await expect(Stack.getShippingAddressForms(['Unknown'])).resolves.toStrictEqual([
-      {
-        countries: [],
-        pre_address_fields: [],
-        address_form: undefined,
-        post_address_fields: []
-      }
+    expect(mockIncludeReference).toHaveBeenNthCalledWith(2, [
+      'countries',
+      'details.address_form',
+      'promo_blocks.hero.banner'
     ]);
   });
 });

package/docs/CHANGELOG.md

@@ -1 +1 @@
-# [2.1.0-pa-1117.9](https://code.tls.nuskin.io/ns-am/utility/npm/contentstack-lib/compare/v2.1.0-pa-1117.8...v2.1.0-pa-1117.9) (2026-05-18)
+# [2.1.0-pa-1117.11](https://code.tls.nuskin.io/ns-am/utility/npm/contentstack-lib/compare/v2.1.0-pa-1117.10...v2.1.0-pa-1117.11) (2026-05-21)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nuskin/contentstack-lib",
-  "version": "2.1.0-pa-1117.9",
+  "version": "2.1.0-pa-1117.11",
   "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": {

package/src/api.js

@@ -8,6 +8,7 @@ const {contentstack: prodEnvConfig} = require(`../config/prod.json`);
 
 let env = null;
 let Stack = null;
+const referenceFieldCache = new Map();
 
 const COMMON_LANGUAGES = {
   'da': 'da-dk',
@@ -22,22 +23,6 @@ const COMMON_LANGUAGES = {
   'tr': 'tr-tr'
 };
 
-const CONTENTSTACK_SYSTEM_FIELDS = new Set([
-  '_content_type_uid',
-  'uid',
-  'title',
-  'tags',
-  'locale',
-  'created_by',
-  'updated_by',
-  'created_at',
-  'updated_at',
-  'ACL',
-  '_version',
-  '_in_progress',
-  'publish_details'
-]);
-
 /**
  * Gets the correct contentstack config settings
  * @param {string} env
@@ -190,108 +175,99 @@ async function getSingletonEntries(options) {
 }
 
 /**
- * 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 [results] = await Stack
-      .ContentType(contentType)
-      .Query()
-      .containedIn('title', values)
-      .includeReference(includeRefs)
-      .toJSON()
-      .find();
-
-    return results;
-  } catch(err) {
-    console.error(err);
-  }
-}
-
-/**
- * Removes Contentstack-managed metadata fields while preserving custom content fields.
- * @param {Object} entry
- * @return {Object}
+ * Collect reference field paths recursively from a content type schema.
+ * @param {Object[]} schema
+ * @param {string=} parentPath
+ * @return {string[]}
  * @private
  */
-const _omitContentstackSystemFields = (entry = {}) => {
-  return Object.fromEntries(
-    Object.entries(entry).filter(([key]) => !CONTENTSTACK_SYSTEM_FIELDS.has(key))
-  );
+function _collectReferenceFieldPaths(schema = [], parentPath = '') {
+  return schema.flatMap((field) => {
+    const currentPath = parentPath ? `${parentPath}.${field.uid}` : field.uid;
+    const nestedSchemaPaths = Array.isArray(field.schema) ?
+      _collectReferenceFieldPaths(field.schema, currentPath) :
+      [];
+    const blockPaths = field.data_type === 'blocks' && Array.isArray(field.blocks) ?
+      field.blocks.flatMap((block) => {
+        return Array.isArray(block.schema) ?
+          _collectReferenceFieldPaths(block.schema, `${currentPath}.${block.uid}`) :
+          [];
+      }) :
+      [];
+
+    return [
+      ...(field.data_type === 'reference' ? [currentPath] : []),
+      ...nestedSchemaPaths,
+      ...blockPaths
+    ];
+  });
 }
 
 /**
- * Maps address form field entries into a small normalized dataset.
- * @param {Object[]} addressFormFields
- * @return {Object[]}
+ * Resolve reference include paths from a boolean, string, or array input.
+ * @param {string} contentType
+ * @param {boolean|string|string[]} includeRefs
+ * @return {Promise<string[]>}
  * @private
  */
-const _extractAddressFormFields = (addressFormFields = [], camelcase = false) => {
-  const mappedFields = addressFormFields.map((addressFormField) => {
-    const mappedField = _omitContentstackSystemFields(addressFormField);
-
-    if (mappedField.max_length !== undefined && mappedField.max_length !== null) {
-      mappedField.max_length = Number(mappedField.max_length);
-    }
+async function _resolveIncludeRefs(contentType, includeRefs) {
+  if (!includeRefs) {
+    return [];
+  }
 
-    return mappedField;
-  });
+  if (typeof includeRefs === 'string') {
+    return [includeRefs];
+  }
 
-  return camelcase ? _snakeObjectToCamel(mappedFields) : mappedFields;
-}
+  if (Array.isArray(includeRefs)) {
+    return includeRefs;
+  }
 
-const _extractAddressForm = (addressForm, camelcase = false) => {
-  if (!addressForm) {
-    return addressForm;
+  if (includeRefs !== true) {
+    return [];
   }
 
-  const mappedForm = _omitContentstackSystemFields(addressForm);
-  mappedForm.address_elements = _extractAddressFormFields(addressForm.address_elements, camelcase);
+  if (referenceFieldCache.has(contentType)) {
+    return referenceFieldCache.get(contentType);
+  }
 
-  return camelcase ? _snakeObjectToCamel(mappedForm) : mappedForm;
+  const contentTypeSchema = await Stack.ContentType(contentType).fetch();
+  const referenceFields = _collectReferenceFieldPaths(contentTypeSchema.content_type.schema);
+  referenceFieldCache.set(contentType, referenceFields);
+  return referenceFields;
 }
 
-const _extractShippingCountries = (countries = []) => {
-  const shippingCountries = countries[0]?.countries ?? [];
-
-  return shippingCountries.map(({country_code, country_name}) => ({
-    code: country_code,
-    name: country_name
-  }));
-}
+/**
+ * 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);
 
-const getShippingAddressForms = async (forms, camelcase = false) => {
-  const results = await _getMultiEntries(
-    'shipping_address_form',
-    ['countries', 'pre_address_fields', 'address_form', 'address_form.address_elements', 'post_address_fields'],
-    forms
-  );
-  const mappedResults = (results || []).map((result) => {
-    const mappedResult = _omitContentstackSystemFields(result);
-    mappedResult.countries = _extractShippingCountries(result.countries);
-    mappedResult.pre_address_fields = _extractAddressFormFields(result.pre_address_fields, camelcase);
-    mappedResult.address_form = _extractAddressForm(result.address_form[0], camelcase);
-    mappedResult.post_address_fields = _extractAddressFormFields(result.post_address_fields, camelcase);
-    return mappedResult;
-  });
+    let query = Stack
+      .ContentType(contentType)
+      .Query()
+      .containedIn('title', values);
 
-  return camelcase ? _snakeObjectToCamel(mappedResults) : mappedResults;
-}
+    if (resolvedIncludeRefs.length) {
+      query = query.includeReference(resolvedIncludeRefs);
+    }
 
-const getAddressForms = async (forms, camelcase = false) => {
-  const results = await _getMultiEntries('address_form', 'address_elements', forms);
-  const mappedResults = (results || []).map((result) => _extractAddressForm(result, camelcase));
+    const [results] = await query.toJSON().find();
 
-  return camelcase ? _snakeObjectToCamel(mappedResults) : mappedResults;
-}
+    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) {
@@ -307,16 +283,13 @@ 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();
+  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;
-  // extend the Stack with a custom function to get ShippingAddressForms
-  Stack.getAddressForms = getAddressForms;
-  // extend the Stack with a custom function to get ShippingAddressForms
-  Stack.getShippingAddressForms = getShippingAddressForms;
-  Stack.extractAddressFormFields = _extractAddressFormFields;
+  Stack.getMultiEntries = getMultiEntries;
 
   return Stack;
 }