@miso.ai/client-sdk-core 1.8.0-beta.16 → 1.8.0-beta.18

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({
       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,7 @@
+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';

package/src/api/interactions.js

@@ -0,0 +1,54 @@
+import ApiBase from './base.js';
+
+export default class Interactions extends ApiBase {
+
+  constructor(api) {
+    super(api, 'interactions');
+  }
+
+  async upload(payload, options) {
+    try {
+      return await this._run('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 === '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/{dist/es → src}/api/recommendation.js

@@ -1,24 +1,33 @@
-import ApiBase from './base';
+import ApiBase from './base.js';
+
 export default class Recommendation extends ApiBase {
+
   constructor(api) {
     super(api, 'recommendation');
   }
+
   async userToProducts(payload, options) {
     return this._run('user_to_products', payload, options);
   }
+
   async userToCategories(payload, options) {
     return this._run('user_to_categories', payload, options);
   }
+
   async userToAttributes(payload, options) {
     return this._run('user_to_attributes', payload, options);
   }
+
   async userToTrending(payload, options) {
     return this._run('user_to_trending', payload, options);
   }
+
   async userToHistory(payload, options) {
     return this._run('user_to_history', payload, options);
   }
+
   async productToProducts(payload, options) {
     return this._run('product_to_products', payload, options);
   }
-}
+
+}

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

@@ -1,15 +1,21 @@
-import ApiBase from './base';
+import ApiBase from './base.js';
+
 export default class Search extends ApiBase {
+
   constructor(api) {
     super(api, 'search');
   }
+
   async search(payload, options) {
     return this._run('search', payload, options);
   }
+
   async autocomplete(payload, options) {
     return this._run('autocomplete', payload, options);
   }
+
   async multipleGet(payload, options) {
     return this._run('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/{dist/es → src}/constants.js

@@ -1,4 +1,4 @@
 export const API = {
   DATA_ENDPOINT: 'https://api-edge.askmiso.com/v1',
-  EVENT_ENDPOINT: 'https://api.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,3 @@
+export { default as version } from './version.js';
+export { default as MisoClient } from './client.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 });
   }
-}
+
+}

package/{dist/es → src}/plugin/auto-events.js

@@ -1,30 +1,31 @@
 import { Component } from '@miso.ai/commons';
+
 const PLUGIN_ID = 'std:auto-events';
+
 export default class AutoEventsPlugin extends Component {
+
   static get id() {
     return PLUGIN_ID;
   }
+
   constructor() {
     super('auto-events');
     this._contexts = new WeakMap();
   }
+
   install(MisoClient, context) {
     context.addSubtree(this);
     MisoClient.on('create', this._injectClient.bind(this));
     context.addPayloadPass(this._captureApiRequest.bind(this));
   }
+
   _injectClient(client) {
     const context = new AutoEventsContext(this);
     this._contexts.set(client, context);
     client.autoEvents = context.interface;
   }
-  _captureApiRequest(_ref) {
-    let {
-      client,
-      apiGroup,
-      apiName,
-      payload
-    } = _ref;
+
+  _captureApiRequest({ client, apiGroup, apiName, payload }) {
     switch (apiGroup) {
       case 'search':
         switch (apiName) {
@@ -35,10 +36,8 @@ export default class AutoEventsPlugin extends Component {
         break;
     }
   }
-  _captureSearchApiRequest(client, _ref2) {
-    let {
-      q: keywords
-    } = _ref2;
+
+  _captureSearchApiRequest(client, { q: keywords }) {
     if (!keywords || keywords === '*') {
       // might be a facet search without real keywords
       return;
@@ -49,29 +48,26 @@ export default class AutoEventsPlugin extends Component {
     }
     client.api.interactions.upload({
       type: 'search',
-      search: {
-        keywords
-      },
-      context: {
-        custom_context: {
-          channel: 'miso_api'
-        }
-      }
+      search: { keywords },
+      context: { custom_context: { channel: 'miso_api' } },
     });
   }
+
 }
+
 class AutoEventsContext {
+
   constructor(plugin) {
     this._plugin = plugin;
     this._config = {
-      search: true
+      search: true,
     };
     this.interface = Object.freeze({
-      config: this.config.bind(this)
+      config: this.config.bind(this),
     });
   }
-  config() {
-    let options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+
+  config(options = {}) {
     if (typeof options !== 'object') {
       throw new Error(`Config options must be an object or undefined: ${options}`);
     }
@@ -86,6 +82,9 @@ class AutoEventsContext {
         this._plugin._events.emit('config', `${key}: ${oldValue} -> ${newValue}`);
       }
     }
-    return Object.freeze(Object.assign({}, this._config));
+    return Object.freeze({
+      ...this._config,
+    });
   }
-}
+
+}

package/src/plugin/index.js

@@ -0,0 +1,3 @@
+export { default as UserPlugin } from './user.js';
+export { default as PageInfoPlugin } from './page-info.js';
+export { default as AutoEventsPlugin } from './auto-events.js';