@miso.ai/client-sdk-ui 1.11.0-beta.9 → 1.11.0

package/src/workflow/base.js

@@ -3,35 +3,45 @@ import { Hub, SessionMaker, DataActor, ViewsActor, InteractionsActor, fields } f
 import * as sources from '../source.js';
 import { STATUS, ROLE } from '../constants.js';
 import { ContainerLayout, ErrorLayout } from '../layout/index.js';
-import { injectLogger } from './utils.js';
-import { WorkflowOptions, mergeLayoutsOptions, mergeInteractionsOptions, makeConfigurable } from './options.js';
-import { writeDataStatus, writeMisoIdToMeta } from './processors.js';
+import { WorkflowOptions, mergeApiOptions, makeConfigurable } from './options.js';
+import { getRevision, writeDataStatus, writeMisoIdToMeta, buildBaseInteraction, writeAffiliationInfoToInteraction, mergeInteraction } from './processors.js';
+
+// TODO: just bury this into hub
+function injectLogger(hub, callback) {
+  const { update, trigger } = hub;
+  hub.update = (name, state, options) => {
+    if (!options || !options.silent) {
+      callback('update', name, state, options);
+    }
+    return update.call(hub, name, state, options);
+  }
+  hub.trigger = (...args) => {
+    callback('trigger', ...args);
+    return trigger.apply(hub, args);
+  }
+  return hub;
+}
+
+const DEFAULT_API_OPTIONS = Object.freeze({});
 
 const DEFAULT_LAYOUTS = Object.freeze({
   [ROLE.CONTAINER]: ContainerLayout.type,
   [ROLE.ERROR]: ErrorLayout.type,
 });
 
-const ROLES_CONFIG = Object.freeze({
-  [ROLE.ERROR]: {
-    mapping: data => data.error,
-  },
-});
+const DEFAULT_TRACKERS = Object.freeze({});
 
-function mergeDefaults(workflow, { layouts, interactions, ...defaults } = {}) {
-  const DEFAULT_INTERACTIONS = {
-    preprocess: [payload => workflow._preprocessInteraction(payload)],
-  };
-  return {
-    ...defaults,
-    layouts: mergeLayoutsOptions(DEFAULT_LAYOUTS, layouts),
-    interactions: mergeInteractionsOptions(DEFAULT_INTERACTIONS, interactions),
-  };
-}
+const DEFAULT_OPTIONS = Object.freeze({
+  api: DEFAULT_API_OPTIONS,
+  layouts: DEFAULT_LAYOUTS,
+  trackers: DEFAULT_TRACKERS,
+});
 
-function getRevision(data) {
-  return data && data.value && data.value.revision;
-}
+const ROLES_OPTIONS = Object.freeze({
+  mappings: {
+    [ROLE.ERROR]: data => data.error,
+  },
+});
 
 export default class Workflow extends Component {
 
@@ -46,43 +56,45 @@ export default class Workflow extends Component {
 
     this._name = args.name;
     this._roles = args.roles;
-    this._rolesConfig = { ...ROLES_CONFIG, ...args.rolesConfig };
 
     this._extensions = plugin._getExtensions(client);
-    this._options = options || new WorkflowOptions(context && context._options, mergeDefaults(this, args.defaults));
+    this._defaults = args.defaults;
+    this._options = options || new WorkflowOptions(context && context._options, args.defaults);
     this._hub = injectLogger(new Hub(), (...args) => this._log(...args));
 
     this._initProperties(args);
     this._initActors(args);
     this._initSubscriptions(args);
-    this._initReset(args);
+    this._initSession(args);
   }
 
   _initProperties() {}
 
-  _initActors() {
+  _initActors({ name, roles }) {
     const hub = this._hub;
     const client = this._client;
-    const roles = this._roles;
-    const rolesConfig = this._rolesConfig;
     const options = this._options;
     const extensions = this._extensions;
     const layouts = this._plugin.layouts;
 
     this._sessions = new SessionMaker(hub);
     this._data = new DataActor(hub, { source: sources.api(client), options });
-    this._views = new ViewsActor(hub, { extensions, layouts, roles, rolesConfig, options, workflow: this._name });
+    this._views = new ViewsActor(hub, { extensions, layouts, roles, options, workflow: name });
     this._interactions = new InteractionsActor(hub, { client, options });
   }
 
-  _initSubscriptions() {
+  _initSubscriptions({ roles }) {
     this._unsubscribes = [
       this._hub.on(fields.response(), data => this.updateData(data)),
+      this._hub.on(fields.tracker(), args => this._onTracker(args)),
     ];
+    if (roles.main) {
+      this._unsubscribes.push(this._hub.on(fields.view(roles.main), state => this._onMainViewUpdate(state)));
+    }
   }
 
-  _initReset() {
-    this.reset();
+  _initSession() {
+    this.restart();
   }
 
   get uuid() {
@@ -93,11 +105,6 @@ export default class Workflow extends Component {
     return this._hub.states[fields.session()];
   }
 
-  get active() {
-    const { session } = this;
-    return !!session && session.active;
-  }
-
   get states() {
     return this._hub.states;
   }
@@ -112,22 +119,51 @@ export default class Workflow extends Component {
   }
 
   // lifecycle //
-  reset() {
-    this._sessions.new();
+  restart() {
+    this._emitInterruptEventIfNecessary();
+    this._sessions.restart();
     return this;
   }
 
-  start() {
-    this._sessions.start();
-    return this;
+  _emitInterruptEventIfNecessary() {
+    const { main } = this._roles;
+    if (!main) {
+      return;
+    }
+    const state = this._hub.states[fields.view(main)] || {};
+    if (state.session && state.status === STATUS.LOADING) {
+      // it's interrupted by a new question
+      this._emitLifecycleEvent('interrupt', state);
+      this._emitLifecycleEvent('finally', state);
+    }
   }
 
-  restart() {
-    this._sessions.restart();
-    return this;
+  _onMainViewUpdate(state) {
+    const { status } = state;
+    const done = status === STATUS.READY;
+    const erroneous = status === STATUS.ERRONEOUS;
+    const eventName = erroneous ? 'error' : status;
+    this._emitLifecycleEvent(eventName, state);
+    if (done) {
+      this._emitLifecycleEvent('done', state);
+    }
+    if (done || erroneous) {
+      this._emitLifecycleEvent('finally', state);
+    }
+  }
+
+  _emitLifecycleEvent(name, event) {
+    this._emit(name, event);
   }
 
-  // states //
+  // request //
+  _request(options = {}) {
+    const { session } = this;
+    const event = mergeApiOptions(this._options.resolved.api, { ...options, session });
+    this._hub.update(fields.request(), event);
+  }
+
+  // data //
   updateData(data) {
     if (!data) {
       throw new Error(`Data is required.`);
@@ -158,8 +194,6 @@ export default class Workflow extends Component {
   }
 
   _updateData(data) {
-    this._sessions.start(); // in case session not started yet
-
     data = this._defaultProcessData(data);
     for (const process of this._options.resolved.dataProcessor) {
       data = process(data);
@@ -178,24 +212,9 @@ export default class Workflow extends Component {
     this._hub.update(fields.data(), data);
   }
 
-  /*
-  _mergeDataIfNecessary(data) {
-    if (!data._inst || !data._inst.merge) {
-      return data;
-    }
-    return {
-      ...this._hub.states[fields.data()],
-      ...data,
-    };
-  }
-
-  _handleResponseObject() {}
-  */
-
   // TODO: notifyViewUpdateAll()
 
   notifyViewUpdate(role, state) {
-    this._assertActive();
     state = {
       status: STATUS.READY,
       session: this.session,
@@ -210,29 +229,54 @@ export default class Workflow extends Component {
     return this._views.trackers;
   }
 
-  // TODO: extract to a separate function
-  _preprocessInteraction({
-    context: {
-      custom_context,
-      ...context
-    } = {},
-    ...payload
-  } = {}) {
-    const {
-      group: api_group,
-      name: api_name,
-    } = this._options.resolved.api;
-    return {
-      ...payload,
+  _onTracker(args) {
+    const payload = this._buildInteraction(args);
+    this._sendInteraction(payload);
+  }
+
+  _buildInteraction(args) {
+    let payload = buildBaseInteraction(args);
+    payload = this._defaultProcessInteraction(payload, args);
+    const { preprocess = [] } = this._options.resolved.interactions;
+    for (const p of preprocess) {
+      payload = p(payload, args);
+    }
+    return payload;
+  }
+
+  _defaultProcessInteraction(payload, args) {
+    payload = this._writeApiInfoToInteraction(payload, args);
+    payload = this._writeMisoIdToInteraction(payload, args);
+    payload = writeAffiliationInfoToInteraction(payload, args);
+    return payload;
+  }
+
+  _writeApiInfoToInteraction(payload) {
+    const { group, name } = this._options.resolved.api;
+    return mergeInteraction(payload, {
       context: {
-        ...context,
         custom_context: {
-          api_group,
-          api_name,
-          ...custom_context,
+          api_group: group,
+          api_name: name,
         },
       },
-    };
+    });
+  }
+
+  _writeMisoIdToInteraction(payload, args) {
+    // TODO: ad-hoc, try to pass info from tracker
+    const state = this._hub.states[fields.view(args.role)] || {};
+    const miso_id = (state.meta && state.meta.miso_id) || undefined;
+    return miso_id ? mergeInteraction(payload, { miso_id }) : payload;
+  }
+
+  _sendInteraction(payload) {
+    const { handle } = this._options.resolved.interactions;
+    if (typeof handle === 'function') {
+      handle(payload);
+    } else {
+      this._hub.trigger(fields.interaction(), payload);
+    }
   }
 
   // destroy //
@@ -263,12 +307,14 @@ export default class Workflow extends Component {
     }
   }
 
-  _assertActive() {
-    if (!this.active) {
-      throw new Error(`Unit is not active yet. Call unit.start() to activate it.`)
-    }
-  }
-
 }
 
 makeConfigurable(Workflow.prototype);
+
+Object.assign(Workflow, {
+  DEFAULT_API_OPTIONS,
+  DEFAULT_LAYOUTS,
+  DEFAULT_TRACKERS,
+  DEFAULT_OPTIONS,
+  ROLES_OPTIONS,
+});

package/src/workflow/explore.js

@@ -1,21 +1,25 @@
 import { API } from '@miso.ai/commons';
 import Workflow from './base.js';
-import { mergeApiOptions } from './options.js';
 import { fields } from '../actor/index.js';
 import { ROLE, EVENT_TYPE } from '../constants.js';
 import { ListLayout, SearchBoxLayout } from '../layout/index.js';
+import { mergeRolesOptions } from './options.js';
+import { enableUseLink, UseLinkMixin } from './use-link.js';
 
 const DEFAULT_API_OPTIONS = Object.freeze({
+  ...Workflow.DEFAULT_API_OPTIONS,
   group: API.GROUP.ASK,
   name: API.NAME.RELATED_QUESTIONS,
 });
 
 const DEFAULT_LAYOUTS = Object.freeze({
+  ...Workflow.DEFAULT_LAYOUTS,
   [ROLE.RELATED_QUESTIONS]: [ListLayout.type, { itemType: 'question', link: { rel: 'noopener nofollow' } }],
   [ROLE.QUERY]: [SearchBoxLayout.type, { placeholder: 'Ask a question' }],
 });
 
 const DEFAULT_TRACKERS = Object.freeze({
+  ...Workflow.DEFAULT_TRACKERS,
   [ROLE.RELATED_QUESTIONS]: {},
   [ROLE.CONTAINER]: {},
   [ROLE.QUERY]: {
@@ -24,11 +28,17 @@ const DEFAULT_TRACKERS = Object.freeze({
 });
 
 const DEFAULT_OPTIONS = Object.freeze({
+  ...Workflow.DEFAULT_OPTIONS,
   api: DEFAULT_API_OPTIONS,
   layouts: DEFAULT_LAYOUTS,
   trackers: DEFAULT_TRACKERS,
 });
 
+const ROLES_OPTIONS = mergeRolesOptions(Workflow.ROLES_OPTIONS, {
+  main: ROLE.RELATED_QUESTIONS,
+  members: Object.keys(DEFAULT_LAYOUTS),
+});
+
 export default class Explore extends Workflow {
 
   constructor(plugin, client) {
@@ -36,7 +46,7 @@ export default class Explore extends Workflow {
       name: 'explore',
       plugin,
       client,
-      roles: Object.keys(DEFAULT_LAYOUTS),
+      roles: ROLES_OPTIONS,
       defaults: DEFAULT_OPTIONS,
     });
   }
@@ -52,7 +62,7 @@ export default class Explore extends Workflow {
     this._unsubscribes = [
       ...this._unsubscribes,
       this._views.get(ROLE.RELATED_QUESTIONS).on('click', event => this._handleRelatedQuestionClick(event)),
-      this._hub.on(fields.query(), payload => this.query(payload)),
+      this._hub.on(fields.query(), args => this._query(args)),
     ];
   }
 
@@ -72,27 +82,18 @@ export default class Explore extends Workflow {
     return super.useApi(options);
   }
 
-  useLink(fn) {
-    if (typeof fn !== 'function' && fn !== false) {
-      throw new Error('useLink(fn) expects fn to be a function or false');
-    }
-    this._linkFn = fn;
-    return this;
-  }
-
   // lifecycle //
   start({ relatedQuestions = true } = {}) {
-    if (relatedQuestions && this._linkFn === undefined) {
-      throw new Error('Define link mapping function before calling start()');
+    if (this._linkFn === undefined) {
+      throw new Error('Must define link mapping function with useLink(fn) before calling start()');
     }
-    this._sessions.start();
     // in explore workflow, start() triggers query
     // TODO: we should still make the query lifecycle
-    const { session } = this;
     if (relatedQuestions) {
-      this._hub.update(fields.request(), mergeApiOptions(this._options.resolved.api, { session }));
+      this._request();
     } else {
       // TODO: ad-hoc
+      const { session } = this;
       this.updateData({ session, request: {}, value: { related_questions: [] } });
     }
     return this;
@@ -105,12 +106,17 @@ export default class Explore extends Workflow {
 
   _defaultProcessData(data) {
     data = super._defaultProcessData(data);
-    let { value } = data;
-    if (!value) {
+    data = this._addUrlToRelatedQuestions(data);
+    return data;
+  }
+
+  _addUrlToRelatedQuestions(data) {
+    const { value } = data;
+    if (!value || !value.related_questions) {
       return data;
     }
-    // patch value with links
-    const related_questions = value.related_questions.map(this._linkFn ? (text => ({ text, url: this._getAnswersUrl(text, true) })) : (text => ({ text })));
+    const linkFn = this._linkFn && this._linkFn[0];
+    const related_questions = value.related_questions.map(linkFn ? (text => ({ text, url: this._getSubmitUrl({ q: text }, { generated: true }) })) : (text => ({ text })));
     return {
       ...data,
       value: {
@@ -124,19 +130,19 @@ export default class Explore extends Workflow {
     this._events.emit('select', Object.freeze({ ...event, question }));
   }
 
-  query({ q } = {}) {
-    if (!this._linkFn) {
-      return;
+  query(args) {
+    if (!args.q) {
+      throw new Error(`q is required in query() call`);
     }
-    const url = this._getAnswersUrl(q);
-    window.open(url, '_blank');
+    this._hub.update(fields.query(), args);
   }
 
-  _getAnswersUrl(text, generated = false) {
-    if (!this._linkFn) {
-      return;
-    }
-    const url = this._linkFn(text);
+  _query(args) {
+    this._submitToPage(args);
+  }
+
+  _getSubmitUrl(args, { generated = false } = {}) {
+    let url = UseLinkMixin.prototype._getSubmitUrl.call(this, args);
     if (!generated || !this._productId) {
       return url;
     }
@@ -144,3 +150,5 @@ export default class Explore extends Workflow {
   }
 
 }
+
+enableUseLink(Explore.prototype);

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

@@ -1,10 +1,12 @@
 import AnswerBasedWorkflow from './answer-based.js';
 import { ROLE, STATUS, ORGANIC_QUESTION_SOURCE } from '../constants.js';
+import { mergeRolesOptions } from './options.js';
 import { writeKeywordsToData } from './processors.js';
+import { makeAutocompletable } from './autocompletable.js';
 
-const ROLES_CONFIG = Object.freeze({
-  [ROLE.QUESTION]: {
-    mapping: ROLE.KEYWORDS,
+const ROLES_OPTIONS = mergeRolesOptions(AnswerBasedWorkflow.ROLES_OPTIONS, {
+  mappings: {
+    [ROLE.QUESTION]: ROLE.KEYWORDS,
   },
 });
 
@@ -16,18 +18,19 @@ export default class HybridSearchAnswer extends AnswerBasedWorkflow {
       plugin: superworkflow._plugin,
       client: superworkflow._client,
       options: superworkflow._options,
-      roles: Object.keys(AnswerBasedWorkflow.DEFAULT_LAYOUTS),
-      rolesConfig: ROLES_CONFIG,
+      defaults: superworkflow._defaults,
+      roles: ROLES_OPTIONS,
       superworkflow,
     });
   }
 
   _initProperties(args) {
     super._initProperties(args);
+    this._initAutocomplete(args);
     this._superworkflow = args.superworkflow;
   }
 
-  _initReset() {} // no reset here, will manually reset later
+  _initSession() {} // no reset here, will manually reset later
 
   restart() {
     super.restart();
@@ -78,4 +81,12 @@ export default class HybridSearchAnswer extends AnswerBasedWorkflow {
     this._resultsSession && this._superworkflow._results.updateData({ ...data, session: this._resultsSession });
   }
 
+  // destroy //
+  _destroy(options) {
+    this._destroyAutocomplete();
+    super._destroy(options);
+  }
+
 }
+
+makeAutocompletable(HybridSearchAnswer.prototype);

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

@@ -1,17 +1,14 @@
 import { trimObj } from '@miso.ai/commons';
-import Workflow from './base.js';
+import SearchBasedWorkflow from './search-based.js';
 import { fields } from '../actor/index.js';
-import { ROLE, STATUS } from '../constants.js';
-import { mergeApiOptions } from './options.js';
-import { writeKeywordsToData, composeFiltersPayload } from './processors.js';
+import { ROLE } from '../constants.js';
+import { mergeRolesOptions } from './options.js';
 
-const ROLES_CONFIG = Object.freeze({
-  [ROLE.FACETS]: {
-    mapping: 'facet_counts',
-  },
+const ROLES_OPTIONS = mergeRolesOptions(SearchBasedWorkflow.ROLES_OPTIONS, {
+  members: [ROLE.PRODUCTS, ROLE.KEYWORDS, ROLE.TOTAL, ROLE.FACETS, ROLE.MORE],
 });
 
-export default class HybridSearchResults extends Workflow {
+export default class HybridSearchResults extends SearchBasedWorkflow {
 
   constructor(superworkflow) {
     super({
@@ -19,8 +16,8 @@ export default class HybridSearchResults extends Workflow {
       plugin: superworkflow._plugin,
       client: superworkflow._client,
       options: superworkflow._options,
-      roles: [ROLE.PRODUCTS, ROLE.KEYWORDS, ROLE.HITS, ROLE.FACETS],
-      rolesConfig: ROLES_CONFIG,
+      defaults: superworkflow._defaults,
+      roles: ROLES_OPTIONS,
       superworkflow,
     });
   }
@@ -30,49 +27,28 @@ export default class HybridSearchResults extends Workflow {
     this._superworkflow = args.superworkflow;
   }
 
-  _initSubscriptions(args) {
-    super._initSubscriptions(args);
-    this._unsubscribes = [
-      ...this._unsubscribes,
-      this._hub.on(fields.filters(), filters => this._refine(filters)),
-    ];
-  }
+  _initSession() {} // no reset here, will manually reset later
 
-  _initReset() {} // no reset here, will manually reset later
+  // lifecycle //
+  _emitLifecycleEvent(name, event) {
+    super._emitLifecycleEvent(name, event);
+    this._superworkflow._emitLifecycleEvent(name, event);
+  }
 
   // query //
-  _refine(filters) {
-    // remember current facet_counts
-    const { facet_counts } = this._hub.states[fields.data()].value || {};
-    this._previousFacetCounts = facet_counts;
-
-    // start a new session
-    this.restart();
-
+  _getQuery() {
     // get stored query from sibling
-    const query = this._superworkflow._answer._hub.states[fields.query()];
-    const payload = this._buildPayload({ ...query, filters });
-    const { session } = this;
-    const event = mergeApiOptions(this._options.resolved.api, { payload, session });
-
-    this._request(event);
+    return this._superworkflow._answer._hub.states[fields.query()];
   }
 
   _buildPayload({ filters, ...payload } = {}) {
     // borrow the work from the sibling
     payload = this._superworkflow._answer._buildPayload(payload);
-    payload = this._writeFiltersToPayload({ ...payload, filters });
+    payload = SearchBasedWorkflow.prototype._buildPayload.call(this, payload);
     payload = this._writeQuestionIdToPayload(payload);
     return { ...payload, answer: false };
   }
 
-  _writeFiltersToPayload({ filters, ...payload } = {}) {
-    return trimObj({
-      ...payload,
-      ...composeFiltersPayload(filters),
-    });
-  }
-
   _writeQuestionIdToPayload(payload) {
     return {
       ...payload,
@@ -83,40 +59,4 @@ export default class HybridSearchResults extends Workflow {
     };
   }
 
-  _request(event) {
-    this._hub.update(fields.request(), event);
-  }
-
-  // data //
-  _defaultProcessData(data) {
-    data = super._defaultProcessData(data);
-    data = writeKeywordsToData(data);
-    data = this._retainFacetCounts(data);
-    return data;
-  }
-
-  _retainFacetCounts(data) {
-    if (!this._previousFacetCounts) {
-      return data;
-    }
-    const { status, value } = data;
-    switch (status) {
-      case STATUS.INITIAL:
-      case STATUS.LOADING:
-        break;
-      default:
-        return data;
-    }
-    if (value && value.facet_counts) {
-      return data;
-    }
-    return {
-      ...data,
-      value: {
-        ...value,
-        facet_counts: this._previousFacetCounts,
-      },
-    };
-  }
-
 }