@uploadista/flow-utility-nodes 0.0.3

package/dist/nodes/merge-node.js

@@ -0,0 +1,82 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { completeNodeExecution, createFlowNode, NodeType, } from "@uploadista/core/flow";
+import { uploadFileSchema } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import { z } from "zod";
+const inputSchema = z.record(z.string(), uploadFileSchema);
+const outputSchema = uploadFileSchema;
+export function createMergeNode(id, { strategy, separator: _separator }) {
+    return Effect.gen(function* () {
+        const uploadServer = yield* UploadServer;
+        return yield* createFlowNode({
+            id,
+            name: "Merge Files",
+            description: `Merges multiple files using ${strategy} strategy`,
+            type: NodeType.merge,
+            inputSchema,
+            outputSchema,
+            multiInput: true,
+            run: ({ data: inputs, storageId, clientId }) => {
+                return Effect.gen(function* () {
+                    if (!inputs || Object.keys(inputs).length === 0) {
+                        return yield* Effect.fail(UploadistaError.fromCode("VALIDATION_ERROR", {
+                            body: "No inputs provided to merge node",
+                        }));
+                    }
+                    const inputFiles = Object.values(inputs);
+                    if (inputFiles.length === 0) {
+                        return yield* Effect.fail(UploadistaError.fromCode("VALIDATION_ERROR", {
+                            body: "No files to merge",
+                        }));
+                    }
+                    switch (strategy) {
+                        case "concat": {
+                            // Read bytes from all input files
+                            const inputBytesArray = [];
+                            let totalSize = 0;
+                            for (const file of inputFiles) {
+                                const bytes = yield* uploadServer.read(file.id, clientId);
+                                inputBytesArray.push(bytes);
+                                totalSize += bytes.byteLength;
+                            }
+                            // Concatenate all files into one
+                            const mergedBytes = new Uint8Array(totalSize);
+                            let offset = 0;
+                            for (const bytes of inputBytesArray) {
+                                mergedBytes.set(bytes, offset);
+                                offset += bytes.byteLength;
+                            }
+                            // Create a stream from the merged bytes
+                            const stream = new ReadableStream({
+                                start(controller) {
+                                    controller.enqueue(mergedBytes);
+                                    controller.close();
+                                },
+                            });
+                            // Upload the merged file
+                            const result = yield* uploadServer.upload({
+                                storageId,
+                                size: mergedBytes.byteLength,
+                                type: "application/octet-stream",
+                                fileName: `merged_${inputFiles.length}_files.bin`,
+                                lastModified: 0,
+                                metadata: JSON.stringify({
+                                    mimeType: "application/octet-stream",
+                                    originalName: `merged_${inputFiles.length}_files`,
+                                    extension: "bin",
+                                }),
+                            }, clientId, stream);
+                            return completeNodeExecution(result);
+                        }
+                        default: {
+                            return yield* Effect.fail(UploadistaError.fromCode("VALIDATION_ERROR", {
+                                body: `Unknown merge strategy: ${strategy}`,
+                            }));
+                        }
+                    }
+                });
+            },
+        });
+    });
+}

package/dist/nodes/multiplex-node.d.ts

@@ -0,0 +1,7 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { type UploadFile } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import type { MultiplexParams } from "@/types/multiplex-node";
+export declare function createMultiplexNode(id: string, { outputCount: _outputCount, strategy }: MultiplexParams): Effect.Effect<import("@uploadista/core").FlowNode<UploadFile, UploadFile, UploadistaError>, never, UploadServer>;
+//# sourceMappingURL=multiplex-node.d.ts.map

package/dist/nodes/multiplex-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiplex-node.d.ts","sourceRoot":"","sources":["../../src/nodes/multiplex-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAO1D,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AAE9D,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,WAAW,EAAE,YAAY,EAAE,QAAQ,EAAE,EAAE,eAAe,oHAwEzD"}

package/dist/nodes/multiplex-node.js

@@ -0,0 +1,57 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { completeNodeExecution, createFlowNode, NodeType, resolveUploadMetadata, } from "@uploadista/core/flow";
+import { uploadFileSchema } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+export function createMultiplexNode(id, { outputCount: _outputCount, strategy }) {
+    return Effect.gen(function* () {
+        const uploadServer = yield* UploadServer;
+        return yield* createFlowNode({
+            id,
+            name: "Multiplex",
+            description: `Multiplexes input using ${strategy} strategy`,
+            type: NodeType.multiplex,
+            inputSchema: uploadFileSchema,
+            outputSchema: uploadFileSchema,
+            multiOutput: true,
+            run: ({ data: file, storageId, clientId }) => {
+                return Effect.gen(function* () {
+                    const { type, fileName, metadata, metadataJson } = resolveUploadMetadata(file.metadata);
+                    const normalizedFile = metadata ? { ...file, metadata } : file;
+                    if (strategy === "copy") {
+                        // For copy strategy, read and re-upload the file
+                        const inputBytes = yield* uploadServer.read(normalizedFile.id, clientId);
+                        const stream = new ReadableStream({
+                            start(controller) {
+                                controller.enqueue(inputBytes);
+                                controller.close();
+                            },
+                        });
+                        const result = yield* uploadServer.upload({
+                            storageId,
+                            size: inputBytes.byteLength,
+                            type,
+                            fileName,
+                            lastModified: 0,
+                            metadata: metadataJson,
+                        }, clientId, stream);
+                        const resolvedResult = resolveUploadMetadata(result.metadata);
+                        return completeNodeExecution(resolvedResult.metadata
+                            ? { ...result, metadata: resolvedResult.metadata }
+                            : result);
+                    }
+                    else if (strategy === "split") {
+                        // Split strategy is not supported in the new pattern
+                        // as it would require returning multiple UploadFiles
+                        return yield* Effect.fail(UploadistaError.fromCode("VALIDATION_ERROR", {
+                            body: "Split strategy is not supported with UploadFile pattern",
+                        }));
+                    }
+                    return yield* Effect.fail(UploadistaError.fromCode("VALIDATION_ERROR", {
+                        body: `Unknown multiplex strategy: ${strategy}`,
+                    }));
+                });
+            },
+        });
+    });
+}

package/dist/nodes/zip-node.d.ts

@@ -0,0 +1,8 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { ZipPlugin } from "@uploadista/core/flow";
+import { type UploadFile } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import type { ZipParams } from "@/types/zip-node";
+export declare function createZipNode(id: string, { zipName, includeMetadata }: ZipParams): Effect.Effect<import("@uploadista/core").FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer | ZipPlugin>;
+//# sourceMappingURL=zip-node.d.ts.map

package/dist/nodes/zip-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-node.d.ts","sourceRoot":"","sources":["../../src/nodes/zip-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAIL,SAAS,EACV,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAKlD,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,EAAE,OAAO,EAAE,eAAe,EAAE,EAAE,SAAS,gJAyExC"}

package/dist/nodes/zip-node.js

@@ -0,0 +1,64 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import { completeNodeExecution, createFlowNode, NodeType, ZipPlugin, } from "@uploadista/core/flow";
+import { uploadFileSchema } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import { z } from "zod";
+const inputSchema = z.record(z.string(), uploadFileSchema);
+const outputSchema = uploadFileSchema;
+export function createZipNode(id, { zipName, includeMetadata }) {
+    return Effect.gen(function* () {
+        const uploadServer = yield* UploadServer;
+        const zipPlugin = yield* ZipPlugin;
+        return yield* createFlowNode({
+            id,
+            name: "Zip Files",
+            description: "Combines multiple files into a zip archive",
+            type: NodeType.process,
+            inputSchema,
+            outputSchema,
+            multiInput: true,
+            run: ({ data: inputs, storageId, clientId }) => {
+                return Effect.gen(function* () {
+                    if (!inputs || Object.keys(inputs).length === 0) {
+                        return yield* Effect.fail(UploadistaError.fromCode("VALIDATION_ERROR", {
+                            body: "No inputs provided to zip node",
+                        }));
+                    }
+                    const zipInputs = yield* Effect.forEach(Object.values(inputs), (input) => Effect.gen(function* () {
+                        const data = yield* uploadServer.read(input.id, clientId);
+                        return {
+                            id: input.id,
+                            data,
+                            metadata: input.metadata,
+                        };
+                    }), { concurrency: "unbounded" });
+                    const zipBytes = yield* zipPlugin.zip(zipInputs, { zipName, includeMetadata });
+                    // Create a stream from the zip bytes
+                    const stream = new ReadableStream({
+                        start(controller) {
+                            controller.enqueue(zipBytes);
+                            controller.close();
+                        },
+                    });
+                    // Upload the zip file
+                    const result = yield* uploadServer.upload({
+                        storageId,
+                        size: zipBytes.byteLength,
+                        type: "application/zip",
+                        fileName: zipName,
+                        lastModified: 0,
+                        metadata: JSON.stringify({
+                            mimeType: "application/zip",
+                            type: "application/zip",
+                            originalName: zipName,
+                            fileName: zipName,
+                            extension: "zip",
+                        }),
+                    }, clientId, stream);
+                    return completeNodeExecution(result);
+                });
+            },
+        });
+    });
+}

package/dist/types/conditional-node.d.ts

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export declare const conditionalParamsSchema: z.ZodObject<{
+    field: z.ZodEnum<{
+        mimeType: "mimeType";
+        size: "size";
+        width: "width";
+        height: "height";
+        extension: "extension";
+    }>;
+    operator: z.ZodEnum<{
+        equals: "equals";
+        notEquals: "notEquals";
+        greaterThan: "greaterThan";
+        lessThan: "lessThan";
+        contains: "contains";
+        startsWith: "startsWith";
+    }>;
+    value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strip>;
+export type ConditionalParams = z.infer<typeof conditionalParamsSchema>;
+//# sourceMappingURL=conditional-node.d.ts.map

package/dist/types/conditional-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"conditional-node.d.ts","sourceRoot":"","sources":["../../src/types/conditional-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;iBAWlC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/dist/types/conditional-node.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+export const conditionalParamsSchema = z.object({
+    field: z.enum(["mimeType", "size", "width", "height", "extension"]),
+    operator: z.enum([
+        "equals",
+        "notEquals",
+        "greaterThan",
+        "lessThan",
+        "contains",
+        "startsWith",
+    ]),
+    value: z.union([z.string(), z.number()]),
+});

package/dist/types/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./conditional-node";
+export * from "./merge-node";
+export * from "./multiplex-node";
+export * from "./zip-node";
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/types/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}

package/dist/types/index.js

@@ -0,0 +1,4 @@
+export * from "./conditional-node";
+export * from "./merge-node";
+export * from "./multiplex-node";
+export * from "./zip-node";

package/dist/types/merge-node.d.ts

@@ -0,0 +1,11 @@
+import { z } from "zod";
+export declare const mergeParamsSchema: z.ZodObject<{
+    strategy: z.ZodDefault<z.ZodEnum<{
+        concat: "concat";
+        batch: "batch";
+    }>>;
+    separator: z.ZodOptional<z.ZodDefault<z.ZodString>>;
+    inputCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type MergeParams = z.infer<typeof mergeParamsSchema>;
+//# sourceMappingURL=merge-node.d.ts.map

package/dist/types/merge-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-node.d.ts","sourceRoot":"","sources":["../../src/types/merge-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;;iBAI5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/dist/types/merge-node.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const mergeParamsSchema = z.object({
+    strategy: z.enum(["concat", "batch"]).default("batch"),
+    separator: z.string().default("\n").optional(),
+    inputCount: z.number().min(2).max(10).default(2),
+});

package/dist/types/multiplex-node.d.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+export declare const multiplexParamsSchema: z.ZodObject<{
+    outputCount: z.ZodNumber;
+    strategy: z.ZodDefault<z.ZodEnum<{
+        copy: "copy";
+        split: "split";
+    }>>;
+}, z.core.$strip>;
+export type MultiplexParams = z.infer<typeof multiplexParamsSchema>;
+//# sourceMappingURL=multiplex-node.d.ts.map

package/dist/types/multiplex-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiplex-node.d.ts","sourceRoot":"","sources":["../../src/types/multiplex-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,qBAAqB;;;;;;iBAGhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC"}

package/dist/types/multiplex-node.js

@@ -0,0 +1,5 @@
+import { z } from "zod";
+export const multiplexParamsSchema = z.object({
+    outputCount: z.number().min(1).max(10),
+    strategy: z.enum(["copy", "split"]).default("copy"),
+});

package/dist/types/zip-node.d.ts

@@ -0,0 +1,8 @@
+import { z } from "zod";
+export declare const zipParamsSchema: z.ZodObject<{
+    zipName: z.ZodDefault<z.ZodString>;
+    includeMetadata: z.ZodDefault<z.ZodBoolean>;
+    inputCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+export type ZipParams = z.infer<typeof zipParamsSchema>;
+//# sourceMappingURL=zip-node.d.ts.map

package/dist/types/zip-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-node.d.ts","sourceRoot":"","sources":["../../src/types/zip-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;;iBAI1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC"}

package/dist/types/zip-node.js

@@ -0,0 +1,6 @@
+import { z } from "zod";
+export const zipParamsSchema = z.object({
+    zipName: z.string().default("archive.zip"),
+    includeMetadata: z.boolean().default(false),
+    inputCount: z.number().min(2).max(10).default(2),
+});

package/dist/zip-node.d.ts

@@ -0,0 +1,9 @@
+import { type FlowFile, type FlowFileBatch } from "@uploadista/flow-core";
+import { z } from "zod";
+export declare const zipParamsSchema: z.ZodObject<{
+    zipName: z.ZodDefault<z.ZodString>;
+    includeMetadata: z.ZodDefault<z.ZodBoolean>;
+}, z.core.$strip>;
+export type ZipParams = z.infer<typeof zipParamsSchema>;
+export declare function createZipNode(id: string, { zipName, includeMetadata }: ZipParams): import("@uploadista/flow-core").FlowNode<Record<string, FlowFile | FlowFileBatch>, FlowFile>;
+//# sourceMappingURL=zip-node.d.ts.map

package/dist/zip-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-node.d.ts","sourceRoot":"","sources":["../src/zip-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,aAAa,EAKnB,MAAM,uBAAuB,CAAC;AAE/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,eAAe;;;iBAG1B,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,eAAe,CAAC,CAAC;AASxD,wBAAgB,aAAa,CAC3B,EAAE,EAAE,MAAM,EACV,EAAE,OAAO,EAAE,eAAe,EAAE,EAAE,SAAS,gGAmExC"}

package/dist/zip-node.js

@@ -0,0 +1,65 @@
+import { createFlowNode, flowFileBatchSchema, flowFileSchema, isFlowFile, NodeType, } from "@uploadista/flow-core";
+import JSZip from "jszip";
+import { z } from "zod";
+export const zipParamsSchema = z.object({
+    zipName: z.string().default("archive.zip"),
+    includeMetadata: z.boolean().default(false),
+});
+// Define schemas for input and output
+const inputSchema = z.record(z.string(), z.union([flowFileSchema, flowFileBatchSchema]));
+export function createZipNode(id, { zipName, includeMetadata }) {
+    return createFlowNode({
+        id,
+        name: "Zip Files",
+        description: "Combines multiple files into a zip archive",
+        type: NodeType.process,
+        inputSchema,
+        outputSchema: flowFileSchema,
+        multiInput: true,
+        run: async ({ data: inputs }) => {
+            if (!inputs) {
+                throw new Error("No inputs provided to zip node");
+            }
+            const zip = new JSZip();
+            // Process all input files
+            for (const [sourceId, input] of Object.entries(inputs)) {
+                if (isFlowFile(input)) {
+                    // Handle single FlowFile
+                    const fileName = input.metadata.originalName || `${sourceId}_${input.path}`;
+                    zip.file(fileName, input.inputBytes);
+                    if (includeMetadata) {
+                        zip.file(`${fileName}.meta.json`, JSON.stringify(input.metadata, null, 2));
+                    }
+                }
+                else {
+                    // Handle FlowFileBatch
+                    for (const file of input.files) {
+                        const fileName = file.metadata.originalName || `${sourceId}_${file.path}`;
+                        zip.file(fileName, file.inputBytes);
+                        if (includeMetadata) {
+                            zip.file(`${fileName}.meta.json`, JSON.stringify(file.metadata, null, 2));
+                        }
+                    }
+                }
+            }
+            // Generate the zip file
+            const zipBuffer = await zip.generateAsync({
+                type: "nodebuffer",
+                compression: "DEFLATE",
+                compressionOptions: {
+                    level: 6, // Good balance between speed and compression
+                },
+            });
+            return {
+                path: zipName,
+                inputBytes: new Uint8Array(zipBuffer.buffer, zipBuffer.byteOffset, zipBuffer.byteLength),
+                metadata: {
+                    mimeType: "application/zip",
+                    size: zipBuffer.length,
+                    originalName: zipName,
+                    extension: "zip",
+                },
+            };
+        },
+    });
+}

package/package.json

@@ -0,0 +1,35 @@
+{
+  "name": "@uploadista/flow-utility-nodes",
+  "type": "module",
+  "version": "0.0.3",
+  "description": "Utility nodes for Uploadista Flow",
+  "license": "MIT",
+  "author": "Uploadista",
+  "exports": {
+    "./nodes": {
+      "types": "./dist/nodes/index.d.ts",
+      "import": "./dist/nodes/index.js",
+      "default": "./dist/nodes/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "import": "./dist/types/index.js",
+      "default": "./dist/types/index.js"
+    }
+  },
+  "dependencies": {
+    "effect": "3.18.4",
+    "zod": "4.1.12",
+    "@uploadista/core": "0.0.3"
+  },
+  "devDependencies": {
+    "@types/node": "24.8.1",
+    "@uploadista/typescript-config": "0.0.3"
+  },
+  "scripts": {
+    "build": "tsc -b",
+    "format": "biome format --write ./src",
+    "lint": "biome lint --write ./src",
+    "check": "biome check --write ./src"
+  }
+}

package/src/nodes/conditional-node.ts

@@ -0,0 +1,28 @@
+import {
+  completeNodeExecution,
+  createFlowNode,
+  NodeType,
+} from "@uploadista/core/flow";
+import { type UploadFile, uploadFileSchema } from "@uploadista/core/types";
+import { Effect } from "effect";
+import type { ConditionalParams } from "@/types/conditional-node";
+
+export function createConditionalNode(
+  id: string,
+  { field, operator, value }: ConditionalParams,
+) {
+  return createFlowNode<UploadFile, UploadFile>({
+    id,
+    name: "Conditional Router",
+    description: `Routes flow based on ${field} ${operator} ${value}`,
+    type: NodeType.conditional,
+    inputSchema: uploadFileSchema,
+    outputSchema: uploadFileSchema,
+    condition: { field, operator, value },
+    run: ({ data }) => {
+      // The actual routing logic is handled by the flow engine
+      // This node just passes through the data
+      return Effect.succeed(completeNodeExecution(data));
+    },
+  });
+}

package/src/nodes/index.ts

@@ -0,0 +1,4 @@
+export * from "./conditional-node";
+export * from "./merge-node";
+export * from "./multiplex-node";
+export * from "./zip-node";

package/src/nodes/merge-node.ts

@@ -0,0 +1,111 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import {
+  completeNodeExecution,
+  createFlowNode,
+  NodeType,
+} from "@uploadista/core/flow";
+import { type UploadFile, uploadFileSchema } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import { z } from "zod";
+import type { MergeParams } from "@/types/merge-node";
+
+const inputSchema = z.record(z.string(), uploadFileSchema);
+const outputSchema = uploadFileSchema;
+
+export function createMergeNode(
+  id: string,
+  { strategy, separator: _separator }: MergeParams,
+) {
+  return Effect.gen(function* () {
+    const uploadServer = yield* UploadServer;
+
+    return yield* createFlowNode<Record<string, UploadFile>, UploadFile>({
+      id,
+      name: "Merge Files",
+      description: `Merges multiple files using ${strategy} strategy`,
+      type: NodeType.merge,
+      inputSchema,
+      outputSchema,
+      multiInput: true,
+      run: ({ data: inputs, storageId, clientId }) => {
+        return Effect.gen(function* () {
+          if (!inputs || Object.keys(inputs).length === 0) {
+            return yield* Effect.fail(
+              UploadistaError.fromCode("VALIDATION_ERROR", {
+                body: "No inputs provided to merge node",
+              }),
+            );
+          }
+
+          const inputFiles = Object.values(inputs);
+
+          if (inputFiles.length === 0) {
+            return yield* Effect.fail(
+              UploadistaError.fromCode("VALIDATION_ERROR", {
+                body: "No files to merge",
+              }),
+            );
+          }
+
+          switch (strategy) {
+            case "concat": {
+              // Read bytes from all input files
+              const inputBytesArray: Uint8Array[] = [];
+              let totalSize = 0;
+
+              for (const file of inputFiles) {
+                const bytes = yield* uploadServer.read(file.id, clientId);
+                inputBytesArray.push(bytes);
+                totalSize += bytes.byteLength;
+              }
+
+              // Concatenate all files into one
+              const mergedBytes = new Uint8Array(totalSize);
+              let offset = 0;
+              for (const bytes of inputBytesArray) {
+                mergedBytes.set(bytes, offset);
+                offset += bytes.byteLength;
+              }
+
+              // Create a stream from the merged bytes
+              const stream = new ReadableStream({
+                start(controller) {
+                  controller.enqueue(mergedBytes);
+                  controller.close();
+                },
+              });
+
+              // Upload the merged file
+              const result = yield* uploadServer.upload(
+                {
+                  storageId,
+                  size: mergedBytes.byteLength,
+                  type: "application/octet-stream",
+                  fileName: `merged_${inputFiles.length}_files.bin`,
+                  lastModified: 0,
+                  metadata: JSON.stringify({
+                    mimeType: "application/octet-stream",
+                    originalName: `merged_${inputFiles.length}_files`,
+                    extension: "bin",
+                  }),
+                },
+                clientId,
+                stream,
+              );
+
+              return completeNodeExecution(result);
+            }
+            default: {
+              return yield* Effect.fail(
+                UploadistaError.fromCode("VALIDATION_ERROR", {
+                  body: `Unknown merge strategy: ${strategy}`,
+                }),
+              );
+            }
+          }
+        });
+      },
+    });
+  });
+}