@napi-rs/cli 3.0.0-alpha.3 → 3.0.0-alpha.31

package/src/api/templates/ci.yml.ts

@@ -2,6 +2,7 @@ import { load, dump } from 'js-yaml'
 
 import {
   NodeArchToCpu,
+  type SupportedPackageManager,
   UniArchsByPlatform,
   parseTriple,
 } from '../../utils/index.js'
@@ -15,11 +16,12 @@ const TEST_LINUX_X64_MUSL = 'test-linux-x64-musl-binding'
 const TEST_LINUX_AARCH64_GNU = 'test-linux-aarch64-gnu-binding'
 const TEST_LINUX_AARCH64_MUSL = 'test-linux-aarch64-musl-binding'
 const TEST_LINUX_ARM_GNUEABIHF = 'test-linux-arm-gnueabihf-binding'
+const TEST_WASI = 'test-wasi-nodejs'
 const UNIVERSAL_MACOS = 'universal-macOS'
 
 export const createGithubActionsCIYml = (
-  binaryName: string,
   targets: string[],
+  packageManager: SupportedPackageManager,
 ) => {
   const allTargets = new Set(
     targets.flatMap((t) => {
@@ -34,7 +36,7 @@ export const createGithubActionsCIYml = (
     }),
   )
 
-  const fullTemplate = load(YAML()) as any
+  const fullTemplate = load(YAML(packageManager)) as any
 
   const requiredSteps = []
   const enableWindowsX86 = allTargets.has('x86_64-pc-windows-msvc')
@@ -46,6 +48,7 @@ export const createGithubActionsCIYml = (
   const enableLinuxArm7 = allTargets.has('armv7-unknown-linux-gnueabihf')
   const enableFreeBSD = allTargets.has('x86_64-unknown-freebsd')
   const enableMacOSUni = allTargets.has('universal-apple-darwin')
+  const enableWasi = allTargets.has('wasm32-wasi-preview1-threads')
   fullTemplate.jobs.build.strategy.matrix.settings =
     fullTemplate.jobs.build.strategy.matrix.settings.filter(
       ({ target }: { target: string }) => allTargets.has(target),
@@ -63,10 +66,16 @@ export const createGithubActionsCIYml = (
   if (!enableWindowsX86 && !enableMacOSX86) {
     delete fullTemplate.jobs[TEST_MACOS_WINDOWS]
   } else {
-    const filterTarget = enableWindowsX86 ? 'macos-latest' : 'windows-latest'
+    const filterTargets = new Set<string>()
+    if (enableWindowsX86) {
+      filterTargets.add('windows-latest')
+    }
+    if (enableMacOSUni || enableMacOSX86) {
+      filterTargets.add('macos-latest')
+    }
     fullTemplate.jobs[TEST_MACOS_WINDOWS].strategy.matrix.settings =
       fullTemplate.jobs[TEST_MACOS_WINDOWS].strategy.matrix.settings.filter(
-        ({ host }: { host: string; target: string }) => host !== filterTarget,
+        ({ host }: { host: string; target: string }) => filterTargets.has(host),
       )
 
     requiredSteps.push(TEST_MACOS_WINDOWS)
@@ -108,6 +117,12 @@ export const createGithubActionsCIYml = (
     requiredSteps.push(UNIVERSAL_MACOS)
   }
 
+  if (!enableWasi) {
+    delete fullTemplate.jobs[TEST_WASI]
+  } else {
+    requiredSteps.push(TEST_WASI)
+  }
+
   fullTemplate.jobs.publish.needs = requiredSteps
 
   return dump(fullTemplate, {

package/src/api/templates/js-binding.ts

@@ -1,130 +1,340 @@
-/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
+export function createCjsBinding(
+  localName: string,
+  pkgName: string,
+  idents: string[],
+): string {
+  return `// prettier-ignore
+/* eslint-disable */
+/* auto-generated by NAPI-RS */
 
-function loadNapiModule(binaryName: string, packageName: string) {
-  const { existsSync, readFileSync } = require('fs')
-  const { join } = require('path')
-  const { platform, arch } = process
+const { existsSync, readFileSync } = require('fs')
+const { join } = require('path')
 
-  const candidates: string[] = []
+const { platform, arch } = process
 
-  function isMusl() {
-    // For Node 10
-    if (!process.report || typeof process.report.getReport !== 'function') {
-      try {
-        const lddPath = require('child_process')
-          .execSync('which ldd')
-          .toString()
-          .trim()
-        return readFileSync(lddPath, 'utf8').includes('musl')
-      } catch (e) {
-        return true
-      }
-    } else {
-      // @ts-expect-error
-      const { glibcVersionRuntime } = process.report.getReport().header
-      return !glibcVersionRuntime
+let nativeBinding = null
+let localFileExisted = false
+let loadError = null
+
+const isMusl = () => {
+  let musl = false
+  if (process.platform === 'linux') {
+    musl = isMuslFromFilesystem()
+    if (musl === null) {
+      musl = isMuslFromReport()
+    }
+    if (musl === null) {
+      musl = isMuslFromChildProcess()
     }
   }
+  return musl
+}
 
-  switch (platform) {
-    case 'android':
-      switch (arch) {
-        case 'arm64':
-          candidates.push('android-arm64')
-          break
-        case 'arm':
-          candidates.push('android-arm-eabi')
-          break
-      }
-      break
-    case 'win32':
-      switch (arch) {
-        case 'x64':
-          candidates.push('win32-x64-msvc')
-          break
-        case 'ia32':
-          candidates.push('win32-ia32-msvc')
-          break
-        case 'arm64':
-          candidates.push('win32-arm64-msvc')
-          break
-      }
-      break
-    case 'darwin':
-      candidates.push('darwin-universal')
-      switch (arch) {
-        case 'x64':
-          candidates.push('darwin-x64')
-          break
-        case 'arm64':
-          candidates.push('darwin-arm64')
-          break
-      }
-      break
-    case 'freebsd':
-      if (arch === 'x64') {
-        candidates.push('freebsd-x64')
-      }
-      break
-    case 'linux':
-      switch (arch) {
-        case 'x64':
-          if (isMusl()) {
-            candidates.push('linux-x64-musl')
+const isFileMusl = (f) => f.includes('libc.musl-') || f.includes('ld-musl-')
+
+const isMuslFromFilesystem = () => {
+  try {
+    return readFileSync('/usr/bin/ldd', 'utf-8').includes('musl')
+  } catch {
+    return null
+  }
+}
+
+const isMuslFromReport = () => {
+  const report = typeof process.report.getReport === 'function' ? process.report.getReport() : null
+  if (!report) {
+    return null
+  }
+  if (report.header && report.header.glibcVersionRuntime) {
+    return false
+  }
+  if (Array.isArray(report.sharedObjects)) {
+    if (report.sharedObjects.some(isFileMusl)) {
+      return true
+    }
+  }
+  return false
+}
+
+const isMuslFromChildProcess = () => {
+  try {
+    return require('child_process').execSync('ldd --version', { encoding: 'utf8' }).includes('musl')
+  } catch (e) {
+    // If we reach this case, we don't know if the system is musl or not, so is better to just fallback to false
+    return false
+  }
+}
+
+switch (platform) {
+  case 'android':
+    switch (arch) {
+      case 'arm64':
+        localFileExisted = existsSync(join(__dirname, '${localName}.android-arm64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.android-arm64.node')
           } else {
-            candidates.push('linux-x64-gnu')
+            nativeBinding = require('${pkgName}-android-arm64')
           }
-          break
-        case 'arm64':
-          if (isMusl()) {
-            candidates.push('linux-arm64-musl')
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(join(__dirname, '${localName}.android-arm-eabi.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.android-arm-eabi.node')
           } else {
-            candidates.push('linux-arm64-gnu')
+            nativeBinding = require('${pkgName}-android-arm-eabi')
           }
-          break
-        case 'arm':
-          candidates.push('linux-arm-gnueabihf')
-          break
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(\`Unsupported architecture on Android \${arch}\`)
+    }
+    break
+  case 'win32':
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.win32-x64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.win32-x64-msvc.node')
+          } else {
+            nativeBinding = require('${pkgName}-win32-x64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'ia32':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.win32-ia32-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.win32-ia32-msvc.node')
+          } else {
+            nativeBinding = require('${pkgName}-win32-ia32-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.win32-arm64-msvc.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.win32-arm64-msvc.node')
+          } else {
+            nativeBinding = require('${pkgName}-win32-arm64-msvc')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(\`Unsupported architecture on Windows: \${arch}\`)
+    }
+    break
+  case 'darwin':
+    localFileExisted = existsSync(join(__dirname, '${localName}.darwin-universal.node'))
+    try {
+      if (localFileExisted) {
+        nativeBinding = require('./${localName}.darwin-universal.node')
+      } else {
+        nativeBinding = require('${pkgName}-darwin-universal')
       }
       break
-  }
-
-  let nativeBinding: any
-  let loadError: any
-
-  for (const suffix of candidates) {
-    const localPath = join(__dirname, `${binaryName}.${suffix}.node`)
-    const pkgPath = `${packageName}-${suffix}`
-
+    } catch {}
+    switch (arch) {
+      case 'x64':
+        localFileExisted = existsSync(join(__dirname, '${localName}.darwin-x64.node'))
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.darwin-x64.node')
+          } else {
+            nativeBinding = require('${pkgName}-darwin-x64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'arm64':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.darwin-arm64.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.darwin-arm64.node')
+          } else {
+            nativeBinding = require('${pkgName}-darwin-arm64')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      default:
+        throw new Error(\`Unsupported architecture on macOS: \${arch}\`)
+    }
+    break
+  case 'freebsd':
+    if (arch !== 'x64') {
+      throw new Error(\`Unsupported architecture on FreeBSD: \${arch}\`)
+    }
+    localFileExisted = existsSync(join(__dirname, '${localName}.freebsd-x64.node'))
     try {
-      if (existsSync(localPath)) {
-        nativeBinding = require(localPath)
+      if (localFileExisted) {
+        nativeBinding = require('./${localName}.freebsd-x64.node')
       } else {
-        nativeBinding = require(pkgPath)
+        nativeBinding = require('${pkgName}-freebsd-x64')
       }
     } catch (e) {
       loadError = e
-      continue
     }
-
-    loadError = null
     break
-  }
+  case 'linux':
+    switch (arch) {
+      case 'x64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-x64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-x64-musl.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-x64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-x64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-x64-gnu.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-x64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-arm64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-arm64-musl.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-arm64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-arm64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-arm64-gnu.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-arm64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      case 'arm':
+        localFileExisted = existsSync(
+          join(__dirname, '${localName}.linux-arm-gnueabihf.node')
+        )
+        try {
+          if (localFileExisted) {
+            nativeBinding = require('./${localName}.linux-arm-gnueabihf.node')
+          } else {
+            nativeBinding = require('${pkgName}-linux-arm-gnueabihf')
+          }
+        } catch (e) {
+          loadError = e
+        }
+        break
+      case 'riscv64':
+        if (isMusl()) {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-riscv64-musl.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-riscv64-musl.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-riscv64-musl')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        } else {
+          localFileExisted = existsSync(
+            join(__dirname, '${localName}.linux-riscv64-gnu.node')
+          )
+          try {
+            if (localFileExisted) {
+              nativeBinding = require('./${localName}.linux-riscv64-gnu.node')
+            } else {
+              nativeBinding = require('${pkgName}-linux-riscv64-gnu')
+            }
+          } catch (e) {
+            loadError = e
+          }
+        }
+        break
+      default:
+        throw new Error(\`Unsupported architecture on Linux: \${arch}\`)
+    }
+    break
+  default:
+    throw new Error(\`Unsupported OS: \${platform}, architecture: \${arch}\`)
+}
 
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require('./${localName}.wasi.cjs')
+  } catch {
+    // ignore
+  }
   if (!nativeBinding) {
-    if (loadError) {
-      throw loadError
+    try {
+      nativeBinding = require('${pkgName}-wasm32-wasi')
+    } catch (err) {
+      console.error(err)
     }
-
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
   }
-
-  return nativeBinding
 }
 
-export function createJsBinding(localName: string, pkgName: string): string {
-  return `${loadNapiModule.toString()}
+if (!nativeBinding) {
+  if (loadError) {
+    throw loadError
+  }
+  throw new Error(\`Failed to load native binding\`)
+}
 
-module.exports = loadNapiModule('${localName}', '${pkgName}')
+${idents
+  .map((ident) => `module.exports.${ident} = nativeBinding.${ident}`)
+  .join('\n')}
 `
 }

package/src/api/templates/lib.rs.ts

@@ -1,7 +1,4 @@
-export const createLibRs = () => `#![deny(clippy::all)]
-
-#[macro_use]
-extern crate napi_derive;
+export const createLibRs = () => `use napi_derive::napi;
 
 #[napi]
 pub fn sum(a: i32, b: i32) -> i32 {

package/src/api/templates/load-wasi-template.ts

@@ -0,0 +1,146 @@
+export const createWasiBrowserBinding = (
+  wasiFilename: string,
+  wasiRegisterFunctions: string[],
+) => `import { instantiateNapiModuleSync as __emnapiInstantiateNapiModuleSync } from '@emnapi/core'
+import { getDefaultContext as __emnapiGetDefaultContext } from '@emnapi/runtime'
+import { WASI as __WASI } from '@tybys/wasm-util'
+import { Volume as __Volume, createFsFromVolume as __createFsFromVolume } from 'memfs-browser'
+
+import __wasmUrl from './${wasiFilename}.wasm?url'
+
+const __fs = __createFsFromVolume(
+  __Volume.fromJSON({
+    '/': null,
+  }),
+)
+
+const __wasi = new __WASI({
+  version: 'preview1',
+  fs: __fs,
+})
+
+const __emnapiContext = __emnapiGetDefaultContext()
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: 1024,
+  maximum: 10240,
+  shared: true,
+})
+
+let __wasmFile = await fetch(__wasmUrl).then((res) => res.arrayBuffer())
+
+const {
+  instance: __napiInstance,
+  module: __wasiModule,
+  napiModule: __napiModule,
+} = __emnapiInstantiateNapiModuleSync(__wasmFile, {
+  context: __emnapiContext,
+  asyncWorkPoolSize: 4,
+  wasi: __wasi,
+  onCreateWorker() {
+    return new Worker(new URL('./wasi-worker-browser.mjs', import.meta.url), {
+      type: 'module',
+    })
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    __napi_rs_initialize_modules(instance)
+  },
+})
+
+function __napi_rs_initialize_modules(__napiInstance) {
+${wasiRegisterFunctions
+  .map((name) => `  __napiInstance.exports['${name}']?.()`)
+  .join('\n')}
+}
+`
+
+export const createWasiBinding = (
+  wasmFileName: string,
+  packageName: string,
+  wasiRegisterFunctions: string[],
+) => `/* eslint-disable */
+/* prettier-ignore */
+
+/* auto-generated by NAPI-RS */
+
+const __nodeFs= require('node:fs')
+const __nodePath = require('node:path')
+const { WASI: __nodeWASI } = require('node:wasi')
+const { Worker } = require('node:worker_threads')
+
+const { instantiateNapiModuleSync: __emnapiInstantiateNapiModuleSync } = require('@emnapi/core')
+const { getDefaultContext: __emnapiGetDefaultContext } = require('@emnapi/runtime')
+
+const __wasi = new __nodeWASI({
+  version: 'preview1',
+  env: process.env,
+  preopens: {
+    '/': '/'
+  }
+})
+
+const __emnapiContext = __emnapiGetDefaultContext()
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: 1024,
+  maximum: 10240,
+  shared: true,
+})
+
+let __wasmFilePath = __nodePath.join(__dirname, '${wasmFileName}.wasm')
+
+if (!__nodeFs.existsSync(__wasmFilePath)) {
+  try {
+    __wasmFilePath = __nodePath.resolve('${packageName}-wasm32-wasi')
+  } catch {
+    throw new Error('Cannot find ${wasmFileName}.wasm file, and ${packageName}-wasm32-wasi package is not installed.')
+  }
+}
+
+const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule } = __emnapiInstantiateNapiModuleSync(__nodeFs.readFileSync(__wasmFilePath), {
+  context: __emnapiContext,
+  asyncWorkPoolSize: (function() {
+    const threadsSizeFromEnv = Number(process.env.NAPI_RS_ASYNC_WORK_POOL_SIZE ?? process.env.UV_THREADPOOL_SIZE)
+    // NaN > 0 is false
+    if (threadsSizeFromEnv > 0) {
+      return threadsSizeFromEnv
+    } else {
+      return 4
+    }
+  })(),
+  wasi: __wasi,
+  onCreateWorker() {
+    return new Worker(__nodePath.join(__dirname, 'wasi-worker.mjs'), {
+      env: process.env,
+      execArgv: ['--experimental-wasi-unstable-preview1'],
+    })
+  },
+  overwriteImports(importObject) {
+    importObject.env = {
+      ...importObject.env,
+      ...importObject.napi,
+      ...importObject.emnapi,
+      memory: __sharedMemory,
+    }
+    return importObject
+  },
+  beforeInit({ instance }) {
+    __napi_rs_initialize_modules(instance)
+  }
+})
+
+function __napi_rs_initialize_modules(__napiInstance) {
+${wasiRegisterFunctions
+  .map((name) => `  __napiInstance.exports['${name}']?.()`)
+  .join('\n')}
+}
+`