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

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

@@ -0,0 +1,78 @@
+import AnswerBasedWorkflow from './answer-based.js';
+import { ROLE, STATUS, ORGANIC_QUESTION_SOURCE } from '../constants.js';
+import { writeKeywordsToData } from './processors.js';
+
+const ROLES_CONFIG = Object.freeze({
+  [ROLE.QUESTION]: {
+    mapping: ROLE.KEYWORDS,
+  },
+});
+
+export default class HybridSearchAnswer extends AnswerBasedWorkflow {
+
+  constructor(superworkflow) {
+    super({
+      name: 'hybrid-search/answer',
+      plugin: superworkflow._plugin,
+      client: superworkflow._client,
+      options: superworkflow._options,
+      roles: Object.keys(AnswerBasedWorkflow.DEFAULT_LAYOUTS),
+      rolesConfig: ROLES_CONFIG,
+      superworkflow,
+    });
+    this.useInteractions(false);
+  }
+
+  _initProperties(args) {
+    super._initProperties(args);
+    this._superworkflow = args.superworkflow;
+  }
+
+  _initReset() {} // no reset here, will manually reset later
+
+  restart() {
+    super.restart();
+    // cascade restart to the sibling
+    const results = this._superworkflow._results;
+    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 //
+  _updateData(data) {
+    // we want this to be available everywhere
+    data = writeKeywordsToData(data);
+
+    switch (data.status) {
+      case STATUS.INITIAL:
+      case STATUS.LOADING:
+        // share the initial/loading status with its sibling
+        this._dispatchDataToSibling(data);
+        break;
+    }
+    super._updateData(data);
+  }
+
+  _handleHeadResponse(data) {
+    super._handleHeadResponse(data);
+    // share the search results with its sibling
+    this._dispatchDataToSibling(data);
+  }
+
+  _dispatchDataToSibling(data) {
+    this._superworkflow._results.updateData({ ...data, session: this._resultsSession });
+  }
+
+}

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

@@ -0,0 +1,79 @@
+import { trimObj } from '@miso.ai/commons';
+import Workflow from './base.js';
+import { fields } from '../actor/index.js';
+import { ROLE } from '../constants.js';
+import { mergeApiOptions } from './options.js';
+import { writeKeywordsToData, composeFq } from './processors.js';
+
+const ROLES_CONFIG = Object.freeze({
+  [ROLE.FACETS]: {
+    mapping: 'facet_counts',
+  },
+});
+
+export default class HybridSearchResults extends Workflow {
+
+  constructor(superworkflow) {
+    super({
+      name: 'hybrid-search/results',
+      plugin: superworkflow._plugin,
+      client: superworkflow._client,
+      options: superworkflow._options,
+      roles: [ROLE.PRODUCTS, ROLE.KEYWORDS, ROLE.HITS, ROLE.FACETS],
+      rolesConfig: ROLES_CONFIG,
+      superworkflow,
+    });
+    this.useInteractions(false);
+  }
+
+  _initProperties(args) {
+    super._initProperties(args);
+    this._superworkflow = args.superworkflow;
+  }
+
+  _initSubscriptions(args) {
+    super._initSubscriptions(args);
+    this._unsubscribes = [
+      ...this._unsubscribes,
+      this._hub.on(fields.filters(), filters => this._refine(filters)),
+    ];
+  }
+
+  _initReset() {} // no reset here, will manually reset later
+
+  // query //
+  _refine(filters) {
+    // start a new session
+    this.restart();
+
+    // get stored query from sibling
+    const query = this._superworkflow._answer._hub.states[fields.query()];
+    const payload = this._buildPayload({ ...query, filters, answer: false });
+    const { session } = this;
+    const event = mergeApiOptions(this._options.resolved.api, { payload, session });
+
+    this._request(event);
+  }
+
+  _buildPayload({ filters, ...payload } = {}) {
+    // borrow the work from the sibling
+    payload = this._superworkflow._answer._buildPayload(payload);
+    const fq = composeFq(filters); // TODO: combine with fq in payload?
+    return trimObj({
+      ...payload,
+      fq,
+    });
+  }
+
+  _request(event) {
+    this._hub.update(fields.request(), event);
+  }
+
+  // data //
+  _defaultProcessData(data) {
+    data = super._defaultProcessData(data);
+    data = writeKeywordsToData(data);
+    return data;
+  }
+
+}

package/src/workflow/hybrid-search.js

@@ -1,16 +1,17 @@
-import { trimObj, API } from '@miso.ai/commons';
+import { API } from '@miso.ai/commons';
+import { InteractionsActor } from '../actor/index.js';
+import Workflow from './base.js';
 import AnswerBasedWorkflow from './answer-based.js';
-import { mergeApiOptions } from './options.js';
-import { fields } from '../actor/index.js';
-import { ROLE, ORGANIC_QUESTION_SOURCE } from '../constants.js';
+import { ROLE } from '../constants.js';
 import { ListLayout, TextLayout, FacetsLayout } from '../layout/index.js';
-import { writeKeywordsToData, addDataInstructions } from './processors.js';
+import HybridSearchResults from './hybrid-search-results.js';
 
 const DEFAULT_API_OPTIONS = Object.freeze({
   ...AnswerBasedWorkflow.DEFAULT_API_OPTIONS,
   name: API.NAME.SEARCH,
   payload: {
     ...AnswerBasedWorkflow.DEFAULT_API_OPTIONS.payload,
+    fl: ['cover_image', 'url', 'created_at', 'updated_at', 'published_at'],
   },
 });
 
@@ -42,7 +43,25 @@ const ROLES_CONFIG = Object.freeze({
   },
 });
 
-export default class HybridSearch extends AnswerBasedWorkflow {
+const SUBWORKFLOW = Object.freeze({
+  ANSWER: 'answer',
+  RESULTS: 'results',
+});
+
+function getSubworkflowByRole(role) {
+  // TODO: ROLE.ERROR
+  switch (role) {
+    case ROLE.PRODUCTS:
+    case ROLE.HITS:
+    case ROLE.FACETS:
+    case ROLE.KEYWORDS:
+      return SUBWORKFLOW.RESULTS;
+    default:
+      return SUBWORKFLOW.ANSWER;
+  }
+}
+
+export default class HybridSearch extends Workflow {
 
   constructor(plugin, client) {
     super({
@@ -55,71 +74,187 @@ export default class HybridSearch extends AnswerBasedWorkflow {
     });
   }
 
-  _initSubscriptions(args) {
-    super._initSubscriptions(args);
-    this._unsubscribes = [
-      ...this._unsubscribes,
-      this._hub.on(fields.filters(), filters => this._refine(filters)),
+  _initProperties(args) {
+    super._initProperties(args);
+    this._subworkflows = [
+      this._answer = new HybridSearchAnswer(this),
+      this._results = new HybridSearchResults(this),
     ];
   }
 
+  _getSubworkflow(name) {
+    switch (name) {
+      case SUBWORKFLOW.ANSWER:
+        return this._answer;
+      case SUBWORKFLOW.RESULTS:
+        return this._results;
+      default:
+        throw new Error(`Invalid subworkflow: ${name}`);
+    }
+  }
+
+  _initActors() {
+    const hub = this._hub;
+    const client = this._client;
+    const options = this._options;
+
+    this._views = new HybridSearchViewsActor(this);
+    this._interactions = new InteractionsActor(hub, { client, options });
+  }
+
+  _initReset() {
+    this._results.reset();
+    this._answer.reset();
+  }
+
+  restart({ answer = true } = {}) {
+    const previousSession = this.session;
+    this._sessions.restart();
+    const { session } = this;
+    if (!answer) {
+      session._answer = previousSession._answer || previousSession;
+    }
+    return this;
+  }
+
+  // properties //
+  get questionId() {
+    return this._answer.questionId;
+  }
+
+  get filters() {
+    return this._results._views.filters;
+  }
+
   // query //
-  _buildPayload({ q, qs, filters, ...payload } = {}) {
-    const fq = this._buildFq(filters); // TODO: combine with fq in payload?
-    return trimObj({
-      ...payload,
-      q, // q, not question
-      fq,
-      _meta: {
-        ...payload._meta,
-        question_source: qs || ORGANIC_QUESTION_SOURCE, // might be null, not undefined
-      },
-    });
+  autoQuery(options) {
+    this._answer.autoQuery(options);
+  }
+
+  query(args) {
+    this._answer.query(args);
   }
 
-  _buildFq(filters) {
-    if (!filters) {
-      return undefined;
+  // interactions //
+  _preprocessInteraction(payload) {
+    return this._answer._preprocessInteraction(payload);
+  }
+
+  // destroy //
+  _destroy() {
+    for (const subworkflow of this._subworkflows) {
+      subworkflow.destroy();
     }
-    const clauses = [];
-    const { facets } = filters;
-    for (const field in facets) {
-      const values = facets[field];
-      if (!values || !values.length) {
-        continue; // just in case
-      }
-      clauses.push(`${field}:(${values.map(v => `"${v}"`).join(' OR ')})`);
+    super._destroy();
+  }
+
+}
+
+class HybridSearchViewsActor {
+
+  constructor(workflow) {
+    this._workflow = workflow;
+    this._containers = new Set();
+  }
+
+  get(role) {
+    return this._getSubviews(role).get(role);
+  }
+
+  addContainer(element) {
+    if (this._containers.has(element)) {
+      return;
+    }
+    this._containers.add(element);
+
+    const { components } = element;
+    for (const component of components) {
+      this.addComponent(component);
     }
-    return clauses.map(c => `(${c})`).join(' AND ');
   }
 
-  _refine(filters) {
-    const query = this._hub.states[fields.query()];
-    const payload = this._buildPayload({ ...query, filters, answer: false });
-    const { session } = this;
+  removeContainer(element) {
+    for (const subworkflow of this._workflow._subworkflows) {
+      subworkflow._views.removeContainer(element);
+    }
+    this._containers.delete(element);
+  }
+
+  addComponent(element) {
+    this._getViewByElement(element).element = element;
+    this._addContainerToSubviews(element._container, element);
+  }
 
-    const event = mergeApiOptions(this._options.resolved.api, { payload, session, _skipLoading: true });
-    this._request(event);
+  removeComponent(element) {
+    this._getViewByElement(element).element = undefined;
+    this._removeContainerFromSubviewsIfNecessary(element._container);
+  }
 
-    // emulate loading status exclusively for products
+  updateComponentRole(element, oldRole, newRole) {
     // TODO
   }
 
-  // data //
-  _defaultProcessData(data) {
-    data = super._defaultProcessData(data);
-    data = writeKeywordsToData(data);
-    data = instructPartialUpdates(data);
-    return data;
+  refreshElement(element) {
+    const view = element.isContainer ? this._containers.get(element) : this._getViewByElement(element);
+    view && view.refresh({ force: true });
   }
 
-}
+  // helpers //
+  _getSubworkflow(role) {
+    return this._workflow._getSubworkflow(getSubworkflowByRole(role));
+  }
+
+  _getAllSubviews() {
+    return this._workflow._subworkflows.flatMap(subworkflow => subworkflow._views);
+  }
 
-function instructPartialUpdates(data) {
-  if (!data.value) {
-    return data;
+  _getSubviews(role) {
+    return this._getSubworkflow(role)._views;
   }
-  return addDataInstructions(data, data.value.products ? 
-    { includes: [ ROLE.PRODUCTS, ROLE.HITS, ROLE.FACETS, ROLE.KEYWORDS, ROLE.QUESTION ], merge: true } :
-    { excludes: [ ROLE.PRODUCTS, ROLE.HITS, ROLE.FACETS ], merge: true });
+
+  _getViewByElement(element) {
+    let { role } = element;
+    if (!role) {
+      throw new Error('Component must have a role');
+    }
+    return this.get(role);
+  }
+
+  _addContainerToSubviews(container, child) {
+    if (!container) {
+      return;
+    }
+    const { role } = child;
+    const subviews = this._getSubviews(role);
+    if (subviews._containers.has(container)) {
+      return;
+    }
+    // check if the container is in other subviews
+    for (const otherSubviews of this._getAllSubviews()) {
+      if (otherSubviews === subviews) {
+        continue;
+      }
+      if (otherSubviews._containers.has(container)) {
+        // find the conflicting element
+        for (const component of container.components) {
+          if (otherSubviews.containsElement(component)) {
+            throw new Error(`<${container.tagName}> cannot contain both <${component.tagName}> and <${child.tagName}>, for they don't share the same data lifecycle.`);
+          }
+        }
+        throw new Error(`Failed to add container <${container.tagName}> with child component <${child.tagName}>.`);
+      }
+    }
+    // add the container to the subviews
+    subviews.addContainer(container);
+  }
+
+  _removeContainerFromSubviewsIfNecessary(container) {
+    if (!container || container.components.length > 0) {
+      return;
+    }
+    for (const subviews of this._getAllSubviews()) {
+      subviews.removeContainer(container);
+    }
+  }
+
 }

package/src/workflow/processors.js

@@ -73,23 +73,18 @@ export function writeAnswerStageToMeta(data) {
   };
 }
 
-export function addDataInstructions(data, instructions) {
-  if (!instructions) {
-    return data;
+export function composeFq(filters) {
+  if (!filters) {
+    return undefined;
   }
-  return {
-    _inst: {
-      ...data._inst,
-      ...instructions,
-    },
-    ...data,
-  };
-}
-
-export function removeDataInstructions(data) {
-  if (typeof data !== 'object') {
-    return data;
+  const clauses = [];
+  const { facets } = filters;
+  for (const field in facets) {
+    const values = facets[field];
+    if (!values || !values.length) {
+      continue; // just in case
+    }
+    clauses.push(`${field}:(${values.map(v => `"${v}"`).join(' OR ')})`);
   }
-  const { _inst, ...rest } = data;
-  return rest;
+  return clauses.map(c => `(${c})`).join(' AND ');
 }