@autometa/http 1.4.20 → 2.0.0-rc.0

package/src/index.ts

@@ -1,13 +0,0 @@
-export * from "./axios-client";
-export * from "./http-client";
-export * from "./http";
-export * from "./http-request";
-export * from "./http-response";
-export * from "./default-schema";
-export type {
-  HTTPAdditionalOptions,
-  HTTPMethod,
-  SchemaParser,
-  RequestHook,
-  ResponseHook,
-} from "./types";

package/src/node_modules/.vitest/deps/_metadata.json

@@ -1,8 +0,0 @@
-{
-  "hash": "e5d6b890",
-  "configHash": "0f868888",
-  "lockfileHash": "aa4bef81",
-  "browserHash": "892900c3",
-  "optimized": {},
-  "chunks": {}
-}

package/src/node_modules/.vitest/deps/package.json

@@ -1,3 +0,0 @@
-{
-  "type": "module"
-}

package/src/node_modules/.vitest/results.json

@@ -1 +0,0 @@
-{"version":"0.34.6","results":[[":schema.map.spec.ts",{"duration":0,"failed":false}],[":http-request.spec.ts",{"duration":0,"failed":false}],[":default-client-factory.other.spec.ts",{"duration":0,"failed":false}],[":request-meta.config.spec.ts",{"duration":0,"failed":false}],[":default-schema.spec.ts",{"duration":0,"failed":false}],[":default-client-factory.axios.spec.ts",{"duration":0,"failed":false}],[":http.spec.ts",{"duration":16,"failed":false}],[":axios-executor.spec.ts",{"duration":6,"failed":false}],[":transform-response.spec.ts",{"duration":17,"failed":false}],[":http.builder.spec.ts",{"duration":10,"failed":false}],[":http.request.spec.ts",{"duration":10,"failed":false}]]}

package/src/request-meta.config.spec.ts

@@ -1,81 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { MetaConfigBuilder } from "./request-meta.config";
-
-describe(MetaConfigBuilder.name, () => {
-  describe("adding schema mapping", () => {
-    it("should add a schema mapping", () => {
-      const parser = { parse: <T>(data: T) => data };
-      const config = new MetaConfigBuilder().schema(parser, 200).build();
-      expect(config.schemas.toObject()).toEqual({ 200: parser });
-    });
-
-    it("should multiple schema mappings", () => {
-      const parser = { parse: <T>(data: T) => data };
-      const config = new MetaConfigBuilder()
-        .schema(parser, 200)
-        .schema(parser, 201)
-        .build();
-      expect(config.schemas.toObject()).toEqual({ 200: parser, 201: parser });
-    });
-
-    it("should add multiple range based schema mappings", () => {
-      const parser = { parse: <T>(data: T) => data };
-      const config = new MetaConfigBuilder()
-        .schema(parser, { from: 200, to: 202 })
-        .build();
-      expect(config.schemas.toObject()).toEqual({
-        200: parser,
-        201: parser,
-        202: parser,
-      });
-    });
-  });
-
-  describe('adding "onBeforeSend" hooks', () => {
-    it("adding a before send hook", () => {
-      const hook = () => undefined;
-      const config = new MetaConfigBuilder().onBeforeSend("hook", hook).build();
-      expect(config.onSend).toEqual([["hook", hook]]);
-    });
-
-    it("adding multiple before send hooks", () => {
-      const hook = () => undefined;
-      const config = new MetaConfigBuilder().onBeforeSend("hook", hook).build();
-      expect(config.onSend).toEqual([["hook", hook]]);
-    });
-  });
-
-  describe('adding "onReceiveResponse" hooks', () => {
-    it("adding a before send hook", () => {
-      const hook = () => undefined;
-      const config = new MetaConfigBuilder()
-        .onReceiveResponse("hook", hook)
-        .build();
-      expect(config.onReceive).toEqual([["hook", hook]]);
-    });
-
-    it("adding multiple before send hooks", () => {
-      const hook = () => undefined;
-      const config = new MetaConfigBuilder()
-        .onReceiveResponse("hook", hook)
-        .build();
-      expect(config.onReceive).toEqual([["hook", hook]]);
-    });
-  });
-
-  describe("deriving a request meta config", () => {
-    it("should derive a config with the same values", () => {
-      const parser = { parse: <T>(data: T) => data };
-      const hook = () => undefined;
-      const configBuilder = new MetaConfigBuilder()
-        .schema(parser, 200)
-        .onBeforeSend("send", hook)
-        .onReceiveResponse("receive", hook);
-      const original = configBuilder.build();
-      const derived = configBuilder.derive().build();
-      expect(derived.schemas).toEqual(original.schemas);
-      expect(derived.onSend).toEqual(original.onSend);
-      expect(derived.onReceive).toEqual(original.onReceive);
-    });
-  });
-});

package/src/request-meta.config.ts

@@ -1,134 +0,0 @@
-import { SchemaMap } from "./schema.map";
-import {
-  HTTPAdditionalOptions,
-  RequestHook,
-  ResponseHook,
-  SchemaParser,
-  StatusCode,
-} from "./types";
-
-export interface SchemaConfig {
-  schemas: SchemaMap;
-  requireSchema: boolean;
-  allowPlainText: boolean;
-}
-
-export interface HTTPHooks {
-  onSend: [string, RequestHook][];
-  onReceive: [string, ResponseHook<unknown>][];
-}
-
-// export type MetaConfig = SchemaConfig & HTTPHooks;
-
-export class MetaConfig implements SchemaConfig, HTTPHooks {
-  schemas: SchemaMap;
-  requireSchema: boolean;
-  allowPlainText: boolean;
-  onSend: [string, RequestHook][] = [];
-  onReceive: [string, ResponseHook<unknown>][] = [];
-  throwOnServerError: boolean;
-  options: HTTPAdditionalOptions<unknown> = {};
-}
-
-export class MetaConfigBuilder {
-  #schemaMap = new SchemaMap();
-  #requireSchema = false;
-  #allowPlainText = false;
-  #onBeforeSend: [string, RequestHook][] = [];
-  #onAfterSend: [string, ResponseHook<unknown>][] = [];
-  #throwOnServerError = false;
-  #options: HTTPAdditionalOptions<unknown> = {};
-
-  options(options: HTTPAdditionalOptions<unknown>) {
-    this.#options = { ...options };
-    return this;
-  }
-  schemaMap(map: SchemaMap) {
-    this.#schemaMap = map;
-    return this;
-  }
-
-  schema(parser: SchemaParser, ...codes: StatusCode[]): MetaConfigBuilder;
-  schema(
-    parser: SchemaParser,
-    ...range: { from: StatusCode; to: StatusCode }[]
-  ): MetaConfigBuilder;
-  schema(
-    parser: SchemaParser,
-    ...args: (StatusCode | { from: StatusCode; to: StatusCode })[]
-  ): MetaConfigBuilder;
-  schema(
-    parser: SchemaParser,
-    ...args: (StatusCode | { from: StatusCode; to: StatusCode })[]
-  ) {
-    args.forEach((arg) => {
-      if (typeof arg === "number") {
-        this.#schemaMap.registerStatus(parser, arg);
-      } else if (Array.isArray(arg)) {
-        this.#schemaMap.registerStatus(parser, ...arg);
-      } else {
-        this.#schemaMap.registerRange(parser, arg.from, arg.to);
-      }
-    });
-
-    return this;
-  }
-
-  requireSchema(value: boolean) {
-    this.#requireSchema = value;
-    return this;
-  }
-
-  allowPlainText(value: boolean) {
-    this.#allowPlainText = value;
-    return this;
-  }
-
-  onBeforeSend(description: string, hook: RequestHook) {
-    this.#onBeforeSend.push([description, hook]);
-    return this;
-  }
-
-  #setOnSend(hooks: [string, RequestHook][]) {
-    this.#onBeforeSend = [...hooks];
-    return this;
-  }
-
-  throwOnServerError(value: boolean) {
-    this.#throwOnServerError = value;
-    return this;
-  }
-
-  onReceiveResponse(description: string, hook: ResponseHook<unknown>) {
-    this.#onAfterSend.push([description, hook]);
-    return this;
-  }
-
-  #setOnReceive(hooks: [string, ResponseHook<unknown>][]) {
-    this.#onAfterSend = [...hooks];
-    return this;
-  }
-
-  build() {
-    const config = new MetaConfig();
-    config.schemas = this.#schemaMap.derive();
-    config.requireSchema = this.#requireSchema;
-    config.allowPlainText = this.#allowPlainText;
-    config.onSend = this.#onBeforeSend;
-    config.onReceive = this.#onAfterSend;
-    config.options = this.#options;
-    config.throwOnServerError = this.#throwOnServerError;
-    return config;
-  }
-
-  derive() {
-    return new MetaConfigBuilder()
-      .schemaMap(this.#schemaMap.derive())
-      .requireSchema(this.#requireSchema)
-      .allowPlainText(this.#allowPlainText)
-      .throwOnServerError(this.#throwOnServerError)
-      .options(this.#options)
-      .#setOnSend(this.#onBeforeSend)
-      .#setOnReceive(this.#onAfterSend);
-  }
-}

package/src/request.config.ts

@@ -1,34 +0,0 @@
-import { HTTPMethod } from "./types";
-
-export interface RequestBaseConfig {
-  headers?: Record<string, string>;
-  params?: Record<string, string | string[] | Record<string, unknown>>;
-  baseUrl?: string;
-  route?: string[];
-  method: HTTPMethod;
-  /**
-   * 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 method 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.
-   * @returns The full url of the request
-   */
-  get fullUrl(): string;
-}
-
-export interface RequestData<T = unknown> {
-  data: T;
-}
-
-export type RequestConfig<T> = RequestBaseConfig & RequestData<T>;
-
-export type RequestConfigBasic = RequestConfig<Record<string, unknown>>;

package/src/schema.map.spec.ts

@@ -1,50 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { SchemaMap } from "./schema.map";
-
-describe("SchemaMap", () => {
-  describe("register", () => {
-    describe("single status", () => {
-      it("should register a single status code", () => {
-        const map = new SchemaMap();
-        const parser = { parse: (data: unknown) => data };
-        map.registerStatus(parser, 200);
-        const retrieved = map.getParser(200, false);
-        expect(retrieved).toBe(parser);
-      });
-
-      it("should throw if the status code is already registered", () => {
-        const map = new SchemaMap();
-        const parser = { parse: <T>(data: T) => data };
-        map.registerStatus(parser, 200);
-        expect(() => map.registerStatus(parser, 200)).toThrow();
-      });
-    });
-
-    describe("range of statuses", () => {
-      it("should register a range of statuses", () => {
-        const map = new SchemaMap();
-        const parser = { parse: <T>(data: T) => data };
-        map.registerRange(parser, 200, 202);
-        const retrieved = map.getParser(200, false);
-        expect(retrieved).toBe(parser);
-      });
-
-      it("should throw if the status code is already registered", () => {
-        const map = new SchemaMap();
-        const parser = { parse: <T>(data: T) => data };
-        map.registerRange(parser, 200, 202);
-        expect(() => map.registerRange(parser, 200, 202)).toThrow();
-      });
-    });
-
-    describe("derive", () => {
-      it("should return a new map with the same values", () => {
-        const map = new SchemaMap();
-        const parser = { parse: <T>(data: T) => data };
-        map.registerRange(parser, 200, 202);
-        const derived = map.derive();
-        expect(derived.getParser(200, false)).toBe(parser);
-      });
-    });
-  });
-});

package/src/schema.map.ts

@@ -1,68 +0,0 @@
-import { SchemaParser, StatusCode } from "./types";
-export class SchemaMap {
-  #map: Map<StatusCode, SchemaParser>;
-  constructor(map?: Map<StatusCode, SchemaParser> | SchemaMap) {
-    if (map instanceof SchemaMap) {
-      this.#map = new Map(map.#map);
-      return;
-    }
-    this.#map = new Map(map);
-  }
-
-  derive() {
-    return new SchemaMap(this.#map);
-  }
-
-  registerStatus(parser: SchemaParser, ...codes: StatusCode[]) {
-    codes.forEach((code) => {
-      if (this.#map.has(code)) {
-        const msg = `Status code ${code} is already registered with a parser`;
-        throw new Error(msg);
-      }
-      this.#map.set(code, parser);
-    });
-  }
-
-  registerRange(parser: SchemaParser, from: StatusCode, to: StatusCode) {
-    for (let i = from; i <= to; i++) {
-      if (this.#map.has(i)) {
-        throw new Error(`Status code ${i} is already registered with a parser`);
-      }
-      this.#map.set(i, parser);
-    }
-  }
-
-  validate(status: StatusCode, data: unknown, requireSchema: boolean) {
-    const parser = this.getParser(status, requireSchema);
-    if ("parse" in parser) {
-      return parser.parse(data);
-    }
-    if ("validate" in parser) {
-      return parser.validate(data);
-    }
-    try {
-      return parser(data);
-    } catch (e) {
-      const msg = `Failed to schema parse response data for status code ${status} with data:
-      
-${JSON.stringify(data, null, 2)}}`;
-      throw new Error(msg);
-    }
-  }
-
-  getParser(status: StatusCode, requireSchema: boolean) {
-    const parser = this.#map.get(status);
-    if (!parser && requireSchema) {
-      const msg = `No parser registered for status code ${status} but 'requireSchema' is true`;
-      throw new Error(msg);
-    }
-    if (parser) {
-      return parser;
-    }
-    return (data: unknown) => data;
-  }
-
-  toObject() {
-    return Object.fromEntries(this.#map) as Record<StatusCode, SchemaParser>;
-  }
-}

package/src/transform-response.ts

@@ -1,43 +0,0 @@
-import { AutomationError } from "@autometa/errors";
-import isJson from "@stdlib/assert-is-json";
-import { highlight } from "cli-highlight";
-
-export function transformResponse(
-  allowPlainText: boolean,
-  data: null | undefined | string
-) {
-  if (data === null) {
-    return null;
-  }
-  if (data === undefined) {
-    return undefined;
-  }
-  if (data === "") {
-    return data;
-  }
-  if (isJson(data)) {
-    return JSON.parse(data);
-  }
-  if (typeof data === "string" && ["true", "false"].includes(data)) {
-    return JSON.parse(data);
-  }
-  if (typeof data === "string" && /^\d*\.?\d+$/.test(data)) {
-    return JSON.parse(data);
-  }
-
-  if (typeof data === "object") {
-    return data;
-  }
-  if (allowPlainText) {
-    return data;
-  }
-  const dataStr = typeof data === "string" ? data : JSON.stringify(data);
-  const response = highlight(dataStr, { language: "html" });
-  const message = [
-    `Could not parse a response as json, and this request was not configured to allow plain text responses.`,
-    `To allow plain text responses, use the 'allowPlainText' method on the HTTP client.`,
-    "",
-    response,
-  ];
-  throw new AutomationError(message.join("\n"));
-}

package/src/types.ts

@@ -1,37 +0,0 @@
-import type { StatusCodes } from "@autometa/status-codes";
-import type { HTTPResponse } from "./http-response";
-import type { HTTPRequest } from "./http-request";
-export type HTTPMethod =
-  | "GET"
-  | "POST"
-  | "PUT"
-  | "DELETE"
-  | "PATCH"
-  | "HEAD"
-  | "OPTIONS"
-  | "TRACE"
-  | "CONNECT"
-  | "get"
-  | "post"
-  | "put"
-  | "delete"
-  | "patch"
-  | "head"
-  | "options"
-  | "trace"
-  | "connect";
-
-export type HTTPAdditionalOptions<T> = {
-  [P in keyof T]: T[P];
-};
-export type SchemaParser =
-  | { parse: (data: unknown) => unknown }
-  | { validate: (data: unknown) => unknown }
-  | ((data: unknown) => unknown);
-
-export type StatusCode<T extends typeof StatusCodes = typeof StatusCodes> = {
-  [P in keyof T]: T[P] extends { status: infer U } ? U : never;
-}[keyof T];
-
-export type RequestHook = <T = unknown>(state: HTTPRequest<T>) => unknown;
-export type ResponseHook<T> = (state: HTTPResponse<T>) => unknown;

package/tsup.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from "tsup";
-
-export default defineConfig({
-  clean: true, // clean up the dist folder
-  format: ["cjs", "esm"], // generate cjs and esm files
-  dts: true,
-  sourcemap: true, // generate sourcemaps
-  skipNodeModulesBundle: true,
-  entryPoints: ["src/index.ts"],
-  target: "es2020",
-  outDir: "dist",
-  legacyOutput: true,
-  external: ["dist"],
-});