@yxcinebendjebbar/asdc 0.0.4

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,45 @@
+# http-toolkit
+
+Zero-dependency, OOP HTTP / WebSocket / JSON-RPC client for TypeScript, built with native `fetch` and `WebSocket` only.
+Architecture is deliberately language-agnostic (Strategy, Chain of Responsibility, Adapter) so the same design ports to Go / Python later.
+
+## Usage
+
+```ts
+import { HttpClient } from './src';
+
+const api = new HttpClient({ baseURL: 'https://api.example.com', timeout: 5000 });
+
+api.interceptors.request.use((config) => {
+  config.headers = { ...config.headers, Authorization: 'Bearer token' };
+  return config;
+});
+
+const { data } = await api.get('/users/1');
+```
+
+```ts
+import { WebSocketClient, JsonRpcClient } from './src';
+
+const ws = new WebSocketClient('wss://api.example.com/ws');
+ws.connect();
+const rpc = new JsonRpcClient(ws);
+const result = await rpc.call('getUser', { id: 1 });
+```
+
+## Structure
+
+```
+src/
+  core/       RequestConfig, Response, errors, InterceptorManager (Chain of Responsibility)
+  transport/  Transport interface (Strategy) + FetchTransport
+  http/       HttpClient (axios-style API)
+  ws/         WebSocketClient (native WS + backoff reconnect)
+  rpc/        JsonRpcClient (JSON-RPC 2.0, Adapter over HTTP or WS)
+  utils/      QueryString helpers
+```
+
+## Roadmap
+- Node `http`/`https` transport (no `fetch` dependency for older runtimes)
+- GraphQL client (Adapter over `HttpClient`, same interceptor pipeline)
+- Retry policy plugin (Strategy, composes with `Transport`)

package/dist/core/InterceptorManager.d.ts

@@ -0,0 +1,10 @@
+export interface InterceptorHandlers<T> {
+    fulfilled: (value: T) => T | Promise<T>;
+    rejected?: (error: unknown) => unknown;
+}
+export declare class InterceptorManager<T> {
+    private handlers;
+    use(fulfilled: InterceptorHandlers<T>['fulfilled'], rejected?: InterceptorHandlers<T>['rejected']): number;
+    eject(id: number): void;
+    run(value: T): Promise<T>;
+}

package/dist/core/InterceptorManager.js

@@ -0,0 +1,30 @@
+export class InterceptorManager {
+    handlers = [];
+    use(fulfilled, rejected) {
+        this.handlers.push({ fulfilled, rejected });
+        return this.handlers.length - 1;
+    }
+    eject(id) {
+        if (this.handlers[id])
+            this.handlers[id] = null;
+    }
+    async run(value) {
+        let result = value;
+        for (const handler of this.handlers) {
+            if (!handler)
+                continue;
+            try {
+                result = await handler.fulfilled(result);
+            }
+            catch (err) {
+                if (handler.rejected) {
+                    result = (await handler.rejected(err));
+                }
+                else {
+                    throw err;
+                }
+            }
+        }
+        return result;
+    }
+}

package/dist/core/RequestConfig.d.ts

@@ -0,0 +1,17 @@
+export type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE' | 'HEAD' | 'OPTIONS';
+export interface RequestConfig {
+    url: string;
+    method?: HttpMethod;
+    baseURL?: string;
+    headers?: Record<string, string>;
+    params?: Record<string, string | number | boolean | undefined>;
+    data?: unknown;
+    timeout?: number;
+    signal?: AbortSignal;
+    responseType?: 'json' | 'text' | 'blob' | 'arraybuffer';
+}
+export interface ClientConfig {
+    baseURL?: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+}

package/dist/core/RequestConfig.js

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

package/dist/core/Response.d.ts

@@ -0,0 +1,10 @@
+import type { RequestConfig } from './RequestConfig.ts';
+export declare class HttpResponse<T = unknown> {
+    readonly status: number;
+    readonly statusText: string;
+    readonly headers: Record<string, string>;
+    readonly data: T;
+    readonly config: RequestConfig;
+    constructor(status: number, statusText: string, headers: Record<string, string>, data: T, config: RequestConfig);
+    get ok(): boolean;
+}

package/dist/core/Response.js

@@ -0,0 +1,17 @@
+export class HttpResponse {
+    status;
+    statusText;
+    headers;
+    data;
+    config;
+    constructor(status, statusText, headers, data, config) {
+        this.status = status;
+        this.statusText = statusText;
+        this.headers = headers;
+        this.data = data;
+        this.config = config;
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,17 @@
+export declare class HttpToolkitError extends Error {
+    config?: unknown | undefined;
+    constructor(message: string, config?: unknown | undefined);
+}
+export declare class NetworkError extends HttpToolkitError {
+    cause?: unknown | undefined;
+    constructor(message: string, cause?: unknown | undefined, config?: unknown);
+}
+export declare class TimeoutError extends HttpToolkitError {
+    constructor(message?: string, config?: unknown);
+}
+export declare class ResponseError<T = unknown> extends HttpToolkitError {
+    status: number;
+    statusText: string;
+    data: T;
+    constructor(message: string, status: number, statusText: string, data: T, config?: unknown);
+}

package/dist/core/errors.js

@@ -0,0 +1,34 @@
+export class HttpToolkitError extends Error {
+    config;
+    constructor(message, config) {
+        super(message);
+        this.config = config;
+        this.name = 'HttpToolkitError';
+    }
+}
+export class NetworkError extends HttpToolkitError {
+    cause;
+    constructor(message, cause, config) {
+        super(message, config);
+        this.cause = cause;
+        this.name = 'NetworkError';
+    }
+}
+export class TimeoutError extends HttpToolkitError {
+    constructor(message = 'Request timed out', config) {
+        super(message, config);
+        this.name = 'TimeoutError';
+    }
+}
+export class ResponseError extends HttpToolkitError {
+    status;
+    statusText;
+    data;
+    constructor(message, status, statusText, data, config) {
+        super(message, config);
+        this.status = status;
+        this.statusText = statusText;
+        this.data = data;
+        this.name = 'ResponseError';
+    }
+}

package/dist/http/HttpClient.d.ts

@@ -0,0 +1,21 @@
+import type { ClientConfig, RequestConfig } from '../core/RequestConfig.ts';
+import { HttpResponse } from '../core/Response.ts';
+import { InterceptorManager } from '../core/InterceptorManager.ts';
+import type { Transport } from '../transport/Transport.ts';
+export declare class HttpClient {
+    private readonly config;
+    private readonly transport;
+    readonly interceptors: {
+        request: InterceptorManager<RequestConfig>;
+        response: InterceptorManager<HttpResponse<unknown>>;
+    };
+    constructor(config?: ClientConfig, transport?: Transport);
+    request<T = unknown>(config: RequestConfig): Promise<HttpResponse<T>>;
+    private method;
+    get<T = unknown>(url: string, config?: Partial<RequestConfig>): Promise<HttpResponse<T>>;
+    delete<T = unknown>(url: string, config?: Partial<RequestConfig>): Promise<HttpResponse<T>>;
+    head<T = unknown>(url: string, config?: Partial<RequestConfig>): Promise<HttpResponse<T>>;
+    post<T = unknown>(url: string, data?: unknown, config?: Partial<RequestConfig>): Promise<HttpResponse<T>>;
+    put<T = unknown>(url: string, data?: unknown, config?: Partial<RequestConfig>): Promise<HttpResponse<T>>;
+    patch<T = unknown>(url: string, data?: unknown, config?: Partial<RequestConfig>): Promise<HttpResponse<T>>;
+}

package/dist/http/HttpClient.js

@@ -0,0 +1,51 @@
+import { InterceptorManager } from "../core/InterceptorManager.js";
+import { ResponseError } from "../core/errors.js";
+import { FetchTransport } from "../transport/FetchTransport.js";
+export class HttpClient {
+    config;
+    transport;
+    interceptors = {
+        request: new InterceptorManager(),
+        response: new InterceptorManager(),
+    };
+    constructor(config = {}, transport = new FetchTransport()) {
+        this.config = config;
+        this.transport = transport;
+    }
+    async request(config) {
+        const merged = {
+            ...config,
+            baseURL: config.baseURL ?? this.config.baseURL,
+            headers: { ...this.config.headers, ...config.headers },
+            timeout: config.timeout ?? this.config.timeout,
+        };
+        const finalConfig = await this.interceptors.request.run(merged);
+        const response = await this.transport.send(finalConfig);
+        const finalResponse = await this.interceptors.response.run(response);
+        if (!finalResponse.ok) {
+            throw new ResponseError(`Request failed with status ${finalResponse.status}`, finalResponse.status, finalResponse.statusText, finalResponse.data, finalConfig);
+        }
+        return finalResponse;
+    }
+    method(method, url, config) {
+        return this.request({ ...config, url, method });
+    }
+    get(url, config) {
+        return this.method('GET', url, config);
+    }
+    delete(url, config) {
+        return this.method('DELETE', url, config);
+    }
+    head(url, config) {
+        return this.method('HEAD', url, config);
+    }
+    post(url, data, config) {
+        return this.method('POST', url, { ...config, data });
+    }
+    put(url, data, config) {
+        return this.method('PUT', url, { ...config, data });
+    }
+    patch(url, data, config) {
+        return this.method('PATCH', url, { ...config, data });
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,9 @@
+export * from './core/RequestConfig.ts';
+export * from './core/Response.ts';
+export * from './core/errors.ts';
+export * from './core/InterceptorManager.ts';
+export * from './transport/Transport.ts';
+export * from './transport/FetchTransport.ts';
+export * from './http/HttpClient.ts';
+export * from './ws/WebSocketClient.ts';
+export * from './rpc/JsonRpcClient.ts';

package/dist/index.js

@@ -0,0 +1,9 @@
+export * from "./core/RequestConfig.js";
+export * from "./core/Response.js";
+export * from "./core/errors.js";
+export * from "./core/InterceptorManager.js";
+export * from "./transport/Transport.js";
+export * from "./transport/FetchTransport.js";
+export * from "./http/HttpClient.js";
+export * from "./ws/WebSocketClient.js";
+export * from "./rpc/JsonRpcClient.js";

package/dist/rpc/JsonRpcClient.d.ts

@@ -0,0 +1,17 @@
+import { HttpClient } from '../http/HttpClient.ts';
+import { WebSocketClient } from '../ws/WebSocketClient.ts';
+export declare class RpcError extends Error {
+    code: number;
+    data?: unknown | undefined;
+    constructor(message: string, code: number, data?: unknown | undefined);
+}
+export declare class JsonRpcClient {
+    private readonly transport;
+    private readonly endpoint;
+    private nextId;
+    private pending;
+    constructor(transport: HttpClient | WebSocketClient, endpoint?: string);
+    call<T = unknown>(method: string, params?: unknown): Promise<T>;
+    private handleMessage;
+    private rejectAllPending;
+}

package/dist/rpc/JsonRpcClient.js

@@ -0,0 +1,67 @@
+import { WebSocketClient } from "../ws/WebSocketClient.js";
+export class RpcError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.code = code;
+        this.data = data;
+        this.name = 'RpcError';
+    }
+}
+export class JsonRpcClient {
+    transport;
+    endpoint;
+    nextId = 1;
+    pending = new Map();
+    constructor(transport, endpoint = '/') {
+        this.transport = transport;
+        this.endpoint = endpoint;
+        if (transport instanceof WebSocketClient) {
+            transport.on('message', (raw) => this.handleMessage(raw));
+            transport.on('close', () => this.rejectAllPending(new RpcError('WebSocket closed', -32000)));
+            transport.on('error', () => this.rejectAllPending(new RpcError('WebSocket error', -32000)));
+        }
+    }
+    async call(method, params) {
+        const id = this.nextId++;
+        const payload = { jsonrpc: '2.0', id, method, params };
+        const transport = this.transport;
+        if (transport instanceof WebSocketClient) {
+            return new Promise((resolve, reject) => {
+                this.pending.set(id, { resolve: resolve, reject });
+                transport.send(JSON.stringify(payload));
+            });
+        }
+        const res = await transport.post(this.endpoint, payload);
+        if (res.data.error) {
+            throw new RpcError(res.data.error.message, res.data.error.code, res.data.error.data);
+        }
+        return res.data.result;
+    }
+    handleMessage(raw) {
+        let msg;
+        try {
+            msg = JSON.parse(raw);
+        }
+        catch {
+            return;
+        }
+        const pending = this.pending.get(msg.id);
+        if (!pending)
+            return;
+        this.pending.delete(msg.id);
+        if (msg.error) {
+            pending.reject(new RpcError(msg.error.message, msg.error.code, msg.error.data));
+        }
+        else {
+            pending.resolve(msg.result);
+        }
+    }
+    rejectAllPending(error) {
+        for (const pending of this.pending.values()) {
+            pending.reject(error);
+        }
+        this.pending.clear();
+    }
+}

package/dist/transport/FetchTransport.d.ts

@@ -0,0 +1,7 @@
+import type { Transport } from './Transport.ts';
+import type { RequestConfig } from '../core/RequestConfig.ts';
+import { HttpResponse } from '../core/Response.ts';
+export declare class FetchTransport implements Transport {
+    send<T = unknown>(config: RequestConfig): Promise<HttpResponse<T>>;
+    private parseBody;
+}

package/dist/transport/FetchTransport.js

@@ -0,0 +1,56 @@
+import { HttpResponse } from "../core/Response.js";
+import { NetworkError, TimeoutError } from "../core/errors.js";
+import { buildURL } from "../utils/QueryString.js";
+export class FetchTransport {
+    async send(config) {
+        const url = buildURL(config.baseURL, config.url, config.params);
+        const controller = new AbortController();
+        const timer = config.timeout ? setTimeout(() => controller.abort(), config.timeout) : undefined;
+        const signals = [controller.signal];
+        if (config.signal)
+            signals.push(config.signal);
+        const signal = AbortSignal.any(signals);
+        const reqHeaders = { ...config.headers };
+        if (config.data !== undefined && !reqHeaders['Content-Type'] && !reqHeaders['content-type']) {
+            reqHeaders['Content-Type'] = 'application/json';
+        }
+        let res;
+        try {
+            res = await fetch(url, {
+                method: config.method ?? 'GET',
+                headers: reqHeaders,
+                body: config.data !== undefined ? JSON.stringify(config.data) : undefined,
+                signal,
+            });
+        }
+        catch (err) {
+            if (err.name === 'AbortError') {
+                throw new TimeoutError(undefined, config);
+            }
+            throw new NetworkError(err.message, err, config);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+        const headers = {};
+        res.headers.forEach((value, key) => (headers[key] = value));
+        const data = await this.parseBody(res, config.responseType);
+        return new HttpResponse(res.status, res.statusText, headers, data, config);
+    }
+    async parseBody(res, type) {
+        if (type === 'text')
+            return (await res.text());
+        if (type === 'blob')
+            return (await res.blob());
+        if (type === 'arraybuffer')
+            return (await res.arrayBuffer());
+        const text = await res.text();
+        try {
+            return text ? JSON.parse(text) : undefined;
+        }
+        catch {
+            return text;
+        }
+    }
+}

package/dist/transport/Transport.d.ts

@@ -0,0 +1,5 @@
+import type { RequestConfig } from '../core/RequestConfig.ts';
+import type { HttpResponse } from '../core/Response.ts';
+export interface Transport {
+    send<T = unknown>(config: RequestConfig): Promise<HttpResponse<T>>;
+}

package/dist/transport/Transport.js

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

package/dist/utils/QueryString.d.ts

@@ -0,0 +1,2 @@
+export declare function buildQueryString(params?: Record<string, string | number | boolean | undefined>): string;
+export declare function buildURL(baseURL: string | undefined, url: string, params?: Record<string, string | number | boolean | undefined>): string;

package/dist/utils/QueryString.js

@@ -0,0 +1,17 @@
+export function buildQueryString(params) {
+    if (!params)
+        return '';
+    const search = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+        if (value !== undefined)
+            search.append(key, String(value));
+    }
+    const qs = search.toString();
+    return qs ? `?${qs}` : '';
+}
+export function buildURL(baseURL, url, params) {
+    const isAbsolute = /^https?:\/\//i.test(url);
+    const base = isAbsolute ? '' : (baseURL ?? '');
+    const full = `${base}${url}`;
+    return `${full}${buildQueryString(params)}`;
+}

package/dist/ws/WebSocketClient.d.ts

@@ -0,0 +1,23 @@
+type WSEvent = 'open' | 'message' | 'close' | 'error';
+type Listener = (...args: unknown[]) => void;
+export interface ReconnectPolicy {
+    maxAttempts?: number;
+    delayMs?: (attempt: number) => number;
+}
+export declare class WebSocketClient {
+    private readonly url;
+    private readonly reconnect;
+    private ws?;
+    private listeners;
+    private attempt;
+    private shouldReconnect;
+    constructor(url: string, reconnect?: ReconnectPolicy);
+    connect(): void;
+    private tryReconnect;
+    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void;
+    close(code?: number, reason?: string): void;
+    on(event: WSEvent, listener: Listener): void;
+    off(event: WSEvent, listener: Listener): void;
+    private emit;
+}
+export {};

package/dist/ws/WebSocketClient.js

@@ -0,0 +1,52 @@
+export class WebSocketClient {
+    url;
+    reconnect;
+    ws;
+    listeners = new Map();
+    attempt = 0;
+    shouldReconnect = true;
+    constructor(url, reconnect = { maxAttempts: 5, delayMs: (a) => Math.min(1000 * 2 ** a, 30000) }) {
+        this.url = url;
+        this.reconnect = reconnect;
+    }
+    connect() {
+        this.shouldReconnect = true;
+        this.ws = new WebSocket(this.url);
+        this.ws.addEventListener('open', (e) => this.emit('open', e));
+        this.ws.addEventListener('message', (e) => this.emit('message', e.data));
+        this.ws.addEventListener('close', (e) => {
+            this.emit('close', e);
+            if (this.shouldReconnect)
+                this.tryReconnect();
+        });
+        this.ws.addEventListener('error', (e) => this.emit('error', e));
+    }
+    tryReconnect() {
+        const max = this.reconnect.maxAttempts ?? 5;
+        if (this.attempt >= max)
+            return;
+        const delay = this.reconnect.delayMs?.(this.attempt) ?? 1000;
+        this.attempt++;
+        setTimeout(() => this.connect(), delay);
+    }
+    send(data) {
+        this.ws?.send(data);
+    }
+    close(code, reason) {
+        this.shouldReconnect = false;
+        this.ws?.close(code, reason);
+    }
+    on(event, listener) {
+        if (!this.listeners.has(event))
+            this.listeners.set(event, new Set());
+        this.listeners.get(event).add(listener);
+    }
+    off(event, listener) {
+        this.listeners.get(event)?.delete(listener);
+    }
+    emit(event, ...args) {
+        this.listeners.get(event)?.forEach((l) => l(...args));
+        if (event === 'open')
+            this.attempt = 0;
+    }
+}

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@yxcinebendjebbar/asdc",
+  "version": "0.0.4",
+  "description": "A zero-dependency, OOP HTTP/WebSocket/RPC client designed to be ported cleanly to other languages",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "http",
+    "fetch",
+    "websocket",
+    "json-rpc",
+    "api",
+    "client",
+    "oop",
+    "zero-dependency"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yxcinebendjebbar/asdc"
+  },
+  "author": "yxcinebendjebbar",
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build",
+    "test": "node --experimental-transform-types --test test/**/*.test.ts"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^26.4.0",
+    "typescript": "^5.5.0"
+  }
+}