@theshelf/http 0.3.1 → 0.4.0

package/README.md

@@ -1,7 +1,7 @@
 
-# HTTP | The Shelf
+# HTTP core | The Shelf
 
-The HTTP package provides a universal interaction layer with an HTTP client inplementation and adds additional caching.
+This package contains the definition of the http clients.
 
 ## Installation
 
@@ -9,49 +9,22 @@ The HTTP package provides a universal interaction layer with an HTTP client inpl
 npm install @theshelf/http
 ```
 
-## Drivers
-
-Currently, there is only one driver available:
-
-* **Fetch** - Node.js fetch implementation.
-
 ## How to use
 
 The basic set up looks like this.
 
 ```ts
-import Http, { FetchDriver as SelectedDriver } from '@theshelf/http';
+import Http, { FetchDriver } from '@theshelf/http';
 
-const driver = new SelectedDriver(/* configuration */);
+const driver = new FetchDriver();
 const http = new Http(driver);
 
 // Perform operations with the http instance
 ```
 
-### Configuration
-
-#### Fetch driver
-
-No configuration options.
-
-### Operations
+## Operations
 
 ```ts
-import { HTTP_METHODS } from '@theshelf/http';
-
-// Set a cached response
-const response: Response = new Response();
-http.setCache(HTTP_METHODS.GET, url, response);
-
-// Get a cached response
-const response: Response | undefined = http.getCache(HTTP_METHODS.GET, url);
-
-// Remove a cached response
-http.removeCache(HTTP_METHODS.GET, url)
-
-// Clear all cache
-http.clearCache()
-
 // Perform a GET request
 const response: Response = await http.get(url);
 
@@ -80,10 +53,32 @@ const headers: Record<string, string> = { };
 const response: Response = await http.head(url, headers);
 ```
 
-### Response model
+## Response model
 
 The result of every request is a standard [ECMAScript Response](https://developer.mozilla.org/en-US/docs/Web/API/Response) object.
 
-### Caching mechanism
+## Drivers
+
+There are two drivers available.
+
+### Fetch
+
+This driver implements the [Node.js fetch](https://nodejs.org/api/globals.html#fetch) API.
+
+### Mapped
+
+In-memory http client (suited for testing). It doesn't have any configuration options, but has an additional operation.
 
-All requests are cached by URL. To prevent this behavior, the cache for the URL must be deleted before performing the request.
+```ts
+// Add a mapping
+driver.setMapping(method, url, response);
+
+// Get a mapping 
+const response: Response | undefined = driver.getMapping(method, url);
+
+// Remove a mapping
+driver.removeMapping(method, url);
+
+// Remove all mappings
+driver.clearMappings();
+```

package/dist/Http.d.ts

@@ -1,11 +1,8 @@
+import type Logger from '@theshelf/logging';
 import type { Driver } from './definitions/interfaces.js';
-export default class Http implements Driver {
+export default class Http {
     #private;
-    constructor(driver: Driver);
-    setCache(method: string, url: string, response: Response): void;
-    getCache(method: string, url: string): Response | undefined;
-    removeCache(method: string, url: string): void;
-    clearCache(): void;
+    constructor(driver: Driver, logger?: Logger);
     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/Http.js

@@ -1,50 +1,70 @@
-import { HttpMethods } from './definitions/constants.js';
 export default class Http {
     #driver;
-    #cache = new Map();
-    constructor(driver) {
+    #logger;
+    #logPrefix;
+    constructor(driver, logger) {
         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();
+        this.#logger = logger?.for(Http.name);
+        this.#logPrefix = `${this.#driver.name} ->`;
     }
     async get(url, headers) {
-        return this.getCache(HttpMethods.GET, url)
-            ?? this.#driver.get(url, headers);
+        this.#logger?.debug(this.#logPrefix, 'Getting', url);
+        try {
+            return await this.#driver.get(url, headers);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Get', url, 'failed with error', error);
+            throw error;
+        }
     }
     async post(url, body, headers) {
-        return this.getCache(HttpMethods.POST, url)
-            ?? this.#driver.post(url, body, headers);
+        this.#logger?.debug(this.#logPrefix, 'Posting', url);
+        try {
+            return await this.#driver.post(url, body, headers);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Post', url, 'failed with error', error);
+            throw error;
+        }
     }
     async put(url, body, headers) {
-        return this.getCache(HttpMethods.PUT, url)
-            ?? this.#driver.put(url, body, headers);
+        this.#logger?.debug(this.#logPrefix, 'Putting', url);
+        try {
+            return await this.#driver.put(url, body, headers);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Put', url, 'failed with error', error);
+            throw error;
+        }
     }
     async patch(url, body, headers) {
-        return this.getCache(HttpMethods.PATCH, url)
-            ?? this.#driver.patch(url, body, headers);
+        this.#logger?.debug(this.#logPrefix, 'Patching', url);
+        try {
+            return await this.#driver.patch(url, body, headers);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Patch', url, 'failed with error', error);
+            throw error;
+        }
     }
     async delete(url, headers) {
-        return this.getCache(HttpMethods.DELETE, url)
-            ?? this.#driver.delete(url, headers);
+        this.#logger?.debug(this.#logPrefix, 'Deleting', url);
+        try {
+            return await this.#driver.delete(url, headers);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Delete', url, 'failed with error', error);
+            throw error;
+        }
     }
     async head(url, headers) {
-        return this.getCache(HttpMethods.HEAD, url)
-            ?? this.#driver.head(url, headers);
-    }
-    #createCacheId(method, url) {
-        return `${method.toUpperCase()} ${url.toLowerCase()}`;
+        this.#logger?.debug(this.#logPrefix, 'Heading', url);
+        try {
+            return await this.#driver.head(url, headers);
+        }
+        catch (error) {
+            this.#logger?.error(this.#logPrefix, 'Head', url, 'failed with error', error);
+            throw error;
+        }
     }
 }

package/dist/definitions/interfaces.d.ts

@@ -1,4 +1,5 @@
 export interface Driver {
+    get name(): string;
     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/drivers/Fetch.d.ts

@@ -1,5 +1,6 @@
 import type { Driver } from '../definitions/interfaces.js';
 export default class Fetch implements Driver {
+    get name(): string;
     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

@@ -1,5 +1,6 @@
 import { HttpMethods } from '../definitions/constants.js';
 export default class Fetch {
+    get name() { return Fetch.name; }
     get(url, headers) {
         return fetch(url, { method: HttpMethods.GET, headers });
     }

package/dist/drivers/Mapped.d.ts

@@ -0,0 +1,16 @@
+import type { HttpMethod } from '../definitions/constants.js';
+import type { Driver } from '../definitions/interfaces.js';
+export default class Mapped implements Driver {
+    #private;
+    get name(): string;
+    setMapping(method: HttpMethod, url: string, response: Response): void;
+    getMapping(method: HttpMethod, url: string): Response | undefined;
+    removeMapping(method: HttpMethod, url: string): void;
+    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>;
+    patch(url: string, body: unknown, headers?: Record<string, string> | undefined): Promise<Response>;
+    delete(url: string, headers?: Record<string, string> | undefined): Promise<Response>;
+    head(url: string, headers?: Record<string, string> | undefined): Promise<Response>;
+    clear(): void;
+}

package/dist/drivers/Mapped.js

@@ -0,0 +1,51 @@
+/* eslint @typescript-eslint/no-unused-vars: "off" */
+import { HttpMethods } from '../definitions/constants.js';
+export default class Mapped {
+    #mappings = new Map();
+    get name() { return Mapped.name; }
+    setMapping(method, url, response) {
+        const id = this.#createCacheId(method, url);
+        this.#mappings.set(id, response);
+    }
+    getMapping(method, url) {
+        const id = this.#createCacheId(method, url);
+        return this.#mappings.get(id)?.clone();
+    }
+    removeMapping(method, url) {
+        const id = this.#createCacheId(method, url);
+        this.#mappings.delete(id);
+    }
+    async get(url, headers) {
+        return this.getMapping(HttpMethods.GET, url)
+            ?? this.#createNotMappedResponse();
+    }
+    async post(url, body, headers) {
+        return this.getMapping(HttpMethods.POST, url)
+            ?? this.#createNotMappedResponse();
+    }
+    async put(url, body, headers) {
+        return this.getMapping(HttpMethods.PUT, url)
+            ?? this.#createNotMappedResponse();
+    }
+    async patch(url, body, headers) {
+        return this.getMapping(HttpMethods.PATCH, url)
+            ?? this.#createNotMappedResponse();
+    }
+    async delete(url, headers) {
+        return this.getMapping(HttpMethods.DELETE, url)
+            ?? this.#createNotMappedResponse();
+    }
+    async head(url, headers) {
+        return this.getMapping(HttpMethods.HEAD, url)
+            ?? this.#createNotMappedResponse();
+    }
+    clear() {
+        this.#mappings.clear();
+    }
+    #createCacheId(method, url) {
+        return `${method.toUpperCase()} ${url}`;
+    }
+    #createNotMappedResponse() {
+        return new Response('Not mapped', { status: 404 });
+    }
+}

package/dist/index.d.ts

@@ -2,5 +2,6 @@ export * from './definitions/constants.js';
 export type * from './definitions/constants.js';
 export type * from './definitions/interfaces.js';
 export { default as HttpError } from './errors/HttpError.js';
+export { default as MappedDriver } from './drivers/Mapped.js';
 export { default as FetchDriver } from './drivers/Fetch.js';
 export { default } from './Http.js';

package/dist/index.js

@@ -1,4 +1,5 @@
 export * from './definitions/constants.js';
 export { default as HttpError } from './errors/HttpError.js';
+export { default as MappedDriver } from './drivers/Mapped.js';
 export { default as FetchDriver } from './drivers/Fetch.js';
 export { default } from './Http.js';

package/package.json

@@ -1,24 +1,26 @@
 {
   "name": "@theshelf/http",
   "private": false,
-  "version": "0.3.1",
+  "version": "0.4.0",
   "type": "module",
   "repository": {
     "url": "git+https://github.com/MaskingTechnology/theshelf.git"
   },
+  "license": "MIT",
   "scripts": {
     "build": "tsc",
     "clean": "rimraf dist",
-    "test": "vitest run",
-    "test-coverage": "vitest run --coverage",
     "lint": "eslint",
-    "review": "npm run build && npm run lint && npm run test",
+    "review": "npm run build && npm run lint",
     "prepublishOnly": "npm run clean && npm run build"
   },
   "files": [
     "README.md",
     "dist"
   ],
-  "types": "dist/index.d.ts",
-  "exports": "./dist/index.js"
+  "types": "./dist/index.d.ts",
+  "exports": "./dist/index.js",
+  "peerDependencies": {
+    "@theshelf/logging": "^0.4.0"
+  }
 }