fix(digest): return correct encoded string for latin1 encoding, validate with test.

Author: ElijahKotyluk

packages/graalvm/api/graalvm.api

@@ -4366,6 +4366,7 @@ public abstract interface class elide/runtime/intrinsics/js/node/ConsoleAPI : el
 }
 
 public abstract interface class elide/runtime/intrinsics/js/node/CryptoAPI : elide/runtime/intrinsics/js/node/NodeAPI {
+	public abstract fun createHash (Ljava/lang/String;)Lelide/runtime/node/crypto/NodeHash;
 	public abstract fun randomUUID (Lorg/graalvm/polyglot/Value;)Ljava/lang/String;
 	public static synthetic fun randomUUID$default (Lelide/runtime/intrinsics/js/node/CryptoAPI;Lorg/graalvm/polyglot/Value;ILjava/lang/Object;)Ljava/lang/String;
 }
@@ -8890,6 +8891,15 @@ public final synthetic class elide/runtime/node/crypto/$NodeCryptoModule$Introsp
 	public fun isBuildable ()Z
 }
 
+public final class elide/runtime/node/crypto/NodeHash {
+	public fun <init> (Ljava/lang/String;Ljava/security/MessageDigest;Z)V
+	public synthetic fun <init> (Ljava/lang/String;Ljava/security/MessageDigest;ZILkotlin/jvm/internal/DefaultConstructorMarker;)V
+	public final fun copy ()Lelide/runtime/node/crypto/NodeHash;
+	public final fun digest ()Ljava/lang/Object;
+	public final fun digest (Ljava/lang/String;)Ljava/lang/Object;
+	public final fun update (Ljava/lang/Object;)Lelide/runtime/node/crypto/NodeHash;
+}
+
 public synthetic class elide/runtime/node/dgram/$NodeDatagramModule$Definition : io/micronaut/context/AbstractInitializableBeanDefinitionAndReference {
 	public static final field $ANNOTATION_METADATA Lio/micronaut/core/annotation/AnnotationMetadata;
 	public fun <init> ()V

packages/graalvm/src/main/kotlin/elide/runtime/node/crypto/NodeCryptoHash.kt

@@ -62,8 +62,6 @@ public class NodeHash(
   public fun update(data: Any): NodeHash {
     if (digested) throw IllegalStateException("Digest already called")
 
-    // @TODO(elijahkotyluk) Remove debug line once tests are passing correctly.
-//    println("NodeHash.update called with data of type: ${data::class}, value: $data")
     val bytes = when (data) {
       is String -> data.toByteArray(Charsets.UTF_8)
       is ByteArray -> data
@@ -118,22 +116,20 @@ public class NodeHash(
    * - `null` or `"buffer"`: returns a [ByteArray]
    * - `"hex"`: returns a hexadecimal [String]
    * - `"base64"`: returns a Base64-encoded [String]
-   * - `"latin1"`: returns a Latin-1 encoded [String]
+   * - `"latin1"`: returns a ISO-8859-1 encoded [String]
    * @return The computed digest in the specified encoding.
    */
   private fun digestInternal(encoding: String? = null): Any {
-    if (digested) throw IllegalStateException("Digest already called")
+    if (digested) throw IllegalStateException("Digest has already been called on this Hash instance.")
     digested = true
     val result = md.digest()
 
     return when (encoding?.lowercase()) {
       null, "buffer" -> NodeHostBuffer.wrap(result)
       "hex" -> result.joinToString("") { "%02x".format(it) }
       "base64" -> Base64.getEncoder().encodeToString(result)
-      // @TODO(elijahkotyluk) take some time to test and validate this encoding
-      "latin1" -> result.decodeToString() // ISO-8859-1 is effectively Latin-1 in JVM
-      // @TODO(elijahkotyluk) better error messaging should be added here
-      else -> throw IllegalArgumentException("Unsupported encoding: $encoding")
+      "latin1" -> result.toString(Charsets.ISO_8859_1)
+      else -> throw IllegalArgumentException("Encoding: ${encoding} is not currently supported.")
     }
   }
 

packages/graalvm/src/test/kotlin/elide/runtime/node/NodeCryptoTest.kt

@@ -13,7 +13,10 @@
 package elide.runtime.node
 
 import org.graalvm.polyglot.Value
+import org.junit.jupiter.api.Assertions.assertArrayEquals
 import org.junit.jupiter.api.assertThrows
+import java.nio.charset.Charset
+import java.security.MessageDigest
 import kotlin.test.Test
 import kotlin.test.assertEquals
 import kotlin.test.assertIs
@@ -786,4 +789,97 @@ import elide.testing.annotations.TestCase
     );
     """
   }
+
+  @Test fun `digest should support base64, buffer, hex, and latin1 encodings when specified`() = conforms {
+    // Base64 encoding
+    val base64 = crypto.provide().createHash("sha256")
+    base64.update("hello world")
+    val base64Digest = base64.digest("base64")
+    assertEquals(
+      "uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=",
+      base64Digest,
+      "Base64 digest should match expected value"
+    )
+
+    // Buffer encoding
+    val buffer = crypto.provide().createHash("sha256")
+    buffer.update("hello world")
+    val bufferDigest = buffer.digest("buffer")
+    assertIs<NodeHostBuffer>(bufferDigest, "Buffer digest should be a NodeHostBuffer")
+    assertEquals(
+      "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+      bufferDigest.toString("hex", null, null),
+      "Buffer digest should match expected value"
+    )
+
+    // Hex encoding
+    val hex = crypto.provide().createHash("sha256")
+    hex.update("hello world")
+
+    val hexDigest = hex.digest("hex")
+    assertEquals(
+      "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+      hexDigest,
+      "Hex digest should match expected value"
+    )
+
+    // Latin1 encoding
+    val latin1 = crypto.provide().createHash("sha256")
+    latin1.update("hello world")
+    val latin1String = latin1.digest("latin1")
+
+    assertIs<String>(latin1String, "Latin1 digest should be a String")
+    val latin1Bytes = latin1String.toByteArray(Charset.forName("ISO-8859-1"))
+    val expectedLatin1Bytes = MessageDigest.getInstance("SHA-256")
+      .digest("hello world".toByteArray(Charsets.UTF_8))
+
+    assertArrayEquals(expectedLatin1Bytes, latin1Bytes)
+  }.guest {
+    //language=javascript
+    """
+    const crypto = require("crypto")
+    const assert = require("assert")
+    const { Buffer } = require("buffer");
+    
+    // Base64 encoding
+    const base64Digest = crypto.createHash("sha256").update("hello world").digest("base64");
+
+    assert.equal(
+      "uU0nuZNNPgilLlLX2n2r+sSE7+N6U4DukIj3rOLvzek=",
+      base64Digest,
+      "Base64 digest should match expected value"
+    );
+
+    // Buffer encoding
+    const bufferDigest = crypto.createHash("sha256").update("hello world").digest("buffer")
+    
+    assert.equal(Buffer.isBuffer(bufferDigest), true, "Default digest output should be a Buffer");
+    
+    const expectedBufferHex = "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9";
+    const actualBufferHex = bufferDigest.toString("hex");
+    
+    assert.equal(
+      expectedBufferHex,
+      actualBufferHex,
+      "Buffer digest should match expected value"
+    );
+
+    // Hex encoding
+    const hexDigest = crypto.createHash("sha256").update("hello world").digest("hex");
+
+    assert.equal(
+      "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9",
+      hexDigest,
+      "Hex digest should match expected value"
+    );
+    
+    // Latin1 encoding
+    const latin1Digest = crypto.createHash("sha256").update("hello world").digest("latin1");
+    
+    const actualLatin1ToHex = Buffer.from(latin1Digest, "latin1").toString("hex");
+    const expectedLatin1ToHex = "b94d27b9934d3e08a52e52d7da7dabfac484efe37a5380ee9088f7ace2efcde9";
+    
+    assert.strict(expectedLatin1ToHex, actualLatin1ToHex, "Latin1 digest bytes should match expected value");
+    """
+  }
 }