@miso.ai/client-sdk-core 1.8.0-beta.9 → 1.8.1-beta.0

package/src/api/ask.js

@@ -0,0 +1,80 @@
+import { polling, signals, StallTimeoutAbortController } from '@miso.ai/commons';
+import { GROUP, NAME } from './constants.js';
+import ApiBase from './base.js';
+
+export default class Ask extends ApiBase {
+
+  constructor(api) {
+    super(api, GROUP.ASK);
+  }
+
+  async questions(payload, options = {}) {
+    if (typeof payload === 'string' && payload.charAt(0) !== '{') {
+      return new Answer(this, { question_id: payload }, options);
+    }
+    const response = await this._run(NAME.QUESTIONS, payload, options);
+    return new Answer(this, response, options);
+  }
+
+  async _questions(payload, options) {
+    return this._run(NAME.QUESTIONS, payload, options);
+  }
+
+  async _get(questionId, options) {
+    return this._run(`${NAME.QUESTIONS}/${questionId}/answer`, undefined, { ...options, method: 'GET' });
+  }
+
+  async relatedQuestions(payload, options = {}) {
+    return this._run(NAME.RELATED_QUESTIONS, payload, options);
+  }
+
+}
+
+class Answer {
+
+  constructor(api, { question_id }, options = {}) {
+    this._api = api;
+    this._questionId = question_id;
+    this._ac = new AbortController();
+    this._options = options;
+  }
+
+  get questionId() {
+    return this._questionId;
+  }
+
+  async get(options) {
+    return this._api._get(this._questionId, { ...this._options, ...options });
+  }
+
+  abort(reason) {
+    this._ac.abort(reason);
+  }
+
+  [Symbol.asyncIterator]() {
+    const fetch = async ({ signal } = {}) => {
+      // TODO: pass signal
+      const response = await this.get();
+      return [response, response.finished];
+    };
+    let { pollingInterval: interval, signal, stallTimeout = 120000, ...options } = this._options;
+    const stac = new StallTimeoutAbortController(stallTimeout);
+    signal = signals.any(this._ac.signal, stac.signal, signal);
+
+    let prevResponse;
+    const onResponse = (response, finished) => {
+      if (finished) {
+        stac.clear();
+      } else if (isUpdated(prevResponse, response)) {
+        stac.touch();
+      }
+      prevResponse = response;
+    };
+    return polling(fetch, { interval, signal, onResponse, ...options })[Symbol.asyncIterator]();
+  }
+
+}
+
+function isUpdated(prev, curr) {
+  return !prev || prev.answer_stage !== curr.answer_stage || prev.answer.length !== curr.answer.length;
+}

package/src/api/base.js

@@ -0,0 +1,47 @@
+import { Component } from '@miso.ai/commons';
+
+export default class ApiBase extends Component {
+
+  // TODO: use private fields (may encounter issues with rollup)
+
+  constructor(api, apiPath) {
+    super(apiPath, api);
+    this._apiPath = apiPath;
+    this.helpers = api.helpers;
+    this.clientOptions = api._client.options;
+    this.context = api._client.context;
+  }
+
+  async _run(apiName, payload, options = {}) {
+    const { bulk } = options;
+    const bulkInfo = bulk ? { bulk: this.helpers.bulkInfo } : undefined;
+    const apiGroup = this._apiPath;
+    const url = this._url({ apiGroup, apiName, payload, options });
+    payload = this._preprocess({ apiGroup, apiName, payload, options });
+    const requestData = { apiGroup, apiName, payload, url, options };
+    this._events.emit('request', { ...requestData, ...bulkInfo });
+    const response = await this._send(requestData);
+    const responseData = { ...requestData, response };
+    this._events.emit('response', { ...responseData, ...bulkInfo });
+    return this._postprocess(responseData);
+  }
+
+  _preprocess({ apiGroup, apiName, payload }) {
+    return this.helpers.applyPayloadPasses(this, { apiGroup, apiName, payload });
+  }
+
+  _url({ apiGroup, apiName, options }) {
+    const url = this.helpers.url([apiGroup, apiName], options);
+    return this.helpers.applyUrlPasses(this, { apiGroup, apiName, url, options });
+  }
+
+  async _send({ apiGroup, apiName, url, payload, options: { bulk, ...options } = {} }) {
+    return bulk ? this.helpers.fetchForBulk(apiGroup, apiName, payload) : this.helpers.fetch(url, payload, options);
+  }
+
+  _postprocess({ response }) {
+    // TODO: we can introduce response passes
+    return response.data;
+  }
+
+}

package/src/api/constants.js

@@ -0,0 +1,21 @@
+export const GROUP = Object.freeze({
+  ASK: 'ask',
+  SEARCH: 'search',
+  RECOMMENDATION: 'recommendation',
+  INTERACTIONS: 'interactions',
+});
+
+export const NAME = Object.freeze({
+  QUESTIONS: 'questions',
+  RELATED_QUESTIONS: 'related_questions',
+  SEARCH: 'search',
+  AUTOCOMPLETE: 'autocomplete',
+  MGET: 'mget',
+  USER_TO_PRODUCTS: 'user_to_products',
+  USER_TO_CATEGORIES: 'user_to_categories',
+  USER_TO_ATTRIBUTES: 'user_to_attributes',
+  USER_TO_TRENDING: 'user_to_trending',
+  USER_TO_HISTORY: 'user_to_history',
+  PRODUCT_TO_PRODUCTS: 'product_to_products',
+  UPLOAD: 'upload',
+});

package/{dist/es → src}/api/helpers.js

@@ -1,41 +1,42 @@
 import { Bulk, trimObj } from '@miso.ai/commons';
-import { API } from '../constants';
+import { API } from '../constants.js';
+
 export default class ApiHelpers {
+
   constructor(client, root) {
     this._client = client;
     this._root = root;
     this._bulk = new Bulk(this._runBulkFetch.bind(this), client._error.bind(client));
   }
-  async fetch(url, payload) {
-    let {
-      method = 'POST',
-      headers,
-      timeout,
-      sendApiKeyByHeader
-    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
-    const {
-      apiKey,
-      request = {}
-    } = this._client.options;
+
+  async fetch(url, payload, {
+    method = 'POST',
+    headers,
+    timeout,
+    sendApiKeyByHeader,
+  } = {}) {
+    const { apiKey, request = {} } = this._client.options;
     timeout = timeout || request.timeout;
     sendApiKeyByHeader = sendApiKeyByHeader || request.sendApiKeyByHeader;
+
     if (sendApiKeyByHeader) {
-      headers = Object.assign({}, headers, {
-        'X-API-KEY': apiKey
-      });
+      headers = { ...headers, 'X-API-KEY': apiKey };
     }
     // TODO: external abort signal
     // TODO: organize arguments
     const body = method !== 'GET' && payload != undefined ? JSON.stringify(payload) : undefined;
+
     const signal = timeout ? AbortSignal.timeout(timeout) : undefined;
-    const res = await window.fetch(url, trimObj({
+
+    const res = await (this._root._customFetch || window.fetch)(url, trimObj({
       method,
       headers,
       body,
       cache: 'no-cache',
       mode: 'cors',
-      signal
+      signal,
     }));
+
     const resBody = await res.json();
     if (res.status >= 400 || resBody.errors) {
       var err = new Error(resBody.message);
@@ -45,66 +46,40 @@ export default class ApiHelpers {
     }
     return resBody;
   }
+
   get bulkInfo() {
     return this._bulk.info;
   }
-  async fetchForBulk(apiGroup, apiName, payload) {
-    let {
-      method
-    } = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : {};
+
+  async fetchForBulk(apiGroup, apiName, payload, { method } = {}) {
     if (method && method !== 'POST') {
       throw new Error(`Non-POST API is not supported in bulk mode: ${url}`);
     }
-    return this._bulk.run({
-      apiGroup,
-      apiName,
-      payload
-    });
+    return this._bulk.run({ apiGroup, apiName, payload });
   }
+
   async _runBulkFetch(requests) {
     // TODO: request options?
     const url = this.url(['bulk']);
     const payload = {
-      requests: requests.map(_ref => {
-        let {
-          action: {
-            apiGroup,
-            apiName,
-            payload
-          }
-        } = _ref;
-        return {
-          api_name: `${apiGroup}/${apiName}`,
-          body: payload
-        };
-      })
+      requests: requests.map(({ action: { apiGroup, apiName, payload } }) => ({
+        api_name: `${apiGroup}/${apiName}`,
+        body: payload,
+      })),
     };
-    const {
-      data: responses
-    } = await this.fetch(url, payload);
+    const { data: responses } = await this.fetch(url, payload);
     for (let i = 0, len = requests.length; i < len; i++) {
-      const {
-        resolution
-      } = requests[i];
-      const {
-        error,
-        status_code,
-        body
-      } = responses[i];
+      const { resolution } = requests[i];
+      const { error, status_code, body } = responses[i];
       if (status_code >= 400 || error) {
-        resolution.reject({
-          status_code,
-          body
-        });
+        resolution.reject({ status_code, body });
       } else {
         resolution.resolve(body);
       }
     }
   }
-  sendBeacon(url, payload) {
-    let {
-      method
-    } = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+
+  sendBeacon(url, payload, { method } = {}) {
     if (method && method !== 'POST') {
       throw new Error(`Non-POST API is not supported in useBeacon mode: ${url}`);
     }
@@ -112,64 +87,45 @@ export default class ApiHelpers {
       throw new Error(`Send beacon unsuccessful: ${url}`);
     }
   }
-  url(paths) {
-    let options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
-    const {
-      apiKey,
-      request = {}
-    } = this._client.options;
+
+  url(paths, options = {}) {
+    const { apiKey, request = {} } = this._client.options;
     const sendApiKeyByHeader = options.sendApiKeyByHeader || request.sendApiKeyByHeader;
     const apiName = paths.filter(s => s).join('/');
     const url = `${this.getApiEndpoint(apiName)}/${apiName}`;
     return sendApiKeyByHeader ? url : `${url}?api_key=${window.encodeURIComponent(apiKey)}`;
   }
+
   getApiEndpoint(apiName) {
     const {
       dataEndpoint = API.DATA_ENDPOINT,
-      eventEndpoint = API.EVENT_ENDPOINT
+      eventEndpoint = API.EVENT_ENDPOINT,
     } = this._client.options;
     return apiName === 'interactions' ? eventEndpoint : dataEndpoint;
   }
-  applyUrlPasses(component, _ref2) {
-    let {
-      apiGroup,
-      apiName,
-      url
-    } = _ref2;
+
+  applyUrlPasses(component, { apiGroup, apiName, url }) {
     const client = this._client;
     for (const pass of this._root._urlPasses) {
       try {
-        url = pass({
-          client,
-          apiGroup,
-          apiName,
-          url
-        }) || url;
-      } catch (e) {
+        url = pass({ client, apiGroup, apiName, url }) || url;
+      } catch(e) {
         component.error(e);
       }
     }
     return url;
   }
-  applyPayloadPasses(component, _ref3) {
-    let {
-      apiGroup,
-      apiName,
-      payload
-    } = _ref3;
+
+  applyPayloadPasses(component, { apiGroup, apiName, payload }) {
     const client = this._client;
     for (const pass of this._root._payloadPasses) {
       try {
-        payload = pass({
-          client,
-          apiGroup,
-          apiName,
-          payload
-        }) || payload;
-      } catch (e) {
+        payload = pass({ client, apiGroup, apiName, payload }) || payload;
+      } catch(e) {
         component.error(e);
       }
     }
     return payload;
   }
-}
+
+}

package/src/api/index.js

@@ -0,0 +1,8 @@
+export { default as Api } from './api.js';
+export { default as ApiBase } from './base.js';
+export { default as ApiHelpers } from './helpers.js';
+export { default as Interactions } from './interactions.js';
+export { default as Ask } from './ask.js';
+export { default as Search } from './search.js';
+export { default as Recommendation } from './recommendation.js';
+export * as constants from './constants.js';

package/src/api/interactions.js

@@ -0,0 +1,55 @@
+import { GROUP, NAME } from './constants.js';
+import ApiBase from './base.js';
+
+export default class Interactions extends ApiBase {
+
+  constructor(api) {
+    super(api, GROUP.INTERACTIONS);
+  }
+
+  async upload(payload, options) {
+    try {
+      return await this._run(NAME.UPLOAD, payload, options);
+    } catch (e) {
+      if (e.status === 400 && e.message && e.message.toLowerCase().indexOf('playground') > -1) {
+        this._warn(`Ignore interactions uploaded to playground app.`);
+      } else {
+        throw e;
+      }
+    }
+  }
+
+  _url({ apiGroup, apiName, options }) {
+    const url = this.helpers.url([this._apiPath], options);
+    return this.helpers.applyUrlPasses(this, { apiGroup, apiName, url, options });
+  }
+
+  _preprocess({ apiGroup, apiName, payload }) {
+    if (apiName === NAME.UPLOAD) {
+      payload = this._normalizeUploadPayload(payload);
+    }
+    return super._preprocess({ apiGroup, apiName, payload });
+  }
+
+  _normalizeUploadPayload(payload) {
+    // TODO: accept string as a shortcut of { type: payload } as well
+    if (typeof payload !== 'object') {
+      throw new Error(`Interactions payload has to be either an object or an array of objects: ${payload}`);
+    }
+    if (!Array.isArray(payload)) {
+      payload = [payload];
+    }
+    return { data: payload };
+  }
+
+  async _send({ options: { useBeacon = true, ...options } = {}, ...args }) {
+    if (useBeacon) {
+      const { url, payload } = args;
+      this.helpers.sendBeacon(url, payload, options);
+      return {};
+    } else {
+      return super._send({ ...args, options });
+    }
+  }
+
+}

package/src/api/recommendation.js

@@ -0,0 +1,34 @@
+import { GROUP, NAME } from './constants.js';
+import ApiBase from './base.js';
+
+export default class Recommendation extends ApiBase {
+
+  constructor(api) {
+    super(api, GROUP.RECOMMENDATION);
+  }
+
+  async userToProducts(payload, options) {
+    return this._run(NAME.USER_TO_PRODUCTS, payload, options);
+  }
+
+  async userToCategories(payload, options) {
+    return this._run(NAME.USER_TO_CATEGORIES, payload, options);
+  }
+
+  async userToAttributes(payload, options) {
+    return this._run(NAME.USER_TO_ATTRIBUTES, payload, options);
+  }
+
+  async userToTrending(payload, options) {
+    return this._run(NAME.USER_TO_TRENDING, payload, options);
+  }
+
+  async userToHistory(payload, options) {
+    return this._run(NAME.USER_TO_HISTORY, payload, options);
+  }
+
+  async productToProducts(payload, options) {
+    return this._run(NAME.PRODUCT_TO_PRODUCTS, payload, options);
+  }
+
+}

package/src/api/search.js

@@ -0,0 +1,22 @@
+import { GROUP, NAME } from './constants.js';
+import ApiBase from './base.js';
+
+export default class Search extends ApiBase {
+
+  constructor(api) {
+    super(api, GROUP.SEARCH);
+  }
+
+  async search(payload, options) {
+    return this._run(NAME.SEARCH, payload, options);
+  }
+
+  async autocomplete(payload, options) {
+    return this._run(NAME.AUTOCOMPLETE, payload, options);
+  }
+
+  async multipleGet(payload, options) {
+    return this._run(NAME.MGET, payload, options);
+  }
+
+}

package/src/classes.js

@@ -0,0 +1,7 @@
+import * as api from './api/index.js';
+import Context from './context.js';
+
+export default {
+  api,
+  context: { Context },
+}

package/{dist/es → src}/client.js

@@ -1,9 +1,11 @@
 import { trimObj, Component, uuidv4, defineValues } from '@miso.ai/commons';
 import { root, register, init } from './root';
-import Api from './api';
+import { Api } from './api/index.js';
 import Context from './context';
 import * as helpers from './utils';
+
 class MisoClient extends Component {
+
   static attach() {
     (window.MisoClients || (window.MisoClients = [])).push(MisoClient);
     if (window.MisoClient) {
@@ -15,48 +17,61 @@ class MisoClient extends Component {
     }
     window.MisoClient = MisoClient;
   }
+
   constructor(options) {
     super('client', root);
     this._config(options);
+
     this.context = new Context(this);
     this.api = new Api(this, root);
+
     register(this);
   }
+
   get version() {
     return MisoClient.version;
   }
+
   _config(options) {
     this.options = Object.freeze(this._normalizeOptions(options));
   }
-  _normalizeOptions() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  _normalizeOptions(options = {}) {
     if (typeof options === 'string') {
-      options = {
-        apiKey: options
-      };
+      options = { apiKey: options };
     }
     if (options.readConfigFromScriptUrl) {
-      options = Object.assign({}, this._readConfigFromScriptUrl(), options);
+      options = {
+        ...this._readConfigFromScriptUrl(),
+        ...options,
+      };
     }
     if (!options.apiKey) {
       throw new Error('Require API key to initialize miso client.');
     }
+
     options.dataEndpoint = options.dataEndpoint || options.apiHost;
     options.eventEndpoint = options.eventEndpoint || options.apiHost;
     delete options.apiHost;
+
     return trimObj(options);
   }
+
   _readConfigFromScriptUrl() {
     const me = document.currentScript;
     const url = me.src || me.href; // might be <link> as well
     const params = new URL(new Request(url).url).searchParams;
     return trimObj({
-      apiKey: params.get('api_key') || undefined
+      apiKey: params.get('api_key') || undefined,
     });
   }
+
 }
+
 MisoClient.helpers = helpers;
+
 defineValues(MisoClient, {
-  uuid: uuidv4()
+  uuid: uuidv4(),
 });
-export default init(MisoClient);
+
+export default init(MisoClient);

package/{dist/es → src}/cmd.js

@@ -5,22 +5,21 @@ function execute(onError, fn) {
     onError(e);
   }
 }
-export default function (key) {
-  let onError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : e => console.error(e);
+
+export default function(key, onError = e => console.error(e)) {
   const cmds = window[key] || (window[key] = []);
   if (cmds._processed) {
     return;
   }
   cmds._processed = true;
-  const exec = fn => execute(onError, fn);
 
+  const exec = fn => execute(onError, fn);
+  
   // overrides push function so future commands are executed immediately
-  Object.defineProperty(cmds, 'push', {
-    value: exec
-  });
-
+  Object.defineProperty(cmds, 'push', { value: exec });
+  
   // process existing miso commands
   for (const fn of cmds) {
     exec(fn);
   }
-}
+}

package/src/constants.js

@@ -0,0 +1,4 @@
+export const API = Object.freeze({
+  DATA_ENDPOINT: 'https://api-edge.askmiso.com/v1',
+  EVENT_ENDPOINT: 'https://api.askmiso.com/v1',
+});

package/{dist/es → src}/context.js

@@ -1,7 +1,10 @@
 import { Component } from '@miso.ai/commons';
+
 export default class Context extends Component {
+
   constructor(client) {
     super('context', client);
     this._client = client;
   }
-}
+
+}

package/src/index.js

@@ -0,0 +1,4 @@
+export { default as version } from './version.js';
+export { default as MisoClient } from './client.js';
+export { constants as API } from './api/index.js';
+export * from './plugin/index.js';

package/{dist/es → src}/plugin/anonymous.js

@@ -1,8 +1,9 @@
 import { defineValues } from '@miso.ai/commons';
+
 export default class AnonymousPlugin {
+
   constructor(install) {
-    defineValues(this, {
-      install
-    });
+    defineValues(this, { install });
   }
-}
+
+}