web_lib

Common web application libraries
git clone https://radroots.dev/git/web_lib.git
Log | Files | Refs | LICENSE

web.ts (2865B)

      1 import {
      2     err_msg,
      3     handle_err,
      4     type ResolveError
      5 } from "@radroots/utils";
      6 import { cl_http_error } from "./error.js";
      7 import {
      8     http_fetch_opts,
      9     lib_http_parse_headers,
     10     lib_http_parse_response
     11 } from "./helpers.js";
     12 import type { IClientHttp, IHttpImageResponse, IHttpOpts, IHttpResponse, WebHttpConfig } from "./types.js";
     13 
     14 export interface IWebHttp extends IClientHttp { }
     15 
     16 export class WebHttp implements IWebHttp {
     17     private _headers: Headers;
     18 
     19     constructor(http_config?: WebHttpConfig) {
     20         try {
     21             const headers = new Headers({
     22                 "Accept": "application/json",
     23                 "Content-Type": "application/json"
     24             });
     25             if (http_config?.app_name) headers.set("X-Radroots-Client", http_config.app_name);
     26             if (http_config?.app_version) headers.set("X-Radroots-App-Version", http_config.app_version);
     27             if (http_config?.app_hash) headers.set("X-Radroots-App-Commit", http_config.app_hash);
     28             this._headers = headers;
     29         } catch {
     30             throw new Error(cl_http_error.init_failure);
     31         }
     32     }
     33 
     34     private apply_default_headers(headers: Headers): void {
     35         this._headers.forEach((value, key) => {
     36             if (!headers.has(key)) headers.set(key, value);
     37         });
     38     }
     39 
     40     public async fetch(opts: IHttpOpts): Promise<ResolveError<IHttpResponse>> {
     41         try {
     42             const { url, options } = http_fetch_opts(opts);
     43             if (options.headers instanceof Headers) this.apply_default_headers(options.headers);
     44             const response = await fetch(url, options);
     45             return lib_http_parse_response(response);
     46         } catch (e) {
     47             handle_err(e);
     48             return err_msg(cl_http_error.fetch_failure);
     49         };
     50     }
     51 
     52     public async fetch_image(url: string): Promise<ResolveError<IHttpImageResponse>> {
     53         try {
     54             const headers = new Headers(this._headers);
     55             const response = await fetch(url, {
     56                 method: "GET",
     57                 headers,
     58             });
     59             switch (response.ok) {
     60                 case true: {
     61                     const blob = await response.blob();
     62                     return {
     63                         status: response.status,
     64                         url: response.url,
     65                         blob,
     66                         headers: lib_http_parse_headers(response.headers)
     67                     };
     68                 }
     69                 case false: {
     70                     return {
     71                         status: response.status,
     72                         url: response.url,
     73                         headers: lib_http_parse_headers(response.headers)
     74                     };
     75                 }
     76             }
     77         } catch (e) {
     78             handle_err(e);
     79             return err_msg(cl_http_error.fetch_image_failure);
     80         };
     81     }
     82 }