recker 1.0.83 → 1.0.84-next.ca0ad49

package/dist/raffel/transport-http.js

@@ -0,0 +1,211 @@
+import { Client } from '../core/client.js';
+import { TransportCapability } from './transport.js';
+import { RaffelError } from './types.js';
+const HTTP_CAPABILITIES = TransportCapability.CALL |
+    TransportCapability.NOTIFY |
+    TransportCapability.STREAM;
+export class HttpTransport {
+    capabilities = HTTP_CAPABILITIES;
+    client;
+    connected = false;
+    listeners = new Map();
+    baseUrl;
+    constructor(url, options = {}) {
+        this.baseUrl = url;
+        this.client = new Client({
+            baseUrl: url,
+            timeout: options.timeout ?? 30_000,
+            headers: {
+                'content-type': 'application/json',
+                'accept': 'application/json',
+                ...options.headers,
+            },
+        });
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    async connect() {
+        this.connected = true;
+        this.emit('connected');
+    }
+    close() {
+        this.connected = false;
+        this.emit('disconnected');
+    }
+    send(_data) {
+    }
+    async execute(envelope) {
+        const { procedure, type, payload, metadata } = envelope;
+        if (type === 'notify' || type === 'event') {
+            await this.client.post(`/events/${procedure}`, {
+                body: JSON.stringify(payload ?? {}),
+                throwHttpErrors: false,
+            });
+            return undefined;
+        }
+        const response = await this.client.post(`/${procedure}`, {
+            body: JSON.stringify(payload ?? {}),
+            headers: metadata,
+            throwHttpErrors: false,
+        });
+        const status = response.status;
+        if (status >= 400) {
+            const body = await this.parseBody(response);
+            if (body?.error) {
+                throw new RaffelError(body.error, procedure);
+            }
+            throw new RaffelError({
+                code: 'INTERNAL_ERROR',
+                status: status,
+                message: `HTTP ${status}`,
+            }, procedure);
+        }
+        return this.parseBody(response);
+    }
+    async *executeStream(envelope) {
+        const { procedure, payload } = envelope;
+        const params = new URLSearchParams();
+        if (payload && typeof payload === 'object') {
+            for (const [key, value] of Object.entries(payload)) {
+                params.set(key, typeof value === 'string' ? value : JSON.stringify(value));
+            }
+        }
+        const query = params.toString();
+        const url = `/streams/${procedure}${query ? `?${query}` : ''}`;
+        const response = await this.client.get(url, {
+            headers: { accept: 'text/event-stream' },
+            throwHttpErrors: false,
+        });
+        const body = response.read();
+        if (!body)
+            return;
+        yield* this.parseSSE(body, procedure);
+    }
+    async *parseSSE(body, procedure) {
+        const reader = this.getReader(body);
+        if (!reader)
+            return;
+        const decoder = new TextDecoder();
+        let buffer = '';
+        let currentEvent = '';
+        let currentData = '';
+        const processLine = function* (line) {
+            if (line === '') {
+                if (currentData) {
+                    yield { event: currentEvent || 'data', data: currentData };
+                    currentEvent = '';
+                    currentData = '';
+                }
+            }
+            else if (line.startsWith('event: ')) {
+                currentEvent = line.slice(7);
+            }
+            else if (line.startsWith('data: ')) {
+                currentData += (currentData ? '\n' : '') + line.slice(6);
+            }
+        };
+        try {
+            while (true) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                buffer += typeof value === 'string' ? value : decoder.decode(value, { stream: true });
+                const lines = buffer.split('\n');
+                buffer = lines.pop() ?? '';
+                for (const line of lines) {
+                    for (const event of processLine(line)) {
+                        if (event.event === 'end')
+                            return;
+                        if (event.event === 'error') {
+                            let parsed;
+                            try {
+                                parsed = JSON.parse(event.data);
+                            }
+                            catch {
+                                parsed = { code: 'INTERNAL_ERROR', message: event.data, status: 500 };
+                            }
+                            throw new RaffelError(parsed, procedure);
+                        }
+                        if (event.event === 'data') {
+                            try {
+                                yield JSON.parse(event.data);
+                            }
+                            catch {
+                                yield event.data;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        finally {
+            if ('cancel' in reader) {
+                await reader.cancel();
+            }
+        }
+    }
+    getReader(body) {
+        if (body && typeof body.getReader === 'function') {
+            return body.getReader();
+        }
+        if (body && Symbol.asyncIterator in body) {
+            return asyncIterableToReader(body);
+        }
+        return null;
+    }
+    async parseBody(response) {
+        if (typeof response.json === 'function') {
+            try {
+                return await response.json();
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const text = typeof response.text === 'function' ? await response.text() : String(response.body ?? '');
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (set) {
+            set.delete(listener);
+            if (set.size === 0)
+                this.listeners.delete(event);
+        }
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        this.on(event, wrapped);
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+    }
+}
+function asyncIterableToReader(iterable) {
+    const iterator = iterable[Symbol.asyncIterator]();
+    return {
+        async read() {
+            const { done, value } = await iterator.next();
+            return { done: done ?? false, value };
+        },
+    };
+}

package/dist/raffel/transport-jsonrpc.d.ts

@@ -0,0 +1,24 @@
+import type { RaffelExecutableTransport, RaffelTransportEvent } from './transport.js';
+import type { RaffelEnvelope, RaffelJsonRpcOptions } from './types.js';
+type Listener = (...args: any[]) => void;
+export declare class JsonRpcTransport implements RaffelExecutableTransport {
+    readonly capabilities: number;
+    private client;
+    private connected;
+    private listeners;
+    private rpcPath;
+    private idCounter;
+    constructor(url: string, options?: RaffelJsonRpcOptions);
+    get isConnected(): boolean;
+    connect(): Promise<void>;
+    close(): void;
+    send(_data: unknown): void;
+    execute(envelope: RaffelEnvelope): Promise<unknown>;
+    private rpcCodeToStatus;
+    private parseBody;
+    on(event: RaffelTransportEvent, listener: Listener): void;
+    off(event: RaffelTransportEvent, listener: Listener): void;
+    once(event: RaffelTransportEvent, listener: Listener): void;
+    private emit;
+}
+export {};

package/dist/raffel/transport-jsonrpc.js

@@ -0,0 +1,139 @@
+import { Client } from '../core/client.js';
+import { TransportCapability } from './transport.js';
+import { RaffelError } from './types.js';
+const JSONRPC_CAPABILITIES = TransportCapability.CALL |
+    TransportCapability.NOTIFY;
+const JSONRPC_ERROR_MAP = {
+    [-32700]: 'PARSE_ERROR',
+    [-32600]: 'INVALID_ARGUMENT',
+    [-32601]: 'NOT_FOUND',
+    [-32602]: 'VALIDATION_ERROR',
+    [-32603]: 'INTERNAL_ERROR',
+    [-32001]: 'UNAUTHENTICATED',
+    [-32002]: 'RATE_LIMITED',
+};
+export class JsonRpcTransport {
+    capabilities = JSONRPC_CAPABILITIES;
+    client;
+    connected = false;
+    listeners = new Map();
+    rpcPath;
+    idCounter = 0;
+    constructor(url, options = {}) {
+        this.rpcPath = options.path ?? '/rpc';
+        let baseUrl = url;
+        if (baseUrl.endsWith('/rpc')) {
+            baseUrl = baseUrl.slice(0, -4);
+        }
+        else if (baseUrl.endsWith('/rpc/')) {
+            baseUrl = baseUrl.slice(0, -5);
+        }
+        this.client = new Client({
+            baseUrl,
+            headers: {
+                'content-type': 'application/json',
+                'accept': 'application/json',
+                ...options.headers,
+            },
+        });
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    async connect() {
+        this.connected = true;
+        this.emit('connected');
+    }
+    close() {
+        this.connected = false;
+        this.emit('disconnected');
+    }
+    send(_data) {
+    }
+    async execute(envelope) {
+        const { procedure, type, payload } = envelope;
+        const isNotification = type === 'notify' || type === 'event';
+        const body = {
+            jsonrpc: '2.0',
+            method: procedure,
+            params: payload ?? {},
+        };
+        if (!isNotification) {
+            body.id = ++this.idCounter;
+        }
+        const response = await this.client.post(this.rpcPath, {
+            body: JSON.stringify(body),
+        });
+        if (isNotification) {
+            return undefined;
+        }
+        const result = await this.parseBody(response);
+        if (result?.error) {
+            const rpcError = result.error;
+            const code = JSONRPC_ERROR_MAP[rpcError.code] ?? 'INTERNAL_ERROR';
+            throw new RaffelError({
+                code,
+                status: this.rpcCodeToStatus(rpcError.code),
+                message: rpcError.message ?? 'JSON-RPC error',
+                details: rpcError.data,
+            }, procedure);
+        }
+        return result?.result;
+    }
+    rpcCodeToStatus(code) {
+        switch (code) {
+            case -32700: return 400;
+            case -32600: return 400;
+            case -32601: return 404;
+            case -32602: return 400;
+            case -32001: return 401;
+            case -32002: return 429;
+            default: return 500;
+        }
+    }
+    async parseBody(response) {
+        if (typeof response.json === 'function') {
+            try {
+                return await response.json();
+            }
+            catch {
+                return undefined;
+            }
+        }
+        const text = typeof response.text === 'function' ? await response.text() : String(response.body ?? '');
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (set) {
+            set.delete(listener);
+            if (set.size === 0)
+                this.listeners.delete(event);
+        }
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        this.on(event, wrapped);
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+    }
+}

package/dist/raffel/transport-tcp.d.ts

@@ -0,0 +1,30 @@
+import type { RaffelTransport, RaffelTransportEvent } from './transport.js';
+import type { RaffelTcpOptions } from './types.js';
+type Listener = (...args: any[]) => void;
+export declare class TcpTransport implements RaffelTransport {
+    readonly capabilities: number;
+    private socket;
+    private connected;
+    private listeners;
+    private host;
+    private port;
+    private options;
+    private buffer;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private closed;
+    constructor(url: string, options?: RaffelTcpOptions);
+    get isConnected(): boolean;
+    connect(): Promise<void>;
+    private _connect;
+    close(): void;
+    send(data: unknown): void;
+    on(event: RaffelTransportEvent, listener: Listener): void;
+    off(event: RaffelTransportEvent, listener: Listener): void;
+    once(event: RaffelTransportEvent, listener: Listener): void;
+    private emit;
+    private onData;
+    private onClose;
+    private attemptReconnect;
+}
+export {};

package/dist/raffel/transport-tcp.js

@@ -0,0 +1,183 @@
+import { createConnection } from 'node:net';
+import { TransportCapability } from './transport.js';
+const MAX_MESSAGE_SIZE = 16 * 1024 * 1024;
+const ALL_CAPABILITIES = TransportCapability.CALL |
+    TransportCapability.NOTIFY |
+    TransportCapability.SUBSCRIBE |
+    TransportCapability.PUBLISH |
+    TransportCapability.CANCEL |
+    TransportCapability.STREAM;
+export class TcpTransport {
+    capabilities = ALL_CAPABILITIES;
+    socket = null;
+    connected = false;
+    listeners = new Map();
+    host;
+    port;
+    options;
+    buffer = Buffer.alloc(0);
+    reconnectAttempts = 0;
+    reconnectTimer = null;
+    closed = false;
+    constructor(url, options = {}) {
+        const parsed = new URL(url.replace('tcp://', 'http://'));
+        this.host = parsed.hostname;
+        this.port = parseInt(parsed.port, 10) || 9000;
+        this.options = options;
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    async connect() {
+        this.closed = false;
+        return this._connect();
+    }
+    _connect() {
+        return new Promise((resolve, reject) => {
+            this.socket = createConnection({
+                host: this.host,
+                port: this.port,
+            });
+            const noDelay = this.options.noDelay ?? true;
+            this.socket.setNoDelay(noDelay);
+            const keepAlive = this.options.keepAlive ?? true;
+            if (keepAlive) {
+                this.socket.setKeepAlive(true, this.options.keepAliveInterval ?? 30_000);
+            }
+            const onConnect = () => {
+                this.connected = true;
+                this.reconnectAttempts = 0;
+                this.buffer = Buffer.alloc(0);
+                cleanup();
+                this.emit('connected');
+                resolve();
+            };
+            const onError = (err) => {
+                cleanup();
+                if (!this.connected) {
+                    reject(err);
+                }
+                else {
+                    this.emit('error', err);
+                }
+            };
+            const cleanup = () => {
+                this.socket.removeListener('connect', onConnect);
+                this.socket.removeListener('error', onError);
+            };
+            this.socket.once('connect', onConnect);
+            this.socket.once('error', onError);
+            this.socket.on('data', (chunk) => this.onData(chunk));
+            this.socket.on('close', () => this.onClose());
+            this.socket.on('error', (err) => {
+                if (this.connected)
+                    this.emit('error', err);
+            });
+        });
+    }
+    close() {
+        this.closed = true;
+        if (this.reconnectTimer) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = null;
+        }
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+        }
+        if (this.connected) {
+            this.connected = false;
+            this.emit('disconnected');
+        }
+    }
+    send(data) {
+        if (!this.socket || !this.connected) {
+            throw new Error('TCP transport not connected');
+        }
+        const json = JSON.stringify(data);
+        const payload = Buffer.from(json, 'utf8');
+        if (payload.length > MAX_MESSAGE_SIZE) {
+            throw new Error(`Message size ${payload.length} exceeds maximum ${MAX_MESSAGE_SIZE}`);
+        }
+        const header = Buffer.alloc(4);
+        header.writeUInt32BE(payload.length, 0);
+        this.socket.write(Buffer.concat([header, payload]));
+    }
+    on(event, listener) {
+        const set = this.listeners.get(event) ?? new Set();
+        set.add(listener);
+        this.listeners.set(event, set);
+    }
+    off(event, listener) {
+        const set = this.listeners.get(event);
+        if (set) {
+            set.delete(listener);
+            if (set.size === 0)
+                this.listeners.delete(event);
+        }
+    }
+    once(event, listener) {
+        const wrapped = (...args) => {
+            this.off(event, wrapped);
+            listener(...args);
+        };
+        this.on(event, wrapped);
+    }
+    emit(event, ...args) {
+        const set = this.listeners.get(event);
+        if (!set)
+            return;
+        for (const listener of [...set]) {
+            listener(...args);
+        }
+    }
+    onData(chunk) {
+        this.buffer = Buffer.concat([this.buffer, chunk]);
+        while (this.buffer.length >= 4) {
+            const messageLength = this.buffer.readUInt32BE(0);
+            if (messageLength > MAX_MESSAGE_SIZE) {
+                this.emit('error', new Error(`Message size ${messageLength} exceeds maximum ${MAX_MESSAGE_SIZE}`));
+                this.socket?.destroy();
+                return;
+            }
+            if (this.buffer.length < 4 + messageLength) {
+                break;
+            }
+            const jsonBuf = this.buffer.subarray(4, 4 + messageLength);
+            this.buffer = this.buffer.subarray(4 + messageLength);
+            let parsed;
+            try {
+                parsed = JSON.parse(jsonBuf.toString('utf8'));
+            }
+            catch {
+                this.emit('error', new Error('Invalid JSON in TCP frame'));
+                continue;
+            }
+            this.emit('message', parsed);
+        }
+    }
+    onClose() {
+        this.connected = false;
+        this.emit('disconnected');
+        if (!this.closed && this.options.reconnect !== false) {
+            this.attemptReconnect();
+        }
+    }
+    attemptReconnect() {
+        const maxAttempts = this.options.maxReconnectAttempts ?? 10;
+        if (this.reconnectAttempts >= maxAttempts)
+            return;
+        this.reconnectAttempts++;
+        const baseDelay = this.options.reconnectDelay ?? 1000;
+        const delay = Math.min(baseDelay * Math.pow(2, this.reconnectAttempts - 1), 30_000);
+        const jitter = delay * (0.5 + Math.random() * 0.5);
+        this.emit('reconnecting', this.reconnectAttempts, jitter);
+        this.reconnectTimer = setTimeout(async () => {
+            try {
+                await this._connect();
+            }
+            catch {
+            }
+        }, jitter);
+    }
+}

package/dist/raffel/transport-udp.d.ts

@@ -0,0 +1,22 @@
+import type { RaffelTransport, RaffelTransportEvent } from './transport.js';
+import type { RaffelUdpOptions } from './types.js';
+type Listener = (...args: any[]) => void;
+export declare class UdpTransport implements RaffelTransport {
+    readonly capabilities: number;
+    private socket;
+    private connected;
+    private listeners;
+    private host;
+    private port;
+    private options;
+    constructor(url: string, options?: RaffelUdpOptions);
+    get isConnected(): boolean;
+    connect(): Promise<void>;
+    close(): void;
+    send(data: unknown): void;
+    on(event: RaffelTransportEvent, listener: Listener): void;
+    off(event: RaffelTransportEvent, listener: Listener): void;
+    once(event: RaffelTransportEvent, listener: Listener): void;
+    private emit;
+}
+export {};