@uploadista/flow-utility-nodes 0.0.3

package/src/nodes/multiplex-node.ts

@@ -0,0 +1,87 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import {
+  completeNodeExecution,
+  createFlowNode,
+  NodeType,
+  resolveUploadMetadata,
+} from "@uploadista/core/flow";
+import { type UploadFile, uploadFileSchema } from "@uploadista/core/types";
+import { UploadServer } from "@uploadista/core/upload";
+import { Effect } from "effect";
+import type { MultiplexParams } from "@/types/multiplex-node";
+
+export function createMultiplexNode(
+  id: string,
+  { outputCount: _outputCount, strategy }: MultiplexParams,
+) {
+  return Effect.gen(function* () {
+    const uploadServer = yield* UploadServer;
+
+    return yield* createFlowNode<UploadFile, UploadFile>({
+      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/src/nodes/zip-node.ts

@@ -0,0 +1,92 @@
+import { UploadistaError } from "@uploadista/core/errors";
+import {
+  completeNodeExecution,
+  createFlowNode,
+  NodeType,
+  ZipPlugin,
+} 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 { ZipParams } from "@/types/zip-node";
+
+const inputSchema = z.record(z.string(), uploadFileSchema);
+const outputSchema = uploadFileSchema;
+
+export function createZipNode(
+  id: string,
+  { zipName, includeMetadata }: ZipParams,
+) {
+  return Effect.gen(function* () {
+    const uploadServer = yield* UploadServer;
+    const zipPlugin = yield* ZipPlugin;
+    return yield* createFlowNode<Record<string, UploadFile>, UploadFile>({
+      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/src/types/conditional-node.ts

@@ -0,0 +1,16 @@
+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()]),
+});
+
+export type ConditionalParams = z.infer<typeof conditionalParamsSchema>;

package/src/types/index.ts

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

package/src/types/merge-node.ts

@@ -0,0 +1,9 @@
+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),
+});
+
+export type MergeParams = z.infer<typeof mergeParamsSchema>;

package/src/types/multiplex-node.ts

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

package/src/types/zip-node.ts

@@ -0,0 +1,9 @@
+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),
+});
+
+export type ZipParams = z.infer<typeof zipParamsSchema>;

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "extends": "@uploadista/typescript-config/server.json",
+  "compilerOptions": {
+    "baseUrl": "./",
+    "paths": {
+      "@/*": ["./src/*"]
+    },
+    "outDir": "./dist",
+    "rootDir": "./src",
+    "lib": ["ESNext", "DOM", "DOM.Iterable"],
+    "types": []
+  },
+  "include": ["src"]
+}

package/tsconfig.tsbuildinfo

@@ -0,0 +1 @@
+{"root":["./src/nodes/conditional-node.ts","./src/nodes/index.ts","./src/nodes/merge-node.ts","./src/nodes/multiplex-node.ts","./src/nodes/zip-node.ts","./src/types/conditional-node.ts","./src/types/index.ts","./src/types/merge-node.ts","./src/types/multiplex-node.ts","./src/types/zip-node.ts"],"version":"5.9.3"}