@miso.ai/client-sdk-ui 1.12.3 → 1.12.4

package/src/workflow/hybrid-search.js

@@ -1,15 +1,18 @@
 import { API } from '@miso.ai/commons';
-import Workflow from './base.js';
 import SearchBasedWorkflow from './search-based.js';
 import AnswerBasedWorkflow from './answer-based.js';
 import { ROLE, WORKFLOW_CONFIGURABLE } from '../constants.js';
 import { SearchBoxLayout, TextLayout, HorizontalLayout } from '../layout/index.js';
 import { compactArticle, compactArticleInfoBlock } from '../layout/templates.js';
 import HybridSearchAnswer from './hybrid-search-answer.js';
-import HybridSearchResults from './hybrid-search-results.js';
 import HybridSearchViewsActor from './hybrid-search-views.js';
 import { makeConfigurable } from './options/index.js';
 
+import { mergeApiPayloads } from '@miso.ai/commons';
+import { STATUS, REQUEST_TYPE } from '../constants.js';
+import { writeMisoIdToSession, writeQuestionSourceToPayload, disableAnswerForNonQueryRequest, carryOverQuestionIdToData, writeAnswerInfoToInteraction } from './processors.js';
+import { makeAutocompletable } from './autocompletable.js';
+
 const DEFAULT_API_OPTIONS = Object.freeze({
   group: API.GROUP.ASK,
   name: API.NAME.SEARCH,
@@ -88,7 +91,13 @@ const ROLES_OPTIONS = Object.freeze({
   }),
 });
 
-export default class HybridSearch extends Workflow {
+const EXTRA_OPTIONS = Object.freeze({
+  api: Object.freeze({
+    polling: false,
+  }),
+});
+
+export default class HybridSearch extends SearchBasedWorkflow {
 
   constructor(plugin, client) {
     super({
@@ -97,41 +106,29 @@ export default class HybridSearch extends Workflow {
       client,
       roles: ROLES_OPTIONS,
       defaults: DEFAULT_OPTIONS,
+      extraOptions: EXTRA_OPTIONS,
     });
   }
 
   _initProperties(args) {
     super._initProperties(args);
-    this._subworkflows = [
-      this._answer = new HybridSearchAnswer(this),
-      this._results = new HybridSearchResults(this),
-    ];
+    this._initAutocomplete(args);
+    this._answer = new HybridSearchAnswer(this);
   }
 
-  _getSubworkflow(name) {
-    switch (name) {
-      case 'answer':
-        return this._answer;
-      case 'results':
-        return this._results;
-      default:
-        throw new Error(`Invalid subworkflow: ${name}`);
-    }
-  }
-
-  _initActors() {
-    this._views = new HybridSearchViewsActor(this);
-  }
-
-  _initSession() {
-    this._results._sessions.restart();
-    this._answer._sessions.restart();
+  _initActors(args) {
+    super._initActors(args);
+    this._views = new HybridSearchViewsActor({
+      results: this._views,
+      answer: this._answer._views,
+    });
   }
 
-  // configuration //
-  useLink(fn, options) {
-    this._answer.useLink(fn, options);
-    return this;
+  restart({ type } = {}) {
+    super.restart();
+    if (!type || type === REQUEST_TYPE.QUERY) {
+      this._answer.restart();
+    }
   }
 
   // properties //
@@ -139,46 +136,95 @@ export default class HybridSearch extends Workflow {
     return this._answer;
   }
 
-  get results() {
-    return this._results;
-  }
-
   get questionId() {
     return this._answer.questionId;
   }
 
-  get filters() {
-    return this._results._views.filters;
+  // query //
+  _buildPayload(payload, type) {
+    payload = super._buildPayload(payload, type);
+    // borrow the work from the sibling
+    payload = disableAnswerForNonQueryRequest(payload, type);
+    payload = writeQuestionSourceToPayload(payload);
+    payload = this._writeQuestionIdToPayload(payload, type);
+    if (payload.answer !== false) {
+      // uses autoQuery params, so we want to apply to this workflow
+      payload = AnswerBasedWorkflow.prototype._writeWikiLinkTemplateToPayload.call(this, payload);
+    }
+    return payload;
   }
 
-  get autocomplete() {
-    return this._answer.autocomplete;
+  _buildOrderBy(sort) {
+    if (!sort) {
+      return undefined;
+    }
+    // works differently than search
+    return sort.field;
   }
 
-  // query //
-  autoQuery(options) {
-    this._answer.autoQuery(options);
+  _writeQuestionIdToPayload(payload, type) {
+    if (type === REQUEST_TYPE.QUERY) {
+      return payload;
+    }
+    const question_id = this._answer.questionId;
+    if (!question_id) {
+      return payload;
+    }
+    return mergeApiPayloads(payload, {
+      metadata: {
+        question_id,
+      },
+    });
+  }
+
+  // data //
+  _defaultProcessData(data, oldData) {
+    data = super._defaultProcessData(data, oldData);
+    writeMisoIdToSession(data);
+    return data;
   }
 
-  query(args) {
-    this._answer.query(args);
+  _updateDataInHub(data, oldData) {
+    this._dispatchDataToAnswerWorkflow(data);
+    data = carryOverQuestionIdToData(data, oldData); // TODO: may as well move to process data
+    super._updateDataInHub(data, oldData);
+  }
+
+  _dispatchDataToAnswerWorkflow(data) {
+    const { request } = data;
+    if (!request) {
+      return;
+    }
+    const { type, payload } = request;
+    if (type !== REQUEST_TYPE.QUERY || !payload || payload.answer === false) {
+      return;
+    }
+    switch (data.status) {
+      case STATUS.LOADING:
+        // share the loading status with its sibling
+        this._answer._doLoading(data);
+        break;
+      case STATUS.READY:
+        // start a query with retrieved question ID, if any
+        this._answer._queryWithQuestionId(data);
+        break;
+    }
   }
 
   // interactions //
   _defaultProcessInteraction(payload, args) {
-    payload = this._answer._defaultProcessInteraction0(payload, args);
-    payload = this._results._defaultProcessInteraction0(payload, args);
+    payload = super._defaultProcessInteraction(payload, args);
+    payload = writeAnswerInfoToInteraction(payload, args);
     return payload;
   }
 
   // destroy //
   _destroy() {
-    for (const subworkflow of this._subworkflows) {
-      subworkflow.destroy();
-    }
+    this._answer.destroy();
     super._destroy();
   }
 
 }
 
 makeConfigurable(HybridSearch.prototype, [WORKFLOW_CONFIGURABLE.PAGINATION, WORKFLOW_CONFIGURABLE.FILTERS]);
+makeAutocompletable(HybridSearch.prototype);

package/src/workflow/options/auto-query.js

@@ -1,10 +1,17 @@
 import { trimObj } from '@miso.ai/commons';
-import { ROLE } from '../../constants.js';
+import { ROLE, QUESTION_SOURCE } from '../../constants.js';
 
 export const DEFAULT_AUTO_QUERY_PARAM = 'q';
 export const DEFAULT_AUTO_QUERY_SOURCE_PARAM = 'qs';
 
-export function normalizeAutoQueryOptions({ setValue = true, focus = true, updateUrl = true, param = DEFAULT_AUTO_QUERY_PARAM, sourceParam = DEFAULT_AUTO_QUERY_SOURCE_PARAM, ...options } = {}) {
+export function normalizeAutoQueryOptions({
+  setValue = true,
+  focus = true,
+  updateUrl = true,
+  param = DEFAULT_AUTO_QUERY_PARAM,
+  sourceParam = DEFAULT_AUTO_QUERY_SOURCE_PARAM,
+  ...options
+} = {}) {
   return { setValue, focus, updateUrl, param, sourceParam, ...options };
 }
 
@@ -27,3 +34,30 @@ export function autoQuery(options = {}) {
     this.query(trimObj({ q, qs }));
   }
 }
+
+export function updateQueryParametersInUrl({ value, request }) {
+  if (!this._autoQuery || !this._autoQuery.updateUrl) {
+    return;
+  }
+  const { param, sourceParam } = this._autoQuery;
+  const query = (value && (value.question || value.keyword)) || (request && request.payload && (request.payload.question || request.payload.q));
+  const querySource = request && request.payload && request.payload.metadata && request.payload.metadata.question_source;
+
+  if (!query) {
+    return; // at initial phase
+  }
+
+  const url = new URL(window.location);
+  const currentQuery = url.searchParams.get(param);
+  const currentQuerySource = url.searchParams.get(sourceParam) || QUESTION_SOURCE.ORGANIC;
+  if (query === currentQuery && querySource === currentQuerySource) {
+    return;
+  }
+  url.searchParams.set(param, query);
+  if (querySource === QUESTION_SOURCE.ORGANIC) {
+    url.searchParams.delete(sourceParam);
+  } else {
+    url.searchParams.set(sourceParam, querySource);
+  }
+  window.history.replaceState({}, '', url);
+}

package/src/workflow/processors.js

@@ -1,5 +1,5 @@
-import { trimObj, mergeInteractions } from '@miso.ai/commons';
-import { STATUS, ROLE, EVENT_TYPE, REQUEST_TYPE, isPerformanceEventType, isProductRole } from '../constants.js';
+import { trimObj, mergeApiPayloads, mergeInteractions } from '@miso.ai/commons';
+import { STATUS, ROLE, EVENT_TYPE, REQUEST_TYPE, QUESTION_SOURCE, isPerformanceEventType, isProductRole } from '../constants.js';
 import { fields } from '../actor/index.js';
 
 // role mappings //
@@ -62,6 +62,14 @@ export function mappingFollowUpQuestionsData(data) {
 }
 
 // payload //
+export function writeQuestionSourceToPayload({ qs, ...payload } = {}) {
+  return mergeApiPayloads(payload, {
+    metadata: {
+      question_source: qs || QUESTION_SOURCE.ORGANIC, // might be null, not undefined
+    },
+  });
+}
+
 export function disableAnswerForNonQueryRequest(payload, type) {
   if (type === REQUEST_TYPE.QUERY) {
     return payload;
@@ -278,6 +286,20 @@ export function writeExhaustionToData(data, { role = ROLE.PRODUCTS } = {}) {
   };
 }
 
+export function carryOverQuestionIdToData(data, oldData) {
+  const { question_id } = (oldData && oldData.value) || {};
+  if (!question_id) {
+    return data;
+  }
+  return {
+    ...data,
+    value: {
+      ...data.value,
+      question_id,
+    },
+  };
+}
+
 // interactions //
 export function buildBaseInteraction(args) {
   const { role, type, items } = args;
@@ -332,6 +354,27 @@ export function writeRequestMetadataToInteraction(payload, args) {
   });
 }
 
+export function writeRequestInfoToInteraction(payload, args) {
+  const { data } = args;
+  if (!data) {
+    return payload;
+  }
+  const requestPayload = data.request && data.request.payload;
+  if (!requestPayload) {
+    return payload;
+  }
+  const { question, q, fq } = requestPayload;
+  return mergeInteractions(payload, {
+    context: {
+      custom_context: {
+        question,
+        q,
+        fq,
+      },
+    },
+  });
+}
+
 export function writeAffiliationInfoToInteraction(payload, args) {
   if (args.role !== ROLE.AFFILIATION) {
     return payload;
@@ -349,6 +392,47 @@ export function writeAffiliationInfoToInteraction(payload, args) {
   });
 }
 
+export function writeAnswerInfoToInteraction(payload, args) {
+  payload = writeQuestionInfoToInteraction(payload, args);
+  payload = writeAnswerClickInfoToInteraction(payload, args);
+  payload = writeEventTargetToInteraction(payload, args);
+  return payload;
+}
+
+export function writeQuestionInfoToInteraction(payload = {}, { data } = {}) {
+  if (!data) {
+    return payload;
+  }
+  const { request = {}, value = {} } = data;
+  const { question_source } = request.payload && request.payload.metadata || {};
+  const { question_id } = value;
+  return mergeInteractions(payload, {
+    context: {
+      custom_context: {
+        question_source,
+        question_id,
+      },
+    },
+  });
+}
+
+export function writeAnswerClickInfoToInteraction(payload, args) {
+  if (args.role !== ROLE.ANSWER) {
+    return payload;
+  }
+  const { items = [] } = args;
+  return mergeInteractions(payload, {
+    context: {
+      custom_context: {
+        urls: items.map(item => item.url),
+        texts: items.map(item => item.text),
+        class_names: items.map(item => item.className),
+        attributes: items.map(item => item.attributes),
+      },
+    },
+  });
+}
+
 export function writeEventTargetToInteraction(payload, { event_target } = {}) {
   if (!event_target) {
     return payload;

package/src/workflow/search-based.js

@@ -4,7 +4,7 @@ import { fields } from '../actor/index.js';
 import { STATUS, ROLE, WORKFLOW_CONFIGURABLE, REQUEST_TYPE } from '../constants.js';
 import { SearchBoxLayout, ListLayout, TextLayout, FacetsLayout, SelectLayout, MoreButtonLayout } from '../layout/index.js';
 import { mappingSortData, writeKeywordsToData, retainFacetCountsInData, writeExhaustionToData, writeMisoIdAsRootMisoId, concatItemsFromMoreResponse } from './processors.js';
-import { mergeRolesOptions, autoQuery as autoQueryFn, makeConfigurable, DEFAULT_TRACKER_OPTIONS } from './options/index.js';
+import { mergeRolesOptions, autoQuery as autoQueryFn, updateQueryParametersInUrl, makeConfigurable, DEFAULT_TRACKER_OPTIONS } from './options/index.js';
 
 const DEFAULT_ROWS = 10;
 const DEFAULT_PAGE_LIMIT = 10;
@@ -99,29 +99,31 @@ export default class SearchBasedWorkflow extends Workflow {
   }
 
   _query(args) {
+    const type = REQUEST_TYPE.QUERY;
+
     // reset filters view
     this._views.filters.reset({ silent: true });
 
     // start a new session
-    this.restart();
+    this.restart({ type });
 
     // payload
-    const type = REQUEST_TYPE.QUERY;
     const payload = this._buildPayload(args, type);
 
     this._request({ payload, type });
   }
 
   _refine() {
+    const type = REQUEST_TYPE.REFINE;
+
     // remember current facet_counts
     const { facet_counts } = this._hub.states[fields.data()].value || {};
     this._currentFacetCounts = facet_counts;
 
     // start a new session
-    this.restart();
+    this.restart({ type });
 
     // payload
-    const type = REQUEST_TYPE.REFINE;
     const query = this._getQuery();
     const payload = this._buildPayload(query, type);
 
@@ -234,9 +236,14 @@ export default class SearchBasedWorkflow extends Workflow {
     return data;
   }
 
-  _updateDataInHub(data) {
+  _updateData(data) {
+    super._updateData(data);
+    updateQueryParametersInUrl.call(this, data);
+  }
+
+  _updateDataInHub(data, oldData) {
     data = this._appendResultsFromMoreRequest(data);
-    super._updateDataInHub(data);
+    super._updateDataInHub(data, oldData);
   }
 
   _appendResultsFromMoreRequest(data) {
@@ -269,26 +276,6 @@ export default class SearchBasedWorkflow extends Workflow {
     return payload;
   }
 
-  _writeRequestInfoToInteraction(payload, args) {
-    const { data } = args;
-    if (!data) {
-      return payload;
-    }
-    const requestPayload = data.request && data.request.payload;
-    if (!requestPayload) {
-      return payload;
-    }
-    const { q, fq } = requestPayload;
-    return mergeInteractions(payload, {
-      context: {
-        custom_context: {
-          q,
-          fq,
-        },
-      },
-    });
-  }
-
   _writeRootMisoIdToInteraction(payload) {
     const data = this._hub.states[fields.data()];
     const { root_miso_id } = (data && data.value) || {};

package/dist/cjs/workflow/hybrid-search-results.js

@@ -1,87 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = void 0;
-var _commons = require("@miso.ai/commons");
-var _searchBased = _interopRequireDefault(require("./search-based.js"));
-var _index = require("../actor/index.js");
-var _constants = require("../constants.js");
-var _processors = require("./processors.js");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
-// we want to override members, not adding to it
-const ROLES_OPTIONS = Object.assign({}, _searchBased.default.ROLES_OPTIONS, {
-  members: [_constants.ROLE.PRODUCTS, _constants.ROLE.KEYWORDS, _constants.ROLE.TOTAL, _constants.ROLE.FACETS, _constants.ROLE.SORT, _constants.ROLE.MORE, _constants.ROLE.ERROR]
-});
-class HybridSearchResults extends _searchBased.default {
-  constructor(superworkflow) {
-    super({
-      name: 'hybrid-search/results',
-      plugin: superworkflow._plugin,
-      client: superworkflow._client,
-      options: superworkflow._options,
-      defaults: superworkflow._defaults,
-      roles: ROLES_OPTIONS,
-      superworkflow
-    });
-  }
-  _initProperties(args) {
-    super._initProperties(args);
-    this._superworkflow = args.superworkflow;
-  }
-  _initSession() {} // no reset here, will manually reset later
-
-  // lifecycle //
-  _emitLifecycleEvent(name, event) {
-    super._emitLifecycleEvent(name, event);
-    this._superworkflow._emitLifecycleEvent(name, event);
-  }
-
-  // query //
-  _getQuery() {
-    // get stored query from sibling
-    return this._superworkflow._answer._hub.states[_index.fields.query()];
-  }
-  _buildPayload(payload, type) {
-    payload = super._buildPayload(payload, type);
-    // borrow the work from the sibling
-    payload = this._superworkflow._answer._writeQuestionSourceToPayload(payload);
-    payload = this._writeQuestionIdToPayload(payload);
-    payload = (0, _processors.disableAnswerForNonQueryRequest)(payload, type);
-    return payload;
-  }
-  _buildOrderBy(sort) {
-    if (!sort) {
-      return undefined;
-    }
-    // works differently than search
-    return sort.field;
-  }
-  _writeQuestionIdToPayload(payload) {
-    return (0, _commons.mergeApiPayloads)(payload, {
-      metadata: {
-        question_id: this._superworkflow._answer.questionId
-      }
-    });
-  }
-
-  // data //
-  _defaultProcessData(data, oldData) {
-    data = super._defaultProcessData(data, oldData);
-    (0, _processors.writeMisoIdToSession)(data);
-    return data;
-  }
-
-  // interactions //
-  _defaultProcessInteraction(payload, args) {
-    return this._superworkflow._defaultProcessInteraction(payload, args);
-  }
-  _defaultProcessInteraction0(payload, args) {
-    return super._defaultProcessInteraction(payload, args);
-  }
-}
-exports.default = HybridSearchResults;
-Object.assign(HybridSearchResults, {
-  ROLES_OPTIONS
-});

package/src/workflow/hybrid-search-results.js

@@ -1,91 +0,0 @@
-import { mergeApiPayloads } from '@miso.ai/commons';
-import SearchBasedWorkflow from './search-based.js';
-import { fields } from '../actor/index.js';
-import { ROLE } from '../constants.js';
-import { writeMisoIdToSession, disableAnswerForNonQueryRequest } from './processors.js';
-
-// we want to override members, not adding to it
-const ROLES_OPTIONS = {
-  ...SearchBasedWorkflow.ROLES_OPTIONS,
-  members: [ROLE.PRODUCTS, ROLE.KEYWORDS, ROLE.TOTAL, ROLE.FACETS, ROLE.SORT, ROLE.MORE, ROLE.ERROR],
-};
-
-export default class HybridSearchResults extends SearchBasedWorkflow {
-
-  constructor(superworkflow) {
-    super({
-      name: 'hybrid-search/results',
-      plugin: superworkflow._plugin,
-      client: superworkflow._client,
-      options: superworkflow._options,
-      defaults: superworkflow._defaults,
-      roles: ROLES_OPTIONS,
-      superworkflow,
-    });
-  }
-
-  _initProperties(args) {
-    super._initProperties(args);
-    this._superworkflow = args.superworkflow;
-  }
-
-  _initSession() {} // no reset here, will manually reset later
-
-  // lifecycle //
-  _emitLifecycleEvent(name, event) {
-    super._emitLifecycleEvent(name, event);
-    this._superworkflow._emitLifecycleEvent(name, event);
-  }
-
-  // query //
-  _getQuery() {
-    // get stored query from sibling
-    return this._superworkflow._answer._hub.states[fields.query()];
-  }
-
-  _buildPayload(payload, type) {
-    payload = super._buildPayload(payload, type);
-    // borrow the work from the sibling
-    payload = this._superworkflow._answer._writeQuestionSourceToPayload(payload);
-    payload = this._writeQuestionIdToPayload(payload);
-    payload = disableAnswerForNonQueryRequest(payload, type);
-    return payload;
-  }
-
-  _buildOrderBy(sort) {
-    if (!sort) {
-      return undefined;
-    }
-    // works differently than search
-    return sort.field;
-  }
-
-  _writeQuestionIdToPayload(payload) {
-    return mergeApiPayloads(payload, {
-      metadata: {
-        question_id: this._superworkflow._answer.questionId,
-      },
-    });
-  }
-
-  // data //
-  _defaultProcessData(data, oldData) {
-    data = super._defaultProcessData(data, oldData);
-    writeMisoIdToSession(data);
-    return data;
-  }
-
-  // interactions //
-  _defaultProcessInteraction(payload, args) {
-    return this._superworkflow._defaultProcessInteraction(payload, args);
-  }
-
-  _defaultProcessInteraction0(payload, args) {
-    return super._defaultProcessInteraction(payload, args);
-  }
-
-}
-
-Object.assign(HybridSearchResults, {
-  ROLES_OPTIONS,
-});