@requence/task 1.0.0-alpha.44 → 1.0.0-alpha.46

package/build/index.js

@@ -49,12 +49,13 @@ function callbackToAsyncIterable(...args) {
   };
 }
 
-// ../helpers/src/utils/isRecord.ts
+// ../helpers/src/utils/guards.ts
 import { z } from "zod/v4";
 var recordSchema = z.record(z.string(), z.unknown());
 function isRecord(data) {
   return recordSchema.safeParse(data).success;
 }
+var uuidSchema = z.uuid();
 
 // ../helpers/src/utils/mapData.ts
 function resolve(value, onResolve) {
@@ -153,110 +154,22 @@ function isCallbackObject(data) {
   return callbackObjectSchema.safeParse(data).success;
 }
 
-// ../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];
+// ../helpers/src/files/fileObject.ts
+import { z as z3 } from "zod/v4";
+var fileObjectSchema = z3.object({
+  size: z3.int().positive(),
+  mime: z3.string(),
+  url: z3.url(),
+  __REQUENCE_type: z3.literal("RequenceFile")
+});
+function toFileObject(fileInfo) {
+  return {
+    ...fileInfo,
+    __REQUENCE_type: "RequenceFile"
+  };
 }
-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;
+function isFileObject(data) {
+  return fileObjectSchema.safeParse(data).success;
 }
 
 // ../helpers/src/files/RequenceFile.ts
@@ -323,15 +236,15 @@ class RequenceStream {
   #data;
   #stream = null;
   #options;
-  constructor(stream2, options) {
-    this.#data = stream2;
+  constructor(stream, options) {
+    this.#data = stream;
     this.#options = options;
   }
-  static fromStreamObject(stream2) {
+  static fromStreamObject(stream) {
     const instance = new this(null, {
       type: "x/x"
     });
-    instance.#stream = stream2;
+    instance.#stream = stream;
     return instance;
   }
   get streamObject() {
@@ -380,11 +293,11 @@ class RequenceStream {
 }
 
 // ../helpers/src/files/streamObject.ts
-import { z as z3 } from "zod/v4";
-var streamObjectSchema = z3.object({
-  mime: z3.string(),
-  url: z3.string().url(),
-  __REQUENCE_type: z3.literal("RequenceStream")
+import { z as z4 } from "zod/v4";
+var streamObjectSchema = z4.object({
+  mime: z4.string(),
+  url: z4.string().url(),
+  __REQUENCE_type: z4.literal("RequenceStream")
 });
 function isStreamObject(data) {
   return streamObjectSchema.safeParse(data).success;
@@ -396,22 +309,110 @@ function toStreamObject(streamInfo) {
   };
 }
 
-// ../helpers/src/files/fileObject.ts
-import { z as z4 } from "zod/v4";
-var fileObjectSchema = z4.object({
-  size: z4.int().positive(),
-  mime: z4.string(),
-  url: z4.url(),
-  __REQUENCE_type: z4.literal("RequenceFile")
-});
-function toFileObject(fileInfo) {
-  return {
-    ...fileInfo,
-    __REQUENCE_type: "RequenceFile"
-  };
+// ../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);
 }
-function isFileObject(data) {
-  return fileObjectSchema.safeParse(data).success;
+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/utils/resolveRequenceTypes.ts
@@ -434,6 +435,7 @@ function resolveRequenceTypes(data, onCallback) {
 }
 
 // src/createTask.ts
+import chalk from "chalk";
 import { createEventSource } from "eventsource-client";
 
 // src/utils/getAccessToken.ts
@@ -483,6 +485,28 @@ async function abortTask(options) {
   }
 }
 
+// src/protectTask.ts
+class TaskProtectError extends Error {
+  taskId;
+  constructor(message, taskId) {
+    super(message);
+    this.taskId = taskId;
+  }
+}
+async function protectTask(options) {
+  const { apiBaseUrl, token } = getAccessToken(options.accessToken);
+  const protectUrl = `${apiBaseUrl}/task/protect/${options.taskId}`;
+  const response = await fetch(protectUrl, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`
+    }
+  });
+  if (!response.ok) {
+    throw new TaskProtectError(await response.text(), options.taskId);
+  }
+}
+
 // src/types.ts
 import { z as z5 } from "zod/v4";
 var nodeInfoSchema = z5.object({
@@ -717,6 +741,9 @@ function createTask(options, onUpdate) {
       return;
     }
     const prepareData = await prepareResponse.json();
+    if (prepareData.branch !== "live" && !options.suppressBranchWarning) {
+      console.warn(chalk.hex("#eab308")("task is executed in", chalk.bold(prepareData.branch), "branch"));
+    }
     taskIdPromiseWithResolvers.resolve(prepareData.taskId);
     const mappedParams = await mapOutput({
       value: {
@@ -775,7 +802,6 @@ function createTask(options, onUpdate) {
       return resultPromiseWithResolvers.promise.finally.bind(resultPromiseWithResolvers.promise);
     },
     get then() {
-      console.log("THEN!");
       startMonitoring();
       return resultPromiseWithResolvers.promise.then.bind(resultPromiseWithResolvers.promise);
     },
@@ -794,6 +820,13 @@ function createTask(options, onUpdate) {
         accessToken: options.accessToken,
         reason
       });
+    },
+    async protect() {
+      const taskId = await taskIdPromiseWithResolvers.promise;
+      await protectTask({
+        taskId,
+        accessToken: options.accessToken
+      });
     }
   };
   return Object.defineProperties(asyncIterable, Object.getOwnPropertyDescriptors(methods));
@@ -935,7 +968,8 @@ var taskSchema = z6.object({
   taskTemplate: z6.string(),
   name: z6.string(),
   nodesData: z6.array(z6.object({ alias: z6.string(), data: z6.unknown() })),
-  nodesError: z6.array(z6.object({ alias: z6.string(), error: z6.string() }))
+  nodesError: z6.array(z6.object({ alias: z6.string(), error: z6.string() })),
+  branch: z6.union([z6.literal("live"), z6.string()])
 });
 async function getTask(taskIdOrOptions) {
   const taskId = typeof taskIdOrOptions === "string" ? taskIdOrOptions : taskIdOrOptions.taskId;
@@ -967,6 +1001,7 @@ async function getTask(taskIdOrOptions) {
     statusText: taskData.statusText,
     taskTemplate: taskData.taskTemplate,
     name: taskData.name,
+    branch: taskData.branch,
     context
   };
 }
@@ -984,6 +1019,7 @@ async function recreateTask(options, onUpdate) {
 export {
   watchTasks,
   recreateTask,
+  protectTask,
   getTask,
   createTask,
   abortTask,
@@ -992,5 +1028,5 @@ export {
   RequenceFile
 };
 
-//# debugId=ACFFAB2F3C0AA3BD64756E2164756E21
+//# debugId=A68A986E1DFD941B64756E2164756E21
 //# sourceMappingURL=index.js.map