@theshelf/http 0.1.0 → 0.2.1

package/README.md

@@ -9,74 +9,75 @@ The HTTP package provides a universal interaction layer with an HTTP client inpl
 npm install @theshelf/http
 ```
 
-## Implementations
+## Drivers
 
-Currently, there is only one implementation:
+Currently, there is only one driver available:
 
 * **Fetch** - Node.js fetch implementation.
 
-## Configuration
-
-The used implementation needs to be configured in the `.env` file.
-
-```env
-HTTP_IMPLEMENTATION="fetch"
-```
-
 ## How to use
 
-An instance of the configured HTTP client implementation can be imported for performing HTTP operations.
+The basic set up looks like this.
 
 ```ts
-import httpClient from '@theshelf/http';
+import Http, { FetchDriver as SelectedDriver } from '@theshelf/http';
 
-// Perform operations with the httpClient instance
+const driver = new SelectedDriver(/* configuration */);
+const http = new Http(driver);
+
+// Perform operations with the http instance
 ```
 
+### Configuration
+
+#### Fetch driver
+
+No configuration options.
+
 ### Operations
 
 ```ts
-import httpClient, { HTTP_METHODS } from '@theshelf/http';
+import { HTTP_METHODS } from '@theshelf/http';
 
 // Set a cached response
 const response: Response = new Response();
-httpClient.setCache(HTTP_METHODS.GET, url, response);
+http.setCache(HTTP_METHODS.GET, url, response);
 
 // Get a cached response
-const response: Response | undefined = httpClient.getCache(HTTP_METHODS.GET, url);
+const response: Response | undefined = http.getCache(HTTP_METHODS.GET, url);
 
 // Remove a cached response
-httpClient.removeCache(method: string, url: string)
+http.removeCache(HTTP_METHODS.GET, url)
 
 // Clear all cache
-httpClient.clearCache()
+http.clearCache()
 
 // Perform a GET request
-const response: Response = await httpClient.get(url);
+const response: Response = await http.get(url);
 
 // Perform a GET request with optional headers
 const headers: Record<string, string> = { 'Accept': 'application/json' };
-const response: Response = await httpClient.get(url, headers);
+const response: Response = await http.get(url, headers);
 
 // Perform a POST request with optional headers
 const headers: Record<string, string> = { 'Content-Type': 'application/json' };
-const response: Response = await httpClient.post(url, data, headers);
+const response: Response = await http.post(url, data, headers);
 
 // Perform a PUT request with optional headers
 const headers: Record<string, string> = { 'Content-Type': 'application/json' };
-const response: Response = await httpClient.put(url, data, headers);
+const response: Response = await http.put(url, data, headers);
 
 // Perform a PATCH request with optional headers
 const headers: Record<string, string> = { 'Content-Type': 'application/json' };
-const response: Response = await httpClient.patch(url, data, headers);
+const response: Response = await http.patch(url, data, headers);
 
 // Perform a DELETE request with optional headers
 const headers: Record<string, string> = { };
-const response: Response = await httpClient.delete(url, headers);
+const response: Response = await http.delete(url, headers);
 
 // Perform a HEAD request with optional headers
 const headers: Record<string, string> = { };
-const response: Response = await httpClient.head(url, headers);
+const response: Response = await http.head(url, headers);
 ```
 
 ### Response model

package/dist/{Client.d.ts → Http.d.ts}

@@ -1,7 +1,7 @@
-import type { Http } from './definitions/interfaces.js';
-export default class Memory implements Http {
+import type { Driver } from './definitions/interfaces.js';
+export default class Http implements Driver {
     #private;
-    constructor(implementation: Http);
+    constructor(driver: Driver);
     setCache(method: string, url: string, response: Response): void;
     getCache(method: string, url: string): Response | undefined;
     removeCache(method: string, url: string): void;

package/dist/Http.js

@@ -0,0 +1,50 @@
+import { HttpMethods } from './definitions/constants.js';
+export default class Http {
+    #driver;
+    #cache = new Map();
+    constructor(driver) {
+        this.#driver = driver;
+    }
+    setCache(method, url, response) {
+        const id = this.#createCacheId(method, url);
+        this.#cache.set(id, response);
+    }
+    getCache(method, url) {
+        const id = this.#createCacheId(method, url);
+        return this.#cache.get(id);
+    }
+    removeCache(method, url) {
+        const id = this.#createCacheId(method, url);
+        this.#cache.delete(id);
+    }
+    clearCache() {
+        this.#cache.clear();
+    }
+    async get(url, headers) {
+        return this.getCache(HttpMethods.GET, url)
+            ?? this.#driver.get(url, headers);
+    }
+    async post(url, body, headers) {
+        return this.getCache(HttpMethods.POST, url)
+            ?? this.#driver.post(url, body, headers);
+    }
+    async put(url, body, headers) {
+        return this.getCache(HttpMethods.PUT, url)
+            ?? this.#driver.put(url, body, headers);
+    }
+    async patch(url, body, headers) {
+        return this.getCache(HttpMethods.PATCH, url)
+            ?? this.#driver.patch(url, body, headers);
+    }
+    async delete(url, headers) {
+        return this.getCache(HttpMethods.DELETE, url)
+            ?? this.#driver.delete(url, headers);
+    }
+    async head(url, headers) {
+        return this.getCache(HttpMethods.HEAD, url)
+            ?? this.#driver.head(url, headers);
+    }
+    #createCacheId(method, url) {
+        return `${method.toUpperCase()} ${url.toLowerCase()}`;
+    }
+}

package/dist/definitions/constants.d.ts

@@ -1,8 +1,9 @@
-export declare const HTTP_METHODS: {
-    GET: string;
-    POST: string;
-    PUT: string;
-    PATCH: string;
-    DELETE: string;
-    HEAD: string;
+export declare const HttpMethods: {
+    readonly GET: "GET";
+    readonly POST: "POST";
+    readonly PUT: "PUT";
+    readonly PATCH: "PATCH";
+    readonly DELETE: "DELETE";
+    readonly HEAD: "HEAD";
 };
+export type HttpMethod = typeof HttpMethods[keyof typeof HttpMethods];

package/dist/definitions/constants.js

@@ -1,4 +1,4 @@
-export const HTTP_METHODS = {
+export const HttpMethods = {
     GET: 'GET',
     POST: 'POST',
     PUT: 'PUT',
@@ -6,4 +6,3 @@ export const HTTP_METHODS = {
     DELETE: 'DELETE',
     HEAD: 'HEAD'
 };
-Object.freeze(HTTP_METHODS);

package/dist/definitions/interfaces.d.ts

@@ -1,4 +1,4 @@
-export interface Http {
+export interface Driver {
     get(url: string, headers?: Record<string, string>): Promise<Response>;
     post(url: string, body: unknown, headers?: Record<string, string>): Promise<Response>;
     put(url: string, body: unknown, headers?: Record<string, string>): Promise<Response>;

package/dist/{implementations/fetch → drivers}/Fetch.d.ts

@@ -1,5 +1,5 @@
-import type { Http } from '../../definitions/interfaces.js';
-export default class Fetch implements Http {
+import type { Driver } from '../definitions/interfaces.js';
+export default class Fetch implements Driver {
     get(url: string, headers?: Record<string, string> | undefined): Promise<Response>;
     post(url: string, body: unknown, headers?: Record<string, string> | undefined): Promise<Response>;
     put(url: string, body: unknown, headers?: Record<string, string> | undefined): Promise<Response>;

package/dist/drivers/Fetch.js

@@ -0,0 +1,21 @@
+import { HttpMethods } from '../definitions/constants.js';
+export default class Fetch {
+    get(url, headers) {
+        return fetch(url, { method: HttpMethods.GET, headers });
+    }
+    post(url, body, headers) {
+        return fetch(url, { method: HttpMethods.POST, headers, body: JSON.stringify(body) });
+    }
+    put(url, body, headers) {
+        return fetch(url, { method: HttpMethods.PUT, headers, body: JSON.stringify(body) });
+    }
+    patch(url, body, headers) {
+        return fetch(url, { method: HttpMethods.PATCH, headers, body: JSON.stringify(body) });
+    }
+    delete(url, headers) {
+        return fetch(url, { method: HttpMethods.DELETE, headers });
+    }
+    head(url, headers) {
+        return fetch(url, { method: HttpMethods.HEAD, headers });
+    }
+}

package/dist/errors/HttpError.d.ts

@@ -1,2 +1,3 @@
 export default class HttpError extends Error {
+    constructor(message?: string);
 }

package/dist/errors/HttpError.js

@@ -1,2 +1,9 @@
 export default class HttpError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
 }

package/dist/index.d.ts

@@ -1,4 +1,6 @@
-import Client from './Client.js';
-declare const client: Client;
 export * from './definitions/constants.js';
-export default client;
+export type * from './definitions/constants.js';
+export type * from './definitions/interfaces.js';
+export { default as HttpError } from './errors/HttpError.js';
+export { default as FetchDriver } from './drivers/Fetch.js';
+export { default } from './Http.js';

package/dist/index.js

@@ -1,5 +1,4 @@
-import Client from './Client.js';
-import implementation from './implementation.js';
-const client = new Client(implementation);
 export * from './definitions/constants.js';
-export default client;
+export { default as HttpError } from './errors/HttpError.js';
+export { default as FetchDriver } from './drivers/Fetch.js';
+export { default } from './Http.js';

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@theshelf/http",
   "private": false,
-  "version": "0.1.0",
+  "version": "0.2.1",
   "type": "module",
   "repository": {
-    "url": "https://github.com/MaskingTechnology/theshelf"
+    "url": "git+https://github.com/MaskingTechnology/theshelf.git"
   },
   "scripts": {
     "build": "tsc",

package/dist/Client.js

@@ -1,51 +0,0 @@
-import { HTTP_METHODS } from './definitions/constants.js';
-export default class Memory {
-    #implementation;
-    #cache = new Map();
-    constructor(implementation) {
-        this.#implementation = implementation;
-        this.#cache = new Map();
-    }
-    setCache(method, url, response) {
-        const id = this.#createCacheId(method, url);
-        this.#cache.set(id, response);
-    }
-    getCache(method, url) {
-        const id = this.#createCacheId(method, url);
-        return this.#cache.get(id);
-    }
-    removeCache(method, url) {
-        const id = this.#createCacheId(method, url);
-        this.#cache.delete(id);
-    }
-    clearCache() {
-        this.#cache.clear();
-    }
-    async get(url, headers) {
-        return this.getCache(HTTP_METHODS.GET, url)
-            ?? this.#implementation.get(url, headers);
-    }
-    async post(url, body, headers) {
-        return this.getCache(HTTP_METHODS.POST, url)
-            ?? this.#implementation.post(url, body, headers);
-    }
-    async put(url, body, headers) {
-        return this.getCache(HTTP_METHODS.PUT, url)
-            ?? this.#implementation.put(url, body, headers);
-    }
-    async patch(url, body, headers) {
-        return this.getCache(HTTP_METHODS.PATCH, url)
-            ?? this.#implementation.patch(url, body, headers);
-    }
-    async delete(url, headers) {
-        return this.getCache(HTTP_METHODS.DELETE, url)
-            ?? this.#implementation.delete(url, headers);
-    }
-    async head(url, headers) {
-        return this.getCache(HTTP_METHODS.HEAD, url)
-            ?? this.#implementation.head(url, headers);
-    }
-    #createCacheId(method, url) {
-        return `${method.toUpperCase()} ${url.toLowerCase()}`;
-    }
-}

package/dist/errors/UnknownImplementation.d.ts

@@ -1,4 +0,0 @@
-import HttpError from './HttpError.js';
-export default class UnknownImplementation extends HttpError {
-    constructor(name: string);
-}

package/dist/errors/UnknownImplementation.js

@@ -1,6 +0,0 @@
-import HttpError from './HttpError.js';
-export default class UnknownImplementation extends HttpError {
-    constructor(name) {
-        super(`Unknown http implementation: ${name}`);
-    }
-}

package/dist/implementation.d.ts

@@ -1,3 +0,0 @@
-import type { Http } from './definitions/interfaces.js';
-declare const _default: Http;
-export default _default;

package/dist/implementation.js

@@ -1,12 +0,0 @@
-import UnknownImplementation from './errors/UnknownImplementation.js';
-import createFetch from './implementations/fetch/create.js';
-const implementations = new Map([
-    ['fetch', createFetch]
-]);
-const DEFAULT_HTTP_IMPLEMENTATION = 'fetch';
-const implementationName = process.env.HTTP_IMPLEMENTATION ?? DEFAULT_HTTP_IMPLEMENTATION;
-const creator = implementations.get(implementationName.toLowerCase());
-if (creator === undefined) {
-    throw new UnknownImplementation(implementationName);
-}
-export default creator();

package/dist/implementations/fetch/Fetch.js

@@ -1,21 +0,0 @@
-import { HTTP_METHODS } from '../../definitions/constants.js';
-export default class Fetch {
-    get(url, headers) {
-        return fetch(url, { method: HTTP_METHODS.GET, headers });
-    }
-    post(url, body, headers) {
-        return fetch(url, { method: HTTP_METHODS.POST, headers, body: JSON.stringify(body) });
-    }
-    put(url, body, headers) {
-        return fetch(url, { method: HTTP_METHODS.PUT, headers, body: JSON.stringify(body) });
-    }
-    patch(url, body, headers) {
-        return fetch(url, { method: HTTP_METHODS.PATCH, headers, body: JSON.stringify(body) });
-    }
-    delete(url, headers) {
-        return fetch(url, { method: HTTP_METHODS.DELETE, headers });
-    }
-    head(url, headers) {
-        return fetch(url, { method: HTTP_METHODS.HEAD, headers });
-    }
-}

package/dist/implementations/fetch/create.d.ts

@@ -1,2 +0,0 @@
-import Fetch from './Fetch.js';
-export default function create(): Fetch;

package/dist/implementations/fetch/create.js

@@ -1,4 +0,0 @@
-import Fetch from './Fetch.js';
-export default function create() {
-    return new Fetch();
-}