@requence/service 0.8.1 → 0.8.2-edge.1151

package/build/index.js

@@ -1,13 +1,19 @@
 import {
+  CAPABILITY_HEADER_KEYS,
   PayloadTooLargeError,
   RequenceConnectionError,
   RequenceUnreachableError,
+  UnsupportedCapabilityError,
   assertReachable,
+  buildServiceClientProperties,
+  buildServiceIdentityHeaders,
   deobfuscate,
   isUnreachableStatus,
   obfuscate,
-  reachableFetch
-} from "./chunk-8r349zge.js";
+  reachableFetch,
+  readRequiredCapabilities,
+  unsupportedCapabilities
+} from "./chunk-974rc2jy.js";
 
 // src/index.ts
 import fs from "node:fs";
@@ -185,6 +191,70 @@ function createCallback(callback) {
 // ../helpers/src/utils/amqpHeartbeat.ts
 var DEFAULT_AMQP_HEARTBEAT_SECONDS = 30;
 
+// ../helpers/src/msgpack/index.ts
+import { Buffer as Buffer2 } from "node:buffer";
+import { Packr, addExtension } from "msgpackr";
+var MSGPACK_EXTENSION_IDS = {
+  referenceCounter: 1,
+  nodeTree: 2,
+  url: 3
+};
+var packingForWire = false;
+addExtension({
+  Class: URL,
+  get type() {
+    return packingForWire ? undefined : MSGPACK_EXTENSION_IDS.url;
+  },
+  write: (v) => v.href,
+  read: (href) => new URL(href)
+});
+var packr = new Packr({ structuredClone: true });
+var wirePackr = new Packr({
+  useRecords: false,
+  structuredClone: false,
+  encodeUndefinedAsNil: true,
+  mapAsEmptyObject: true,
+  setAsEmptyObject: true,
+  int64AsType: "number"
+});
+function packWire(value) {
+  packingForWire = true;
+  try {
+    return wirePackr.pack(value);
+  } finally {
+    packingForWire = false;
+  }
+}
+function unpackWire(buffer) {
+  return wirePackr.unpack(buffer);
+}
+function wireByteLength(value) {
+  return wirePackr.pack(value).length;
+}
+var WIRE_CONTENT_TYPES = {
+  json: "application/json",
+  msgpack: "application/msgpack"
+};
+function wireCodecFromContentType(contentType) {
+  return contentType === WIRE_CONTENT_TYPES.msgpack ? "msgpack" : "json";
+}
+function encodeWireBody(value, codec) {
+  return {
+    body: codec === "msgpack" ? packWire(value) : Buffer2.from(JSON.stringify(value ?? null)),
+    contentType: WIRE_CONTENT_TYPES[codec]
+  };
+}
+function decodeWireBody(content, contentType) {
+  return wireCodecFromContentType(contentType) === "msgpack" ? unpackWire(content) : JSON.parse(Buffer2.from(content).toString());
+}
+function wireBodyByteLength(value, codec) {
+  if (codec === "msgpack") {
+    return wireByteLength(value);
+  }
+  const json = JSON.stringify(value);
+  return json === undefined ? 0 : Buffer2.byteLength(json);
+}
+
 // src/createAmqpConnection.ts
 import { connect } from "amqp-connection-manager";
 import { z as z6 } from "zod/v4";
@@ -697,7 +767,7 @@ function createRequenceStreamHandler() {
   };
 }
 // ../files/src/handlers/claimCheckHandler.ts
-import { Buffer as Buffer2 } from "node:buffer";
+import { Buffer as Buffer3 } from "node:buffer";
 var DEFAULT_MAX_PAYLOAD_SIZE = 4 * 1024 * 1024;
 function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -716,6 +786,29 @@ async function offload(ctx, uploadUrl, json) {
   }
   return toClaimCheckObject({ url: data.url, size: data.size });
 }
+function jsonByteLength(value) {
+  const json = JSON.stringify(value);
+  return json === undefined ? 0 : Buffer3.byteLength(json);
+}
+
+class UnserializableValue extends Error {
+}
+function toOffloadJson(value) {
+  try {
+    return JSON.stringify(value, function(key, encoded) {
+      const raw = this[key];
+      if (ArrayBuffer.isView(raw) || raw instanceof ArrayBuffer) {
+        throw new UnserializableValue;
+      }
+      return encoded;
+    });
+  } catch (error) {
+    if (error instanceof UnserializableValue) {
+      return;
+    }
+    throw error;
+  }
+}
 function createMessageHandler() {
   return {
     async wrapOutbound(body, ctx) {
@@ -723,8 +816,8 @@ function createMessageHandler() {
       if (maxBytes <= 0 || body === undefined) {
         return body;
       }
-      const json = JSON.stringify(body);
-      if (json === undefined || Buffer2.byteLength(json) <= maxBytes) {
+      const measure = ctx.measure ?? jsonByteLength;
+      if (measure(body) <= maxBytes) {
         return body;
       }
       const { uploadUrl } = ctx;
@@ -733,25 +826,29 @@ function createMessageHandler() {
         return body;
       }
       if (!isRecord2(body)) {
+        const json = toOffloadJson(body);
+        if (json === undefined) {
+          return body;
+        }
         return offload(ctx, uploadUrl, json);
       }
-      const entries = Object.entries(body).map(([key, value]) => {
-        const valueJson = JSON.stringify(value);
-        return {
-          key,
-          valueJson,
-          size: valueJson === undefined ? 0 : Buffer2.byteLength(valueJson)
-        };
-      }).sort((a, b) => b.size - a.size);
+      const entries = Object.entries(body).map(([key, value]) => ({
+        key,
+        valueJson: toOffloadJson(value),
+        size: measure(value)
+      })).sort((a, b) => b.size - a.size);
       const wrapped = { ...body };
-      let total = Buffer2.byteLength(json);
+      let total = measure(body);
       for (const entry of entries) {
-        if (total <= maxBytes || entry.valueJson === undefined || entry.size <= 256) {
+        if (total <= maxBytes || entry.size <= 256) {
           break;
         }
+        if (entry.valueJson === undefined) {
+          continue;
+        }
         const ref = await offload(ctx, uploadUrl, entry.valueJson);
         wrapped[entry.key] = ref;
-        total += Buffer2.byteLength(JSON.stringify(ref)) - entry.size;
+        total += measure(ref) - entry.size;
       }
       return wrapped;
     }
@@ -1015,6 +1112,8 @@ function createOutboundBoundary(base) {
   const warn = base.warn ?? ((message, error) => error === undefined ? console.warn(message) : console.warn(message, error));
   const ledger = [];
   const errors = [];
+  const codec = base.wireCodec ?? "json";
+  const measure = (value) => wireBodyByteLength(value, codec);
   const track = (promise) => {
     ledger.push(promise.then(() => {}, (error) => {
       errors.push(error instanceof Error ? error : new Error(String(error)));
@@ -1030,6 +1129,7 @@ function createOutboundBoundary(base) {
         streamUrl: base.streamUrl,
         maxPayloadSize: base.maxPayloadSize,
         maxFileSize: base.maxFileSize,
+        measure,
         outputName: opts.outputName ?? null,
         onCallback: opts.onCallback,
         ...opts.bestEffort ? {
@@ -1186,7 +1286,10 @@ var headerSchema = z6.object({
   taskId: msg.properties.headers.taskId,
   mode: msg.properties.headers.mode
 }));
-var payloadSchema = z6.object({ content: z6.instanceof(Buffer) }).transform((msg) => JSON.parse(msg.content.toString())).pipe(z6.object({
+var payloadSchema = z6.object({
+  content: z6.instanceof(Buffer),
+  properties: z6.object({ contentType: z6.string().optional() })
+}).transform((msg) => decodeWireBody(msg.content, msg.properties.contentType)).pipe(z6.object({
   input: z6.unknown(),
   configuration: z6.unknown(),
   options: z6.object({
@@ -1197,7 +1300,16 @@ var payloadSchema = z6.object({ content: z6.instanceof(Buffer) }).transform((msg
   })
 }));
 var backchannelMessageSchema = z6.object({
-  content: z6.instanceof(Buffer).transform((content) => JSON.parse(content.toString())).pipe(z6.discriminatedUnion("type", [
+  content: z6.instanceof(Buffer),
+  properties: z6.object({
+    correlationId: z6.string(),
+    contentType: z6.string().optional()
+  })
+}).transform((message) => ({
+  ...message,
+  content: decodeWireBody(message.content, message.properties.contentType)
+})).pipe(z6.object({
+  content: z6.discriminatedUnion("type", [
     z6.object({
       type: z6.literal("stop")
     }),
@@ -1206,11 +1318,11 @@ var backchannelMessageSchema = z6.object({
       callbackId: z6.uuid(),
       arg: z6.any()
     })
-  ])),
+  ]),
   properties: z6.object({
     correlationId: z6.string()
   })
-}).transform((message) => ({
+})).transform((message) => ({
   payload: message.content,
   messageId: message.properties.correlationId
 }));
@@ -1221,6 +1333,7 @@ var connectionOptionsSchema = z6.object({
     z6.instanceof(URL).refine((url) => url.protocol.match(/^amqps?:/), "Wrong protocol")
   ]),
   version: z6.string(),
+  name: z6.string().optional(),
   devOverlay: z6.string().optional(),
   silent: z6.boolean().optional(),
   prefetch: z6.number().int().optional(),
@@ -1234,6 +1347,7 @@ function isMessageHandlerGenerator(handler) {
   return handler.constructor.name === "GeneratorFunction" || handler.constructor.name === "AsyncGeneratorFunction";
 }
 var activeMessages = new Map;
+var messageCodecs = new Map;
 function isChannelClosedError(error) {
   return error instanceof Error && error.name === "IllegalOperationError";
 }
@@ -1263,8 +1377,10 @@ function createConnection({
   connectionTimeout,
   heartbeatInterval = DEFAULT_AMQP_HEARTBEAT_SECONDS,
   connectionOptions,
+  name,
   devOverlay = "",
   maxMessageSize,
+  onConnectionStateChange,
   ...rest
 }, messageHandler) {
   const passthroughByteReferences = rest.passthroughByteReferences ?? false;
@@ -1272,13 +1388,33 @@ function createConnection({
   const queue = devOverlay ? `${baseQueue}-dev-overlay-${devOverlay}` : baseQueue;
   const exchange = url.username;
   const connection = connect(url.toString(), {
-    connectionOptions,
+    connectionOptions: {
+      ...connectionOptions,
+      clientProperties: {
+        ...connectionOptions?.clientProperties,
+        ...buildServiceClientProperties({
+          libVersion: "javascript@0.8.2-edge.1151",
+          serviceVersion: version,
+          name,
+          devOverlay: Boolean(devOverlay)
+        })
+      }
+    },
     heartbeatIntervalInSeconds: heartbeatInterval
   });
   connection.on("disconnect", ({ err }) => {
     if (!silent && err) {
       console.error("Requence AMQP connection lost:", err.message);
     }
+    onConnectionStateChange?.({ connected: false, err });
+  });
+  let hasConnected = false;
+  connection.on("connect", () => {
+    if (hasConnected && !silent) {
+      console.info("Requence AMQP reconnected");
+    }
+    hasConnected = true;
+    onConnectionStateChange?.({ connected: true });
   });
   const connectedPromise = new Promise((resolve2, reject) => {
     const unsubscribe = () => {
@@ -1371,19 +1507,18 @@ function createConnection({
     priority,
     ...headers
   }) => {
-    const body = Buffer.from(JSON.stringify(data ?? null));
+    const { body, contentType } = encodeWireBody(data ?? null, messageCodecs.get(messageId) ?? "json");
     if (body.byteLength > maxMessageSize) {
       return Promise.reject(new PayloadTooLargeError(body.byteLength, maxMessageSize));
     }
     return channelWrapper.publish(exchange, "", body, {
       correlationId: messageId,
-      contentType: "application/json",
+      contentType,
       persistent: true,
       priority,
       headers: {
         outputName: outputName ?? null,
         connectionId,
-        libVersion: "javascript@0.8.1",
         ...headers
       }
     });
@@ -1454,6 +1589,12 @@ function createConnection({
       try {
         const { messageId, taskId, mode } = headerSchema.parse(message);
         messageIdForCleanup = messageId;
+        const unsupported = unsupportedCapabilities(readRequiredCapabilities(message.properties.headers));
+        if (unsupported.length > 0) {
+          throw new UnsupportedCapabilityError(unsupported);
+        }
+        const dispatchCodec = wireCodecFromContentType(message.properties.contentType);
+        messageCodecs.set(messageId, dispatchCodec);
         let deferred = false;
         let deferredReason = null;
         const messageExecution = Promise.withResolvers();
@@ -1480,6 +1621,7 @@ function createConnection({
           streamUrl: payload.options.streamUrl,
           maxPayloadSize: payload.options.maxPayloadSize,
           maxFileSize: payload.options.maxFileSize,
+          wireCodec: dispatchCodec,
           signal: abortController.signal,
           warn: (msg, error) => console.warn(`${msg} (task ${taskId})`, error instanceof Error ? error.message : error ?? "")
         });
@@ -1557,7 +1699,11 @@ function createConnection({
           taskId,
           priority: message.properties.priority,
           begin: true,
-          epoch
+          epoch,
+          ...buildServiceIdentityHeaders({
+            libVersion: "javascript@0.8.2-edge.1151",
+            name
+          })
         });
         if (isMessageHandlerGenerator(messageHandler)) {
           if (mode === "CONTINUOUS") {
@@ -1693,6 +1839,29 @@ function createConnection({
           });
           return;
         }
+        if (error instanceof UnsupportedCapabilityError) {
+          if (!silent) {
+            console.error(error.message);
+          }
+          if (!acked) {
+            safeAck(channel, message);
+          }
+          channelWrapper.publish(`${exchange}-retry`, "operator", message.content, {
+            ...message.properties,
+            headers: {
+              ...message.properties.headers,
+              version,
+              [CAPABILITY_HEADER_KEYS.mismatch]: true,
+              index: publishIndex++,
+              "error-message": error.message
+            }
+          }).catch((publishError) => {
+            if (!silent) {
+              console.error("Failed to publish capability mismatch message:", publishError);
+            }
+          });
+          return;
+        }
         if (error instanceof AbortError && error.message.length > 0) {
           if (!acked) {
             safeAck(channel, message);
@@ -1703,7 +1872,6 @@ function createConnection({
             headers: {
               ...message.properties.headers,
               index: publishIndex++,
-              libVersion: "javascript@0.8.1",
               abort: true
             }
           }).catch((publishError) => {
@@ -1734,7 +1902,6 @@ function createConnection({
               version,
               exception: true,
               index: publishIndex++,
-              libVersion: "javascript@0.8.1",
               "error-message": error.message || "error in service handler"
             }
           }).catch((publishError) => {
@@ -1747,6 +1914,7 @@ function createConnection({
       } finally {
         if (messageIdForCleanup) {
           generatorTerminators.delete(messageIdForCleanup);
+          messageCodecs.delete(messageIdForCleanup);
         }
         registeredCallbackIds.forEach((id) => callbacks.delete(id));
         resolveActiveMessage();
@@ -1818,7 +1986,6 @@ function createConnection({
             contentType: "text/plain",
             headers: {
               taskId,
-              libVersion: "javascript@0.8.1",
               index: publishIndex++,
               abort: true
             }
@@ -2017,13 +2184,16 @@ function createService(optionsOrVersion, optionalMessageHandler) {
     devOverlay = devParts[1];
   }
   const envMaxMessageSize = process.env.REQUENCE_MAX_MESSAGE_SIZE ? Number(process.env.REQUENCE_MAX_MESSAGE_SIZE) : undefined;
-  return createConnection(connectionOptionsSchema.parse({
-    ...options,
-    connectionOptions: resolveConnectionOptions(options.connectionOptions),
-    maxMessageSize: options.maxMessageSize ?? envMaxMessageSize,
-    url,
-    devOverlay
-  }), messageHandler);
+  return createConnection({
+    ...connectionOptionsSchema.parse({
+      ...options,
+      connectionOptions: resolveConnectionOptions(options.connectionOptions),
+      maxMessageSize: options.maxMessageSize ?? envMaxMessageSize,
+      url,
+      devOverlay
+    }),
+    onConnectionStateChange: options.onConnectionStateChange
+  }, messageHandler);
 }
 export {
   wrapIterable,
@@ -2033,6 +2203,7 @@ export {
   createCallback,
   asyncEventEmitter,
   assertReachable,
+  UnsupportedCapabilityError,
   RequenceUnreachableError,
   RequenceStream,
   RequenceFile,
@@ -2040,5 +2211,5 @@ export {
   PayloadTooLargeError
 };
 
-//# debugId=06D2FC35693704C864756E2164756E21
+//# debugId=886A241C6AA974E564756E2164756E21
 //# sourceMappingURL=index.js.map