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

package/build/index.js

@@ -1,6 +1,6 @@
 import {
   deobfuscate
-} from "./chunk-4r30g3ha.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,57 +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 (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 (aborted) {
+      return 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 z3 } from "zod";
-
-// ../helpers/src/files/index.ts
-import { z as z2 } from "zod";
+mapData.abort = () => {
+  throw new AbortMapData;
+};
 
 // ../helpers/src/files/mapOutput.ts
 async function upload(uploadUrl, body, signal, contentType) {
@@ -251,6 +267,7 @@ async function mapOutput(params) {
   Promise.allSettled(streamPromises).then(() => params.onDone?.());
   return mapped;
 }
+
 // ../helpers/src/files/RequenceFile.ts
 class RequenceFile {
   #data;
@@ -309,6 +326,7 @@ class RequenceFile {
     return `RequenceFile<${this.mimeType}>`;
   }
 }
+
 // ../helpers/src/files/RequenceStream.ts
 class RequenceStream {
   #data;
@@ -370,47 +388,42 @@ class RequenceStream {
   }
 }
 
-// ../helpers/src/files/index.ts
-var fileObjectSchema = z2.object({
-  size: z2.number().int().positive(),
-  mime: z2.string(),
-  url: z2.string().url(),
-  __REQUENCE_type: z2.literal("RequenceFile")
-});
-function toFileObject(fileInfo) {
-  return {
-    ...fileInfo,
-    __REQUENCE_type: "RequenceFile"
-  };
-}
-function isFileObject(data) {
-  return fileObjectSchema.safeParse(data).success;
-}
+// ../helpers/src/files/streamObject.ts
+import { z as z2 } from "zod/v4";
 var streamObjectSchema = z2.object({
   mime: z2.string(),
   url: z2.string().url(),
   __REQUENCE_type: z2.literal("RequenceStream")
 });
+function isStreamObject(data) {
+  return streamObjectSchema.safeParse(data).success;
+}
 function toStreamObject(streamInfo) {
   return {
     ...streamInfo,
     __REQUENCE_type: "RequenceStream"
   };
 }
-function isStreamObject(data) {
-  return streamObjectSchema.safeParse(data).success;
-}
 
-// ../helpers/src/context/context.ts
-var contextSchema = z3.object({
-  input: z3.any(),
-  meta: z3.any(),
-  tenant: z3.object({ name: z3.string() }),
-  data: z3.record(z3.string(), z3.any()),
-  errors: z3.record(z3.string(), z3.string()),
-  dates: z3.record(z3.string(), z3.string().datetime())
+// ../helpers/src/files/fileObject.ts
+import { z as z3 } from "zod/v4";
+var fileObjectSchema = z3.object({
+  size: z3.number().int().positive(),
+  mime: z3.string(),
+  url: z3.string().url(),
+  __REQUENCE_type: z3.literal("RequenceFile")
 });
-var internalKey = Symbol.for("internal");
+function toFileObject(fileInfo) {
+  return {
+    ...fileInfo,
+    __REQUENCE_type: "RequenceFile"
+  };
+}
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
+}
+
+// ../helpers/src/utils/resolveRequenceTypes.ts
 function resolveRequenceTypes(data) {
   return mapData(data, {
     Object(obj) {
@@ -423,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";
@@ -550,45 +488,28 @@ async function abortTask(options) {
 }
 
 // src/types.ts
-import { z as z4 } from "zod";
-var serviceNodeInfoSchema = z4.object({
-  id: z4.string().uuid(),
+import { z as z4 } from "zod/v4";
+var nodeInfoSchema = z4.object({
+  id: z4.uuid(),
   type: z4.literal("service"),
-  alias: z4.string().optional(),
-  service: z4.object({
-    id: z4.string().uuid(),
-    name: z4.string(),
-    version: z4.string()
-  }).optional()
-});
-var logicNodeInfoSchema = z4.object({
-  id: z4.string().uuid(),
-  type: z4.literal("logic"),
-  alias: z4.string().optional(),
-  logic: z4.object({
-    language: z4.enum(["typescript", "javascript", "python"])
-  }).optional()
+  alias: z4.string().optional()
 });
-var nodeInfoSchema = z4.discriminatedUnion("type", [
-  serviceNodeInfoSchema,
-  logicNodeInfoSchema
-]);
 var baseUpdate = z4.object({
   timestamp: z4.coerce.date(),
-  taskId: z4.string().uuid(),
-  updateId: z4.string().uuid(),
-  context: contextSchema,
-  nodes: z4.custom((data) => Array.isArray(data))
+  taskId: z4.uuid(),
+  updateId: z4.uuid()
 });
 var taskStartUpdateSchema = baseUpdate.extend({
-  type: z4.literal("taskStart")
+  type: z4.literal("taskStart"),
+  input: z4.unknown()
 });
 var taskErrorUpdateSchema = baseUpdate.extend({
   type: z4.literal("taskError"),
-  error: z4.string()
+  reason: z4.string().optional()
 });
 var taskEndUpdateSchema = baseUpdate.extend({
-  type: z4.literal("taskEnd")
+  type: z4.literal("taskEnd"),
+  result: z4.record(z4.string(), z4.any())
 });
 var nodeStartUpdateSchema = baseUpdate.extend({
   type: z4.literal("nodeStart"),
@@ -626,20 +547,6 @@ var updateSchema = z4.discriminatedUnion("type", [
 ]);
 var eventSchema = z4.object({ type: z4.string(), data: z4.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
 
-// src/utils/mapOutput.ts
-function mapOutput3(data) {
-  return mapData(data, {
-    Object(obj) {
-      if (isFileObject(obj)) {
-        return RequenceFile.fromFileObject(obj);
-      }
-      if (isStreamObject(obj)) {
-        return RequenceStream.fromStreamObject(obj);
-      }
-    }
-  });
-}
-
 // src/createTask.ts
 class TaskError extends Error {
   taskTemplate;
@@ -662,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;
@@ -701,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);
@@ -710,43 +610,64 @@ 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: mapOutput3(contextUpdate.data)
-        } : contextUpdate;
-        taskUpdateHandlers.forEach((handler) => handler(extendedUpdate));
+        taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
       });
     });
   };
   const taskMetaPromise = createRemotePromise();
   const resultPromise = createRemotePromise(startMonitoring);
+  taskMetaPromise.catch(() => {});
   (async () => {
     const prepareResponse = await fetch(prepareUrl, {
       method: "POST",
@@ -857,6 +778,7 @@ function watchTasks(options) {
     "nodeError",
     "nodeEnd"
   ];
+  const taskStorage = new Map;
   taskEvents.forEach((taskEvent) => {
     eventSource.addEventListener(taskEvent, (event) => {
       const updateResult = eventSchema.safeParse(event);
@@ -865,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: mapOutput3(contextUpdate.data)
-      } : contextUpdate;
-      taskUpdateHandlers.forEach((handler) => handler(extendedUpdate));
+      taskUpdateHandlers.forEach((handler) => handler(contextUpdate));
     });
   });
   const stopWatching = () => {
@@ -895,5 +857,5 @@ export {
   RequenceFile
 };
 
-//# debugId=1ABBB576345EB61164756E2164756E21
+//# debugId=D44324C24B98459964756E2164756E21
 //# sourceMappingURL=index.js.map