@miso.ai/client-sdk-ui 1.11.4-beta.0 → 1.11.4-beta.2

package/src/workflow/base.js

@@ -3,7 +3,7 @@ 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 { WorkflowOptions, mergeApiOptions, makeConfigurable } from './options.js';
+import { WorkflowOptions, mergeApiOptions, makeConfigurable } from './options/index.js';
 import { getRevision, writeDataStatus, writeMisoIdToMeta, buildBaseInteraction, writeAffiliationInfoToInteraction, mergeInteraction } from './processors.js';
 
 // TODO: just bury this into hub
@@ -61,6 +61,7 @@ export default class Workflow extends Component {
     this._defaults = args.defaults;
     this._options = options || new WorkflowOptions(context && context._options, args.defaults);
     this._hub = injectLogger(new Hub(), (...args) => this._log(...args));
+    this._sessionContext = new WeakMap();
 
     this._initProperties(args);
     this._initActors(args);
@@ -97,6 +98,15 @@ export default class Workflow extends Component {
     this.restart();
   }
 
+  _getSessionContext(session) {
+    let context = this._sessionContext.get(session);
+    if (!context) {
+      this._sessionContext.set(session, context = {});
+    }
+    return context;
+  }
+
+  // properties //
   get uuid() {
     return this.session && this.session.uuid;
   }
@@ -152,7 +162,18 @@ export default class Workflow extends Component {
     }
   }
 
+  _shallEmitLifecycleEvent(name, { session }) {
+    const context = this._getSessionContext(session);
+    const events = context.lifecycleEvents || (context.lifecycleEvents = new Set());
+    const emitted = events.has(name);
+    events.add(name);
+    return !emitted;
+  }
+
   _emitLifecycleEvent(name, event) {
+    if (!this._shallEmitLifecycleEvent(name, event)) {
+      return;
+    }
     this._emit(name, event);
   }
 

package/src/workflow/context.js

@@ -1,5 +1,5 @@
 import { Component } from '@miso.ai/commons';
-import { WorkflowContextOptions, makeConfigurable } from './options.js';
+import { WorkflowContextOptions, makeConfigurable } from './options/index.js';
 
 export default class WorkflowContext extends Component {
 

package/src/workflow/explore.js

@@ -3,7 +3,7 @@ import Workflow from './base.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 { mergeRolesOptions } from './options/index.js';
 import { enableUseLink, UseLinkMixin } from './use-link.js';
 
 const DEFAULT_API_OPTIONS = Object.freeze({

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

@@ -1,6 +1,6 @@
 import AnswerBasedWorkflow from './answer-based.js';
 import { ROLE, STATUS, ORGANIC_QUESTION_SOURCE } from '../constants.js';
-import { mergeRolesOptions } from './options.js';
+import { mergeRolesOptions } from './options/index.js';
 import { writeKeywordsToData } from './processors.js';
 import { makeAutocompletable } from './autocompletable.js';
 
@@ -42,10 +42,15 @@ export default class HybridSearchAnswer extends AnswerBasedWorkflow {
   }
 
   // query //
-  _buildPayload({ q, qs, ...payload } = {}) {
+  _buildPayload(payload) {
+    payload = this._writeQuestionSourceToPayload(payload);
+    payload = this._superworkflow._results._writeFiltersToPayload(payload);
+    return payload;
+  }
+
+  _writeQuestionSourceToPayload({ qs, ...payload } = {}) {
     return {
       ...payload,
-      q, // q, not question
       _meta: {
         ...payload._meta,
         question_source: qs || ORGANIC_QUESTION_SOURCE, // might be null, not undefined

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

@@ -2,11 +2,12 @@ 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],
-});
+// we want to override members, not adding to it
+const ROLES_OPTIONS = {
+  ...SearchBasedWorkflow.ROLES_OPTIONS,
+  members: [ROLE.PRODUCTS, ROLE.KEYWORDS, ROLE.TOTAL, ROLE.FACETS, ROLE.SORT, ROLE.MORE, ROLE.ERROR],
+};
 
 export default class HybridSearchResults extends SearchBasedWorkflow {
 
@@ -41,14 +42,23 @@ export default class HybridSearchResults extends SearchBasedWorkflow {
     return this._superworkflow._answer._hub.states[fields.query()];
   }
 
-  _buildPayload({ filters, ...payload } = {}) {
+  _buildPayload(payload) {
     // borrow the work from the sibling
-    payload = this._superworkflow._answer._buildPayload(payload);
-    payload = SearchBasedWorkflow.prototype._buildPayload.call(this, { filters, ...payload });
+    payload = this._superworkflow._answer._writeQuestionSourceToPayload(payload);
+    payload = this._writeFiltersToPayload(payload);
+    payload = this._writePageInfoToPayload(payload);
     payload = this._writeQuestionIdToPayload(payload);
     return { ...payload, answer: false };
   }
 
+  _buildOrderBy(sort) {
+    if (!sort) {
+      return undefined;
+    }
+    // works differently than search
+    return sort.field;
+  }
+
   _writeQuestionIdToPayload(payload) {
     return {
       ...payload,
@@ -60,3 +70,7 @@ export default class HybridSearchResults extends SearchBasedWorkflow {
   }
 
 }
+
+Object.assign(HybridSearchResults, {
+  ROLES_OPTIONS,
+});

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

@@ -1,17 +1,9 @@
 import { ROLE } from '../constants.js';
+import HybridSearchResults from './hybrid-search-results.js';
 
 function getSubworkflowByRole(role) {
   // TODO: ROLE.ERROR
-  switch (role) {
-    case ROLE.PRODUCTS:
-    case ROLE.TOTAL:
-    case ROLE.FACETS:
-    case ROLE.KEYWORDS:
-    case ROLE.MORE:
-      return 'results';
-    default:
-      return 'answer';
-  }
+  return HybridSearchResults.ROLES_OPTIONS.members.includes(role) ? 'results' : 'answer';
 }
 
 export default class HybridSearchViewsActor {
@@ -102,10 +94,10 @@ export default class HybridSearchViewsActor {
         // 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(`<${container.tagName.toLowerCase()}> cannot contain both <${component.tagName.toLowerCase()}> and <${child.tagName.toLowerCase()}>, for they don't share the same data lifecycle.`);
           }
         }
-        throw new Error(`Failed to add container <${container.tagName}> with child component <${child.tagName}>.`);
+        throw new Error(`Failed to add container <${container.tagName.toLowerCase()}> with child component <${child.tagName.toLowerCase()}>.`);
       }
     }
     // add the container to the subviews

package/src/workflow/hybrid-search.js

@@ -3,11 +3,12 @@ import { InteractionsActor } from '../actor/index.js';
 import Workflow from './base.js';
 import SearchBasedWorkflow from './search-based.js';
 import AnswerBasedWorkflow from './answer-based.js';
-import { ROLE } from '../constants.js';
+import { ROLE, WORKFLOW_CONFIGURABLE } from '../constants.js';
 import { SearchBoxLayout, TextLayout } from '../layout/index.js';
 import HybridSearchAnswer from './hybrid-search-answer.js';
 import HybridSearchResults from './hybrid-search-results.js';
 import HybridSearchViewsActor from './hybrid-search-views.js';
+import { makeConfigurable } from './options/index.js';
 
 const DEFAULT_API_OPTIONS = Object.freeze({
   group: API.GROUP.ASK,
@@ -117,6 +118,14 @@ export default class HybridSearch extends Workflow {
   }
 
   // properties //
+  get answer() {
+    return this._answer;
+  }
+
+  get results() {
+    return this._results;
+  }
+
   get questionId() {
     return this._answer.questionId;
   }
@@ -152,3 +161,5 @@ export default class HybridSearch extends Workflow {
   }
 
 }
+
+makeConfigurable(HybridSearch.prototype, [WORKFLOW_CONFIGURABLE.PAGINATION, WORKFLOW_CONFIGURABLE.FILTERS]);

package/src/workflow/options/api.js

@@ -0,0 +1,46 @@
+import { trimObj } from '@miso.ai/commons';
+import { mergeOptions } from './utils.js';
+
+export function normalizeApiOptions([name, payload] = []) {
+  // TODO: take object form as well
+  if (name === false) {
+    return { actor: false };
+  }
+  if (typeof name === 'object' && payload === undefined) {
+    payload = name;
+    name = undefined;
+  }
+  let group = undefined;
+  if (name && name.indexOf('/') !== -1) {
+    [group, name] = name.split('/');
+  }
+  if ((name && typeof name !== 'string') || (payload !== undefined && typeof payload !== 'object')) {
+    throw new Error(`Invalid arguments for useApi(): ${name}, ${payload}`);
+  }
+  return trimObj({ group, name, payload });
+}
+
+export function mergeApiOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, {
+    ...options,
+    payload: mergeApiPayloads(merged.payload, options.payload),
+  }));
+}
+
+function mergeApiPayloads(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    ...mergeObjectValueIfPresent('_meta', base, overrides),
+  };
+}
+
+function mergeObjectValueIfPresent(key, base, overrides) {
+  const baseValue = base && base[key];
+  const overridesValue = overrides && overrides[key];
+  const value = baseValue ? (overridesValue ? { ...baseValue, ...overridesValue } : baseValue) : overridesValue;
+  return value !== undefined ? { [key]: value } : {};
+}

package/src/workflow/options/configurable.js

@@ -0,0 +1,48 @@
+import { WORKFLOW_CONFIGURABLE } from '../../constants.js';
+
+const DEFAULT_FEATURES = [
+  WORKFLOW_CONFIGURABLE.API,
+  WORKFLOW_CONFIGURABLE.LAYOUTS,
+  WORKFLOW_CONFIGURABLE.DATA_PROCESSOR,
+  WORKFLOW_CONFIGURABLE.TRACKERS,
+  WORKFLOW_CONFIGURABLE.INTERACTIONS,
+];
+
+export function makeConfigurable(prototype, features = DEFAULT_FEATURES) {
+  for (const feature of features) {
+    injectConfigurableFeature(prototype, feature);
+  }
+}
+
+function injectConfigurableFeature(prototype, feature) {
+  if (feature === 'api') {
+    Object.assign(prototype, {
+      useApi(...args) {
+        this._options.api.merge(args);
+        return this;
+      },
+      clearApi() {
+        this._options.api.set();
+        return this;
+      },
+    });
+  } else {
+    const upperCased = upperCase(feature);
+    Object.assign(prototype, {
+      [`use${upperCased}`](value) {
+        (this._options[feature]).merge(value);
+        return this;
+      },
+      [`clear${upperCased}`]() {
+        (this._options[feature]).set();
+        return this;
+      },
+    });
+  }
+}
+
+// helpers //
+// TODO: move to commons
+function upperCase(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}

package/src/workflow/options/data-processor.js

@@ -0,0 +1,15 @@
+import { asArray } from '@miso.ai/commons';
+
+export function normalizeDataProcessorOptions(fns) {
+  fns = asArray(fns);
+  for (const fn of fns) {
+    if (typeof fn !== 'function') {
+      throw new Error(`Expect data processor options to be a function: ${fn}`);
+    }
+  }
+  return fns;
+}
+
+export function mergeDataProcessorOptions(...optionsList) {
+  return optionsList.flat().filter(Boolean);
+}

package/src/workflow/options/filters.js

@@ -0,0 +1,10 @@
+import { mergeOptions, normalizeOptions } from './utils.js';
+
+export const normalizeFiltersOptions = normalizeOptions;
+
+export function mergeFiltersOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, options));
+}

package/src/workflow/options/index.js

@@ -0,0 +1,10 @@
+export * from './roles.js';
+export * from './api.js';
+export * from './layouts.js';
+export * from './data-processor.js';
+export * from './trackers.js';
+export * from './interactions.js';
+export * from './filters.js';
+export * from './pagination.js';
+export * from './options.js';
+export * from './configurable.js';

package/src/workflow/options/interactions.js

@@ -0,0 +1,36 @@
+import { asArray } from '@miso.ai/commons';
+import { mergeOptions } from './utils.js';
+
+export function normalizeInteractionsOptions(options) {
+  if (options === undefined) {
+    return undefined;
+  }
+  if (options === false) {
+    return {
+      handle: () => {},
+    };
+  }
+  // preprocess
+  const preprocess = asArray(options.preprocess);
+  for (const p of preprocess) {
+    if (typeof p !== 'function') {
+      throw new Error(`Expect preprocess options to be a function: ${p}`);
+    }
+  }
+  // handle
+  if (options.handle && typeof options.handle !== 'function') {
+    throw new Error(`Expect handle options to be a function: ${options.handle}`);
+  }
+  return { ...options, preprocess };
+}
+
+export function mergeInteractionsOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, {
+    ...options,
+    preprocess: concatArrays(merged.preprocess, options.preprocess),
+  }));
+}
+

package/src/workflow/options/layouts.js

@@ -0,0 +1,73 @@
+import { asArray, lowerCamelToSnake, kebabToSnake } from '@miso.ai/commons';
+import { ROLE } from '../../constants.js';
+import { mergeOptions } from './utils.js';
+
+export function normalizeLayoutsOptions(options = {}) {
+  if (options === false) {
+    return false;
+  }
+  // fallback: results -> products
+  const { results, ...rest } = options;
+  if (results !== undefined) {
+    console.warn(`useLayouts({ results: ... }) is deprecated, use useLayouts({ ${ROLE.PRODUCTS}: ... }) instead`);
+    options = { ...rest, [ROLE.PRODUCTS]: results };
+  }
+  const normalize = {};
+  for (const [role, args] of Object.entries(options)) {
+    normalize[normalizeRole(role)] = normalizeLayoutOptions(args);
+  }
+  return normalize;
+}
+
+function normalizeRole(role) {
+  role = lowerCamelToSnake(role);
+  role = kebabToSnake(role);
+  return role;
+}
+
+function normalizeLayoutOptions(args) {
+  // take args:
+  // * undefined
+  // * false
+  // * name (string)
+  // * options (object)
+  // * [name, options]
+  if (args === undefined) {
+    return undefined;
+  }
+  let [name, options] = asArray(args);
+  if (typeof name === 'object') {
+    options = name;
+    name = undefined;
+  }
+  return [name, options];
+}
+
+export function mergeLayoutsOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => {
+    for (const [role, args] of Object.entries(options)) {
+      merged[role] = mergeLayoutOptions(merged[role], args);
+    }
+    return merged;
+  });
+}
+
+function mergeLayoutOptions(base, overrides) {
+  overrides = normalizeLayoutOptions(overrides);
+  if (overrides[0] === false) {
+    return overrides;
+  }
+  return base && overrides ? [overrides[0] || base[0], mergeLayoutParameters(base[1], overrides[1])] : (overrides || base);
+}
+
+function mergeLayoutParameters(base, overrides) {
+  return {
+    ...base,
+    ...overrides,
+    link: { ...(base && base.link), ...(overrides && overrides.link) },
+    templates: { ...(base && base.templates), ...(overrides && overrides.templates) },
+  };
+}

package/src/workflow/options/options.js

@@ -0,0 +1,169 @@
+import { EventEmitter, defineValues } from '@miso.ai/commons';
+import { WORKFLOW_CONFIGURABLE } from '../../constants.js';
+import { normalizeApiOptions, mergeApiOptions } from './api.js';
+import { normalizeLayoutsOptions, mergeLayoutsOptions } from './layouts.js';
+import { normalizeDataProcessorOptions, mergeDataProcessorOptions } from './data-processor.js';
+import { normalizeTrackersOptions, mergeTrackersOptions } from './trackers.js';
+import { normalizeInteractionsOptions, mergeInteractionsOptions } from './interactions.js';
+import { normalizeFiltersOptions, mergeFiltersOptions } from './filters.js';
+import { normalizePaginationOptions, mergePaginationOptions } from './pagination.js';
+
+const FEATURES = [
+  {
+    key: WORKFLOW_CONFIGURABLE.API,
+    normalize: normalizeApiOptions,
+    merge: mergeApiOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.LAYOUTS,
+    normalize: normalizeLayoutsOptions,
+    merge: mergeLayoutsOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.DATA_PROCESSOR,
+    normalize: normalizeDataProcessorOptions,
+    merge: mergeDataProcessorOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.TRACKERS,
+    normalize: normalizeTrackersOptions,
+    merge: mergeTrackersOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.INTERACTIONS,
+    normalize: normalizeInteractionsOptions,
+    merge: mergeInteractionsOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.FILTERS,
+    normalize: normalizeFiltersOptions,
+    merge: mergeFiltersOptions,
+  },
+  {
+    key: WORKFLOW_CONFIGURABLE.PAGINATION,
+    normalize: normalizePaginationOptions,
+    merge: mergePaginationOptions,
+  },
+];
+
+
+
+export class WorkflowContextOptions {
+
+  constructor() {
+    this._events = new EventEmitter({ target: this });
+    this._globals = {};
+  }
+
+  _notify(name) {
+    this._events.emit(name);
+    this._events.emit('_update', name);
+  }
+
+}
+
+export class WorkflowOptions {
+
+  constructor(context = {}, defaults = {}) {
+    this._events = new EventEmitter({ target: this });
+    this._defaults = defaults; // TODO: we should call normalize() on defaults
+    this._context = context || {};
+    this._locals = {};
+
+    defineValues(this, {
+      resolved: new ResolvedWorkflowOptions(this),
+      defaults,
+    });
+
+    if (context && context.on) {
+      this._unsubscribes = [
+        context.on('_update', name => this._notify(name)),
+      ];
+    }
+  }
+
+  _notify(name) {
+    this.resolved._invalidate(name);
+    this._events.emit(name);
+  }
+
+  _destroy() {
+    for (const unsubscribe of this._unsubscribes || []) {
+      unsubscribe();
+    }
+    this._unsubscribes = [];
+  }
+
+}
+
+class ResolvedWorkflowOptions {
+
+  constructor(options) {
+    this._options = options;
+    this._cache = {};
+  }
+
+  _invalidate(key) {
+    this._cache[key] = undefined;
+  }
+
+  _get({ key, merge }) {
+    if (this._cache[key] === undefined) {
+      const options = this._options;
+      const contextFeature = options._context[key];
+      this._cache[key] = merge(options._defaults[key], contextFeature && contextFeature.get(), options._locals[key]);
+    }
+    return this._cache[key];
+  }
+
+}
+
+class WorkflowConfigurableFeature {
+
+  constructor(options, store, key, normalize, merge) {
+    this._options = options;
+    this._store = store;
+    this._key = key;
+    this._normalize = value => value !== undefined ? normalize(value) : undefined;
+    this._merge = merge;
+  }
+
+  get() {
+    return this._store[this._key];
+  }
+
+  set(value) {
+    this._set(this._normalize(value));
+  }
+
+  merge(value) {
+    this._set(this._merge(this.get(), this._normalize(value)));
+  }
+
+  _set(value) {
+    this._store[this._key] = value;
+    this._options._notify(this._key);
+  }
+
+}
+
+for (const feature of FEATURES) {
+  const { key, normalize, merge } = feature;
+  Object.defineProperty(WorkflowContextOptions.prototype, key, {
+    get: function() {
+      const _key = `_${key}`;
+      return this[_key] || (this[_key] = new WorkflowConfigurableFeature(this, this._globals, key, normalize, merge));
+    },
+  });
+  Object.defineProperty(WorkflowOptions.prototype, key, {
+    get: function() {
+      const _key = `_${key}`;
+      return this[_key] || (this[_key] = new WorkflowConfigurableFeature(this, this._locals, key, normalize, merge));
+    },
+  });
+  Object.defineProperty(ResolvedWorkflowOptions.prototype, key, {
+    get: function() {
+      return this._get(feature);
+    },
+  });
+}

package/src/workflow/options/pagination.js

@@ -0,0 +1,18 @@
+import { mergeOptions } from './utils.js';
+
+export function normalizePaginationOptions(options) {
+  if (options === undefined) {
+    throw new Error(`Expect pagination options to be an object or a boolean value: ${options}`);
+  }
+  if (typeof options === 'boolean') {
+    options = { active: options };
+  }
+  return options;
+}
+
+export function mergePaginationOptions(...optionsList) {
+  if (optionsList[optionsList.length - 1] === false) {
+    return false;
+  }
+  return mergeOptions(optionsList, (merged, options) => Object.assign(merged, options));
+}

package/src/workflow/options/roles.js

@@ -0,0 +1,12 @@
+export function mergeRolesOptions(base, overrides) {
+  return Object.freeze({
+    ...base,
+    ...overrides,
+    members: mergeRolesMembers(base.members, overrides.members),
+    mappings: Object.freeze({ ...base.mappings, ...overrides.mappings }),
+  });
+}
+
+function mergeRolesMembers(base = [], overrides = []) {
+  return [...new Set([...base, ...overrides])];
+}