@requence/task 1.0.0-alpha.21 → 1.0.0-alpha.22

package/build/index.js

@@ -1,6 +1,6 @@
 import {
   deobfuscate
-} from "./chunk-xdx5gf9h.js";
+} from "./chunk-y4v98p2s.js";
 
 // ../helpers/src/utils/createRemotePromise.ts
 function createRemotePromise(onAwait) {
@@ -78,8 +78,8 @@ function callbackToAsyncIterable(...args) {
 }
 
 // ../helpers/src/utils/isRecord.ts
-import { z } from "zod";
-var recordSchema = z.record(z.unknown());
+import { z } from "zod/v4";
+var recordSchema = z.record(z.string(), z.unknown());
 function isRecord(data) {
   return recordSchema.safeParse(data).success;
 }
@@ -94,54 +94,73 @@ function resolve(value, onResolve) {
 function notUndefined(value, fallback) {
   return resolve(value, (resolvedValue) => typeof resolvedValue === "undefined" ? fallback : resolvedValue);
 }
+
+class AbortMapData extends Error {
+}
 function mapData(data, visitors) {
+  let aborted = false;
   const traverseData = (data2, path) => {
-    if (Array.isArray(data2)) {
-      return resolve(visitors.Array?.(data2, path), (resolvedData) => {
-        if (resolvedData) {
-          return resolvedData;
-        }
-        const items = data2.map((item, index) => traverseData(item, [...path, index]));
-        if (items.some((item) => item instanceof Promise)) {
-          return Promise.all(items);
-        }
-        return items;
-      });
-    }
-    if (data2 === null) {
-      return notUndefined(visitors.Null?.(data2, path), data2);
+    if (aborted) {
+      return data2;
     }
-    if (typeof Buffer !== "undefined" && Buffer.isBuffer(data2)) {
-      return notUndefined(visitors.Buffer?.(data2, path), data2);
-    }
-    if (typeof data2 === "string") {
-      return notUndefined(visitors.String?.(data2, path), data2);
-    }
-    if (typeof data2 === "number") {
-      return notUndefined(visitors.Number?.(data2, path), data2);
-    }
-    if (isRecord(data2)) {
-      return resolve(visitors.Object?.(data2, path), (resolvedData) => {
-        if (resolvedData) {
-          return resolvedData;
-        }
-        const entries = Object.entries(data2).map(([key, value]) => [
-          key,
-          traverseData(value, [...path, key])
-        ]);
-        if (entries.some(([, value]) => value instanceof Promise)) {
-          return Promise.all(entries.map(([key, value]) => Promise.resolve().then(() => value).then((resolvedValue) => [key, resolvedValue]))).then((entries2) => Object.fromEntries(entries2));
-        }
-        return Object.fromEntries(entries);
-      });
+    try {
+      if (Array.isArray(data2)) {
+        return resolve(visitors.Array?.(data2, path), (resolvedData) => {
+          if (resolvedData) {
+            return resolvedData;
+          }
+          const items = data2.map((item, index) => traverseData(item, [...path, index]));
+          if (items.some((item) => item instanceof Promise)) {
+            return Promise.all(items);
+          }
+          return items;
+        });
+      }
+      if (data2 === null) {
+        return notUndefined(visitors.Null?.(data2, path), data2);
+      }
+      if (typeof Buffer !== "undefined" && Buffer.isBuffer(data2)) {
+        return notUndefined(visitors.Buffer?.(data2, path), data2);
+      }
+      if (typeof data2 === "string") {
+        return notUndefined(visitors.String?.(data2, path), data2);
+      }
+      if (typeof data2 === "number") {
+        return notUndefined(visitors.Number?.(data2, path), data2);
+      }
+      if (typeof data2 === "symbol") {
+        return notUndefined(visitors.Symbol?.(data2, path), data2);
+      }
+      if (isRecord(data2)) {
+        return resolve(visitors.Object?.(structuredClone(data2), path), (resolvedData) => {
+          const nextData = resolvedData ?? data2;
+          const entries = Object.entries(nextData).map(([key, value]) => [
+            key,
+            traverseData(value, [...path, key])
+          ]);
+          if (entries.some(([, value]) => value instanceof Promise)) {
+            return Promise.all(entries.map(([key, value]) => Promise.resolve().then(() => value).then((resolvedValue) => [key, resolvedValue]))).then((entries2) => Object.fromEntries(entries2));
+          }
+          return Object.fromEntries(entries);
+        });
+      }
+      if (typeof data2 === "object" && data2) {
+        return notUndefined(visitors.Object?.(data2, path), data2);
+      }
+      return data2;
+    } catch (error) {
+      if (error instanceof AbortMapData) {
+        aborted = true;
+        return data2;
+      }
+      throw error;
     }
-    return data2;
   };
   return traverseData(data, []);
 }
-
-// ../helpers/src/context/context.ts
-import { z as z4 } from "zod";
+mapData.abort = () => {
+  throw new AbortMapData;
+};
 
 // ../helpers/src/files/mapOutput.ts
 async function upload(uploadUrl, body, signal, contentType) {
@@ -370,7 +389,7 @@ class RequenceStream {
 }
 
 // ../helpers/src/files/streamObject.ts
-import { z as z2 } from "zod";
+import { z as z2 } from "zod/v4";
 var streamObjectSchema = z2.object({
   mime: z2.string(),
   url: z2.string().url(),
@@ -387,7 +406,7 @@ function toStreamObject(streamInfo) {
 }
 
 // ../helpers/src/files/fileObject.ts
-import { z as z3 } from "zod";
+import { z as z3 } from "zod/v4";
 var fileObjectSchema = z3.object({
   size: z3.number().int().positive(),
   mime: z3.string(),
@@ -404,16 +423,7 @@ function isFileObject(data) {
   return fileObjectSchema.safeParse(data).success;
 }
 
-// ../helpers/src/context/context.ts
-var contextSchema = z4.object({
-  input: z4.any(),
-  meta: z4.any(),
-  tenant: z4.object({ name: z4.string() }),
-  data: z4.record(z4.string(), z4.any()),
-  errors: z4.record(z4.string(), z4.string()),
-  dates: z4.record(z4.string(), z4.string().datetime())
-});
-var internalKey = Symbol.for("internal");
+// ../helpers/src/utils/resolveRequenceTypes.ts
 function resolveRequenceTypes(data) {
   return mapData(data, {
     Object(obj) {
@@ -426,81 +436,6 @@ function resolveRequenceTypes(data) {
     }
   });
 }
-function createContextHelper(context, nodes) {
-  const input = resolveRequenceTypes(context.input);
-  const meta = resolveRequenceTypes(context.meta);
-  const results = new Map(nodes.map((node) => [
-    node.id,
-    {
-      node,
-      executionDate: node.id in context.dates ? new Date(context.dates[node.id]) : null,
-      data: resolveRequenceTypes(context.data[node.id] ?? null),
-      error: context.errors[node.id] ?? null
-    }
-  ]));
-  const lookUpMap = new Map;
-  for (const node of nodes) {
-    const alias = typeof node.meta?.mapAlias === "string" ? node.meta.mapAlias : ("alias" in node) && node.alias;
-    if (alias) {
-      if (lookUpMap.has(alias)) {
-        lookUpMap.get(alias).push(node.id);
-      } else {
-        lookUpMap.set(alias, [node.id]);
-      }
-    }
-    const name = typeof node.meta?.mapName === "string" ? node.meta.mapName : node.type === "service" && node.name;
-    if (name) {
-      if (lookUpMap.has(name)) {
-        lookUpMap.get(name).push(node.id);
-      } else {
-        lookUpMap.set(name, [node.id]);
-      }
-    }
-  }
-  return {
-    [internalKey]: {
-      results
-    },
-    getInput() {
-      return input;
-    },
-    getMeta() {
-      return meta;
-    },
-    getData(alias) {
-      if (alias) {
-        const nodeIds = lookUpMap.get(alias);
-        if (!nodeIds) {
-          return null;
-        }
-        const uniqueNodeIds = Array.from(new Set(nodeIds));
-        const combinedData = uniqueNodeIds.map((nodeId) => results.get(nodeId)?.data).filter(Boolean);
-        if (combinedData.length === 0) {
-          return null;
-        }
-        if (combinedData.length === 1) {
-          return combinedData[0];
-        }
-        if (combinedData.every(isRecord)) {
-          return combinedData.reduce((acc, data) => ({ ...acc, ...data }), {});
-        }
-        return combinedData;
-      }
-      return Array.from(results.values()).filter((result) => result.executionDate && isRecord(result.data)).toSorted((a, b) => a.executionDate.getTime() - b.executionDate.getTime()).reduce((acc, result) => ({
-        ...acc,
-        ...result.data
-      }), isRecord(input) ? input : {});
-    },
-    getError(alias) {
-      const nodeIds = lookUpMap.get(alias);
-      if (!nodeIds) {
-        return null;
-      }
-      return nodeIds.map((nodeId) => results.get(nodeId)?.error).filter((str) => typeof str === "string").join(`
-`);
-    }
-  };
-}
 
 // src/createTask.ts
 import { EventSource } from "eventsource";
@@ -553,71 +488,54 @@ async function abortTask(options) {
 }
 
 // src/types.ts
-import { z as z5 } from "zod";
-var serviceNodeInfoSchema = z5.object({
-  id: z5.string().uuid(),
-  type: z5.literal("service"),
-  alias: z5.string().optional(),
-  service: z5.object({
-    id: z5.string().uuid(),
-    name: z5.string(),
-    version: z5.string()
-  }).optional()
+import { z as z4 } from "zod/v4";
+var nodeInfoSchema = z4.object({
+  id: z4.uuid(),
+  type: z4.literal("service"),
+  alias: z4.string().optional()
 });
-var logicNodeInfoSchema = z5.object({
-  id: z5.string().uuid(),
-  type: z5.literal("logic"),
-  alias: z5.string().optional(),
-  logic: z5.object({
-    language: z5.enum(["typescript", "javascript", "python"])
-  }).optional()
-});
-var nodeInfoSchema = z5.discriminatedUnion("type", [
-  serviceNodeInfoSchema,
-  logicNodeInfoSchema
-]);
-var baseUpdate = z5.object({
-  timestamp: z5.coerce.date(),
-  taskId: z5.string().uuid(),
-  updateId: z5.string().uuid(),
-  context: contextSchema,
-  nodes: z5.custom((data) => Array.isArray(data))
+var baseUpdate = z4.object({
+  timestamp: z4.coerce.date(),
+  taskId: z4.uuid(),
+  updateId: z4.uuid()
 });
 var taskStartUpdateSchema = baseUpdate.extend({
-  type: z5.literal("taskStart")
+  type: z4.literal("taskStart"),
+  input: z4.unknown()
 });
 var taskErrorUpdateSchema = baseUpdate.extend({
-  type: z5.literal("taskError"),
-  error: z5.string()
+  type: z4.literal("taskError"),
+  reason: z4.string().optional()
 });
 var taskEndUpdateSchema = baseUpdate.extend({
-  type: z5.literal("taskEnd")
+  type: z4.literal("taskEnd"),
+  result: z4.record(z4.string(), z4.any())
 });
 var nodeStartUpdateSchema = baseUpdate.extend({
-  type: z5.literal("nodeStart"),
+  type: z4.literal("nodeStart"),
   node: nodeInfoSchema
 });
 var nodeUpdateUpdateSchema = baseUpdate.extend({
-  type: z5.literal("nodeUpdate"),
+  type: z4.literal("nodeUpdate"),
   node: nodeInfoSchema,
-  data: z5.unknown(),
-  output: z5.union([z5.null(), z5.string()])
+  data: z4.unknown(),
+  output: z4.union([z4.null(), z4.string()])
 });
 var nodeErrorUpdateSchema = baseUpdate.extend({
-  type: z5.literal("nodeError"),
+  type: z4.literal("nodeError"),
   node: nodeInfoSchema,
-  error: z5.string()
+  error: z4.string()
 });
 var nodeDeferUpdateSchema = baseUpdate.extend({
-  type: z5.literal("nodeDefer"),
+  type: z4.literal("nodeDefer"),
   node: nodeInfoSchema,
-  reason: z5.string().optional()
+  reason: z4.string().optional()
 });
 var nodeEndUpdateSchema = baseUpdate.extend({
-  type: z5.literal("nodeEnd"),
+  type: z4.literal("nodeEnd"),
   node: nodeInfoSchema
 });
-var updateSchema = z5.discriminatedUnion("type", [
+var updateSchema = z4.discriminatedUnion("type", [
   taskStartUpdateSchema,
   taskErrorUpdateSchema,
   taskEndUpdateSchema,
@@ -627,21 +545,7 @@ var updateSchema = z5.discriminatedUnion("type", [
   nodeDeferUpdateSchema,
   nodeEndUpdateSchema
 ]);
-var eventSchema = z5.object({ type: z5.string(), data: z5.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
-
-// src/utils/mapOutput.ts
-function mapOutput2(data) {
-  return mapData(data, {
-    Object(obj) {
-      if (isFileObject(obj)) {
-        return RequenceFile.fromFileObject(obj);
-      }
-      if (isStreamObject(obj)) {
-        return RequenceStream.fromStreamObject(obj);
-      }
-    }
-  });
-}
+var eventSchema = z4.object({ type: z4.string(), data: z4.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
 
 // src/createTask.ts
 class TaskError extends Error {
@@ -665,23 +569,15 @@ function createTask(options, onUpdate) {
     const payload = await payloadPromise;
     if (!payload.urls) {
       resultPromise.resolve({
-        getInput() {
-          return options.input;
-        },
-        getMeta() {
-          return options.meta;
-        },
-        getError(_alias) {
+        input: options.input,
+        taskId: payload.taskId,
+        taskUrl: "",
+        result: null,
+        getNodeData(_alias) {
           return null;
         },
-        getData(_alias) {
+        getNodeError(_alias) {
           return null;
-        },
-        getTaskId() {
-          return payload.taskId;
-        },
-        getTaskUrl() {
-          return "";
         }
       });
       return;
@@ -704,6 +600,7 @@ function createTask(options, onUpdate) {
       "nodeError",
       "nodeEnd"
     ];
+    const taskStorage = { input: null, data: {}, errors: {}, result: null };
     taskEvents.forEach((taskEvent) => {
       eventSource.addEventListener(taskEvent, (event) => {
         const updateResult = eventSchema.safeParse(event);
@@ -713,38 +610,58 @@ function createTask(options, onUpdate) {
           return;
         }
         const update = updateResult.data;
-        if (update.type === "taskEnd" || update.type === "taskError") {
-          eventSource.close();
-        }
-        const context = update.context;
-        if (update.type === "nodeUpdate") {
-          context.dates[update.node.id] = update.timestamp.toISOString();
-          context.data[update.node.id] = update.data;
+        switch (update.type) {
+          case "taskStart": {
+            taskStorage.input = resolveRequenceTypes(update.input);
+            break;
+          }
+          case "nodeUpdate": {
+            if (update.node.id) {
+              taskStorage.data[update.node.id] = resolveRequenceTypes(update.data);
+            }
+            break;
+          }
+          case "nodeError": {
+            if (update.node.id) {
+              taskStorage.errors[update.node.id] = update.error;
+            }
+            break;
+          }
+          case "taskEnd": {
+            taskStorage.result = resolveRequenceTypes(update.result);
+            eventSource.close();
+            break;
+          }
+          case "taskError": {
+            eventSource.close();
+            break;
+          }
         }
+        const context = {
+          taskId: update.taskId,
+          input: taskStorage.input,
+          getNodeData(alias) {
+            return taskStorage.data[alias] ?? null;
+          },
+          getNodeError(alias) {
+            return taskStorage.errors[alias] ?? null;
+          },
+          result: taskStorage.result
+        };
         const contextUpdate = {
           ...update,
-          context: createContextHelper(context, update.nodes)
+          context
         };
         if (contextUpdate.type === "taskEnd") {
           resultPromise.resolve({
-            ...contextUpdate.context,
-            getTaskId() {
-              return payload.taskId;
-            },
-            getTaskUrl() {
-              return payload.urls?.show ?? "";
-            }
+            ...context,
+            taskUrl: payload.urls?.show ?? ""
           });
         }
         if (contextUpdate.type === "taskError") {
-          resultPromise.reject(new TaskError(contextUpdate.error, options.taskTemplate));
+          resultPromise.reject(new TaskError(contextUpdate.reason ?? "Task failed", options.taskTemplate));
         }
-        const extendedUpdate = contextUpdate.type === "nodeUpdate" ? {
-          ...contextUpdate,
-          output: contextUpdate.output === "__default__" ? null : contextUpdate.output,
-          data: mapOutput2(contextUpdate.data)
-        } : contextUpdate;
-        taskUpdateHandlers.forEach((handler) => handler(extendedUpdate));
+        taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
       });
     });
   };
@@ -861,6 +778,7 @@ function watchTasks(options) {
     "nodeError",
     "nodeEnd"
   ];
+  const taskStorage = new Map;
   taskEvents.forEach((taskEvent) => {
     eventSource.addEventListener(taskEvent, (event) => {
       const updateResult = eventSchema.safeParse(event);
@@ -869,21 +787,61 @@ function watchTasks(options) {
         throw new Error("invalid update");
       }
       const update = updateResult.data;
-      const context = update.context;
-      if (update.type === "nodeUpdate") {
-        context.dates[update.node.id] = update.timestamp.toISOString();
-        context.data[update.node.id] = update.data;
+      if (!taskStorage.has(update.taskId)) {
+        taskStorage.set(update.taskId, {
+          input: null,
+          data: {},
+          errors: {},
+          result: null,
+          incomplete: true
+        });
       }
+      const storageEntry = taskStorage.get(update.taskId);
+      switch (update.type) {
+        case "taskStart": {
+          storageEntry.input = resolveRequenceTypes(update.input);
+          storageEntry.incomplete = false;
+          break;
+        }
+        case "nodeUpdate": {
+          if (update.node.alias) {
+            storageEntry.data[update.node.alias] = resolveRequenceTypes(update.data);
+          }
+          break;
+        }
+        case "nodeError": {
+          if (update.node.alias) {
+            storageEntry.errors[update.node.alias] = update.error;
+          }
+          break;
+        }
+        case "taskEnd": {
+          storageEntry.result = resolveRequenceTypes(update.result);
+          taskStorage.delete(update.taskId);
+          break;
+        }
+        case "taskError": {
+          taskStorage.delete(update.taskId);
+          break;
+        }
+      }
+      const context = {
+        taskId: update.taskId,
+        input: storageEntry.input,
+        getNodeData(alias) {
+          return storageEntry.data[alias] ?? null;
+        },
+        getNodeError(alias) {
+          return storageEntry.errors[alias] ?? null;
+        },
+        result: storageEntry.result
+      };
       const contextUpdate = {
         ...update,
-        context: createContextHelper(context, update.nodes)
+        context,
+        incomplete: storageEntry.incomplete
       };
-      const extendedUpdate = contextUpdate.type === "nodeUpdate" ? {
-        ...contextUpdate,
-        output: contextUpdate.output === "__default__" ? null : contextUpdate.output,
-        data: mapOutput2(contextUpdate.data)
-      } : contextUpdate;
-      taskUpdateHandlers.forEach((handler) => handler(extendedUpdate));
+      taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
     });
   });
   const stopWatching = () => {
@@ -899,5 +857,5 @@ export {
   RequenceFile
 };
 
-//# debugId=5101AFB42955246864756E2164756E21
+//# debugId=D44324C24B98459964756E2164756E21
 //# sourceMappingURL=index.js.map