@theshelf/http 0.0.1

package/README.md

@@ -0,0 +1,88 @@
+
+# HTTP | The Shelf
+
+The HTTP package provides a universal interaction layer with an HTTP client inplementation and adds additional caching.
+
+## Installation
+
+```bash
+npm install @theshelf/http
+```
+
+## Implementations
+
+Currently, there is only one implementation:
+
+* **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.
+
+```ts
+import httpClient from '@theshelf/http';
+
+// Perform operations with the httpClient instance
+```
+
+### Operations
+
+```ts
+import httpClient, { HTTP_METHODS } from '@theshelf/http';
+
+// Set a cached response
+const response: Response = new Response();
+httpClient.setCache(HTTP_METHODS.GET, url, response);
+
+// Get a cached response
+const response: Response | undefined = httpClient.getCache(HTTP_METHODS.GET, url);
+
+// Remove a cached response
+httpClient.removeCache(method: string, url: string)
+
+// Clear all cache
+httpClient.clearCache()
+
+// Perform a GET request
+const response: Response = await httpClient.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);
+
+// 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);
+
+// 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);
+
+// 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);
+
+// Perform a DELETE request with optional headers
+const headers: Record<string, string> = { };
+const response: Response = await httpClient.delete(url, headers);
+
+// Perform a HEAD request with optional headers
+const headers: Record<string, string> = { };
+const response: Response = await httpClient.head(url, headers);
+```
+
+### 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
+
+All requests are cached by URL. To prevent this behavior, the cache for the URL must be deleted before performing the request.

package/dist/Client.d.ts

@@ -0,0 +1,15 @@
+import type { Http } from './definitions/interfaces';
+export default class Memory implements Http {
+    #private;
+    constructor(implementation: Http);
+    setCache(method: string, url: string, response: Response): void;
+    getCache(method: string, url: string): Response | undefined;
+    removeCache(method: string, url: string): void;
+    clearCache(): 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>;
+}

package/dist/Client.js

@@ -0,0 +1,51 @@
+import { HTTP_METHODS } from './definitions/constants';
+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/definitions/constants.d.ts

@@ -0,0 +1,8 @@
+export declare const HTTP_METHODS: {
+    GET: string;
+    POST: string;
+    PUT: string;
+    PATCH: string;
+    DELETE: string;
+    HEAD: string;
+};

package/dist/definitions/constants.js

@@ -0,0 +1,9 @@
+export const HTTP_METHODS = {
+    GET: 'GET',
+    POST: 'POST',
+    PUT: 'PUT',
+    PATCH: 'PATCH',
+    DELETE: 'DELETE',
+    HEAD: 'HEAD'
+};
+Object.freeze(HTTP_METHODS);

package/dist/definitions/interfaces.d.ts

@@ -0,0 +1,8 @@
+export interface Http {
+    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>;
+    patch(url: string, body: unknown, headers?: Record<string, string>): Promise<Response>;
+    delete(url: string, headers?: Record<string, string>): Promise<Response>;
+    head(url: string, headers?: Record<string, string>): Promise<Response>;
+}

package/dist/definitions/interfaces.js

@@ -0,0 +1 @@
+export {};

package/dist/errors/HttpError.d.ts

@@ -0,0 +1,2 @@
+export default class HttpError extends Error {
+}

package/dist/errors/HttpError.js

@@ -0,0 +1,2 @@
+export default class HttpError extends Error {
+}

package/dist/errors/UnknownImplementation.d.ts

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

package/dist/errors/UnknownImplementation.js

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

package/dist/implementation.d.ts

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

package/dist/implementation.js

@@ -0,0 +1,12 @@
+import UnknownImplementation from './errors/UnknownImplementation';
+import createFetch from './implementations/fetch/create';
+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.d.ts

@@ -0,0 +1,9 @@
+import type { Http } from '../../definitions/interfaces';
+export default class Fetch implements Http {
+    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>;
+}

package/dist/implementations/fetch/Fetch.js

@@ -0,0 +1,21 @@
+import { HTTP_METHODS } from '../../definitions/constants';
+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

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

package/dist/implementations/fetch/create.js

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

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import Client from './Client';
+declare const client: Client;
+export * from './definitions/constants';
+export default client;

package/dist/index.js

@@ -0,0 +1,5 @@
+import Client from './Client';
+import implementation from './implementation';
+const client = new Client(implementation);
+export * from './definitions/constants';
+export default client;

package/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "@theshelf/http",
+  "private": false,
+  "version": "0.0.1",
+  "type": "module",
+  "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",
+    "prepublishOnly": "npm run clean && npm run build"
+  },
+  "files": [
+    "README.md",
+    "dist"
+  ],
+  "types": "dist/index.d.ts",
+  "exports": "./dist/index.js"
+}