@autometa/http 1.4.19 → 2.0.0-rc.0

package/src/axios-client.ts

@@ -1,35 +0,0 @@
-import { HTTPRequest } from "./http-request";
-import { HTTPResponse, HTTPResponseBuilder } from "./http-response";
-import { HTTPAdditionalOptions, StatusCode } from "./types";
-import axios, { AxiosRequestConfig } from "axios";
-import { HTTPClient } from "./http-client";
-
-@HTTPClient.Use()
-export class AxiosClient extends HTTPClient {
-  async request<TRequestType, TResponseType>(
-    request: HTTPRequest<TRequestType>,
-    options: HTTPAdditionalOptions<AxiosRequestConfig>
-  ): Promise<HTTPResponse<TResponseType>> {
-    const { baseUrl, route, params, headers, method, data } = request;
-    const url = [baseUrl, ...route].join("/");
-    const axiosRequest: AxiosRequestConfig = {
-      url,
-      params,
-      headers,
-      method,
-      data,
-      validateStatus: function (status) {
-        return status >= 0 && status < 600;
-      },
-      ...options,
-    };
-    const response = await axios(axiosRequest);
-    return HTTPResponseBuilder.create()
-      .status(response.status as StatusCode)
-      .statusText(response.statusText)
-      .data(response.data)
-      .headers(response.headers as Record<string, string>)
-      .request(request)
-      .build() as HTTPResponse<TResponseType>;
-  }
-}

package/src/default-client-factory.axios.spec.ts

@@ -1,9 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { defaultClientFactory } from "./default-client-factory";
-import { AxiosClient } from "./axios-client";
-describe("default client as Axios", () => {
-  it("should be an Axios client", () => {
-    const client = defaultClientFactory();
-    expect(client).instanceOf(AxiosClient);
-  });
-});

package/src/default-client-factory.other.spec.ts

@@ -1,13 +0,0 @@
-import { describe, it, expect, vi } from "vitest";
-import { defaultClientFactory } from "./default-client-factory";
-import { HTTPClient } from "./http-client";
-describe("default client as Axios", () => {
-  @HTTPClient.Use()
-  class TestHTTPClient extends HTTPClient {
-    request = vi.fn();
-  }
-  it("should be an Axios client", () => {
-    const client = defaultClientFactory();
-    expect(client).instanceOf(TestHTTPClient);
-  });
-});

package/src/default-client-factory.ts

@@ -1,7 +0,0 @@
-import { Class } from "@autometa/types";
-import { defaultClient, type HTTPClient } from "./http-client";
-
-export function defaultClientFactory() {
-  const type = defaultClient as Class<HTTPClient>;
-  return new type();
-}

package/src/default-schema.spec.ts

@@ -1,74 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  AnySchema,
-  BooleanSchema,
-  NullSchema,
-  NumberSchema,
-  StringSchema,
-  UndefinedSchema,
-} from "./default-schema";
-describe("Default Schema Functions", () => {
-  describe("AnySchema", () => {
-    it("should return the data", () => {
-      expect(AnySchema(1)).toBe(1);
-    });
-  });
-
-  describe("StringSchema", () => {
-    it("should return the data", () => {
-      expect(StringSchema("1")).toBe("1");
-    });
-  });
-
-  describe("NumberSchema", () => {
-    it("should return the data", () => {
-      expect(NumberSchema(1)).toBe(1);
-    });
-
-    it("should return stringified data", () => {
-      expect(NumberSchema("1")).toBe(1);
-    });
-  });
-
-  describe("BooleanSchema", () => {
-    it("should return the data", () => {
-      expect(BooleanSchema(true)).toBe(true);
-    });
-
-    it("should return stringified data", () => {
-      expect(BooleanSchema("true")).toBe(true);
-    });
-  });
-
-  describe("NullSchema", () => {
-    it("should return the data", () => {
-      expect(NullSchema(null)).toBe(null);
-    });
-
-    it("should return the stringified data", () => {
-      expect(NullSchema("null")).toBe(null);
-    });
-
-    it("should throw if the data is not null", () => {
-      expect(() => NullSchema(1)).toThrow();
-    });
-
-    it("should throw if the data is not null", () => {
-      expect(() => NullSchema(undefined)).toThrow();
-    });
-  });
-
-  describe("UndefinedSchema", () => {
-    it("should return the data", () => {
-      expect(UndefinedSchema(undefined)).toBe(undefined);
-    });
-
-    it("should throw if the data is not undefined", () => {
-      expect(() => UndefinedSchema(1)).toThrow();
-    });
-
-    it("should throw if the data is not undefined", () => {
-      expect(() => UndefinedSchema(null)).toThrow();
-    });
-  });
-});

package/src/default-schema.ts

@@ -1,127 +0,0 @@
-import isJson from "@stdlib/assert-is-json";
-
-/**
- * Schema which does not care about data validation.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response does not matter.
- * @param data
- * @returns
- */
-export function AnySchema(data: unknown) {
-  return data;
-}
-
-/**
- * Schema which validates that a response is empty. This can mean
- * the data payload was `null`, `undefined` or the string `'null'`.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be null or not defined.
- * @param data
- * @returns
- */
-export function EmptySchema(data: unknown) {
-  if (data !== null && data !== undefined && data !== "null") {
-    throw new Error(`Expected null but got <${typeof data}> for ${data}`);
-  }
-  return data === "null" ? null : data;
-}
-
-/**
- * Schema which validates a response was null.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be null.
- * @param data
- * @returns
- */
-export function NullSchema(data: unknown) {
-  if (data !== null && data !== "null") {
-    throw new Error(`Expected null but got <${typeof data}> for ${data}`);
-  }
-  return null;
-}
-
-/**
- * Schema which validates a response was undefined.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be undefined.
- *
- * @param data
- * @returns
- */
-export function UndefinedSchema(data: unknown) {
-  if (data !== undefined) {
-    throw new Error(`Expected undefined but got <${typeof data}> for ${data}`);
-  }
-  return undefined;
-}
-
-/**
- * Schema which validates a response was a boolean, or a string of value
- * `'true'` or `'false'`.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be a boolean.
- *
- * @param data
- * @returns
- */
-export function BooleanSchema(data: unknown) {
-  if (
-    !(typeof data === "boolean") &&
-    ["true", "false"].includes(String(data)) === false
-  ) {
-    throw new Error(`Expected boolean but got <${typeof data}> for ${data}`);
-  }
-  return JSON.parse(data as string);
-}
-
-/**
- * Schema which validates a response was a number, or a string of value
- * of a number.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be a number.
- *
- * @param data
- * @returns
- */
-export function NumberSchema(data: unknown) {
-  if (
-    !(typeof data === "number") &&
-    /^\d*\.?\d+$/.test(String(data)) === false
-  ) {
-    throw new Error(`Expected number but got <${typeof data}> for ${data}`);
-  }
-  return JSON.parse(data as string);
-}
-
-/**
- * Schema which validates a response was a string.
- *
- * Useful if `requireSchema` is set to true, but a specific
- * endpoints response should be a string.
- *
- * @param data
- * @returns
- */
-export function StringSchema(data: unknown) {
-  if (typeof data !== "string") {
-    throw new Error(`Expected string but got <${typeof data}> for ${data}`);
-  }
-  return data;
-}
-
-export function JSONSchema<T = unknown>(data: unknown) {
-  if (typeof data === "object") {
-    return data as T;
-  }
-  if (!isJson(data)) {
-    throw new Error(`Expected JSON but got <${typeof data}> for ${data}`);
-  }
-  const result = JSON.parse(data);
-  return result;
-}

package/src/http-client.ts

@@ -1,20 +0,0 @@
-import { HTTPRequest } from "./http-request";
-import { HTTPResponse } from "./http-response";
-import { HTTPAdditionalOptions } from "./types";
-import { Class } from "@autometa/types";
-export let defaultClient: Class<HTTPClient>;
-export abstract class HTTPClient {
-  static Use(): (target: Class<HTTPClient>) => void;
-  static Use(client?: Class<HTTPClient>) {
-    if (client) {
-      defaultClient = client;
-    }
-    return function (target: Class<HTTPClient>) {
-      defaultClient = target;
-    };
-  }
-  abstract request<TRequestType, TResponseType>(
-    request: HTTPRequest<TRequestType>,
-    options?: HTTPAdditionalOptions<unknown>
-  ): Promise<HTTPResponse<TResponseType>>;
-}

package/src/http-request.spec.ts

@@ -1,172 +0,0 @@
-import { describe, expect, it } from "vitest";
-import { HTTPRequest, HTTPRequestBuilder } from "./http-request";
-
-describe("HTTP Request", () => {
-  it("should derive a detailed request", () => {
-    const request = new HTTPRequest();
-    request.baseUrl = "https://example.com";
-    request.route.push("foo", "bar");
-    request.params = { foo: "bar" };
-    request.data = { foo: "bar" };
-    request.headers = { foo: "bar" };
-    request.method = "GET";
-
-    const derived = HTTPRequest.derive(request);
-    expect(derived).toEqual({
-      baseUrl: "https://example.com",
-      route: ["foo", "bar"],
-      params: { foo: "bar" },
-      data: { foo: "bar" },
-      headers: { foo: "bar" },
-      method: "GET",
-    });
-  });
-
-  describe("HTTPRequestBuilder", () => {
-    it("should build a request from a base", () => {
-      const request = new HTTPRequest();
-      request.baseUrl = "https://example.com";
-      request.route.push("foo", "bar");
-      request.params = { foo: "bar" };
-      request.data = { foo: "bar" };
-      request.headers = { foo: "bar" };
-      request.method = "GET";
-      const builder = new HTTPRequestBuilder(request);
-      expect(builder.request).toEqual(request);
-    });
-
-    it("should build a request from scratch", () => {
-      const builder = new HTTPRequestBuilder()
-        .url("https://example.com")
-        .route("foo", "bar")
-        .param("foo", "bar")
-        .data({ foo: "bar" })
-        .header("foo", "bar")
-        .method("GET");
-      expect(builder.request).toEqual({
-        baseUrl: "https://example.com",
-        route: ["foo", "bar"],
-        params: { foo: "bar" },
-        data: { foo: "bar" },
-        headers: { foo: "bar" },
-        method: "GET",
-      });
-    });
-
-    it("should derive a request builder", () => {
-      const builder = new HTTPRequestBuilder()
-        .url("https://example.com")
-        .route("foo", "bar")
-        .param("foo", "bar")
-        .data({ foo: "bar" })
-        .header("foo", "bar")
-        .method("GET");
-      const derived = builder.derive();
-      expect(derived.request).toEqual(builder.request);
-      expect(derived.request).not.toBe(builder.request);
-    });
-
-    describe("build", () => {
-      it("should build a request", () => {
-        const request = new HTTPRequestBuilder()
-          .url("https://example.com")
-          .route("foo", "bar")
-          .param("foo", "bar")
-          .data({ foo: "bar" })
-          .header("foo", "bar")
-          .method("GET")
-          .build();
-        expect(request).toEqual({
-          baseUrl: "https://example.com",
-          route: ["foo", "bar"],
-          params: { foo: "bar" },
-          data: { foo: "bar" },
-          headers: { foo: "bar" },
-          method: "GET",
-        });
-      });
-    });
-
-    describe("paramList", () => {
-      it("should build a request with a list of params", () => {
-        const request = new HTTPRequestBuilder()
-          .url("https://example.com")
-          .route("foo", "bar")
-          .param("foo", ["bar", "baz"])
-          .data({ foo: "bar" })
-          .header("foo", "bar")
-          .method("GET")
-          .build();
-        expect(request).toEqual({
-          baseUrl: "https://example.com",
-          route: ["foo", "bar"],
-          params: { foo: ["bar", "baz"] },
-          data: { foo: "bar" },
-          headers: { foo: "bar" },
-          method: "GET",
-        });
-      });
-    });
-
-    describe("fullUrl", () => {
-      it("should have a full url with routes", () => {
-        const request = new HTTPRequestBuilder()
-          .url("https://example.com")
-          .route("foo")
-          .build().fullUrl;
-        expect(request).toEqual("https://example.com/foo");
-      });
-      it("should have a full url with routes and params", () => {
-        const request = new HTTPRequestBuilder()
-          .url("https://example.com")
-          .route("foo")
-          .param("gru", "bar")
-          .build().fullUrl;
-        expect(request).toEqual("https://example.com/foo?gru=bar");
-      });
-
-      it("should have a full url with a route and a param list", () => {
-        const request = new HTTPRequestBuilder()
-          .url("https://example.com")
-          .route("foo")
-          .param("bob", ["bar", "baz"])
-          .build().fullUrl;
-        expect(request).toEqual("https://example.com/foo?bob=bar%2Cbaz");
-      });
-    });
-  });
-
-  describe("dynamic header", () => {
-    it("should resolve a synchronous dynamic header", async () => {
-      const builder = new HTTPRequestBuilder()
-        .url("https://example.com")
-        .route("foo", "bar")
-        .param("foo", "bar")
-        .data({ foo: "bar" })
-        .header("foo", "bar")
-        .header("dynamic", () => "foo")
-        .method("GET");
-      await builder.resolveDynamicHeaders();
-      expect(builder.request.headers).toEqual({
-        foo: "bar",
-        dynamic: "foo",
-      });
-    });
-
-    it("should resolve an asynchronous dynamic header", async () => {
-      const builder = new HTTPRequestBuilder()
-        .url("https://example.com")
-        .route("foo", "bar")
-        .param("foo", "bar")
-        .data({ foo: "bar" })
-        .header("foo", "bar")
-        .header("dynamic", async () => "foo")
-        .method("GET");
-      await builder.resolveDynamicHeaders();
-      expect(builder.request.headers).toEqual({
-        foo: "bar",
-        dynamic: "foo",
-      });
-    });
-  });
-});

package/src/http-request.ts

@@ -1,201 +0,0 @@
-import { RequestConfig, RequestConfigBasic } from "./request.config";
-import { HTTPMethod } from "./types";
-import { urlJoinP } from "url-join-ts";
-export class HTTPRequest<T = unknown> implements RequestConfig<T> {
-  headers: Record<string, string> = {};
-  params: Record<string, string | string[] | Record<string, unknown>> = {};
-  baseUrl?: string;
-  route: string[] = [];
-  method: HTTPMethod;
-  data: T;
-
-  constructor(config?: RequestConfigBasic) {
-    Object.assign(this, config);
-  }
-
-  /**
-   * Returns the full URL of the request, including the base url,
-   * routes, and query parameters.
-   *
-   * ```ts
-   *  console.log(request.fullUrl())// https://example.com/foo?bar=baz?array=1,2,3
-   * ```
-   *
-   * Note characters may be converted to escape codes. I.e (space => %20) and (comma => %2C)
-   *
-   * N.B this getter estimates what the url will be. The actual value
-   * might be different depending on your underlying HTTPClient and
-   * configuration. For example, query parameters might
-   * use different array formats.
-   */
-  get fullUrl() {
-    return urlJoinP(this.baseUrl, this.route, this.params);
-  }
-
-  /**
-   * Returns a new independent copy of the request.
-   */
-  static derive(original: HTTPRequest<unknown>) {
-    const request = new HTTPRequest();
-    request.headers = { ...original.headers };
-    request.params = { ...original.params };
-    request.baseUrl = original.baseUrl;
-    request.route = [...original.route];
-    request.method = original.method;
-    request.data = original.data;
-    return request;
-  }
-}
-
-export class HTTPRequestBuilder<T extends HTTPRequest<unknown>> {
-  #request: T;
-  #dynamicHeaders = new Map<
-    string,
-    | (() => string | number | boolean | null)
-    | (() => Promise<string | number | boolean | null>)
-  >();
-
-  constructor(request: T | (() => T) = () => new HTTPRequest() as T) {
-    if (typeof request === "function") {
-      this.#request = request();
-      return;
-    }
-    this.#request = request;
-  }
-
-  static create<T extends HTTPRequest<unknown>>() {
-    return new HTTPRequestBuilder<T>();
-  }
-
-  get request() {
-    return this.#request;
-  }
-
-  async resolveDynamicHeaders(
-    request: HTTPRequest<T> = this.#request as HTTPRequest<T>
-  ) {
-    for (const [name, value] of this.#dynamicHeaders) {
-      try {
-        if (!request.headers) request.headers = {};
-        request.headers[name] = String(await value());
-      } catch (e) {
-        const cause = e as Error;
-        const msg = `Failed to resolve dynamic header "${name}": 
-${cause}`;
-        throw new Error(msg);
-      }
-    }
-    return this;
-  }
-
-  url(url: string) {
-    this.#request.baseUrl = url;
-    return this;
-  }
-
-  route(...route: string[]) {
-    this.#request.route.push(...route);
-    return this;
-  }
-
-  param(
-    name: string,
-    value:
-      | string
-      | number
-      | boolean
-      | (string | number | boolean)[]
-      | Record<string, string | number | boolean>
-  ) {
-    if (Array.isArray(value)) {
-      const asStr = value.flatMap(String);
-      this.#request.params[name] = asStr;
-      return this;
-    }
-    if (!Array.isArray(value) && typeof value === "object") {
-      this.#request.params[name] = value;
-      return this;
-    }
-    this.#request.params[name] = String(value);
-    return this;
-  }
-
-  params(dict: Record<string, unknown>) {
-    Object.assign(this.#request.params, dict);
-    return this;
-  }
-
-  data<T>(data: T) {
-    this.#request.data = data;
-    return this;
-  }
-
-  header(
-    name: string,
-    value:
-      | string
-      | number
-      | boolean
-      | null
-      | (string | number | boolean)[]
-      | (() => string | number | boolean | null)
-      | (() => Promise<string | number | boolean | null>),
-    onArray: (value: (string | number | boolean)[]) => string = (value) =>
-      value.join(",")
-  ) {
-    if (typeof value === "function") {
-      if (this.#request.headers[name]) {
-        delete this.#request.headers[name];
-      }
-      this.#dynamicHeaders.set(name, value);
-      return this;
-    }
-    if (this.#dynamicHeaders.has(name)) {
-      this.#dynamicHeaders.delete(name);
-    }
-    const val = Array.isArray(value) ? onArray(value) : String(value);
-    this.#request.headers[name] = val;
-    return this;
-  }
-
-  headers(dict: Record<string, string>) {
-    Object.assign(this.#request.headers, dict);
-    return this;
-  }
-
-  get() {
-    return this.#request;
-  }
-
-  method(method: HTTPMethod) {
-    this.#request.method = method;
-    return this;
-  }
-
-  #setDynamicHeaders(
-    headers: Map<
-      string,
-      | (() => string | number | boolean | null)
-      | (() => Promise<string | number | boolean | null>)
-    >
-  ) {
-    this.#dynamicHeaders = new Map(headers);
-    return this;
-  }
-
-  derive(): HTTPRequestBuilder<T> {
-    const request = HTTPRequest.derive(this.#request);
-    return new HTTPRequestBuilder(request).#setDynamicHeaders(
-      this.#dynamicHeaders
-    ) as HTTPRequestBuilder<T>;
-  }
-
-  build(): HTTPRequest<T> {
-    return this.#request as HTTPRequest<T>;
-  }
-
-  async buildAsync(): Promise<HTTPRequest<T>> {
-    await this.resolveDynamicHeaders();
-    return this.#request as HTTPRequest<T>;
-  }
-}