@nhost/nhost-js 0.3.5 → 0.3.9

package/dist/index.es.js

@@ -0,0 +1,1293 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+const axios$3 = require("axios");
+const SERVER_ERROR_CODE = 500;
+class HasuraAuthApi {
+  constructor({ url = "" }) {
+    this.url = url;
+    this.httpClient = axios$3.create({
+      baseURL: this.url
+    });
+    this.httpClient.interceptors.response.use((response) => response, (error) => {
+      var _a, _b, _c, _d, _e, _f;
+      return Promise.reject({
+        message: (_d = (_c = (_b = (_a = error.response) == null ? void 0 : _a.data) == null ? void 0 : _b.message) != null ? _c : error.message) != null ? _d : JSON.stringify(error),
+        status: (_f = (_e = error.response) == null ? void 0 : _e.status) != null ? _f : SERVER_ERROR_CODE
+      });
+    });
+  }
+  async signUpEmailPassword(params) {
+    try {
+      const res = await this.httpClient.post("/signup/email-password", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signInEmailPassword(params) {
+    try {
+      const res = await this.httpClient.post("/signin/email-password", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signInPasswordlessEmail(params) {
+    try {
+      const res = await this.httpClient.post("/signin/passwordless/email", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signInPasswordlessSms(params) {
+    try {
+      const res = await this.httpClient.post("/signin/passwordless/sms", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signInPasswordlessSmsOtp(params) {
+    try {
+      const res = await this.httpClient.post("/signin/passwordless/sms/otp", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  async signOut(params) {
+    try {
+      await this.httpClient.post("/signout", params);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async refreshToken(params) {
+    try {
+      const res = await this.httpClient.post("/token", params);
+      return { error: null, session: res.data };
+    } catch (error) {
+      return { error, session: null };
+    }
+  }
+  async resetPassword(params) {
+    try {
+      await this.httpClient.post("/user/password/reset", params);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async changePassword(params) {
+    try {
+      await this.httpClient.post("/user/password", params, {
+        headers: __spreadValues({}, this.generateAuthHeaders())
+      });
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async sendVerificationEmail(params) {
+    try {
+      await this.httpClient.post("/user/email/send-verification-email", params);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async changeEmail(params) {
+    try {
+      await this.httpClient.post("/user/email/change", params, {
+        headers: __spreadValues({}, this.generateAuthHeaders())
+      });
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async deanonymize(params) {
+    try {
+      await this.httpClient.post("/user/deanonymize", params);
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  async verifyEmail(params) {
+    try {
+      const res = await this.httpClient.post("/user/email/verify", params);
+      return { data: res.data, error: null };
+    } catch (error) {
+      return { data: null, error };
+    }
+  }
+  setAccessToken(accessToken) {
+    this.accessToken = accessToken;
+  }
+  generateAuthHeaders() {
+    if (!this.accessToken) {
+      return null;
+    }
+    return {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+  }
+}
+var queryString = {};
+var strictUriEncode = (str) => encodeURIComponent(str).replace(/[!'()*]/g, (x) => `%${x.charCodeAt(0).toString(16).toUpperCase()}`);
+var token = "%[a-f0-9]{2}";
+var singleMatcher = new RegExp(token, "gi");
+var multiMatcher = new RegExp("(" + token + ")+", "gi");
+function decodeComponents(components, split) {
+  try {
+    return decodeURIComponent(components.join(""));
+  } catch (err) {
+  }
+  if (components.length === 1) {
+    return components;
+  }
+  split = split || 1;
+  var left = components.slice(0, split);
+  var right = components.slice(split);
+  return Array.prototype.concat.call([], decodeComponents(left), decodeComponents(right));
+}
+function decode(input) {
+  try {
+    return decodeURIComponent(input);
+  } catch (err) {
+    var tokens = input.match(singleMatcher);
+    for (var i = 1; i < tokens.length; i++) {
+      input = decodeComponents(tokens, i).join("");
+      tokens = input.match(singleMatcher);
+    }
+    return input;
+  }
+}
+function customDecodeURIComponent(input) {
+  var replaceMap = {
+    "%FE%FF": "\uFFFD\uFFFD",
+    "%FF%FE": "\uFFFD\uFFFD"
+  };
+  var match = multiMatcher.exec(input);
+  while (match) {
+    try {
+      replaceMap[match[0]] = decodeURIComponent(match[0]);
+    } catch (err) {
+      var result = decode(match[0]);
+      if (result !== match[0]) {
+        replaceMap[match[0]] = result;
+      }
+    }
+    match = multiMatcher.exec(input);
+  }
+  replaceMap["%C2"] = "\uFFFD";
+  var entries = Object.keys(replaceMap);
+  for (var i = 0; i < entries.length; i++) {
+    var key = entries[i];
+    input = input.replace(new RegExp(key, "g"), replaceMap[key]);
+  }
+  return input;
+}
+var decodeUriComponent = function(encodedURI) {
+  if (typeof encodedURI !== "string") {
+    throw new TypeError("Expected `encodedURI` to be of type `string`, got `" + typeof encodedURI + "`");
+  }
+  try {
+    encodedURI = encodedURI.replace(/\+/g, " ");
+    return decodeURIComponent(encodedURI);
+  } catch (err) {
+    return customDecodeURIComponent(encodedURI);
+  }
+};
+var splitOnFirst = (string, separator) => {
+  if (!(typeof string === "string" && typeof separator === "string")) {
+    throw new TypeError("Expected the arguments to be of type `string`");
+  }
+  if (separator === "") {
+    return [string];
+  }
+  const separatorIndex = string.indexOf(separator);
+  if (separatorIndex === -1) {
+    return [string];
+  }
+  return [
+    string.slice(0, separatorIndex),
+    string.slice(separatorIndex + separator.length)
+  ];
+};
+var filterObj = function(obj, predicate) {
+  var ret = {};
+  var keys = Object.keys(obj);
+  var isArr = Array.isArray(predicate);
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    var val = obj[key];
+    if (isArr ? predicate.indexOf(key) !== -1 : predicate(key, val, obj)) {
+      ret[key] = val;
+    }
+  }
+  return ret;
+};
+(function(exports) {
+  const strictUriEncode$1 = strictUriEncode;
+  const decodeComponent = decodeUriComponent;
+  const splitOnFirst$1 = splitOnFirst;
+  const filterObject = filterObj;
+  const isNullOrUndefined = (value) => value === null || value === void 0;
+  const encodeFragmentIdentifier = Symbol("encodeFragmentIdentifier");
+  function encoderForArrayFormat(options) {
+    switch (options.arrayFormat) {
+      case "index":
+        return (key) => (result, value) => {
+          const index = result.length;
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode(key, options), "[", index, "]"].join("")];
+          }
+          return [
+            ...result,
+            [encode(key, options), "[", encode(index, options), "]=", encode(value, options)].join("")
+          ];
+        };
+      case "bracket":
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode(key, options), "[]"].join("")];
+          }
+          return [...result, [encode(key, options), "[]=", encode(value, options)].join("")];
+        };
+      case "colon-list-separator":
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, [encode(key, options), ":list="].join("")];
+          }
+          return [...result, [encode(key, options), ":list=", encode(value, options)].join("")];
+        };
+      case "comma":
+      case "separator":
+      case "bracket-separator": {
+        const keyValueSep = options.arrayFormat === "bracket-separator" ? "[]=" : "=";
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          value = value === null ? "" : value;
+          if (result.length === 0) {
+            return [[encode(key, options), keyValueSep, encode(value, options)].join("")];
+          }
+          return [[result, encode(value, options)].join(options.arrayFormatSeparator)];
+        };
+      }
+      default:
+        return (key) => (result, value) => {
+          if (value === void 0 || options.skipNull && value === null || options.skipEmptyString && value === "") {
+            return result;
+          }
+          if (value === null) {
+            return [...result, encode(key, options)];
+          }
+          return [...result, [encode(key, options), "=", encode(value, options)].join("")];
+        };
+    }
+  }
+  function parserForArrayFormat(options) {
+    let result;
+    switch (options.arrayFormat) {
+      case "index":
+        return (key, value, accumulator) => {
+          result = /\[(\d*)\]$/.exec(key);
+          key = key.replace(/\[\d*\]$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = {};
+          }
+          accumulator[key][result[1]] = value;
+        };
+      case "bracket":
+        return (key, value, accumulator) => {
+          result = /(\[\])$/.exec(key);
+          key = key.replace(/\[\]$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = [value];
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+      case "colon-list-separator":
+        return (key, value, accumulator) => {
+          result = /(:list)$/.exec(key);
+          key = key.replace(/:list$/, "");
+          if (!result) {
+            accumulator[key] = value;
+            return;
+          }
+          if (accumulator[key] === void 0) {
+            accumulator[key] = [value];
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+      case "comma":
+      case "separator":
+        return (key, value, accumulator) => {
+          const isArray = typeof value === "string" && value.includes(options.arrayFormatSeparator);
+          const isEncodedArray = typeof value === "string" && !isArray && decode2(value, options).includes(options.arrayFormatSeparator);
+          value = isEncodedArray ? decode2(value, options) : value;
+          const newValue = isArray || isEncodedArray ? value.split(options.arrayFormatSeparator).map((item) => decode2(item, options)) : value === null ? value : decode2(value, options);
+          accumulator[key] = newValue;
+        };
+      case "bracket-separator":
+        return (key, value, accumulator) => {
+          const isArray = /(\[\])$/.test(key);
+          key = key.replace(/\[\]$/, "");
+          if (!isArray) {
+            accumulator[key] = value ? decode2(value, options) : value;
+            return;
+          }
+          const arrayValue = value === null ? [] : value.split(options.arrayFormatSeparator).map((item) => decode2(item, options));
+          if (accumulator[key] === void 0) {
+            accumulator[key] = arrayValue;
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], arrayValue);
+        };
+      default:
+        return (key, value, accumulator) => {
+          if (accumulator[key] === void 0) {
+            accumulator[key] = value;
+            return;
+          }
+          accumulator[key] = [].concat(accumulator[key], value);
+        };
+    }
+  }
+  function validateArrayFormatSeparator(value) {
+    if (typeof value !== "string" || value.length !== 1) {
+      throw new TypeError("arrayFormatSeparator must be single character string");
+    }
+  }
+  function encode(value, options) {
+    if (options.encode) {
+      return options.strict ? strictUriEncode$1(value) : encodeURIComponent(value);
+    }
+    return value;
+  }
+  function decode2(value, options) {
+    if (options.decode) {
+      return decodeComponent(value);
+    }
+    return value;
+  }
+  function keysSorter(input) {
+    if (Array.isArray(input)) {
+      return input.sort();
+    }
+    if (typeof input === "object") {
+      return keysSorter(Object.keys(input)).sort((a, b) => Number(a) - Number(b)).map((key) => input[key]);
+    }
+    return input;
+  }
+  function removeHash(input) {
+    const hashStart = input.indexOf("#");
+    if (hashStart !== -1) {
+      input = input.slice(0, hashStart);
+    }
+    return input;
+  }
+  function getHash(url) {
+    let hash = "";
+    const hashStart = url.indexOf("#");
+    if (hashStart !== -1) {
+      hash = url.slice(hashStart);
+    }
+    return hash;
+  }
+  function extract(input) {
+    input = removeHash(input);
+    const queryStart = input.indexOf("?");
+    if (queryStart === -1) {
+      return "";
+    }
+    return input.slice(queryStart + 1);
+  }
+  function parseValue(value, options) {
+    if (options.parseNumbers && !Number.isNaN(Number(value)) && (typeof value === "string" && value.trim() !== "")) {
+      value = Number(value);
+    } else if (options.parseBooleans && value !== null && (value.toLowerCase() === "true" || value.toLowerCase() === "false")) {
+      value = value.toLowerCase() === "true";
+    }
+    return value;
+  }
+  function parse(query, options) {
+    options = Object.assign({
+      decode: true,
+      sort: true,
+      arrayFormat: "none",
+      arrayFormatSeparator: ",",
+      parseNumbers: false,
+      parseBooleans: false
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const formatter = parserForArrayFormat(options);
+    const ret = Object.create(null);
+    if (typeof query !== "string") {
+      return ret;
+    }
+    query = query.trim().replace(/^[?#&]/, "");
+    if (!query) {
+      return ret;
+    }
+    for (const param of query.split("&")) {
+      if (param === "") {
+        continue;
+      }
+      let [key, value] = splitOnFirst$1(options.decode ? param.replace(/\+/g, " ") : param, "=");
+      value = value === void 0 ? null : ["comma", "separator", "bracket-separator"].includes(options.arrayFormat) ? value : decode2(value, options);
+      formatter(decode2(key, options), value, ret);
+    }
+    for (const key of Object.keys(ret)) {
+      const value = ret[key];
+      if (typeof value === "object" && value !== null) {
+        for (const k of Object.keys(value)) {
+          value[k] = parseValue(value[k], options);
+        }
+      } else {
+        ret[key] = parseValue(value, options);
+      }
+    }
+    if (options.sort === false) {
+      return ret;
+    }
+    return (options.sort === true ? Object.keys(ret).sort() : Object.keys(ret).sort(options.sort)).reduce((result, key) => {
+      const value = ret[key];
+      if (Boolean(value) && typeof value === "object" && !Array.isArray(value)) {
+        result[key] = keysSorter(value);
+      } else {
+        result[key] = value;
+      }
+      return result;
+    }, Object.create(null));
+  }
+  exports.extract = extract;
+  exports.parse = parse;
+  exports.stringify = (object, options) => {
+    if (!object) {
+      return "";
+    }
+    options = Object.assign({
+      encode: true,
+      strict: true,
+      arrayFormat: "none",
+      arrayFormatSeparator: ","
+    }, options);
+    validateArrayFormatSeparator(options.arrayFormatSeparator);
+    const shouldFilter = (key) => options.skipNull && isNullOrUndefined(object[key]) || options.skipEmptyString && object[key] === "";
+    const formatter = encoderForArrayFormat(options);
+    const objectCopy = {};
+    for (const key of Object.keys(object)) {
+      if (!shouldFilter(key)) {
+        objectCopy[key] = object[key];
+      }
+    }
+    const keys = Object.keys(objectCopy);
+    if (options.sort !== false) {
+      keys.sort(options.sort);
+    }
+    return keys.map((key) => {
+      const value = object[key];
+      if (value === void 0) {
+        return "";
+      }
+      if (value === null) {
+        return encode(key, options);
+      }
+      if (Array.isArray(value)) {
+        if (value.length === 0 && options.arrayFormat === "bracket-separator") {
+          return encode(key, options) + "[]";
+        }
+        return value.reduce(formatter(key), []).join("&");
+      }
+      return encode(key, options) + "=" + encode(value, options);
+    }).filter((x) => x.length > 0).join("&");
+  };
+  exports.parseUrl = (url, options) => {
+    options = Object.assign({
+      decode: true
+    }, options);
+    const [url_, hash] = splitOnFirst$1(url, "#");
+    return Object.assign({
+      url: url_.split("?")[0] || "",
+      query: parse(extract(url), options)
+    }, options && options.parseFragmentIdentifier && hash ? { fragmentIdentifier: decode2(hash, options) } : {});
+  };
+  exports.stringifyUrl = (object, options) => {
+    options = Object.assign({
+      encode: true,
+      strict: true,
+      [encodeFragmentIdentifier]: true
+    }, options);
+    const url = removeHash(object.url).split("?")[0] || "";
+    const queryFromUrl = exports.extract(object.url);
+    const parsedQueryFromUrl = exports.parse(queryFromUrl, { sort: false });
+    const query = Object.assign(parsedQueryFromUrl, object.query);
+    let queryString2 = exports.stringify(query, options);
+    if (queryString2) {
+      queryString2 = `?${queryString2}`;
+    }
+    let hash = getHash(object.url);
+    if (object.fragmentIdentifier) {
+      hash = `#${options[encodeFragmentIdentifier] ? encode(object.fragmentIdentifier, options) : object.fragmentIdentifier}`;
+    }
+    return `${url}${queryString2}${hash}`;
+  };
+  exports.pick = (input, filter, options) => {
+    options = Object.assign({
+      parseFragmentIdentifier: true,
+      [encodeFragmentIdentifier]: false
+    }, options);
+    const { url, query, fragmentIdentifier } = exports.parseUrl(input, options);
+    return exports.stringifyUrl({
+      url,
+      query: filterObject(query, filter),
+      fragmentIdentifier
+    }, options);
+  };
+  exports.exclude = (input, filter, options) => {
+    const exclusionFilter = Array.isArray(filter) ? (key) => !filter.includes(key) : (key, value) => !filter(key, value);
+    return exports.pick(input, exclusionFilter, options);
+  };
+})(queryString);
+const NHOST_REFRESH_TOKEN = "nhostRefreshToken";
+const isBrowser = () => typeof window !== "undefined";
+class inMemoryLocalStorage {
+  constructor() {
+    this.memory = {};
+  }
+  setItem(key, value) {
+    this.memory[key] = value;
+  }
+  getItem(key) {
+    return this.memory[key];
+  }
+  removeItem(key) {
+    delete this.memory[key];
+  }
+}
+class HasuraAuthClient {
+  constructor({
+    url,
+    autoRefreshToken = true,
+    autoLogin = true,
+    refreshIntervalTime,
+    clientStorage,
+    clientStorageType = "web"
+  }) {
+    this.refreshIntervalTime = refreshIntervalTime;
+    if (!clientStorage) {
+      this.clientStorage = isBrowser() ? localStorage : new inMemoryLocalStorage();
+    } else {
+      this.clientStorage = clientStorage;
+    }
+    this.clientStorageType = clientStorageType;
+    this.onTokenChangedFunctions = [];
+    this.onAuthChangedFunctions = [];
+    this.refreshInterval;
+    this.refreshSleepCheckInterval = 0;
+    this.refreshIntervalSleepCheckLastSample = Date.now();
+    this.sampleRate = 2e3;
+    this.url = url;
+    this.autoRefreshToken = autoRefreshToken;
+    this.initAuthLoading = true;
+    this.session = null;
+    this.api = new HasuraAuthApi({ url: this.url });
+    let refreshToken = null;
+    let autoLoginFromQueryParameters = false;
+    if (autoLogin && isBrowser() && window.location) {
+      const urlParams = queryString.parse(window.location.toString().split("#")[1]);
+      if ("refreshToken" in urlParams) {
+        refreshToken = urlParams.refreshToken;
+      }
+      if ("otp" in urlParams && "email" in urlParams) {
+        const { otp, email } = urlParams;
+        this.signIn({
+          otp,
+          email
+        });
+        autoLoginFromQueryParameters = true;
+      }
+    }
+    if (!autoLoginFromQueryParameters && autoLogin) {
+      this._autoLogin(refreshToken);
+    } else if (refreshToken) {
+      this._setItem(NHOST_REFRESH_TOKEN, refreshToken);
+    }
+  }
+  async signUp(params) {
+    const { email, password } = params;
+    if (email && password) {
+      const { data, error } = await this.api.signUpEmailPassword(params);
+      if (error) {
+        return { session: null, error };
+      }
+      if (!data) {
+        return {
+          session: null,
+          error: { message: "An error occurred on sign up.", status: 500 }
+        };
+      }
+      const { session } = data;
+      if (session) {
+        await this._setSession(session);
+      }
+      return { session, error: null };
+    }
+    return {
+      session: null,
+      error: { message: "Incorrect parameters", status: 500 }
+    };
+  }
+  async signIn(params) {
+    if ("provider" in params) {
+      const { provider } = params;
+      const providerUrl = `${this.url}/signin/provider/${provider}`;
+      if (isBrowser()) {
+        window.location.href = providerUrl;
+      }
+      return { providerUrl, provider, session: null, mfa: null, error: null };
+    }
+    if ("email" in params && "password" in params) {
+      const { data, error } = await this.api.signInEmailPassword(params);
+      if (error) {
+        return { session: null, mfa: null, error };
+      }
+      if (!data) {
+        return {
+          session: null,
+          mfa: null,
+          error: { message: "Incorrect Data", status: 500 }
+        };
+      }
+      const { session, mfa } = data;
+      if (session) {
+        await this._setSession(session);
+      }
+      return { session, mfa, error: null };
+    }
+    if ("email" in params && !("otp" in params)) {
+      const { error } = await this.api.signInPasswordlessEmail(params);
+      if (error) {
+        return { session: null, mfa: null, error };
+      }
+      return { session: null, mfa: null, error: null };
+    }
+    if ("phoneNumber" in params && !("otp" in params)) {
+      const { error } = await this.api.signInPasswordlessSms(params);
+      if (error) {
+        return { session: null, mfa: null, error };
+      }
+      return { session: null, mfa: null, error: null };
+    }
+    if ("otp" in params) {
+      const { data, error } = await this.api.signInPasswordlessSmsOtp(params);
+      if (error) {
+        return { session: null, mfa: null, error };
+      }
+      if (!data) {
+        return {
+          session: null,
+          mfa: null,
+          error: { message: "Incorrect data", status: 500 }
+        };
+      }
+      const { session, mfa } = data;
+      if (session) {
+        await this._setSession(session);
+      }
+      return { session, mfa, error: null };
+    }
+    return {
+      session: null,
+      mfa: null,
+      error: { message: "Incorrect parameters", status: 500 }
+    };
+  }
+  async signOut(params) {
+    const refreshToken = await this._getItem(NHOST_REFRESH_TOKEN);
+    this._clearSession();
+    const { error } = await this.api.signOut({
+      refreshToken,
+      all: params == null ? void 0 : params.all
+    });
+    return { error };
+  }
+  async verifyEmail(params) {
+    return await this.api.verifyEmail(params);
+  }
+  async resetPassword(params) {
+    const { error } = await this.api.resetPassword(params);
+    return { error };
+  }
+  async changePassword(params) {
+    const { error } = await this.api.changePassword(params);
+    return { error };
+  }
+  async sendVerificationEmail(params) {
+    const { error } = await this.api.sendVerificationEmail(params);
+    return { error };
+  }
+  async changeEmail(params) {
+    const { error } = await this.api.changeEmail(params);
+    return { error };
+  }
+  async deanonymize(params) {
+    const { error } = await this.api.deanonymize(params);
+    return { error };
+  }
+  onTokenChanged(fn) {
+    this.onTokenChangedFunctions.push(fn);
+    const index = this.onTokenChangedFunctions.length - 1;
+    const unsubscribe = () => {
+      try {
+        this.onTokenChangedFunctions[index] = () => {
+        };
+      } catch {
+        console.warn("Unable to unsubscribe onTokenChanged function. Maybe the functions is already unsubscribed?");
+      }
+    };
+    return unsubscribe;
+  }
+  onAuthStateChanged(fn) {
+    this.onAuthChangedFunctions.push(fn);
+    const index = this.onAuthChangedFunctions.length - 1;
+    const unsubscribe = () => {
+      try {
+        this.onAuthChangedFunctions[index] = () => {
+        };
+      } catch {
+        console.warn("Unable to unsubscribe onAuthStateChanged function. Maybe you already did?");
+      }
+    };
+    return unsubscribe;
+  }
+  isAuthenticated() {
+    return this.session !== null;
+  }
+  async isAuthenticatedAsync() {
+    return new Promise((resolve) => {
+      if (!this.initAuthLoading) {
+        resolve(this.isAuthenticated());
+      } else {
+        const unsubscribe = this.onAuthStateChanged((event, _session) => {
+          resolve(event === "SIGNED_IN");
+          unsubscribe();
+        });
+      }
+    });
+  }
+  getAuthenticationStatus() {
+    if (this.initAuthLoading)
+      return { isAuthenticated: false, isLoading: true };
+    return { isAuthenticated: this.session !== null, isLoading: false };
+  }
+  getJWTToken() {
+    return this.getAccessToken();
+  }
+  getAccessToken() {
+    if (!this.session) {
+      return void 0;
+    }
+    return this.session.accessToken;
+  }
+  async refreshSession(refreshToken) {
+    const refreshTokenToUse = refreshToken || await this._getItem(NHOST_REFRESH_TOKEN);
+    if (!refreshTokenToUse) {
+      console.warn("no refresh token found. No way of refreshing session");
+    }
+    return this._refreshTokens(refreshTokenToUse);
+  }
+  getSession() {
+    return this.session;
+  }
+  getUser() {
+    return this.session ? this.session.user : null;
+  }
+  async _setItem(key, value) {
+    if (typeof value !== "string") {
+      console.error(`value is not of type "string"`);
+      return;
+    }
+    switch (this.clientStorageType) {
+      case "web":
+        if (typeof this.clientStorage.setItem !== "function") {
+          console.error(`this.clientStorage.setItem is not a function`);
+          break;
+        }
+        this.clientStorage.setItem(key, value);
+        break;
+      case "custom":
+      case "react-native":
+        if (typeof this.clientStorage.setItem !== "function") {
+          console.error(`this.clientStorage.setItem is not a function`);
+          break;
+        }
+        await this.clientStorage.setItem(key, value);
+        break;
+      case "capacitor":
+        if (typeof this.clientStorage.set !== "function") {
+          console.error(`this.clientStorage.set is not a function`);
+          break;
+        }
+        await this.clientStorage.set({ key, value });
+        break;
+      case "expo-secure-storage":
+        if (typeof this.clientStorage.setItemAsync !== "function") {
+          console.error(`this.clientStorage.setItemAsync is not a function`);
+          break;
+        }
+        this.clientStorage.setItemAsync(key, value);
+        break;
+    }
+  }
+  async _getItem(key) {
+    switch (this.clientStorageType) {
+      case "web":
+        if (typeof this.clientStorage.getItem !== "function") {
+          console.error(`this.clientStorage.getItem is not a function`);
+          break;
+        }
+        return this.clientStorage.getItem(key);
+      case "custom":
+      case "react-native":
+        if (typeof this.clientStorage.getItem !== "function") {
+          console.error(`this.clientStorage.getItem is not a function`);
+          break;
+        }
+        return await this.clientStorage.getItem(key);
+      case "capacitor":
+        if (typeof this.clientStorage.get !== "function") {
+          console.error(`this.clientStorage.get is not a function`);
+          break;
+        }
+        const res = await this.clientStorage.get({ key });
+        return res.value;
+      case "expo-secure-storage":
+        if (typeof this.clientStorage.getItemAsync !== "function") {
+          console.error(`this.clientStorage.getItemAsync is not a function`);
+          break;
+        }
+        return this.clientStorage.getItemAsync(key);
+      default:
+        return "";
+    }
+    return "";
+  }
+  async _removeItem(key) {
+    switch (this.clientStorageType) {
+      case "web":
+        if (typeof this.clientStorage.removeItem !== "function") {
+          console.error(`this.clientStorage.removeItem is not a function`);
+          break;
+        }
+        return void this.clientStorage.removeItem(key);
+      case "custom":
+      case "react-native":
+        if (typeof this.clientStorage.removeItem !== "function") {
+          console.error(`this.clientStorage.removeItem is not a function`);
+          break;
+        }
+        return void this.clientStorage.removeItem(key);
+      case "capacitor":
+        if (typeof this.clientStorage.remove !== "function") {
+          console.error(`this.clientStorage.remove is not a function`);
+          break;
+        }
+        await this.clientStorage.remove({ key });
+        break;
+      case "expo-secure-storage":
+        if (typeof this.clientStorage.deleteItemAsync !== "function") {
+          console.error(`this.clientStorage.deleteItemAsync is not a function`);
+          break;
+        }
+        this.clientStorage.deleteItemAsync(key);
+        break;
+    }
+  }
+  _autoLogin(refreshToken) {
+    if (!isBrowser()) {
+      return;
+    }
+    this._refreshTokens(refreshToken);
+  }
+  async _refreshTokens(paramRefreshToken) {
+    const refreshToken = paramRefreshToken || await this._getItem(NHOST_REFRESH_TOKEN);
+    if (!refreshToken) {
+      setTimeout(async () => {
+        await this._clearSession();
+      }, 0);
+      return;
+    }
+    try {
+      const { session, error } = await this.api.refreshToken({ refreshToken });
+      if (error && error.status === 401) {
+        await this._clearSession();
+        return;
+      }
+      if (!session)
+        throw new Error("Invalid session data");
+      await this._setSession(session);
+      this.tokenChanged();
+    } catch {
+    }
+  }
+  tokenChanged() {
+    for (const tokenChangedFunction of this.onTokenChangedFunctions) {
+      tokenChangedFunction(this.session);
+    }
+  }
+  authStateChanged({
+    event,
+    session
+  }) {
+    if (event === "SIGNED_IN" && session) {
+      this.api.setAccessToken(session.accessToken);
+    } else {
+      this.api.setAccessToken(void 0);
+    }
+    for (const authChangedFunction of this.onAuthChangedFunctions) {
+      authChangedFunction(event, session);
+    }
+  }
+  async _clearSession() {
+    const { isLoading, isAuthenticated } = this.getAuthenticationStatus();
+    this.session = null;
+    this.initAuthLoading = false;
+    await this._removeItem(NHOST_REFRESH_TOKEN);
+    if (isLoading || isAuthenticated) {
+      clearInterval(this.refreshInterval);
+      clearInterval(this.refreshSleepCheckInterval);
+      this.authStateChanged({ event: "SIGNED_OUT", session: null });
+    }
+  }
+  async _setSession(session) {
+    const { isAuthenticated } = this.getAuthenticationStatus();
+    this.session = session;
+    await this._setItem(NHOST_REFRESH_TOKEN, session.refreshToken);
+    if (this.autoRefreshToken && !isAuthenticated) {
+      const JWTExpiresIn = session.accessTokenExpiresIn;
+      const refreshIntervalTime = this.refreshIntervalTime ? this.refreshIntervalTime : Math.max(1, JWTExpiresIn - 1);
+      this.refreshInterval = setInterval(async () => {
+        const refreshToken = await this._getItem(NHOST_REFRESH_TOKEN);
+        await this._refreshTokens(refreshToken);
+      }, refreshIntervalTime * 1e3);
+      this.refreshIntervalSleepCheckLastSample = Date.now();
+      this.refreshSleepCheckInterval = setInterval(async () => {
+        if (Date.now() - this.refreshIntervalSleepCheckLastSample >= this.sampleRate * 2) {
+          const refreshToken = await this._getItem(NHOST_REFRESH_TOKEN);
+          await this._refreshTokens(refreshToken);
+        }
+        this.refreshIntervalSleepCheckLastSample = Date.now();
+      }, this.sampleRate);
+      this.authStateChanged({ event: "SIGNED_IN", session: this.session });
+    }
+    this.initAuthLoading = false;
+  }
+}
+const axios$2 = require("axios");
+class HasuraStorageApi {
+  constructor({ url }) {
+    this.url = url;
+    this.httpClient = axios$2.create({
+      baseURL: this.url
+    });
+  }
+  async upload(params) {
+    try {
+      const res = await this.httpClient.post("/files", params.file, {
+        headers: __spreadValues(__spreadValues({}, this.generateUploadHeaders(params)), this.generateAuthHeaders())
+      });
+      return { fileMetadata: res.data, error: null };
+    } catch (error) {
+      return { fileMetadata: null, error };
+    }
+  }
+  async getPresignedUrl(params) {
+    try {
+      const { fileId } = params;
+      const res = await this.httpClient.get(`/files/${fileId}/presignedurl`, {
+        headers: __spreadValues({}, this.generateAuthHeaders())
+      });
+      return { presignedUrl: res.data, error: null };
+    } catch (error) {
+      return { presignedUrl: null, error };
+    }
+  }
+  async delete(params) {
+    try {
+      const { fileId } = params;
+      await this.httpClient.delete(`/files/${fileId}`, {
+        headers: __spreadValues({}, this.generateAuthHeaders())
+      });
+      return { error: null };
+    } catch (error) {
+      return { error };
+    }
+  }
+  setAccessToken(accessToken) {
+    this.accessToken = accessToken;
+  }
+  generateUploadHeaders(params) {
+    const { bucketId, name, id } = params;
+    const uploadheaders = {};
+    if (bucketId) {
+      uploadheaders["x-nhost-bucket-id"] = bucketId;
+    }
+    if (id) {
+      uploadheaders["x-nhost-file-id"] = id;
+    }
+    if (name) {
+      uploadheaders["x-nhost-file-name"] = name;
+    }
+    return uploadheaders;
+  }
+  generateAuthHeaders() {
+    if (!this.accessToken) {
+      return null;
+    }
+    return {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+  }
+}
+class HasuraStorageClient {
+  constructor({ url }) {
+    this.url = url;
+    this.api = new HasuraStorageApi({ url });
+  }
+  async upload(params) {
+    const file = new FormData();
+    file.append("file", params.file);
+    const { fileMetadata, error } = await this.api.upload(__spreadProps(__spreadValues({}, params), {
+      file
+    }));
+    if (error) {
+      return { fileMetadata: null, error };
+    }
+    if (!fileMetadata) {
+      return { fileMetadata: null, error: new Error("Invalid file returned") };
+    }
+    return { fileMetadata, error: null };
+  }
+  getUrl(params) {
+    const { fileId } = params;
+    return `${this.url}/files/${fileId}`;
+  }
+  async getPresignedUrl(params) {
+    const { presignedUrl, error } = await this.api.getPresignedUrl(params);
+    if (error) {
+      return { presignedUrl: null, error };
+    }
+    if (!presignedUrl) {
+      return { presignedUrl: null, error: new Error("Invalid file id") };
+    }
+    return { presignedUrl, error: null };
+  }
+  async delete(params) {
+    const { error } = await this.api.delete(params);
+    if (error) {
+      return { error };
+    }
+    return { error: null };
+  }
+  setAccessToken(accessToken) {
+    this.api.setAccessToken(accessToken);
+  }
+}
+const axios$1 = require("axios");
+class NhostFunctionsClient {
+  constructor(params) {
+    const { url } = params;
+    this.accessToken = null;
+    this.instance = axios$1.create({
+      baseURL: url
+    });
+  }
+  async call(url, data, config) {
+    const headers = __spreadValues(__spreadValues({}, this.generateAccessTokenHeaders()), config == null ? void 0 : config.headers);
+    let res;
+    try {
+      res = await this.instance.post(url, data, __spreadProps(__spreadValues({}, config), { headers }));
+    } catch (error) {
+      if (error instanceof Error) {
+        return { res: null, error };
+      }
+    }
+    if (!res) {
+      return {
+        res: null,
+        error: new Error("Unable to make post request to funtion")
+      };
+    }
+    return { res, error: null };
+  }
+  setAccessToken(accessToken) {
+    if (!accessToken) {
+      this.accessToken = null;
+      return;
+    }
+    this.accessToken = accessToken;
+  }
+  generateAccessTokenHeaders() {
+    if (!this.accessToken) {
+      return;
+    }
+    return {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+  }
+}
+const axios = require("axios");
+class NhostGraphqlClient {
+  constructor(params) {
+    const { url } = params;
+    this.url = url;
+    this.accessToken = null;
+    this.instance = axios.create({
+      baseURL: url
+    });
+  }
+  async request(document, variables, config) {
+    const headers = __spreadValues(__spreadValues({}, config == null ? void 0 : config.headers), this.generateAccessTokenHeaders());
+    const operationName = "";
+    let responseData;
+    try {
+      const res = await this.instance.post("", {
+        operationName: operationName || void 0,
+        query: document,
+        variables
+      }, __spreadProps(__spreadValues({}, config), { headers }));
+      responseData = res.data;
+    } catch (error) {
+      if (error instanceof Error) {
+        return { data: null, error };
+      }
+      console.error(error);
+      return {
+        data: null,
+        error: new Error("Unable to get do GraphQL request")
+      };
+    }
+    if (typeof responseData !== "object" || Array.isArray(responseData) || responseData === null) {
+      return {
+        data: null,
+        error: new Error("incorrect response data from GraphQL server")
+      };
+    }
+    responseData = responseData;
+    if (responseData.errors) {
+      return {
+        data: null,
+        error: responseData.errors
+      };
+    }
+    return { data: responseData.data, error: null };
+  }
+  getUrl() {
+    return this.url;
+  }
+  setAccessToken(accessToken) {
+    if (!accessToken) {
+      this.accessToken = null;
+      return;
+    }
+    this.accessToken = accessToken;
+  }
+  generateAccessTokenHeaders() {
+    if (!this.accessToken) {
+      return;
+    }
+    return {
+      Authorization: `Bearer ${this.accessToken}`
+    };
+  }
+}
+class NhostClient {
+  constructor(params) {
+    if (!params.backendUrl)
+      throw new Error("Please specify a `backendUrl`. Docs: [todo]!");
+    const {
+      backendUrl,
+      refreshIntervalTime,
+      clientStorage,
+      clientStorageType,
+      autoRefreshToken,
+      autoLogin
+    } = params;
+    this.auth = new HasuraAuthClient({
+      url: `${backendUrl}/v1/auth`,
+      refreshIntervalTime,
+      clientStorage,
+      clientStorageType,
+      autoRefreshToken,
+      autoLogin
+    });
+    this.storage = new HasuraStorageClient({
+      url: `${backendUrl}/v1/storage`
+    });
+    this.functions = new NhostFunctionsClient({
+      url: `${backendUrl}/v1/functions`
+    });
+    this.graphql = new NhostGraphqlClient({
+      url: `${backendUrl}/v1/graphql`
+    });
+    this.storage.setAccessToken(this.auth.getAccessToken());
+    this.functions.setAccessToken(this.auth.getAccessToken());
+    this.graphql.setAccessToken(this.auth.getAccessToken());
+    this.auth.onAuthStateChanged((_event, session) => {
+      this.storage.setAccessToken(session == null ? void 0 : session.accessToken);
+      this.functions.setAccessToken(session == null ? void 0 : session.accessToken);
+      this.graphql.setAccessToken(session == null ? void 0 : session.accessToken);
+    });
+    this.auth.onTokenChanged((session) => {
+      this.storage.setAccessToken(session == null ? void 0 : session.accessToken);
+      this.functions.setAccessToken(session == null ? void 0 : session.accessToken);
+      this.graphql.setAccessToken(session == null ? void 0 : session.accessToken);
+    });
+  }
+}
+const createClient = (config) => new NhostClient(config);
+export { NhostClient, createClient };