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

package/build/index.js

@@ -1,88 +1,232 @@
 import {
   createRemotePromise,
-  deobfuscate
-} from "./chunk-s4kgf465.js";
+  deobfuscate,
+  mapData
+} from "./chunk-ajdmm777.js";
 
-// src/index.ts
-import { readFileSync } from "node:fs";
+// ../helpers/src/files/index.ts
+import { z } from "zod";
+
+// ../helpers/src/files/RequenceFile.ts
+class RequenceFile {
+  #data;
+  #file = null;
+  constructor(blobParts, options) {
+    this.#data = new Blob(blobParts, options);
+  }
+  static fromFileObject(file) {
+    const instance = new this([], { type: "x/x" });
+    instance.#file = file;
+    return instance;
+  }
+  get fileObject() {
+    return this.#file;
+  }
+  get size() {
+    return this.#file?.size ?? this.#data.size;
+  }
+  get mimeType() {
+    return this.#file?.mime ?? this.#data.type;
+  }
+  get mainMimeType() {
+    return this.mimeType.split("/")[0];
+  }
+  get subMimeType() {
+    return this.mimeType.split("/")[1];
+  }
+  async text() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.text());
+    }
+    return this.#data.text();
+  }
+  async json() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.json());
+    }
+    return JSON.parse(await this.text());
+  }
+  async blob() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.blob());
+    }
+    return this.#data;
+  }
+  async arrayBuffer() {
+    if (this.#file) {
+      return fetch(this.#file.url).then((response) => response.arrayBuffer());
+    }
+    return this.#data.arrayBuffer();
+  }
+  toString() {
+    return `RequenceFile<${this.mimeType}>`;
+  }
+  toJSON() {
+    return `RequenceFile<${this.mimeType}>`;
+  }
+}
+// ../helpers/src/files/RequenceStream.ts
+class RequenceStream {
+  #data;
+  #stream = null;
+  #options;
+  constructor(stream, options) {
+    this.#data = stream;
+    this.#options = options;
+  }
+  static fromStreamObject(stream) {
+    const instance = new this(null, {
+      type: "x/x"
+    });
+    instance.#stream = stream;
+    return instance;
+  }
+  get streamObject() {
+    return this.#stream;
+  }
+  get mimeType() {
+    return this.#stream?.mime ?? this.#options.type;
+  }
+  get mainMimeType() {
+    return this.mimeType.split("/")[0];
+  }
+  get subMimeType() {
+    return this.mimeType.split("/")[1];
+  }
+  stream() {
+    if (this.#stream) {
+      const { readable, writable } = new TransformStream;
+      fetch(this.#stream.url).then((response) => response.body?.pipeTo(writable));
+      return readable;
+    }
+    return this.#data;
+  }
+  asyncIterable() {
+    const reader = this.stream().getReader();
+    return {
+      [Symbol.asyncIterator]() {
+        return {
+          async next() {
+            return reader.read();
+          },
+          async return() {
+            reader.cancel();
+            reader.releaseLock();
+            return { done: true, value: null };
+          }
+        };
+      }
+    };
+  }
+  toString() {
+    return `RequenceStream<${this.mimeType}>`;
+  }
+  toJSON() {
+    return `RequenceStream<${this.mimeType}>`;
+  }
+}
+
+// ../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")
+});
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
+}
+var streamObjectSchema = z.object({
+  mime: z.string(),
+  url: z.string().url(),
+  __REQUENCE_type: z.literal("RequenceStream")
+});
+function isStreamObject(data) {
+  return streamObjectSchema.safeParse(data).success;
+}
+
+// src/createTask.ts
 import { EventSource } from "eventsource";
-import { z as z2 } from "zod";
+import FormData from "form-data";
 
 // src/types.ts
-import { z } from "zod";
-var serviceNodeInfoSchema = z.object({
-  id: z.string().uuid(),
-  type: z.literal("service"),
-  alias: z.string().optional(),
-  service: z.object({
-    id: z.string().uuid(),
-    name: z.string(),
-    version: z.string()
+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()
   }).optional()
 });
-var logicNodeInfoSchema = z.object({
-  id: z.string().uuid(),
-  type: z.literal("logic"),
-  alias: z.string().optional(),
-  logic: z.object({
-    language: z.enum(["typescript", "javascript", "python"])
+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"])
   }).optional()
 });
-var nodeInfoSchema = z.discriminatedUnion("type", [
+var nodeInfoSchema = z2.discriminatedUnion("type", [
   serviceNodeInfoSchema,
   logicNodeInfoSchema
 ]);
-var taskStartUpdateSchema = z.object({
-  type: z.literal("taskStart"),
-  timestamp: z.coerce.date(),
-  input: z.unknown(),
-  meta: z.unknown()
+var baseUpdate = z2.object({
+  timestamp: z2.coerce.date(),
+  taskId: z2.string().uuid()
+});
+var taskStartUpdateSchema = baseUpdate.extend({
+  type: z2.literal("taskStart"),
+  input: z2.unknown(),
+  meta: z2.unknown()
 });
-var taskErrorUpdateSchema = z.object({
-  type: z.literal("taskError"),
-  timestamp: z.coerce.date(),
-  error: z.string()
+var taskErrorUpdateSchema = baseUpdate.extend({
+  type: z2.literal("taskError"),
+  error: z2.string()
 });
-var taskEndUpdateSchema = z.object({
-  type: z.literal("taskEnd"),
-  timestamp: z.coerce.date(),
-  result: z.record(z.string(), z.unknown()),
-  partialResults: z.array(z.object({
+var taskEndUpdateSchema = baseUpdate.extend({
+  type: z2.literal("taskEnd"),
+  result: z2.record(z2.string(), z2.unknown()),
+  partialResults: z2.array(z2.object({
     node: nodeInfoSchema,
-    timestamp: z.coerce.date().nullable(),
-    data: z.unknown(),
-    error: z.string().optional()
+    timestamp: z2.coerce.date().nullable(),
+    data: z2.unknown(),
+    error: z2.string().optional()
   }))
 });
-var nodeStartUpdateSchema = z.object({
-  type: z.literal("nodeStart"),
-  timestamp: z.coerce.date(),
+var nodeStartUpdateSchema = baseUpdate.extend({
+  type: z2.literal("nodeStart"),
   node: nodeInfoSchema
 });
-var nodeUpdateUpdateSchema = z.object({
-  type: z.literal("nodeUpdate"),
-  timestamp: z.coerce.date(),
-  data: z.unknown()
+var nodeUpdateUpdateSchema = baseUpdate.extend({
+  type: z2.literal("nodeUpdate"),
+  data: z2.unknown()
 });
-var nodeErrorUpdateSchema = z.object({
-  type: z.literal("nodeError"),
-  timestamp: z.coerce.date(),
-  error: z.string()
+var nodeErrorUpdateSchema = baseUpdate.extend({
+  type: z2.literal("nodeError"),
+  error: z2.string()
 });
-var nodeDeferUpdateSchema = z.object({
-  type: z.literal("nodeDefer"),
-  timestamp: z.coerce.date(),
-  reason: z.string().optional()
+var nodeDeferUpdateSchema = baseUpdate.extend({
+  type: z2.literal("nodeDefer"),
+  reason: z2.string().optional()
 });
-var updateSchema = z.discriminatedUnion("type", [
+var nodeEndUpdateSchema = baseUpdate.extend({
+  type: z2.literal("nodeEnd"),
+  node: nodeInfoSchema
+});
+var updateSchema = z2.discriminatedUnion("type", [
   taskStartUpdateSchema,
   taskErrorUpdateSchema,
   taskEndUpdateSchema,
   nodeStartUpdateSchema,
   nodeUpdateUpdateSchema,
   nodeErrorUpdateSchema,
-  nodeDeferUpdateSchema
+  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) {
@@ -113,7 +257,9 @@ function callbackToAsyncIterator(options) {
             return { value: undefined, done: true };
           }
           const value = await pullValue();
-          done = options.done(value);
+          if (options.done) {
+            done = options.done(value);
+          }
           return { value, done: false };
         },
         async return() {
@@ -125,30 +271,52 @@ function callbackToAsyncIterator(options) {
   };
 }
 
-// src/index.ts
-class TaskError extends Error {
-  taskTemplate;
-  constructor(message, taskTemplate) {
-    super(message);
-    this.taskTemplate = taskTemplate;
-  }
-}
-var eventSchema = z2.object({ type: z2.string(), data: z2.string() }).transform((event) => ({ type: event.type, ...JSON.parse(event.data) })).pipe(updateSchema);
-function createTask(params, onUpdate) {
-  const taskUpdateHandlers = new Set;
-  const accessKey = params.accessToken ?? process.env.REQUENCE_ACCESS_TOKEN ?? JSON.parse(readFileSync("package.json", "utf-8")).requence?.accessToken;
-  if (!accessKey) {
+// src/utils/getAccessToken.ts
+import { readFileSync } from "node:fs";
+function getAccessToken(accessToken) {
+  const token = accessToken ?? process.env.REQUENCE_ACCESS_TOKEN ?? JSON.parse(readFileSync("package.json", "utf-8")).requence?.accessToken;
+  if (!token) {
     throw new Error(`No access token found
 You can provide the access token as argument to createTask,
 as environment variable REQUENCE_ACCESS_TOKEN or
 in your package.json in requence.accessToken`);
   }
-  const parts = deobfuscate(accessKey);
+  const parts = deobfuscate(token);
   if (parts.length < 2 || parts[0] !== "api") {
     throw new Error("Invalid api key");
   }
-  const [, token, apiBaseUrl] = parts;
-  const startUrl = `${apiBaseUrl}/task/start/${params.taskTemplate}`;
+  return {
+    token: parts[1],
+    apiBaseUrl: parts[2]
+  };
+}
+
+// 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);
+      }
+    }
+  });
+}
+
+// src/createTask.ts
+class TaskError extends Error {
+  taskTemplate;
+  constructor(message, taskTemplate) {
+    super(message);
+    this.taskTemplate = taskTemplate;
+  }
+}
+function createTask(options, onUpdate) {
+  const taskUpdateHandlers = new Set;
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const startUrl = `${apiBaseUrl}/task/start/${options.taskTemplate}`;
   const payloadPromise = createRemotePromise();
   let isMonitoring = false;
   const startMonitoring = async () => {
@@ -157,6 +325,23 @@ in your package.json in requence.accessToken`);
     }
     isMonitoring = true;
     const payload = await payloadPromise;
+    if (!payload.urls) {
+      resultPromise.resolve({
+        getInput() {
+          return input;
+        },
+        getMeta() {
+          return meta;
+        },
+        getError(_alias) {
+          return null;
+        },
+        getData(_alias) {
+          return null;
+        }
+      });
+      return;
+    }
     const eventSource = new EventSource(payload.urls.watch, {
       fetch: (input2, init) => fetch(input2, {
         ...init,
@@ -172,7 +357,8 @@ in your package.json in requence.accessToken`);
       "nodeStart",
       "nodeUpdate",
       "nodeDefer",
-      "nodeError"
+      "nodeError",
+      "nodeEnd"
     ];
     let input = null;
     let meta = null;
@@ -181,11 +367,10 @@ in your package.json in requence.accessToken`);
         const updateResult = eventSchema.safeParse(event);
         if (!updateResult.success) {
           eventSource.close();
-          resultPromise.reject(new TaskError(`Invalid ${taskEvent} update received`, params.taskTemplate));
+          resultPromise.reject(new TaskError(`Invalid ${taskEvent} update received`, options.taskTemplate));
           return;
         }
         const update = updateResult.data;
-        taskUpdateHandlers.forEach((handler) => handler(update));
         if (update.type === "taskEnd" || update.type === "taskError") {
           eventSource.close();
         }
@@ -197,42 +382,64 @@ in your package.json in requence.accessToken`);
           const getPartialResult = (alias) => update.partialResults.find((partialResult) => partialResult.node.alias === alias);
           resultPromise.resolve({
             getInput() {
-              return input;
+              return mapOutput2(input);
             },
             getMeta() {
-              return meta;
+              return mapOutput2(meta);
             },
             getError(alias) {
               return getPartialResult(alias)?.error ?? null;
             },
             getData(alias) {
               if (!alias) {
-                return update.result;
+                return mapOutput2(update.result);
               }
-              return getPartialResult(alias)?.data ?? null;
+              return mapOutput2(getPartialResult(alias)?.data ?? null);
             }
           });
         }
         if (update.type === "taskError") {
-          resultPromise.reject(new TaskError(update.error, params.taskTemplate));
+          resultPromise.reject(new TaskError(update.error, options.taskTemplate));
         }
+        taskUpdateHandlers.forEach((handler) => handler(update));
       });
     });
   };
   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)}`);
+      }
+    };
+    await walkData({
+      input: options.input ?? null,
+      meta: options.meta ?? null,
+      name: options.name ?? null
+    });
+    console.log(formData);
     const response = await fetch(startUrl, {
-      method: "post",
+      method: "POST",
+      body: formData,
       headers: {
-        Accept: "application/json",
-        "Content-Type": "application/json",
         Authorization: `Bearer ${token}`
-      },
-      body: JSON.stringify({ input: params.input, meta: params.meta })
+      }
     });
     if (!response.ok) {
-      const error = new TaskError(await response.text(), params.taskTemplate);
+      const error = new TaskError(await response.text(), options.taskTemplate);
       taskIdPromise.reject(error);
       resultPromise.reject(error);
       return;
@@ -249,6 +456,9 @@ in your package.json in requence.accessToken`);
     subscribe: (push) => {
       taskUpdateHandlers.add(push);
       startMonitoring();
+      return () => {
+        taskUpdateHandlers.delete(push);
+      };
     },
     done: (value) => value.type === "taskError" || value.type === "taskEnd"
   });
@@ -258,10 +468,63 @@ in your package.json in requence.accessToken`);
     }
   });
 }
+// src/watchTasks.ts
+import { EventSource as EventSource2 } from "eventsource";
+function watchTasks(options) {
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const taskUpdateHandlers = new Set;
+  if (options.onUpdate) {
+    taskUpdateHandlers.add(options.onUpdate);
+  }
+  const watchUrl = new URL(`${apiBaseUrl}/task/watch-all`);
+  watchUrl.searchParams.set("since", options.since.toISOString());
+  const eventSource = new EventSource2(watchUrl, {
+    fetch: (input, init) => fetch(input, {
+      ...init,
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    })
+  });
+  const asyncIterable = callbackToAsyncIterator({
+    subscribe: (push) => {
+      taskUpdateHandlers.add(push);
+      return () => {
+        taskUpdateHandlers.delete(push);
+      };
+    }
+  });
+  const taskEvents = [
+    "taskStart",
+    "taskError",
+    "taskEnd",
+    "nodeStart",
+    "nodeUpdate",
+    "nodeDefer",
+    "nodeError",
+    "nodeEnd"
+  ];
+  taskEvents.forEach((taskEvent) => {
+    eventSource.addEventListener(taskEvent, (event) => {
+      const updateResult = eventSchema.safeParse(event);
+      if (!updateResult.success) {
+        eventSource.close();
+        throw new Error("invalid update");
+      }
+      taskUpdateHandlers.forEach((handler) => handler(updateResult.data));
+    });
+  });
+  const stopWatching = () => {
+    eventSource.close();
+  };
+  return Object.assign(stopWatching, asyncIterable);
+}
 export {
+  watchTasks,
   createTask,
-  TaskError
+  RequenceStream,
+  RequenceFile
 };
 
-//# debugId=A9D3BA4F308FA87164756E2164756E21
+//# debugId=D795FF91B80A9C0364756E2164756E21
 //# sourceMappingURL=index.js.map