@durable-streams/cli 0.1.3 → 0.1.5

package/README.md

@@ -70,6 +70,11 @@ durable-stream-dev read my-stream
 
 - `STREAM_URL` - Base URL of the stream server (default: `http://localhost:4437`)
 
+### Write Options
+
+- `--content-type <type>` - Content-Type for the message (default: `application/octet-stream`)
+- `--json` - Shorthand for `--content-type application/json`
+
 ### Commands
 
 #### Create a stream
@@ -87,8 +92,26 @@ durable-stream-dev write <stream_id> "Hello, world!"
 # Pipe content from stdin
 echo "Hello from stdin" | durable-stream-dev write <stream_id>
 cat file.txt | durable-stream-dev write <stream_id>
+
+# Specify content type
+durable-stream-dev write <stream_id> '{"key": "value"}' --content-type application/json
+
+# Shorthand for JSON
+durable-stream-dev write <stream_id> '{"key": "value"}' --json
 ```
 
+##### JSON Mode Array Flattening
+
+In JSON mode (`--json` or `--content-type application/json`), top-level arrays are flattened into individual messages:
+
+| Input        | Messages stored        |
+| ------------ | ---------------------- |
+| `{}`         | 1 message: `{}`        |
+| `[{}, {}]`   | 2 messages: `{}`, `{}` |
+| `[[{}, {}]]` | 1 message: `[{}, {}]`  |
+
+This matches the protocol's batch semantics.
+
 #### Read from a stream
 
 ```bash

package/dist/index.cjs

@@ -23,9 +23,73 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
+const node_path = __toESM(require("node:path"));
 const node_process = __toESM(require("node:process"));
+const node_url = __toESM(require("node:url"));
 const __durable_streams_client = __toESM(require("@durable-streams/client"));
 
+//#region src/jsonUtils.ts
+/**
+* Check if content-type indicates JSON mode.
+* Handles cases like "application/json; charset=utf-8".
+*/
+function isJsonContentType(contentType) {
+	return contentType.split(`;`)[0].trim().toLowerCase() === `application/json`;
+}
+/**
+* One-level array flattening for JSON batch semantics.
+* - Single object: `{}` → yields once
+* - Array: `[{}, {}]` → yields each element (flattened)
+* - Nested array: `[[{}, {}]]` → yields `[{}, {}]` (outer array flattened, inner preserved)
+*
+* This matches the protocol's batch semantics where servers flatten exactly one level.
+*/
+function* flattenJsonForAppend(parsed) {
+	if (Array.isArray(parsed)) for (const item of parsed) yield item;
+	else yield parsed;
+}
+
+//#endregion
+//#region src/parseWriteArgs.ts
+/**
+* Parse write command arguments, extracting content-type flags and content.
+* @param args - Arguments after the stream_id (starting from index 2)
+* @returns Parsed content type and content string
+* @throws Error if --content-type is missing its value or if unknown flags are provided
+*/
+function parseWriteArgs(args) {
+	let contentType = `application/octet-stream`;
+	let batchJson = false;
+	const contentParts = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === `--json`) {
+			contentType = `application/json`;
+			continue;
+		}
+		if (arg === `--batch-json`) {
+			batchJson = true;
+			contentType = `application/json`;
+			continue;
+		}
+		if (arg === `--content-type`) {
+			const nextArg = args[i + 1];
+			if (!nextArg || nextArg.startsWith(`--`)) throw new Error(`--content-type requires a value`);
+			contentType = nextArg;
+			i++;
+			continue;
+		}
+		if (arg.startsWith(`--`)) throw new Error(`unknown flag: ${arg}`);
+		contentParts.push(arg);
+	}
+	return {
+		contentType,
+		content: contentParts.join(` `),
+		batchJson
+	};
+}
+
+//#endregion
 //#region src/index.ts
 const STREAM_URL = process.env.STREAM_URL || `http://localhost:4437`;
 function printUsage() {
@@ -37,6 +101,11 @@ Usage:
   durable-stream read <stream_id>                Follow a stream and write to stdout
   durable-stream delete <stream_id>              Delete a stream
 
+Write Options:
+  --content-type <type>   Content-Type for the message (default: application/octet-stream)
+  --json                  Write as JSON (input stored as single message)
+  --batch-json            Write as JSON array of messages (each array element stored separately)
+
 Environment Variables:
   STREAM_URL    Base URL of the stream server (default: http://localhost:4437)
 `);
@@ -54,14 +123,40 @@ async function createStream(streamId) {
 		process.exit(1);
 	}
 }
-async function writeStream(streamId, content) {
+/**
+* Append JSON data to a stream with one-level array flattening.
+*/
+async function appendJson(stream, parsed) {
+	let count = 0;
+	for (const item of flattenJsonForAppend(parsed)) {
+		await stream.append(item);
+		count++;
+	}
+	return count;
+}
+async function writeStream(streamId, contentType, batchJson, content) {
 	const url = `${STREAM_URL}/v1/stream/${streamId}`;
+	const isJson = isJsonContentType(contentType);
 	try {
-		const stream = new __durable_streams_client.DurableStream({ url });
+		const stream = new __durable_streams_client.DurableStream({
+			url,
+			contentType
+		});
 		if (content) {
 			const processedContent = content.replace(/\\n/g, `\n`).replace(/\\t/g, `\t`).replace(/\\r/g, `\r`).replace(/\\\\/g, `\\`);
-			await stream.append(processedContent);
-			console.log(`Wrote ${processedContent.length} bytes to ${streamId}`);
+			if (isJson) {
+				const parsed = JSON.parse(processedContent);
+				if (batchJson) {
+					const count = await appendJson(stream, parsed);
+					console.log(`Wrote ${count} message(s) to ${streamId}`);
+				} else {
+					await stream.append(parsed);
+					console.log(`Wrote 1 message to ${streamId}`);
+				}
+			} else {
+				await stream.append(processedContent);
+				console.log(`Wrote ${processedContent.length} bytes to ${streamId}`);
+			}
 		} else {
 			const chunks = [];
 			node_process.stdin.on(`data`, (chunk) => {
@@ -72,8 +167,19 @@ async function writeStream(streamId, content) {
 				node_process.stdin.on(`error`, reject);
 			});
 			const data = Buffer.concat(chunks);
-			await stream.append(data);
-			console.log(`Wrote ${data.length} bytes to ${streamId}`);
+			if (isJson) {
+				const parsed = JSON.parse(data.toString(`utf8`));
+				if (batchJson) {
+					const count = await appendJson(stream, parsed);
+					console.log(`Wrote ${count} message(s) to ${streamId}`);
+				} else {
+					await stream.append(parsed);
+					console.log(`Wrote 1 message to ${streamId}`);
+				}
+			} else {
+				await stream.append(data);
+				console.log(`Wrote ${data.length} bytes to ${streamId}`);
+			}
 		}
 	} catch (error) {
 		if (error instanceof Error) node_process.stderr.write(`Error writing to stream: ${error.message}\n`);
@@ -126,9 +232,15 @@ async function main() {
 				process.exit(1);
 			}
 			const streamId = args[1];
-			const content = args.slice(2).join(` `);
-			if (!node_process.stdin.isTTY) await writeStream(streamId);
-			else if (content) await writeStream(streamId, content);
+			let parsed;
+			try {
+				parsed = parseWriteArgs(args.slice(2));
+			} catch (error) {
+				if (error instanceof Error) node_process.stderr.write(`Error: ${error.message}\n`);
+				process.exit(1);
+			}
+			if (!node_process.stdin.isTTY) await writeStream(streamId, parsed.contentType, parsed.batchJson);
+			else if (parsed.content) await writeStream(streamId, parsed.contentType, parsed.batchJson, parsed.content);
 			else {
 				node_process.stderr.write(`Error: content required (provide as argument or pipe to stdin)\n`);
 				printUsage();
@@ -160,9 +272,18 @@ async function main() {
 			process.exit(1);
 	}
 }
-main().catch((error) => {
+function isMainModule() {
+	if (!process.argv[1]) return false;
+	const scriptPath = (0, node_path.resolve)(process.argv[1]);
+	const modulePath = (0, node_url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+	return scriptPath === modulePath;
+}
+if (isMainModule()) main().catch((error) => {
 	node_process.stderr.write(`Fatal error: ${error.message}\n`);
 	process.exit(1);
 });
 
-//#endregion
+//#endregion
+exports.flattenJsonForAppend = flattenJsonForAppend
+exports.isJsonContentType = isJsonContentType
+exports.parseWriteArgs = parseWriteArgs

package/dist/index.d.cts

@@ -1 +1,33 @@
-export { };
+//#region src/jsonUtils.d.ts
+/**
+* Check if content-type indicates JSON mode.
+* Handles cases like "application/json; charset=utf-8".
+*/
+declare function isJsonContentType(contentType: string): boolean;
+/**
+* One-level array flattening for JSON batch semantics.
+* - Single object: `{}` → yields once
+* - Array: `[{}, {}]` → yields each element (flattened)
+* - Nested array: `[[{}, {}]]` → yields `[{}, {}]` (outer array flattened, inner preserved)
+*
+* This matches the protocol's batch semantics where servers flatten exactly one level.
+*/
+declare function flattenJsonForAppend(parsed: unknown): Generator<unknown>;
+
+//#endregion
+//#region src/parseWriteArgs.d.ts
+interface ParsedWriteArgs {
+  contentType: string;
+  content: string;
+  batchJson: boolean;
+}
+/**
+* Parse write command arguments, extracting content-type flags and content.
+* @param args - Arguments after the stream_id (starting from index 2)
+* @returns Parsed content type and content string
+* @throws Error if --content-type is missing its value or if unknown flags are provided
+*/
+declare function parseWriteArgs(args: Array<string>): ParsedWriteArgs;
+
+//#endregion
+export { ParsedWriteArgs, flattenJsonForAppend, isJsonContentType, parseWriteArgs };

package/dist/index.d.ts

@@ -1 +1,33 @@
-export { };
+//#region src/jsonUtils.d.ts
+/**
+* Check if content-type indicates JSON mode.
+* Handles cases like "application/json; charset=utf-8".
+*/
+declare function isJsonContentType(contentType: string): boolean;
+/**
+* One-level array flattening for JSON batch semantics.
+* - Single object: `{}` → yields once
+* - Array: `[{}, {}]` → yields each element (flattened)
+* - Nested array: `[[{}, {}]]` → yields `[{}, {}]` (outer array flattened, inner preserved)
+*
+* This matches the protocol's batch semantics where servers flatten exactly one level.
+*/
+declare function flattenJsonForAppend(parsed: unknown): Generator<unknown>;
+
+//#endregion
+//#region src/parseWriteArgs.d.ts
+interface ParsedWriteArgs {
+  contentType: string;
+  content: string;
+  batchJson: boolean;
+}
+/**
+* Parse write command arguments, extracting content-type flags and content.
+* @param args - Arguments after the stream_id (starting from index 2)
+* @returns Parsed content type and content string
+* @throws Error if --content-type is missing its value or if unknown flags are provided
+*/
+declare function parseWriteArgs(args: Array<string>): ParsedWriteArgs;
+
+//#endregion
+export { ParsedWriteArgs, flattenJsonForAppend, isJsonContentType, parseWriteArgs };

package/dist/index.js

@@ -1,7 +1,71 @@
 #!/usr/bin/env node
+import { resolve } from "node:path";
 import { stderr, stdin, stdout } from "node:process";
+import { fileURLToPath } from "node:url";
 import { DurableStream } from "@durable-streams/client";
 
+//#region src/jsonUtils.ts
+/**
+* Check if content-type indicates JSON mode.
+* Handles cases like "application/json; charset=utf-8".
+*/
+function isJsonContentType(contentType) {
+	return contentType.split(`;`)[0].trim().toLowerCase() === `application/json`;
+}
+/**
+* One-level array flattening for JSON batch semantics.
+* - Single object: `{}` → yields once
+* - Array: `[{}, {}]` → yields each element (flattened)
+* - Nested array: `[[{}, {}]]` → yields `[{}, {}]` (outer array flattened, inner preserved)
+*
+* This matches the protocol's batch semantics where servers flatten exactly one level.
+*/
+function* flattenJsonForAppend(parsed) {
+	if (Array.isArray(parsed)) for (const item of parsed) yield item;
+	else yield parsed;
+}
+
+//#endregion
+//#region src/parseWriteArgs.ts
+/**
+* Parse write command arguments, extracting content-type flags and content.
+* @param args - Arguments after the stream_id (starting from index 2)
+* @returns Parsed content type and content string
+* @throws Error if --content-type is missing its value or if unknown flags are provided
+*/
+function parseWriteArgs(args) {
+	let contentType = `application/octet-stream`;
+	let batchJson = false;
+	const contentParts = [];
+	for (let i = 0; i < args.length; i++) {
+		const arg = args[i];
+		if (arg === `--json`) {
+			contentType = `application/json`;
+			continue;
+		}
+		if (arg === `--batch-json`) {
+			batchJson = true;
+			contentType = `application/json`;
+			continue;
+		}
+		if (arg === `--content-type`) {
+			const nextArg = args[i + 1];
+			if (!nextArg || nextArg.startsWith(`--`)) throw new Error(`--content-type requires a value`);
+			contentType = nextArg;
+			i++;
+			continue;
+		}
+		if (arg.startsWith(`--`)) throw new Error(`unknown flag: ${arg}`);
+		contentParts.push(arg);
+	}
+	return {
+		contentType,
+		content: contentParts.join(` `),
+		batchJson
+	};
+}
+
+//#endregion
 //#region src/index.ts
 const STREAM_URL = process.env.STREAM_URL || `http://localhost:4437`;
 function printUsage() {
@@ -13,6 +77,11 @@ Usage:
   durable-stream read <stream_id>                Follow a stream and write to stdout
   durable-stream delete <stream_id>              Delete a stream
 
+Write Options:
+  --content-type <type>   Content-Type for the message (default: application/octet-stream)
+  --json                  Write as JSON (input stored as single message)
+  --batch-json            Write as JSON array of messages (each array element stored separately)
+
 Environment Variables:
   STREAM_URL    Base URL of the stream server (default: http://localhost:4437)
 `);
@@ -30,26 +99,63 @@ async function createStream(streamId) {
 		process.exit(1);
 	}
 }
-async function writeStream(streamId, content) {
+/**
+* Append JSON data to a stream with one-level array flattening.
+*/
+async function appendJson(stream, parsed) {
+	let count = 0;
+	for (const item of flattenJsonForAppend(parsed)) {
+		await stream.append(item);
+		count++;
+	}
+	return count;
+}
+async function writeStream(streamId, contentType, batchJson, content) {
 	const url = `${STREAM_URL}/v1/stream/${streamId}`;
+	const isJson = isJsonContentType(contentType);
 	try {
-		const stream = new DurableStream({ url });
+		const stream = new DurableStream({
+			url,
+			contentType
+		});
 		if (content) {
 			const processedContent = content.replace(/\\n/g, `\n`).replace(/\\t/g, `\t`).replace(/\\r/g, `\r`).replace(/\\\\/g, `\\`);
-			await stream.append(processedContent);
-			console.log(`Wrote ${processedContent.length} bytes to ${streamId}`);
+			if (isJson) {
+				const parsed = JSON.parse(processedContent);
+				if (batchJson) {
+					const count = await appendJson(stream, parsed);
+					console.log(`Wrote ${count} message(s) to ${streamId}`);
+				} else {
+					await stream.append(parsed);
+					console.log(`Wrote 1 message to ${streamId}`);
+				}
+			} else {
+				await stream.append(processedContent);
+				console.log(`Wrote ${processedContent.length} bytes to ${streamId}`);
+			}
 		} else {
 			const chunks = [];
 			stdin.on(`data`, (chunk) => {
 				chunks.push(chunk);
 			});
-			await new Promise((resolve, reject) => {
-				stdin.on(`end`, resolve);
+			await new Promise((resolve$1, reject) => {
+				stdin.on(`end`, resolve$1);
 				stdin.on(`error`, reject);
 			});
 			const data = Buffer.concat(chunks);
-			await stream.append(data);
-			console.log(`Wrote ${data.length} bytes to ${streamId}`);
+			if (isJson) {
+				const parsed = JSON.parse(data.toString(`utf8`));
+				if (batchJson) {
+					const count = await appendJson(stream, parsed);
+					console.log(`Wrote ${count} message(s) to ${streamId}`);
+				} else {
+					await stream.append(parsed);
+					console.log(`Wrote 1 message to ${streamId}`);
+				}
+			} else {
+				await stream.append(data);
+				console.log(`Wrote ${data.length} bytes to ${streamId}`);
+			}
 		}
 	} catch (error) {
 		if (error instanceof Error) stderr.write(`Error writing to stream: ${error.message}\n`);
@@ -102,9 +208,15 @@ async function main() {
 				process.exit(1);
 			}
 			const streamId = args[1];
-			const content = args.slice(2).join(` `);
-			if (!stdin.isTTY) await writeStream(streamId);
-			else if (content) await writeStream(streamId, content);
+			let parsed;
+			try {
+				parsed = parseWriteArgs(args.slice(2));
+			} catch (error) {
+				if (error instanceof Error) stderr.write(`Error: ${error.message}\n`);
+				process.exit(1);
+			}
+			if (!stdin.isTTY) await writeStream(streamId, parsed.contentType, parsed.batchJson);
+			else if (parsed.content) await writeStream(streamId, parsed.contentType, parsed.batchJson, parsed.content);
 			else {
 				stderr.write(`Error: content required (provide as argument or pipe to stdin)\n`);
 				printUsage();
@@ -136,9 +248,16 @@ async function main() {
 			process.exit(1);
 	}
 }
-main().catch((error) => {
+function isMainModule() {
+	if (!process.argv[1]) return false;
+	const scriptPath = resolve(process.argv[1]);
+	const modulePath = fileURLToPath(import.meta.url);
+	return scriptPath === modulePath;
+}
+if (isMainModule()) main().catch((error) => {
 	stderr.write(`Fatal error: ${error.message}\n`);
 	process.exit(1);
 });
 
-//#endregion
+//#endregion
+export { flattenJsonForAppend, isJsonContentType, parseWriteArgs };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@durable-streams/cli",
   "description": "CLI tool for working with Durable Streams",
-  "version": "0.1.3",
+  "version": "0.1.5",
   "author": "Durable Stream contributors",
   "bin": {
     "cli": "./dist/index.js",
@@ -12,14 +12,15 @@
     "url": "https://github.com/durable-streams/durable-streams/issues"
   },
   "dependencies": {
-    "@durable-streams/client": "0.1.2"
+    "@durable-streams/client": "0.1.4"
   },
   "devDependencies": {
     "@types/node": "^22.15.21",
     "tsdown": "^0.9.0",
     "tsx": "^4.19.2",
     "typescript": "^5.5.2",
-    "@durable-streams/server": "0.1.3"
+    "vitest": "^3.1.3",
+    "@durable-streams/server": "0.1.5"
   },
   "engines": {
     "node": ">=18.0.0"
@@ -62,6 +63,7 @@
     "build": "tsdown",
     "dev": "tsdown --watch",
     "link:dev": "pnpm link --global",
-    "start:dev": "tsx --watch example-server.ts"
+    "start:dev": "tsx --watch example-server.ts",
+    "test": "vitest run"
   }
 }