@compassdigital/sdk.typescript 4.72.0 → 4.74.0

package/src/base.ts

@@ -1,31 +1,30 @@
-
-import fetch from "cross-fetch";
+import fetch from 'cross-fetch';
 
 export interface RequestOptions {
-  // environment to make requests to
-  stage?: string;
-  // authentication token
-  token?: string;
-  // additional headers
-  headers?: Record<string, string>;
-  // query parameters
-  query?: { _provider?: string };
-  // log all requests and responses
-  debug?: boolean;
-  // the number of times to retry a request
-  retry?: number;
-  // timeout in milliseconds
-  timeout?: number;
-  // make requests against this base url.
-  // per-service base urls are configured as an object
-  // eg. { order: 'http://localhost:3000', shoppingcart: 'http://localhost:4000' }
-  // note: the stage property is ignored if base_url is set
-  base_url?: string | Record<string, string>
-  // intercept outgoing http requests
-  intercept?: InterceptFn;
-  // https.Agent agent to use
-  // Note: we use 'any' type to remain browser compatible
-  agent?: any;
+	// environment to make requests to
+	stage?: string;
+	// authentication token
+	token?: string;
+	// additional headers
+	headers?: Record<string, string>;
+	// query parameters
+	query?: { _provider?: string };
+	// log all requests and responses
+	debug?: boolean;
+	// the number of times to retry a request
+	retry?: number;
+	// timeout in milliseconds
+	timeout?: number;
+	// make requests against this base url.
+	// per-service base urls are configured as an object
+	// eg. { order: 'http://localhost:3000', shoppingcart: 'http://localhost:4000' }
+	// note: the stage property is ignored if base_url is set
+	base_url?: string | Record<string, string>;
+	// intercept outgoing http requests
+	intercept?: InterceptFn;
+	// https.Agent agent to use
+	// Note: we use 'any' type to remain browser compatible
+	agent?: any;
 }
 
 /**
@@ -33,12 +32,12 @@ export interface RequestOptions {
  * functions.
  */
 export interface RequestData {
-  name: string;
-  service: string;
-  url: string;
-  method: string;
-  headers: Record<string, string>;
-  body?: string;
+	route: string;
+	service: string;
+	url: string;
+	method: string;
+	headers: Record<string, string>;
+	body?: string;
 }
 
 /**
@@ -46,10 +45,10 @@ export interface RequestData {
  * intercept functions.
  */
 export interface ResponseData {
-  ok: boolean;
-  status: number;
-  body: string;
-  err?: any; // network error
+	ok: boolean;
+	status: number;
+	body: string;
+	err?: any; // network error
 }
 
 /**
@@ -67,207 +66,208 @@ export type InterceptFn = (req: RequestData, fetch: FetchFn) => Promise<Response
  * the existing Promise class due to: https://github.com/microsoft/TypeScript/issues/15202
  */
 export class ResponsePromise<T> implements Promise<T> {
-
-  /**
-   * Implements Promise interface.
-   */
-  [Symbol.toStringTag] = "[object ResponsePromise]";
-
-  constructor(private promise: Promise<T>) { }
-
-  /**
-   * Implements Promise interface.
-   */
-  then<TResult1 = T, TResult2 = never>(
-    onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
-    onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null
-  ): ResponsePromise<TResult1 | TResult2> {
-    return new ResponsePromise(this.promise.then(onfulfilled, onrejected));
-  }
-
-  /**
-   * Implements Promise interface.
-   */
-  catch<TResult = never>(
-    onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null
-  ): ResponsePromise<T | TResult> {
-    return new ResponsePromise(this.promise.catch(onrejected));
-  }
-
-  /**
-   * Implements Promise interface.
-   */
-  finally(onfinally?: (() => void) | null): ResponsePromise<T> {
-    return new ResponsePromise(this.promise.finally(onfinally));
-  }
-
-  /**
-   * Returns a promise that resolves to null if http status code
-   * or service error code matches one of the provided codes.
-   * If no codes are specified, all codes are ignored.
-   */
-  ignore(...codes: number[]): ResponsePromise<T | null> {
-    return new ResponsePromise(ServiceError.ignore(codes, this.promise));
-  }
-
-  /**
-   * Returns a promise that resolves to either the response body
-   * or a ServiceError.
-   */
-  combine(...codes: number[]): Promise<EitherResponse<T>> {
-    return new ResponsePromise(ServiceError.combine<T>(codes, this.promise));
-  }
-
-  /**
-   * Creates a new resolved promise for the provided value.
-   */
-  static resolve<T>(value: T): ResponsePromise<T> {
-    return new ResponsePromise(Promise.resolve(value));
-  }
-
-  /**
-   * Creates a new rejected promise for the provided reason.
-   * @param reason The reason the promise was rejected.
-   * @returns A new rejected Promise.
-   */
-  static reject<T = never>(reason?: any): ResponsePromise<T> {
-    return new ResponsePromise(Promise.reject(reason));
-  }
+	/**
+	 * Implements Promise interface.
+	 */
+	[Symbol.toStringTag] = '[object ResponsePromise]';
+
+	constructor(private promise: Promise<T>) {}
+
+	/**
+	 * Implements Promise interface.
+	 */
+	then<TResult1 = T, TResult2 = never>(
+		onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null,
+		onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | null,
+	): ResponsePromise<TResult1 | TResult2> {
+		return new ResponsePromise(this.promise.then(onfulfilled, onrejected));
+	}
+
+	/**
+	 * Implements Promise interface.
+	 */
+	catch<TResult = never>(
+		onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | null,
+	): ResponsePromise<T | TResult> {
+		return new ResponsePromise(this.promise.catch(onrejected));
+	}
+
+	/**
+	 * Implements Promise interface.
+	 */
+	finally(onfinally?: (() => void) | null): ResponsePromise<T> {
+		return new ResponsePromise(this.promise.finally(onfinally));
+	}
+
+	/**
+	 * Returns a promise that resolves to null if http status code
+	 * or service error code matches one of the provided codes.
+	 * If no codes are specified, all codes are ignored.
+	 */
+	ignore(...codes: number[]): ResponsePromise<T | null> {
+		return new ResponsePromise(ServiceError.ignore(codes, this.promise));
+	}
+
+	/**
+	 * Returns a promise that resolves to either the response body
+	 * or a ServiceError.
+	 */
+	combine(...codes: number[]): Promise<EitherResponse<T>> {
+		return new ResponsePromise(ServiceError.combine<T>(codes, this.promise));
+	}
+
+	/**
+	 * Creates a new resolved promise for the provided value.
+	 */
+	static resolve<T>(value: T): ResponsePromise<T> {
+		return new ResponsePromise(Promise.resolve(value));
+	}
+
+	/**
+	 * Creates a new rejected promise for the provided reason.
+	 * @param reason The reason the promise was rejected.
+	 * @returns A new rejected Promise.
+	 */
+	static reject<T = never>(reason?: any): ResponsePromise<T> {
+		return new ResponsePromise(Promise.reject(reason));
+	}
 }
 
 /**
  * Either a response body or a service error.
  */
-export type EitherResponse<T> = { ok: true; data: T; err: null } | { ok: false; data: null, err: ServiceError; };
+export type EitherResponse<T> =
+	| { ok: true; data: T; err: null }
+	| { ok: false; data: null; err: ServiceError };
 
 /**
  * This is a hack to make captureStackTrace visible.
  */
 interface ErrorConstructor {
-  captureStackTrace?(target: object, constructorOpt?: Function): void;
+	captureStackTrace?(target: object, constructorOpt?: Function): void;
 }
 
 /**
  * An error returned from an api service.
  */
 export class ServiceError extends Error {
-  constructor(
-    public status: number, // http status
-    public code: number,   // service error code
-    message: string        // service error message
-  ) {
-    super(message);
-    this.name = `ServiceError(${code})`;
-
-    // TODO: remove this if we change compilation target > es5
-    Object.setPrototypeOf(this, ServiceError.prototype);
-  }
-
-  /**
-   * Returns the http status code from err.
-   * If err isn't an instance of ServiceError, -1 is returned.
-   */
-  static status(err: any): number {
-    if (err instanceof ServiceError) {
-      return err.status;
-    }
-    return -1;
-  }
-
-  /**
-   * Returns the service error code from err.
-   * If err isn't an instance of ServiceError, -1 is returned.
-   */
-  static code(err: any): number {
-    if (err instanceof ServiceError) {
-      return err.code;
-    }
-    return -1;
-  }
-
-  /**
-   * Returns a promise that resolves to null if http status code
-   * or service error code matches one of the provided codes.
-   * If no codes are specified, all codes are ignored.
-   */
-  static async ignore<T>(codes: number[], response: Promise<T>): Promise<T | null> {
-    try {
-      return await response;
-    } catch (err) {
-      if (ServiceError.unwrap(err, codes)) {
-        return null;
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Returns a promise that resolves to either T or a ServiceError.
-   */
-  static async combine<T>(codes: number[], response: Promise<T>): Promise<EitherResponse<T>> {
-    try {
-      const data = await response;
-      return { ok: true, data, err: null };
-    } catch (err) {
-      const match = ServiceError.unwrap(err, codes);
-      if (match) {
-        return { ok: false, data: null, err: match };
-      }
-      throw err;
-    }
-  }
-
-  /**
-   * Returns the first ServiceError in the cause chain matches the provided codes.
-   * If no codes were provided, the first ServiceError is returned.
-   */
-  private static unwrap(err: any, codes: number[]): ServiceError | null {
-    while (err) {
-      if (err instanceof ServiceError) {
-        if (codes.length === 0) {
-          return err
-        }
-        for (const code of codes) {
-          if (err.status === code || err.code === code) {
-            return err
-          }
-        }
-      }
-      err = err?.cause;
-    }
-    return null;
-  }
-
-  /**
-   * Constructs a ServiceError from the provided response data.
-   */
-  static from_res(res: ResponseData): ServiceError {
-    let message = res.body;
-    let code = res.status;
-    if (res.err) {
-      // network error
-      if (res.err instanceof Error) {
-        message = res.err.message;
-      } else {
-        message = "Network Error";
-      }
-      code = 0;
-    } else {
-      try {
-        let data = JSON.parse(res.body);
-        if (data.code && (data.message || data.error)) {
-          code = data.code;
-          message = data.message || data.error;
-        }
-      } catch (_) { }
-    }
-    const err = new ServiceError(res.status, code, message);
-    // override the stack trace so that it doesn't include the from_res helper.
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(err, ServiceError.from_res);
-    }
-    return err;
-  }
+	constructor(
+		public status: number, // http status
+		public code: number, // service error code
+		message: string, // service error message
+	) {
+		super(message);
+		this.name = `ServiceError(${code})`;
+
+		// TODO: remove this if we change compilation target > es5
+		Object.setPrototypeOf(this, ServiceError.prototype);
+	}
+
+	/**
+	 * Returns the http status code from err.
+	 * If err isn't an instance of ServiceError, -1 is returned.
+	 */
+	static status(err: any): number {
+		if (err instanceof ServiceError) {
+			return err.status;
+		}
+		return -1;
+	}
+
+	/**
+	 * Returns the service error code from err.
+	 * If err isn't an instance of ServiceError, -1 is returned.
+	 */
+	static code(err: any): number {
+		if (err instanceof ServiceError) {
+			return err.code;
+		}
+		return -1;
+	}
+
+	/**
+	 * Returns a promise that resolves to null if http status code
+	 * or service error code matches one of the provided codes.
+	 * If no codes are specified, all codes are ignored.
+	 */
+	static async ignore<T>(codes: number[], response: Promise<T>): Promise<T | null> {
+		try {
+			return await response;
+		} catch (err) {
+			if (ServiceError.unwrap(err, codes)) {
+				return null;
+			}
+			throw err;
+		}
+	}
+
+	/**
+	 * Returns a promise that resolves to either T or a ServiceError.
+	 */
+	static async combine<T>(codes: number[], response: Promise<T>): Promise<EitherResponse<T>> {
+		try {
+			const data = await response;
+			return { ok: true, data, err: null };
+		} catch (err) {
+			const match = ServiceError.unwrap(err, codes);
+			if (match) {
+				return { ok: false, data: null, err: match };
+			}
+			throw err;
+		}
+	}
+
+	/**
+	 * Returns the first ServiceError in the cause chain matches the provided codes.
+	 * If no codes were provided, the first ServiceError is returned.
+	 */
+	private static unwrap(err: any, codes: number[]): ServiceError | null {
+		while (err) {
+			if (err instanceof ServiceError) {
+				if (codes.length === 0) {
+					return err;
+				}
+				for (const code of codes) {
+					if (err.status === code || err.code === code) {
+						return err;
+					}
+				}
+			}
+			err = err?.cause;
+		}
+		return null;
+	}
+
+	/**
+	 * Constructs a ServiceError from the provided response data.
+	 */
+	static from_res(res: ResponseData): ServiceError {
+		let message = res.body;
+		let code = res.status;
+		if (res.err) {
+			// network error
+			if (res.err instanceof Error) {
+				message = res.err.message;
+			} else {
+				message = 'Network Error';
+			}
+			code = 0;
+		} else {
+			try {
+				const data = JSON.parse(res.body);
+				if (data.code && (data.message || data.error)) {
+					code = data.code;
+					message = data.message || data.error;
+				}
+			} catch (_) {}
+		}
+		const err = new ServiceError(res.status, code, message);
+		// override the stack trace so that it doesn't include the from_res helper.
+		if (Error.captureStackTrace) {
+			Error.captureStackTrace(err, ServiceError.from_res);
+		}
+		return err;
+	}
 }
 
 /**
@@ -275,231 +275,238 @@ export class ServiceError extends Error {
  * This class is meant to be extended by the generated code.
  */
 export abstract class BaseServiceClient {
-  private options: RequestOptions;
-
-  /**
-   * shared default https.Agent
-   * Note: we use 'any' type to remain browser compatible
-   */
-  private static agent: any;
-
-  constructor(options?: RequestOptions) {
-    this.options = {
-      ...this.env_options(),
-      ...options,
-    };
-  }
-
-  /**
-   * Parse request options from environment variables.
-   */
-  private env_options(): RequestOptions {
-    const options: RequestOptions = {};
-    const stage = process.env.P2_SDK_STAGE;
-    if (stage) {
-      options.stage = stage;
-    }
-    const token = process.env.P2_SDK_TOKEN;
-    if (token) {
-      options.token = token;
-    }
-    const debug = process.env.P2_SDK_DEBUG;
-    if (debug && debug !== "0" && `${debug}`.toLowerCase() !== "false") {
-      options.debug = true;
-    }
-    const base_url = process.env.P2_SDK_BASE_URL;
-    if (base_url) {
-      if (base_url.includes('=')) {
-        options.base_url = {};
-        for (const custom_service_url of base_url.split(',')) {
-          const [service, custom_url] = custom_service_url.split('=');
-          options.base_url[service] = custom_url
-        }
-      } else {
-        options.base_url = base_url;
-      }
-    }
-    return options;
-  }
-
-  /**
-   * Combine the route and query parameters into a full url.
-   */
-  private build_url(route: string, service: string, { base_url, stage = "dev" }: RequestOptions, params: any): string {
-    let url = stage === 'v1'
-      ? `https://api.compassdigital.org${route}`
-      : `https://${stage}.api.compassdigital.org${route}`;
-    // use the base url if one was provided.
-    if (base_url) {
-      if (typeof base_url === 'object' && base_url[service]) base_url = base_url[service];
-      if (typeof base_url === 'string') url = `${this.clean_url(base_url)}${route}`;
-    }
-    // add query parameters.
-    const query: string[] = [];
-    for (const [name, values] of Object.entries(params)) {
-      for (const value of Array.isArray(values) ? values : [values]) {
-        query.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
-      }
-    }
-    if (query.length > 0) {
-      url += "?" + query.join("&");
-    }
-    return url;
-  }
-
-  private clean_url(url: string): string {
-    if (url.endsWith("/")) {
-      url = url.slice(0, -1);
-    }
-    return url;
-  }
-
-  /**
-   * Perform the http request or pass it to the intercept function
-   * if one was configured.
-   */
-  private async fetch(req: RequestData, options?: RequestOptions): Promise<ResponseData> {
-    if (options?.intercept) {
-      return options.intercept(req, this.fetch.bind(this));
-    }
-    try {
-      let signal: AbortSignal | undefined;
-      if (options?.timeout) {
-        const controller = new AbortController();
-        setTimeout(() => controller.abort("timeout"), options.timeout);
-        signal = controller.signal;
-      }
-      const res = await fetch(req.url, {
-        method: req.method,
-        body: req.body,
-        headers: req.headers,
-        // @ts-expect-error
-        agent: options?.agent,
-        signal,
-      });
-      return {
-        ok: res.ok,
-        status: res.status,
-        body: await res.text(),
-      };
-    } catch (err) {
-      return {
-        ok: false,
-        status: 0,
-        body: "",
-        err: err,
-      }
-    }
-  }
-
-  /**
-   * Get default https.Agent or undefined
-   */
-  private agent(): any {
-    if (process?.release?.name === "node" && !BaseServiceClient.agent) {
-      const https = require("https");
-      BaseServiceClient.agent = new https.Agent({ keepAlive: true });
-    }
-    return BaseServiceClient.agent;
-  }
-
-  /**
-   * Returns true if the status code represents a transient error
-   * or it's a network error.
-   */
-  private should_retry(res: ResponseData): boolean {
-    if (res.err) {
-      return true;
-    }
-    switch (res.status) {
-      case 408: // timeout
-      case 413: // too large
-      case 429: // too many requests
-      case 500: // generic error response
-      case 502: // invalid upstream response
-      case 503: // service unavailable
-      case 504: // gateway timeout
-      case 522: // tcp connection timeout
-        return true;
-      default:
-        return false;
-    }
-  }
-
-  /**
-   * Returns the merged options.
-   */
-  private get_options(options: RequestOptions): RequestOptions {
-    return {
-      ...this.options,
-      ...options,
-      headers: {
-        ...this.options.headers,
-        ...options.headers,
-      }
-    };
-  }
-
-  /**
-   * A delegate to _request that wraps the response in a ResponsePromise.
-   */
-  protected request(
-    service: string,
-    name: string,
-    method: string,
-    route: string,
-    body: any,
-    options: { query?: any } & RequestOptions = {}
-  ): ResponsePromise<any> {
-    const promise = this._request(service, name, method, route, body, options);
-    return new ResponsePromise(promise);
-  }
-
-  /**
-   * The main logic for fulfilling a request as perscribed by
-   * the request options.
-   */
-  private async _request(
-    service: string,
-    name: string,
-    method: string,
-    route: string,
-    body: any,
-    options: { query?: any } & RequestOptions = {}
-  ): Promise<any> {
-    options = this.get_options(options);
-    const url = this.build_url(route, service, options, options.query ?? {});
-    if (url.startsWith('https://')) options.agent ??= this.agent();
-    const headers = Object.assign({
-      "User-Agent": "CDL/ServiceClient",
-      "Content-Type": "application/json",
-    }, options.headers);
-    if (options.token) {
-      headers["Authorization"] = `Bearer ${options.token}`;
-    }
-    const req: RequestData = { name, service, url, method, headers };
-    if (body) {
-      req.body = JSON.stringify(body);
-    }
-    if (options.debug) {
-      console.log(`REQ(${method.toUpperCase()})`, url, JSON.stringify(req, null, 2));
-    }
-    const res = await this.fetch(req, options);
-    if (!res.ok) {
-      const err = ServiceError.from_res(res);
-      if (options.debug) {
-        console.log(`ERR(${res.status})`, url, err.message);
-      }
-      if (typeof options.retry === "number" && options.retry > 0 && this.should_retry(res)) {
-        options.retry--;
-        return this.request(service, name, method, route, body, options);
-      }
-      throw err;
-    }
-    const data = res.body ? JSON.parse(res.body) : res.body;
-    if (options.debug) {
-      console.log(`RES(${res.status})`, url, JSON.stringify(data, null, 2));
-    }
-    return data;
-  }
+	private options: RequestOptions;
+
+	/**
+	 * shared default https.Agent
+	 * Note: we use 'any' type to remain browser compatible
+	 */
+	private static agent: any;
+
+	constructor(options?: RequestOptions) {
+		this.options = {
+			...this.env_options(),
+			...options,
+		};
+	}
+
+	/**
+	 * Parse request options from environment variables.
+	 */
+	private env_options(): RequestOptions {
+		const options: RequestOptions = {};
+		const stage = process.env.P2_SDK_STAGE;
+		if (stage) {
+			options.stage = stage;
+		}
+		const token = process.env.P2_SDK_TOKEN;
+		if (token) {
+			options.token = token;
+		}
+		const debug = process.env.P2_SDK_DEBUG;
+		if (debug && debug !== '0' && `${debug}`.toLowerCase() !== 'false') {
+			options.debug = true;
+		}
+		const base_url = process.env.P2_SDK_BASE_URL;
+		if (base_url) {
+			if (base_url.includes('=')) {
+				options.base_url = {};
+				for (const custom_service_url of base_url.split(',')) {
+					const [service, custom_url] = custom_service_url.split('=');
+					options.base_url[service] = custom_url;
+				}
+			} else {
+				options.base_url = base_url;
+			}
+		}
+		return options;
+	}
+
+	/**
+	 * Combine the path and query parameters into a full url.
+	 */
+	private build_url(
+		path: string,
+		service: string,
+		{ base_url, stage = 'dev' }: RequestOptions,
+		params: any,
+	): string {
+		let url =
+			stage === 'v1'
+				? `https://api.compassdigital.org${path}`
+				: `https://${stage}.api.compassdigital.org${path}`;
+		// use the base url if one was provided.
+		if (base_url) {
+			if (typeof base_url === 'object' && base_url[service]) base_url = base_url[service];
+			if (typeof base_url === 'string') url = `${this.clean_url(base_url)}${path}`;
+		}
+		// add query parameters.
+		const query: string[] = [];
+		for (const [name, values] of Object.entries(params)) {
+			for (const value of Array.isArray(values) ? values : [values]) {
+				query.push(`${encodeURIComponent(name)}=${encodeURIComponent(value)}`);
+			}
+		}
+		if (query.length > 0) {
+			url += `?${query.join('&')}`;
+		}
+		return url;
+	}
+
+	private clean_url(url: string): string {
+		if (url.endsWith('/')) {
+			url = url.slice(0, -1);
+		}
+		return url;
+	}
+
+	/**
+	 * Perform the http request or pass it to the intercept function
+	 * if one was configured.
+	 */
+	private async fetch(req: RequestData, options?: RequestOptions): Promise<ResponseData> {
+		if (options?.intercept) {
+			return options.intercept(req, this.fetch.bind(this));
+		}
+		try {
+			let signal: AbortSignal | undefined;
+			if (options?.timeout) {
+				const controller = new AbortController();
+				setTimeout(() => controller.abort('timeout'), options.timeout);
+				signal = controller.signal;
+			}
+			const res = await fetch(req.url, {
+				method: req.method,
+				body: req.body,
+				headers: req.headers,
+				// @ts-expect-error
+				agent: options?.agent,
+				signal,
+			});
+			return {
+				ok: res.ok,
+				status: res.status,
+				body: await res.text(),
+			};
+		} catch (err) {
+			return {
+				ok: false,
+				status: 0,
+				body: '',
+				err,
+			};
+		}
+	}
+
+	/**
+	 * Get default https.Agent or undefined
+	 */
+	private agent(): any {
+		if (process?.release?.name === 'node' && !BaseServiceClient.agent) {
+			const https = require('https');
+			BaseServiceClient.agent = new https.Agent({ keepAlive: true });
+		}
+		return BaseServiceClient.agent;
+	}
+
+	/**
+	 * Returns true if the status code represents a transient error
+	 * or it's a network error.
+	 */
+	private should_retry(res: ResponseData): boolean {
+		if (res.err) {
+			return true;
+		}
+		switch (res.status) {
+			case 408: // timeout
+			case 413: // too large
+			case 429: // too many requests
+			case 500: // generic error response
+			case 502: // invalid upstream response
+			case 503: // service unavailable
+			case 504: // gateway timeout
+			case 522: // tcp connection timeout
+				return true;
+			default:
+				return false;
+		}
+	}
+
+	/**
+	 * Returns the merged options.
+	 */
+	private get_options(options: RequestOptions): RequestOptions {
+		return {
+			...this.options,
+			...options,
+			headers: {
+				...this.options.headers,
+				...options.headers,
+			},
+		};
+	}
+
+	/**
+	 * A delegate to _request that wraps the response in a ResponsePromise.
+	 */
+	protected request(
+		service: string,
+		route: string,
+		method: string,
+		path: string,
+		body: any,
+		options: { query?: any } & RequestOptions = {},
+	): ResponsePromise<any> {
+		const promise = this._request(service, route, method, path, body, options);
+		return new ResponsePromise(promise);
+	}
+
+	/**
+	 * The main logic for fulfilling a request as perscribed by
+	 * the request options.
+	 */
+	private async _request(
+		service: string,
+		route: string,
+		method: string,
+		path: string,
+		body: any,
+		options: { query?: any } & RequestOptions = {},
+	): Promise<any> {
+		options = this.get_options(options);
+		const url = this.build_url(path, service, options, options.query ?? {});
+		if (url.startsWith('https://')) options.agent ??= this.agent();
+		const headers: Record<string, string> = {
+			'User-Agent': 'CDL/ServiceClient',
+			'Content-Type': 'application/json',
+			...options.headers,
+		};
+		if (options.token) {
+			headers.Authorization = `Bearer ${options.token}`;
+		}
+		const req: RequestData = { service, route, url, method, headers };
+		if (body) {
+			req.body = JSON.stringify(body);
+		}
+		if (options.debug) {
+			console.log(`REQ(${method.toUpperCase()})`, url, JSON.stringify(req, null, 2));
+		}
+		const res = await this.fetch(req, options);
+		if (!res.ok) {
+			const err = ServiceError.from_res(res);
+			if (options.debug) {
+				console.log(`ERR(${res.status})`, url, err.message);
+			}
+			if (typeof options.retry === 'number' && options.retry > 0 && this.should_retry(res)) {
+				options.retry--;
+				return this._request(service, route, method, path, body, options);
+			}
+			throw err;
+		}
+		const data = res.body ? JSON.parse(res.body) : res.body;
+		if (options.debug) {
+			console.log(`RES(${res.status})`, url, JSON.stringify(data, null, 2));
+		}
+		return data;
+	}
 }