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

package/src/workflow/answer-based.js

@@ -1,16 +1,17 @@
-import { trimObj, API } from '@miso.ai/commons';
+import { API } from '@miso.ai/commons';
 import Workflow from './base.js';
-import { mergeApiOptions } from './options.js';
-// import * as sources from '../source.js';
-import { fields, FeedbackActor, AutocompleteActor } from '../actor/index.js';
-import { ROLE, STATUS, ORGANIC_QUESTION_SOURCE, DATA_ASPECT } from '../constants.js';
+import { fields, FeedbackActor } from '../actor/index.js';
+import { ROLE, STATUS, ORGANIC_QUESTION_SOURCE } from '../constants.js';
 import { SearchBoxLayout, TextLayout, ListLayout, TypewriterLayout, FeedbackLayout, AffiliationLayout } from '../layout/index.js';
 import { processData as processAffiliationData } from '../affiliation/index.js';
-import { writeAnswerStageToMeta } from './processors.js';
+import { mergeRolesOptions } from './options.js';
+import { writeAnswerStageToMeta, mergeInteraction } from './processors.js';
 
 const DEFAULT_API_OPTIONS = Object.freeze({
+  ...Workflow.DEFAULT_API_OPTIONS,
   group: API.GROUP.ASK,
   payload: {
+    ...Workflow.DEFAULT_API_OPTIONS.payload,
     source_fl: ['cover_image', 'url', 'created_at', 'updated_at', 'published_at'],
     cite_link: 1,
     cite_start: '[',
@@ -27,6 +28,7 @@ const DEFAULT_AUTOCOMPLETE_OPTIONS = Object.freeze({
 });
 
 const DEFAULT_LAYOUTS = Object.freeze({
+  ...Workflow.DEFAULT_LAYOUTS,
   [ROLE.QUERY]: [SearchBoxLayout.type, { placeholder: 'Ask a question' }],
   [ROLE.QUESTION]: [TextLayout.type, { tag: 'h2' }],
   [ROLE.ANSWER]: TypewriterLayout.type,
@@ -36,17 +38,25 @@ const DEFAULT_LAYOUTS = Object.freeze({
 });
 
 const DEFAULT_TRACKERS = Object.freeze({
+  ...Workflow.DEFAULT_TRACKERS,
   [ROLE.SOURCES]: {},
   [ROLE.AFFILIATION]: {},
+  [ROLE.PRODUCTS]: {},
 });
 
 const DEFAULT_OPTIONS = Object.freeze({
+  ...Workflow.DEFAULT_OPTIONS,
   api: DEFAULT_API_OPTIONS,
   autocomplete: DEFAULT_AUTOCOMPLETE_OPTIONS,
   layouts: DEFAULT_LAYOUTS,
   trackers: DEFAULT_TRACKERS,
 });
 
+const ROLES_OPTIONS = mergeRolesOptions(Workflow.ROLES_OPTIONS, {
+  main: ROLE.ANSWER,
+  members: Object.keys(DEFAULT_LAYOUTS),
+});
+
 export default class AnswerBasedWorkflow extends Workflow {
 
   // constructor //
@@ -59,12 +69,6 @@ export default class AnswerBasedWorkflow extends Workflow {
   _initActors(args) {
     super._initActors(args);
     this._feedback = new FeedbackActor(this._hub);
-    /*
-    this._autocomplete = new AutocompleteActor(this._hub, {
-      source: sources.api(this._client),
-      options: this._options,
-    });
-    */
   }
 
   _initSubscriptions(args) {
@@ -72,30 +76,49 @@ export default class AnswerBasedWorkflow extends Workflow {
     this._unsubscribes = [
       ...this._unsubscribes,
       this._hub.on(fields.query(), args => this._query(args)),
-      this._hub.on(fields.view(ROLE.ANSWER), data => this._onAnswerViewUpdate(data)),
       this._views.get(ROLE.ANSWER).on('citation-click', event => this._onCitationClick(event)),
     ];
   }
 
+  // configuration //
+  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 //
   restart() {
     // clear question id from previous session
     if (this._questionId) {
       this._questionId = undefined;
     }
-    // interrupt event
-    // TODO: move to workflow base
-    const { session, status, ongoing } = this._hub.states[fields.view(ROLE.ANSWER)] || {};
-    if (session && status !== STATUS.INITIAL && (status !== STATUS.READY || ongoing)) {
-      // it's interrupted by a new question
-      const state = Object.freeze({ session, status, ongoing });
-      this._emit('interrupt', state);
-      this._emit('finally', state);
-    }
     // restart
     super.restart();
   }
 
+  _emitInterruptEventIfNecessary() {
+    const state = this._hub.states[fields.view(this._roles.main)] || {};
+    if (state.session && state.status !== STATUS.INITIAL && (state.status !== STATUS.READY || state.ongoing)) {
+      // it's interrupted by a new question
+      this._emitLifecycleEvent('interrupt', state);
+      this._emitLifecycleEvent('finally', state);
+    }
+  }
+
+  _onMainViewUpdate(state) {
+    const { status } = state;
+    const done = status === STATUS.READY && !state.ongoing;
+    const erroneous = status === STATUS.ERRONEOUS;
+    const eventName = done ? 'done' : erroneous ? 'error' : status;
+    this._emitLifecycleEvent(eventName, state);
+    if (done || erroneous) {
+      this._emitLifecycleEvent('finally', state);
+    }
+  }
+
   // properties //
   get questionId() {
     return this._questionId;
@@ -130,53 +153,61 @@ export default class AnswerBasedWorkflow extends Workflow {
   }
 
   _query(args = {}) {
+    if (this._linkFn) {
+      this._submit(args);
+      return;
+    }
     // start a new session
     this.restart();
 
-    // keep track of question source on this session
-    const { session } = this;
-    session.meta.question_source = args.questionSource || ORGANIC_QUESTION_SOURCE; // might be null, not undefined
+    // keep track of question source on this session, for suggested questions interactions
+    this._writeQuestionSourceToSession(args);
 
     // build payload and trigger request
     const payload = this._buildPayload(args);
-    const event = mergeApiOptions(this._options.resolved.api, { payload, session });
-    this._request(event);
+    this._request({ payload });
   }
 
-  _request(event) {
-    this._hub.update(fields.request(), event);
+  _submit(args) {
+    if (!this._linkFn) {
+      return;
+    }
+    // TODO: we want a submit event, but only with linkFn
+    const url = this._linkFn(args.q);
+    window.open(url, '_blank');
   }
 
-  _buildPayload() {
-    throw new Error(`Not implemented`);
+  _writeQuestionSourceToSession(args) {
+    this.session.meta.question_source = args.qs || ORGANIC_QUESTION_SOURCE; // might be null, not undefined
   }
 
-  // autocomplete //
-  /*
-  updateCompletions(event) {
-    // TODO: verify
-    this._hub.update(fields.data(DATA_ASPECT.AUTOCOMPLETE), {
-      ...event,
-      source: 'manual',
-    });
-    return this;
+  _buildPayload() {
+    throw new Error(`Not implemented`);
   }
-  */
 
   // data //
-  _defaultProcessData(data) {
-    data = super._defaultProcessData(data);
-
-    // capture question ID and register at context
-    this._writeQuestionIdFromData(data);
+  _updateData(data) {
+    // if it's the head response, write question id and return
+    if (data.value && !data.value.answer_stage) {
+      this._handleHeadResponse(data);
+      return;
+    }
+    super._updateData(data);
 
     // update URL if autoQuery.updateUrl is not false
     this._updateUrlIfNecessary(data);
+  }
 
-    // affiliation
-    data = processAffiliationData(data);
+  _handleHeadResponse(data) {
+    // capture question ID and register at context
+    this._writeQuestionIdFromData(data);
+  }
 
-    return writeAnswerStageToMeta(data);
+  _defaultProcessData(data) {
+    data = super._defaultProcessData(data);
+    data = processAffiliationData(data);
+    data = writeAnswerStageToMeta(data);
+    return data;
   }
 
   _writeQuestionIdFromData({ value }) {
@@ -204,38 +235,32 @@ export default class AnswerBasedWorkflow extends Workflow {
   }
 
   // interactions //
-  _preprocessInteraction(payload) {
-    payload = super._preprocessInteraction(payload) || {};
-    const { context = {} } = payload;
-    const { custom_context = {} } = context;
-    let { questionId } = this;
-    return {
-      ...payload,
+  _defaultProcessInteraction(payload, args) {
+    payload = super._defaultProcessInteraction(payload, args);
+    payload = this._writeAskPropertiesToInteraction(payload, args);
+    return payload;
+  }
+
+  _writeAskPropertiesToInteraction(payload = {}, args) {
+    const question_source = this._getQuestionSourceFromViewState(args);
+    const question_id = this.questionId;
+    return mergeInteraction(payload, {
       context: {
-        ...context,
-        custom_context: trimObj({
-          question_id: questionId,
-          ...custom_context,
-        }),
+        custom_context: {
+          question_source,
+          question_id,
+        },
       },
-    };
+    });
   }
 
-  // handlers //
-  _onAnswerViewUpdate({ session, status, ongoing }) {
-    if (status === STATUS.INITIAL) {
-      return;
-    }
-    const done = status === STATUS.READY && !ongoing;
-    const erroneous = status === STATUS.ERRONEOUS;
-    const eventName = done ? 'done' : erroneous ? 'error' : status;
-    const state = Object.freeze({ session, status, ongoing });
-    this._emit(eventName, state);
-    if (done || erroneous) {
-      this._emit('finally', state);
-    }
+  _getQuestionSourceFromViewState(args) {
+    const { request } = this._hub.states[fields.view(args.role)] || {};
+    const { payload } = request || {};
+    return (payload && payload._meta && payload._meta.question_source) || undefined;
   }
 
+  // handlers //
   _onCitationClick({ index }) {
     const { value } = this.states[fields.data()] || {};
     const { sources } = value || {};
@@ -269,12 +294,11 @@ export default class AnswerBasedWorkflow extends Workflow {
 
 }
 
-// makeConfigurable(AnswerBasedWorkflow.prototype, ['autocomplete']);
-
 Object.assign(AnswerBasedWorkflow, {
   DEFAULT_API_OPTIONS,
   DEFAULT_AUTOCOMPLETE_OPTIONS,
   DEFAULT_LAYOUTS,
   DEFAULT_TRACKERS,
   DEFAULT_OPTIONS,
+  ROLES_OPTIONS,
 });

package/src/workflow/ask.js

@@ -2,7 +2,8 @@ import { defineValues, trimObj, API } from '@miso.ai/commons';
 import AnswerBasedWorkflow from './answer-based.js';
 import { fields } from '../actor/index.js';
 import { ROLE, ORGANIC_QUESTION_SOURCE } from '../constants.js';
-import { OptionListLayout, ListLayout, TextLayout } from '../layout/index.js';
+import { OptionListLayout, ListLayout, SearchBoxLayout } from '../layout/index.js';
+import { mergeInteraction } from './processors.js';
 
 const DEFAULT_API_OPTIONS = Object.freeze({
   ...AnswerBasedWorkflow.DEFAULT_API_OPTIONS,
@@ -15,6 +16,7 @@ const DEFAULT_API_OPTIONS = Object.freeze({
 
 const DEFAULT_LAYOUTS = Object.freeze({
   ...AnswerBasedWorkflow.DEFAULT_LAYOUTS,
+  [ROLE.QUERY]: [SearchBoxLayout.type, { templates: { buttonIcon: 'send' } }],
   [ROLE.RELATED_RESOURCES]: [ListLayout.type, { incremental: true, itemType: 'article' }],
   [ROLE.QUERY_SUGGESTIONS]: OptionListLayout.type,
 });
@@ -36,13 +38,15 @@ const DEFAULT_OPTIONS = Object.freeze({
   trackers: DEFAULT_TRACKERS,
 });
 
+const ROLES_OPTIONS = AnswerBasedWorkflow.ROLES_OPTIONS;
+
 export default class Ask extends AnswerBasedWorkflow {
 
   constructor(context, parentQuestionId) {
     super({
       name: 'ask',
       context,
-      roles: Object.keys(DEFAULT_LAYOUTS),
+      roles: ROLES_OPTIONS,
       defaults: DEFAULT_OPTIONS,
       parentQuestionId,
     });
@@ -64,16 +68,17 @@ export default class Ask extends AnswerBasedWorkflow {
     if (!previous) {
       return;
     }
+    // TODO: write question_source from payload._meta, so we don't need to write it to session.meta
     const values = previous.states[fields.data()].value;
     const value = values.suggested_followup_questions || values.followup_questions || [];
     this._hub.update(fields.suggestions(), { value: value.map(text => ({ text })) });
   }
 
-  _initReset(args) {
+  _initSession(args) {
     // register at context
     args.parentQuestionId && this._context._byPqid.set(args.parentQuestionId, this);
     this._context._events.emit('create', this);
-    super._initReset(args);
+    super._initSession(args);
   }
 
   // lifecycle //
@@ -119,30 +124,33 @@ export default class Ask extends AnswerBasedWorkflow {
   }
 
   // interactions //
-  _preprocessInteraction(payload) {
-    payload = super._preprocessInteraction(payload) || {};
-
-    const { context = {} } = payload;
-    const { ...custom_context } = context.custom_context || {};
-    let { rootQuestionId, parentQuestionId, questionId } = this;
-
-    if (custom_context.property === ROLE.QUERY_SUGGESTIONS) {
-      questionId = parentQuestionId;
-      parentQuestionId = this.previous && this.previous.parentQuestionId;
-      custom_context.property = 'suggested_followup_questions';
-      custom_context.question_source = this.previous && this.previous.session.meta.question_source;
+  _writeAskPropertiesToInteraction(payload, args) {
+    const root_question_id = this.rootQuestionId;
+    let { property } = (payload.context && payload.context.custom_context) || {};
+    let question_id, parent_question_id, question_source;
+
+    if (args.role === ROLE.QUERY_SUGGESTIONS) {
+      property = 'suggested_followup_questions';
+      parent_question_id = this.previous && this.previous.parentQuestionId;
+      question_id = this.parentQuestionId;
+      question_source = this.previous && this.previous.session.meta.question_source;
+    } else {
+      parent_question_id = this.parentQuestionId;
+      question_id = this.questionId;
+      question_source = this._getQuestionSourceFromViewState(args);
     }
-    custom_context.question_id = questionId;
-    custom_context.root_question_id = rootQuestionId;
-    custom_context.parent_question_id = parentQuestionId;
 
-    return {
-      ...payload,
+    return mergeInteraction(payload, {
       context: {
-        ...context,
-        custom_context: trimObj(custom_context),
-      },
-    };
+        custom_context: {
+          property,
+          root_question_id,
+          parent_question_id,
+          question_id,
+          question_source,
+        },
+      }
+    });
   }
 
   // helpers //

package/src/workflow/asks.js

@@ -55,7 +55,7 @@ export default class Asks extends WorkflowContext {
 
     // reset root workflow
     if (root) {
-      this._root.reset();
+      this._root.restart();
     }
   }
 

package/src/workflow/autocompletable.js

@@ -0,0 +1,29 @@
+import { mixin } from '@miso.ai/commons';
+import { fields } from '../actor/index.js';
+import Autocomplete from './autocomplete.js';
+
+export function makeAutocompletable(prototype) {
+  mixin(prototype, AutocompletableMixin.prototype);
+}
+
+export class AutocompletableMixin {
+
+  _initAutocomplete(args) {
+    this._autocomplete = new Autocomplete(this, { defaults: args.defaults.autocomplete });
+  }
+
+  get autocomplete() {
+    return this._autocomplete;
+  }
+
+  updateCompletions(data) {
+    this._hub.update(fields.completions(), data);
+    return this;
+  }
+
+  _destroyAutocomplete() {
+    this._autocomplete && this._autocomplete._destroy();
+    this._autocomplete = undefined;
+  }
+
+}

package/src/workflow/autocomplete.js

@@ -0,0 +1,113 @@
+import { STATUS } from '../constants.js';
+import { fields } from '../actor/index.js';
+import Workflow from './base.js';
+
+const ROLES_OPTIONS = Object.freeze({
+  members: [],
+});
+
+function shimDefaults({ layouts, trackers, ...options } = {}) {
+  return {
+    active: false,
+    ...options,
+    layouts: {},
+    trackers: {},
+  };
+}
+
+function sameInputValue(a, b) {
+  return getInputValue(a) === getInputValue(b);
+}
+
+function getInputValue(args) {
+  return (args && args.value && args.value.trim()) || undefined;
+}
+
+export default class Autocomplete extends Workflow {
+
+  constructor(superworkflow, { defaults, ...args } = {}) {
+    super({
+      name: 'autocomplete',
+      plugin: superworkflow._plugin,
+      client: superworkflow._client,
+      defaults: shimDefaults(defaults),
+      roles: ROLES_OPTIONS,
+      superworkflow,
+      ...args,
+    });
+  }
+
+  _initProperties(args) {
+    super._initProperties(args);
+    this._superworkflow = args.superworkflow;
+    this._active = args.defaults.active;
+  }
+
+  _initSubscriptions(args) {
+    // TODO: how to sync options updates
+    super._initSubscriptions(args);
+    this._unsubscribes = [
+      ...this._unsubscribes,
+      args.superworkflow._hub.on(fields.input(), args => this._query(args)),
+    ];
+  }
+
+  // API //
+  get enabled() {
+    return this._active;
+  }
+
+  enable() {
+    this._active = true;
+  }
+
+  disable() {
+    this._active = false;
+  }
+
+  // query //
+  _query(args) {
+    if (!this._active || sameInputValue(args, this._args)) {
+      return;
+    }
+    this._args = args;
+
+    // start a new session
+    this.restart();
+    const { session } = this;
+    session.meta.input = args;
+
+    // if input value is blank, emit empty response
+    if (!getInputValue(args)) {
+      this._updateCompletions({ session, status: STATUS.INITIAL });
+      return;
+    }
+
+    // payload
+    const payload = this._buildPayload(args);
+
+    // request
+    this._request({ payload });
+  }
+
+  _buildPayload(args) {
+    return { q: getInputValue(args) };
+  }
+
+  // data //
+  _updateDataInHub(data) {
+    if (data.value) {
+      data = {
+        ...data,
+        value: data.value.completions,
+      };
+    }
+    // update completion field in superworkflow hub
+    this._updateCompletions(data);
+  }
+
+  _updateCompletions(data) {
+    this._superworkflow.updateCompletions(data);
+  }
+
+}