@basmilius/http-client 1.13.0 → 2.2.0

package/src/http/HttpClient.ts

@@ -0,0 +1,41 @@
+export default class HttpClient {
+    get authToken(): string | null {
+        return this.#authToken;
+    }
+
+    set authToken(value: string | null) {
+        this.#authToken = value;
+    }
+
+    get baseUrl(): string {
+        return this.#baseUrl;
+    }
+
+    get dataField(): boolean {
+        return this.#dataField;
+    }
+
+    #authToken: string | null;
+    readonly #baseUrl: string;
+    readonly #dataField: boolean;
+
+    constructor(authToken: string | null, baseUrl: string, dataField: boolean = false) {
+        this.#authToken = authToken;
+        this.#baseUrl = baseUrl;
+        this.#dataField = dataField;
+    }
+
+    static get instance(): HttpClient {
+        if (HttpClient.#instance === null) {
+            throw new Error('There is currently no HttpClient instance registered. Register one using the HttpClient.register() function.');
+        }
+
+        return HttpClient.#instance;
+    }
+
+    static #instance: HttpClient | null = null;
+
+    static register(client: HttpClient): void {
+        HttpClient.#instance = client;
+    }
+}

package/src/http/QueryString.ts

@@ -0,0 +1,75 @@
+export default class QueryString {
+    readonly #builder: URLSearchParams;
+
+    constructor() {
+        this.#builder = new URLSearchParams();
+    }
+
+    public build(): string {
+        return this.#builder.toString();
+    }
+
+    public append(name: string, value: QueryStringValue): QueryString {
+        return this.#add(this.#builder.append.bind(this.#builder), name, value);
+    }
+
+    public appendArray(name: string, values: QueryStringValue[] | null): QueryString {
+        if (values === undefined || values === null) {
+            return this;
+        }
+
+        values.forEach(value => this.append(name, value));
+
+        return this;
+    }
+
+    public delete(name: string): QueryString {
+        this.#builder.delete(name);
+
+        return this;
+    }
+
+    public get(name: string): string | null {
+        return this.#builder.get(name);
+    }
+
+    public getAll(name: string): string[] {
+        return this.#builder.getAll(name);
+    }
+
+    public has(name: string): boolean {
+        return this.#builder.has(name);
+    }
+
+    public set(name: string, value: QueryStringValue): QueryString {
+        return this.#add(this.#builder.set.bind(this.#builder), name, value);
+    }
+
+    #add(fn: ((name: string, value: string) => void), name: string, value: QueryStringValue): QueryString {
+        if (!value && value !== false) {
+            return this;
+        }
+
+        switch (typeof value) {
+            case 'boolean':
+                fn(name, value ? 'true' : 'false');
+                break;
+
+            case 'number':
+                fn(name, value.toString(10));
+                break;
+
+            case 'string':
+                fn(name, value);
+                break;
+        }
+
+        return this;
+    }
+
+    public static builder(): QueryString {
+        return new QueryString();
+    }
+}
+
+type QueryStringValue = boolean | number | string | null;

package/src/http/RequestBuilder.ts

@@ -0,0 +1,222 @@
+import { DateTime } from 'luxon';
+import { HttpAdapter } from '../adapter';
+import { BlobResponse, Paginated, RequestError } from '../dto';
+import type { HttpMethod, HttpStatusCode } from '../type';
+import BaseResponse from './BaseResponse';
+import HttpClient from './HttpClient';
+import type QueryString from './QueryString';
+
+export default class RequestBuilder {
+    get client(): HttpClient {
+        return this.#client;
+    }
+
+    get options(): RequestInit {
+        return this.#options;
+    }
+
+    get path(): string {
+        return this.#path;
+    }
+
+    set path(value: string) {
+        this.#path = value;
+    }
+
+    get query(): QueryString | null {
+        return this.#query;
+    }
+
+    set query(value: QueryString | null) {
+        this.#query = value;
+    }
+
+    readonly #client: HttpClient;
+    #path: string;
+    #options: RequestInit = {};
+    #query: QueryString | null = null;
+
+    constructor(path: string, client?: HttpClient) {
+        this.#client = client ?? HttpClient.instance;
+        this.#options.cache = 'no-cache';
+        this.#options.method = 'GET';
+        this.#path = path;
+    }
+
+    public bearerToken(token?: string): RequestBuilder {
+        token = token ?? this.#client.authToken;
+
+        if (token) {
+            return this.header('Authorization', `Bearer ${token}`);
+        }
+
+        if (this.#options.headers && 'Authorization' in this.#options.headers) {
+            delete this.#options.headers['Authorization'];
+        }
+
+        return this;
+    }
+
+    public body(body: BodyInit | FormData | object | null, contentType: string | null = 'application/octet-stream'): RequestBuilder {
+        if (body instanceof FormData) {
+            // note: this allows browsers to set formdata with their custom boundary.
+            contentType = null;
+        } else if (Array.isArray(body) || typeof body === 'object') {
+            body = JSON.stringify(body);
+            contentType = 'application/json';
+        }
+
+        this.#options.body = body;
+
+        if (contentType !== null) {
+            return this.header('Content-Type', contentType);
+        }
+
+        return this;
+    }
+
+    public header(name: string, value: string): RequestBuilder {
+        this.#options.headers = this.#options.headers || {};
+        this.#options.headers[name] = value;
+
+        return this;
+    }
+
+    public method(method: HttpMethod): RequestBuilder {
+        this.#options.method = method.toUpperCase();
+
+        return this;
+    }
+
+    public queryString(queryString: QueryString): RequestBuilder {
+        this.#query = queryString;
+
+        return this;
+    }
+
+    public signal(signal: AbortSignal | null = null): RequestBuilder {
+        this.#options.signal = signal;
+
+        return this;
+    }
+
+    public async fetch<TResult>(): Promise<TResult> {
+        return this.#execute()
+            .then(r => r.json());
+    }
+
+    public async fetchBlob(): Promise<BlobResponse> {
+        let response = await this.#execute();
+
+        if (response.status !== 200) {
+            const data = await response.json();
+
+            if ('code' in data && 'error' in data && 'error_description' in data) {
+                throw new RequestError(data.code, data.error, data.error_description, response.status as HttpStatusCode);
+            }
+
+            throw new RequestError(-1, 'failed_without_info', 'Request failed without any information from the backend.', response.status as HttpStatusCode);
+        }
+
+        let filename = response.headers.has('content-disposition')
+            ? HttpAdapter.parseFileNameFromContentDispositionHeader(response.headers.get('content-disposition'))
+            : `download-${DateTime.now().toFormat('yyyy-MM-dd HH-mm-ss')}`;
+
+        return new BlobResponse(
+            await response.blob(),
+            filename
+        );
+    }
+
+    public async run<TResult extends {}>(): Promise<BaseResponse<TResult>> {
+        const {data, response} = await this.#executeSafe<TResult>();
+
+        return new BaseResponse(data, response);
+    }
+
+    public async runAdapter<TResult extends {}>(adapterMethod: (item: object) => TResult): Promise<BaseResponse<TResult>> {
+        const {data, response} = await this.#executeSafe<TResult>();
+
+        return new BaseResponse(adapterMethod(data), response);
+    }
+
+    public async runArrayAdapter<TResult extends {}>(adapterMethod: (item: object) => TResult): Promise<BaseResponse<TResult[]>> {
+        return this.runAdapter<TResult[]>((data: []) => data.map(adapterMethod));
+    }
+
+    public async runEmpty(): Promise<BaseResponse<never>> {
+        return await this.#executeSafe<never>();
+    }
+
+    public async runPaginatedAdapter<TResult extends {}>(adapterMethod: (item: object) => TResult): Promise<BaseResponse<Paginated<TResult>>> {
+        return this.runAdapter<Paginated<TResult>>(response => HttpAdapter.parsePaginatedAdapter(response, adapterMethod));
+    }
+
+    public async runData<TResult>(): Promise<BaseResponse<TResult>> {
+        return await this.#executeSafe<TResult>();
+    }
+
+    public async runDataKey<TResult extends object, TKey extends keyof TResult = keyof TResult>(key: TKey): Promise<BaseResponse<TResult[TKey]>> {
+        const {data, response} = await this.#executeSafe<TResult>();
+
+        return new BaseResponse(data[key] as TResult[TKey], response);
+    }
+
+    public async runStatusCode(): Promise<HttpStatusCode> {
+        const response = await this.#executeSafe<never>();
+
+        return response.statusCode;
+    }
+
+    async #execute(): Promise<Response> {
+        let path = this.path;
+
+        if (this.query !== null) {
+            path += `?${this.query.build()}`;
+        }
+
+        return await fetch(this.client.baseUrl + path, this.options);
+    }
+
+    async #executeSafe<TResult>(): Promise<BaseResponse<TResult>> {
+        return await this
+            .#execute()
+            .then(response => RequestBuilder.#handleResponse<TResult>(response, this.client.dataField));
+    }
+
+    static async #handleResponse<TResult>(response: Response, dataField: boolean): Promise<BaseResponse<TResult | null>> {
+        if (response.status === 204) {
+            return new BaseResponse(null, response);
+        }
+
+        if (response.headers.has('content-type') && response.headers.get('content-type').startsWith('application/json')) {
+            const data = await response.json();
+
+            if ('code' in data && 'error' in data && 'error_description' in data) {
+                if ('errors' in data) {
+                    throw HttpAdapter.parseValidationError(data);
+                }
+
+                throw HttpAdapter.parseRequestError(data, response.status as HttpStatusCode);
+            }
+
+            if (dataField && 'data' in data) {
+                return new BaseResponse(data.data as TResult, response);
+            }
+
+            return new BaseResponse(data, response);
+        }
+
+        if (response.status === 401 || response.status === 403) {
+            return new BaseResponse(null, response);
+        }
+
+        const data = await response.text();
+
+        if (data.length === 0 && response.status >= 200 && response.status < 300) {
+            return new BaseResponse(null, response);
+        }
+
+        throw new RequestError(-1, 'not_a_json_response', 'The response was not a JSON response.', response.status as HttpStatusCode);
+    }
+}

package/src/http/helpers.ts

@@ -0,0 +1,17 @@
+import { RequestError, ValidationError } from '../dto';
+
+export function isRequestError(obj: unknown): obj is RequestError {
+    return obj instanceof RequestError;
+}
+
+export function isUnsanctionedRequest(statusCode: unknown): boolean {
+    if (statusCode instanceof RequestError) {
+        statusCode = statusCode.statusCode;
+    }
+
+    return statusCode === 403 || statusCode === 401;
+}
+
+export function isValidationError(obj: unknown): obj is ValidationError {
+    return obj instanceof ValidationError;
+}

package/src/http/index.ts

@@ -0,0 +1,19 @@
+import BaseResponse from './BaseResponse';
+import BaseService from './BaseService';
+import HttpClient from './HttpClient';
+import QueryString from './QueryString';
+import RequestBuilder from './RequestBuilder';
+
+export {
+    BaseResponse,
+    BaseService,
+    HttpClient,
+    QueryString,
+    RequestBuilder
+};
+
+export {
+    isRequestError,
+    isUnsanctionedRequest,
+    isValidationError
+} from './helpers';

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './adapter';
+export * from './decorator';
+export * from './dto';
+export * from './http';
+export type * from './type';

package/src/type/index.ts

@@ -0,0 +1,74 @@
+export type HttpMethod =
+    | 'connect'
+    | 'delete'
+    | 'get'
+    | 'head'
+    | 'options'
+    | 'patch'
+    | 'post'
+    | 'put'
+    | 'trace';
+
+export type HttpStatusCode =
+    | 100 // continue
+    | 101 // switching protocols
+    | 102 // processing
+    | 200 // ok
+    | 201 // created
+    | 202 // accepted
+    | 203 // non authoritative information
+    | 204 // no content
+    | 205 // reset content
+    | 206 // partial content
+    | 207 // multi status
+    | 208 // already reported
+    | 226 // im used
+    | 300 // multiple choices
+    | 301 // moved permanently
+    | 302 // found
+    | 303 // see other
+    | 304 // not modified
+    | 305 // use proxy
+    | 306 // switch proxy
+    | 307 // temporary redirect
+    | 308 // permanent redirect
+    | 400 // bad request
+    | 401 // unauthorized
+    | 402 // payment required
+    | 403 // forbidden
+    | 404 // not found
+    | 405 // method not allowed
+    | 406 // not acceptable
+    | 407 // proxy authentication required
+    | 408 // request timeout
+    | 409 // conflict
+    | 410 // gone
+    | 411 // length required
+    | 412 // precondition failed
+    | 413 // payload too large
+    | 414 // uri too long
+    | 415 // unsupported media type
+    | 416 // range not satisfiable
+    | 417 // expectation failed
+    | 418 // i am a teapot
+    | 421 // misdirected request
+    | 422 // unprocessable entity
+    | 423 // locked
+    | 424 // failed dependency
+    | 426 // upgrade required
+    | 428 // precondition required
+    | 429 // too many requests
+    | 431 // request header fields too large
+    | 451 // unavailable for legal reasons
+    | 500 // internal server error
+    | 501 // not implemented
+    | 502 // bad gateway
+    | 503 // service unavailable
+    | 504 // gateway timeout
+    | 505 // http version not supported
+    | 506 // variant also negotiates
+    | 507 // insufficient storage
+    | 508 // loop detected
+    | 510 // not extended
+    | 511 // network authentication required
+    ;

package/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 Bas Milius
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.