@codemation/core-nodes 0.6.0 → 0.7.1

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # @codemation/core-nodes
 
+## 0.7.1
+
+### Patch Changes
+
+- [#130](https://github.com/MadeRelevant/codemation/pull/130) [`e8e3935`](https://github.com/MadeRelevant/codemation/commit/e8e39358a4282e0a780efb428ae0d71d105afd5f) Thanks [@cblokland90](https://github.com/cblokland90)! - `SubWorkflow` nodes now render with the Lucide `workflow` glyph by default, so they read at a glance on the canvas. Nodes that don't set an explicit `icon` (and have no semantic role like agent / model / tool) now fall back to a question-mark glyph instead of `Boxes` — a clearer "missing icon" signal for plugin authors. Unknown icon tokens (`builtin:`, `si:`, `lucide:` lookups that don't resolve) also fall back to the same question-mark glyph for consistency.
+
+- Updated dependencies [[`d283b48`](https://github.com/MadeRelevant/codemation/commit/d283b481f01a1a259d38d25c1482006eff963384)]:
+  - @codemation/core@0.10.2
+
+## 0.7.0
+
+### Minor Changes
+
+- [#123](https://github.com/MadeRelevant/codemation/pull/123) [`c191557`](https://github.com/MadeRelevant/codemation/commit/c19155783a012d293568f55427ae36b31171af11) Thanks [@cblokland90](https://github.com/cblokland90)! - feat(core-nodes): HttpRequest body and response support binary slots
+  - Add `responseFormat: "binary"` config field to store response bytes directly in `ctx.binary` rather than parsing as JSON/text. Output JSON carries `{ status, headers, binarySlot, contentType, size, filename }`.
+  - Add `responseBinarySlot?: string` (default `"response"`) and `responseSizeCapBytes?: number` (default 100 MiB, checked against `Content-Length` before allocating).
+  - Add `body: { kind: "binary", slot: string }` body spec to send raw bytes from a binary attachment slot as the request body. The attachment's `mimeType` is used as `Content-Type` unless an explicit header overrides it.
+  - Fix: explicit `headers["content-type"]` now correctly wins over the body-derived content type for all body kinds (was previously overwritten).
+  - Extract `HttpBodyBuilder.readStreamToBuffer` private helper to deduplicate stream-reading code shared between multipart and binary body kinds.
+
+### Patch Changes
+
+- [#126](https://github.com/MadeRelevant/codemation/pull/126) [`d0f2bd9`](https://github.com/MadeRelevant/codemation/commit/d0f2bd9a670ff80c2e2e12f7c410c63d14c94b55) Thanks [@cblokland90](https://github.com/cblokland90)! - DriveDownload and OnNewMail now stream binary attachments directly into binary storage instead of buffering the entire payload in RAM (`Buffer.concat` / `Buffer.from(x, "base64")`). Functionally equivalent — only the memory profile improves (critical for multi-GB files).
+
+  Adds `codemation/no-buffer-everything` ESLint rule (error severity) to prevent future regressions: flags `Buffer.from(x,"base64")`, `.arrayBuffer()`, and `Buffer.concat()` with guidance on streaming alternatives. Genuine constraints (AES-GCM cipher, Graph upload requiring Content-Length, Excel workbook responses) are suppressed with justified `-- <reason>` comments.
+
+  Follow-up: support streaming multipart upload via the form-data package to remove the suppression in `HttpBodyBuilder`.
+
+- Updated dependencies [[`1f10121`](https://github.com/MadeRelevant/codemation/commit/1f10121a093ef0612a33c873419b032709c9964d)]:
+  - @codemation/core@0.10.1
+
 ## 0.6.0
 
 ### Minor Changes

package/dist/index.cjs

@@ -323,7 +323,8 @@ var HttpRequestExecutor = class {
 			...credentialDelta.query ?? {}
 		};
 		const encodedBody = await this.bodyBuilder.build(spec.body, item, spec.ctx);
-		if (encodedBody && encodedBody.contentType) mergedHeaders["content-type"] = encodedBody.contentType;
+		const hasExplicitContentType = Object.keys(mergedHeaders).some((k) => k.toLowerCase() === "content-type");
+		if (encodedBody && encodedBody.contentType && !hasExplicitContentType) mergedHeaders["content-type"] = encodedBody.contentType;
 		return {
 			url: this.urlBuilder.build(spec.url, mergedQuery),
 			init: {
@@ -422,21 +423,7 @@ var HttpBodyBuilder = class {
 				if (attachment) {
 					const readResult = await ctx.binary.openReadStream(attachment);
 					if (readResult) {
-						const reader = readResult.body.getReader();
-						const chunks = [];
-						let done = false;
-						while (!done) {
-							const result = await reader.read();
-							done = result.done;
-							if (result.value) chunks.push(result.value);
-						}
-						const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
-						const merged = new Uint8Array(totalLength);
-						let offset = 0;
-						for (const chunk of chunks) {
-							merged.set(chunk, offset);
-							offset += chunk.length;
-						}
+						const merged = await this.readStreamToBuffer(readResult.body);
 						const blob = new Blob([merged], { type: attachment.mimeType });
 						formData.append(fieldName, blob, attachment.filename ?? binaryRef);
 					}
@@ -447,6 +434,34 @@ var HttpBodyBuilder = class {
 				contentType: ""
 			};
 		}
+		if (spec.kind === "binary") {
+			const attachment = item.binary?.[spec.slot];
+			if (!attachment) throw new Error(`HttpRequest bodyFormat "binary": no binary attachment found at slot "${spec.slot}". Ensure a previous node attached binary data at that slot.`);
+			const readResult = await ctx.binary.openReadStream(attachment);
+			if (!readResult) throw new Error(`HttpRequest bodyFormat "binary": could not open read stream for slot "${spec.slot}".`);
+			return {
+				body: readResult.body,
+				contentType: attachment.mimeType
+			};
+		}
+	}
+	async readStreamToBuffer(stream) {
+		const reader = stream.getReader();
+		const chunks = [];
+		let done = false;
+		while (!done) {
+			const result = await reader.read();
+			done = result.done;
+			if (result.value) chunks.push(result.value);
+		}
+		const totalLength = chunks.reduce((acc, chunk) => acc + chunk.length, 0);
+		const merged = new Uint8Array(new ArrayBuffer(totalLength));
+		let offset = 0;
+		for (const chunk of chunks) {
+			merged.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return merged;
 	}
 };
 
@@ -6540,12 +6555,16 @@ let HttpRequestNode = class HttpRequestNode$1 {
 				mode: ctx.config.downloadMode,
 				binaryName: ctx.config.binaryName
 			},
+			responseFormat: ctx.config.responseFormat,
+			responseBinarySlot: ctx.config.responseBinarySlot,
+			responseSizeCapBytes: ctx.config.responseSizeCapBytes,
 			ctx
 		};
 		const { url: resolvedUrl, init } = await new HttpRequestExecutor(globalThis.fetch, new HttpBodyBuilder(), new HttpUrlBuilder()).buildRequest(spec, item);
 		const response = await globalThis.fetch(resolvedUrl, init);
 		const headers = this.readHeaders(response.headers);
 		const mimeType = this.resolveMimeType(headers);
+		if (ctx.config.responseFormat === "binary") return await this.handleBinaryResponse(response, resolvedUrl, headers, mimeType, ctx);
 		const binaryName = ctx.config.binaryName;
 		if (this.shouldAttachBody(ctx.config.downloadMode, mimeType)) {
 			const outputJson = {
@@ -6589,6 +6608,36 @@ let HttpRequestNode = class HttpRequestNode$1 {
 			...text !== void 0 ? { text } : {}
 		} };
 	}
+	async handleBinaryResponse(response, resolvedUrl, headers, mimeType, ctx) {
+		const slotName = ctx.config.responseBinarySlot;
+		const sizeCap = ctx.config.responseSizeCapBytes;
+		const contentLengthHeader = headers["content-length"];
+		if (contentLengthHeader) {
+			const declaredSize = parseInt(contentLengthHeader, 10);
+			if (!isNaN(declaredSize) && declaredSize > sizeCap) throw new Error(`HttpRequest responseFormat "binary": response Content-Length (${declaredSize} bytes) exceeds responseSizeCapBytes (${sizeCap} bytes).`);
+		}
+		const filename = this.resolveFilename(resolvedUrl, headers);
+		const attachment = await ctx.binary.attach({
+			name: slotName,
+			body: response.body ? response.body : new Uint8Array(await response.arrayBuffer()),
+			mimeType,
+			filename
+		});
+		let outputItem = { json: {
+			url: resolvedUrl,
+			method: ctx.config.method,
+			ok: response.ok,
+			status: response.status,
+			statusText: response.statusText,
+			headers,
+			binarySlot: slotName,
+			contentType: mimeType,
+			size: attachment.size,
+			...filename !== void 0 ? { filename } : {}
+		} };
+		outputItem = ctx.binary.withAttachment(outputItem, slotName, attachment);
+		return outputItem;
+	}
 	async resolveCredential(ctx) {
 		const slotKey = ctx.config.args.credentialSlot;
 		if (!slotKey) return;
@@ -6660,6 +6709,8 @@ const HTTP_REQUEST_ACCEPTED_CREDENTIAL_TYPES = [
 	basicAuthCredentialType.definition.typeId,
 	oauth2ClientCredentialsType.definition.typeId
 ];
+/** Default maximum response size for binary mode: 100 MiB. */
+const DEFAULT_RESPONSE_SIZE_CAP_BYTES = 100 * 1024 * 1024;
 var HttpRequest = class {
 	kind = "node";
 	type = HttpRequestNode;
@@ -6685,6 +6736,15 @@ var HttpRequest = class {
 	get downloadMode() {
 		return this.args.downloadMode ?? "auto";
 	}
+	get responseFormat() {
+		return this.args.responseFormat;
+	}
+	get responseBinarySlot() {
+		return this.args.responseBinarySlot ?? "response";
+	}
+	get responseSizeCapBytes() {
+		return this.args.responseSizeCapBytes ?? DEFAULT_RESPONSE_SIZE_CAP_BYTES;
+	}
 	getCredentialRequirements() {
 		if (!this.args.credentialSlot) return [];
 		return [{
@@ -7178,6 +7238,10 @@ let SubWorkflowNode = class SubWorkflowNode$1 {
 				engineMaxSubworkflowDepth: args.ctx.engineMaxSubworkflowDepth
 			}
 		});
+		await args.ctx.nodeState?.setChildRunId?.({
+			nodeId: args.ctx.nodeId,
+			childRunId: result.runId
+		});
 		if (result.status !== "completed") throw new Error(`Subworkflow ${args.ctx.config.workflowId} did not complete (status=${result.status})`);
 		const out = [];
 		for (const produced of result.outputs) {
@@ -7209,6 +7273,7 @@ SubWorkflowNode = __decorate([
 var SubWorkflow = class {
 	kind = "node";
 	type = SubWorkflowNode;
+	icon = "lucide:workflow";
 	constructor(name, workflowId, upstreamRefs, startAt, id) {
 		this.name = name;
 		this.workflowId = workflowId;