@requence/service 1.0.0-alpha.49 → 1.0.0-alpha.50

package/build/index.js

@@ -6,12 +6,13 @@ import {
 // src/index.ts
 import fs from "node:fs";
 
-// ../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) {
@@ -110,12 +111,9 @@ function isCallbackObject(data) {
   return callbackObjectSchema.safeParse(data).success;
 }
 function createCallback(callback) {
-  let resolvePromise;
-  const promise = new Promise((resolve2) => {
-    resolvePromise = resolve2;
-  });
+  const { promise, resolve: resolve2 } = Promise.withResolvers();
   const executor = (arg) => {
-    resolvePromise(arg);
+    resolve2(arg);
     callback?.(arg);
   };
   return Object.assign(executor, {
@@ -125,110 +123,22 @@ function createCallback(callback) {
   });
 }
 
-// ../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
@@ -295,15 +205,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() {
@@ -352,11 +262,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;
@@ -368,22 +278,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
@@ -405,15 +403,14 @@ function resolveRequenceTypes(data, onCallback) {
   });
 }
 
-// src/index.ts
-import { z as z6 } from "zod/v4";
-
 // src/createAmqpConnection.ts
-import {
-  connect
-} from "amqp-connection-manager";
+import { connect } from "amqp-connection-manager";
 import { z as z5 } from "zod/v4";
 
+// src/errors.ts
+class RequenceConnectionError extends Error {
+}
+
 // src/helpers.ts
 import { AsyncLocalStorage } from "node:async_hooks";
 class RetryError extends Error {
@@ -430,22 +427,6 @@ class SkipError extends Error {
 class AbortError extends Error {
 }
 var OUTPUT_VALUE = Symbol("output_value");
-
-class PromiseChain {
-  chain = Promise.resolve();
-  add(createPromise) {
-    this.chain = this.chain.then(createPromise);
-  }
-  async done() {
-    while (true) {
-      const lastChainSegment = this.chain;
-      await lastChainSegment;
-      if (lastChainSegment === this.chain) {
-        break;
-      }
-    }
-  }
-}
 function isOutputValue(value) {
   return value !== null && typeof value === "object" && OUTPUT_VALUE in value;
 }
@@ -594,6 +575,18 @@ var backchannelMessageSchema = z5.object({
   messageId: message.properties.correlationId
 }));
 var abortSymbol = Symbol();
+var connectionOptionsSchema = z5.object({
+  url: z5.union([
+    z5.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
+    z5.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
+  ]),
+  version: z5.string(),
+  devOverlay: z5.string().optional(),
+  silent: z5.boolean().optional(),
+  prefetch: z5.number().int().optional(),
+  connectionTimeout: z5.number().positive().default(3000),
+  connectionOptions: z5.any()
+});
 function isMessageHandlerGenerator(handler) {
   return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
 }
@@ -604,9 +597,11 @@ function createConnection({
   prefetch = 1,
   silent = false,
   connectionTimeout,
-  connectionOptions
+  connectionOptions,
+  devOverlay = ""
 }, messageHandler) {
-  const queue = `${url.username}@${version}`;
+  const baseQueue = `${url.username}@${version}`;
+  const queue = devOverlay ? `${baseQueue}-dev-overlay-${devOverlay}` : baseQueue;
   const exchange = url.username;
   const connection = connect(url.toString(), { connectionOptions });
   const connectedPromise = new Promise((resolve2, reject) => {
@@ -616,7 +611,9 @@ function createConnection({
       connection.removeListener("connectFailed", handleConnectFailed);
     };
     const timeout = setTimeout(() => {
-      handleConnectFailed({ err: new Error("Requence connection timeout") });
+      handleConnectFailed({
+        err: new RequenceConnectionError("Requence connection timeout")
+      });
     }, connectionTimeout);
     const handleConnect = () => {
       unsubscribe();
@@ -625,7 +622,7 @@ function createConnection({
     const handleConnectFailed = ({ err }) => {
       unsubscribe();
       if (err.message.startsWith("Handshake terminated by server: 403 (ACCESS-REFUSED)")) {
-        reject(new Error("Invalid service credentials"));
+        reject(new RequenceConnectionError("Invalid service credentials"));
       } else {
         reject(err);
       }
@@ -634,9 +631,13 @@ function createConnection({
     connection.addListener("connectFailed", handleConnectFailed);
   });
   const connectionId = crypto.randomUUID();
-  const backchannelQueue = `${queue}-backchannel-${connectionId}`;
+  const backchannelQueue = `${baseQueue}-backchannel-${connectionId}`;
   const channelWrapper = connection.createChannel({
     async setup(channel) {
+      if (devOverlay) {
+        await channel.assertQueue(queue);
+        await channel.bindQueue(queue, "service", queue);
+      }
       await channel.checkExchange(exchange);
       await channel.checkExchange(`${exchange}-retry`);
       await channel.checkQueue(queue);
@@ -657,7 +658,7 @@ function createConnection({
     headers: {
       outputName: outputName ?? null,
       connectionId,
-      libVersion: "javascript@1.0.0-alpha.49",
+      libVersion: "javascript@1.0.0-alpha.50",
       ...headers
     }
   });
@@ -876,7 +877,7 @@ function createConnection({
             headers: {
               ...message.properties.headers,
               index: publishIndex++,
-              libVersion: "javascript@1.0.0-alpha.49",
+              libVersion: "javascript@1.0.0-alpha.50",
               abort: true
             }
           });
@@ -895,7 +896,7 @@ function createConnection({
               version,
               exception: true,
               index: publishIndex++,
-              libVersion: "javascript@1.0.0-alpha.49",
+              libVersion: "javascript@1.0.0-alpha.50",
               "error-message": error.message || "error in service handler"
             }
           });
@@ -993,7 +994,7 @@ function createConnection({
             contentType: "text/plain",
             headers: {
               taskId,
-              libVersion: "javascript@1.0.0-alpha.49",
+              libVersion: "javascript@1.0.0-alpha.50",
               index: publishIndex++,
               abort: true
             }
@@ -1108,17 +1109,13 @@ function asyncEventEmitter(initial = []) {
 }
 
 // src/index.ts
-var connectionOptionsSchema = z6.object({
-  url: z6.union([
-    z6.string().regex(/^amqps?:\/\/(.+):(.+)@(.+)$/).transform((str) => new URL(str)),
-    z6.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
-  ]),
-  version: z6.string(),
-  silent: z6.boolean().optional(),
-  prefetch: z6.number().int().optional(),
-  connectionTimeout: z6.number().positive().default(3000),
-  connectionOptions: z6.any()
-});
+var pkgJson;
+function loadPkgJson() {
+  if (!pkgJson) {
+    pkgJson = JSON.parse(fs.readFileSync("package.json", "utf-8"));
+  }
+  return pkgJson;
+}
 function createService(optionsOrVersion, optionalMessageHandler) {
   let options;
   let messageHandler;
@@ -1134,22 +1131,41 @@ function createService(optionsOrVersion, optionalMessageHandler) {
   let token = options.accessToken ?? process.env.REQUENCE_SERVICE_ACCESS_TOKEN ?? process.env.REQUENCE_ACCESS_TOKEN;
   if (!token) {
     try {
-      const pkgJson = JSON.parse(fs.readFileSync("package.json", "utf-8"));
-      token = pkgJson.requence?.service?.accessToken ?? pkgJson.requence?.accessToken;
+      const pkgJson2 = loadPkgJson();
+      token = pkgJson2.requence?.service?.accessToken ?? pkgJson2.requence?.accessToken;
+    } catch {}
+  }
+  let devToken = options.devToken ?? process.env.REQUENCE_SERVICE_DEV_TOKEN ?? process.env.REQUENCE_DEV_TOKEN;
+  if (!devToken) {
+    try {
+      const pkgJson2 = loadPkgJson();
+      devToken = pkgJson2.requence?.service?.devToken ?? pkgJson2.requence?.devToken;
     } catch {}
   }
   if (!token) {
-    throw new Error("No service key found");
+    throw new Error("no access token provided");
   }
   const parts = deobfuscate(token);
   if (parts.length < 2 || parts[0] !== "service") {
-    throw new Error("Invalid service key");
+    throw new Error("invalid access token");
   }
-  const connectionOptions = {
+  const url = parts[1];
+  let devOverlay;
+  if (devToken) {
+    const devParts = deobfuscate(devToken);
+    if (devParts[0] !== "api") {
+      throw new Error("invalid dev token: please provide a personal access token");
+    }
+    if (devParts[2] !== parts[2]) {
+      throw new Error("invalid dev token: access token and dev token belong to different requence instances");
+    }
+    devOverlay = devParts[1];
+  }
+  return createConnection(connectionOptionsSchema.parse({
     ...options,
-    url: parts[1]
-  };
-  return createConnection(connectionOptionsSchema.parse(connectionOptions), messageHandler);
+    url,
+    devOverlay
+  }), messageHandler);
 }
 export {
   wrapIterable,
@@ -1157,8 +1173,9 @@ export {
   createCallback,
   asyncEventEmitter,
   RequenceStream,
-  RequenceFile
+  RequenceFile,
+  RequenceConnectionError
 };
 
-//# debugId=101F6FA242E20D3464756E2164756E21
+//# debugId=57C0C865BD4C680C64756E2164756E21
 //# sourceMappingURL=index.js.map