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

package/src/workflow/base.js

@@ -3,42 +3,52 @@ 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, addDataInstructions } 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 {
 
   constructor(args) {
     super(args.name || 'workflow', args.plugin);
 
-    let { context, plugin, client } = args;
+    let { context, plugin, client, options } = args;
     this._context = context;
     this._plugin = plugin = plugin || context._plugin;
     this._client = client = client || context._client;
@@ -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 = 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() {
@@ -90,12 +102,7 @@ export default class Workflow extends Component {
   }
 
   get session() {
-    return this._hub.states.session;
-  }
-
-  get active() {
-    const { session } = this;
-    return !!session && session.active;
+    return this._hub.states[fields.session()];
   }
 
   get states() {
@@ -112,23 +119,52 @@ 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);
+  }
+
+  // request //
+  _request(options = {}) {
+    const { session } = this;
+    const event = mergeApiOptions(this._options.resolved.api, { ...options, session });
+    this._hub.update(fields.request(), event);
   }
 
-  // states //
-  updateData(data, { instructions } = {}) {
+  // data //
+  updateData(data) {
     if (!data) {
       throw new Error(`Data is required.`);
     }
@@ -152,43 +188,33 @@ export default class Workflow extends Component {
       }
     }
 
-    this._sessions.start(); // in case session not started yet
+    this._updateData(data);
 
-    data = writeDataStatus(data);
+    return this;
+  }
+
+  _updateData(data) {
     data = this._defaultProcessData(data);
     for (const process of this._options.resolved.dataProcessor) {
       data = process(data);
     }
 
-    // write data instructions from function args
-    data = addDataInstructions(data, instructions);
-    data = this._mergeDataIfNecessary(data);
-
-    this._hub.update(fields.data(), data);
-
-    return this;
+    this._updateDataInHub(data);
   }
 
   _defaultProcessData(data) {
-    return writeMisoIdToMeta(data);
+    data = writeDataStatus(data);
+    data = writeMisoIdToMeta(data);
+    return data;
   }
 
-  _mergeDataIfNecessary(data) {
-    if (!data._inst || !data._inst.merge) {
-      return data;
-    }
-    return {
-      ...this._hub.states[fields.data()],
-      ...data,
-    };
+  _updateDataInHub(data) {
+    this._hub.update(fields.data(), data);
   }
 
-  _handleResponseObject() {}
-
   // TODO: notifyViewUpdateAll()
 
   notifyViewUpdate(role, state) {
-    this._assertActive();
     state = {
       status: STATUS.READY,
       session: this.session,
@@ -203,28 +229,54 @@ export default class Workflow extends Component {
     return this._views.trackers;
   }
 
-  _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 //
@@ -255,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,24 @@
 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';
 
 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 +27,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 +45,7 @@ export default class Explore extends Workflow {
       name: 'explore',
       plugin,
       client,
-      roles: Object.keys(DEFAULT_LAYOUTS),
+      roles: ROLES_OPTIONS,
       defaults: DEFAULT_OPTIONS,
     });
   }
@@ -52,7 +61,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._submit(args)),
     ];
   }
 
@@ -82,17 +91,16 @@ export default class Explore extends Workflow {
 
   // lifecycle //
   start({ relatedQuestions = true } = {}) {
-    if (relatedQuestions && this._linkFn === undefined) {
+    if (this._linkFn === undefined) {
       throw new Error('Define link mapping function 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;
@@ -124,7 +132,14 @@ export default class Explore extends Workflow {
     this._events.emit('select', Object.freeze({ ...event, question }));
   }
 
-  query({ q } = {}) {
+  query(args) {
+    if (!args.q) {
+      throw new Error(`q is required in query() call`);
+    }
+    this._hub.update(fields.query(), args);
+  }
+
+  _submit({ q } = {}) {
     if (!this._linkFn) {
       return;
     }

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

@@ -0,0 +1,92 @@
+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_OPTIONS = mergeRolesOptions(AnswerBasedWorkflow.ROLES_OPTIONS, {
+  mappings: {
+    [ROLE.QUESTION]: ROLE.KEYWORDS,
+  },
+});
+
+export default class HybridSearchAnswer extends AnswerBasedWorkflow {
+
+  constructor(superworkflow) {
+    super({
+      name: 'hybrid-search/answer',
+      plugin: superworkflow._plugin,
+      client: superworkflow._client,
+      options: superworkflow._options,
+      defaults: superworkflow._defaults,
+      roles: ROLES_OPTIONS,
+      superworkflow,
+    });
+  }
+
+  _initProperties(args) {
+    super._initProperties(args);
+    this._initAutocomplete(args);
+    this._superworkflow = args.superworkflow;
+  }
+
+  _initSession() {} // no reset here, will manually reset later
+
+  restart() {
+    super.restart();
+    // cascade restart to the sibling
+    const results = this._superworkflow._results;
+    results._views.filters.reset();
+    results.restart();
+    this._resultsSession = results.session; // keep track of the session
+  }
+
+  // query //
+  _buildPayload({ q, qs, ...payload } = {}) {
+    return {
+      ...payload,
+      q, // q, not question
+      _meta: {
+        ...payload._meta,
+        question_source: qs || ORGANIC_QUESTION_SOURCE, // might be null, not undefined
+      },
+    };
+  }
+
+  // data //
+  _defaultProcessData(data) {
+    data = super._defaultProcessData(data);
+    data = writeKeywordsToData(data);
+    return data;
+  }
+
+  _updateDataInHub(data) {
+    switch (data.status) {
+      case STATUS.INITIAL:
+      case STATUS.LOADING:
+        // share the initial/loading status with its sibling
+        this._dispatchDataToSibling(data);
+        break;
+    }
+    super._updateDataInHub(data);
+  }
+
+  _handleHeadResponse(data) {
+    super._handleHeadResponse(data);
+    // share the search results with its sibling
+    this._dispatchDataToSibling(data);
+  }
+
+  _dispatchDataToSibling(data) {
+    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

@@ -0,0 +1,62 @@
+import { trimObj } from '@miso.ai/commons';
+import SearchBasedWorkflow from './search-based.js';
+import { fields } from '../actor/index.js';
+import { ROLE } from '../constants.js';
+import { mergeRolesOptions } from './options.js';
+
+const ROLES_OPTIONS = mergeRolesOptions(SearchBasedWorkflow.ROLES_OPTIONS, {
+  members: [ROLE.PRODUCTS, ROLE.KEYWORDS, ROLE.TOTAL, ROLE.FACETS, ROLE.MORE],
+});
+
+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({ filters, ...payload } = {}) {
+    // borrow the work from the sibling
+    payload = this._superworkflow._answer._buildPayload(payload);
+    payload = SearchBasedWorkflow.prototype._buildPayload.call(this, payload);
+    payload = this._writeQuestionIdToPayload(payload);
+    return { ...payload, answer: false };
+  }
+
+  _writeQuestionIdToPayload(payload) {
+    return {
+      ...payload,
+      _meta: trimObj({
+        ...payload._meta,
+        question_id: this._superworkflow._answer.questionId,
+      }),
+    };
+  }
+
+}