@durable-streams/client-conformance-tests 0.1.0

package/dist/adapters/typescript-adapter.js

@@ -0,0 +1,586 @@
+#!/usr/bin/env node
+import { ErrorCodes, decodeBase64, parseCommand, serializeResult } from "../protocol-qb83AeUH.js";
+import { createInterface } from "node:readline";
+import { DurableStream, DurableStreamError, FetchError, stream } from "@durable-streams/client";
+
+//#region src/adapters/typescript-adapter.ts
+const CLIENT_VERSION = `0.0.1`;
+let serverUrl = ``;
+const streamContentTypes = new Map();
+const dynamicHeaders = new Map();
+const dynamicParams = new Map();
+/** Resolve dynamic headers, returning both the header function map and tracked values */
+function resolveDynamicHeaders() {
+	const headers = {};
+	const values = {};
+	for (const [name, config] of dynamicHeaders.entries()) {
+		let value;
+		switch (config.type) {
+			case `counter`:
+				config.counter++;
+				value = config.counter.toString();
+				break;
+			case `timestamp`:
+				value = Date.now().toString();
+				break;
+			case `token`:
+				value = config.tokenValue ?? ``;
+				break;
+		}
+		values[name] = value;
+		const capturedValue = value;
+		headers[name] = () => capturedValue;
+	}
+	return {
+		headers,
+		values
+	};
+}
+/** Resolve dynamic params */
+function resolveDynamicParams() {
+	const params = {};
+	const values = {};
+	for (const [name, config] of dynamicParams.entries()) {
+		let value;
+		switch (config.type) {
+			case `counter`:
+				config.counter++;
+				value = config.counter.toString();
+				break;
+			case `timestamp`:
+				value = Date.now().toString();
+				break;
+			default: value = ``;
+		}
+		values[name] = value;
+		const capturedValue = value;
+		params[name] = () => capturedValue;
+	}
+	return {
+		params,
+		values
+	};
+}
+async function handleCommand(command) {
+	switch (command.type) {
+		case `init`: {
+			serverUrl = command.serverUrl;
+			streamContentTypes.clear();
+			dynamicHeaders.clear();
+			dynamicParams.clear();
+			return {
+				type: `init`,
+				success: true,
+				clientName: `@durable-streams/client`,
+				clientVersion: CLIENT_VERSION,
+				features: {
+					batching: true,
+					sse: true,
+					longPoll: true,
+					streaming: true,
+					dynamicHeaders: true
+				}
+			};
+		}
+		case `create`: try {
+			const url = `${serverUrl}${command.path}`;
+			const contentType = command.contentType ?? `application/octet-stream`;
+			let alreadyExists = false;
+			try {
+				await DurableStream.head({ url });
+				alreadyExists = true;
+			} catch {}
+			const ds = await DurableStream.create({
+				url,
+				contentType,
+				ttlSeconds: command.ttlSeconds,
+				expiresAt: command.expiresAt,
+				headers: command.headers
+			});
+			streamContentTypes.set(command.path, contentType);
+			const head = await ds.head();
+			return {
+				type: `create`,
+				success: true,
+				status: alreadyExists ? 200 : 201,
+				offset: head.offset
+			};
+		} catch (err) {
+			return errorResult(`create`, err);
+		}
+		case `connect`: try {
+			const url = `${serverUrl}${command.path}`;
+			const ds = await DurableStream.connect({
+				url,
+				headers: command.headers
+			});
+			const head = await ds.head();
+			if (head.contentType) streamContentTypes.set(command.path, head.contentType);
+			return {
+				type: `connect`,
+				success: true,
+				status: 200,
+				offset: head.offset
+			};
+		} catch (err) {
+			return errorResult(`connect`, err);
+		}
+		case `append`: try {
+			const url = `${serverUrl}${command.path}`;
+			const contentType = streamContentTypes.get(command.path) ?? `application/octet-stream`;
+			const { headers: dynamicHdrs, values: headersSent } = resolveDynamicHeaders();
+			const { values: paramsSent } = resolveDynamicParams();
+			const mergedHeaders = {
+				...dynamicHdrs,
+				...command.headers
+			};
+			const ds = new DurableStream({
+				url,
+				headers: mergedHeaders,
+				contentType
+			});
+			let body;
+			if (command.binary) body = decodeBase64(command.data);
+			else body = command.data;
+			await ds.append(body, { seq: command.seq?.toString() });
+			const head = await ds.head();
+			return {
+				type: `append`,
+				success: true,
+				status: 200,
+				offset: head.offset,
+				headersSent: Object.keys(headersSent).length > 0 ? headersSent : void 0,
+				paramsSent: Object.keys(paramsSent).length > 0 ? paramsSent : void 0
+			};
+		} catch (err) {
+			return errorResult(`append`, err);
+		}
+		case `read`: try {
+			const url = `${serverUrl}${command.path}`;
+			const { headers: dynamicHdrs, values: headersSent } = resolveDynamicHeaders();
+			const { values: paramsSent } = resolveDynamicParams();
+			const mergedHeaders = {
+				...dynamicHdrs,
+				...command.headers
+			};
+			let live;
+			if (command.live === `long-poll`) live = `long-poll`;
+			else if (command.live === `sse`) live = `sse`;
+			else live = false;
+			const abortController = new AbortController();
+			const timeoutMs = command.timeoutMs ?? 5e3;
+			const timeoutId = setTimeout(() => {
+				abortController.abort();
+			}, timeoutMs);
+			let response;
+			try {
+				response = await stream({
+					url,
+					offset: command.offset,
+					live,
+					headers: mergedHeaders,
+					signal: abortController.signal
+				});
+			} catch (err) {
+				clearTimeout(timeoutId);
+				if (abortController.signal.aborted) return {
+					type: `read`,
+					success: true,
+					status: 200,
+					chunks: [],
+					offset: command.offset ?? `-1`,
+					upToDate: true,
+					headersSent: Object.keys(headersSent).length > 0 ? headersSent : void 0,
+					paramsSent: Object.keys(paramsSent).length > 0 ? paramsSent : void 0
+				};
+				throw err;
+			}
+			clearTimeout(timeoutId);
+			const chunks = [];
+			let finalOffset = command.offset ?? response.offset;
+			let upToDate = response.upToDate;
+			const maxChunks = command.maxChunks ?? 100;
+			if (!live) try {
+				const data = await response.body();
+				if (data.length > 0) chunks.push({
+					data: new TextDecoder().decode(data),
+					offset: response.offset
+				});
+				finalOffset = response.offset;
+				upToDate = response.upToDate;
+			} catch {}
+			else {
+				const decoder = new TextDecoder();
+				const startTime = Date.now();
+				let chunkCount = 0;
+				let done = false;
+				await new Promise((resolve) => {
+					const subscriptionTimeoutId = setTimeout(() => {
+						done = true;
+						abortController.abort();
+						upToDate = response.upToDate || true;
+						finalOffset = response.offset;
+						resolve();
+					}, timeoutMs);
+					const unsubscribe = response.subscribeBytes(async (chunk) => {
+						if (done || chunkCount >= maxChunks) return;
+						if (Date.now() - startTime > timeoutMs) {
+							done = true;
+							resolve();
+							return;
+						}
+						const hasData = chunk.data.length > 0;
+						if (hasData) {
+							chunks.push({
+								data: decoder.decode(chunk.data),
+								offset: chunk.offset
+							});
+							chunkCount++;
+						}
+						finalOffset = chunk.offset;
+						upToDate = chunk.upToDate;
+						if (command.waitForUpToDate && chunk.upToDate) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							resolve();
+							return;
+						}
+						if (chunkCount >= maxChunks) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							resolve();
+						}
+						await Promise.resolve();
+					});
+					response.closed.then(() => {
+						if (!done) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							upToDate = response.upToDate;
+							finalOffset = response.offset;
+							resolve();
+						}
+					}).catch(() => {
+						if (!done) {
+							done = true;
+							clearTimeout(subscriptionTimeoutId);
+							resolve();
+						}
+					});
+				});
+			}
+			response.cancel();
+			return {
+				type: `read`,
+				success: true,
+				status: 200,
+				chunks,
+				offset: finalOffset,
+				upToDate,
+				headersSent: Object.keys(headersSent).length > 0 ? headersSent : void 0,
+				paramsSent: Object.keys(paramsSent).length > 0 ? paramsSent : void 0
+			};
+		} catch (err) {
+			return errorResult(`read`, err);
+		}
+		case `head`: try {
+			const url = `${serverUrl}${command.path}`;
+			const result = await DurableStream.head({
+				url,
+				headers: command.headers
+			});
+			if (result.contentType) streamContentTypes.set(command.path, result.contentType);
+			return {
+				type: `head`,
+				success: true,
+				status: 200,
+				offset: result.offset,
+				contentType: result.contentType
+			};
+		} catch (err) {
+			return errorResult(`head`, err);
+		}
+		case `delete`: try {
+			const url = `${serverUrl}${command.path}`;
+			await DurableStream.delete({
+				url,
+				headers: command.headers
+			});
+			streamContentTypes.delete(command.path);
+			return {
+				type: `delete`,
+				success: true,
+				status: 200
+			};
+		} catch (err) {
+			return errorResult(`delete`, err);
+		}
+		case `shutdown`: return {
+			type: `shutdown`,
+			success: true
+		};
+		case `benchmark`: return handleBenchmark(command);
+		case `set-dynamic-header`: {
+			dynamicHeaders.set(command.name, {
+				type: command.valueType,
+				counter: 0,
+				tokenValue: command.initialValue
+			});
+			return {
+				type: `set-dynamic-header`,
+				success: true
+			};
+		}
+		case `set-dynamic-param`: {
+			dynamicParams.set(command.name, {
+				type: command.valueType,
+				counter: 0
+			});
+			return {
+				type: `set-dynamic-param`,
+				success: true
+			};
+		}
+		case `clear-dynamic`: {
+			dynamicHeaders.clear();
+			dynamicParams.clear();
+			return {
+				type: `clear-dynamic`,
+				success: true
+			};
+		}
+		default: return {
+			type: `error`,
+			success: false,
+			commandType: command.type,
+			errorCode: ErrorCodes.NOT_SUPPORTED,
+			message: `Unknown command type: ${command.type}`
+		};
+	}
+}
+function errorResult(commandType, err) {
+	if (err instanceof DurableStreamError) {
+		let errorCode = ErrorCodes.INTERNAL_ERROR;
+		let status;
+		if (err.code === `NOT_FOUND`) {
+			errorCode = ErrorCodes.NOT_FOUND;
+			status = 404;
+		} else if (err.code === `CONFLICT_EXISTS`) {
+			errorCode = ErrorCodes.CONFLICT;
+			status = 409;
+		} else if (err.code === `CONFLICT_SEQ`) {
+			errorCode = ErrorCodes.SEQUENCE_CONFLICT;
+			status = 409;
+		} else if (err.code === `BAD_REQUEST`) {
+			errorCode = ErrorCodes.INVALID_OFFSET;
+			status = 400;
+		}
+		return {
+			type: `error`,
+			success: false,
+			commandType,
+			status,
+			errorCode,
+			message: err.message
+		};
+	}
+	if (err instanceof FetchError) {
+		let errorCode;
+		const msg = err.message.toLowerCase();
+		if (err.status === 404) errorCode = ErrorCodes.NOT_FOUND;
+		else if (err.status === 409) if (msg.includes(`sequence`)) errorCode = ErrorCodes.SEQUENCE_CONFLICT;
+		else errorCode = ErrorCodes.CONFLICT;
+		else if (err.status === 400) if (msg.includes(`offset`) || msg.includes(`invalid`)) errorCode = ErrorCodes.INVALID_OFFSET;
+		else errorCode = ErrorCodes.UNEXPECTED_STATUS;
+		else errorCode = ErrorCodes.UNEXPECTED_STATUS;
+		return {
+			type: `error`,
+			success: false,
+			commandType,
+			status: err.status,
+			errorCode,
+			message: err.message
+		};
+	}
+	if (err instanceof Error) {
+		if (err.message.includes(`ECONNREFUSED`) || err.message.includes(`fetch`)) return {
+			type: `error`,
+			success: false,
+			commandType,
+			errorCode: ErrorCodes.NETWORK_ERROR,
+			message: err.message
+		};
+		return {
+			type: `error`,
+			success: false,
+			commandType,
+			errorCode: ErrorCodes.INTERNAL_ERROR,
+			message: err.message
+		};
+	}
+	return {
+		type: `error`,
+		success: false,
+		commandType,
+		errorCode: ErrorCodes.INTERNAL_ERROR,
+		message: String(err)
+	};
+}
+/**
+* Handle benchmark commands with high-resolution timing.
+*/
+async function handleBenchmark(command) {
+	const { iterationId, operation } = command;
+	try {
+		const startTime = process.hrtime.bigint();
+		const metrics = {};
+		switch (operation.op) {
+			case `append`: {
+				const url = `${serverUrl}${operation.path}`;
+				const contentType = streamContentTypes.get(operation.path) ?? `application/octet-stream`;
+				const ds = new DurableStream({
+					url,
+					contentType
+				});
+				const payload = new Uint8Array(operation.size).fill(42);
+				await ds.append(payload);
+				metrics.bytesTransferred = operation.size;
+				break;
+			}
+			case `read`: {
+				const url = `${serverUrl}${operation.path}`;
+				const res = await stream({
+					url,
+					offset: operation.offset,
+					live: false
+				});
+				const data = await res.body();
+				metrics.bytesTransferred = data.length;
+				break;
+			}
+			case `roundtrip`: {
+				const url = `${serverUrl}${operation.path}`;
+				const contentType = operation.contentType ?? `application/octet-stream`;
+				const ds = await DurableStream.create({
+					url,
+					contentType
+				});
+				const payload = new Uint8Array(operation.size).fill(42);
+				const readPromise = (async () => {
+					const res = await ds.stream({ live: operation.live ?? `long-poll` });
+					return new Promise((resolve) => {
+						const unsubscribe = res.subscribeBytes(async (chunk) => {
+							if (chunk.data.length > 0) {
+								unsubscribe();
+								res.cancel();
+								resolve(chunk.data);
+							}
+						});
+					});
+				})();
+				await ds.append(payload);
+				const readData = await readPromise;
+				metrics.bytesTransferred = operation.size + readData.length;
+				break;
+			}
+			case `create`: {
+				const url = `${serverUrl}${operation.path}`;
+				await DurableStream.create({
+					url,
+					contentType: operation.contentType ?? `application/octet-stream`
+				});
+				break;
+			}
+			case `throughput_append`: {
+				const url = `${serverUrl}${operation.path}`;
+				const contentType = streamContentTypes.get(operation.path) ?? `application/octet-stream`;
+				try {
+					await DurableStream.create({
+						url,
+						contentType
+					});
+				} catch {}
+				const ds = new DurableStream({
+					url,
+					contentType
+				});
+				const payload = new Uint8Array(operation.size).fill(42);
+				await Promise.all(Array.from({ length: operation.count }, () => ds.append(payload)));
+				metrics.bytesTransferred = operation.count * operation.size;
+				metrics.messagesProcessed = operation.count;
+				break;
+			}
+			case `throughput_read`: {
+				const url = `${serverUrl}${operation.path}`;
+				const res = await stream({
+					url,
+					live: false
+				});
+				let count = 0;
+				let bytes = 0;
+				for await (const msg of res.jsonStream()) {
+					count++;
+					bytes += JSON.stringify(msg).length;
+				}
+				metrics.bytesTransferred = bytes;
+				metrics.messagesProcessed = count;
+				break;
+			}
+			default: return {
+				type: `error`,
+				success: false,
+				commandType: `benchmark`,
+				errorCode: ErrorCodes.NOT_SUPPORTED,
+				message: `Unknown benchmark operation: ${operation.op}`
+			};
+		}
+		const endTime = process.hrtime.bigint();
+		const durationNs = endTime - startTime;
+		return {
+			type: `benchmark`,
+			success: true,
+			iterationId,
+			durationNs: durationNs.toString(),
+			metrics
+		};
+	} catch (err) {
+		return {
+			type: `error`,
+			success: false,
+			commandType: `benchmark`,
+			errorCode: ErrorCodes.INTERNAL_ERROR,
+			message: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+async function main() {
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout,
+		terminal: false
+	});
+	for await (const line of rl) {
+		if (!line.trim()) continue;
+		try {
+			const command = parseCommand(line);
+			const result = await handleCommand(command);
+			console.log(serializeResult(result));
+			if (command.type === `shutdown`) break;
+		} catch (err) {
+			console.log(serializeResult({
+				type: `error`,
+				success: false,
+				commandType: `init`,
+				errorCode: ErrorCodes.PARSE_ERROR,
+				message: `Failed to parse command: ${err}`
+			}));
+		}
+	}
+	process.exit(0);
+}
+main().catch((err) => {
+	console.error(`Fatal error:`, err);
+	process.exit(1);
+});
+
+//#endregion