@constructor-io/constructorio-node 4.2.1 → 4.3.1

package/src/modules/tasks.js

@@ -1,6 +1,5 @@
 /* eslint-disable object-curly-newline, no-underscore-dangle, max-len */
 const qs = require('qs');
-const nodeFetch = require('node-fetch').default;
 const { AbortController } = require('node-abort-controller');
 const helpers = require('../utils/helpers');
 
@@ -58,7 +57,7 @@ class Tasks {
   getAllTasks(parameters = {}, networkParameters = {}) {
     const queryParams = {};
     let requestUrl;
-    const fetch = (this.options && this.options.fetch) || nodeFetch;
+    const { fetch } = this.options;
     const controller = new AbortController();
     const { signal } = controller;
     const headers = {
@@ -134,7 +133,7 @@ class Tasks {
    */
   getTask(parameters = {}, networkParameters = {}) {
     let requestUrl;
-    const fetch = (this.options && this.options.fetch) || nodeFetch;
+    const { fetch } = this.options;
     const controller = new AbortController();
     const { signal } = controller;
     const headers = {

package/src/modules/tracker.js

@@ -1,6 +1,5 @@
 /* eslint-disable camelcase, no-underscore-dangle, no-unneeded-ternary, brace-style */
 const qs = require('qs');
-const nodeFetch = require('node-fetch').default;
 const { AbortController } = require('node-abort-controller');
 const EventEmitter = require('events');
 const helpers = require('../utils/helpers');
@@ -79,7 +78,7 @@ function applyParamsAsString(parameters, userParameters, options) {
 // Send request to server
 function send(url, userParameters, networkParameters, method = 'GET', body = {}) { // eslint-disable-line max-params
   let request;
-  const fetch = (this.options && this.options.fetch) || nodeFetch;
+  const { fetch } = this.options;
   const controller = new AbortController();
   const { signal } = controller;
   const headers = {};
@@ -273,6 +272,7 @@ class Tracker {
    * @param {object} parameters - Additional parameters to be sent with request
    * @param {string} parameters.item_name - Product item name
    * @param {string} parameters.item_id - Product item unique identifier
+   * @param {string} parameters.url - Current page URL
    * @param {string} [parameters.variation_id] - Product item variation unique identifier
    * @param {object} userParameters - Parameters relevant to the user request
    * @param {number} userParameters.sessionId - Session ID, utilized to personalize results
@@ -294,41 +294,57 @@ class Tracker {
    *     {
    *         item_name: 'Red T-Shirt',
    *         item_id: 'KMH876',
+   *         url: 'https://constructor.io/product/KMH876',
    *     },
    * );
    */
   trackItemDetailLoad(parameters, userParameters, networkParameters = {}) {
     // Ensure parameters are provided (required)
     if (parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
-      const url = `${this.options.serviceUrl}/behavior?`;
-      const queryParams = { action: 'item_detail_load' };
-      const { item_name, name, item_id, customer_id, variation_id } = parameters;
+      const requestPath = `${this.options.serviceUrl}/v2/behavioral_action/item_detail_load?`;
+      const bodyParams = {};
+      const {
+        item_name,
+        name,
+        item_id,
+        customer_id,
+        variation_id,
+        url,
+      } = parameters;
 
       // Ensure support for both item_name and name as parameters
       if (item_name) {
-        queryParams.name = item_name;
+        bodyParams.item_name = item_name;
       } else if (name) {
-        queryParams.name = name;
+        bodyParams.item_name = name;
       }
 
       // Ensure support for both item_id and customer_id as parameters
       if (item_id) {
-        queryParams.customer_id = item_id;
+        bodyParams.item_id = item_id;
       } else if (customer_id) {
-        queryParams.customer_id = customer_id;
+        bodyParams.item_id = customer_id;
       }
 
       if (variation_id) {
-        queryParams.variation_id = variation_id;
+        bodyParams.variation_id = variation_id;
+      }
+
+      if (url) {
+        bodyParams.url = url;
       }
 
-      const requestUrl = `${url}${applyParamsAsString(queryParams, userParameters, this.options)}`;
+      const requestUrl = `${requestPath}${applyParamsAsString({}, userParameters, this.options)}`;
+      const requestMethod = 'POST';
+      const requestBody = applyParams(bodyParams, userParameters, { ...this.options, requestMethod });
 
       send.call(
         this,
         requestUrl,
         userParameters,
         networkParameters,
+        requestMethod,
+        requestBody,
       );
 
       return true;
@@ -606,6 +622,8 @@ class Tracker {
    * @param {string} parameters.item_id - Product item unique identifier
    * @param {string} [parameters.variation_id] - Product item variation unique identifier
    * @param {string} [parameters.result_id] - Search result identifier (returned in response from Constructor)
+   * @param {string} [parameters.item_is_convertible] - Whether or not an item is available for a conversion
+   * @param {string} [parameters.section] - The section name for the item Ex. "Products"
    * @param {object} userParameters - Parameters relevant to the user request
    * @param {number} userParameters.sessionId - Session ID, utilized to personalize results
    * @param {number} userParameters.clientId - Client ID, utilized to personalize results
@@ -645,7 +663,16 @@ class Tracker {
       if (parameters && typeof parameters === 'object' && !Array.isArray(parameters)) {
         const url = `${this.options.serviceUrl}/autocomplete/${helpers.encodeURIComponentRFC3986(helpers.trimNonBreakingSpaces(term))}/click_through?`;
         const queryParams = {};
-        const { item_name, name, item_id, customer_id, variation_id, result_id } = parameters;
+        const {
+          item_name,
+          name,
+          item_id,
+          customer_id,
+          variation_id,
+          result_id,
+          item_is_convertible,
+          section,
+        } = parameters;
 
         // Ensure support for both item_name and name as parameters
         if (item_name) {
@@ -669,6 +696,14 @@ class Tracker {
           queryParams.result_id = result_id;
         }
 
+        if (typeof item_is_convertible === 'boolean') {
+          queryParams.item_is_convertible = item_is_convertible;
+        }
+
+        if (section) {
+          queryParams.section = section;
+        }
+
         const requestUrl = `${url}${applyParamsAsString(queryParams, userParameters, this.options)}`;
 
         send.call(
@@ -915,6 +950,7 @@ class Tracker {
    * @param {string} parameters.url - Current page URL
    * @param {string} parameters.pod_id - Pod identifier
    * @param {number} parameters.num_results_viewed - Number of results viewed
+   * @param {object[]} [parameters.items] - List of Product Item Objects
    * @param {number} [parameters.result_count] - Total number of results
    * @param {number} [parameters.result_page] - Page number of results
    * @param {string} [parameters.result_id] - Recommendation result identifier (returned in response from Constructor)
@@ -1442,7 +1478,7 @@ class Tracker {
    * @param {object} [userParameters] - Parameters relevant to the user request
    * @param {number} userParameters.sessionId - Session ID, utilized to personalize results
    * @param {number} userParameters.clientId - Client ID, utilized to personalize results
-   * @param {string} userParameters.userId - User ID, utilized to personalize results
+   * @param {string} [userParameters.userId] - User ID, utilized to personalize results
    * @param {string} [userParameters.segments] - User segments
    * @param {object} [userParameters.testCells] - User test cells
    * @param {string} [userParameters.originReferrer] - Client page URL (including path)

package/src/types/autocomplete.d.ts

@@ -0,0 +1,56 @@
+import {
+  ConstructorClientOptions,
+  NetworkParameters,
+  RequestFeature,
+  RequestFeatureVariant,
+  UserParameters,
+} from '.';
+
+export default Autocomplete;
+
+export interface AutocompleteParameters {
+  numResults?: number;
+  filters?: Record<string, any>;
+  resultsPerSection?: Record<string, number>;
+  hiddenFields?: string[];
+  variationsMap?: Record<string, any>;
+}
+
+declare class Autocomplete {
+  constructor(options: ConstructorClientOptions);
+
+  options: ConstructorClientOptions;
+
+  getAutocompleteResults(
+    query: string,
+    parameters?: AutocompleteParameters,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<AutocompleteResponse>;
+}
+
+/* Autocomplete results returned from server */
+export interface AutocompleteResponse extends Record<string, any> {
+  request: Partial<AutocompleteRequestType>;
+  sections: Record<string, Section>;
+  result_id: string;
+}
+
+export interface AutocompleteRequestType extends Record<string, any> {
+  num_results: number;
+  term: string;
+  query: string;
+  features: Partial<RequestFeature>;
+  feature_variants: Partial<RequestFeatureVariant>;
+  searchandized_items: Record<string, any>;
+}
+
+export type Section = Partial<SectionItem>[];
+
+export interface SectionItem extends Record<string, any> {
+  data: Record<string, any>;
+  is_slotted: boolean;
+  labels: Record<string, any>;
+  matched_terms: string[];
+  value: string;
+}

package/src/types/browse.d.ts

@@ -0,0 +1,140 @@
+import {
+  NetworkParameters,
+  UserParameters,
+  Collection,
+  ConstructorClientOptions,
+  Facet,
+  Feature,
+  Group,
+  RequestFeature,
+  RequestFeatureVariant,
+  ResultSources,
+  SortOption,
+  FmtOptions,
+} from '.';
+
+export default Browse;
+
+export interface BrowseParameters {
+  page?: number;
+  offset?: number;
+  resultsPerPage?: number;
+  filters?: Record<string, any>;
+  sortBy?: string;
+  sortOrder?: string;
+  section?: string;
+  fmtOptions?: FmtOptions;
+  hiddenFields?: string[];
+  hiddenFacets?: string[];
+  variationsMap?: Record<string, any>;
+}
+
+declare class Browse {
+  constructor(options: ConstructorClientOptions);
+
+  options: ConstructorClientOptions;
+
+  getBrowseResults(
+    filterName: string,
+    filterValue: string,
+    parameters?: BrowseParameters,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<GetBrowseResultsResponse>;
+
+  getBrowseResultsForItemIds(
+    itemIds: string[],
+    parameters?: BrowseParameters,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<GetBrowseResultsForItemIdsResponse>;
+
+  getBrowseGroups(
+    parameters?: Pick<BrowseParameters, 'filters' | 'section' | 'fmtOptions'>,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<GetBrowseGroupsResponse>;
+
+  getBrowseFacets(
+    parameters?: Pick<
+      BrowseParameters,
+      'page' | 'offset' | 'section' | 'fmtOptions' | 'resultsPerPage'
+    >,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<GetBrowseFacetsResponse>;
+
+  getBrowseFacetOptions(
+    facetName: string,
+    parameters?: Pick<BrowseParameters, 'section' | 'fmtOptions'>,
+    userParameters?: UserParameters,
+    networkParameters?: NetworkParameters
+  ): Promise<GetBrowseFacetOptionsResponse>;
+}
+
+/* Browse results returned from server */
+interface BrowseResponse<ResponseType> extends Record<string, any> {
+  request?: Partial<BrowseRequestType>;
+  response?: Partial<ResponseType>;
+  result_id?: string;
+  ad_based?: boolean;
+}
+
+export type GetBrowseResultsResponse =
+  BrowseResponse<GetBrowseResultsResponseData>;
+export type GetBrowseResultsForItemIdsResponse =
+  BrowseResponse<GetBrowseResultsResponseData>;
+export type GetBrowseGroupsResponse = BrowseResponse<
+  Pick<
+    GetBrowseResultsResponseData,
+    'result_sources' | 'groups' | 'refined_content'
+  >
+>;
+export type GetBrowseFacetsResponse = BrowseResponse<
+  Pick<GetBrowseResultsResponseData, 'facets' | 'total_num_results'>
+>;
+export type GetBrowseFacetOptionsResponse = BrowseResponse<
+  Pick<GetBrowseResultsResponseData, 'facets'>
+>;
+
+export interface GetBrowseResultsResponseData extends Record<string, any> {
+  result_sources: Partial<ResultSources>;
+  facets: Partial<Facet>[];
+  groups: Partial<Group>[];
+  results: Partial<BrowseResultData>[];
+  sort_options: Partial<SortOption>[];
+  refined_content: Record<string, any>[];
+  total_num_results: number;
+  features: Partial<Feature>[];
+  collection: Partial<Collection>;
+}
+
+export interface BrowseResultData extends Record<string, any> {
+  matched_terms: string[];
+  data: {
+    id: string;
+    [key: string]: any;
+  };
+  value: string;
+  is_slotted: false;
+  labels: Record<string, any>;
+  variations: Record<string, any>[];
+}
+
+export interface BrowseRequestType extends Record<string, any> {
+  browse_filter_name: string;
+  browse_filter_value: string;
+  filter_match_types: Record<string, any>;
+  filters: Record<string, any>;
+  fmt_options: Record<string, any>;
+  num_results_per_page: number;
+  page: number;
+  section: string;
+  sort_by: string;
+  sort_order: string;
+  term: string;
+  query: string;
+  features: Partial<RequestFeature>;
+  feature_variants: Partial<RequestFeatureVariant>;
+  searchandized_items: Record<string, any>;
+}