solid-auth-client/module/host.js

Opaquely authenticates solid clients

import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _regeneratorRuntime from "@babel/runtime/regenerator";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";

function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); keys.push.apply(keys, symbols); } return keys; }

function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }

/* globalRequest, Response, URL */
import { getSession } from './session';
import { getData, updateStorage } from './storage';
import * as WebIdOidc from './webid-oidc';
export function getHost(storage) {
  return /*#__PURE__*/function () {
    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url) {
      var _URL, host, session, _yield$getData, hosts;

      return _regeneratorRuntime.wrap(function _callee$(_context) {
        while (1) {
          switch (_context.prev = _context.next) {
            case 0:
              _URL = new URL(url), host = _URL.host;
              _context.next = 3;
              return getSession(storage);

            case 3:
              session = _context.sent;

              if (!(session && host === new URL(session.idp).host)) {
                _context.next = 6;
                break;
              }

              return _context.abrupt("return", {
                url: host,
                requiresAuth: true
              });

            case 6:
              _context.next = 8;
              return getData(storage);

            case 8:
              _yield$getData = _context.sent;
              hosts = _yield$getData.hosts;
              return _context.abrupt("return", hosts && hosts[host]);

            case 11:
            case "end":
              return _context.stop();
          }
        }
      }, _callee);
    }));

    return function (_x) {
      return _ref.apply(this, arguments);
    };
  }();
}
export function saveHost(storage) {
  return /*#__PURE__*/function () {
    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(_ref2) {
      var url, requiresAuth;
      return _regeneratorRuntime.wrap(function _callee2$(_context2) {
        while (1) {
          switch (_context2.prev = _context2.next) {
            case 0:
              url = _ref2.url, requiresAuth = _ref2.requiresAuth;
              _context2.next = 3;
              return updateStorage(storage, function (data) {
                return _objectSpread(_objectSpread({}, data), {}, {
                  hosts: _objectSpread(_objectSpread({}, data.hosts), {}, _defineProperty({}, url, {
                    requiresAuth: requiresAuth
                  }))
                });
              });

            case 3:
            case "end":
              return _context2.stop();
          }
        }
      }, _callee2);
    }));

    return function (_x2) {
      return _ref3.apply(this, arguments);
    };
  }();
}
export function updateHostFromResponse(storage) {
  return /*#__PURE__*/function () {
    var _ref4 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(resp) {
      var _URL2, host;

      return _regeneratorRuntime.wrap(function _callee3$(_context3) {
        while (1) {
          switch (_context3.prev = _context3.next) {
            case 0:
              if (!WebIdOidc.requiresAuth(resp)) {
                _context3.next = 4;
                break;
              }

              _URL2 = new URL(resp.url), host = _URL2.host;
              _context3.next = 4;
              return saveHost(storage)({
                url: host,
                requiresAuth: true
              });

            case 4:
            case "end":
              return _context3.stop();
          }
        }
      }, _callee3);
    }));

    return function (_x3) {
      return _ref4.apply(this, arguments);
    };
  }();
}