jotai/urql.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var core = require('@urql/core');
var jotai = require('jotai');
var wonka = require('wonka');

var DEFAULT_URL = function () {
  try {
    return process.env.JOTAI_URQL_DEFAULT_URL;
  } catch (_unused) {
    return undefined;
  }
}() || '/graphql';

var clientAtom = jotai.atom(core.createClient({
  url: DEFAULT_URL
}));

function _extends() {
  _extends = Object.assign ? Object.assign.bind() : function (target) {
    for (var i = 1; i < arguments.length; i++) {
      var source = arguments[i];

      for (var key in source) {
        if (Object.prototype.hasOwnProperty.call(source, key)) {
          target[key] = source[key];
        }
      }
    }

    return target;
  };
  return _extends.apply(this, arguments);
}

var isOperationResultWithData$1 = function isOperationResultWithData(result) {
  return 'data' in result && !result.error;
};

function atomWithQuery(createQueryArgs, getClient) {
  if (getClient === void 0) {
    getClient = function getClient(get) {
      return get(clientAtom);
    };
  }

  var queryResultAtom = jotai.atom(function (get) {
    var args = createQueryArgs(get);

    if (args.pause) {
      return null;
    }

    var client = getClient(get);
    var resolve = null;
    var baseResultAtom = jotai.atom(new Promise(function (r) {
      resolve = r;
    }));

    var setResult = function setResult() {
      throw new Error('setting result without mount');
    };

    var listener = function listener(result) {
      if (result instanceof Promise) {
        setResult(result);
        return;
      }

      if (!isOperationResultWithData$1(result)) {
        throw new Error('result does not have data');
      }

      if (resolve) {
        resolve(result);
        resolve = null;
      } else {
        setResult(result);
      }
    };

    client.query(args.query, args.variables, _extends({}, args.requestPolicy && {
      requestPolicy: args.requestPolicy
    }, args.context)).toPromise().then(listener).catch(function () {});

    baseResultAtom.onMount = function (update) {
      setResult = update;
    };

    var subscriptionAtom = jotai.atom(null);
    var resultAtom = jotai.atom(function (get) {
      return get(baseResultAtom);
    }, function (get, set, callback) {
      var subscription = wonka.pipe(client.query(args.query, args.variables, _extends({}, args.requestPolicy && {
        requestPolicy: args.requestPolicy
      }, args.context)), wonka.subscribe(listener));
      set(subscriptionAtom, subscription);
      callback(function () {
        var _get;

        return (_get = get(subscriptionAtom)) == null ? void 0 : _get.unsubscribe();
      });
    });

    resultAtom.onMount = function (init) {
      var cleanup;
      init(function (c) {
        cleanup = c;
      });
      return cleanup;
    };

    return {
      args: args,
      client: client,
      resultAtom: resultAtom,
      subscriptionAtom: subscriptionAtom,
      listener: listener
    };
  });
  var queryAtom = jotai.atom(function (get) {
    var queryResult = get(queryResultAtom);

    if (!queryResult) {
      return null;
    }

    var resultAtom = queryResult.resultAtom;
    return get(resultAtom);
  }, function (get, set, action) {
    switch (action.type) {
      case 'reexecute':
        {
          var queryResult = get(queryResultAtom);

          if (!queryResult) {
            throw new Error('query is paused');
          }

          var args = queryResult.args,
              client = queryResult.client,
              subscriptionAtom = queryResult.subscriptionAtom,
              listener = queryResult.listener;
          listener(new Promise(function () {}));
          var newSubscription = wonka.pipe(client.query(args.query, args.variables, _extends({}, args.requestPolicy && {
            requestPolicy: args.requestPolicy
          }, args.context, action.opts)), wonka.subscribe(listener));
          var oldSubscription = get(subscriptionAtom);
          oldSubscription == null ? void 0 : oldSubscription.unsubscribe();
          set(subscriptionAtom, newSubscription);
        }
    }
  });
  return queryAtom;
}

function atomWithMutation(createQuery, getClient) {
  if (getClient === void 0) {
    getClient = function getClient(get) {
      return get(clientAtom);
    };
  }

  var operationResultAtom = jotai.atom(new Promise(function () {}));
  var queryResultAtom = jotai.atom(function (get) {
    return get(operationResultAtom);
  }, function (get, set, action) {
    set(operationResultAtom, new Promise(function () {}));
    var client = getClient(get);
    var query = createQuery(get);
    client.mutation(query, action.variables, action.context).toPromise().then(function (result) {
      set(operationResultAtom, result);
      action.callback == null ? void 0 : action.callback(result);
    }).catch(function () {});
  });
  return queryResultAtom;
}

var isOperationResultWithData = function isOperationResultWithData(result) {
  return 'data' in result;
};

function atomWithSubscription(createSubscriptionArgs, getClient) {
  if (getClient === void 0) {
    getClient = function getClient(get) {
      return get(clientAtom);
    };
  }

  var queryResultAtom = jotai.atom(function (get) {
    var args = createSubscriptionArgs(get);

    if (args.pause) {
      return {
        args: args
      };
    }

    var client = getClient(get);
    var resolve = null;
    var resultAtom = jotai.atom(new Promise(function (r) {
      resolve = r;
    }));

    var setResult = function setResult() {
      throw new Error('setting result without mount');
    };

    var isMounted = false;

    var listener = function listener(result) {
      if (!isOperationResultWithData(result)) {
        throw new Error('result does not have data');
      }

      if (resolve) {
        if (!isMounted) {
          var _subscription;

          (_subscription = subscription) == null ? void 0 : _subscription.unsubscribe();
          subscription = null;
        }

        resolve(result);
        resolve = null;
      } else {
        setResult(result);
      }
    };

    var subscription = wonka.pipe(client.subscription(args.query, args.variables, args.context), wonka.subscribe(listener));

    resultAtom.onMount = function (update) {
      setResult = update;
      isMounted = true;

      if (!subscription) {
        subscription = wonka.pipe(client.subscription(args.query, args.variables, args.context), wonka.subscribe(listener));
      }

      return function () {
        var _subscription2;

        return (_subscription2 = subscription) == null ? void 0 : _subscription2.unsubscribe();
      };
    };

    return {
      resultAtom: resultAtom,
      args: args
    };
  });
  var queryAtom = jotai.atom(function (get) {
    var _get = get(queryResultAtom),
        resultAtom = _get.resultAtom;

    return resultAtom ? get(resultAtom) : null;
  });
  return queryAtom;
}

exports.atomWithMutation = atomWithMutation;
exports.atomWithQuery = atomWithQuery;
exports.atomWithSubscription = atomWithSubscription;
exports.clientAtom = clientAtom;