Merge pull request #129 from godaddy/use-go-warmup-library

Add Bun runtime support via Go warmup library

Author: jgowdy-godaddy

.asherah-version

@@ -1 +1 @@
-ASHERAH_VERSION=v0.4.33
+ASHERAH_VERSION=v0.4.36

.github/workflows/test.yml

@@ -30,9 +30,15 @@ jobs:
       options: --ulimit core=-1 --ulimit memlock=-1:-1
     steps:
     - uses: actions/checkout@v4
+    - name: Install Bun
+      run: |
+        curl -fsSL https://bun.sh/install | bash
+        export PATH="$HOME/.bun/bin:$PATH"
+        echo "PATH=$HOME/.bun/bin:$PATH" >> $GITHUB_ENV
+        bun --version
     - name: Install npm packages
       run: npm install
-    - name: Unit Test
+    - name: Unit Test (includes Bun test via posttest)
       run: npm test
     - name: Initialize RDBMS based metastore
       run: |

package.json

@@ -16,8 +16,9 @@
     "test:mocha-debug": "lldb -o run -- node node_modules/mocha/bin/mocha --inspect-brk",
     "test:mocha": "mocha",
     "test": "nyc npm run test:mocha",
+    "test:bun": "bun test/bun-test.js",
     "debug": "nyc npm run test:mocha-debug",
-    "posttest": "npm run lint",
+    "posttest": "npm run lint && npm run test:bun",
     "lint": "eslint src/**.ts --fix",
     "update": "npx npm-check-updates --target latest -u -x mocha && npm i && npm audit fix"
   },

scripts/download-libraries.sh

@@ -71,7 +71,8 @@ function download_file {
 function verify_checksums {
   local archive=$1
   local header=$2
-  local sums=$3
+  local warmup=$3
+  local sums=$4
 
   # Determine the available SHA hashing utility
   if command -v sha256sum &> /dev/null; then
@@ -90,9 +91,9 @@ function verify_checksums {
   fi
 
   # Filter the relevant checksums and verify they are not empty
-  checksums=$(grep -e "${archive}" -e "${header}" "${sums}")
+  checksums=$(grep -e "${archive}" -e "${header}" -e "${warmup}" "${sums}")
   if [[ -z "$checksums" ]]; then
-    echo "Error: No matching checksums found for ${archive} or ${header} in ${sums}." >&2
+    echo "Error: No matching checksums found for ${archive}, ${header}, or ${warmup} in ${sums}." >&2
     return 1
   fi
 
@@ -144,11 +145,13 @@ function detect_os_and_cpu {
       #echo "Using Asherah libraries for Linux x86_64"
       ARCHIVE="libasherah-x64.a"
       HEADER="libasherah-x64-archive.h"
+      WARMUP="go-warmup-linux-x64.so"
       SUMS="SHA256SUMS"
     elif [[ ${MACHINE} == 'aarch64' ]]; then
       #echo "Using Asherah libraries for Linux aarch64"
       ARCHIVE="libasherah-arm64.a"
       HEADER="libasherah-arm64-archive.h"
+      WARMUP="go-warmup-linux-arm64.so"
       SUMS="SHA256SUMS"
     else
       #echo "Unsupported CPU architecture: ${MACHINE}" >&2
@@ -159,11 +162,13 @@ function detect_os_and_cpu {
       #echo "Using Asherah libraries for MacOS x86_64"
       ARCHIVE="libasherah-darwin-x64.a"
       HEADER="libasherah-darwin-x64-archive.h"
+      WARMUP="go-warmup-darwin-x64.dylib"
       SUMS="SHA256SUMS-darwin"
     elif [[ ${MACHINE} == 'arm64' ]]; then
       #echo "Using Asherah libraries for MacOS arm64"
       ARCHIVE="libasherah-darwin-arm64.a"
       HEADER="libasherah-darwin-arm64-archive.h"
+      WARMUP="go-warmup-darwin-arm64.dylib"
       SUMS="SHA256SUMS-darwin"
     else
       echo "Unsupported CPU architecture: ${MACHINE}" >&2
@@ -174,7 +179,7 @@ function detect_os_and_cpu {
     exit 1
   fi
 
-  echo "${ARCHIVE}" "${HEADER}" "${SUMS}"  # Return value
+  echo "${ARCHIVE}" "${HEADER}" "${WARMUP}" "${SUMS}"  # Return value
 }
 
 # Parse script arguments
@@ -216,18 +221,20 @@ function main {
   no_cache=$(parse_args "$@")
 
   # Detect OS and CPU architecture
-  read -r archive header sums < <(detect_os_and_cpu)
+  read -r archive header warmup sums < <(detect_os_and_cpu)
   echo "Archive: $archive"
   echo "Header: $header"
+  echo "Warmup: $warmup"
   echo "Sums: $sums"
   echo "Version: $ASHERAH_VERSION"
 
   # Interpolate the URLs
   url_prefix="https://github.com/godaddy/asherah-cobhan/releases/download/${ASHERAH_VERSION}"
-  file_names=("${archive}" "${header}" "${sums}")
+  file_names=("${archive}" "${header}" "${warmup}" "${sums}")
   file_urls=(
     "${url_prefix}/${archive}"
     "${url_prefix}/${header}"
+    "${url_prefix}/${warmup}"
     "${url_prefix}/${sums}"
   )
 
@@ -249,7 +256,7 @@ function main {
     done
 
     # Verify checksums and copy files
-    if verify_checksums "${archive}" "${header}" "${sums}"; then
+    if verify_checksums "${archive}" "${header}" "${warmup}" "${sums}"; then
       copy_files "${archive}" "${header}"
       checksums_verified=true
     else

scripts/runs-on-emulated.sh

@@ -1,4 +1,12 @@
 #!/bin/bash
 cd /build || exit 1
+
+# Install Bun for multi-arch testing
+echo "Installing Bun..."
+curl -fsSL https://bun.sh/install | bash
+export PATH="$HOME/.bun/bin:$PATH"
+bun --version
+
+# Run npm install and tests
 npm install
 npm run test

src/index.js

@@ -0,0 +1,72 @@
+/**
+ * asherah-node - Entry point with runtime compatibility support
+ * 
+ * This module automatically handles runtime compatibility by detecting
+ * JavaScript runtimes that need Go initialization and loading the warmup
+ * library if available.
+ */
+
+const path = require('path');
+
+// Auto-detect and handle Bun runtime compatibility
+if (typeof Bun !== 'undefined') {
+  try {
+    const { dlopen, FFIType } = require('bun:ffi');
+    const fs = require('fs');
+    
+    // Determine platform-specific library name
+    const platform = process.platform;
+    const arch = process.arch;
+    let libName;
+    
+    if (platform === 'darwin') {
+      if (arch === 'x64') {
+        libName = 'go-warmup-darwin-x64.dylib';
+      } else if (arch === 'arm64') {
+        libName = 'go-warmup-darwin-arm64.dylib';
+      } else {
+        throw new Error(`Unsupported architecture for Darwin: ${arch}. Only x64 and arm64 are supported.`);
+      }
+    } else if (platform === 'linux') {
+      if (arch === 'x64') {
+        libName = 'go-warmup-linux-x64.so';
+      } else if (arch === 'arm64') {
+        libName = 'go-warmup-linux-arm64.so';
+      } else {
+        throw new Error(`Unsupported architecture for Linux: ${arch}. Only x64 and arm64 are supported.`);
+      }
+    } else {
+      throw new Error(`Unsupported platform: ${platform}. Only darwin and linux are supported.`);
+    }
+    
+    // Load Go warmup library to initialize Go runtime for compatibility
+    const libPath = path.join(__dirname, '..', 'lib', libName);
+    
+    // Check if library exists
+    if (!fs.existsSync(libPath)) {
+      throw new Error(
+        `asherah-node: Go warmup library not found at ${libPath}. ` +
+        `Please ensure you have the latest asherah-cobhan release with warmup library support.`
+      );
+    }
+    
+    const lib = dlopen(libPath, {
+      Warmup: { returns: FFIType.int, args: [] }
+    });
+    
+    // Initialize Go runtime
+    lib.symbols.Warmup();
+    
+    // Optional: Log success in verbose mode
+    if (process.env.ASHERAH_VERBOSE) {
+      console.log('✅ asherah-node: Go runtime initialized for compatibility');
+    }
+    
+  } catch (error) {
+    // Re-throw the error - initialization is required for Bun
+    throw new Error(`asherah-node: Failed to initialize Go runtime for Bun: ${error.message}`);
+  }
+}
+
+// Load the native asherah module
+module.exports = require(path.join(__dirname, '..', 'build', 'Release', 'asherah.node'));

test/bun-test.js

@@ -0,0 +1,96 @@
+#!/usr/bin/env bun
+
+/**
+ * Simple Bun test runner for CI/CD integration
+ * 
+ * This script runs the Bun compatibility test and exits with
+ * appropriate status codes for CI/CD pipelines.
+ * 
+ * Usage: bun test/bun-test.js
+ */
+
+const asherah = require('../src/index');
+
+console.log('=== Bun Compatibility Test ===');
+console.log(`Runtime: ${typeof Bun !== 'undefined' ? 'Bun' : 'Not Bun'}`);
+console.log(`Platform: ${process.platform} ${process.arch}`);
+console.log('');
+
+const config = {
+  KMS: 'static',
+  Metastore: 'memory',
+  ServiceName: 'bun-test',
+  ProductID: 'bun-test',
+  Verbose: false,
+  EnableSessionCaching: false,
+  ExpireAfter: 60,
+  CheckInterval: 1
+};
+
+let success = true;
+
+try {
+  // Test 1: Setup
+  console.log('1. Testing setup...');
+  asherah.setup(config);
+  console.log('   ✅ Setup successful');
+  
+  // Test 2: Encrypt
+  console.log('2. Testing encryption...');
+  const partitionId = 'bun-test-' + Date.now();
+  const testData = 'Bun runtime test: Hello from Bun! 🚀';
+  const encrypted = asherah.encrypt(partitionId, Buffer.from(testData, 'utf8'));
+  
+  if (!encrypted || encrypted.length === 0) {
+    throw new Error('Encryption failed - no data returned');
+  }
+  console.log(`   ✅ Encrypted ${testData.length} bytes -> ${encrypted.length} chars`);
+  
+  // Test 3: Decrypt
+  console.log('3. Testing decryption...');
+  const decrypted = asherah.decrypt(partitionId, encrypted);
+  
+  if (!decrypted) {
+    throw new Error('Decryption failed - no data returned');
+  }
+  
+  const decryptedText = decrypted.toString('utf8');
+  if (decryptedText !== testData) {
+    throw new Error(`Decryption mismatch: expected "${testData}", got "${decryptedText}"`);
+  }
+  console.log('   ✅ Decrypted successfully, data matches');
+  
+  // Test 4: Multiple cycles
+  console.log('4. Testing multiple encrypt/decrypt cycles...');
+  for (let i = 0; i < 5; i++) {
+    const data = `Test cycle ${i}: ${Math.random()}`;
+    const enc = asherah.encrypt(partitionId, Buffer.from(data, 'utf8'));
+    const dec = asherah.decrypt(partitionId, enc);
+    if (dec.toString('utf8') !== data) {
+      throw new Error(`Cycle ${i} failed: data mismatch`);
+    }
+  }
+  console.log('   ✅ 5 cycles completed successfully');
+  
+  // Test 5: Shutdown
+  console.log('5. Testing shutdown...');
+  asherah.shutdown();
+  console.log('   ✅ Shutdown successful');
+  
+  console.log('');
+  console.log('🎉 All tests PASSED!');
+  console.log('Bun compatibility confirmed ✅');
+  
+} catch (error) {
+  console.error('');
+  console.error('❌ Test FAILED:');
+  console.error(error.message);
+  if (error.stack) {
+    console.error('\nStack trace:');
+    console.error(error.stack);
+  }
+  success = false;
+}
+
+// Exit with appropriate code
+process.exit(success ? 0 : 1);