@requence/task 1.0.0-alpha.10 → 1.0.0-alpha.12

package/build/index.js

@@ -1,12 +1,253 @@
 import {
-  createRemotePromise,
-  deobfuscate,
-  mapData
-} from "./chunk-ajdmm777.js";
+  deobfuscate
+} from "./chunk-4r30g3ha.js";
 
-// ../helpers/src/files/index.ts
+// ../helpers/src/utils/createRemotePromise.ts
+function createRemotePromise(onAwait) {
+  let resolvePromise;
+  let rejectPromise;
+  const internalPromise = new Promise((resolve, reject) => {
+    resolvePromise = resolve;
+    rejectPromise = reject;
+  });
+  let isAwaited = false;
+  const wrappedPromise = new Proxy(internalPromise, {
+    get(target, property) {
+      if (property === "then" || property === "catch" || property === "finally") {
+        if (!isAwaited && onAwait) {
+          isAwaited = true;
+          onAwait(resolvePromise, rejectPromise);
+        }
+        return target[property].bind(target);
+      }
+      return target[property];
+    }
+  });
+  return Object.assign(wrappedPromise, {
+    resolve: resolvePromise,
+    reject: rejectPromise,
+    promise: wrappedPromise
+  });
+}
+
+// ../helpers/src/utils/callbackToAsyncIterator.ts
+function callbackToAsyncIterator(subscribe) {
+  const pullQueue = [];
+  const pushQueue = [];
+  const pushValue = (value) => {
+    if (pullQueue.length !== 0) {
+      const resolver = pullQueue.shift();
+      resolver(value);
+    } else {
+      pushQueue.push(value);
+    }
+  };
+  const pullValue = () => new Promise((resolve) => {
+    if (pushQueue.length !== 0) {
+      resolve(pushQueue.shift());
+    } else {
+      pullQueue.push(resolve);
+    }
+  });
+  subscribe((value) => {
+    pushValue({ value });
+  }, (error) => {
+    pushValue({ error });
+  }, () => {
+    pushValue({ done: true });
+  });
+  return {
+    async next() {
+      const value = await pullValue();
+      if (value.done) {
+        return { value: undefined, done: true };
+      }
+      if (value.error) {
+        throw value.error;
+      }
+      return { value: value.value, done: false };
+    }
+  };
+}
+function callbackToAsyncIterable(...args) {
+  return {
+    [Symbol.asyncIterator]() {
+      return callbackToAsyncIterator(...args);
+    }
+  };
+}
+
+// ../helpers/src/utils/isRecord.ts
 import { z } from "zod";
+var recordSchema = z.record(z.unknown());
+function isRecord(data) {
+  return recordSchema.safeParse(data).success;
+}
+
+// ../helpers/src/utils/mapData.ts
+function resolve(value, onResolve) {
+  if (value instanceof Promise) {
+    return Promise.resolve().then(() => value).then(onResolve);
+  }
+  return onResolve(value);
+}
+function notUndefined(value, fallback) {
+  return resolve(value, (resolvedValue) => typeof resolvedValue === "undefined" ? fallback : resolvedValue);
+}
+function mapData(data, visitors) {
+  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 (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);
+      });
+    }
+    return data2;
+  };
+  return traverseData(data, []);
+}
 
+// ../helpers/src/files/index.ts
+import { z as z2 } from "zod";
+
+// ../helpers/src/files/mapOutput.ts
+async function upload(uploadUrl, body, signal, contentType) {
+  const uploadResponse = await fetch(uploadUrl, {
+    method: "POST",
+    signal,
+    headers: contentType ? {
+      "Content-Type": contentType
+    } : {},
+    body
+  });
+  const data = await uploadResponse.json();
+  if (!data || typeof data !== "object") {
+    throw new Error("invalid upload response");
+  }
+  return toFileObject(data);
+}
+async function stream(streamUrl, stream2, signal, contentType) {
+  const [testStream, dataStream] = stream2.tee();
+  const reader = testStream.getReader();
+  const dataPromise = reader.read().then(({ done: done2 }) => {
+    if (done2) {
+      throw new Error("No streaming date received");
+    }
+    reader.cancel();
+  });
+  const streamResponse = await fetch(streamUrl, {
+    method: "POST",
+    signal,
+    headers: contentType ? { "Content-Type": contentType } : {}
+  });
+  const data = await streamResponse.json();
+  if (!data || typeof data !== "object") {
+    throw new Error("invalid stream response");
+  }
+  const { mime, url } = data;
+  await dataPromise;
+  const done = fetch(url, {
+    method: "POST",
+    signal,
+    duplex: "half",
+    body: dataStream
+  });
+  return [toStreamObject({ mime, url }), done];
+}
+async function mapOutput(params) {
+  const streamPromises = [];
+  const mapped = await mapData(params.value, {
+    async Object(obj) {
+      if (obj instanceof Blob || obj instanceof RequenceFile) {
+        if (obj instanceof RequenceFile && obj.fileObject) {
+          return obj.fileObject;
+        }
+        if (params.options.uploadUrl) {
+          try {
+            if (obj instanceof Blob) {
+              return await upload(params.options.uploadUrl, obj, params.signal, obj.type);
+            }
+            if (obj instanceof RequenceFile) {
+              return await upload(params.options.uploadUrl, await obj.blob(), params.signal, obj.mimeType);
+            }
+          } catch (error) {
+            if (!(error instanceof Error)) {
+              throw error;
+            }
+            params.onFail?.(error);
+            return null;
+          }
+        } else {
+          params.onSkip?.();
+          return null;
+        }
+      }
+      if (obj instanceof Response || obj instanceof RequenceStream) {
+        if (obj instanceof RequenceStream && obj.streamObject) {
+          return obj.streamObject;
+        }
+        if (params.options.streamUrl) {
+          try {
+            if (obj instanceof Response && obj.body) {
+              const [streamObject, streamPromise] = await stream(params.options.streamUrl, obj.body, params.signal, obj.headers.get("Content-Type"));
+              streamPromises.push(streamPromise);
+              return streamObject;
+            }
+            if (obj instanceof RequenceStream) {
+              const [streamObject, streamPromise] = await stream(params.options.streamUrl, obj.stream(), params.signal, obj.mimeType);
+              streamPromises.push(streamPromise);
+              return streamObject;
+            }
+          } catch (error) {
+            if (!(error instanceof Error)) {
+              throw error;
+            }
+            params.onFail?.(error);
+            return null;
+          }
+        } else {
+          params.onSkip?.();
+          return null;
+        }
+      }
+    }
+  });
+  Promise.allSettled(streamPromises).then(() => params.onDone?.());
+  return mapped;
+}
 // ../helpers/src/files/RequenceFile.ts
 class RequenceFile {
   #data;
@@ -70,15 +311,15 @@ class RequenceStream {
   #data;
   #stream = null;
   #options;
-  constructor(stream, options) {
-    this.#data = stream;
+  constructor(stream2, options) {
+    this.#data = stream2;
     this.#options = options;
   }
-  static fromStreamObject(stream) {
+  static fromStreamObject(stream2) {
     const instance = new this(null, {
       type: "x/x"
     });
-    instance.#stream = stream;
+    instance.#stream = stream2;
     return instance;
   }
   get streamObject() {
@@ -127,96 +368,107 @@ class RequenceStream {
 }
 
 // ../helpers/src/files/index.ts
-var fileObjectSchema = z.object({
-  size: z.number().int().positive(),
-  mime: z.string(),
-  url: z.string().url(),
-  __REQUENCE_type: z.literal("RequenceFile")
+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;
 }
-var streamObjectSchema = z.object({
-  mime: z.string(),
-  url: z.string().url(),
-  __REQUENCE_type: z.literal("RequenceStream")
+var streamObjectSchema = z2.object({
+  mime: z2.string(),
+  url: z2.string().url(),
+  __REQUENCE_type: z2.literal("RequenceStream")
 });
+function toStreamObject(streamInfo) {
+  return {
+    ...streamInfo,
+    __REQUENCE_type: "RequenceStream"
+  };
+}
 function isStreamObject(data) {
   return streamObjectSchema.safeParse(data).success;
 }
 
 // src/createTask.ts
 import { EventSource } from "eventsource";
-import FormData from "form-data";
 
 // src/types.ts
-import { z as z2 } from "zod";
-var serviceNodeInfoSchema = z2.object({
-  id: z2.string().uuid(),
-  type: z2.literal("service"),
-  alias: z2.string().optional(),
-  service: z2.object({
-    id: z2.string().uuid(),
-    name: z2.string(),
-    version: z2.string()
+import { z as z3 } from "zod";
+var serviceNodeInfoSchema = z3.object({
+  id: z3.string().uuid(),
+  type: z3.literal("service"),
+  alias: z3.string().optional(),
+  service: z3.object({
+    id: z3.string().uuid(),
+    name: z3.string(),
+    version: z3.string()
   }).optional()
 });
-var logicNodeInfoSchema = z2.object({
-  id: z2.string().uuid(),
-  type: z2.literal("logic"),
-  alias: z2.string().optional(),
-  logic: z2.object({
-    language: z2.enum(["typescript", "javascript", "python"])
+var logicNodeInfoSchema = z3.object({
+  id: z3.string().uuid(),
+  type: z3.literal("logic"),
+  alias: z3.string().optional(),
+  logic: z3.object({
+    language: z3.enum(["typescript", "javascript", "python"])
   }).optional()
 });
-var nodeInfoSchema = z2.discriminatedUnion("type", [
+var nodeInfoSchema = z3.discriminatedUnion("type", [
   serviceNodeInfoSchema,
   logicNodeInfoSchema
 ]);
-var baseUpdate = z2.object({
-  timestamp: z2.coerce.date(),
-  taskId: z2.string().uuid()
+var baseUpdate = z3.object({
+  timestamp: z3.coerce.date(),
+  taskId: z3.string().uuid()
 });
 var taskStartUpdateSchema = baseUpdate.extend({
-  type: z2.literal("taskStart"),
-  input: z2.unknown(),
-  meta: z2.unknown()
+  type: z3.literal("taskStart"),
+  input: z3.unknown(),
+  meta: z3.unknown()
 });
 var taskErrorUpdateSchema = baseUpdate.extend({
-  type: z2.literal("taskError"),
-  error: z2.string()
+  type: z3.literal("taskError"),
+  error: z3.string()
 });
 var taskEndUpdateSchema = baseUpdate.extend({
-  type: z2.literal("taskEnd"),
-  result: z2.record(z2.string(), z2.unknown()),
-  partialResults: z2.array(z2.object({
+  type: z3.literal("taskEnd"),
+  result: z3.record(z3.string(), z3.unknown()),
+  partialResults: z3.array(z3.object({
     node: nodeInfoSchema,
-    timestamp: z2.coerce.date().nullable(),
-    data: z2.unknown(),
-    error: z2.string().optional()
+    timestamp: z3.coerce.date().nullable(),
+    data: z3.unknown(),
+    error: z3.string().optional()
   }))
 });
 var nodeStartUpdateSchema = baseUpdate.extend({
-  type: z2.literal("nodeStart"),
+  type: z3.literal("nodeStart"),
   node: nodeInfoSchema
 });
 var nodeUpdateUpdateSchema = baseUpdate.extend({
-  type: z2.literal("nodeUpdate"),
-  data: z2.unknown()
+  type: z3.literal("nodeUpdate"),
+  data: z3.unknown()
 });
 var nodeErrorUpdateSchema = baseUpdate.extend({
-  type: z2.literal("nodeError"),
-  error: z2.string()
+  type: z3.literal("nodeError"),
+  error: z3.string()
 });
 var nodeDeferUpdateSchema = baseUpdate.extend({
-  type: z2.literal("nodeDefer"),
-  reason: z2.string().optional()
+  type: z3.literal("nodeDefer"),
+  reason: z3.string().optional()
 });
 var nodeEndUpdateSchema = baseUpdate.extend({
-  type: z2.literal("nodeEnd"),
+  type: z3.literal("nodeEnd"),
   node: nodeInfoSchema
 });
-var updateSchema = z2.discriminatedUnion("type", [
+var updateSchema = z3.discriminatedUnion("type", [
   taskStartUpdateSchema,
   taskErrorUpdateSchema,
   taskEndUpdateSchema,
@@ -226,50 +478,7 @@ var updateSchema = z2.discriminatedUnion("type", [
   nodeDeferUpdateSchema,
   nodeEndUpdateSchema
 ]);
-var eventSchema = z2.object({ type: z2.string(), data: z2.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
-
-// src/utils/callbackToAsyncIterator.ts
-function callbackToAsyncIterator(options) {
-  const pullQueue = [];
-  const pushQueue = [];
-  const pushValue = (value) => {
-    if (pullQueue.length !== 0) {
-      const resolver = pullQueue.shift();
-      resolver(value);
-    } else {
-      pushQueue.push(value);
-    }
-  };
-  const pullValue = () => new Promise((resolve) => {
-    if (pushQueue.length !== 0) {
-      resolve(pushQueue.shift());
-    } else {
-      pullQueue.push(resolve);
-    }
-  });
-  return {
-    [Symbol.asyncIterator]() {
-      let done = false;
-      const unsubscribe = options.subscribe(pushValue);
-      return {
-        async next() {
-          if (done) {
-            return { value: undefined, done: true };
-          }
-          const value = await pullValue();
-          if (options.done) {
-            done = options.done(value);
-          }
-          return { value, done: false };
-        },
-        async return() {
-          unsubscribe?.();
-          return { value: undefined, done: true };
-        }
-      };
-    }
-  };
-}
+var eventSchema = z3.object({ type: z3.string(), data: z3.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
 
 // src/utils/getAccessToken.ts
 import { readFileSync } from "node:fs";
@@ -292,7 +501,7 @@ in your package.json in requence.accessToken`);
 }
 
 // src/utils/mapOutput.ts
-function mapOutput2(data) {
+function mapOutput3(data) {
   return mapData(data, {
     Object(obj) {
       if (isFileObject(obj)) {
@@ -316,7 +525,7 @@ class TaskError extends Error {
 function createTask(options, onUpdate) {
   const taskUpdateHandlers = new Set;
   const { apiBaseUrl, token } = getAccessToken(options.accessToken);
-  const startUrl = `${apiBaseUrl}/task/start/${options.taskTemplate}`;
+  const prepareUrl = `${apiBaseUrl}/task/prepare/${options.taskTemplate}`;
   const payloadPromise = createRemotePromise();
   let isMonitoring = false;
   const startMonitoring = async () => {
@@ -338,6 +547,12 @@ function createTask(options, onUpdate) {
         },
         getData(_alias) {
           return null;
+        },
+        getTaskId() {
+          return payload.taskId;
+        },
+        getTaskUrl() {
+          return "";
         }
       });
       return;
@@ -382,89 +597,100 @@ function createTask(options, onUpdate) {
           const getPartialResult = (alias) => update.partialResults.find((partialResult) => partialResult.node.alias === alias);
           resultPromise.resolve({
             getInput() {
-              return mapOutput2(input);
+              return mapOutput3(input);
             },
             getMeta() {
-              return mapOutput2(meta);
+              return mapOutput3(meta);
             },
             getError(alias) {
               return getPartialResult(alias)?.error ?? null;
             },
             getData(alias) {
               if (!alias) {
-                return mapOutput2(update.result);
+                return mapOutput3(update.result);
               }
-              return mapOutput2(getPartialResult(alias)?.data ?? null);
+              return mapOutput3(getPartialResult(alias)?.data ?? null);
+            },
+            getTaskId() {
+              return payload.taskId;
+            },
+            getTaskUrl() {
+              return payload.urls?.show ?? "";
             }
           });
         }
         if (update.type === "taskError") {
           resultPromise.reject(new TaskError(update.error, options.taskTemplate));
         }
-        taskUpdateHandlers.forEach((handler) => handler(update));
+        const extendedUpdate = update.type === "nodeUpdate" ? { type: "nodeUpdate", data: mapOutput3(update.data) } : update;
+        taskUpdateHandlers.forEach((handler) => handler(extendedUpdate));
       });
     });
   };
   const taskIdPromise = createRemotePromise();
   const resultPromise = createRemotePromise(startMonitoring);
   (async () => {
-    const formData = new FormData;
-    const walkData = async (data, path = []) => {
-      const name = path.map((segment, index) => index === 0 ? segment : typeof segment === "string" ? `.${segment}` : `[${segment}]`).join("");
-      if (data instanceof RequenceFile) {
-        formData.append(name, await data.blob(), name);
-      } else if (data instanceof RequenceStream) {
-        formData.append(name, data.stream(), name);
-      } else if (Array.isArray(data)) {
-        await Promise.all(data.map((item, index) => walkData(item, [...path, index])));
-      } else if (data && typeof data === "object") {
-        for (const [key, value] of Object.entries(data)) {
-          await walkData(value, [...path, key]);
-        }
-      } else if (typeof data !== "undefined") {
-        formData.append(name, `json://${JSON.stringify(data)}`);
+    const prepareResponse = await fetch(prepareUrl, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!prepareResponse.ok) {
+      const error = new TaskError(await prepareResponse.text(), options.taskTemplate);
+      taskIdPromise.reject(error);
+      resultPromise.reject(error);
+      return;
+    }
+    const prepareData = await prepareResponse.json();
+    const mappedParams = await mapOutput({
+      value: {
+        name: options.name,
+        input: options.input,
+        meta: options.meta
+      },
+      options: {
+        uploadUrl: prepareData.fileUrls?.uploadUrl,
+        streamUrl: prepareData.fileUrls?.streamUrl
       }
-    };
-    await walkData({
-      input: options.input ?? null,
-      meta: options.meta ?? null,
-      name: options.name ?? null
     });
-    console.log(formData);
-    const response = await fetch(startUrl, {
+    const finalizeResponse = await fetch(prepareData.finalizeUrl, {
       method: "POST",
-      body: formData,
+      body: JSON.stringify(mappedParams),
       headers: {
-        Authorization: `Bearer ${token}`
+        Authorization: `Bearer ${token}`,
+        "Content-Type": "application/json"
       }
     });
-    if (!response.ok) {
-      const error = new TaskError(await response.text(), options.taskTemplate);
+    if (!finalizeResponse.ok) {
+      const error = new TaskError(await prepareResponse.text(), options.taskTemplate);
       taskIdPromise.reject(error);
       resultPromise.reject(error);
       return;
     }
-    const payload = await response.json();
-    taskIdPromise.resolve(payload.id);
+    const payload = await finalizeResponse.json();
+    taskIdPromise.resolve(payload.taskId);
     payloadPromise.resolve(payload);
     if (onUpdate) {
       taskUpdateHandlers.add(onUpdate);
       startMonitoring();
     }
   })();
-  const asyncIterable = callbackToAsyncIterator({
-    subscribe: (push) => {
-      taskUpdateHandlers.add(push);
-      startMonitoring();
-      return () => {
-        taskUpdateHandlers.delete(push);
-      };
-    },
-    done: (value) => value.type === "taskError" || value.type === "taskEnd"
+  const asyncIterable = callbackToAsyncIterable((push, _fail, done) => {
+    taskUpdateHandlers.add(function handleUpdate(update) {
+      push(update);
+      if (update.type === "taskEnd" || update.type === "taskError") {
+        done();
+        taskUpdateHandlers.delete(handleUpdate);
+      }
+    });
+    startMonitoring();
   });
   return Object.assign(resultPromise.promise, asyncIterable, {
     getTaskId() {
       return taskIdPromise;
+    },
+    getTaskUrl() {
     }
   });
 }
@@ -486,13 +712,8 @@ function watchTasks(options) {
       }
     })
   });
-  const asyncIterable = callbackToAsyncIterator({
-    subscribe: (push) => {
-      taskUpdateHandlers.add(push);
-      return () => {
-        taskUpdateHandlers.delete(push);
-      };
-    }
+  const asyncIterable = callbackToAsyncIterable((push) => {
+    taskUpdateHandlers.add(push);
   });
   const taskEvents = [
     "taskStart",
@@ -511,7 +732,9 @@ function watchTasks(options) {
         eventSource.close();
         throw new Error("invalid update");
       }
-      taskUpdateHandlers.forEach((handler) => handler(updateResult.data));
+      const update = updateResult.data;
+      const extendedUpdate = update.type === "nodeUpdate" ? { type: "nodeUpdate", data: mapOutput3(update.data) } : update;
+      taskUpdateHandlers.forEach((handler) => handler(extendedUpdate));
     });
   });
   const stopWatching = () => {
@@ -526,5 +749,5 @@ export {
   RequenceFile
 };
 
-//# debugId=D795FF91B80A9C0364756E2164756E21
+//# debugId=17D151A31EA3238664756E2164756E21
 //# sourceMappingURL=index.js.map