swell-js 4.0.0 → 4.0.1

package/dist/account.mjs

@@ -1 +1,100 @@
-export { m as default } from './account.d991b136.mjs';
+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

@@ -1,21 +1,327 @@
-export { a as default } from './api.1e92f86d.mjs';
-import './card.982ad378.mjs';
-import './index.b29eadc6.mjs';
+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 './_baseClone.c22e5907.mjs';
-import './round.10a34c5f.mjs';
+import './find.fd7de00e.mjs';
+import './round.a606b844.mjs';
 import 'deepmerge';
 import 'fast-case';
-import './cookie.40ff798c.mjs';
-import './cache.70033487.mjs';
-import './cart.dd00d6d6.mjs';
-import './products.c20a4350.mjs';
-import './attributes.b332bfad.mjs';
-import './account.d991b136.mjs';
-import './categories.f6027058.mjs';
-import './subscriptions.fd44cccc.mjs';
-import './content.5b4bea62.mjs';
-import './settings.6c0d2563.mjs';
-import './index.a60f77a7.mjs';
-import './locale.9d7241ac.mjs';
-import './currency.e2cd8985.mjs';
+
+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

@@ -1,8 +1,21 @@
-export { m as default } from './attributes.b332bfad.mjs';
-import './index.b29eadc6.mjs';
+import { d as defaultMethods } from './index.78b6af02.mjs';
+import cacheApi from './cache.mjs';
 import 'qs';
-import './_baseClone.c22e5907.mjs';
-import './round.10a34c5f.mjs';
+import './find.fd7de00e.mjs';
+import './round.a606b844.mjs';
 import 'deepmerge';
 import 'fast-case';
-import './cache.70033487.mjs';
+
+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

@@ -1,7 +1,170 @@
-export { c as default } from './cache.70033487.mjs';
-import './index.b29eadc6.mjs';
+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 './_baseClone.c22e5907.mjs';
-import './round.10a34c5f.mjs';
+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 };