feat: add fetch middleware for api keys and request init

chore: remove file

wip

Author: janniks

package-lock.json

@@ -1,5 +1,4 @@
 import { resolveZoneFileToProfile } from '@stacks/profile';
-import { fetchPrivate } from '@stacks/common';
 import { StacksMainnet, StacksNetwork, StacksNetworkName } from '@stacks/network';
 
 export interface ProfileLookupOptions {
@@ -31,13 +30,13 @@ export function lookupProfile(lookupOptions: ProfileLookupOptions): Promise<Reco
   let lookupPromise;
   if (options.zoneFileLookupURL) {
     const url = `${options.zoneFileLookupURL.replace(/\/$/, '')}/${options.username}`;
-    lookupPromise = fetchPrivate(url).then(response => response.json());
+    lookupPromise = network.fetchFn(url).then(response => response.json());
   } else {
     lookupPromise = network.getNameInfo(options.username);
   }
   return lookupPromise.then((responseJSON: any) => {
     if (responseJSON.hasOwnProperty('zonefile') && responseJSON.hasOwnProperty('address')) {
-      return resolveZoneFileToProfile(responseJSON.zonefile, responseJSON.address);
+      return resolveZoneFileToProfile(responseJSON.zonefile, responseJSON.address, network.fetchFn);
     } else {
       throw new Error(
         'Invalid zonefile lookup response: did not contain `address`' + ' or `zonefile` field'

packages/auth/src/profile.ts

@@ -1,6 +1,6 @@
 import * as queryString from 'query-string';
 import { decodeToken } from 'jsontokens';
-import { BLOCKSTACK_HANDLER, getGlobalObject, fetchPrivate } from '@stacks/common';
+import { BLOCKSTACK_HANDLER, getGlobalObject, createFetchFn, FetchFn } from '@stacks/common';
 
 /**
  * Retrieves the authentication request from the query string
@@ -36,7 +36,10 @@ export function getAuthRequestFromURL() {
  * @private
  * @ignore
  */
-export async function fetchAppManifest(authRequest: string): Promise<any> {
+export async function fetchAppManifest(
+  authRequest: string,
+  fetchFn: FetchFn = createFetchFn()
+): Promise<any> {
   if (!authRequest) {
     throw new Error('Invalid auth request');
   }
@@ -47,7 +50,7 @@ export async function fetchAppManifest(authRequest: string): Promise<any> {
   const manifestURI = payload.manifest_uri as string;
   try {
     // Logger.debug(`Fetching manifest from ${manifestURI}`)
-    const response = await fetchPrivate(manifestURI);
+    const response = await fetchFn(manifestURI);
     const responseText = await response.text();
     const responseJSON = JSON.parse(responseText);
     return { ...responseJSON, manifestURI };

packages/auth/src/provider.ts

@@ -1,5 +1,5 @@
 // @ts-ignore
-import { Buffer } from '@stacks/common';
+import { Buffer, FetchFn, createFetchFn } from '@stacks/common';
 import { AppConfig } from './appConfig';
 import { SessionOptions } from './sessionData';
 import { InstanceDataStore, LocalStorageStore, SessionDataStore } from './sessionStore';
@@ -15,7 +15,6 @@ import {
 import { getAddressFromDID } from './dids';
 import {
   BLOCKSTACK_DEFAULT_GAIA_HUB_URL,
-  fetchPrivate,
   getGlobalObject,
   InvalidStateError,
   isLaterVersion,
@@ -214,7 +213,8 @@ export class UserSession {
    * if handling the sign in request fails or there was no pending sign in request.
    */
   async handlePendingSignIn(
-    authResponseToken: string = this.getAuthResponseToken()
+    authResponseToken: string = this.getAuthResponseToken(),
+    fetchFn: FetchFn = createFetchFn()
   ): Promise<UserData> {
     const sessionData = this.store.getSessionData();
 
@@ -312,7 +312,7 @@ export class UserSession {
     };
     const profileURL = tokenPayload.profile_url as string;
     if (!userData.profile && profileURL) {
-      const response = await fetchPrivate(profileURL);
+      const response = await fetchFn(profileURL);
       if (!response.ok) {
         // return blank profile if we fail to fetch
         userData.profile = Object.assign({}, DEFAULT_PROFILE);

packages/auth/src/userSession.ts

@@ -1,11 +1,11 @@
 import blockstack from 'blockstack';
 import * as bitcoin from 'bitcoinjs-lib';
 import BN from 'bn.js';
-import fetch from 'node-fetch';
 
 import { CLI_CONFIG_TYPE } from './argparse';
 
 import { BlockstackNetwork } from 'blockstack/lib/network';
+import { FetchFn, createFetchFn } from '@stacks/common';
 
 export interface CLI_NETWORK_OPTS {
   consensusHash: string | null;
@@ -187,15 +187,16 @@ export class CLINetworkAdapter {
   getNamespaceBurnAddress(
     namespace: string,
     useCLI: boolean = true,
-    receiveFeesPeriod: number = -1
+    receiveFeesPeriod: number = -1,
+    fetchFn: FetchFn = createFetchFn()
   ): Promise<string> {
     // override with CLI option
     if (this.namespaceBurnAddress && useCLI) {
       return new Promise((resolve: any) => resolve(this.namespaceBurnAddress));
     }
 
     return Promise.all([
-      fetch(`${this.legacyNetwork.blockstackAPIUrl}/v1/namespaces/${namespace}`),
+      fetchFn(`${this.legacyNetwork.blockstackAPIUrl}/v1/namespaces/${namespace}`),
       this.legacyNetwork.getBlockHeight(),
     ])
       .then(([resp, blockHeight]: [any, number]) => {
@@ -245,10 +246,10 @@ export class CLINetworkAdapter {
     });
   }
 
-  getBlockchainNameRecord(name: string): Promise<any> {
+  getBlockchainNameRecord(name: string, fetchFn: FetchFn = createFetchFn()): Promise<any> {
     // TODO: send to blockstack.js
     const url = `${this.legacyNetwork.blockstackAPIUrl}/v1/blockchains/bitcoin/names/${name}`;
-    return fetch(url)
+    return fetchFn(url)
       .then(resp => {
         if (resp.status !== 200) {
           throw new Error(`Bad response status: ${resp.status}`);
@@ -268,10 +269,14 @@ export class CLINetworkAdapter {
       });
   }
 
-  getNameHistory(name: string, page: number): Promise<Record<string, any[]>> {
+  getNameHistory(
+    name: string,
+    page: number,
+    fetchFn: FetchFn = createFetchFn()
+  ): Promise<Record<string, any[]>> {
     // TODO: send to blockstack.js
     const url = `${this.legacyNetwork.blockstackAPIUrl}/v1/names/${name}/history?page=${page}`;
-    return fetch(url)
+    return fetchFn(url)
       .then(resp => {
         if (resp.status !== 200) {
           throw new Error(`Bad response status: ${resp.status}`);

packages/cli/src/network.ts

@@ -36,3 +36,120 @@ export async function fetchPrivate(input: RequestInfo, init?: RequestInit): Prom
   const fetchResult = await fetch(input, fetchOpts);
   return fetchResult;
 }
+
+export type FetchFn = (url: string, init?: RequestInit) => Promise<Response>;
+
+export interface RequestContext {
+  fetch: FetchFn;
+  url: string;
+  init: RequestInit;
+}
+
+export interface ResponseContext {
+  fetch: FetchFn;
+  url: string;
+  init: RequestInit;
+  response: Response;
+}
+
+export interface FetchParams {
+  url: string;
+  init: RequestInit;
+}
+
+export interface FetchMiddleware {
+  pre?: (context: RequestContext) => PromiseLike<FetchParams | void> | FetchParams | void;
+  post?: (context: ResponseContext) => Promise<Response | void> | Response | void;
+}
+export interface ApiKeyMiddlewareOpts {
+  /** The middleware / API key header will only be added to requests matching this host. */
+  host?: RegExp | string;
+  /** The http header name used for specifying the API key value. */
+  httpHeader?: string;
+  /** The API key string to specify as an http header value. */
+  apiKey: string;
+}
+
+/** @internal */
+export function hostMatches(host: string, pattern: string | RegExp) {
+  if (typeof pattern === 'string') return pattern === host;
+  return (pattern as RegExp).exec(host);
+}
+
+/**
+ * Creates a new middleware from an API key.
+ * @example
+ * ```
+ * const apiMiddleware = createApiKeyMiddleware("example_e8e044a3_41d8b0fe_3dd3988ef302");
+ * const fetchFn = createFetchFn(apiMiddleware);
+ * const network = new StacksMainnet({ fetchFn });
+ * ```
+ * @category Network
+ * @related {@link createFetchFn}, {@link StacksNetwork}
+ */
+export function createApiKeyMiddleware({
+  apiKey,
+  host = /(.*)api(.*)\.stacks\.co$/i,
+  httpHeader = 'x-api-key',
+}: ApiKeyMiddlewareOpts): FetchMiddleware {
+  return {
+    pre: context => {
+      const reqUrl = new URL(context.url);
+      if (!hostMatches(reqUrl.host, host)) return; // Skip middleware if host does not match pattern
+
+      const headers = new Headers(context.init.headers);
+      headers.set(httpHeader, apiKey);
+      context.init.headers = headers;
+    },
+  };
+}
+
+function argsForCreateFetchFn(args: any[]): { middlewares: FetchMiddleware[]; fetchLib: FetchFn } {
+  let fetchLib: FetchFn = fetch;
+  let middlewares: FetchMiddleware[] = [];
+  if (args.length > 0 && typeof args[0] === 'function') {
+    fetchLib = args.shift();
+  }
+  if (args.length > 0) {
+    middlewares = args;
+  }
+  return { middlewares, fetchLib };
+}
+
+export function createFetchFn(fetchLib: FetchFn, ...middleware: FetchMiddleware[]): FetchFn;
+export function createFetchFn(...middleware: FetchMiddleware[]): FetchFn;
+export function createFetchFn(...args: any[]): FetchFn {
+  const { middlewares: middlewareArgs, fetchLib } = argsForCreateFetchFn(args);
+  const middlewares = [...middlewareArgs]; // shallow copy
+
+  const fetchFn = async (url: string, init?: RequestInit | undefined): Promise<Response> => {
+    let fetchParams = { url, init: init ?? {} };
+    for (const middleware of middlewares) {
+      if (typeof middleware.pre !== 'function') continue;
+      const result = await Promise.resolve(
+        middleware.pre({
+          fetch: fetchLib,
+          ...fetchParams,
+        })
+      );
+      fetchParams = result ?? fetchParams;
+    }
+
+    let response = await fetchLib(fetchParams.url, fetchParams.init);
+
+    for (const middleware of middlewares) {
+      if (typeof middleware.post !== 'function') continue;
+      const result = await Promise.resolve(
+        middleware.post({
+          fetch: fetchLib,
+          url: fetchParams.url,
+          init: fetchParams.init,
+          response: response.clone(),
+        })
+      );
+      response = result ?? response;
+    }
+    return response;
+  };
+  return fetchFn;
+}

packages/common/src/fetchUtil.ts

@@ -1,4 +1,5 @@
 import { makeAuthResponse } from '@stacks/auth';
+import { FetchFn, createFetchFn } from '@stacks/common';
 import { getPublicKeyFromPrivate, publicKeyToAddress } from '@stacks/encryption';
 import { bip32 } from 'bitcoinjs-lib';
 import { Identity as IdentifyInterface, Profile } from './common';
@@ -130,9 +131,9 @@ export class Identity implements IdentifyInterface {
     return `${gaiaUrl}${this.address}/profile.json`;
   }
 
-  async fetchNames() {
+  async fetchNames(fetchFn: FetchFn = createFetchFn()) {
     const getNamesUrl = `https://stacks-node-api.stacks.co/v1/addresses/bitcoin/${this.address}`;
-    const res = await fetchPrivate(getNamesUrl);
+    const res = await fetchFn(getNamesUrl);
     const data = await res.json();
     const { names }: { names: string[] } = data;
     return names;

packages/keychain/src/identity.ts

@@ -1,10 +1,9 @@
-import { connectToGaiaHub } from '@stacks/storage';
-import { signProfileToken, wrapProfileToken, makeProfileZoneFile } from '@stacks/profile';
+import { createFetchFn, FetchFn } from '@stacks/common';
+import { makeProfileZoneFile, signProfileToken, wrapProfileToken } from '@stacks/profile';
+import { connectToGaiaHub, GaiaHubConfig } from '@stacks/storage';
 import { Identity, Profile } from './common';
 import { IdentityKeyPair } from './utils';
 import { uploadToGaiaHub } from './utils/gaia';
-import { GaiaHubConfig } from '@stacks/storage';
-import { fetchPrivate } from '@stacks/common';
 
 export const DEFAULT_PROFILE: Profile = {
   '@type': 'Person',
@@ -61,13 +60,15 @@ interface SendToRegistrarParams {
   subdomain: Subdomains;
   zoneFile: string;
   identity: Identity;
+  fetchFn?: FetchFn;
 }
 
 const sendUsernameToRegistrar = async ({
   username,
   subdomain,
   zoneFile,
   identity,
+  fetchFn = createFetchFn(),
 }: SendToRegistrarParams) => {
   const { registerUrl } = registrars[subdomain];
 
@@ -82,7 +83,7 @@ const sendUsernameToRegistrar = async ({
     'Content-Type': 'application/json',
   };
 
-  const response = await fetchPrivate(registerUrl, {
+  const response = await fetchFn(registerUrl, {
     method: 'POST',
     headers: requestHeaders,
     body: registrationRequestBody,
@@ -151,13 +152,15 @@ export const signAndUploadProfile = async ({
 export const fetchProfile = async ({
   identity,
   gaiaUrl,
+  fetchFn = createFetchFn(),
 }: {
   identity: Identity;
   gaiaUrl: string;
+  fetchFn?: FetchFn;
 }) => {
   try {
     const url = await identity.profileUrl(gaiaUrl);
-    const res = await fetchPrivate(url);
+    const res = await fetchFn(url);
     if (res.ok) {
       const json = await res.json();
       const { decodedToken } = json[0];