swell-js 4.0.0-next.0 → 4.0.1

package/LICENSE

@@ -1,4 +1,6 @@
-Copyright 2019 Schema Technologies, LLC
+MIT License
+
+Copyright (c) 2022 Swell Commerce Corp.
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/README.md

@@ -9,7 +9,7 @@ Universal JavaScript client for Swell's Frontend API, providing client-safe acce
 - Resolve linked content to dynamically generate page URLs
 - Format prices in the store's currency
 
-> This SDK implements a subset of operations available in Swell's [Backend API](https://swell.store/docs/api) and is authorized with a public key + session token, making it safe to use in any context. You should only use the Backend API server-side, and keep your secret keys stored as environment variables.
+> This SDK implements a subset of operations available in Swell's [Backend API](https://developers.swell.is/backend-api/) and is authorized with a public key + session token, making it safe to use in any context. You should only use the Backend API server-side, and keep your secret keys stored as environment variables.
 
 **About Swell**
 
@@ -17,4 +17,4 @@ Universal JavaScript client for Swell's Frontend API, providing client-safe acce
 
 ## Documentation
 
-📖  [**View Swell.js Documentation**](https://swell.store/docs/js/)
+📖 [**View Swell.js Documentation**](https://developers.swell.is/frontend-api/)

package/dist/account.mjs

@@ -0,0 +1,100 @@
+function methods(request) {
+  return {
+    state: null,
+
+    async requestStateChange(method, url, id, data) {
+      const result = await request(method, url, id, data);
+      if (result && result.errors) {
+        return result;
+      }
+      return (this.state = result);
+    },
+
+    get(query) {
+      return this.requestStateChange('get', '/account', query);
+    },
+
+    create(data) {
+      return this.requestStateChange('post', '/account', data);
+    },
+
+    update(data) {
+      return this.requestStateChange('put', '/account', data);
+    },
+
+    login(email, password) {
+      if (password && password.password_token) {
+        return this.requestStateChange('post', '/account/login', {
+          email,
+          password_token: password.password_token,
+        });
+      }
+      return this.requestStateChange('post', '/account/login', {
+        email,
+        password,
+      });
+    },
+
+    logout() {
+      this.state = null;
+      return request('post', '/account/logout');
+    },
+
+    recover(data) {
+      return request('post', '/account/recover', data);
+    },
+
+    listAddresses(query) {
+      return request('get', '/account/addresses', query);
+    },
+
+    createAddress(data) {
+      return request('post', '/account/addresses', data);
+    },
+
+    updateAddress(id, data) {
+      return request('put', `/account/addresses/${id}`, data);
+    },
+
+    deleteAddress(id) {
+      return request('delete', `/account/addresses/${id}`);
+    },
+
+    listCards(query) {
+      return request('get', '/account/cards', query);
+    },
+
+    createCard(data) {
+      return request('post', '/account/cards', data);
+    },
+
+    updateCard(id, data) {
+      return request('put', `/account/cards/${id}`, data);
+    },
+
+    deleteCard(id) {
+      return request('delete', `/account/cards/${id}`);
+    },
+
+    listOrders(query) {
+      return request('get', `/account/orders`, query);
+    },
+
+    getOrder(id) {
+      return request('get', `/account/orders/${id}`);
+    },
+
+    // Deprecated methods
+    getAddresses(query) {
+      return request('get', '/account/addresses', query);
+    },
+    getCards(query) {
+      return request('get', '/account/cards', query);
+    },
+    getOrders(query) {
+      return request('get', `/account/orders`, query);
+    },
+  };
+}
+
+export { methods as default };

package/dist/api.mjs

@@ -0,0 +1,327 @@
+import cardApi from './card.mjs';
+import { getCookie, setCookie } from './cookie.mjs';
+import cacheApi from './cache.mjs';
+import methods$3 from './cart.mjs';
+import methods$4 from './account.mjs';
+import methods$5 from './products.mjs';
+import methods$6 from './categories.mjs';
+import methods$7 from './attributes.mjs';
+import methods$8 from './subscriptions.mjs';
+import { d as defaultMethods, z as trimEnd, A as utils, B as trimStart, C as trimBoth, t as toSnake, D as stringifyQuery, E as base64Encode, a as toCamel, F as setOptions } from './index.78b6af02.mjs';
+import methods$9 from './content.mjs';
+import methods$a from './settings.mjs';
+import PaymentController from './payment.mjs';
+import methods$b from './locale.mjs';
+import methods$c from './currency.mjs';
+import 'qs';
+import './find.fd7de00e.mjs';
+import './round.a606b844.mjs';
+import 'deepmerge';
+import 'fast-case';
+
+function methods$2(request) {
+  const { get, list } = defaultMethods(request, '/invoices', ['list', 'get']);
+  return {
+    get: (id, ...args) => {
+      return cacheApi.getFetch('invoices', id, () => get(id, ...args));
+    },
+
+    list,
+  };
+}
+
+function methods$1(request, opt) {
+  return {
+    /**
+     * Get the decoded session as an object of session values
+     */
+    get() {
+      return request('get', '/session');
+    },
+
+    /**
+     * Get the encoded session cookie
+     * This simplifies storing or passing the session to another system
+     */
+    getCookie() {
+      return opt.getCookie('swell-session');
+    },
+
+    /**
+     * Set the encoded session cookie
+     * This simplifies restoring the session from another system
+     */
+    setCookie(value) {
+      opt.setCookie('swell-session', value);
+    },
+  };
+}
+
+function methods(request, _opt) {
+  return {
+    /**
+     * Make a request to an app function and greceiveet a response
+     * @param {string} method
+     * @param {string} appId
+     * @param {string} functionName
+     * @param {any} data
+     * @param {object?} options
+     * @returns {any}
+     */
+    request(method, appId, functionName, data, options = undefined) {
+      return request(method, functionName, undefined, data, {
+        ...options,
+        path: `/functions/${appId}`,
+        useCamelCase: false, // avoid mutating data
+      });
+    },
+
+    /**
+     * Helper to make a GET request to an app function and receive a response
+     * @param {string} appId
+     * @param {string} functionName
+     * @param {any} data
+     * @param {object?} options
+     * @returns {any}
+     */
+    get(appId, functionName, data, options = undefined) {
+      return this.request('get', appId, functionName, data, options);
+    },
+
+    /**
+     * Helper to make a PUT request to an app function and receive a response
+     * @param {string} appId
+     * @param {string} functionName
+     * @param {any} data
+     * @param {object?} options
+     * @returns {any}
+     */
+    put(appId, functionName, data, options = undefined) {
+      return this.request('put', appId, functionName, data, options);
+    },
+
+    /**
+     * Helper to make a POST request to an app function and receive a response
+     * @param {string} appId
+     * @param {string} functionName
+     * @param {any} data
+     * @param {object?} options
+     * @returns {any}
+     */
+    post(appId, functionName, data, options = undefined) {
+      return this.request('post', appId, functionName, data, options);
+    },
+
+    /**
+     * Helper to make a DELETE request to an app function and receive a response
+     * @param {string} appId
+     * @param {string} functionName
+     * @param {any} data
+     * @param {object?} options
+     * @returns {any}
+     */
+    delete(appId, functionName, data, options = undefined) {
+      return this.request('delete', appId, functionName, data, options);
+    },
+  };
+}
+
+const options = {
+  store: null,
+  key: null,
+  url: null,
+  useCamelCase: null,
+  previewContent: null,
+};
+
+const api = {
+  version: '4.0.1',
+  options,
+  request,
+
+  init(store, key, opt = {}) {
+    options.key = key;
+    options.store = store;
+    options.url = opt.url
+      ? trimEnd(opt.url)
+      : `https://${store}.swell.store`;
+    options.vaultUrl = opt.vaultUrl
+      ? trimEnd(opt.vaultUrl)
+      : `https://vault.schema.io`;
+    options.timeout = (opt.timeout && parseInt(opt.timeout, 10)) || 20000;
+    options.useCamelCase = opt.useCamelCase || false;
+    options.previewContent = opt.previewContent || false;
+    options.session = opt.session;
+    options.locale = opt.locale;
+    options.currency = opt.currency;
+    options.api = api;
+    options.getCookie = opt.getCookie || getCookie;
+    options.setCookie = opt.setCookie || setCookie;
+    options.getCart = opt.getCart;
+    options.updateCart = opt.updateCart;
+    setOptions(options);
+  },
+
+  // Backward compatibility
+  auth(...args) {
+    return this.init(...args);
+  },
+
+  get(url, query) {
+    return request('get', url, query);
+  },
+
+  put(url, data) {
+    return request('put', url, data);
+  },
+
+  post(url, data) {
+    return request('post', url, data);
+  },
+
+  delete(url, data) {
+    return request('delete', url, data);
+  },
+
+  cache: cacheApi,
+
+  card: cardApi,
+
+  cart: methods$3(request, options),
+
+  account: methods$4(request),
+
+  products: methods$5(request, options),
+
+  categories: methods$6(request),
+
+  attributes: methods$7(request),
+
+  subscriptions: methods$8(request),
+
+  invoices: methods$2(request),
+
+  content: methods$9(request, options),
+
+  settings: methods$a(request, options),
+
+  payment: new PaymentController(request, options),
+
+  locale: methods$b(request, options),
+
+  currency: methods$c(request, options),
+
+  session: methods$1(request, options),
+
+  functions: methods(request),
+
+  utils,
+};
+
+async function request(
+  method,
+  url,
+  id = undefined,
+  data = undefined,
+  opt = undefined,
+) {
+  const allOptions = {
+    ...options,
+    ...opt,
+  };
+
+  const session = allOptions.session || allOptions.getCookie('swell-session');
+  const locale = allOptions.locale || allOptions.getCookie('swell-locale');
+  const currency =
+    allOptions.currency || allOptions.getCookie('swell-currency');
+  const path = allOptions.path || '/api';
+
+  const baseUrl = `${allOptions.url}${allOptions.base || ''}${path}`;
+  const reqMethod = String(method).toLowerCase();
+
+  let reqUrl = url;
+  let reqData = id;
+
+  if (data !== undefined || typeof id === 'string') {
+    reqUrl = [trimEnd(url), trimStart(id)].join('/');
+    reqData = data;
+  }
+
+  reqUrl = allOptions.fullUrl || `${baseUrl}/${trimBoth(reqUrl)}`;
+  reqData = allOptions.useCamelCase ? toSnake(reqData) : reqData;
+
+  let reqBody;
+  if (reqMethod === 'get') {
+    let exQuery;
+    [reqUrl, exQuery] = reqUrl.split('?');
+    const fullQuery = [exQuery, stringifyQuery(reqData)]
+      .join('&')
+      .replace(/^&/, '');
+    reqUrl = `${reqUrl}${fullQuery ? `?${fullQuery}` : ''}`;
+  } else {
+    reqBody = JSON.stringify(reqData);
+  }
+
+  const reqHeaders = {
+    Accept: 'application/json',
+    'Content-Type': 'application/json',
+    Authorization: `Basic ${base64Encode(String(allOptions.key))}`,
+  };
+
+  if (session) {
+    reqHeaders['X-Session'] = session;
+  }
+
+  if (locale) {
+    reqHeaders['X-Locale'] = locale;
+  }
+
+  if (currency) {
+    reqHeaders['X-Currency'] = currency;
+  }
+
+  const response = await fetch(reqUrl, {
+    method: reqMethod,
+    headers: reqHeaders,
+    body: reqBody,
+    credentials: 'include',
+    mode: 'cors',
+  });
+
+  const responseSession = response.headers.get('X-Session');
+
+  if (typeof responseSession === 'string' && session !== responseSession) {
+    allOptions.setCookie('swell-session', responseSession);
+  }
+
+  // Response could be text, json, or empty
+  let result = null;
+  try {
+    result = await response.text();
+    try {
+      result = JSON.parse(result);
+    } catch (err) {
+      // noop
+    }
+  } catch (err) {
+    // noop
+  }
+
+  if (result && result.error) {
+    const err = new Error(result.error.message || result.error);
+    err.status = response.status;
+    err.code = result.error.code;
+    err.param = result.error.param;
+    throw err;
+  } else if (!response.ok) {
+    const err = new Error(
+      'A connection error occurred while making the request',
+    );
+    err.code = 'connection_error';
+    throw err;
+  }
+
+  return allOptions.useCamelCase ? toCamel(result) : result;
+}
+
+export { api as default };

package/dist/attributes.mjs

@@ -0,0 +1,21 @@
+import { d as defaultMethods } from './index.78b6af02.mjs';
+import cacheApi from './cache.mjs';
+import 'qs';
+import './find.fd7de00e.mjs';
+import './round.a606b844.mjs';
+import 'deepmerge';
+import 'fast-case';
+
+function methods(request) {
+  const { get, list } = defaultMethods(request, '/attributes', ['list', 'get']);
+
+  return {
+    get: (id, ...args) => {
+      return cacheApi.getFetch('attributes', id, () => get(id, ...args));
+    },
+
+    list,
+  };
+}
+
+export { methods as default };

package/dist/cache.mjs

@@ -0,0 +1,170 @@
+import { s as set, m as merge, a as toCamel, h as toCamelPath, j as getOptions } from './index.78b6af02.mjs';
+import { g as get } from './find.fd7de00e.mjs';
+import 'qs';
+import './round.a606b844.mjs';
+import 'deepmerge';
+import 'fast-case';
+
+const RECORD_TIMEOUT = 5000;
+
+let VALUES = {
+  /*
+  [model]: {
+    [id]: {
+      data,
+      record,
+      recordTimer,
+      presets,
+    }
+  }
+*/
+};
+
+const cacheApi = {
+  options: {
+    enabled: true,
+    debug: false,
+  },
+
+  debug(...args) {
+    if (this.options.debug) {
+      console.log(...args);
+    }
+  },
+
+  values({ model, id }, setValues = undefined) {
+    this.debug('cache.values', ...arguments);
+    if (setValues !== undefined) {
+      for (let key in setValues) {
+        set(VALUES, `${model}.${id}.${key}`, setValues[key]);
+      }
+      return;
+    }
+    return get(VALUES, `${model}.${id}`, {});
+  },
+
+  preset(details) {
+    this.debug('cache.preset', ...arguments);
+    const { presets = [] } = this.values(details);
+    presets.push(details);
+    this.values(details, { presets });
+  },
+
+  set(details) {
+    this.debug('cache.set', ...arguments);
+    let { model, id, path, value } = details;
+    let { data = {}, record, presets } = this.values(details);
+
+    if (id === null) {
+      return;
+    }
+
+    if (record === undefined) {
+      return this.preset(details);
+    }
+
+    data = merge(record || {}, data);
+
+    const { useCamelCase } = getOptions();
+    if (useCamelCase && value && typeof value === 'object') {
+      value = toCamel(value);
+    }
+
+    if (path || value instanceof Array) {
+      let upData = { ...(data || {}) };
+      let upPath = useCamelCase ? toCamelPath(path) : path;
+      set(upData, upPath || '', value);
+      data = upData;
+    } else if (value && typeof value === 'object') {
+      data = data || {};
+      data = merge(data, value);
+    } else {
+      data = value;
+    }
+
+    this.values(details, { data });
+
+    try {
+      // Make sure values have clean refs
+      const cache = VALUES[model][id];
+      if (cache !== undefined) {
+        if (cache.data !== undefined) {
+          cache.data = JSON.parse(JSON.stringify(cache.data));
+        }
+        if (cache.record !== undefined) {
+          cache.record = JSON.parse(JSON.stringify(cache.record));
+        }
+      }
+    } catch (err) {
+      // noop
+    }
+  },
+
+  get(model, id) {
+    this.debug('cache.get', ...arguments);
+    const { data, recordTimer } = this.values({ model, id });
+    this.debug('cache.get:data+recordTimer', ...arguments);
+    if (recordTimer) {
+      return data;
+    }
+  },
+
+  setRecord(record, details) {
+    this.debug('cache.setRecord', ...arguments);
+    let { recordTimer, presets } = this.values(details);
+
+    if (recordTimer) {
+      clearTimeout(recordTimer);
+    }
+
+    recordTimer = setTimeout(() => {
+      this.values(details, { record: undefined, recordTimer: undefined });
+    }, RECORD_TIMEOUT);
+
+    // Record has to be null at minimum, not undefined
+    this.values(details, {
+      record: record !== undefined ? record : null,
+      recordTimer,
+    });
+
+    if (presets) {
+      for (let preset of presets) {
+        this.set(preset);
+      }
+      this.values(details, { presets: undefined });
+    }
+
+    const result = this.get(details.model, details.id);
+
+    return result !== undefined ? result : record;
+  },
+
+  async getFetch(model, id, fetch) {
+    if (this.options.enabled) {
+      this.debug('cache.getFetch', ...arguments);
+      const value = this.get(model, id);
+
+      if (value !== undefined) {
+        return value;
+      }
+    }
+
+    const record = await fetch();
+    return this.setRecord(record, { model, id });
+  },
+
+  clear(model = undefined, id = undefined) {
+    this.debug('cache.clear', ...arguments);
+    if (model) {
+      if (id) {
+        set(VALUES, `${model}.${id}`, undefined);
+      } else {
+        set(VALUES, model, undefined);
+      }
+    } else {
+      VALUES = {};
+    }
+  },
+};
+
+export { cacheApi as default };