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

package/src/workflow/hybrid-search.js

@@ -0,0 +1,125 @@
+import { trimObj, API } from '@miso.ai/commons';
+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 { ListLayout, TextLayout, FacetsLayout } from '../layout/index.js';
+import { writeKeywordsToData, addDataInstructions } from './processors.js';
+
+const DEFAULT_API_OPTIONS = Object.freeze({
+  ...AnswerBasedWorkflow.DEFAULT_API_OPTIONS,
+  name: API.NAME.SEARCH,
+  payload: {
+    ...AnswerBasedWorkflow.DEFAULT_API_OPTIONS.payload,
+  },
+});
+
+const DEFAULT_LAYOUTS = Object.freeze({
+  ...AnswerBasedWorkflow.DEFAULT_LAYOUTS,
+  [ROLE.PRODUCTS]: [ListLayout.type, { itemType: 'article' }],
+  [ROLE.KEYWORDS]: [TextLayout.type, { raw: true }],
+  [ROLE.HITS]: [TextLayout.type, { raw: true, format: 'number' }],
+  [ROLE.FACETS]: [FacetsLayout.type],
+});
+
+const DEFAULT_TRACKERS = Object.freeze({
+  ...AnswerBasedWorkflow.DEFAULT_TRACKERS,
+});
+
+const DEFAULT_OPTIONS = Object.freeze({
+  ...AnswerBasedWorkflow.DEFAULT_OPTIONS,
+  api: DEFAULT_API_OPTIONS,
+  layouts: DEFAULT_LAYOUTS,
+  trackers: DEFAULT_TRACKERS,
+});
+
+const ROLES_CONFIG = Object.freeze({
+  [ROLE.QUESTION]: {
+    mapping: ROLE.KEYWORDS,
+  },
+  [ROLE.FACETS]: {
+    mapping: 'facet_counts',
+  },
+});
+
+export default class HybridSearch extends AnswerBasedWorkflow {
+
+  constructor(plugin, client) {
+    super({
+      name: 'hybrid-search',
+      plugin,
+      client,
+      roles: Object.keys(DEFAULT_LAYOUTS),
+      rolesConfig: ROLES_CONFIG,
+      defaults: DEFAULT_OPTIONS,
+    });
+  }
+
+  _initSubscriptions(args) {
+    super._initSubscriptions(args);
+    this._unsubscribes = [
+      ...this._unsubscribes,
+      this._hub.on(fields.filters(), filters => this._refine(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
+      },
+    });
+  }
+
+  _buildFq(filters) {
+    if (!filters) {
+      return undefined;
+    }
+    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 ')})`);
+    }
+    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;
+
+    const event = mergeApiOptions(this._options.resolved.api, { payload, session, _skipLoading: true });
+    this._request(event);
+
+    // emulate loading status exclusively for products
+    // TODO
+  }
+
+  // data //
+  _defaultProcessData(data) {
+    data = super._defaultProcessData(data);
+    data = writeKeywordsToData(data);
+    data = instructPartialUpdates(data);
+    return data;
+  }
+
+}
+
+function instructPartialUpdates(data) {
+  if (!data.value) {
+    return data;
+  }
+  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 });
+}

package/src/workflow/index.js

@@ -1,4 +1,5 @@
 export { default as Asks } from './asks.js';
+export { default as HybridSearch } from './hybrid-search.js';
 export { default as Explore } from './explore.js';
 export { default as Search } from './search.js';
 export { default as Recommendations } from './recommendations.js';

package/src/workflow/processors.js

@@ -0,0 +1,95 @@
+import { trimObj } from '@miso.ai/commons';
+import { STATUS } from '../constants.js';
+
+export function writeDataStatus(data) {
+  const status = getStatus(data);
+  const ongoing = status === STATUS.READY ? !!data.ongoing : undefined;
+  return trimObj({ ...data, status, ongoing });
+}
+
+function getStatus(data) {
+  if (!data) {
+    return STATUS.INITIAL;
+  }
+  const { request, error, value } = data;
+  return error ? STATUS.ERRONEOUS : value ? STATUS.READY : request ? STATUS.LOADING : STATUS.INITIAL;
+}
+
+export function writeMisoIdToMeta(data) {
+  const { value } = data;
+  if (!value) {
+    return data;
+  }
+  const { miso_id } = value;
+  if (!miso_id) {
+    return data;
+  }
+  return {
+    ...data,
+    meta: {
+      ...data.meta,
+      miso_id,
+    },
+  };
+}
+
+export function writeKeywordsToData(data) {
+  const { request, value } = data;
+  if (!request || !value) {
+    return data;
+  }
+  const { payload } = request || {};
+  const { q: keywords } = payload || {};
+  if (!keywords) {
+    return data;
+  }
+  return {
+    ...data,
+    value: {
+      ...value,
+      keywords,
+    },
+  };
+}
+
+export function writeAnswerStageToMeta(data) {
+  const { value } = data;
+  if (!value) {
+    return data;
+  }
+  const { answer_stage } = value;
+  if (!answer_stage) {
+    return data;
+  }
+  // 1. put answer_stage to meta
+  // 2. mark ongoing flag
+  return {
+    ...data,
+    ongoing: !value.finished,
+    meta: {
+      ...data.meta,
+      answer_stage,
+    },
+  };
+}
+
+export function addDataInstructions(data, instructions) {
+  if (!instructions) {
+    return data;
+  }
+  return {
+    _inst: {
+      ...data._inst,
+      ...instructions,
+    },
+    ...data,
+  };
+}
+
+export function removeDataInstructions(data) {
+  if (typeof data !== 'object') {
+    return data;
+  }
+  const { _inst, ...rest } = data;
+  return rest;
+}

package/src/workflow/recommendation.js

@@ -35,12 +35,19 @@ export default class Recommendation extends Workflow {
       context,
       roles: Object.keys(DEFAULT_LAYOUTS),
       defaults: DEFAULT_OPTIONS,
+      id,
     });
+  }
 
+  _initProperties(args) {
+    super._initProperties(args);
+    const { id } = args;
     defineValues(this, { id });
-    this._context = context;
+  }
 
-    context._members.set(id, this);
+  _initReset(args) {
+    this._context._members.set(args.id, this);
+    super._initReset(args);
   }
 
   // lifecycle //

package/src/workflow/search.js

@@ -1,9 +1,9 @@
 import { API } from '@miso.ai/commons';
 import Workflow from './base.js';
 import { mergeApiOptions } from './options.js';
-import * as sources from '../source/index.js';
+import * as sources from '../source.js';
 import { fields, AutocompleteActor } from '../actor/index.js';
-import { ROLE } from '../constants.js';
+import { ROLE, DATA_ASPECT } from '../constants.js';
 import { ListLayout, SearchBoxLayout } from '../layout/index.js';
 import { makeConfigurable } from './options.js';
 
@@ -54,13 +54,22 @@ export default class Search extends Workflow {
       roles: Object.keys(DEFAULT_LAYOUTS),
       defaults: DEFAULT_OPTIONS,
     });
+  }
 
+  _initActors(args) {
+    super._initActors(args);
     this._autocomplete = new AutocompleteActor(this._hub, {
       source: sources.api(this._client),
       options: this._options,
     });
+  }
 
-    this._unsubscribes.push(this._hub.on(fields.query(), payload => this.query(payload)));
+  _initSubscriptions(args) {
+    super._initSubscriptions(args);
+    this._unsubscribes = [
+      ...this._unsubscribes,
+      this._hub.on(fields.query(), args => this._query(args)),
+    ];
   }
 
   // lifecycle //
@@ -80,16 +89,35 @@ export default class Search extends Workflow {
     }
   }
 
-  query(payload) {
+  query(args) {
+    if (!args.q) {
+      throw new Error(`q is required in query() call`);
+    }
+    this._hub.update(fields.query(), args);
+  }
+
+  _query(args) {
+    // start a new session
     this.restart();
     const { session } = this;
-    this._hub.update(fields.request(), mergeApiOptions(this._options.resolved.api, { payload, session }));
-    return this;
+
+    // build payload and trigger request
+    const payload = this._buildPayload(args);
+    const event = mergeApiOptions(this._options.resolved.api, { payload, session });
+    this._request(event);
+  }
+
+  _buildPayload(args) {
+    return args;
+  }
+
+  _request(event) {
+    this._hub.update(fields.request(), event);
   }
 
   updateCompletions(event) {
     // TODO: verify
-    this._hub.update(fields.completions(), {
+    this._hub.update(fields.data(DATA_ASPECT.AUTOCOMPLETE), {
       ...event,
       source: 'manual',
     });

package/dist/cjs/source/api.js

@@ -1,23 +0,0 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.default = _default;
-var _commons = require("@miso.ai/commons");
-function _default(client) {
-  // TODO: send uuid & unit id
-  return async _ref => {
-    let {
-      group,
-      name,
-      payload,
-      options
-    } = _ref;
-    if (group === _commons.API.GROUP.ASK && name === _commons.API.NAME.QUESTIONS) {
-      return client.api.ask.questions(payload, options);
-    }
-    // because name is in snake case
-    return client.api[group]._run(name, payload, options);
-  };
-}

package/src/source/api.js

@@ -1,12 +0,0 @@
-import { API } from '@miso.ai/commons';
-
-export default function(client) {
-  // TODO: send uuid & unit id
-  return async ({ group, name, payload, options }) => {
-    if (group === API.GROUP.ASK && name === API.NAME.QUESTIONS) {
-      return client.api.ask.questions(payload, options);
-    }
-    // because name is in snake case
-    return client.api[group]._run(name, payload, options);
-  };
-}