@uploadista/core 0.0.13 → 0.0.14

package/tests/flow/type-system.test.ts

@@ -0,0 +1,799 @@
+/**
+ * Tests for Flow Type System and Automatic Narrowing
+ *
+ * Covers:
+ * - TypedOutput discriminated unions
+ * - Automatic type narrowing for built-in types
+ * - Type guards for custom types
+ * - FlowJob.result with TypedOutput[]
+ * - Multi-output flow handling
+ * - Backward compatibility with untyped nodes
+ * - Type registry integration
+ * - Helper functions (filter, getSingle)
+ */
+
+import { Effect } from "effect";
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import type { UploadFile } from "../../src/types/upload-file";
+import { createFlow } from "../../src/flow";
+import { createFlowNode, NodeType } from "../../src/flow/node";
+import type { TypedOutput } from "../../src/flow/types/flow-types";
+import {
+	createTypeGuard,
+	filterOutputsByType,
+	getSingleOutputByType,
+	isStorageOutput,
+} from "../../src/flow/type-guards";
+import { flowTypeRegistry } from "../../src/flow/type-registry";
+// Import built-in type registrations
+import "../../src/flow/node-types";
+
+// Helper function to create valid UploadFile test data
+function createMockUploadFile(overrides?: Partial<UploadFile>): UploadFile {
+	return {
+		id: "file-123",
+		offset: 0,
+		storage: {
+			id: "storage-1",
+			type: "s3",
+			bucket: "uploads",
+		},
+		size: 1024,
+		url: "https://example.com/file.jpg",
+		creationDate: new Date().toISOString(),
+		...overrides,
+	};
+}
+
+describe("Type System", () => {
+	describe("TypedOutput Discriminated Unions", () => {
+		it("should automatically narrow built-in storage-output-v1", () => {
+			// Create a typed output with built-in type
+			const output: TypedOutput = {
+				nodeType: "storage-output-v1",
+				nodeId: "storage-1",
+				timestamp: new Date().toISOString(),
+				data: createMockUploadFile({
+					id: "file-123",
+					url: "https://example.com/test.jpg",
+					size: 1024,
+				}),
+			};
+
+			// TypeScript should automatically narrow in switch
+			switch (output.nodeType) {
+				case "storage-output-v1":
+					// ✅ TypeScript knows output.data is UploadFile
+					expect(output.data.url).toBe("https://example.com/test.jpg");
+					expect(output.data.size).toBe(1024);
+					expect(output.data.id).toBe("file-123");
+					break;
+				default:
+					throw new Error("Should have matched storage-output-v1");
+			}
+		});
+
+		it("should automatically narrow built-in streaming-input-v1", () => {
+			const output: TypedOutput = {
+				nodeType: "streaming-input-v1",
+				nodeId: "input-1",
+				timestamp: new Date().toISOString(),
+				data: {
+					id: "file-456",
+					name: "upload.pdf",
+					size: 2048,
+					mimeType: "application/pdf",
+					url: "https://example.com/upload.pdf",
+					bucket: "inputs",
+					key: "upload.pdf",
+					storageId: "storage-1",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				} satisfies UploadFile,
+			};
+
+			switch (output.nodeType) {
+				case "streaming-input-v1":
+					// ✅ TypeScript knows output.data is UploadFile
+					expect(output.data.name).toBe("upload.pdf");
+					expect(output.data.size).toBe(2048);
+					break;
+				default:
+					throw new Error("Should have matched streaming-input-v1");
+			}
+		});
+
+		it("should handle custom types with optional nodeType", () => {
+			type ThumbnailOutput = { width: number; height: number; url: string };
+
+			const output: TypedOutput<ThumbnailOutput> = {
+				nodeType: "thumbnail-v1",
+				nodeId: "thumbnail-1",
+				timestamp: new Date().toISOString(),
+				data: { width: 150, height: 150, url: "https://example.com/thumb.jpg" },
+			};
+
+			// Custom types require type guards (no automatic narrowing)
+			expect(output.nodeType).toBe("thumbnail-v1");
+			expect((output.data as ThumbnailOutput).width).toBe(150);
+		});
+
+		it("should handle untyped outputs (no nodeType)", () => {
+			const output: TypedOutput = {
+				nodeId: "untyped-1",
+				timestamp: new Date().toISOString(),
+				data: { customField: "value" },
+			};
+
+			// Untyped outputs have unknown data
+			expect(output.nodeType).toBeUndefined();
+			expect(output.data).toEqual({ customField: "value" });
+		});
+
+		it("should support array of mixed typed outputs", () => {
+			const outputs: TypedOutput[] = [
+				{
+					nodeType: "storage-output-v1",
+					nodeId: "storage-1",
+					timestamp: new Date().toISOString(),
+					data: {
+						id: "file-1",
+						name: "file1.jpg",
+						size: 1024,
+						mimeType: "image/jpeg",
+						url: "https://example.com/file1.jpg",
+						bucket: "uploads",
+						key: "file1.jpg",
+						storageId: "storage-1",
+						createdAt: new Date(),
+						updatedAt: new Date(),
+					},
+				},
+				{
+					nodeType: "streaming-input-v1",
+					nodeId: "input-1",
+					timestamp: new Date().toISOString(),
+					data: {
+						id: "file-2",
+						name: "file2.pdf",
+						size: 2048,
+						mimeType: "application/pdf",
+						url: "https://example.com/file2.pdf",
+						bucket: "inputs",
+						key: "file2.pdf",
+						storageId: "storage-1",
+						createdAt: new Date(),
+						updatedAt: new Date(),
+					},
+				},
+				{
+					nodeType: "custom-v1",
+					nodeId: "custom-1",
+					timestamp: new Date().toISOString(),
+					data: { customData: "test" },
+				},
+			];
+
+			// Process mixed outputs with automatic narrowing + type guards
+			let storageCount = 0;
+			let inputCount = 0;
+			let customCount = 0;
+
+			for (const output of outputs) {
+				switch (output.nodeType) {
+					case "storage-output-v1":
+						storageCount++;
+						expect(output.data.url).toContain("https://");
+						break;
+					case "streaming-input-v1":
+						inputCount++;
+						expect(output.data.name).toBeTruthy();
+						break;
+					default:
+						customCount++;
+				}
+			}
+
+			expect(storageCount).toBe(1);
+			expect(inputCount).toBe(1);
+			expect(customCount).toBe(1);
+		});
+	});
+
+	describe("Type Guards", () => {
+		it("should validate storage outputs with isStorageOutput", () => {
+			const validOutput: TypedOutput = {
+				nodeType: "storage-output-v1",
+				nodeId: "storage-1",
+				timestamp: new Date().toISOString(),
+				data: createMockUploadFile({
+					id: "file-123",
+					url: "https://example.com/test.jpg",
+				}),
+			};
+
+			const invalidOutput: TypedOutput = {
+				nodeType: "custom-v1",
+				nodeId: "custom-1",
+				timestamp: new Date().toISOString(),
+				data: { customField: "value" },
+			};
+
+			expect(isStorageOutput(validOutput)).toBe(true);
+			expect(isStorageOutput(invalidOutput)).toBe(false);
+		});
+
+		it("should create custom type guards with createTypeGuard", () => {
+			// Register custom type
+			type ThumbnailOutput = { width: number; height: number; url: string };
+			const thumbnailSchema = z.object({
+				width: z.number(),
+				height: z.number(),
+				url: z.string().url(),
+			});
+
+			flowTypeRegistry.register({
+				id: "thumbnail-test-v1",
+				name: "Thumbnail Output",
+				description: "Thumbnail metadata",
+				category: "output",
+				schema: thumbnailSchema,
+			});
+
+			const isThumbnailOutput = createTypeGuard<ThumbnailOutput>("thumbnail-test-v1");
+
+			const validOutput: TypedOutput = {
+				nodeType: "thumbnail-test-v1",
+				nodeId: "thumb-1",
+				timestamp: new Date().toISOString(),
+				data: { width: 150, height: 150, url: "https://example.com/thumb.jpg" },
+			};
+
+			const invalidOutput: TypedOutput = {
+				nodeType: "thumbnail-test-v1",
+				nodeId: "thumb-2",
+				timestamp: new Date().toISOString(),
+				data: { invalid: "data" }, // Missing required fields
+			};
+
+			expect(isThumbnailOutput(validOutput)).toBe(true);
+			expect(isThumbnailOutput(invalidOutput)).toBe(false);
+		});
+
+		it("should handle type guards with wrong nodeType", () => {
+			const output: TypedOutput = {
+				nodeType: "storage-output-v1",
+				nodeId: "storage-1",
+				timestamp: new Date().toISOString(),
+				data: {
+					id: "file-123",
+					name: "test.jpg",
+					size: 1024,
+					mimeType: "image/jpeg",
+					url: "https://example.com/test.jpg",
+					bucket: "uploads",
+					key: "test.jpg",
+					storageId: "storage-1",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			};
+
+			// Create guard for different type
+			const isThumbnail = createTypeGuard("thumbnail-test-v1");
+
+			// Should return false for wrong nodeType
+			expect(isThumbnail(output)).toBe(false);
+		});
+	});
+
+	describe("Helper Functions", () => {
+		it("should filter outputs by type with filterOutputsByType", () => {
+			const outputs: TypedOutput[] = [
+				{
+					nodeType: "storage-output-v1",
+					nodeId: "storage-1",
+					timestamp: new Date().toISOString(),
+					data: createMockUploadFile({
+						id: "file-1",
+						url: "https://example.com/file1.jpg",
+					}),
+				},
+				{
+					nodeType: "streaming-input-v1",
+					nodeId: "input-1",
+					timestamp: new Date().toISOString(),
+					data: createMockUploadFile({
+						id: "file-2",
+						url: "https://example.com/file2.pdf",
+						size: 2048,
+					}),
+				},
+				{
+					nodeType: "storage-output-v1",
+					nodeId: "storage-2",
+					timestamp: new Date().toISOString(),
+					data: createMockUploadFile({
+						id: "file-3",
+						url: "https://example.com/file3.png",
+						size: 512,
+					}),
+				},
+			];
+
+			const storageOutputs = filterOutputsByType(outputs, isStorageOutput);
+
+			expect(storageOutputs).toHaveLength(2);
+			expect(storageOutputs[0]?.data.id).toBe("file-1");
+			expect(storageOutputs[1]?.data.id).toBe("file-3");
+		});
+
+		it("should get single output with getSingleOutputByType", () =>
+			Effect.gen(function* () {
+				const outputs: TypedOutput[] = [
+					{
+						nodeType: "streaming-input-v1",
+						nodeId: "input-1",
+						timestamp: new Date().toISOString(),
+						data: createMockUploadFile({
+							id: "file-1",
+							url: "https://example.com/file1.pdf",
+							size: 2048,
+						}),
+					},
+					{
+						nodeType: "storage-output-v1",
+						nodeId: "storage-1",
+						timestamp: new Date().toISOString(),
+						data: createMockUploadFile({
+							id: "file-2",
+							url: "https://example.com/file2.jpg",
+						}),
+					},
+				];
+
+				const storageOutput = yield* getSingleOutputByType(outputs, isStorageOutput);
+
+				expect(storageOutput.nodeType).toBe("storage-output-v1");
+				expect(storageOutput.data.id).toBe("file-2");
+			}).pipe(Effect.runPromise));
+
+		it("should fail when no outputs match getSingleOutputByType", () =>
+			Effect.gen(function* () {
+				const outputs: TypedOutput[] = [
+					{
+						nodeType: "streaming-input-v1",
+						nodeId: "input-1",
+						timestamp: new Date().toISOString(),
+						data: createMockUploadFile({
+							id: "file-1",
+							url: "https://example.com/file1.pdf",
+						}),
+					},
+				];
+
+				const result = yield* Effect.either(
+					getSingleOutputByType(outputs, isStorageOutput),
+				);
+
+				expect(result._tag).toBe("Left");
+				if (result._tag === "Left") {
+					expect(result.left.code).toBe("OUTPUT_NOT_FOUND");
+				}
+			}).pipe(Effect.runPromise));
+
+		it("should fail when multiple outputs match getSingleOutputByType", () =>
+			Effect.gen(function* () {
+				const outputs: TypedOutput[] = [
+					{
+						nodeType: "storage-output-v1",
+						nodeId: "storage-1",
+						timestamp: new Date().toISOString(),
+						data: createMockUploadFile({
+							id: "file-1",
+							url: "https://example.com/file1.jpg",
+						}),
+					},
+					{
+						nodeType: "storage-output-v1",
+						nodeId: "storage-2",
+						timestamp: new Date().toISOString(),
+						data: createMockUploadFile({
+							id: "file-2",
+							url: "https://example.com/file2.jpg",
+							size: 2048,
+						}),
+					},
+				];
+
+				const result = yield* Effect.either(
+					getSingleOutputByType(outputs, isStorageOutput),
+				);
+
+				expect(result._tag).toBe("Left");
+				if (result._tag === "Left") {
+					expect(result.left.code).toBe("MULTIPLE_OUTPUTS_FOUND");
+				}
+			}).pipe(Effect.runPromise));
+	});
+
+	describe("Flow Integration with Typed Outputs", () => {
+		it("should collect typed outputs from single output node", () =>
+			Effect.gen(function* () {
+				const inputNode = yield* createFlowNode({
+					id: "input-1",
+					name: "Input Node",
+					description: "Test input",
+					type: NodeType.input,
+					nodeTypeId: "streaming-input-v1",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ value: z.string() }),
+					run: ({ data }) =>
+						Effect.succeed({ type: "complete", data: { value: data.value } }),
+				});
+
+				const storageNode = yield* createFlowNode({
+					id: "storage-1",
+					name: "Storage Node",
+					description: "Storage output",
+					type: NodeType.output,
+					nodeTypeId: "storage-output-v1",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.custom<UploadFile>(),
+					run: () =>
+						Effect.succeed({
+							type: "complete",
+							data: createMockUploadFile({
+								id: "file-123",
+								url: "https://example.com/output.jpg",
+							}),
+						}),
+				});
+
+				const flow = yield* createFlow({
+					flowId: "typed-output-flow",
+					name: "Typed Output Flow",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.custom<UploadFile>(),
+					nodes: {
+						"input-1": inputNode,
+						"storage-1": storageNode,
+					},
+					edges: [{ source: "input-1", target: "storage-1" }],
+				});
+
+				const result = yield* flow.run({
+					inputs: { "input-1": { value: "test" } },
+					storageId: "test-storage",
+					jobId: "test-job",
+				});
+
+				expect(result.type).toBe("completed");
+				if (result.type === "completed") {
+					// Check typed outputs array
+					expect(result.outputs).toBeDefined();
+					expect(Array.isArray(result.outputs)).toBe(true);
+					expect(result.outputs?.length).toBe(1);
+
+					const output = result.outputs?.[0];
+					expect(output?.nodeType).toBe("storage-output-v1");
+					expect(output?.nodeId).toBe("storage-1");
+
+					// Automatic narrowing in switch
+					if (output) {
+						switch (output.nodeType) {
+							case "storage-output-v1":
+								expect(output.data.url).toBe("https://example.com/output.jpg");
+								expect(output.data.id).toBe("file-123");
+								break;
+						}
+					}
+				}
+			}).pipe(Effect.runPromise));
+
+		it("should collect typed outputs from multiple output nodes", () =>
+			Effect.gen(function* () {
+				const inputNode = yield* createFlowNode({
+					id: "input-1",
+					name: "Input Node",
+					description: "Test input",
+					type: NodeType.input,
+					nodeTypeId: "streaming-input-v1",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ value: z.string() }),
+					run: ({ data }) =>
+						Effect.succeed({ type: "complete", data: { value: data.value } }),
+				});
+
+				const storage1 = yield* createFlowNode({
+					id: "storage-1",
+					name: "Storage 1",
+					description: "First storage",
+					type: NodeType.output,
+					nodeTypeId: "storage-output-v1",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.custom<UploadFile>(),
+					run: () =>
+						Effect.succeed({
+							type: "complete",
+							data: createMockUploadFile({
+								id: "file-1",
+								url: "https://example.com/output1.jpg",
+							}),
+						}),
+				});
+
+				const storage2 = yield* createFlowNode({
+					id: "storage-2",
+					name: "Storage 2",
+					description: "Second storage",
+					type: NodeType.output,
+					nodeTypeId: "storage-output-v1",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.custom<UploadFile>(),
+					run: () =>
+						Effect.succeed({
+							type: "complete",
+							data: createMockUploadFile({
+								id: "file-2",
+								url: "https://example.com/output2.png",
+								size: 2048,
+							}),
+						}),
+				});
+
+				const flow = yield* createFlow({
+					flowId: "multi-output-flow",
+					name: "Multi Output Flow",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.custom<UploadFile>(),
+					nodes: {
+						"input-1": inputNode,
+						"storage-1": storage1,
+						"storage-2": storage2,
+					},
+					edges: [
+						{ source: "input-1", target: "storage-1" },
+						{ source: "input-1", target: "storage-2" },
+					],
+				});
+
+				const result = yield* flow.run({
+					inputs: { "input-1": { value: "test" } },
+					storageId: "test-storage",
+					jobId: "test-job",
+				});
+
+				expect(result.type).toBe("completed");
+				if (result.type === "completed") {
+					expect(result.outputs).toBeDefined();
+					expect(result.outputs?.length).toBe(2);
+
+					// Filter by type
+					const storageOutputs = filterOutputsByType(
+						result.outputs || [],
+						isStorageOutput,
+					);
+					expect(storageOutputs).toHaveLength(2);
+
+					// Check both outputs
+					const ids = storageOutputs.map((o) => o.data.id).sort();
+					expect(ids).toEqual(["file-1", "file-2"]);
+				}
+			}).pipe(Effect.runPromise));
+
+		it("should handle flows with mixed typed and untyped nodes", () =>
+			Effect.gen(function* () {
+				const inputNode = yield* createFlowNode({
+					id: "input-1",
+					name: "Input Node",
+					description: "Test input",
+					type: NodeType.input,
+					// No nodeTypeId - untyped
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ value: z.string() }),
+					run: ({ data }) =>
+						Effect.succeed({ type: "complete", data: { value: data.value } }),
+				});
+
+				const processNode = yield* createFlowNode({
+					id: "process-1",
+					name: "Process Node",
+					description: "Process data",
+					type: NodeType.process,
+					// No nodeTypeId - untyped
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ value: z.string() }),
+					run: ({ data }) =>
+						Effect.succeed({
+							type: "complete",
+							data: { value: `processed-${data.value}` },
+						}),
+				});
+
+				const storageNode = yield* createFlowNode({
+					id: "storage-1",
+					name: "Storage Node",
+					description: "Storage output",
+					type: NodeType.output,
+					nodeTypeId: "storage-output-v1", // Typed
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.custom<UploadFile>(),
+					run: () =>
+						Effect.succeed({
+							type: "complete",
+							data: createMockUploadFile({
+								id: "file-123",
+								url: "https://example.com/output.jpg",
+							}),
+						}),
+				});
+
+				const flow = yield* createFlow({
+					flowId: "mixed-flow",
+					name: "Mixed Typed/Untyped Flow",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.custom<UploadFile>(),
+					nodes: {
+						"input-1": inputNode,
+						"process-1": processNode,
+						"storage-1": storageNode,
+					},
+					edges: [
+						{ source: "input-1", target: "process-1" },
+						{ source: "process-1", target: "storage-1" },
+					],
+				});
+
+				const result = yield* flow.run({
+					inputs: { "input-1": { value: "test" } },
+					storageId: "test-storage",
+					jobId: "test-job",
+				});
+
+				expect(result.type).toBe("completed");
+				if (result.type === "completed") {
+					// Only typed output nodes should be in outputs array
+					expect(result.outputs).toBeDefined();
+					expect(result.outputs?.length).toBe(1);
+
+					const output = result.outputs?.[0];
+					expect(output?.nodeType).toBe("storage-output-v1");
+					expect(output?.nodeId).toBe("storage-1");
+				}
+			}).pipe(Effect.runPromise));
+
+		it("should handle flows with no output nodes (empty outputs)", () =>
+			Effect.gen(function* () {
+				const inputNode = yield* createFlowNode({
+					id: "input-1",
+					name: "Input Node",
+					description: "Test input",
+					type: NodeType.input,
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ value: z.string() }),
+					run: ({ data }) =>
+						Effect.succeed({ type: "complete", data: { value: data.value } }),
+				});
+
+				const processNode = yield* createFlowNode({
+					id: "process-1",
+					name: "Process Node",
+					description: "Process data",
+					type: NodeType.process,
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ value: z.string() }),
+					run: ({ data }) =>
+						Effect.succeed({
+							type: "complete",
+							data: { value: `processed-${data.value}` },
+						}),
+				});
+
+				const flow = yield* createFlow({
+					flowId: "no-output-flow",
+					name: "Flow with No Outputs",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ value: z.string() }),
+					nodes: {
+						"input-1": inputNode,
+						"process-1": processNode,
+					},
+					edges: [{ source: "input-1", target: "process-1" }],
+				});
+
+				const result = yield* flow.run({
+					inputs: { "input-1": { value: "test" } },
+					storageId: "test-storage",
+					jobId: "test-job",
+				});
+
+				expect(result.type).toBe("completed");
+				if (result.type === "completed") {
+					// No output nodes, so outputs should be empty array
+					expect(result.outputs).toBeDefined();
+					expect(result.outputs?.length).toBe(0);
+				}
+			}).pipe(Effect.runPromise));
+	});
+
+	describe("Backward Compatibility", () => {
+		it("should support legacy flows without nodeTypeId", () =>
+			Effect.gen(function* () {
+				const inputNode = yield* createFlowNode({
+					id: "input-1",
+					name: "Input Node",
+					description: "Legacy input",
+					type: NodeType.input,
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ value: z.string() }),
+					run: ({ data }) =>
+						Effect.succeed({ type: "complete", data: { value: data.value } }),
+				});
+
+				const outputNode = yield* createFlowNode({
+					id: "output-1",
+					name: "Output Node",
+					description: "Legacy output",
+					type: NodeType.output,
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ result: z.string() }),
+					run: ({ data }) =>
+						Effect.succeed({
+							type: "complete",
+							data: { result: `result-${data.value}` },
+						}),
+				});
+
+				const flow = yield* createFlow({
+					flowId: "legacy-flow",
+					name: "Legacy Flow",
+					inputSchema: z.object({ value: z.string() }),
+					outputSchema: z.object({ result: z.string() }),
+					nodes: {
+						"input-1": inputNode,
+						"output-1": outputNode,
+					},
+					edges: [{ source: "input-1", target: "output-1" }],
+				});
+
+				const result = yield* flow.run({
+					inputs: { "input-1": { value: "test" } },
+					storageId: "test-storage",
+					jobId: "test-job",
+				});
+
+				expect(result.type).toBe("completed");
+				if (result.type === "completed") {
+					// Legacy result field still works
+					expect(result.result["output-1"]).toEqual({ result: "result-test" });
+
+					// Typed outputs may be empty or undefined for legacy nodes
+					expect(result.outputs).toBeDefined();
+				}
+			}).pipe(Effect.runPromise));
+
+		it("should support existing type guards on untyped outputs", () => {
+			const untypedOutput: TypedOutput = {
+				nodeId: "untyped-1",
+				timestamp: new Date().toISOString(),
+				data: {
+					id: "file-123",
+					name: "test.jpg",
+					size: 1024,
+					mimeType: "image/jpeg",
+					url: "https://example.com/test.jpg",
+					bucket: "uploads",
+					key: "test.jpg",
+					storageId: "storage-1",
+					createdAt: new Date(),
+					updatedAt: new Date(),
+				},
+			};
+
+			// Type guards should work even without nodeType
+			expect(isStorageOutput(untypedOutput)).toBe(false); // No nodeType, so returns false
+		});
+	});
+});