@nozich/api 1.0.0

package/circuit-breaker.ts

@@ -0,0 +1,68 @@
+export enum CircuitState {
+  CLOSED,
+  OPEN,
+  HALF_OPEN,
+}
+
+interface CircuitBreakerOptions {
+  failureThreshold: number;
+  resetTimeoutMs: number;
+}
+
+export class CircuitBreaker {
+  private state: CircuitState = CircuitState.CLOSED;
+  private failures = 0;
+  private lastFailureTime = 0;
+  private readonly failureThreshold: number;
+  private readonly resetTimeoutMs: number;
+
+  constructor(
+    options: CircuitBreakerOptions = {
+      failureThreshold: 5,
+      resetTimeoutMs: 10000,
+    },
+  ) {
+    this.failureThreshold = options.failureThreshold;
+    this.resetTimeoutMs = options.resetTimeoutMs;
+  }
+
+  public async execute<T>(action: () => Promise<T>): Promise<T> {
+    if (this.state === CircuitState.OPEN) {
+      if (Date.now() - this.lastFailureTime > this.resetTimeoutMs) {
+        this.state = CircuitState.HALF_OPEN;
+      } else {
+        throw new Error('Circuit Breaker is OPEN');
+      }
+    }
+
+    try {
+      const result = await action();
+      this.onSuccess();
+      return result;
+    } catch (error) {
+      this.onFailure();
+      throw error;
+    }
+  }
+
+  private onSuccess() {
+    this.failures = 0;
+    this.state = CircuitState.CLOSED;
+  }
+
+  private onFailure() {
+    this.failures++;
+    this.lastFailureTime = Date.now();
+
+    if (
+      this.state === CircuitState.HALF_OPEN ||
+      this.failures >= this.failureThreshold
+    ) {
+      this.state = CircuitState.OPEN;
+    }
+  }
+
+  public getState(): CircuitState {
+    return this.state;
+  }
+}

package/dist/circuit-breaker.d.ts

@@ -0,0 +1,22 @@
+export declare enum CircuitState {
+    CLOSED = 0,
+    OPEN = 1,
+    HALF_OPEN = 2
+}
+interface CircuitBreakerOptions {
+    failureThreshold: number;
+    resetTimeoutMs: number;
+}
+export declare class CircuitBreaker {
+    private state;
+    private failures;
+    private lastFailureTime;
+    private readonly failureThreshold;
+    private readonly resetTimeoutMs;
+    constructor(options?: CircuitBreakerOptions);
+    execute<T>(action: () => Promise<T>): Promise<T>;
+    private onSuccess;
+    private onFailure;
+    getState(): CircuitState;
+}
+export {};

package/dist/circuit-breaker.js

@@ -0,0 +1,52 @@
+export var CircuitState;
+(function (CircuitState) {
+    CircuitState[CircuitState["CLOSED"] = 0] = "CLOSED";
+    CircuitState[CircuitState["OPEN"] = 1] = "OPEN";
+    CircuitState[CircuitState["HALF_OPEN"] = 2] = "HALF_OPEN";
+})(CircuitState || (CircuitState = {}));
+export class CircuitBreaker {
+    constructor(options = {
+        failureThreshold: 5,
+        resetTimeoutMs: 10000,
+    }) {
+        this.state = CircuitState.CLOSED;
+        this.failures = 0;
+        this.lastFailureTime = 0;
+        this.failureThreshold = options.failureThreshold;
+        this.resetTimeoutMs = options.resetTimeoutMs;
+    }
+    async execute(action) {
+        if (this.state === CircuitState.OPEN) {
+            if (Date.now() - this.lastFailureTime > this.resetTimeoutMs) {
+                this.state = CircuitState.HALF_OPEN;
+            }
+            else {
+                throw new Error('Circuit Breaker is OPEN');
+            }
+        }
+        try {
+            const result = await action();
+            this.onSuccess();
+            return result;
+        }
+        catch (error) {
+            this.onFailure();
+            throw error;
+        }
+    }
+    onSuccess() {
+        this.failures = 0;
+        this.state = CircuitState.CLOSED;
+    }
+    onFailure() {
+        this.failures++;
+        this.lastFailureTime = Date.now();
+        if (this.state === CircuitState.HALF_OPEN ||
+            this.failures >= this.failureThreshold) {
+            this.state = CircuitState.OPEN;
+        }
+    }
+    getState() {
+        return this.state;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,44 @@
+import { ApiResponse } from '@nozich/types';
+export interface ApiConfig {
+    baseUrl: string;
+    projectId: string;
+    tokens?: {
+        getToken?: () => string | null | Promise<string | null>;
+    };
+    adapters?: {
+        socket?: any;
+        notifications?: any;
+    };
+}
+export declare class ApiClient {
+    private readonly config;
+    private ws;
+    private wsFailures;
+    private forceHttp;
+    private readonly MAX_WS_FAILURES;
+    private readonly circuitBreaker;
+    private wsConnected;
+    private readonly listeners;
+    private readonly pendingRequests;
+    private heartbeatInterval;
+    constructor(config: ApiConfig);
+    private getToken;
+    setToken(token: string): Promise<void>;
+    subscribe<T>(event: string, callback: (payload: T) => void): () => void;
+    unsubscribe(event: string, callback: (payload: any) => void): void;
+    private connectWs;
+    private startHeartbeat;
+    private sendWs;
+    private dispatch;
+    private handleWsError;
+    request<T>(endpoint: string, options?: RequestInit & {
+        silent?: boolean;
+    }): Promise<ApiResponse<T>>;
+    private requestHttp;
+    get<T>(endpoint: string, query?: any, options?: RequestInit): Promise<ApiResponse<T>>;
+    post<T>(endpoint: string, body?: any, options?: RequestInit): Promise<ApiResponse<T>>;
+    put<T>(endpoint: string, body?: any, options?: RequestInit): Promise<ApiResponse<T>>;
+    patch<T>(endpoint: string, body?: any, options?: RequestInit): Promise<ApiResponse<T>>;
+    delete<T>(endpoint: string, body?: any, options?: RequestInit): Promise<ApiResponse<T>>;
+}
+export declare const createApiClient: (config: ApiConfig) => ApiClient;

package/dist/index.js

@@ -0,0 +1,284 @@
+import { nanoid } from 'nanoid';
+import SuperJSON from 'superjson';
+import { CircuitBreaker } from './circuit-breaker';
+export class ApiClient {
+    constructor(config) {
+        this.ws = null;
+        this.wsFailures = 0;
+        this.forceHttp = false;
+        this.MAX_WS_FAILURES = 3;
+        this.wsConnected = false;
+        this.listeners = new Map();
+        this.pendingRequests = new Map();
+        this.heartbeatInterval = null;
+        this.config = config;
+        this.circuitBreaker = new CircuitBreaker();
+        this.connectWs();
+    }
+    async getToken() {
+        if (this.config.tokens?.getToken) {
+            return await this.config.tokens.getToken();
+        }
+        return null;
+    }
+    async setToken(token) {
+        // Legacy support? Or just rely on getToken?
+        // In new design, we pull token from callback.
+        // But socket might need immediate push.
+        if (this.wsConnected && this.ws) {
+            this.sendWs({ type: 'auth.identify', payload: { token }, id: nanoid() });
+        }
+    }
+    subscribe(event, callback) {
+        if (!this.listeners.has(event)) {
+            this.listeners.set(event, []);
+        }
+        this.listeners.get(event)?.push(callback);
+        return () => this.unsubscribe(event, callback);
+    }
+    unsubscribe(event, callback) {
+        const list = this.listeners.get(event);
+        if (!list)
+            return;
+        this.listeners.set(event, list.filter((cb) => cb !== callback));
+    }
+    connectWs() {
+        if (this.config.adapters?.socket) {
+            // Use external socket adapter if provided (e.g. from Panel's useSocket store)
+            this.ws = this.config.adapters.socket;
+            return;
+        }
+        if (this.forceHttp)
+            return;
+        if (typeof WebSocket === 'undefined')
+            return;
+        try {
+            const wsUrl = this.config.baseUrl.replace('http', 'ws') + '/ws';
+            this.ws = new WebSocket(wsUrl);
+            this.ws.onopen = async () => {
+                this.wsFailures = 0;
+                this.wsConnected = true;
+                console.log('[API] WS Connected');
+                this.startHeartbeat();
+                const token = await this.getToken();
+                // Auto-identify if token exists
+                if (token) {
+                    this.sendWs({
+                        type: 'auth.identify',
+                        payload: { token },
+                        id: nanoid(),
+                    });
+                }
+            };
+            this.ws.onmessage = (event) => {
+                try {
+                    const data = JSON.parse(event.data.toString());
+                    // 1. Handle Request Correlation (Standard)
+                    if (data.id && this.pendingRequests.has(data.id)) {
+                        const req = this.pendingRequests.get(data.id);
+                        if (req) {
+                            clearTimeout(req.timer);
+                            this.pendingRequests.delete(data.id);
+                            if (data.type === 'error') {
+                                req.reject(new Error(data.payload?.message || 'Unknown WS Error'));
+                            }
+                            else {
+                                req.resolve(data.payload);
+                            }
+                            return; // Handled as response
+                        }
+                    }
+                    // 2. Handle Events
+                    if (data.type) {
+                        this.dispatch(data.type, data.payload);
+                    }
+                }
+                catch (e) {
+                    console.error('[API] WS Parse Error', e);
+                }
+            };
+            this.ws.onerror = () => {
+                this.handleWsError();
+            };
+            this.ws.onclose = () => {
+                this.wsConnected = false;
+                if (this.heartbeatInterval)
+                    clearInterval(this.heartbeatInterval);
+                // Reject all pending requests
+                for (const [id, req] of this.pendingRequests) {
+                    clearTimeout(req.timer);
+                    req.reject(new Error('WS Closed'));
+                }
+                this.pendingRequests.clear();
+                // Exponential backoff
+                if (!this.forceHttp) {
+                    const delay = Math.min(30000, 1000 * Math.pow(2, this.wsFailures));
+                    console.log(`[API] Reconnecting WS in ${delay}ms...`);
+                    setTimeout(() => this.connectWs(), delay);
+                }
+            };
+        }
+        catch (e) {
+            this.handleWsError();
+        }
+    }
+    startHeartbeat() {
+        if (this.heartbeatInterval)
+            clearInterval(this.heartbeatInterval);
+        this.heartbeatInterval = setInterval(() => {
+            if (this.ws?.readyState === WebSocket.OPEN) {
+                this.ws.send(JSON.stringify({ type: 'ping', payload: Date.now() }));
+            }
+        }, 30000);
+    }
+    sendWs(event) {
+        if (this.ws?.readyState === WebSocket.OPEN) {
+            this.ws.send(JSON.stringify(event));
+        }
+    }
+    dispatch(type, payload) {
+        const callbacks = this.listeners.get(type);
+        callbacks?.forEach((cb) => cb(payload));
+    }
+    handleWsError() {
+        this.wsFailures++;
+        console.warn(`[API] WS Error (${this.wsFailures}/${this.MAX_WS_FAILURES})`);
+        if (this.wsFailures >= this.MAX_WS_FAILURES) {
+            this.forceHttp = true;
+            console.error('[API] WS Circuit Breaker Tripped. Locked to HTTP.');
+            this.ws?.close();
+            this.ws = null;
+        }
+    }
+    async request(endpoint, options = {}) {
+        const isSock = this.ws &&
+            this.ws.readyState === WebSocket.OPEN &&
+            !this.forceHttp &&
+            options.method !== 'HEAD'; // HEAD not supported over WS usually?
+        // In original code: const isSock = useSocket.getState().readyState === socketStates.OPEN && opt.type !== 'fetch';
+        // We try to use WS if connected.
+        if (isSock) {
+            return new Promise((resolve, reject) => {
+                const id = nanoid();
+                const timer = setTimeout(() => {
+                    if (this.pendingRequests.has(id)) {
+                        this.pendingRequests.delete(id);
+                        console.warn(`[API] WS Request Timeout for ${endpoint}, falling back to HTTP`);
+                        this.requestHttp(endpoint, options).then(resolve).catch(reject);
+                    }
+                }, 5000); // 5s timeout
+                this.pendingRequests.set(id, { resolve, reject, timer });
+                this.sendWs({
+                    type: 'api.request',
+                    payload: {
+                        path: endpoint,
+                        method: options?.method || 'GET',
+                        body: options?.body
+                            ? JSON.parse(options.body)
+                            : undefined,
+                    },
+                    id,
+                });
+            });
+        }
+        // 2. HTTP Fallback with Circuit Breaker
+        return this.requestHttp(endpoint, options);
+    }
+    async requestHttp(endpoint, options = {}) {
+        try {
+            return await this.circuitBreaker.execute(async () => {
+                let url = `${this.config.baseUrl}/${endpoint}`;
+                // Handle GET query params if body is present (SuperJSON behavior from original file)
+                if (['GET', 'HEAD'].includes(options.method || 'GET') && options.body) {
+                    // It seems options.body is stringified already by wrapper methods?
+                    // Wrapper methods below create JSON string.
+                    // We need to parse it back if we want to put it in QP? Or just trust caller?
+                    // Original: path = path + '?' + new URLSearchParams({ q: SuperJSON.stringify(opt.body) }).toString();
+                    // Here options.body is currently stringified JSON standard.
+                    // Let's assume wrapper passes object if it's GET? No, wrapper stringifies.
+                    // We should change wrapper to NOT stringify for GET?
+                }
+                const token = await this.getToken();
+                const headers = {
+                    'Content-Type': 'application/json',
+                    'X-Project-ID': this.config.projectId,
+                    ...(token ? { Authorization: `Bearer ${token}` } : {}),
+                    ...options?.headers,
+                };
+                const res = await fetch(url, { ...options, headers });
+                const text = await res.text();
+                // SuperJSON parse? Or standard?
+                // Original used:
+                // if (isJson(message)) { message = JSON.parse(message); }
+                // Let's standard JSON parse for now unless SuperJSON is enforced by server.
+                // If server returns SuperJSON, we need SuperJSON.parse.
+                let json;
+                try {
+                    json = JSON.parse(text);
+                }
+                catch {
+                    return text;
+                }
+                if (!res.ok) {
+                    const error = json.error || {
+                        code: `HTTP_${res.status}`,
+                        message: json.message || res.statusText,
+                        details: json.details,
+                    };
+                    throw new Error(error.message || JSON.stringify(error));
+                }
+                return json;
+            });
+        }
+        catch (error) {
+            if (!options.silent && this.config.adapters?.notifications) {
+                this.config.adapters.notifications.show({
+                    color: 'red',
+                    title: 'Error',
+                    message: error.message || 'Unknown Error',
+                });
+            }
+            throw error;
+        }
+    }
+    get(endpoint, query, options) {
+        // If query is object, we should maybe append to URL?
+        // Original code: if (['GET', 'HEAD'].includes(opt.method) && opt.body) ... q=SuperJSON(body)
+        if (query) {
+            endpoint =
+                endpoint +
+                    '?' +
+                    new URLSearchParams({ q: SuperJSON.stringify(query) }).toString();
+        }
+        return this.request(endpoint, { ...options, method: 'GET' });
+    }
+    post(endpoint, body, options) {
+        return this.request(endpoint, {
+            ...options,
+            method: 'POST',
+            body: SuperJSON.stringify(body),
+        });
+    }
+    put(endpoint, body, options) {
+        return this.request(endpoint, {
+            ...options,
+            method: 'PUT',
+            body: SuperJSON.stringify(body),
+        });
+    }
+    patch(endpoint, body, options) {
+        return this.request(endpoint, {
+            ...options,
+            method: 'PATCH',
+            body: SuperJSON.stringify(body),
+        });
+    }
+    delete(endpoint, body, options) {
+        return this.request(endpoint, {
+            ...options,
+            method: 'DELETE',
+            body: body ? SuperJSON.stringify(body) : undefined,
+        });
+    }
+}
+export const createApiClient = (config) => new ApiClient(config);

package/index.ts

@@ -0,0 +1,360 @@
+import { ApiResponse } from '@nozich/types';
+import { nanoid } from 'nanoid';
+import SuperJSON from 'superjson';
+
+export interface ApiConfig {
+  baseUrl: string;
+  projectId: string;
+  tokens?: {
+    getToken?: () => string | null | Promise<string | null>;
+  };
+  adapters?: {
+    socket?: any; // Socket adapter
+    notifications?: any;
+  };
+}
+
+import { CircuitBreaker } from './circuit-breaker';
+
+interface PendingRequest {
+  resolve: (value: any) => void;
+  reject: (reason?: any) => void;
+  timer: ReturnType<typeof setTimeout>;
+}
+
+export class ApiClient {
+  private readonly config: ApiConfig;
+  private ws: WebSocket | null = null;
+  private wsFailures = 0;
+  private forceHttp = false;
+  private readonly MAX_WS_FAILURES = 3;
+  private readonly circuitBreaker: CircuitBreaker;
+
+  private wsConnected = false;
+  private readonly listeners: Map<string, ((payload: any) => void)[]> =
+    new Map();
+  private readonly pendingRequests = new Map<string, PendingRequest>();
+  private heartbeatInterval: ReturnType<typeof setInterval> | null = null;
+
+  constructor(config: ApiConfig) {
+    this.config = config;
+    this.circuitBreaker = new CircuitBreaker();
+    this.connectWs();
+  }
+
+  private async getToken(): Promise<string | null> {
+    if (this.config.tokens?.getToken) {
+      return await this.config.tokens.getToken();
+    }
+    return null;
+  }
+
+  public async setToken(token: string) {
+    // Legacy support? Or just rely on getToken?
+    // In new design, we pull token from callback.
+    // But socket might need immediate push.
+    if (this.wsConnected && this.ws) {
+      this.sendWs({ type: 'auth.identify', payload: { token }, id: nanoid() });
+    }
+  }
+
+  public subscribe<T>(event: string, callback: (payload: T) => void) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)?.push(callback);
+    return () => this.unsubscribe(event, callback);
+  }
+
+  public unsubscribe(event: string, callback: (payload: any) => void) {
+    const list = this.listeners.get(event);
+    if (!list) return;
+    this.listeners.set(
+      event,
+      list.filter((cb) => cb !== callback),
+    );
+  }
+
+  private connectWs() {
+    if (this.config.adapters?.socket) {
+      // Use external socket adapter if provided (e.g. from Panel's useSocket store)
+      this.ws = this.config.adapters.socket;
+      return;
+    }
+
+    if (this.forceHttp) return;
+    if (typeof WebSocket === 'undefined') return;
+
+    try {
+      const wsUrl = this.config.baseUrl.replace('http', 'ws') + '/ws';
+      this.ws = new WebSocket(wsUrl);
+
+      this.ws.onopen = async () => {
+        this.wsFailures = 0;
+        this.wsConnected = true;
+        console.log('[API] WS Connected');
+        this.startHeartbeat();
+
+        const token = await this.getToken();
+
+        // Auto-identify if token exists
+        if (token) {
+          this.sendWs({
+            type: 'auth.identify',
+            payload: { token },
+            id: nanoid(),
+          });
+        }
+      };
+
+      this.ws.onmessage = (event) => {
+        try {
+          const data = JSON.parse(event.data.toString());
+
+          // 1. Handle Request Correlation (Standard)
+          if (data.id && this.pendingRequests.has(data.id)) {
+            const req = this.pendingRequests.get(data.id);
+            if (req) {
+              clearTimeout(req.timer);
+              this.pendingRequests.delete(data.id);
+
+              if (data.type === 'error') {
+                req.reject(
+                  new Error(data.payload?.message || 'Unknown WS Error'),
+                );
+              } else {
+                req.resolve(data.payload);
+              }
+              return; // Handled as response
+            }
+          }
+
+          // 2. Handle Events
+          if (data.type) {
+            this.dispatch(data.type, data.payload);
+          }
+        } catch (e) {
+          console.error('[API] WS Parse Error', e);
+        }
+      };
+
+      this.ws.onerror = () => {
+        this.handleWsError();
+      };
+
+      this.ws.onclose = () => {
+        this.wsConnected = false;
+        if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+
+        // Reject all pending requests
+        for (const [id, req] of this.pendingRequests) {
+          clearTimeout(req.timer);
+          req.reject(new Error('WS Closed'));
+        }
+        this.pendingRequests.clear();
+
+        // Exponential backoff
+        if (!this.forceHttp) {
+          const delay = Math.min(30000, 1000 * Math.pow(2, this.wsFailures));
+          console.log(`[API] Reconnecting WS in ${delay}ms...`);
+          setTimeout(() => this.connectWs(), delay);
+        }
+      };
+    } catch (e) {
+      this.handleWsError();
+    }
+  }
+
+  private startHeartbeat() {
+    if (this.heartbeatInterval) clearInterval(this.heartbeatInterval);
+    this.heartbeatInterval = setInterval(() => {
+      if (this.ws?.readyState === WebSocket.OPEN) {
+        this.ws.send(JSON.stringify({ type: 'ping', payload: Date.now() }));
+      }
+    }, 30000);
+  }
+
+  private sendWs(event: { type: string; payload: any; id?: string }) {
+    if (this.ws?.readyState === WebSocket.OPEN) {
+      this.ws.send(JSON.stringify(event));
+    }
+  }
+
+  private dispatch(type: string, payload: any) {
+    const callbacks = this.listeners.get(type);
+    callbacks?.forEach((cb) => cb(payload));
+  }
+
+  private handleWsError() {
+    this.wsFailures++;
+    console.warn(`[API] WS Error (${this.wsFailures}/${this.MAX_WS_FAILURES})`);
+
+    if (this.wsFailures >= this.MAX_WS_FAILURES) {
+      this.forceHttp = true;
+      console.error('[API] WS Circuit Breaker Tripped. Locked to HTTP.');
+      this.ws?.close();
+      this.ws = null;
+    }
+  }
+
+  async request<T>(
+    endpoint: string,
+    options: RequestInit & { silent?: boolean } = {},
+  ): Promise<ApiResponse<T>> {
+    const isSock =
+      this.ws &&
+      this.ws.readyState === WebSocket.OPEN &&
+      !this.forceHttp &&
+      options.method !== 'HEAD'; // HEAD not supported over WS usually?
+
+    // In original code: const isSock = useSocket.getState().readyState === socketStates.OPEN && opt.type !== 'fetch';
+    // We try to use WS if connected.
+
+    if (isSock) {
+      return new Promise<ApiResponse<T>>((resolve, reject) => {
+        const id = nanoid();
+        const timer = setTimeout(() => {
+          if (this.pendingRequests.has(id)) {
+            this.pendingRequests.delete(id);
+            console.warn(
+              `[API] WS Request Timeout for ${endpoint}, falling back to HTTP`,
+            );
+            this.requestHttp<T>(endpoint, options).then(resolve).catch(reject);
+          }
+        }, 5000); // 5s timeout
+
+        this.pendingRequests.set(id, { resolve, reject, timer });
+
+        this.sendWs({
+          type: 'api.request',
+          payload: {
+            path: endpoint,
+            method: options?.method || 'GET',
+            body: options?.body
+              ? JSON.parse(options.body as string)
+              : undefined,
+          },
+          id,
+        });
+      });
+    }
+
+    // 2. HTTP Fallback with Circuit Breaker
+    return this.requestHttp<T>(endpoint, options);
+  }
+
+  private async requestHttp<T>(
+    endpoint: string,
+    options: RequestInit & { silent?: boolean } = {},
+  ): Promise<ApiResponse<T>> {
+    try {
+      return await this.circuitBreaker.execute(async () => {
+        let url = `${this.config.baseUrl}/${endpoint}`;
+
+        // Handle GET query params if body is present (SuperJSON behavior from original file)
+        if (['GET', 'HEAD'].includes(options.method || 'GET') && options.body) {
+          // It seems options.body is stringified already by wrapper methods?
+          // Wrapper methods below create JSON string.
+          // We need to parse it back if we want to put it in QP? Or just trust caller?
+          // Original: path = path + '?' + new URLSearchParams({ q: SuperJSON.stringify(opt.body) }).toString();
+          // Here options.body is currently stringified JSON standard.
+          // Let's assume wrapper passes object if it's GET? No, wrapper stringifies.
+          // We should change wrapper to NOT stringify for GET?
+        }
+
+        const token = await this.getToken();
+
+        const headers: Record<string, string> = {
+          'Content-Type': 'application/json',
+          'X-Project-ID': this.config.projectId,
+          ...(token ? { Authorization: `Bearer ${token}` } : {}),
+          ...(options?.headers as any),
+        };
+
+        const res = await fetch(url, { ...options, headers });
+        const text = await res.text();
+
+        // SuperJSON parse? Or standard?
+        // Original used:
+        // if (isJson(message)) { message = JSON.parse(message); }
+        // Let's standard JSON parse for now unless SuperJSON is enforced by server.
+        // If server returns SuperJSON, we need SuperJSON.parse.
+
+        let json;
+        try {
+          json = JSON.parse(text);
+        } catch {
+          return text as any;
+        }
+
+        if (!res.ok) {
+          const error = json.error || {
+            code: `HTTP_${res.status}`,
+            message: json.message || res.statusText,
+            details: json.details,
+          };
+          throw new Error(error.message || JSON.stringify(error));
+        }
+
+        return json as ApiResponse<T>;
+      });
+    } catch (error: any) {
+      if (!options.silent && this.config.adapters?.notifications) {
+        this.config.adapters.notifications.show({
+          color: 'red',
+          title: 'Error',
+          message: error.message || 'Unknown Error',
+        });
+      }
+      throw error;
+    }
+  }
+
+  public get<T>(endpoint: string, query?: any, options?: RequestInit) {
+    // If query is object, we should maybe append to URL?
+    // Original code: if (['GET', 'HEAD'].includes(opt.method) && opt.body) ... q=SuperJSON(body)
+
+    if (query) {
+      endpoint =
+        endpoint +
+        '?' +
+        new URLSearchParams({ q: SuperJSON.stringify(query) }).toString();
+    }
+
+    return this.request<T>(endpoint, { ...options, method: 'GET' });
+  }
+
+  public post<T>(endpoint: string, body?: any, options?: RequestInit) {
+    return this.request<T>(endpoint, {
+      ...options,
+      method: 'POST',
+      body: SuperJSON.stringify(body),
+    });
+  }
+
+  public put<T>(endpoint: string, body?: any, options?: RequestInit) {
+    return this.request<T>(endpoint, {
+      ...options,
+      method: 'PUT',
+      body: SuperJSON.stringify(body),
+    });
+  }
+
+  public patch<T>(endpoint: string, body?: any, options?: RequestInit) {
+    return this.request<T>(endpoint, {
+      ...options,
+      method: 'PATCH',
+      body: SuperJSON.stringify(body),
+    });
+  }
+
+  public delete<T>(endpoint: string, body?: any, options?: RequestInit) {
+    return this.request<T>(endpoint, {
+      ...options,
+      method: 'DELETE',
+      body: body ? SuperJSON.stringify(body) : undefined,
+    });
+  }
+}
+
+export const createApiClient = (config: ApiConfig) => new ApiClient(config);

package/package.json

@@ -0,0 +1,28 @@
+{
+    "name": "@nozich/api",
+    "version": "1.0.0",
+    "main": "dist/index.js",
+    "types": "dist/index.d.ts",
+    "scripts": {
+        "build": "tsc",
+        "validate:api": "bun run validate-standards.ts",
+        "validate:ws": "bun run validate-ws.ts"
+    },
+    "devDependencies": {
+        "typescript": "^5.9.3"
+    },
+    "dependencies": {
+        "@nozich/types": "*",
+        "nanoid": "^5.1.6",
+        "superjson": "^2.2.1"
+    },
+    "publishConfig": {
+        "access": "public",
+        "registry": "https://registry.npmjs.org/"
+    },
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/anilcan-kara/nozich-api.git",
+        "directory": "packages/api"
+    }
+}

package/test-circuit-breaker.ts

@@ -0,0 +1,56 @@
+import { createApiClient } from './index';
+
+// Mock fetch
+const originalFetch = global.fetch;
+let mockResponse: Response | Error = new Response(JSON.stringify({}), {
+  status: 200,
+});
+
+global.fetch = async (input, init) => {
+  if (mockResponse instanceof Error) throw mockResponse;
+  return mockResponse;
+};
+
+// Helper: sleep
+const sleep = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
+
+async function testCircuitBreaker() {
+  console.log('--- Starting Circuit Breaker Test ---');
+
+  // Create client (internal circuit breaker has threshold 5, timeout 10000ms by default)
+  // For testing, we might need to export options or just hit it 5 times.
+  const client = createApiClient({
+    baseUrl: 'http://test.com',
+    projectId: 'test',
+  });
+
+  // 1. Send 5 failed requests
+  console.log('1. Simulating 5 failures...');
+  mockResponse = new Response('Server Error', { status: 500 });
+
+  for (let i = 0; i < 5; i++) {
+    const res = await client.request('/test');
+    if (res.error?.code === 'NETWORK_ERROR') {
+      console.log(`Failure ${i + 1}: Caught NETWORK_ERROR`);
+    } else {
+      console.log(`Failure ${i + 1}: Got unexpected result`, res);
+    }
+  }
+
+  // 2. Next request should fail instantly with CIRCUIT_OPEN
+  console.log('2. Sending 6th request (should trip circuit)...');
+  const resOpen = await client.request('/test');
+
+  if (resOpen.error?.code === 'CIRCUIT_OPEN') {
+    console.log('PASS: Circuit is OPEN');
+  } else {
+    console.error('FAIL: Circuit did NOT open', resOpen);
+  }
+
+  // Note: We can't easily wait 10s in this script without blocking,
+  // but we verified the state transition.
+
+  console.log('--- Test Complete ---');
+}
+
+testCircuitBreaker().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "declaration": true,
+    "outDir": "./dist",
+    "strict": true
+  },
+  "include": ["index.ts"]
+}

package/validate-standards.ts

@@ -0,0 +1,100 @@
+import { ApiErrorCode } from '@nozich/types';
+
+import { createApiClient } from './index';
+
+// Mock fetch globally
+const originalFetch = globalThis.fetch;
+
+async function runValidation() {
+  console.log('Validating API Client Standards...');
+
+  const mockResponse = {
+    success: true,
+    data: { id: 1, name: 'Test Item' },
+    meta: { page: 1 },
+  };
+
+  let lastRequest: { url: string; options: any } | null = null;
+
+  globalThis.fetch = async (url: any, options: any) => {
+    lastRequest = { url: url.toString(), options };
+    return new Response(JSON.stringify(mockResponse), {
+      status: 200,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  };
+
+  const client = createApiClient({
+    baseUrl: 'http://api.nozich.com',
+    projectId: 'test-project',
+  });
+
+  // Test GET
+  console.log('Testing GET...');
+  const res = await client.get('/items');
+
+  if (lastRequest?.options.headers['X-Project-ID'] !== 'test-project') {
+    console.error('FAIL: X-Project-ID header missing or incorrect');
+    // @ts-ignore
+    process.exit(1);
+  }
+  console.log('PASS: X-Project-ID header present');
+
+  if (!res.success || res.data?.id !== 1) {
+    console.error('FAIL: Response parsing incorrect', res);
+    // @ts-ignore
+    process.exit(1);
+  }
+  console.log('PASS: Response envelope parsed');
+
+  // Test Auth
+  console.log('Testing Auth...');
+  const testToken = 'abc-123';
+  client.setToken(testToken);
+  await client.get('/protected');
+
+  // @ts-ignore
+  const authHeader = lastRequest?.options.headers['Authorization'];
+  if (authHeader !== `Bearer ${testToken}`) {
+    console.error(
+      'FAIL: Authorization header missing or incorrect',
+      authHeader,
+    );
+    // @ts-ignore
+    process.exit(1);
+  }
+  console.log('PASS: Authorization header present');
+
+  // Test Error Handling
+  globalThis.fetch = async (url: any, options: any) => {
+    return new Response(
+      JSON.stringify({
+        success: false,
+        error: {
+          code: ApiErrorCode.VALIDATION_ERROR,
+          message: 'Something went wrong',
+        },
+      }),
+      { status: 400 },
+    );
+  };
+
+  console.log('Testing Error Handling...');
+  const errorRes = await client.post('/items', { name: 'Bad Item' });
+
+  if (
+    errorRes.success ||
+    errorRes.error?.code !== ApiErrorCode.VALIDATION_ERROR
+  ) {
+    console.error('FAIL: Error parsing incorrect', errorRes);
+    // @ts-ignore
+    process.exit(1);
+  }
+  console.log('PASS: Standard error parsed');
+
+  console.log('ALL STANDARDS VALIDATED.');
+}
+
+runValidation().finally(() => {
+  globalThis.fetch = originalFetch;
+});

package/validate-ws.ts

@@ -0,0 +1,106 @@
+import { createApiClient } from './index';
+
+// Mock WebSocket
+class MockWebSocket {
+  onopen: any;
+  onmessage: any;
+  onerror: any;
+  onclose: any;
+  readyState: number = 1; // OPEN
+
+  static OPEN = 1;
+
+  send(data: string) {
+    console.log('WS SEND:', data);
+    const parsed = JSON.parse(data);
+
+    // Auto-respond to ping
+    if (parsed.type === 'ping') {
+      // no-op, server usually doesn't need to pong back app-level for this simple contract, or maybe it does?
+      // Contract says Ping/Pong, implies standard or app level?
+      // Contract: "Heartbeat: Ping/Pong every 30s"
+      // Let's assume server sends nothing back or sends pong
+    }
+
+    // Check auth
+    if (parsed.type === 'auth.identify') {
+      setTimeout(() => {
+        if (this.onmessage) {
+          this.onmessage({
+            data: JSON.stringify({
+              type: 'auth.success',
+              payload: { userId: '1' },
+            }),
+          });
+        }
+      }, 50);
+    }
+  }
+
+  close() {
+    console.log('WS CLOSED');
+  }
+}
+
+// @ts-ignore
+globalThis.WebSocket = MockWebSocket;
+
+async function runTest() {
+  console.log('Testing WebSocket Client...');
+
+  const client = createApiClient({
+    baseUrl: 'http://api.test.com',
+    projectId: 'test',
+  });
+
+  // Test 1: Connect and Auth
+  console.log('Test 1: Auth');
+  client.setToken('my-token');
+
+  // Wait for WS to trigger (it's async in construction/setToken)
+  await new Promise((r) => setTimeout(r, 100));
+
+  // Test 2: Subscription
+  console.log('Test 2: Subscription');
+  return new Promise<void>((resolve, reject) => {
+    const unsub = client.subscribe('data.update', (payload: any) => {
+      console.log('RECEIVED EVENT:', payload);
+      if (payload.value === 123) {
+        console.log('PASS: Received data.update');
+        resolve();
+      } else {
+        reject(new Error('Wrong payload'));
+      }
+    });
+
+    // Simulate server push
+    // We need access to the mock instance or just simulate via the event loop if we could hook into it.
+    // Since we mocked the class, we can find the instance if we stored it, or just use a dirty hack in the MockWebSocket to trigger it?
+    // Actually, `client` has the `ws` instance private.
+    // For this test, let's verify `setToken` triggered the send (saw in logs).
+    // And to test `subscribe`, we need to simulate an incoming message.
+
+    // Let's simulate incoming message by hacking the MockWebSocket prototype or just ...
+    // Better: modifying MockWebSocket to emit an event content after a delay.
+
+    setTimeout(() => {
+      // @ts-ignore
+      if (client['ws'] && client['ws'].onmessage) {
+        // @ts-ignore
+        client['ws'].onmessage({
+          data: JSON.stringify({
+            type: 'data.update',
+            payload: { value: 123 },
+          }),
+        });
+      }
+    }, 200);
+  });
+}
+
+runTest()
+  .then(() => console.log('WS VALIDATION PASSED'))
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });