wao 0.24.0 → 0.24.2

package/esm/signer.js

@@ -101,6 +101,12 @@ function hbEncodeValue(value) {
           // Escape quotes and backslashes
           const escaped = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
           return `"${escaped}"`
+        } else if (typeof v === "number") {
+          // Numbers should be encoded as bare items, not strings
+          return String(v)
+        } else if (typeof v === "boolean") {
+          // Booleans as structured field tokens
+          return v ? "?1" : "?0"
         }
         return `"${String(v)}"`
       })
@@ -137,17 +143,77 @@ function hbEncodeLift(obj, parent = "", top = {}) {
         )
       }
 
-      // first/second lift object
+      // Store the original value for reference
+      const originalValue = value
+
+      // first/second lift object - handle nested objects
       if (isPojo(value)) {
-        hbEncodeLift(value, storageKey, top)
+        // Check if this object has any nested objects or arrays with objects
+        const hasComplexValues = Object.values(value).some(
+          v => isPojo(v) || (Array.isArray(v) && v.some(item => isPojo(item)))
+        )
+
+        if (!hasComplexValues) {
+          // Simple flat object - can be encoded as structured field dictionary
+          const items = []
+
+          Object.entries(value).forEach(([k, v]) => {
+            const subKey = k.toLowerCase()
+
+            if (typeof v === "string") {
+              const escaped = v.replace(/\\/g, "\\\\").replace(/"/g, '\\"')
+              items.push(`${subKey}="${escaped}"`)
+            } else if (typeof v === "number") {
+              items.push(`${subKey}=${v}`)
+              if (Number.isInteger(v)) {
+                // Use URL-encoded forward slash separator
+                acc[1][`${key.toLowerCase()}%2f${subKey}`] = "integer"
+              } else {
+                acc[1][`${key.toLowerCase()}%2f${subKey}`] = "float"
+              }
+            } else if (typeof v === "boolean") {
+              items.push(`${subKey}=${v ? "?1" : "?0"}`)
+            } else if (Array.isArray(v) && !v.some(item => isPojo(item))) {
+              // Simple array (no objects) - encode as structured field inner list
+              const listItems = v.map(item => {
+                if (typeof item === "string") {
+                  return `"${item.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`
+                } else if (typeof item === "number") {
+                  return String(item)
+                } else if (typeof item === "boolean") {
+                  return item ? "?1" : "?0"
+                } else {
+                  return `"${String(item)}"`
+                }
+              })
+              items.push(`${subKey}=(${listItems.join(" ")})`)
+            }
+          })
+
+          const encodedValue = items.join(", ")
+          acc[0][key] = encodedValue
+          acc[1][key.toLowerCase()] = "map"
+        } else {
+          // Has nested objects - needs multipart encoding
+          hbEncodeLift(value, storageKey, top)
+          // Add the original object to flattened so it can be processed
+          acc[0][key] = value
+        }
+
         return acc
       }
 
       // leaf encode value
       const [type, encoded] = hbEncodeValue(value)
       if (encoded !== undefined) {
-        if (Buffer.from(String(encoded)).byteLength > MAX_HEADER_LENGTH) {
-          top[storageKey] = String(encoded)
+        // For binary data, check the byte length directly without converting to string
+        const byteLength = isBytes(encoded)
+          ? encoded.byteLength
+          : Buffer.from(String(encoded)).byteLength
+
+        if (byteLength > MAX_HEADER_LENGTH) {
+          // Store large values, but preserve binary data as-is
+          top[storageKey] = isBytes(encoded) ? encoded : String(encoded)
         } else {
           // Preserve the original key casing
           const httpKey = key
@@ -172,12 +238,14 @@ function hbEncodeLift(obj, parent = "", top = {}) {
   if (Object.keys(types).length > 0) {
     // Format as structured fields dictionary
     const aoTypeItems = Object.entries(types).map(([key, value]) => {
+      // The Erlang side expects keys with %2f for forward slashes
       const safeKey = key
         .toLowerCase()
         .replace(
-          /[^a-z0-9_-]/g,
+          /[^a-z0-9_\-.*\/]/g,
           c => "%" + c.charCodeAt(0).toString(16).padStart(2, "0")
         )
+        .replace(/\//g, "%2f") // Replace forward slashes AFTER other encoding
       return `${safeKey}="${value}"`
     })
     aoTypeItems.sort()
@@ -200,8 +268,14 @@ function hbEncodeLift(obj, parent = "", top = {}) {
   return top
 }
 
-function encodePart(name, { headers, body }) {
-  const parts = Object.entries(Object.fromEntries(headers)).reduce(
+function encodePart(name, { headers = {}, body }) {
+  // Convert headers to a plain object if it's a Headers instance
+  const headerEntries =
+    headers instanceof Headers
+      ? Array.from(headers.entries())
+      : Object.entries(headers || {})
+
+  const parts = headerEntries.reduce(
     (acc, [name, value]) => {
       acc.push(`${name}: `, value, "\r\n")
       return acc
@@ -215,7 +289,7 @@ function encodePart(name, { headers, body }) {
 }
 
 async function encode(obj = {}) {
-  if (Object.keys(obj).length === 0) return
+  if (Object.keys(obj).length === 0) return { headers: {}, body: undefined }
 
   // Keep reference to original object for data field
   const originalObj = obj
@@ -239,11 +313,22 @@ async function encode(obj = {}) {
       }
 
       // Check if this should be a body field
+      if (isBytes(value)) {
+        // Binary data should always go to body
+        bodyKeys.push(key)
+        flattened[key] = new Blob([
+          `content-disposition: form-data;name="${key}"\r\n\r\n`,
+          new Uint8Array(value.buffer || value),
+        ])
+        return
+      }
+
       const valueStr = String(value)
       if (
         (await hasNewline(valueStr)) ||
         key.includes("/") ||
-        Buffer.from(valueStr).byteLength > MAX_HEADER_LENGTH
+        Buffer.from(valueStr).byteLength > MAX_HEADER_LENGTH ||
+        (isPojo(value) && valueStr === "[object Object]") // Catch unencoded objects
       ) {
         bodyKeys.push(key)
         flattened[key] = new Blob([
@@ -276,37 +361,84 @@ async function encode(obj = {}) {
   }
 
   let body = undefined
+  let promoteToBody = true
   if (bodyKeys.length > 0) {
     if (bodyKeys.length === 1) {
       // If there is only one element, promote it to be the full body
       const bodyKey = bodyKeys[0]
-      body = new Blob([originalObj[bodyKey] || flattened[bodyKey]])
-      headers["inline-body-key"] = bodyKey
-    } else {
+      const originalValue = originalObj[bodyKey]
+      const flattenedValue = flattened[bodyKey]
+
+      // Only promote if it's not a complex object
+      if (
+        !isPojo(originalValue) ||
+        (isPojo(originalValue) && typeof flattenedValue === "string")
+      ) {
+        // For objects that were encoded as structured fields, use the encoded value
+        if (
+          (bodyKey === "body" || bodyKey === "data") &&
+          isPojo(originalValue) &&
+          typeof flattenedValue === "string"
+        ) {
+          body = new Blob([flattenedValue])
+        } else {
+          body = new Blob([originalValue || flattenedValue])
+        }
+        headers["inline-body-key"] = bodyKey
+      } else {
+        // Complex object - don't promote, create multipart
+        promoteToBody = false
+      }
+    }
+
+    if (!promoteToBody || bodyKeys.length > 1) {
       // Multiple body fields - create multipart
       const bodyParts = await Promise.all(
-        bodyKeys.map(name => {
+        bodyKeys.map(async name => {
           if (flattened[name] instanceof Blob) {
-            return flattened[name].arrayBuffer()
+            // The blob already has the content-disposition header
+            return flattened[name]
+          }
+          // For raw values, we need to create a proper multipart part
+          const value = originalObj[name] || flattened[name] || ""
+
+          // Special case: if this is a structured field encoded value, use the flattened value
+          if (
+            name === "body" &&
+            isPojo(originalObj[name]) &&
+            typeof flattened[name] === "string"
+          ) {
+            const partBlob = new Blob([
+              `content-disposition: form-data;name="${name}"\r\n\r\n`,
+              flattened[name],
+            ])
+            return partBlob
           }
-          // For raw values, create a blob
-          return new Blob([originalObj[name] || ""]).arrayBuffer()
+
+          const partBlob = new Blob([
+            `content-disposition: form-data;name="${name}"\r\n\r\n`,
+            value,
+          ])
+          return partBlob
         })
       )
 
-      const base = new Blob(
-        bodyParts.flatMap((p, i, arr) =>
-          i < arr.length - 1 ? [p, "\r\n"] : [p]
-        )
-      )
-      const hash = await sha256(await base.arrayBuffer())
+      // Calculate boundary from the content
+      const allPartsBuffer = await new Blob(bodyParts).arrayBuffer()
+      const hash = await sha256(allPartsBuffer)
       const boundary = base64url.encode(Buffer.from(hash))
 
-      const blobParts = bodyParts.flatMap(p => [`--${boundary}\r\n`, p, "\r\n"])
-      blobParts.push(`--${boundary}--`)
+      // Build the multipart body with proper boundaries
+      const finalParts = []
+      for (const part of bodyParts) {
+        finalParts.push(`--${boundary}\r\n`)
+        finalParts.push(part)
+        finalParts.push("\r\n")
+      }
+      finalParts.push(`--${boundary}--`)
 
       headers["content-type"] = `multipart/form-data; boundary="${boundary}"`
-      body = new Blob(blobParts)
+      body = new Blob(finalParts)
     }
 
     if (body) {
@@ -447,6 +579,12 @@ export function createRequest(config) {
     // Get all header keys for signing (lowercase)
     const signingFields = Object.keys(lowercaseHeaders)
 
+    // If there are no fields to sign, add at least the content-length
+    if (signingFields.length === 0 && !body) {
+      lowercaseHeaders["content-length"] = "0"
+      signingFields.push("content-length")
+    }
+
     // Sign the request with lowercase headers
     const signedRequest = await toHttpSigner(signer)({
       request: { url: _url, method, headers: lowercaseHeaders },
@@ -526,8 +664,15 @@ export async function send(signedMsg, fetchImpl = fetch) {
     throw new Error(`${response.status}: ${await response.text()}`)
   }
 
+  // Convert Headers object to plain object
+  let headers = {}
+  if (response.headers && typeof response.headers.forEach === "function") {
+    response.headers.forEach((v, k) => (headers[k] = v))
+  } else headers = response.headers
+
   return {
-    headers: response.headers,
+    response,
+    headers,
     body: await response.text(),
     status: response.status,
   }
@@ -573,7 +718,7 @@ function extractSignatureName(headers) {
  * @param {string} [signatureName] - Optional signature name to look for
  * @returns {Buffer|null} Public key buffer or null
  */
-function extractPublicKeyFromHeaders(headers, signatureName) {
+export function extractPublicKeyFromHeaders(headers, signatureName) {
   const signatureInput =
     headers["signature-input"] || headers["Signature-Input"]
   if (!signatureInput) return null

package/esm/utils.js

@@ -547,6 +547,7 @@ const toGraphObj = ({ query, variables }) => {
   if (fields) args.fields = fields
   if (args.sort && args.sort === "HEIGHT_ASC") args.asc = true
   delete args.sort
+  if (!Array.isArray(args.tags)) args.tags = [args.tags]
   if (args.tags) {
     let _tags = {}
     for (const v of args.tags) _tags[v.name] = v.values

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wao",
-  "version": "0.24.0",
+  "version": "0.24.2",
   "bin": {
     "wao": "./cjs/cli.js",
     "wao-esm": "./esm/cli.js"