@uploadista/flow-utility-nodes 0.0.3 → 0.0.4

package/.turbo/turbo-build.log

@@ -1,5 +1,32 @@
 
 
-> @uploadista/flow-utility-nodes@0.0.2 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/flow/utility/nodes
-> tsc -b
+> @uploadista/flow-utility-nodes@0.0.3 build /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/flow/utility/nodes
+> tsdown
 
+ℹ tsdown v0.15.9 powered by rolldown v1.0.0-beta.44
+ℹ Using tsdown config: /Users/denislaboureyras/Documents/uploadista/dev/uploadista-workspace/uploadista-sdk/packages/flow/utility/nodes/tsdown.config.ts
+ℹ entry: src/nodes/index.ts, src/types/index.ts
+ℹ tsconfig: tsconfig.json
+ℹ Build start
+ℹ Cleaning 19 files
+ℹ [CJS] dist/nodes/index.cjs     4.34 kB │ gzip: 1.39 kB
+ℹ [CJS] dist/types/index.cjs     0.84 kB │ gzip: 0.42 kB
+ℹ [CJS] dist/chunk-DjWAcSYV.cjs  0.55 kB │ gzip: 0.34 kB
+ℹ [CJS] 3 files, total: 5.74 kB
+ℹ [ESM] dist/nodes/index.js               3.77 kB │ gzip: 1.35 kB
+ℹ [ESM] dist/types/index.js               0.78 kB │ gzip: 0.41 kB
+ℹ [ESM] dist/nodes/index.js.map          14.16 kB │ gzip: 3.23 kB
+ℹ [ESM] dist/types/index.js.map           2.26 kB │ gzip: 0.79 kB
+ℹ [ESM] dist/zip-node-BzneQXn3.d.ts.map   0.65 kB │ gzip: 0.32 kB
+ℹ [ESM] dist/nodes/index.d.ts.map         0.57 kB │ gzip: 0.26 kB
+ℹ [ESM] dist/nodes/index.d.ts             1.74 kB │ gzip: 0.52 kB
+ℹ [ESM] dist/types/index.d.ts             0.38 kB │ gzip: 0.18 kB
+ℹ [ESM] dist/zip-node-BzneQXn3.d.ts       1.79 kB │ gzip: 0.60 kB
+ℹ [ESM] 9 files, total: 26.10 kB
+ℹ [CJS] dist/zip-node-BbFUu_Oc.d.cts.map  0.65 kB │ gzip: 0.33 kB
+ℹ [CJS] dist/nodes/index.d.cts.map        0.57 kB │ gzip: 0.26 kB
+ℹ [CJS] dist/nodes/index.d.cts            1.75 kB │ gzip: 0.52 kB
+ℹ [CJS] dist/types/index.d.cts            0.38 kB │ gzip: 0.18 kB
+ℹ [CJS] dist/zip-node-BbFUu_Oc.d.cts      1.79 kB │ gzip: 0.61 kB
+ℹ [CJS] 5 files, total: 5.13 kB
+✔ Build complete in 11681ms

package/dist/chunk-DjWAcSYV.cjs

@@ -0,0 +1 @@
+var e=Object.create,t=Object.defineProperty,n=Object.getOwnPropertyDescriptor,r=Object.getOwnPropertyNames,i=Object.getPrototypeOf,a=Object.prototype.hasOwnProperty,o=(e,i,o,s)=>{if(i&&typeof i==`object`||typeof i==`function`)for(var c=r(i),l=0,u=c.length,d;l<u;l++)d=c[l],!a.call(e,d)&&d!==o&&t(e,d,{get:(e=>i[e]).bind(null,d),enumerable:!(s=n(i,d))||s.enumerable});return e},s=(n,r,a)=>(a=n==null?{}:e(i(n)),o(r||!n||!n.__esModule?t(a,`default`,{value:n,enumerable:!0}):a,n));Object.defineProperty(exports,`t`,{enumerable:!0,get:function(){return s}});

package/dist/nodes/index.cjs

@@ -0,0 +1 @@
+const e=require(`../chunk-DjWAcSYV.cjs`);let t=require(`@uploadista/core/flow`);t=e.t(t);let n=require(`@uploadista/core/types`);n=e.t(n);let r=require(`effect`);r=e.t(r);let i=require(`@uploadista/core/errors`);i=e.t(i);let a=require(`@uploadista/core/upload`);a=e.t(a);let o=require(`zod`);o=e.t(o);function s(e,{field:i,operator:a,value:o}){return(0,t.createFlowNode)({id:e,name:`Conditional Router`,description:`Routes flow based on ${i} ${a} ${o}`,type:t.NodeType.conditional,inputSchema:n.uploadFileSchema,outputSchema:n.uploadFileSchema,condition:{field:i,operator:a,value:o},run:({data:e})=>r.Effect.succeed((0,t.completeNodeExecution)(e))})}const c=o.z.record(o.z.string(),n.uploadFileSchema),l=n.uploadFileSchema;function u(e,{strategy:n,separator:o}){return r.Effect.gen(function*(){let o=yield*a.UploadServer;return yield*(0,t.createFlowNode)({id:e,name:`Merge Files`,description:`Merges multiple files using ${n} strategy`,type:t.NodeType.merge,inputSchema:c,outputSchema:l,multiInput:!0,run:({data:e,storageId:a,clientId:s})=>r.Effect.gen(function*(){if(!e||Object.keys(e).length===0)return yield*r.Effect.fail(i.UploadistaError.fromCode(`VALIDATION_ERROR`,{body:`No inputs provided to merge node`}));let c=Object.values(e);if(c.length===0)return yield*r.Effect.fail(i.UploadistaError.fromCode(`VALIDATION_ERROR`,{body:`No files to merge`}));switch(n){case`concat`:{let e=[],n=0;for(let t of c){let r=yield*o.read(t.id,s);e.push(r),n+=r.byteLength}let r=new Uint8Array(n),i=0;for(let t of e)r.set(t,i),i+=t.byteLength;let l=new ReadableStream({start(e){e.enqueue(r),e.close()}});return(0,t.completeNodeExecution)(yield*o.upload({storageId:a,size:r.byteLength,type:`application/octet-stream`,fileName:`merged_${c.length}_files.bin`,lastModified:0,metadata:JSON.stringify({mimeType:`application/octet-stream`,originalName:`merged_${c.length}_files`,extension:`bin`})},s,l))}default:return yield*r.Effect.fail(i.UploadistaError.fromCode(`VALIDATION_ERROR`,{body:`Unknown merge strategy: ${n}`}))}})})})}function d(e,{outputCount:o,strategy:s}){return r.Effect.gen(function*(){let o=yield*a.UploadServer;return yield*(0,t.createFlowNode)({id:e,name:`Multiplex`,description:`Multiplexes input using ${s} strategy`,type:t.NodeType.multiplex,inputSchema:n.uploadFileSchema,outputSchema:n.uploadFileSchema,multiOutput:!0,run:({data:e,storageId:n,clientId:a})=>r.Effect.gen(function*(){let{type:c,fileName:l,metadata:u,metadataJson:d}=(0,t.resolveUploadMetadata)(e.metadata),f=u?{...e,metadata:u}:e;if(s===`copy`){let e=yield*o.read(f.id,a),r=new ReadableStream({start(t){t.enqueue(e),t.close()}}),i=yield*o.upload({storageId:n,size:e.byteLength,type:c,fileName:l,lastModified:0,metadata:d},a,r),s=(0,t.resolveUploadMetadata)(i.metadata);return(0,t.completeNodeExecution)(s.metadata?{...i,metadata:s.metadata}:i)}else if(s===`split`)return yield*r.Effect.fail(i.UploadistaError.fromCode(`VALIDATION_ERROR`,{body:`Split strategy is not supported with UploadFile pattern`}));return yield*r.Effect.fail(i.UploadistaError.fromCode(`VALIDATION_ERROR`,{body:`Unknown multiplex strategy: ${s}`}))})})})}const f=o.z.record(o.z.string(),n.uploadFileSchema),p=n.uploadFileSchema;function m(e,{zipName:n,includeMetadata:o}){return r.Effect.gen(function*(){let s=yield*a.UploadServer,c=yield*t.ZipPlugin;return yield*(0,t.createFlowNode)({id:e,name:`Zip Files`,description:`Combines multiple files into a zip archive`,type:t.NodeType.process,inputSchema:f,outputSchema:p,multiInput:!0,run:({data:e,storageId:a,clientId:l})=>r.Effect.gen(function*(){if(!e||Object.keys(e).length===0)return yield*r.Effect.fail(i.UploadistaError.fromCode(`VALIDATION_ERROR`,{body:`No inputs provided to zip node`}));let u=yield*r.Effect.forEach(Object.values(e),e=>r.Effect.gen(function*(){let t=yield*s.read(e.id,l);return{id:e.id,data:t,metadata:e.metadata}}),{concurrency:`unbounded`}),d=yield*c.zip(u,{zipName:n,includeMetadata:o}),f=new ReadableStream({start(e){e.enqueue(d),e.close()}});return(0,t.completeNodeExecution)(yield*s.upload({storageId:a,size:d.byteLength,type:`application/zip`,fileName:n,lastModified:0,metadata:JSON.stringify({mimeType:`application/zip`,type:`application/zip`,originalName:n,fileName:n,extension:`zip`})},l,f))})})})}exports.createConditionalNode=s,exports.createMergeNode=u,exports.createMultiplexNode=d,exports.createZipNode=m;

package/dist/nodes/index.d.cts

@@ -0,0 +1,36 @@
+import { a as MergeParams, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-BbFUu_Oc.cjs";
+import * as _uploadista_core_errors0 from "@uploadista/core/errors";
+import { UploadistaError } from "@uploadista/core/errors";
+import * as _uploadista_core_flow0 from "@uploadista/core/flow";
+import { ZipPlugin } from "@uploadista/core/flow";
+import { UploadFile } from "@uploadista/core/types";
+import { Effect } from "effect";
+import { UploadServer } from "@uploadista/core/upload";
+
+//#region src/nodes/conditional-node.d.ts
+declare function createConditionalNode(id: string, {
+  field,
+  operator,
+  value
+}: ConditionalParams): Effect.Effect<_uploadista_core_flow0.FlowNode<UploadFile, UploadFile, _uploadista_core_errors0.UploadistaError>, never, never>;
+//#endregion
+//#region src/nodes/merge-node.d.ts
+declare function createMergeNode(id: string, {
+  strategy,
+  separator: _separator
+}: MergeParams): Effect.Effect<_uploadista_core_flow0.FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer>;
+//#endregion
+//#region src/nodes/multiplex-node.d.ts
+declare function createMultiplexNode(id: string, {
+  outputCount: _outputCount,
+  strategy
+}: MultiplexParams): Effect.Effect<_uploadista_core_flow0.FlowNode<UploadFile, UploadFile, UploadistaError>, never, UploadServer>;
+//#endregion
+//#region src/nodes/zip-node.d.ts
+declare function createZipNode(id: string, {
+  zipName,
+  includeMetadata
+}: ZipParams): Effect.Effect<_uploadista_core_flow0.FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer | ZipPlugin>;
+//#endregion
+export { createConditionalNode, createMergeNode, createMultiplexNode, createZipNode };
+//# sourceMappingURL=index.d.cts.map

package/dist/nodes/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../../src/nodes/conditional-node.ts","../../src/nodes/merge-node.ts","../../src/nodes/multiplex-node.ts","../../src/nodes/zip-node.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;iBASgB,qBAAA;;;;GAEc,oBAAiB,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,YAAA,YAAA,wBAAA,CAAA,eAAA;;;iBCI/B,eAAA;;aAES;GAAc,cAAW,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,eAAA,aAAA,YAAA,yBAAA;;;iBCLlC,mBAAA;eAEC;;GAA0B,kBAAe,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,YAAA,YAAA,yBAAA;;;iBCE1C,aAAA;;;GAEgB,YAAS,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,eAAA,aAAA,YAAA,yBAAA,eAAA"}

package/dist/nodes/index.d.ts

@@ -1,5 +1,36 @@
-export * from "./conditional-node";
-export * from "./merge-node";
-export * from "./multiplex-node";
-export * from "./zip-node";
+import { a as MergeParams, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-BzneQXn3.js";
+import * as _uploadista_core_flow0 from "@uploadista/core/flow";
+import { ZipPlugin } from "@uploadista/core/flow";
+import { UploadFile } from "@uploadista/core/types";
+import { Effect } from "effect";
+import * as _uploadista_core_errors0 from "@uploadista/core/errors";
+import { UploadistaError } from "@uploadista/core/errors";
+import { UploadServer } from "@uploadista/core/upload";
+
+//#region src/nodes/conditional-node.d.ts
+declare function createConditionalNode(id: string, {
+  field,
+  operator,
+  value
+}: ConditionalParams): Effect.Effect<_uploadista_core_flow0.FlowNode<UploadFile, UploadFile, _uploadista_core_errors0.UploadistaError>, never, never>;
+//#endregion
+//#region src/nodes/merge-node.d.ts
+declare function createMergeNode(id: string, {
+  strategy,
+  separator: _separator
+}: MergeParams): Effect.Effect<_uploadista_core_flow0.FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer>;
+//#endregion
+//#region src/nodes/multiplex-node.d.ts
+declare function createMultiplexNode(id: string, {
+  outputCount: _outputCount,
+  strategy
+}: MultiplexParams): Effect.Effect<_uploadista_core_flow0.FlowNode<UploadFile, UploadFile, UploadistaError>, never, UploadServer>;
+//#endregion
+//#region src/nodes/zip-node.d.ts
+declare function createZipNode(id: string, {
+  zipName,
+  includeMetadata
+}: ZipParams): Effect.Effect<_uploadista_core_flow0.FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer | ZipPlugin>;
+//#endregion
+export { createConditionalNode, createMergeNode, createMultiplexNode, createZipNode };
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/nodes/index.ts"],"names":[],"mappings":"AAAA,cAAc,oBAAoB,CAAC;AACnC,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/nodes/conditional-node.ts","../../src/nodes/merge-node.ts","../../src/nodes/multiplex-node.ts","../../src/nodes/zip-node.ts"],"sourcesContent":[],"mappings":";;;;;;;;;;iBASgB,qBAAA;;;;GAEc,oBAAiB,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,YAAA,YAAA,wBAAA,CAAA,eAAA;;;iBCI/B,eAAA;;aAES;GAAc,cAAW,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,eAAA,aAAA,YAAA,yBAAA;;;iBCLlC,mBAAA;eAEC;;GAA0B,kBAAe,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,YAAA,YAAA,yBAAA;;;iBCE1C,aAAA;;;GAEgB,YAAS,MAAA,CAAA,OAAA,sBAAA,CAAA,SAAA,eAAA,aAAA,YAAA,yBAAA,eAAA"}

package/dist/nodes/index.js

@@ -1,4 +1,2 @@
-export * from "./conditional-node";
-export * from "./merge-node";
-export * from "./multiplex-node";
-export * from "./zip-node";
+import{NodeType as e,ZipPlugin as t,completeNodeExecution as n,createFlowNode as r,resolveUploadMetadata as i}from"@uploadista/core/flow";import{uploadFileSchema as a}from"@uploadista/core/types";import{Effect as o}from"effect";import{UploadistaError as s}from"@uploadista/core/errors";import{UploadServer as c}from"@uploadista/core/upload";import{z as l}from"zod";function u(t,{field:i,operator:s,value:c}){return r({id:t,name:`Conditional Router`,description:`Routes flow based on ${i} ${s} ${c}`,type:e.conditional,inputSchema:a,outputSchema:a,condition:{field:i,operator:s,value:c},run:({data:e})=>o.succeed(n(e))})}const d=l.record(l.string(),a),f=a;function p(t,{strategy:i,separator:a}){return o.gen(function*(){let a=yield*c;return yield*r({id:t,name:`Merge Files`,description:`Merges multiple files using ${i} strategy`,type:e.merge,inputSchema:d,outputSchema:f,multiInput:!0,run:({data:e,storageId:t,clientId:r})=>o.gen(function*(){if(!e||Object.keys(e).length===0)return yield*o.fail(s.fromCode(`VALIDATION_ERROR`,{body:`No inputs provided to merge node`}));let c=Object.values(e);if(c.length===0)return yield*o.fail(s.fromCode(`VALIDATION_ERROR`,{body:`No files to merge`}));switch(i){case`concat`:{let e=[],i=0;for(let t of c){let n=yield*a.read(t.id,r);e.push(n),i+=n.byteLength}let o=new Uint8Array(i),s=0;for(let t of e)o.set(t,s),s+=t.byteLength;let l=new ReadableStream({start(e){e.enqueue(o),e.close()}});return n(yield*a.upload({storageId:t,size:o.byteLength,type:`application/octet-stream`,fileName:`merged_${c.length}_files.bin`,lastModified:0,metadata:JSON.stringify({mimeType:`application/octet-stream`,originalName:`merged_${c.length}_files`,extension:`bin`})},r,l))}default:return yield*o.fail(s.fromCode(`VALIDATION_ERROR`,{body:`Unknown merge strategy: ${i}`}))}})})})}function m(t,{outputCount:l,strategy:u}){return o.gen(function*(){let l=yield*c;return yield*r({id:t,name:`Multiplex`,description:`Multiplexes input using ${u} strategy`,type:e.multiplex,inputSchema:a,outputSchema:a,multiOutput:!0,run:({data:e,storageId:t,clientId:r})=>o.gen(function*(){let{type:a,fileName:c,metadata:d,metadataJson:f}=i(e.metadata),p=d?{...e,metadata:d}:e;if(u===`copy`){let e=yield*l.read(p.id,r),o=new ReadableStream({start(t){t.enqueue(e),t.close()}}),s=yield*l.upload({storageId:t,size:e.byteLength,type:a,fileName:c,lastModified:0,metadata:f},r,o),u=i(s.metadata);return n(u.metadata?{...s,metadata:u.metadata}:s)}else if(u===`split`)return yield*o.fail(s.fromCode(`VALIDATION_ERROR`,{body:`Split strategy is not supported with UploadFile pattern`}));return yield*o.fail(s.fromCode(`VALIDATION_ERROR`,{body:`Unknown multiplex strategy: ${u}`}))})})})}const h=l.record(l.string(),a),g=a;function _(i,{zipName:a,includeMetadata:l}){return o.gen(function*(){let u=yield*c,d=yield*t;return yield*r({id:i,name:`Zip Files`,description:`Combines multiple files into a zip archive`,type:e.process,inputSchema:h,outputSchema:g,multiInput:!0,run:({data:e,storageId:t,clientId:r})=>o.gen(function*(){if(!e||Object.keys(e).length===0)return yield*o.fail(s.fromCode(`VALIDATION_ERROR`,{body:`No inputs provided to zip node`}));let i=yield*o.forEach(Object.values(e),e=>o.gen(function*(){let t=yield*u.read(e.id,r);return{id:e.id,data:t,metadata:e.metadata}}),{concurrency:`unbounded`}),c=yield*d.zip(i,{zipName:a,includeMetadata:l}),f=new ReadableStream({start(e){e.enqueue(c),e.close()}});return n(yield*u.upload({storageId:t,size:c.byteLength,type:`application/zip`,fileName:a,lastModified:0,metadata:JSON.stringify({mimeType:`application/zip`,type:`application/zip`,originalName:a,fileName:a,extension:`zip`})},r,f))})})})}export{u as createConditionalNode,p as createMergeNode,m as createMultiplexNode,_ as createZipNode};
+//# sourceMappingURL=index.js.map

package/dist/nodes/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["inputSchema","outputSchema","inputBytesArray: Uint8Array[]"],"sources":["../../src/nodes/conditional-node.ts","../../src/nodes/merge-node.ts","../../src/nodes/multiplex-node.ts","../../src/nodes/zip-node.ts"],"sourcesContent":["import {\n  completeNodeExecution,\n  createFlowNode,\n  NodeType,\n} from \"@uploadista/core/flow\";\nimport { type UploadFile, uploadFileSchema } from \"@uploadista/core/types\";\nimport { Effect } from \"effect\";\nimport type { ConditionalParams } from \"@/types/conditional-node\";\n\nexport function createConditionalNode(\n  id: string,\n  { field, operator, value }: ConditionalParams,\n) {\n  return createFlowNode<UploadFile, UploadFile>({\n    id,\n    name: \"Conditional Router\",\n    description: `Routes flow based on ${field} ${operator} ${value}`,\n    type: NodeType.conditional,\n    inputSchema: uploadFileSchema,\n    outputSchema: uploadFileSchema,\n    condition: { field, operator, value },\n    run: ({ data }) => {\n      // The actual routing logic is handled by the flow engine\n      // This node just passes through the data\n      return Effect.succeed(completeNodeExecution(data));\n    },\n  });\n}\n","import { UploadistaError } from \"@uploadista/core/errors\";\nimport {\n  completeNodeExecution,\n  createFlowNode,\n  NodeType,\n} from \"@uploadista/core/flow\";\nimport { type UploadFile, uploadFileSchema } from \"@uploadista/core/types\";\nimport { UploadServer } from \"@uploadista/core/upload\";\nimport { Effect } from \"effect\";\nimport { z } from \"zod\";\nimport type { MergeParams } from \"@/types/merge-node\";\n\nconst inputSchema = z.record(z.string(), uploadFileSchema);\nconst outputSchema = uploadFileSchema;\n\nexport function createMergeNode(\n  id: string,\n  { strategy, separator: _separator }: MergeParams,\n) {\n  return Effect.gen(function* () {\n    const uploadServer = yield* UploadServer;\n\n    return yield* createFlowNode<Record<string, UploadFile>, UploadFile>({\n      id,\n      name: \"Merge Files\",\n      description: `Merges multiple files using ${strategy} strategy`,\n      type: NodeType.merge,\n      inputSchema,\n      outputSchema,\n      multiInput: true,\n      run: ({ data: inputs, storageId, clientId }) => {\n        return Effect.gen(function* () {\n          if (!inputs || Object.keys(inputs).length === 0) {\n            return yield* Effect.fail(\n              UploadistaError.fromCode(\"VALIDATION_ERROR\", {\n                body: \"No inputs provided to merge node\",\n              }),\n            );\n          }\n\n          const inputFiles = Object.values(inputs);\n\n          if (inputFiles.length === 0) {\n            return yield* Effect.fail(\n              UploadistaError.fromCode(\"VALIDATION_ERROR\", {\n                body: \"No files to merge\",\n              }),\n            );\n          }\n\n          switch (strategy) {\n            case \"concat\": {\n              // Read bytes from all input files\n              const inputBytesArray: Uint8Array[] = [];\n              let totalSize = 0;\n\n              for (const file of inputFiles) {\n                const bytes = yield* uploadServer.read(file.id, clientId);\n                inputBytesArray.push(bytes);\n                totalSize += bytes.byteLength;\n              }\n\n              // Concatenate all files into one\n              const mergedBytes = new Uint8Array(totalSize);\n              let offset = 0;\n              for (const bytes of inputBytesArray) {\n                mergedBytes.set(bytes, offset);\n                offset += bytes.byteLength;\n              }\n\n              // Create a stream from the merged bytes\n              const stream = new ReadableStream({\n                start(controller) {\n                  controller.enqueue(mergedBytes);\n                  controller.close();\n                },\n              });\n\n              // Upload the merged file\n              const result = yield* uploadServer.upload(\n                {\n                  storageId,\n                  size: mergedBytes.byteLength,\n                  type: \"application/octet-stream\",\n                  fileName: `merged_${inputFiles.length}_files.bin`,\n                  lastModified: 0,\n                  metadata: JSON.stringify({\n                    mimeType: \"application/octet-stream\",\n                    originalName: `merged_${inputFiles.length}_files`,\n                    extension: \"bin\",\n                  }),\n                },\n                clientId,\n                stream,\n              );\n\n              return completeNodeExecution(result);\n            }\n            default: {\n              return yield* Effect.fail(\n                UploadistaError.fromCode(\"VALIDATION_ERROR\", {\n                  body: `Unknown merge strategy: ${strategy}`,\n                }),\n              );\n            }\n          }\n        });\n      },\n    });\n  });\n}\n","import { UploadistaError } from \"@uploadista/core/errors\";\nimport {\n  completeNodeExecution,\n  createFlowNode,\n  NodeType,\n  resolveUploadMetadata,\n} from \"@uploadista/core/flow\";\nimport { type UploadFile, uploadFileSchema } from \"@uploadista/core/types\";\nimport { UploadServer } from \"@uploadista/core/upload\";\nimport { Effect } from \"effect\";\nimport type { MultiplexParams } from \"@/types/multiplex-node\";\n\nexport function createMultiplexNode(\n  id: string,\n  { outputCount: _outputCount, strategy }: MultiplexParams,\n) {\n  return Effect.gen(function* () {\n    const uploadServer = yield* UploadServer;\n\n    return yield* createFlowNode<UploadFile, UploadFile>({\n      id,\n      name: \"Multiplex\",\n      description: `Multiplexes input using ${strategy} strategy`,\n      type: NodeType.multiplex,\n      inputSchema: uploadFileSchema,\n      outputSchema: uploadFileSchema,\n      multiOutput: true,\n      run: ({ data: file, storageId, clientId }) => {\n        return Effect.gen(function* () {\n          const { type, fileName, metadata, metadataJson } =\n            resolveUploadMetadata(file.metadata);\n          const normalizedFile = metadata ? { ...file, metadata } : file;\n\n          if (strategy === \"copy\") {\n            // For copy strategy, read and re-upload the file\n            const inputBytes = yield* uploadServer.read(\n              normalizedFile.id,\n              clientId,\n            );\n\n            const stream = new ReadableStream({\n              start(controller) {\n                controller.enqueue(inputBytes);\n                controller.close();\n              },\n            });\n\n            const result = yield* uploadServer.upload(\n              {\n                storageId,\n                size: inputBytes.byteLength,\n                type,\n                fileName,\n                lastModified: 0,\n                metadata: metadataJson,\n              },\n              clientId,\n              stream,\n            );\n\n            const resolvedResult = resolveUploadMetadata(result.metadata);\n\n            return completeNodeExecution(\n              resolvedResult.metadata\n                ? { ...result, metadata: resolvedResult.metadata }\n                : result,\n            );\n          } else if (strategy === \"split\") {\n            // Split strategy is not supported in the new pattern\n            // as it would require returning multiple UploadFiles\n            return yield* Effect.fail(\n              UploadistaError.fromCode(\"VALIDATION_ERROR\", {\n                body: \"Split strategy is not supported with UploadFile pattern\",\n              }),\n            );\n          }\n\n          return yield* Effect.fail(\n            UploadistaError.fromCode(\"VALIDATION_ERROR\", {\n              body: `Unknown multiplex strategy: ${strategy}`,\n            }),\n          );\n        });\n      },\n    });\n  });\n}\n","import { UploadistaError } from \"@uploadista/core/errors\";\nimport {\n  completeNodeExecution,\n  createFlowNode,\n  NodeType,\n  ZipPlugin,\n} from \"@uploadista/core/flow\";\nimport { type UploadFile, uploadFileSchema } from \"@uploadista/core/types\";\nimport { UploadServer } from \"@uploadista/core/upload\";\nimport { Effect } from \"effect\";\nimport { z } from \"zod\";\nimport type { ZipParams } from \"@/types/zip-node\";\n\nconst inputSchema = z.record(z.string(), uploadFileSchema);\nconst outputSchema = uploadFileSchema;\n\nexport function createZipNode(\n  id: string,\n  { zipName, includeMetadata }: ZipParams,\n) {\n  return Effect.gen(function* () {\n    const uploadServer = yield* UploadServer;\n    const zipPlugin = yield* ZipPlugin;\n    return yield* createFlowNode<Record<string, UploadFile>, UploadFile>({\n      id,\n      name: \"Zip Files\",\n      description: \"Combines multiple files into a zip archive\",\n      type: NodeType.process,\n      inputSchema,\n      outputSchema,\n      multiInput: true,\n      run: ({ data: inputs, storageId, clientId }) => {\n        return Effect.gen(function* () {\n          if (!inputs || Object.keys(inputs).length === 0) {\n            return yield* Effect.fail(\n              UploadistaError.fromCode(\"VALIDATION_ERROR\", {\n                body: \"No inputs provided to zip node\",\n              }),\n            );\n          }\n\n\n          const zipInputs = yield* Effect.forEach(\n            Object.values(inputs),\n            (input) =>\n              Effect.gen(function* () {\n                const data = yield* uploadServer.read(input.id, clientId);\n                return {\n                  id: input.id,\n                  data,\n                  metadata: input.metadata,\n                };\n              }),\n            { concurrency: \"unbounded\" }\n          );\n\n          const zipBytes = yield* zipPlugin.zip(zipInputs, { zipName, includeMetadata });\n\n          // Create a stream from the zip bytes\n          const stream = new ReadableStream({\n            start(controller) {\n              controller.enqueue(zipBytes);\n              controller.close();\n            },\n          });\n\n          // Upload the zip file\n          const result = yield* uploadServer.upload(\n            {\n              storageId,\n              size: zipBytes.byteLength,\n              type: \"application/zip\",\n              fileName: zipName,\n              lastModified: 0,\n              metadata: JSON.stringify({\n                mimeType: \"application/zip\",\n                type: \"application/zip\",\n                originalName: zipName,\n                fileName: zipName,\n                extension: \"zip\",\n              }),\n            },\n            clientId,\n            stream,\n          );\n\n          return completeNodeExecution(result);\n        });\n      },\n    });\n  });\n}\n"],"mappings":"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"}

package/dist/types/index.cjs

@@ -0,0 +1,2 @@
+const e=require(`../chunk-DjWAcSYV.cjs`);let t=require(`zod`);t=e.t(t);const n=t.z.object({field:t.z.enum([`mimeType`,`size`,`width`,`height`,`extension`]),operator:t.z.enum([`equals`,`notEquals`,`greaterThan`,`lessThan`,`contains`,`startsWith`]),value:t.z.union([t.z.string(),t.z.number()])}),r=t.z.object({strategy:t.z.enum([`concat`,`batch`]).default(`batch`),separator:t.z.string().default(`
+`).optional(),inputCount:t.z.number().min(2).max(10).default(2)}),i=t.z.object({outputCount:t.z.number().min(1).max(10),strategy:t.z.enum([`copy`,`split`]).default(`copy`)}),a=t.z.object({zipName:t.z.string().default(`archive.zip`),includeMetadata:t.z.boolean().default(!1),inputCount:t.z.number().min(2).max(10).default(2)});exports.conditionalParamsSchema=n,exports.mergeParamsSchema=r,exports.multiplexParamsSchema=i,exports.zipParamsSchema=a;

package/dist/types/index.d.cts

@@ -0,0 +1,2 @@
+import { a as MergeParams, c as conditionalParamsSchema, i as multiplexParamsSchema, n as zipParamsSchema, o as mergeParamsSchema, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-BbFUu_Oc.cjs";
+export { ConditionalParams, MergeParams, MultiplexParams, ZipParams, conditionalParamsSchema, mergeParamsSchema, multiplexParamsSchema, zipParamsSchema };

package/dist/types/index.d.ts

@@ -1,5 +1,2 @@
-export * from "./conditional-node";
-export * from "./merge-node";
-export * from "./multiplex-node";
-export * from "./zip-node";
-//# sourceMappingURL=index.d.ts.map
+import { a as MergeParams, c as conditionalParamsSchema, i as multiplexParamsSchema, n as zipParamsSchema, o as mergeParamsSchema, r as MultiplexParams, s as ConditionalParams, t as ZipParams } from "../zip-node-BzneQXn3.js";
+export { ConditionalParams, MergeParams, MultiplexParams, ZipParams, conditionalParamsSchema, mergeParamsSchema, multiplexParamsSchema, zipParamsSchema };

package/dist/types/index.js

@@ -1,4 +1,3 @@
-export * from "./conditional-node";
-export * from "./merge-node";
-export * from "./multiplex-node";
-export * from "./zip-node";
+import{z as e}from"zod";const t=e.object({field:e.enum([`mimeType`,`size`,`width`,`height`,`extension`]),operator:e.enum([`equals`,`notEquals`,`greaterThan`,`lessThan`,`contains`,`startsWith`]),value:e.union([e.string(),e.number()])}),n=e.object({strategy:e.enum([`concat`,`batch`]).default(`batch`),separator:e.string().default(`
+`).optional(),inputCount:e.number().min(2).max(10).default(2)}),r=e.object({outputCount:e.number().min(1).max(10),strategy:e.enum([`copy`,`split`]).default(`copy`)}),i=e.object({zipName:e.string().default(`archive.zip`),includeMetadata:e.boolean().default(!1),inputCount:e.number().min(2).max(10).default(2)});export{t as conditionalParamsSchema,n as mergeParamsSchema,r as multiplexParamsSchema,i as zipParamsSchema};
+//# sourceMappingURL=index.js.map

package/dist/types/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../src/types/conditional-node.ts","../../src/types/merge-node.ts","../../src/types/multiplex-node.ts","../../src/types/zip-node.ts"],"sourcesContent":["import { z } from \"zod\";\n\nexport const conditionalParamsSchema = z.object({\n  field: z.enum([\"mimeType\", \"size\", \"width\", \"height\", \"extension\"]),\n  operator: z.enum([\n    \"equals\",\n    \"notEquals\",\n    \"greaterThan\",\n    \"lessThan\",\n    \"contains\",\n    \"startsWith\",\n  ]),\n  value: z.union([z.string(), z.number()]),\n});\n\nexport type ConditionalParams = z.infer<typeof conditionalParamsSchema>;\n","import { z } from \"zod\";\n\nexport const mergeParamsSchema = z.object({\n  strategy: z.enum([\"concat\", \"batch\"]).default(\"batch\"),\n  separator: z.string().default(\"\\n\").optional(),\n  inputCount: z.number().min(2).max(10).default(2),\n});\n\nexport type MergeParams = z.infer<typeof mergeParamsSchema>;\n","import { z } from \"zod\";\n\nexport const multiplexParamsSchema = z.object({\n  outputCount: z.number().min(1).max(10),\n  strategy: z.enum([\"copy\", \"split\"]).default(\"copy\"),\n});\n\nexport type MultiplexParams = z.infer<typeof multiplexParamsSchema>;\n","import { z } from \"zod\";\n\nexport const zipParamsSchema = z.object({\n  zipName: z.string().default(\"archive.zip\"),\n  includeMetadata: z.boolean().default(false),\n  inputCount: z.number().min(2).max(10).default(2),\n});\n\nexport type ZipParams = z.infer<typeof zipParamsSchema>;\n"],"mappings":"wBAEA,MAAa,EAA0B,EAAE,OAAO,CAC9C,MAAO,EAAE,KAAK,CAAC,WAAY,OAAQ,QAAS,SAAU,YAAY,CAAC,CACnE,SAAU,EAAE,KAAK,CACf,SACA,YACA,cACA,WACA,WACA,aACD,CAAC,CACF,MAAO,EAAE,MAAM,CAAC,EAAE,QAAQ,CAAE,EAAE,QAAQ,CAAC,CAAC,CACzC,CAAC,CCXW,EAAoB,EAAE,OAAO,CACxC,SAAU,EAAE,KAAK,CAAC,SAAU,QAAQ,CAAC,CAAC,QAAQ,QAAQ,CACtD,UAAW,EAAE,QAAQ,CAAC,QAAQ;EAAK,CAAC,UAAU,CAC9C,WAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,CAAC,QAAQ,EAAE,CACjD,CAAC,CCJW,EAAwB,EAAE,OAAO,CAC5C,YAAa,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,CACtC,SAAU,EAAE,KAAK,CAAC,OAAQ,QAAQ,CAAC,CAAC,QAAQ,OAAO,CACpD,CAAC,CCHW,EAAkB,EAAE,OAAO,CACtC,QAAS,EAAE,QAAQ,CAAC,QAAQ,cAAc,CAC1C,gBAAiB,EAAE,SAAS,CAAC,QAAQ,GAAM,CAC3C,WAAY,EAAE,QAAQ,CAAC,IAAI,EAAE,CAAC,IAAI,GAAG,CAAC,QAAQ,EAAE,CACjD,CAAC"}

package/dist/zip-node-BbFUu_Oc.d.cts

@@ -0,0 +1,54 @@
+import { z } from "zod";
+
+//#region src/types/conditional-node.d.ts
+declare const conditionalParamsSchema: z.ZodObject<{
+  field: z.ZodEnum<{
+    size: "size";
+    mimeType: "mimeType";
+    width: "width";
+    height: "height";
+    extension: "extension";
+  }>;
+  operator: z.ZodEnum<{
+    startsWith: "startsWith";
+    equals: "equals";
+    notEquals: "notEquals";
+    greaterThan: "greaterThan";
+    lessThan: "lessThan";
+    contains: "contains";
+  }>;
+  value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strip>;
+type ConditionalParams = z.infer<typeof conditionalParamsSchema>;
+//#endregion
+//#region src/types/merge-node.d.ts
+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>;
+type MergeParams = z.infer<typeof mergeParamsSchema>;
+//#endregion
+//#region src/types/multiplex-node.d.ts
+declare const multiplexParamsSchema: z.ZodObject<{
+  outputCount: z.ZodNumber;
+  strategy: z.ZodDefault<z.ZodEnum<{
+    split: "split";
+    copy: "copy";
+  }>>;
+}, z.core.$strip>;
+type MultiplexParams = z.infer<typeof multiplexParamsSchema>;
+//#endregion
+//#region src/types/zip-node.d.ts
+declare const zipParamsSchema: z.ZodObject<{
+  zipName: z.ZodDefault<z.ZodString>;
+  includeMetadata: z.ZodDefault<z.ZodBoolean>;
+  inputCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ZipParams = z.infer<typeof zipParamsSchema>;
+//#endregion
+export { MergeParams as a, conditionalParamsSchema as c, multiplexParamsSchema as i, zipParamsSchema as n, mergeParamsSchema as o, MultiplexParams as r, ConditionalParams as s, ZipParams as t };
+//# sourceMappingURL=zip-node-BbFUu_Oc.d.cts.map

package/dist/zip-node-BbFUu_Oc.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zip-node-BbFUu_Oc.d.cts","names":[],"sources":["../src/types/conditional-node.ts","../src/types/merge-node.ts","../src/types/multiplex-node.ts","../src/types/zip-node.ts"],"sourcesContent":[],"mappings":";;;cAEa,yBAAuB,CAAA,CAAA;;IAAvB,IAAA,EAAA,MAAA;;;;;;;IAAuB,UAAA,EAAA,YAAA;IAAA,MAAA,EAAA,QAAA;IAaxB,SAAA,EAAA,WAAiB;;;;ECbhB,CAAA,CAAA;;;KDaD,iBAAA,GAAoB,CAAA,CAAE,aAAa;;;cCblC,mBAAiB,CAAA,CAAA;;IDAjB,MAAA,EAAA,QAAA;;;;;;KCMD,WAAA,GAAc,CAAA,CAAE,aAAa;;;cCN5B,uBAAqB,CAAA,CAAA;;EFArB,QAAA,cAAA,UAWX,CAAA;;;;;KENU,eAAA,GAAkB,CAAA,CAAE,aAAa;;;cCLhC,iBAAe,CAAA,CAAA;;EHAf,eAAA,cAWX,aAAA,CAAA;;;KGLU,SAAA,GAAY,CAAA,CAAE,aAAa"}

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

@@ -0,0 +1,54 @@
+import { z } from "zod";
+
+//#region src/types/conditional-node.d.ts
+declare const conditionalParamsSchema: z.ZodObject<{
+  field: z.ZodEnum<{
+    size: "size";
+    mimeType: "mimeType";
+    width: "width";
+    height: "height";
+    extension: "extension";
+  }>;
+  operator: z.ZodEnum<{
+    startsWith: "startsWith";
+    equals: "equals";
+    notEquals: "notEquals";
+    greaterThan: "greaterThan";
+    lessThan: "lessThan";
+    contains: "contains";
+  }>;
+  value: z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>;
+}, z.core.$strip>;
+type ConditionalParams = z.infer<typeof conditionalParamsSchema>;
+//#endregion
+//#region src/types/merge-node.d.ts
+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>;
+type MergeParams = z.infer<typeof mergeParamsSchema>;
+//#endregion
+//#region src/types/multiplex-node.d.ts
+declare const multiplexParamsSchema: z.ZodObject<{
+  outputCount: z.ZodNumber;
+  strategy: z.ZodDefault<z.ZodEnum<{
+    split: "split";
+    copy: "copy";
+  }>>;
+}, z.core.$strip>;
+type MultiplexParams = z.infer<typeof multiplexParamsSchema>;
+//#endregion
+//#region src/types/zip-node.d.ts
+declare const zipParamsSchema: z.ZodObject<{
+  zipName: z.ZodDefault<z.ZodString>;
+  includeMetadata: z.ZodDefault<z.ZodBoolean>;
+  inputCount: z.ZodDefault<z.ZodNumber>;
+}, z.core.$strip>;
+type ZipParams = z.infer<typeof zipParamsSchema>;
+//#endregion
+export { MergeParams as a, conditionalParamsSchema as c, multiplexParamsSchema as i, zipParamsSchema as n, mergeParamsSchema as o, MultiplexParams as r, ConditionalParams as s, ZipParams as t };
+//# sourceMappingURL=zip-node-BzneQXn3.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zip-node-BzneQXn3.d.ts","names":[],"sources":["../src/types/conditional-node.ts","../src/types/merge-node.ts","../src/types/multiplex-node.ts","../src/types/zip-node.ts"],"sourcesContent":[],"mappings":";;;cAEa,yBAAuB,CAAA,CAAA;;IAAvB,IAAA,EAAA,MAAA;;;;;;;IAAuB,UAAA,EAAA,YAAA;IAAA,MAAA,EAAA,QAAA;IAaxB,SAAA,EAAA,WAAiB;;;;ECbhB,CAAA,CAAA;;;KDaD,iBAAA,GAAoB,CAAA,CAAE,aAAa;;;cCblC,mBAAiB,CAAA,CAAA;;IDAjB,MAAA,EAAA,QAAA;;;;;;KCMD,WAAA,GAAc,CAAA,CAAE,aAAa;;;cCN5B,uBAAqB,CAAA,CAAA;;EFArB,QAAA,cAAA,UAWX,CAAA;;;;;KENU,eAAA,GAAkB,CAAA,CAAE,aAAa;;;cCLhC,iBAAe,CAAA,CAAA;;EHAf,eAAA,cAWX,aAAA,CAAA;;;KGLU,SAAA,GAAY,CAAA,CAAE,aAAa"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@uploadista/flow-utility-nodes",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Utility nodes for Uploadista Flow",
   "license": "MIT",
   "author": "Uploadista",
@@ -20,14 +20,15 @@
   "dependencies": {
     "effect": "3.18.4",
     "zod": "4.1.12",
-    "@uploadista/core": "0.0.3"
+    "@uploadista/core": "0.0.4"
   },
   "devDependencies": {
     "@types/node": "24.8.1",
-    "@uploadista/typescript-config": "0.0.3"
+    "tsdown": "0.15.9",
+    "@uploadista/typescript-config": "0.0.4"
   },
   "scripts": {
-    "build": "tsc -b",
+    "build": "tsdown",
     "format": "biome format --write ./src",
     "lint": "biome lint --write ./src",
     "check": "biome check --write ./src"

package/tsdown.config.ts

@@ -0,0 +1,12 @@
+import { defineConfig } from "tsdown";
+
+export default defineConfig({
+  entry: {
+    "nodes/index": "src/nodes/index.ts",
+    "types/index": "src/types/index.ts",
+  },
+  minify: true,
+  format: ["esm", "cjs"],
+  dts: true,
+  outDir: "dist",
+});

package/dist/conditional-node.d.ts

@@ -1,25 +0,0 @@
-import { type FlowFile } from "@uploadista/flow-core";
-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]>;
-    trueBranch: z.ZodString;
-    falseBranch: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export type ConditionalParams = z.infer<typeof conditionalParamsSchema>;
-export declare function createConditionalNode(id: string, { field, operator, value, trueBranch, falseBranch }: ConditionalParams): import("@uploadista/flow-core").FlowNode<FlowFile, FlowFile>;
-//# sourceMappingURL=conditional-node.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"conditional-node.d.ts","sourceRoot":"","sources":["../src/conditional-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAGd,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;iBAalC,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC;AAIxE,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,UAAU,EAAE,WAAW,EAAE,EAAE,iBAAiB,gEAmBvE"}

package/dist/conditional-node.js

@@ -1,34 +0,0 @@
-import { createFlowNode, flowFileSchema, NodeType, } from "@uploadista/flow-core";
-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()]),
-    trueBranch: z.string(),
-    falseBranch: z.string().optional(),
-});
-// Define schemas for input and output
-export function createConditionalNode(id, { field, operator, value, trueBranch, falseBranch }) {
-    return createFlowNode({
-        id,
-        name: "Conditional Router",
-        description: `Routes flow based on ${field} ${operator} ${value}`,
-        type: NodeType.conditional,
-        inputSchema: flowFileSchema,
-        outputSchema: flowFileSchema,
-        condition: { field, operator, value },
-        branches: [trueBranch, falseBranch].filter((branch) => branch !== undefined),
-        run: async ({ data }) => {
-            // The actual routing logic is handled by the flow engine
-            // This node just passes through the data
-            return data;
-        },
-    });
-}

package/dist/index.d.ts

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

package/dist/index.d.ts.map

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

package/dist/index.js

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

package/dist/merge-node.d.ts

@@ -1,12 +0,0 @@
-import { type FlowFile, type FlowFileBatch } from "@uploadista/flow-core";
-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>>;
-}, z.core.$strip>;
-export type MergeParams = z.infer<typeof mergeParamsSchema>;
-export declare function createMergeNode(id: string, { strategy, separator: _separator }: MergeParams): import("@uploadista/flow-core").FlowNode<Record<string, FlowFile | FlowFileBatch>, FlowFile | FlowFileBatch>;
-//# sourceMappingURL=merge-node.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"merge-node.d.ts","sourceRoot":"","sources":["../src/merge-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,aAAa,EAInB,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAExB,eAAO,MAAM,iBAAiB;;;;;;iBAG5B,CAAC;AAEH,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAO5D,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,WAAW,gHAwEjD"}

package/dist/merge-node.js

@@ -1,77 +0,0 @@
-import { createFlowNode, flowDataSchema, isFlowFile, NodeType, } from "@uploadista/flow-core";
-import { z } from "zod";
-export const mergeParamsSchema = z.object({
-    strategy: z.enum(["concat", "batch"]).default("batch"),
-    separator: z.string().default("\n").optional(),
-});
-// Define schemas for input and output
-const inputSchema = z.record(z.string(), flowDataSchema);
-const outputSchema = flowDataSchema;
-export function createMergeNode(id, { strategy, separator: _separator }) {
-    return createFlowNode({
-        id,
-        name: "Merge Files",
-        description: `Merges multiple files using ${strategy} strategy`,
-        type: NodeType.merge,
-        inputSchema,
-        outputSchema,
-        multiInput: true,
-        run: async ({ data: inputs }) => {
-            if (!inputs) {
-                throw new Error("No inputs provided to merge node");
-            }
-            const inputFiles = [];
-            // Collect all input files
-            for (const [_sourceId, input] of Object.entries(inputs)) {
-                if (isFlowFile(input)) {
-                    // Handle single FlowFile
-                    inputFiles.push(input);
-                }
-                else {
-                    // Handle FlowFileBatch
-                    inputFiles.push(...input.files);
-                }
-            }
-            if (inputFiles.length === 0) {
-                throw new Error("No files to merge");
-            }
-            if (strategy === "batch") {
-                // Return as a batch
-                return {
-                    files: inputFiles,
-                    metadata: {
-                        batchId: crypto.randomUUID(),
-                        totalSize: inputFiles.reduce((sum, file) => sum + file.metadata.size, 0),
-                        fileCount: inputFiles.length,
-                    },
-                };
-            }
-            else if (strategy === "concat") {
-                // Concatenate all files into one
-                const inputBytesArray = [];
-                let totalSize = 0;
-                for (const file of inputFiles) {
-                    inputBytesArray.push(file.inputBytes);
-                    totalSize += file.inputBytes.length;
-                }
-                const mergedInputBytes = new Uint8Array(totalSize);
-                let offset = 0;
-                for (const inputBytes of inputBytesArray) {
-                    mergedInputBytes.set(inputBytes, offset);
-                    offset += inputBytes.length;
-                }
-                return {
-                    path: `merged_${crypto.randomUUID()}`,
-                    inputBytes: mergedInputBytes,
-                    metadata: {
-                        mimeType: "application/octet-stream",
-                        size: totalSize,
-                        originalName: `merged_${inputFiles.length}_files`,
-                        extension: "bin",
-                    },
-                };
-            }
-            throw new Error(`Unknown merge strategy: ${strategy}`);
-        },
-    });
-}

package/dist/multiplex-node.d.ts

@@ -1,42 +0,0 @@
-import { z } from "zod";
-export declare const multiplexParamsSchema: z.ZodObject<{
-    outputCount: z.ZodNumber;
-    strategy: z.ZodDefault<z.ZodEnum<{
-        split: "split";
-        copy: "copy";
-    }>>;
-}, z.core.$strip>;
-export type MultiplexParams = z.infer<typeof multiplexParamsSchema>;
-export declare function createMultiplexNode(id: string, { outputCount, strategy }: MultiplexParams): import("@uploadista/flow-core").FlowNode<{
-    path: string;
-    inputBytes: Uint8Array<ArrayBufferLike>;
-    metadata: {
-        mimeType: string;
-        size: number;
-        width?: number | undefined;
-        height?: number | undefined;
-        format?: string | undefined;
-        originalName?: string | undefined;
-        extension?: string | undefined;
-    };
-}, {
-    files: {
-        path: string;
-        inputBytes: Uint8Array<ArrayBufferLike>;
-        metadata: {
-            mimeType: string;
-            size: number;
-            width?: number | undefined;
-            height?: number | undefined;
-            format?: string | undefined;
-            originalName?: string | undefined;
-            extension?: string | undefined;
-        };
-    }[];
-    metadata?: {
-        batchId: string;
-        totalSize: number;
-        fileCount: number;
-    } | undefined;
-}>;
-//# sourceMappingURL=multiplex-node.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"multiplex-node.d.ts","sourceRoot":"","sources":["../src/multiplex-node.ts"],"names":[],"mappings":"AAQA,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;AAIpE,wBAAgB,mBAAmB,CACjC,EAAE,EAAE,MAAM,EACV,EAAE,WAAW,EAAE,QAAQ,EAAE,EAAE,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoE3C"}

package/dist/multiplex-node.js

@@ -1,67 +0,0 @@
-import { createFlowNode, flowFileBatchSchema, flowFileSchema, NodeType, } from "@uploadista/flow-core";
-import { z } from "zod";
-export const multiplexParamsSchema = z.object({
-    outputCount: z.number().min(1).max(10),
-    strategy: z.enum(["copy", "split"]).default("copy"),
-});
-// Define schemas for input and output
-export function createMultiplexNode(id, { outputCount, strategy }) {
-    return createFlowNode({
-        id,
-        name: "Multiplex",
-        description: `Splits input into ${outputCount} parallel outputs using ${strategy} strategy`,
-        type: NodeType.multiplex,
-        inputSchema: flowFileSchema,
-        outputSchema: flowFileBatchSchema,
-        multiOutput: true,
-        run: async ({ data }) => {
-            if (strategy === "copy") {
-                // Copy the same file to multiple outputs
-                const files = Array.from({ length: outputCount }, (_, index) => ({
-                    path: `${data.path}_copy_${index}`,
-                    inputBytes: data.inputBytes,
-                    metadata: {
-                        ...data.metadata,
-                        originalName: `${data.metadata.originalName || data.path}_copy_${index}`,
-                    },
-                }));
-                return {
-                    files,
-                    metadata: {
-                        batchId: crypto.randomUUID(),
-                        totalSize: files.length * data.metadata.size,
-                        fileCount: files.length,
-                    },
-                };
-            }
-            else if (strategy === "split") {
-                // Split the file into chunks
-                const chunkSize = Math.ceil(data.inputBytes.length / outputCount);
-                const files = [];
-                for (let i = 0; i < outputCount; i++) {
-                    const start = i * chunkSize;
-                    const end = Math.min(start + chunkSize, data.inputBytes.length);
-                    const chunk = data.inputBytes.subarray(start, end);
-                    files.push({
-                        path: `${data.path}_part_${i}`,
-                        inputBytes: chunk,
-                        metadata: {
-                            ...data.metadata,
-                            size: chunk.length,
-                            originalName: `${data.metadata.originalName || data.path}_part_${i}`,
-                        },
-                    });
-                }
-                return {
-                    files,
-                    metadata: {
-                        batchId: crypto.randomUUID(),
-                        totalSize: data.inputBytes.length,
-                        fileCount: files.length,
-                    },
-                };
-            }
-            throw new Error(`Unknown multiplex strategy: ${strategy}`);
-        },
-    });
-}

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

@@ -1,5 +0,0 @@
-import { type UploadFile } from "@uploadista/core/types";
-import { Effect } from "effect";
-import type { ConditionalParams } from "@/types/conditional-node";
-export declare function createConditionalNode(id: string, { field, operator, value }: ConditionalParams): Effect.Effect<import("@uploadista/core").FlowNode<UploadFile, UploadFile, import("@uploadista/core").UploadistaError>, never, never>;
-//# sourceMappingURL=conditional-node.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"conditional-node.d.ts","sourceRoot":"","sources":["../../src/nodes/conditional-node.ts"],"names":[],"mappings":"AAKA,OAAO,EAAE,KAAK,UAAU,EAAoB,MAAM,wBAAwB,CAAC;AAC3E,OAAO,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAChC,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,0BAA0B,CAAC;AAElE,wBAAgB,qBAAqB,CACnC,EAAE,EAAE,MAAM,EACV,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,EAAE,iBAAiB,wIAgB9C"}

package/dist/nodes/conditional-node.js

@@ -1,19 +0,0 @@
-import { completeNodeExecution, createFlowNode, NodeType, } from "@uploadista/core/flow";
-import { uploadFileSchema } from "@uploadista/core/types";
-import { Effect } from "effect";
-export function createConditionalNode(id, { field, operator, value }) {
-    return createFlowNode({
-        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/dist/nodes/merge-node.d.ts

@@ -1,7 +0,0 @@
-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 { MergeParams } from "@/types/merge-node";
-export declare function createMergeNode(id: string, { strategy, separator: _separator }: MergeParams): Effect.Effect<import("@uploadista/core").FlowNode<Record<string, UploadFile>, UploadFile, UploadistaError>, never, UploadServer>;
-//# sourceMappingURL=merge-node.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"merge-node.d.ts","sourceRoot":"","sources":["../../src/nodes/merge-node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAM1D,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,WAAW,EAAE,MAAM,oBAAoB,CAAC;AAKtD,wBAAgB,eAAe,CAC7B,EAAE,EAAE,MAAM,EACV,EAAE,QAAQ,EAAE,SAAS,EAAE,UAAU,EAAE,EAAE,WAAW,oIA6FjD"}

package/dist/nodes/merge-node.js

@@ -1,82 +0,0 @@
-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

@@ -1,7 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,57 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,64 +0,0 @@
-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

@@ -1,21 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,13 +0,0 @@
-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.map

@@ -1 +0,0 @@
-{"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/merge-node.d.ts

@@ -1,11 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,6 +0,0 @@
-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

@@ -1,10 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,5 +0,0 @@
-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

@@ -1,8 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,6 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1 +0,0 @@
-{"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

@@ -1,65 +0,0 @@
-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",
-                },
-            };
-        },
-    });
-}