rentdynamics
Version:
Package to help facilitate communicating with the Rent Dynamics API
374 lines • 50.7 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.decodePayload = exports.encodeSegment = exports.ProofOfPossession = exports.ClientHelpers = exports.ClientOptions = exports.BASE_URL = exports.Client = void 0;
/**
* Client is a convenience class for interacting with the Rent Dynamics services.
*
* Note if this class does not suit your needs, it may be wise to roll your own implementation using
* the {@linkcode ClientHelpers} class.
*/
class Client {
constructor(options) {
this.helpers = new ClientHelpers(options);
}
/**
* get wraps a request library to work with the Rent Dynamics API.
* @param endpoint the path following the baseUrl.
* @example get('/foo');
*/
async get(endpoint) {
const fullUrl = this.helpers.baseUrl + endpoint;
const headers = await this.helpers.getHeaders(endpoint, undefined, this.authToken);
return fetch(fullUrl.replace(/\|/g, '%7C'), {
method: 'GET',
headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' })
});
}
/**
* put wraps a request library to work with the Rent Dynamics API.
* @param endpoint the path following the baseUrl.
* @param payload a JSON serializable object.
* @example put('/foo', { bar: 1 });
*/
async put(endpoint, payload) {
const fullUrl = this.helpers.baseUrl + endpoint;
const headers = await this.helpers.getHeaders(endpoint, payload, this.authToken);
return fetch(fullUrl, {
method: 'PUT',
headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }),
body: JSON.stringify(payload)
});
}
/**
* post wraps a request library to work with the Rent Dynamics API.
* @param endpoint the path following the baseUrl.
* @param payload a JSON serializable object.
* @example post('/foo', { bar: 1 });
*/
async post(endpoint, payload) {
const fullUrl = this.helpers.baseUrl + endpoint;
const headers = await this.helpers.getHeaders(endpoint, payload, this.authToken);
return fetch(fullUrl, {
method: 'POST',
headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' }),
body: JSON.stringify(payload)
});
}
/**
* delete wraps a request library to work with the Rent Dynamics API.
* @param endpoint the path following the baseUrl.
* @example delete('/foo/1');
*/
async delete(endpoint) {
const fullUrl = this.helpers.baseUrl + endpoint;
const headers = await this.helpers.getHeaders(endpoint, undefined, this.authToken);
return fetch(fullUrl, {
method: 'DELETE',
headers: Object.assign(Object.assign({}, headers), { 'Content-Type': 'application/json' })
});
}
/**
* login enables an instance of {@linkcode Client} to make authenticated requests to the Rent
* Dynamics API.
*/
async login(username, password) {
const _password = await this.helpers.encryptPassword(password);
const endpoint = '/auth/login';
const result = await this.post(endpoint, { username, password: _password });
if (!result.ok) {
return result;
}
const { token } = await result.json();
this.authToken = token;
return result;
}
/** logout invalidates the users session generated by {@linkcode login}. */
async logout() {
const endpoint = '/auth/logout';
const result = await this.post(endpoint, { authToken: this.authToken });
if (!result.ok) {
return result;
}
this.authToken = undefined;
return result;
}
}
exports.Client = Client;
/** BASE_URL is a collection of base urls for each dev/prod Rent Dynamics service. */
var BASE_URL;
(function (BASE_URL) {
BASE_URL["DEV_RD"] = "https://api.rentdynamics.dev";
BASE_URL["PROD_RD"] = "https://api.rentdynamics.com";
BASE_URL["DEV_RP"] = "https://api.rentplus.dev";
BASE_URL["PROD_RP"] = "https://api.rentplus.com";
})(BASE_URL = exports.BASE_URL || (exports.BASE_URL = {}));
/** ClientOptions is consumed and updated by {@linkcode ClientHelpers}. */
class ClientOptions {
constructor() {
/**
* baseUrl is the base request url. The default is the development rentdynamics api. A custom
* string may be provided beyond the {@linkcode BASE_URL} options.
*/
this.baseUrl = BASE_URL.DEV_RD;
/**
* getEncoder is used to encode text. The encoder can be overridden as needed. For example in a
* node environment.
* @example
* const options = new ClientOptions();
* options.getEncoder = async () => new (await import('util')).TextEncoder();
*/
this.getEncoder = async () => new TextEncoder();
/**
* getCryptographer is used for cryptography. The cryptographer can be overridden as needed. For
* example in a node environment.
* @example
* const options = new ClientOptions();
* options.getCryptographer = async () => (await import('crypto')).subtle;
*/
this.getCryptographer = async () => crypto.subtle;
}
}
exports.ClientOptions = ClientOptions;
/**
* ClientHelpers is a collection of utilities consumed by {@linkcode Client}. ClientHelpers can be
* used to calculate headers in case a consumer wants to build their own API client.
*/
class ClientHelpers {
constructor(options) {
this.options = options;
}
/**
* baseUrl is the base url used throughout the {@linkcode ClientHelpers} instance. It is initially
* configured through {@linkcode ClientOptions}.
*/
get baseUrl() {
return this.options.baseUrl;
}
/**
* getTimestamp is used to calculate the timestamp header. This method is not likely to be called
* on it's own. Instead, it is typically used to mock the current time.
*/
getTimestamp() {
return Date.now();
}
/**
* getHeaders creates headers for the given params. If an auth token is included, this method will
* generate an `Authorization` header.
*/
async getHeaders(endpoint, payload, authToken) {
const headers = {};
if (this.options.apiKey && this.options.apiSecretKey) {
if (!payload || !Object.keys(payload).length) {
payload = undefined;
}
if (typeof payload !== 'undefined') {
payload = JSON.stringify(this.formatPayload(payload));
}
const timestamp = this.getTimestamp();
const nonce = await this.getNonce(timestamp, endpoint, payload);
if (authToken) {
headers.Authorization = 'TOKEN ' + authToken;
}
headers['x-rd-api-key'] = this.options.apiKey;
headers['x-rd-api-nonce'] = nonce;
headers['x-rd-timestamp'] = timestamp.toString();
return headers;
}
return headers;
}
/** formatPayload formats the payload for nonce calculation. */
formatPayload(payload) {
let formattedPayload = {};
if (payload === undefined || payload === null) {
formattedPayload = null;
}
else if (payload !== Object(payload)) {
formattedPayload = payload;
}
else if (Array.isArray(payload)) {
formattedPayload = [];
payload.forEach((_, index) => {
formattedPayload[index] = this.formatPayload(payload[index]);
});
}
else {
Object.keys(payload)
.sort()
.forEach(k => {
if (typeof payload[k] === 'object') {
formattedPayload[k] = this.formatPayload(payload[k]);
}
else if (typeof payload[k] === 'string') {
formattedPayload[k] = payload[k].replace(/ /g, '');
}
else {
formattedPayload[k] = payload[k];
}
});
}
return formattedPayload;
}
/** getNonce calculates the nonce for the given params. */
async getNonce(timestamp, url, payloadStr) {
if (!this.options.apiSecretKey)
return Promise.resolve('');
const encodedUrl = encodeURI(url)
.replace(/%7[Cc]/g, '|')
.replace(/%20/g, ' ');
const nonceStr = typeof payloadStr !== 'undefined'
? timestamp + encodedUrl + payloadStr
: timestamp + encodedUrl;
const cryptographer = await this.options.getCryptographer();
const encoder = await this.options.getEncoder();
const key = encoder.encode(this.options.apiSecretKey);
const data = encoder.encode(nonceStr);
const algorithm = { name: 'HMAC', hash: 'SHA-1' };
const hmac = await cryptographer.importKey('raw', key, algorithm, false, ['sign']);
const signed = await cryptographer.sign(algorithm.name, hmac, data);
return _hexDigest(signed);
}
/** encryptPassword encrypts the password for login. */
async encryptPassword(password) {
const cryptographer = await this.options.getCryptographer();
const encoder = await this.options.getEncoder();
const encodedPassword = encoder.encode(password);
const digestedPassword = await cryptographer.digest('SHA-1', encodedPassword);
return _hexDigest(digestedPassword);
}
}
exports.ClientHelpers = ClientHelpers;
const _hexDigest = (buf) => Array.from(new Uint8Array(buf))
.map(b => b.toString(16).padStart(2, '0'))
.join('');
/**
* ProofOfPossession encapsulates generic low level logic related to generating proof of possession
* tokens and storing their associated key pair.
*/
class ProofOfPossession {
/**
* constructor creates an instance capable of generating proof of possession tokens.
*
* @param indexedDB window.indexedDB satisfies this interface. If you're not in a browser
* environment, proof of possession tokens are likely not necessary.
*/
constructor(indexedDB) {
this._encoder = new TextEncoder();
this._keyStoreName = 'keys';
this._keyKey = 1;
this._dbName = 'rdb';
this._dbVersion = 2;
this._algorithm = {
name: 'RSA-PSS',
modulusLength: 2048,
publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
hash: 'SHA-256',
saltLength: 32
};
this.indexedDB = indexedDB;
}
/**
* generateProof generates a proof of possession JWT with the key pair. The key pair comes from a
* get or create method. Where the key pair will continuously be used until evicted with
* evictKeyPair.
*/
async generateProof() {
const key = await this._getOrCreateKey();
const header = this._getHeader();
const payload = this._getPayload();
const encodedHeaderAndPayload = this._encoder.encode(`${header}.${payload}`);
const signature = await crypto.subtle.sign(this._algorithm, key.privateKey, encodedHeaderAndPayload);
const encodedSignature = (0, exports.encodeSegment)(String.fromCharCode(...new Uint8Array(signature)));
return `${header}.${payload}.${encodedSignature}`;
}
/**
* getPublicKey gets or creates a key pair and stores it. The public key component is then
* extracted and returned in a base64 url encoded form.
*/
async getPublicKey() {
const keyPair = await this._getOrCreateKey();
const pk = await crypto.subtle.exportKey('jwk', keyPair.publicKey);
return (0, exports.encodeSegment)(JSON.stringify(pk));
}
/**
* evictKeyPair evicts the currently stored key pair. No operation is performed if the key pair
* does not exist.
*/
evictKeyPair() {
return new Promise((resolve, reject) => {
const db = this.indexedDB.open(this._dbName, this._dbVersion);
db.onsuccess = () => {
const t = db.result.transaction(this._keyStoreName, 'readwrite');
const req = t.objectStore(this._keyStoreName).delete(this._keyKey);
req.onsuccess = resolve;
req.onerror = reject;
};
db.onupgradeneeded = this._upgradeDb(db);
db.onerror = reject;
});
}
_getHeader() {
return (0, exports.encodeSegment)(JSON.stringify({
typ: 'dpop+jwt',
alg: 'PS256'
}));
}
_getPayload() {
const d = Math.floor(new Date().getTime() / 1000);
return (0, exports.encodeSegment)(JSON.stringify({
iat: d
}));
}
_getOrCreateKey() {
return new Promise((resolve, reject) => {
const db = this.indexedDB.open(this._dbName, this._dbVersion);
db.onsuccess = this._onDatabaseOpened(resolve, reject, db);
db.onupgradeneeded = this._upgradeDb(db);
db.onerror = reject;
});
}
_onDatabaseOpened(resolve, reject, r) {
return () => {
const t = r.result.transaction(this._keyStoreName, 'readwrite');
t.onerror = reject;
const req = t.objectStore(this._keyStoreName).get(this._keyKey);
req.onerror = reject;
req.onsuccess = this._onKeyLookup(resolve, reject, r, req);
};
}
_onKeyLookup(resolve, reject, db, keyRequest) {
return async () => {
if (keyRequest.result) {
return resolve(keyRequest.result);
}
const key = await this._createKey();
const t2 = db.result.transaction(this._keyStoreName, 'readwrite');
t2.onerror = reject;
const req2 = t2.objectStore(this._keyStoreName).put(key, this._keyKey);
req2.onsuccess = () => resolve(key);
};
}
_upgradeDb(r) {
return () => {
if (!r.result.objectStoreNames.contains(this._keyStoreName)) {
r.result.createObjectStore(this._keyStoreName);
}
};
}
_createKey() {
return crypto.subtle.generateKey(this._algorithm, false, ['sign', 'verify']);
}
}
exports.ProofOfPossession = ProofOfPossession;
/** encodeSegment base64url encodes a string or JWT segment */
const encodeSegment = (segment) => {
return btoa(segment).replace(/\+/g, '-').replace(/\//g, '_').replace(/=+$/g, '');
};
exports.encodeSegment = encodeSegment;
/** decodePayload decodes the payload segment of a JWT to it's object representation */
const decodePayload = (token) => {
const [, payload] = token.split('.');
const padding = payload.length % 4 === 0 ? '' : '='.repeat(4 - (payload.length % 4));
return JSON.parse(atob(`${payload.replace(/-/g, '+').replace(/_/g, '/')}${padding}`));
};
exports.decodePayload = decodePayload;
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"index.js","sourceRoot":"","sources":["../../lib/index.ts"],"names":[],"mappings":"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","sourcesContent":["/** Payload is known as the \"body\" of a Request. The payload must be JSON serializable. */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\ntype Payload = any;\n\n/**\n * Client is a convenience class for interacting with the Rent Dynamics services.\n *\n * Note if this class does not suit your needs, it may be wise to roll your own implementation using\n * the {@linkcode ClientHelpers} class.\n */\nexport class Client {\n  /**\n   * authToken if defined, authToken is used to make authenticated requests. Note authToken is not\n   * typically get/set manually, but instead is managed through the login/logout methods.\n   */\n  public authToken: string | undefined;\n  private readonly helpers: ClientHelpers;\n\n  constructor(options: ClientOptions) {\n    this.helpers = new ClientHelpers(options);\n  }\n\n  /**\n   * get wraps a request library to work with the Rent Dynamics API.\n   * @param endpoint the path following the baseUrl.\n   * @example get('/foo');\n   */\n  public async get(endpoint: string) {\n    const fullUrl = this.helpers.baseUrl + endpoint;\n    const headers = await this.helpers.getHeaders(endpoint, undefined, this.authToken);\n    return fetch(fullUrl.replace(/\\|/g, '%7C'), {\n      method: 'GET',\n      headers: {\n        ...headers,\n        'Content-Type': 'application/json'\n      }\n    });\n  }\n\n  /**\n   * put wraps a request library to work with the Rent Dynamics API.\n   * @param endpoint the path following the baseUrl.\n   * @param payload a JSON serializable object.\n   * @example put('/foo', { bar: 1 });\n   */\n  public async put(endpoint: string, payload: Payload) {\n    const fullUrl = this.helpers.baseUrl + endpoint;\n    const headers = await this.helpers.getHeaders(endpoint, payload, this.authToken);\n    return fetch(fullUrl, {\n      method: 'PUT',\n      headers: {\n        ...headers,\n        'Content-Type': 'application/json'\n      },\n      body: JSON.stringify(payload)\n    });\n  }\n\n  /**\n   * post wraps a request library to work with the Rent Dynamics API.\n   * @param endpoint the path following the baseUrl.\n   * @param payload a JSON serializable object.\n   * @example post('/foo', { bar: 1 });\n   */\n  public async post(endpoint: string, payload: Payload) {\n    const fullUrl = this.helpers.baseUrl + endpoint;\n    const headers = await this.helpers.getHeaders(endpoint, payload, this.authToken);\n    return fetch(fullUrl, {\n      method: 'POST',\n      headers: {\n        ...headers,\n        'Content-Type': 'application/json'\n      },\n      body: JSON.stringify(payload)\n    });\n  }\n\n  /**\n   * delete wraps a request library to work with the Rent Dynamics API.\n   * @param endpoint the path following the baseUrl.\n   * @example delete('/foo/1');\n   */\n  public async delete(endpoint: string) {\n    const fullUrl = this.helpers.baseUrl + endpoint;\n    const headers = await this.helpers.getHeaders(endpoint, undefined, this.authToken);\n    return fetch(fullUrl, {\n      method: 'DELETE',\n      headers: {\n        ...headers,\n        'Content-Type': 'application/json'\n      }\n    });\n  }\n\n  /**\n   * login enables an instance of {@linkcode Client} to make authenticated requests to the Rent\n   * Dynamics API.\n   */\n  public async login(username: string, password: string) {\n    const _password = await this.helpers.encryptPassword(password);\n    const endpoint = '/auth/login';\n    const result = await this.post(endpoint, { username, password: _password });\n    if (!result.ok) {\n      return result;\n    }\n    const { token } = await result.json();\n    this.authToken = token;\n    return result;\n  }\n\n  /** logout invalidates the users session generated by {@linkcode login}. */\n  public async logout() {\n    const endpoint = '/auth/logout';\n    const result = await this.post(endpoint, { authToken: this.authToken });\n    if (!result.ok) {\n      return result;\n    }\n    this.authToken = undefined;\n    return result;\n  }\n}\n\n/** BASE_URL is a collection of base urls for each dev/prod Rent Dynamics service. */\nexport enum BASE_URL {\n  DEV_RD = 'https://api.rentdynamics.dev',\n  PROD_RD = 'https://api.rentdynamics.com',\n  DEV_RP = 'https://api.rentplus.dev',\n  PROD_RP = 'https://api.rentplus.com'\n}\n\nexport type RdEncoder = Pick<TextEncoder, 'encode'>;\n\nexport type RdCryptographer = Pick<SubtleCrypto, 'importKey'> &\n  Pick<SubtleCrypto, 'sign'> &\n  Pick<SubtleCrypto, 'digest'>;\n\n/** ClientOptions is consumed and updated by {@linkcode ClientHelpers}. */\nexport class ClientOptions {\n  /** apiKey if defined apiKey is used to calculate auth headers. */\n  public apiKey: string | undefined;\n  /** apiSecretKey if defined apiSecretKey is used to calculate auth headers.  */\n  public apiSecretKey: string | undefined;\n  /**\n   * baseUrl is the base request url. The default is the development rentdynamics api. A custom\n   * string may be provided beyond the {@linkcode BASE_URL} options.\n   */\n  public baseUrl: BASE_URL | string = BASE_URL.DEV_RD;\n\n  /**\n   * getEncoder is used to encode text. The encoder can be overridden as needed. For example in a\n   * node environment.\n   * @example\n   * const options = new ClientOptions();\n   * options.getEncoder = async () => new (await import('util')).TextEncoder();\n   */\n  public getEncoder = async (): Promise<RdEncoder> => new TextEncoder();\n\n  /**\n   * getCryptographer is used for cryptography. The cryptographer can be overridden as needed. For\n   * example in a node environment.\n   * @example\n   * const options = new ClientOptions();\n   * options.getCryptographer = async () => (await import('crypto')).subtle;\n   */\n  public getCryptographer = async (): Promise<RdCryptographer> => crypto.subtle;\n}\n\n/**\n * ClientHelpers is a collection of utilities consumed by {@linkcode Client}. ClientHelpers can be\n * used to calculate headers in case a consumer wants to build their own API client.\n */\nexport class ClientHelpers {\n  private options: ClientOptions;\n\n  constructor(options: ClientOptions) {\n    this.options = options;\n  }\n\n  /**\n   * baseUrl is the base url used throughout the {@linkcode ClientHelpers} instance. It is initially\n   * configured through {@linkcode ClientOptions}.\n   */\n  get baseUrl() {\n    return this.options.baseUrl;\n  }\n\n  /**\n   * getTimestamp is used to calculate the timestamp header. This method is not likely to be called\n   * on it's own. Instead, it is typically used to mock the current time.\n   */\n  public getTimestamp() {\n    return Date.now();\n  }\n\n  /**\n   * getHeaders creates headers for the given params. If an auth token is included, this method will\n   * generate an `Authorization` header.\n   */\n  public async getHeaders(\n    endpoint: string,\n    payload?: Payload | undefined,\n    authToken?: string | undefined\n  ) {\n    const headers: Record<string, string> = {};\n    if (this.options.apiKey && this.options.apiSecretKey) {\n      if (!payload || !Object.keys(payload).length) {\n        payload = undefined;\n      }\n      if (typeof payload !== 'undefined') {\n        payload = JSON.stringify(this.formatPayload(payload));\n      }\n      const timestamp = this.getTimestamp();\n      const nonce = await this.getNonce(timestamp, endpoint, payload);\n      if (authToken) {\n        headers.Authorization = 'TOKEN ' + authToken;\n      }\n      headers['x-rd-api-key'] = this.options.apiKey;\n      headers['x-rd-api-nonce'] = nonce;\n      headers['x-rd-timestamp'] = timestamp.toString();\n      return headers;\n    }\n    return headers;\n  }\n\n  /** formatPayload formats the payload for nonce calculation. */\n  public formatPayload(payload: Payload): Payload {\n    let formattedPayload: Payload = {};\n    if (payload === undefined || payload === null) {\n      formattedPayload = null;\n    } else if (payload !== Object(payload)) {\n      formattedPayload = payload;\n    } else if (Array.isArray(payload)) {\n      formattedPayload = [];\n      payload.forEach((_, index) => {\n        formattedPayload[index] = this.formatPayload(payload[index]);\n      });\n    } else {\n      Object.keys(payload)\n        .sort()\n        .forEach(k => {\n          if (typeof payload[k] === 'object') {\n            formattedPayload[k] = this.formatPayload(payload[k]);\n          } else if (typeof payload[k] === 'string') {\n            formattedPayload[k] = payload[k].replace(/ /g, '');\n          } else {\n            formattedPayload[k] = payload[k];\n          }\n        });\n    }\n    return formattedPayload;\n  }\n\n  /** getNonce calculates the nonce for the given params. */\n  public async getNonce(timestamp: number, url: string, payloadStr?: string): Promise<string> {\n    if (!this.options.apiSecretKey) return Promise.resolve('');\n    const encodedUrl = encodeURI(url)\n      .replace(/%7[Cc]/g, '|')\n      .replace(/%20/g, ' ');\n    const nonceStr =\n      typeof payloadStr !== 'undefined'\n        ? timestamp + encodedUrl + payloadStr\n        : timestamp + encodedUrl;\n    const cryptographer = await this.options.getCryptographer();\n    const encoder = await this.options.getEncoder();\n    const key = encoder.encode(this.options.apiSecretKey);\n    const data = encoder.encode(nonceStr);\n    const algorithm = { name: 'HMAC', hash: 'SHA-1' };\n    const hmac = await cryptographer.importKey('raw', key, algorithm, false, ['sign']);\n    const signed = await cryptographer.sign(algorithm.name, hmac, data);\n    return _hexDigest(signed);\n  }\n\n  /** encryptPassword encrypts the password for login. */\n  public async encryptPassword(password: string) {\n    const cryptographer = await this.options.getCryptographer();\n    const encoder = await this.options.getEncoder();\n    const encodedPassword = encoder.encode(password);\n    const digestedPassword = await cryptographer.digest('SHA-1', encodedPassword);\n    return _hexDigest(digestedPassword);\n  }\n}\n\nconst _hexDigest = (buf: ArrayBuffer): string =>\n  Array.from(new Uint8Array(buf))\n    .map(b => b.toString(16).padStart(2, '0'))\n    .join('');\n\n/**\n * ProofOfPossession encapsulates generic low level logic related to generating proof of possession\n * tokens and storing their associated key pair.\n */\nexport class ProofOfPossession {\n  private readonly _encoder = new TextEncoder();\n  private readonly _keyStoreName = 'keys';\n  private readonly _keyKey = 1;\n  private readonly _dbName = 'rdb';\n  private readonly _dbVersion = 2;\n  private readonly _algorithm = {\n    name: 'RSA-PSS',\n    modulusLength: 2048,\n    publicExponent: new Uint8Array([0x01, 0x00, 0x01]), // 65537\n    hash: 'SHA-256',\n    saltLength: 32\n  };\n  private readonly indexedDB: IDBFactory;\n\n  /**\n   * constructor creates an instance capable of generating proof of possession tokens.\n   *\n   * @param indexedDB window.indexedDB satisfies this interface. If you're not in a browser\n   * environment, proof of possession tokens are likely not necessary.\n   */\n  constructor(indexedDB: IDBFactory) {\n    this.indexedDB = indexedDB;\n  }\n\n  /**\n   * generateProof generates a proof of possession JWT with the key pair. The key pair comes from a\n   * get or create method. Where the key pair will continuously be used until evicted with\n   * evictKeyPair.\n   */\n  public async generateProof() {\n    const key = await this._getOrCreateKey();\n    const header = this._getHeader();\n    const payload = this._getPayload();\n    const encodedHeaderAndPayload = this._encoder.encode(`${header}.${payload}`);\n    const signature = await crypto.subtle.sign(\n      this._algorithm,\n      key.privateKey,\n      encodedHeaderAndPayload\n    );\n    const encodedSignature = encodeSegment(String.fromCharCode(...new Uint8Array(signature)));\n    return `${header}.${payload}.${encodedSignature}`;\n  }\n\n  /**\n   * getPublicKey gets or creates a key pair and stores it. The public key component is then\n   * extracted and returned in a base64 url encoded form.\n   */\n  public async getPublicKey() {\n    const keyPair = await this._getOrCreateKey();\n    const pk = await crypto.subtle.exportKey('jwk', keyPair.publicKey);\n    return encodeSegment(JSON.stringify(pk));\n  }\n\n  /**\n   * evictKeyPair evicts the currently stored key pair. No operation is performed if the key pair\n   * does not exist.\n   */\n  public evictKeyPair() {\n    return new Promise((resolve, reject) => {\n      const db = this.indexedDB.open(this._dbName, this._dbVersion);\n      db.onsuccess = () => {\n        const t = db.result.transaction(this._keyStoreName, 'readwrite');\n        const req = t.objectStore(this._keyStoreName).delete(this._keyKey);\n        req.onsuccess = resolve;\n        req.onerror = reject;\n      };\n      db.onupgradeneeded = this._upgradeDb(db);\n      db.onerror = reject;\n    });\n  }\n\n  private _getHeader() {\n    return encodeSegment(\n      JSON.stringify({\n        typ: 'dpop+jwt',\n        alg: 'PS256'\n      })\n    );\n  }\n\n  private _getPayload() {\n    const d = Math.floor(new Date().getTime() / 1000);\n    return encodeSegment(\n      JSON.stringify({\n        iat: d\n      })\n    );\n  }\n\n  private _getOrCreateKey(): Promise<CryptoKeyPair> {\n    return new Promise((resolve, reject) => {\n      const db = this.indexedDB.open(this._dbName, this._dbVersion);\n      db.onsuccess = this._onDatabaseOpened(resolve, reject, db);\n      db.onupgradeneeded = this._upgradeDb(db);\n      db.onerror = reject;\n    });\n  }\n\n  private _onDatabaseOpened(\n    resolve: (value: CryptoKeyPair) => void,\n    reject: (reason?: unknown) => void,\n    r: IDBOpenDBRequest\n  ) {\n    return () => {\n      const t = r.result.transaction(this._keyStoreName, 'readwrite');\n      t.onerror = reject;\n      const req = t.objectStore(this._keyStoreName).get(this._keyKey);\n      req.onerror = reject;\n      req.onsuccess = this._onKeyLookup(resolve, reject, r, req);\n    };\n  }\n\n  private _onKeyLookup(\n    resolve: (value: CryptoKeyPair) => void,\n    reject: (reason?: unknown) => void,\n    db: IDBOpenDBRequest,\n    keyRequest: IDBRequest\n  ) {\n    return async () => {\n      if (keyRequest.result) {\n        return resolve(keyRequest.result);\n      }\n      const key = await this._createKey();\n      const t2 = db.result.transaction(this._keyStoreName, 'readwrite');\n      t2.onerror = reject;\n      const req2 = t2.objectStore(this._keyStoreName).put(key, this._keyKey);\n      req2.onsuccess = () => resolve(key);\n    };\n  }\n\n  private _upgradeDb(r: IDBOpenDBRequest) {\n    return () => {\n      if (!r.result.objectStoreNames.contains(this._keyStoreName)) {\n        r.result.createObjectStore(this._keyStoreName);\n      }\n    };\n  }\n\n  private _createKey() {\n    return crypto.subtle.generateKey(this._algorithm, false, ['sign', 'verify']);\n  }\n}\n\n/** encodeSegment base64url encodes a string or JWT segment */\nexport const encodeSegment = (segment