http-client-impulse 1.0.1

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+import type { RequestConfig, HttpResponse, HttpGetOptions, HttpPostOptions, HttpPutOptions, HttpDeleteOptions } from "./index.types.d.ts";
+declare function create(config?: RequestConfig): {
+    get<T>(...options: HttpGetOptions): Promise<HttpResponse<T>>;
+    post<T>(...options: HttpPostOptions): Promise<HttpResponse<T>>;
+    put<T>(...options: HttpPutOptions): Promise<HttpResponse<T>>;
+    delete<T>(...options: HttpDeleteOptions): Promise<HttpResponse<T>>;
+};
+export default create;

package/dist/index.js

@@ -0,0 +1,165 @@
+// проверка на url
+function isUrl(url) {
+    if (typeof url === 'string') {
+        return true;
+    }
+    if (typeof url === 'object' && url !== null) {
+        return url instanceof URL;
+    }
+    return false;
+}
+// gpt: проверка BodyData , на чистый объект
+function isPlainObject(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        !(value instanceof FormData) &&
+        !(value instanceof Blob) &&
+        !(value instanceof ArrayBuffer) &&
+        !(value instanceof URLSearchParams));
+}
+// объединение с baseURL
+function buildUrl(url, baseURL) {
+    if (!baseURL)
+        return new URL(url);
+    const urlString = url.toString();
+    const mormalized = urlString.startsWith('/') ? urlString.slice(1) : urlString;
+    return new URL(mormalized, baseURL);
+}
+// Обработка search params опции адаптера
+function handleUrlParams(params) {
+    return new URLSearchParams(params);
+}
+// обработка(адаптация) кастомных опций для fetch() опций
+function handleRequestOptionsForFetch(options) {
+    const { url, params, ...otherParams } = options;
+    const newUrl = new URL(url.toString()); // ревью-gpt: лучше сделать новый, дабы было безопаснее, чем мутировать неизвестно-приходящий
+    if (params && typeof params === 'object' && params !== null) {
+        newUrl.search = handleUrlParams(params).toString();
+    }
+    return { ...otherParams, url: newUrl };
+}
+// обработка опций при работе с method [get | delete]: [url], [{url}], [url, options]
+function getOptionsWithoutDataForHttp(options, config, method) {
+    const argsLength = options.length;
+    // [url] | [{url}]
+    if (argsLength === 1) {
+        const urlOrOptions = options[0];
+        // [url]
+        if (isUrl(urlOrOptions)) {
+            const url = urlOrOptions;
+            return {
+                method,
+                url: buildUrl(url, config.baseURL)
+            };
+        }
+        // [{url}]
+        const { url, ...optionsWithoutUrl } = urlOrOptions;
+        if (!isUrl(url)) {
+            throw new Error('Invalid url');
+        }
+        return {
+            ...optionsWithoutUrl,
+            method,
+            url: buildUrl(url, config.baseURL)
+        };
+    }
+    // [url, options]
+    const [url, _options] = options;
+    if (!isUrl(url)) {
+        throw new Error('Invalid url');
+    }
+    return {
+        ..._options,
+        method,
+        url: buildUrl(url, config.baseURL)
+    };
+}
+// обработка опций при работе с method [post | put]: [url, data, options]
+function getOptionsWithDataForHttp(optionsArg, config, method) {
+    const [url, data, options] = optionsArg;
+    if (!isUrl(url)) {
+        throw new Error('Invalid url');
+    }
+    const urlWithBase = buildUrl(url, config.baseURL);
+    let body = data;
+    let jsonHeaders;
+    if (isPlainObject(data)) {
+        body = JSON.stringify(data);
+        jsonHeaders = {
+            'Content-Type': 'application/json'
+        };
+    }
+    const baseOptions = {
+        method,
+        url: urlWithBase,
+        body,
+    };
+    if (options) {
+        const { headers: headersOption, ...otherOptions } = options;
+        const finalHeaders = new Headers(headersOption ?? {}); // gpt: нормализация headers
+        if (jsonHeaders) {
+            for (const [key, value] of Object.entries(jsonHeaders)) {
+                // не перезаписываем, если уже есть 
+                if (!finalHeaders.has(key)) {
+                    finalHeaders.set(key, value);
+                }
+            }
+        }
+        return {
+            ...otherOptions,
+            ...baseOptions,
+            headers: finalHeaders
+        };
+    }
+    return {
+        ...baseOptions,
+        ...jsonHeaders
+    };
+}
+// http адаптер: отправка http запросов
+async function httpRequest(options) {
+    const { url, ...optionsWithoutUrl } = handleRequestOptionsForFetch(options);
+    const response = await fetch(url, optionsWithoutUrl);
+    if (!response.ok) {
+        const errorData = await response.text();
+        throw new Error(`HTTP ${response.status}: ${errorData}`);
+    }
+    const data = await response.json();
+    return {
+        data,
+        status: response.status,
+        statusText: response.statusText,
+        headers: response.headers,
+        url: response.url
+    };
+}
+function create(config) {
+    const baseURL = config?.baseURL;
+    return {
+        async get(...options) {
+            const optionsForRequest = getOptionsWithoutDataForHttp(options, {
+                baseURL
+            }, 'GET');
+            return await httpRequest(optionsForRequest);
+        },
+        async post(...options) {
+            const optionsForRequest = getOptionsWithDataForHttp(options, {
+                baseURL
+            }, 'POST');
+            return await httpRequest(optionsForRequest);
+        },
+        async put(...options) {
+            const optionsForRequest = getOptionsWithDataForHttp(options, {
+                baseURL
+            }, 'PUT');
+            return await httpRequest(optionsForRequest);
+        },
+        async delete(...options) {
+            const optionsForRequest = getOptionsWithoutDataForHttp(options, {
+                baseURL
+            }, 'DELETE');
+            return await httpRequest(optionsForRequest);
+        },
+    };
+}
+export default create;

package/dist/index.types.d.ts

@@ -0,0 +1,34 @@
+export type ImpulseURL = string | URL;
+export interface Params {
+    [key: string]: string | number;
+}
+interface DefaultOptions extends RequestInit {
+}
+export interface RequestConfig {
+    baseURL?: string;
+    defaultOptions?: DefaultOptions;
+}
+interface BodyObject {
+}
+export type RequestDataBody = BodyInit | BodyObject | null;
+export interface HttpResponse<T> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    url: string;
+}
+export interface RequestOptions extends RequestInit {
+    url: ImpulseURL;
+    params?: Params;
+}
+export type RequestOptionsWithoutUrl = Omit<RequestOptions, "url">;
+type RequestOptionsWithoutUrlAndMethod = Omit<RequestOptionsWithoutUrl, "method">;
+type RequestOptionsWithoutMethod = Omit<RequestOptions, 'method'>;
+type HttpOptions = [ImpulseURL | RequestOptionsWithoutMethod] | [ImpulseURL, RequestOptionsWithoutUrlAndMethod] | [RequestOptionsWithoutMethod];
+type HttpDataOptions = [ImpulseURL] | [ImpulseURL, RequestDataBody] | [ImpulseURL, RequestDataBody, RequestOptionsWithoutUrlAndMethod];
+export type HttpGetOptions = HttpOptions;
+export type HttpDeleteOptions = HttpOptions;
+export type HttpPostOptions = HttpDataOptions;
+export type HttpPutOptions = HttpDataOptions;
+export {};

package/dist/index.types.js

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

package/dist/tests/index.test.d.ts

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

package/dist/tests/index.test.js

@@ -0,0 +1,95 @@
+import { test, describe } from 'node:test';
+import assert from 'node:assert';
+import create from '../index.js';
+import nock from 'nock';
+describe('CONFIG CREATE', () => {
+    test('Проверка верной конкатинации baseURL + URL', async (t) => {
+        const baseURL = 'http://localhost:3000/api/';
+        const url = 'users';
+        const expectedUrl = new URL(url, baseURL);
+        const mock = nock('http://localhost:3000')
+            .get('/api/users')
+            .reply(200, {});
+        const impulse = create({ baseURL });
+        const response = await impulse.get(url);
+        //t.diagnostic(response.url)
+        assert.strictEqual(response.url, expectedUrl.toString());
+        assert.ok(mock.isDone());
+    });
+});
+describe('HTTP GET', () => {
+    test('GET запрос с пустым URL значением должен вызвать ошибку', async () => {
+        const impulse = create();
+        try {
+            await impulse.get('');
+            assert.fail('Ожидалась ошибка при пустом URL');
+        }
+        catch (err) {
+            if (err instanceof Error) {
+                assert.ok(err.message.includes('Invalid'));
+            }
+            else {
+                assert.fail('Ошибка не является объектом Error');
+            }
+        }
+    });
+    test('GET запрос', async () => {
+        const impulse = create();
+        const response = await impulse.get('https://jsonplaceholder.typicode.com/users');
+        assert.strictEqual(response.status, 200);
+    });
+    test('GET запрос с option params', async () => {
+        const impulse = create();
+        const response = await impulse.get('https://jsonplaceholder.typicode.com/users', {
+            params: {
+                id: 10
+            }
+        });
+        assert.strictEqual(response.status, 200);
+    });
+});
+describe('HTTP POST', () => {
+    test('POST запрос только с url (data по умолчанию = null), не должен приводить к функциональной ошибке', async () => {
+        const impulse = create();
+        const response = await impulse.post('https://jsonplaceholder.typicode.com/users');
+        assert.strictEqual(response.status, 201);
+    });
+    test('POST запрос c data', async () => {
+        const impulse = create();
+        const response = await impulse.post('https://jsonplaceholder.typicode.com/users', {
+            name: 'John Smit'
+        });
+        assert.strictEqual(response.status, 201);
+    });
+    test('POST запрос c data = null не должен приводить к функциональной ошибке', async () => {
+        const impulse = create();
+        const response = await impulse.post('https://jsonplaceholder.typicode.com/users', null);
+        assert.strictEqual(response.status, 201);
+    });
+});
+describe('HTTP PUT', () => {
+    test('PUT запрос только с url (data по умолчанию = null), не должен приводить к функциональной ошибке', async () => {
+        const impulse = create();
+        const response = await impulse.put('https://jsonplaceholder.typicode.com/users/1');
+        assert.strictEqual(response.status, 200);
+    });
+    test('PUT запрос c data', async () => {
+        const impulse = create();
+        const response = await impulse.put('https://jsonplaceholder.typicode.com/users/1', {
+            name: 'John Smit'
+        });
+        assert.strictEqual(response.status, 200);
+    });
+    test('PUT запрос c data = null не должен приводить к функциональной ошибке', async () => {
+        const impulse = create();
+        const response = await impulse.put('https://jsonplaceholder.typicode.com/users/1', null);
+        assert.strictEqual(response.status, 200);
+    });
+});
+describe('HTTP DELETE', () => {
+    test('DELETE запрос', async () => {
+        const impulse = create();
+        const response = await impulse.delete('https://jsonplaceholder.typicode.com/users/1');
+        assert.strictEqual(response.status, 200);
+    });
+});

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "http-client-impulse",
+  "version": "1.0.1",
+  "description": "A package for implementing HTTP requests in JavaScript",
+  "license": "ISC",
+  "author": "PaulBash",
+  "keywords": ["http", "get", "post", "put", "delete", "http client", "client"],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Paulbashk?tab=repositories"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": ["dist"],
+  "type": "module",
+  "scripts": {
+    "dev": "tsc & node dist/index.js",
+    "build": "tsc",
+    "test": "tsc & node --test dist/tests/index.test.js",
+    "prepublishOnly": "npm run test",
+    "prepare": "npm run build"
+  },
+  "devDependencies": {
+    "@types/node": "^25.5.0"
+  },
+  "dependencies": {
+    "nock": "^14.0.11"
+  }
+}