@durable-streams/client-conformance-tests 0.1.0 → 0.1.2

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 durable-stream
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/adapters/typescript-adapter.cjs

@@ -0,0 +1,588 @@
+#!/usr/bin/env node
+"use strict";
+const require_chunk = require('../chunk-BCwAaXi7.cjs');
+const require_protocol = require('../protocol-XeAOKBD-.cjs');
+const node_readline = require_chunk.__toESM(require("node:readline"));
+const __durable_streams_client = require_chunk.__toESM(require("@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 __durable_streams_client.DurableStream.head({ url });
+				alreadyExists = true;
+			} catch {}
+			const ds = await __durable_streams_client.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 __durable_streams_client.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 __durable_streams_client.DurableStream({
+				url,
+				headers: mergedHeaders,
+				contentType
+			});
+			let body;
+			if (command.binary) body = require_protocol.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 (0, __durable_streams_client.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 __durable_streams_client.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 __durable_streams_client.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: require_protocol.ErrorCodes.NOT_SUPPORTED,
+			message: `Unknown command type: ${command.type}`
+		};
+	}
+}
+function errorResult(commandType, err) {
+	if (err instanceof __durable_streams_client.DurableStreamError) {
+		let errorCode = require_protocol.ErrorCodes.INTERNAL_ERROR;
+		let status;
+		if (err.code === `NOT_FOUND`) {
+			errorCode = require_protocol.ErrorCodes.NOT_FOUND;
+			status = 404;
+		} else if (err.code === `CONFLICT_EXISTS`) {
+			errorCode = require_protocol.ErrorCodes.CONFLICT;
+			status = 409;
+		} else if (err.code === `CONFLICT_SEQ`) {
+			errorCode = require_protocol.ErrorCodes.SEQUENCE_CONFLICT;
+			status = 409;
+		} else if (err.code === `BAD_REQUEST`) {
+			errorCode = require_protocol.ErrorCodes.INVALID_OFFSET;
+			status = 400;
+		}
+		return {
+			type: `error`,
+			success: false,
+			commandType,
+			status,
+			errorCode,
+			message: err.message
+		};
+	}
+	if (err instanceof __durable_streams_client.FetchError) {
+		let errorCode;
+		const msg = err.message.toLowerCase();
+		if (err.status === 404) errorCode = require_protocol.ErrorCodes.NOT_FOUND;
+		else if (err.status === 409) if (msg.includes(`sequence`)) errorCode = require_protocol.ErrorCodes.SEQUENCE_CONFLICT;
+		else errorCode = require_protocol.ErrorCodes.CONFLICT;
+		else if (err.status === 400) if (msg.includes(`offset`) || msg.includes(`invalid`)) errorCode = require_protocol.ErrorCodes.INVALID_OFFSET;
+		else errorCode = require_protocol.ErrorCodes.UNEXPECTED_STATUS;
+		else errorCode = require_protocol.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: require_protocol.ErrorCodes.NETWORK_ERROR,
+			message: err.message
+		};
+		return {
+			type: `error`,
+			success: false,
+			commandType,
+			errorCode: require_protocol.ErrorCodes.INTERNAL_ERROR,
+			message: err.message
+		};
+	}
+	return {
+		type: `error`,
+		success: false,
+		commandType,
+		errorCode: require_protocol.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 __durable_streams_client.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 (0, __durable_streams_client.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 __durable_streams_client.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 __durable_streams_client.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 __durable_streams_client.DurableStream.create({
+						url,
+						contentType
+					});
+				} catch {}
+				const ds = new __durable_streams_client.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 (0, __durable_streams_client.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: require_protocol.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: require_protocol.ErrorCodes.INTERNAL_ERROR,
+			message: err instanceof Error ? err.message : String(err)
+		};
+	}
+}
+async function main() {
+	const rl = (0, node_readline.createInterface)({
+		input: process.stdin,
+		output: process.stdout,
+		terminal: false
+	});
+	for await (const line of rl) {
+		if (!line.trim()) continue;
+		try {
+			const command = require_protocol.parseCommand(line);
+			const result = await handleCommand(command);
+			console.log(require_protocol.serializeResult(result));
+			if (command.type === `shutdown`) break;
+		} catch (err) {
+			console.log(require_protocol.serializeResult({
+				type: `error`,
+				success: false,
+				commandType: `init`,
+				errorCode: require_protocol.ErrorCodes.PARSE_ERROR,
+				message: `Failed to parse command: ${err}`
+			}));
+		}
+	}
+	process.exit(0);
+}
+main().catch((err) => {
+	console.error(`Fatal error:`, err);
+	process.exit(1);
+});
+
+//#endregion

package/dist/adapters/typescript-adapter.d.cts

@@ -0,0 +1 @@
+export { };