@vibesdotdev/client 0.1.0

package/src/lib/client/internal/generator.ts

@@ -0,0 +1,181 @@
+import type { APIResource, PathInfo, RequestOptions } from '../types.ts';
+import type { RequestBuilder } from './request-builder.ts';
+
+export interface OpenAPISpec {
+	paths?: Record<string, Record<string, unknown>>;
+	[key: string]: unknown;
+}
+
+export class APIGenerator {
+	constructor(private requestBuilder: RequestBuilder) {}
+
+	generateAPIs(
+		spec: OpenAPISpec
+	): Record<string, Record<string, (...args: unknown[]) => Promise<unknown>>> {
+		const resources = this.groupPathsByResource(spec);
+		const apis: Record<string, Record<string, (...args: unknown[]) => Promise<unknown>>> = {};
+		for (const resource of resources.values()) {
+			apis[resource.name] = this.createResourceAPI(resource);
+		}
+		return apis;
+	}
+
+	private groupPathsByResource(spec: OpenAPISpec): Map<string, APIResource> {
+		const resources = new Map<string, APIResource>();
+		for (const [path, pathItem] of Object.entries(spec.paths || {})) {
+			if (!pathItem || typeof pathItem !== 'object') continue;
+			const resourceName = this.extractResourceName(path);
+			if (!resourceName) continue;
+			let resource = resources.get(resourceName);
+			if (!resource) {
+				resource = {
+					name: resourceName,
+					basePath: this.extractBasePath(path, resourceName),
+					operations: new Map()
+				};
+				resources.set(resourceName, resource);
+			}
+			const methods = ['get', 'post', 'put', 'patch', 'delete'] as const;
+			for (const method of methods) {
+				const operation = (pathItem as Record<string, unknown>)[method];
+				if (operation && typeof operation === 'object' && 'responses' in operation) {
+					const op = operation as Record<string, unknown>;
+					const pi = pathItem as Record<string, unknown>;
+					const opParams = (op.parameters || []) as Record<string, unknown>[];
+					const piParams = (pi.parameters || []) as Record<string, unknown>[];
+					const pathInfo: PathInfo = {
+						path,
+						method: method.toUpperCase(),
+						operationId: op.operationId as string | undefined,
+						parameters: [...piParams, ...opParams],
+						requestBody: op.requestBody as Record<string, unknown> | undefined,
+						responses: op.responses as Record<string, unknown>,
+						tags: op.tags as string[] | undefined,
+						summary: op.summary as string | undefined,
+						description: op.description as string | undefined
+					};
+					const operationName = this.getOperationName(pathInfo);
+					resource.operations.set(operationName, pathInfo);
+				}
+			}
+		}
+		return resources;
+	}
+
+	private extractResourceName(path: string): string | null {
+		const segments = path.split('/').filter(Boolean);
+		if (segments[0] !== 'api' || segments.length < 2) return null;
+		return this.toCamelCase(segments[1]);
+	}
+
+	private extractBasePath(path: string, resourceName: string): string {
+		const match = path.match(/^(\/api\/[^/]+)/);
+		return match ? match[1] : `/api/${resourceName}`;
+	}
+
+	private getOperationName(pathInfo: PathInfo): string {
+		const pathParts = pathInfo.path.split('/').filter(Boolean);
+		const method = pathInfo.method.toLowerCase();
+		const hasPathParam = pathInfo.path.includes('{');
+		const resourceName = pathParts[1];
+		if (method === 'get' && !hasPathParam) {
+			return pathInfo.operationId?.toLowerCase().includes('list') ? 'list' : 'list';
+		}
+		if (method === 'get' && hasPathParam) return 'get';
+		if (method === 'post' && !hasPathParam) return 'create';
+		if ((method === 'put' || method === 'patch') && hasPathParam) return 'update';
+		if (method === 'delete' && hasPathParam) return 'delete';
+		if (pathInfo.operationId) {
+			let opName = pathInfo.operationId;
+			if (resourceName && opName.toLowerCase().startsWith(resourceName.slice(0, -1))) {
+				opName = opName.slice(resourceName.length - 1);
+			}
+			return this.toCamelCase(opName);
+		}
+		const lastPart = pathParts[pathParts.length - 1];
+		if (!lastPart.startsWith('{')) return this.toCamelCase(lastPart);
+		return method;
+	}
+
+	private createResourceAPI(
+		resource: APIResource
+	): Record<string, (...args: unknown[]) => Promise<unknown>> {
+		const api: Record<string, (...args: unknown[]) => Promise<unknown>> = {};
+		for (const [name, pathInfo] of resource.operations) {
+			api[name] = this.createOperation(pathInfo);
+		}
+		this.addConvenienceMethods(api, resource);
+		return api;
+	}
+
+	private createOperation(pathInfo: PathInfo): (...args: unknown[]) => Promise<unknown> {
+		return (...args: unknown[]) => {
+			const options = this.buildRequestOptions(pathInfo, args);
+			return this.requestBuilder.request(options);
+		};
+	}
+
+	private buildRequestOptions(pathInfo: PathInfo, args: unknown[]): RequestOptions {
+		const options: RequestOptions = { method: pathInfo.method, path: pathInfo.path };
+		const params: Record<string, unknown> = {};
+		const query: Record<string, unknown> = {};
+		let body: unknown;
+		let argIndex = 0;
+		if (pathInfo.parameters) {
+			for (const param of pathInfo.parameters) {
+				if ((param as Record<string, unknown>).in === 'path' && argIndex < args.length) {
+					params[(param as Record<string, unknown>).name as string] = args[argIndex++];
+				}
+			}
+		}
+		if (argIndex < args.length) {
+			const nextArg = args[argIndex];
+			if (typeof nextArg === 'object' && nextArg !== null) {
+				if (pathInfo.method === 'GET' || pathInfo.method === 'DELETE') {
+					Object.assign(query, nextArg);
+				} else {
+					body = nextArg;
+					argIndex++;
+					if (argIndex < args.length && typeof args[argIndex] === 'object') {
+						Object.assign(query, args[argIndex]);
+					}
+				}
+			}
+		}
+		if (Object.keys(params).length > 0) options.params = params as Record<string, string | number | boolean>;
+		if (Object.keys(query).length > 0) options.query = query as Record<string, string | number | boolean | string[] | undefined>;
+		if (body !== undefined) options.body = body;
+		return options;
+	}
+
+	private addConvenienceMethods(
+		api: Record<string, (...args: unknown[]) => Promise<unknown>>,
+		_resource: APIResource
+	): void {
+		if (api.list && !api.search) {
+			api.search = ((query: string, params?: Record<string, unknown>) => {
+				return api.list({ ...params, search: query });
+			}) as (...args: unknown[]) => Promise<unknown>;
+		}
+		if (api.get && api.create && !api.getOrCreate) {
+			api.getOrCreate = (async (id: string, data: unknown) => {
+				try {
+					return await api.get(id);
+				} catch (error: unknown) {
+					const status = (error as Record<string, unknown>).status;
+					if (status === 404) {
+						const record = data as Record<string, unknown>;
+						return await api.create(Object.assign({}, record, { id }));
+					}
+					throw error;
+				}
+			}) as (...args: unknown[]) => Promise<unknown>;
+		}
+	}
+
+	private toCamelCase(str: string): string {
+		return str
+			.replace(/[-_](.)/g, (_, char) => char.toUpperCase())
+			.replace(/^(.)/, (_, char) => char.toLowerCase());
+	}
+}

package/src/lib/client/internal/index.ts

@@ -0,0 +1,4 @@
+export { BaseAPIClient } from './base-client.ts';
+export { APIError } from './base-types.ts';
+export { Endpoint } from './endpoint.ts';
+export type { BaseAPIConfig, EndpointOptions } from './base-types.ts';

package/src/lib/client/internal/node/http2-fetch.node.ts

@@ -0,0 +1,138 @@
+import { getRuntimeEnv } from '@vibesdotdev/runtime';
+import { connect as http2Connect, type ClientHttp2Session } from 'node:http2';
+
+export function createHttp2Fetch(
+	baseUrl: string
+): (input: Parameters<typeof fetch>[0], init?: RequestInit) => Promise<Response> {
+	const sessions = new Map<string, ClientHttp2Session>();
+	const rejectUnauthorized = getRuntimeEnv('REJECT_UNAUTHORIZED') !== 'false';
+
+	return (input: Parameters<typeof fetch>[0], init?: RequestInit): Promise<Response> => {
+		const url =
+			typeof input === 'string'
+				? new URL(input, baseUrl)
+				: input instanceof URL
+					? input
+					: new URL(input.url, baseUrl);
+
+		const method = init?.method?.toUpperCase() || 'GET';
+		const headers = new Headers(init?.headers);
+		const sessionKey = `${url.protocol}//${url.host}`;
+		let session = sessions.get(sessionKey);
+
+		if (!session || session.destroyed || session.closed) {
+			try {
+				session = http2Connect(url.origin, { rejectUnauthorized });
+				sessions.set(sessionKey, session);
+				session.on('close', () => sessions.delete(sessionKey));
+				session.on('error', (error) => {
+					if (sessions.has(sessionKey)) {
+						console.warn('[http2] Session error:', error.message);
+					}
+					sessions.delete(sessionKey);
+				});
+			} catch {
+				return fetch(url.toString(), init);
+			}
+		}
+
+		return new Promise((resolve, reject) => {
+			try {
+				const http2Headers: Record<string, string> = {
+					':method': method,
+					':path': `${url.pathname}${url.search}`,
+					':scheme': url.protocol.replace(':', ''),
+					':authority': url.host
+				};
+				headers.forEach((value, key) => {
+					http2Headers[key.toLowerCase()] = value;
+				});
+				const req = session!.request(http2Headers);
+				let settled = false;
+
+				const abort = () => {
+					if (settled) return;
+					settled = true;
+					try {
+						req.close();
+						req.destroy();
+					} catch {
+						// ignore
+					}
+					const error = new Error('Request aborted');
+					error.name = 'AbortError';
+					reject(error);
+				};
+
+				const signal = init?.signal;
+				if (signal) {
+					if (signal.aborted) {
+						abort();
+						return;
+					}
+					signal.addEventListener('abort', abort, { once: true });
+				}
+
+				const cleanupAbort = () => {
+					if (!signal) return;
+					signal.removeEventListener('abort', abort);
+				};
+
+				if (init?.body) {
+					if (typeof init.body === 'string') {
+						req.write(init.body);
+					} else if (init.body instanceof Buffer) {
+						req.write(init.body);
+					}
+				}
+				req.end();
+
+				const chunks: Buffer[] = [];
+				const responseHeaders = new Headers();
+				let statusCode = 200;
+
+				req.on('response', (headers) => {
+					const statusValue = headers[':status'];
+					statusCode =
+						parseInt(Array.isArray(statusValue) ? statusValue[0] : String(statusValue ?? 200)) ||
+						200;
+					for (const [key, value] of Object.entries(headers)) {
+						if (key.startsWith(':') || value === undefined) continue;
+						if (Array.isArray(value)) value.forEach((v) => responseHeaders.append(key, v));
+						else responseHeaders.set(key, String(value));
+					}
+				});
+
+				req.on('data', (chunk) => {
+					if (typeof chunk === 'string') {
+						chunks.push(Buffer.from(chunk));
+						return;
+					}
+					chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(new Uint8Array(chunk)));
+				});
+
+				req.on('end', () => {
+					if (settled) return;
+					settled = true;
+					cleanupAbort();
+					const body = Buffer.concat(chunks);
+					resolve(
+						new Response(body, {
+							status: statusCode,
+							headers: responseHeaders
+						})
+					);
+				});
+
+				req.on('error', (error) => {
+					if (settled) return;
+					settled = true;
+					cleanupAbort();
+					reject(error);
+				});
+			} catch (error) {
+				reject(error);
+			}
+		});
+	};
+}

package/src/lib/client/internal/request-builder.ts

@@ -0,0 +1,147 @@
+import { ClientError, type AuthConfig, type RequestOptions } from '../types.ts';
+
+export class RequestBuilder {
+	constructor(
+		private baseUrl: string,
+		private auth: AuthConfig,
+		private fetchImpl: typeof fetch,
+		private timeout: number = 30000,
+		private debug: boolean = false
+	) {}
+
+	async request<T = unknown>(options: RequestOptions): Promise<T> {
+		const url = this.buildUrl(options);
+		const headers = await this.buildHeaders(options);
+		const init: RequestInit = {
+			method: options.method,
+			headers,
+			signal: this.createAbortSignal(options.timeout || this.timeout)
+		};
+		if (options.body !== undefined) {
+			if (headers.get('Content-Type')?.includes('application/json'))
+				init.body = JSON.stringify(options.body);
+			else init.body = options.body as NonNullable<RequestInit['body']>;
+		}
+		const shouldLog = this.debug || url.pathname.includes('/auth/');
+		if (shouldLog) {
+			console.info('[Client] Request:', {
+				url: url.toString(),
+				method: options.method,
+				headers: Object.fromEntries(headers.entries()),
+				body: options.body
+			});
+		}
+		try {
+			const response = await this.fetchImpl(url.toString(), init);
+			if (shouldLog) {
+				console.info('[Client] Response:', {
+					status: response.status,
+					statusText: response.statusText,
+					headers: Object.fromEntries(response.headers.entries())
+				});
+			}
+			if (!response.ok) throw await this.createError(response, options);
+			if (response.status === 204 || response.headers.get('Content-Length') === '0')
+				return undefined as T;
+			const contentType = response.headers.get('Content-Type');
+			if (contentType?.includes('application/json')) return (await response.json()) as T;
+			return (await response.text()) as T;
+		} catch (error) {
+			if (this.debug) {
+				console.error('[Client] Request failed:', {
+					url: url.toString(),
+					method: options.method,
+					error: error instanceof Error ? error.message : String(error),
+					errorName: error instanceof Error ? error.name : undefined
+				});
+			}
+			if (error instanceof Error && error.name === 'AbortError') {
+				throw new ClientError('Request timeout', 408, undefined, options);
+			}
+			throw error;
+		}
+	}
+
+	private buildUrl(options: RequestOptions): URL {
+		let path = options.path;
+		if (options.params) {
+			for (const [key, value] of Object.entries(options.params)) {
+				path = path.replace(`{${key}}`, encodeURIComponent(String(value)));
+			}
+		}
+		const url = new URL(path, this.baseUrl);
+		if (options.query) {
+			for (const [key, value] of Object.entries(options.query)) {
+				if (value === undefined) continue;
+				if (Array.isArray(value)) value.forEach((v) => url.searchParams.append(key, String(v)));
+				else url.searchParams.set(key, String(value));
+			}
+		}
+		return url;
+	}
+
+	private async buildHeaders(options: RequestOptions): Promise<Headers> {
+		const headers = new Headers(options.headers);
+		if (!headers.has('Content-Type') && options.body !== undefined)
+			headers.set('Content-Type', 'application/json');
+		if (!headers.has('Accept')) headers.set('Accept', 'application/json');
+		if (this.auth.type !== 'none') {
+			const token = this.auth.credentials || (await this.auth.tokenProvider?.());
+			if (token) {
+				switch (this.auth.type) {
+					case 'apiKey':
+					case 'bearer':
+						headers.set('Authorization', `Bearer ${token}`);
+						break;
+					case 'session':
+						headers.set('Cookie', `session=${token}`);
+						break;
+				}
+			}
+		}
+		return headers;
+	}
+
+	private createAbortSignal(timeout: number): AbortSignal {
+		const controller = new AbortController();
+		setTimeout(() => controller.abort(), timeout);
+		return controller.signal;
+	}
+
+	private async createError(response: Response, request: RequestOptions): Promise<ClientError> {
+		let message = `${response.status} ${response.statusText}`;
+		try {
+			const contentType = response.headers.get('Content-Type');
+			if (contentType?.includes('application/json')) {
+				const error = await response.json();
+				const validationErrors =
+					(error as { issues?: unknown; errors?: unknown }).issues ??
+					(error as { errors?: unknown }).errors;
+				if (Array.isArray(validationErrors) && validationErrors.length > 0) {
+					const fieldErrors = validationErrors
+						.map((issue) => {
+							const rec = issue as { path?: unknown; message?: unknown };
+							const path =
+								Array.isArray(rec.path) && rec.path.length > 0
+									? rec.path.map(String).join('.')
+									: 'unknown';
+							return `  - ${path}: ${typeof rec.message === 'string' ? rec.message : 'Invalid'}`;
+						})
+						.join('\n');
+					message = `Validation failed:\n${fieldErrors}`;
+				} else if (typeof (error as { message?: unknown }).message === 'string') {
+					message = (error as { message: string }).message;
+				} else if ((error as { error?: unknown }).error !== undefined) {
+					const e = (error as { error: unknown }).error;
+					message = typeof e === 'string' ? e : JSON.stringify(e);
+				}
+			} else {
+				const text = await response.text();
+				if (text) message = text;
+			}
+		} catch {
+			// ignore parsing errors
+		}
+		return new ClientError(message, response.status, response, request);
+	}
+}

package/src/lib/client/internal/sse-stream.ts

@@ -0,0 +1,130 @@
+import { type AuthConfig, type RequestOptions, ClientError } from '../types.ts';
+
+export interface SSEEvent<T = unknown> {
+	event?: string;
+	data: T;
+	id?: string;
+	retry?: number;
+}
+
+export type SSEStreamOptions = {
+	method?: string;
+	params?: Record<string, string | number | boolean>;
+	query?: Record<string, string | number | boolean | string[] | undefined>;
+	body?: unknown;
+	headers?: Record<string, string>;
+	timeout?: number;
+};
+
+export async function* streamSSE<T = unknown>(args: {
+	baseUrl: string;
+	auth: AuthConfig;
+	fetchImpl: typeof fetch;
+	path: string;
+	options?: SSEStreamOptions;
+}): AsyncIterableIterator<SSEEvent<T>> {
+	const options = args.options ?? {};
+	let url = `${args.baseUrl}${args.path}`;
+	if (options.params) {
+		for (const [key, value] of Object.entries(options.params)) {
+			url = url.replace(`:${key}`, String(value));
+			url = url.replace(`{${key}}`, String(value));
+		}
+	}
+	if (options.query) {
+		const searchParams = new URLSearchParams();
+		for (const [key, value] of Object.entries(options.query)) {
+			if (value === undefined || value === null) continue;
+			if (Array.isArray(value)) value.forEach((v) => searchParams.append(key, String(v)));
+			else searchParams.append(key, String(value));
+		}
+		const queryString = searchParams.toString();
+		if (queryString) url += `?${queryString}`;
+	}
+	const headers: Record<string, string> = { Accept: 'text/event-stream', ...options.headers };
+	if (!('Content-Type' in headers)) headers['Content-Type'] = 'application/json';
+	if (args.auth.type === 'apiKey' && args.auth.credentials) {
+		headers['X-API-Key'] = args.auth.credentials;
+	} else if (args.auth.type === 'bearer') {
+		const token = args.auth.tokenProvider ? await args.auth.tokenProvider() : args.auth.credentials;
+		if (token) headers.Authorization = `Bearer ${token}`;
+	}
+	const requestOptions: RequestOptions = {
+		method: options.method || 'POST',
+		path: args.path,
+		params: options.params,
+		query: options.query,
+		body: options.body,
+		headers: options.headers,
+		timeout: options.timeout
+	};
+	const requestInit: RequestInit = { method: requestOptions.method, headers };
+	if (requestOptions.timeout) {
+		const controller = new AbortController();
+		setTimeout(() => controller.abort(), requestOptions.timeout);
+		requestInit.signal = controller.signal;
+	}
+	if (options.body !== undefined) requestInit.body = JSON.stringify(options.body);
+	const response = await args.fetchImpl(url, requestInit);
+	if (!response.ok) {
+		throw new ClientError(
+			`SSE stream failed: ${response.statusText}`,
+			response.status,
+			response,
+			requestOptions
+		);
+	}
+	if (!response.body) {
+		throw new ClientError(
+			'No response body for SSE stream',
+			response.status,
+			response,
+			requestOptions
+		);
+	}
+	const reader = response.body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = '';
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			buffer += decoder.decode(value, { stream: true });
+			const lines = buffer.split('\n');
+			buffer = lines.pop() || '';
+			let currentEvent: Partial<SSEEvent<T>> = {};
+			for (const line of lines) {
+				if (line.trim() === '') {
+					if (currentEvent.data !== undefined) {
+						yield currentEvent as SSEEvent<T>;
+						currentEvent = {};
+					}
+					continue;
+				}
+				if (line.startsWith('event:')) {
+					currentEvent.event = line.slice(6).trim();
+					continue;
+				}
+				if (line.startsWith('data:')) {
+					const dataStr = line.slice(5).trim();
+					if (dataStr === '[DONE]') return;
+					try {
+						currentEvent.data = JSON.parse(dataStr) as T;
+					} catch {
+						currentEvent.data = dataStr as T;
+					}
+					continue;
+				}
+				if (line.startsWith('id:')) {
+					currentEvent.id = line.slice(3).trim();
+					continue;
+				}
+				if (line.startsWith('retry:')) {
+					currentEvent.retry = parseInt(line.slice(6).trim());
+				}
+			}
+		}
+	} finally {
+		reader.releaseLock();
+	}
+}