@nozich/api 1.0.0 → 1.0.1

package/index.ts

@@ -2,6 +2,10 @@ import { ApiResponse } from '@nozich/types';
 import { nanoid } from 'nanoid';
 import SuperJSON from 'superjson';
 
+export * from './src/contracts/auth';
+export * from './src/contracts/chat';
+export * from './src/contracts/fortune';
+
 export interface ApiConfig {
   baseUrl: string;
   projectId: string;

package/package.json

@@ -1,10 +1,13 @@
 {
     "name": "@nozich/api",
-    "version": "1.0.0",
+    "version": "1.0.1",
     "main": "dist/index.js",
     "types": "dist/index.d.ts",
     "scripts": {
-        "build": "tsc",
+        "clean": "rm -rf dist",
+        "build": "npm run clean && tsc",
+        "prepublishOnly": "npm run build",
+        "publish:npm": "npm publish --access public",
         "validate:api": "bun run validate-standards.ts",
         "validate:ws": "bun run validate-ws.ts"
     },
@@ -14,7 +17,7 @@
     "dependencies": {
         "@nozich/types": "*",
         "nanoid": "^5.1.6",
-        "superjson": "^2.2.1"
+        "superjson": "^2.2.6"
     },
     "publishConfig": {
         "access": "public",
@@ -22,7 +25,7 @@
     },
     "repository": {
         "type": "git",
-        "url": "git+https://github.com/anilcan-kara/nozich-api.git",
+        "url": "git+https://github.com/anilcan-kara/api.git",
         "directory": "packages/api"
     }
 }

package/src/contracts/auth.ts

@@ -0,0 +1,25 @@
+import { User } from '@nozich/types';
+
+export interface AuthContract {
+  'auth.login': {
+    payload: {
+      email: string;
+      password?: string;
+      provider?: string;
+      token?: string;
+    };
+    response: { token: string; user: User };
+  };
+  'auth.register': {
+    payload: { email: string; password?: string; name?: string };
+    response: { token: string; user: User };
+  };
+  'auth.me': {
+    payload: {};
+    response: { user: User };
+  };
+  'auth.refresh': {
+    payload: { refreshToken: string };
+    response: { token: string };
+  };
+}

package/src/contracts/chat.ts

@@ -0,0 +1,23 @@
+export interface Message {
+  role: 'system' | 'user' | 'assistant';
+  content: string;
+}
+
+export interface ChatContract {
+  'chat.completions': {
+    payload: {
+      messages: Message[];
+      model?: string;
+      stream?: boolean;
+    };
+    // For stream=false
+    response: {
+      content: string;
+      usage?: { prompt: number; completion: number };
+    };
+  };
+  'chat.history': {
+    payload: { userId: string; limit?: number };
+    response: { messages: Message[] };
+  };
+}

package/src/contracts/fortune.ts

@@ -0,0 +1,34 @@
+export enum FortuneType {
+  COFFEE = 'coffee',
+  TAROT = 'tarot',
+  ASTROLOGY = 'astrology',
+}
+
+export interface FortuneTeller {
+  id: string;
+  name: string;
+  rating: number;
+  specialties: string[];
+  isOnline: boolean;
+}
+
+export interface FortuneContract {
+  'fortune.tellers.list': {
+    payload: { type?: FortuneType; onlineOnly?: boolean };
+    response: { tellers: FortuneTeller[] };
+  };
+  'fortune.consultations.create': {
+    payload: {
+      tellerId: string;
+      type: FortuneType;
+      question?: string;
+      media?: string[]; // URLs
+      birthDate?: string;
+    };
+    response: { consultationId: string; status: 'pending' | 'accepted' };
+  };
+  'fortune.consultations.list': {
+    payload: { status?: string };
+    response: { consultations: any[] };
+  };
+}

package/dist/circuit-breaker.d.ts

@@ -1,22 +0,0 @@
-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

@@ -1,52 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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

@@ -1,284 +0,0 @@
-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);