feat: Implement Blob node and associated components for file uploads

Author: bchapuis

apps/api/src/nodes/blob/blob-node.ts

@@ -0,0 +1,56 @@
+import { NodeExecution, NodeType } from "@dafthunk/types";
+
+import { ExecutableNode } from "../types";
+import { NodeContext } from "../types";
+
+/**
+ * Blob node implementation
+ * This node provides a blob widget that allows users to upload any file type and outputs them as binary data.
+ */
+export class BlobNode extends ExecutableNode {
+  public static readonly nodeType: NodeType = {
+    id: "blob",
+    name: "Blob",
+    type: "blob",
+    description: "A blob widget for uploading any file type",
+    tags: ["Widget", "Blob", "Load", "File"],
+    icon: "file",
+    documentation:
+      "This node provides a blob widget for uploading any file type and outputs them as blob references. It can accept any MIME type and connect to any specific blob type (image, audio, document, etc.).",
+    inputs: [
+      {
+        name: "value",
+        type: "blob",
+        description: "Current file as a blob reference",
+        hidden: true,
+      },
+    ],
+    outputs: [
+      {
+        name: "blob",
+        type: "blob",
+        description: "The uploaded file as a blob reference",
+      },
+    ],
+  };
+
+  async execute(context: NodeContext): Promise<NodeExecution> {
+    try {
+      const { value } = context.inputs;
+
+      // If no value is provided, fail
+      if (!value) {
+        return this.createErrorResult("No blob data provided");
+      }
+
+      // Convert raw object to BlobValue
+      return this.createSuccessResult({
+        blob: value,
+      });
+    } catch (error) {
+      return this.createErrorResult(
+        error instanceof Error ? error.message : "Unknown error"
+      );
+    }
+  }
+}

apps/api/src/nodes/blob/index.ts

@@ -0,0 +1 @@
+export * from "./blob-node";

apps/api/src/nodes/cloudflare-node-registry.ts

@@ -38,6 +38,7 @@ import { ListGuildChannelsDiscordNode } from "./discord/list-guild-channels-disc
 import { ListUserGuildsDiscordNode } from "./discord/list-user-guilds-discord-node";
 import { SendDMDiscordNode } from "./discord/send-dm-discord-node";
 import { SendMessageDiscordNode } from "./discord/send-message-discord-node";
+import { BlobNode } from "./blob/blob-node";
 import { DocumentNode } from "./document/document-node";
 import { ToMarkdownNode } from "./document/to-markdown-node";
 import { ParseEmailNode } from "./email/parse-email-node";
@@ -517,6 +518,7 @@ export class CloudflareNodeRegistry extends BaseNodeRegistry {
 
     this.registerImplementation(AudioRecorderNode);
     this.registerImplementation(ToMarkdownNode);
+    this.registerImplementation(BlobNode);
     this.registerImplementation(DocumentNode);
     this.registerImplementation(HttpRequestNode);
 

apps/api/src/nodes/parameter-mapper.ts

@@ -6,6 +6,7 @@ import {
 import { ObjectStore } from "../stores/object-store";
 import {
   AudioParameter as NodeAudioParameter,
+  BlobParameter as NodeBlobParameter,
   BufferGeometryParameter as NodeBufferGeometryParameter,
   DocumentParameter as NodeDocumentParameter,
   GltfParameter as NodeGltfParameter,
@@ -14,6 +15,17 @@ import {
 } from "./types";
 
 // Type guards for binary parameter types
+function isBlobParameter(value: unknown): value is NodeBlobParameter {
+  return (
+    !!value &&
+    typeof value === "object" &&
+    "data" in value &&
+    "mimeType" in value &&
+    value["data"] instanceof Uint8Array &&
+    typeof value["mimeType"] === "string"
+  );
+}
+
 function isImageParameter(value: unknown): value is NodeImageParameter {
   return (
     !!value &&
@@ -142,6 +154,40 @@ const converters = {
     nodeToApi: typeValidatingNodeToApi("boolean"),
     apiToNode: typeValidatingApiToNode("boolean"),
   },
+  blob: {
+    nodeToApi: async (
+      value: NodeParameterValue,
+      objectStore: ObjectStore,
+      organizationId: string,
+      executionId?: string
+    ) => {
+      if (!isBlobParameter(value)) return undefined;
+      const blob = new Blob([value.data], { type: value.mimeType });
+      const buffer = await blob.arrayBuffer();
+      const data = new Uint8Array(buffer);
+      return await objectStore.writeObject(
+        data,
+        blob.type,
+        organizationId,
+        executionId
+      );
+    },
+    apiToNode: async (value: ApiParameterValue, objectStore: ObjectStore) => {
+      if (
+        !value ||
+        typeof value !== "object" ||
+        !("id" in value) ||
+        !("mimeType" in value)
+      )
+        return undefined;
+      const result = await objectStore.readObject(value as ObjectReference);
+      if (!result) return undefined;
+      return {
+        data: result.data,
+        mimeType: (value as ObjectReference).mimeType,
+      } as NodeBlobParameter;
+    },
+  },
   image: {
     nodeToApi: async (
       value: NodeParameterValue,
@@ -525,6 +571,7 @@ export async function nodeToApiParameter(
       );
 
     if (
+      type === "blob" ||
       type === "image" ||
       type === "document" ||
       type === "audio" ||

apps/api/src/nodes/types.ts

@@ -47,6 +47,10 @@ export type ParameterType =
       type: "boolean";
       value?: boolean;
     }
+  | {
+      type: "blob";
+      value?: BlobParameter;
+    }
   | {
       type: "image";
       value?: ImageParameter;

apps/api/src/utils/workflows.ts

@@ -116,12 +116,26 @@ export function validateTypeCompatibility(
       };
     }
 
-    if (sourceParam.type !== targetParam.type) {
-      // Allow "any" type to be compatible with all other types
-      if (sourceParam.type === "any" || targetParam.type === "any") {
-        continue;
-      }
-
+    // Define blob-compatible types
+    const blobTypes = new Set([
+      "image",
+      "audio",
+      "document",
+      "buffergeometry",
+      "gltf",
+    ]);
+
+    // Check type compatibility
+    const exactMatch = sourceParam.type === targetParam.type;
+    const anyTypeMatch =
+      sourceParam.type === "any" || targetParam.type === "any";
+    const blobCompatible =
+      (sourceParam.type === "blob" && blobTypes.has(targetParam.type)) ||
+      (targetParam.type === "blob" && blobTypes.has(sourceParam.type));
+
+    const typesMatch = exactMatch || anyTypeMatch || blobCompatible;
+
+    if (!typesMatch) {
       return {
         type: "TYPE_MISMATCH",
         message: `Type mismatch: ${sourceParam.type.toLowerCase().replace("value", "")} -> ${targetParam.type.toLowerCase().replace("value", "")}`,