@napi-rs/cli 3.0.0-alpha.1 → 3.0.0-alpha.11

package/src/api/build.ts

@@ -1,7 +1,9 @@
-import { spawn } from 'child_process'
-import { createHash } from 'crypto'
-import { tmpdir } from 'os'
-import { parse, join, resolve } from 'path'
+import { spawn } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import { existsSync, mkdirSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { tmpdir, homedir } from 'node:os'
+import { parse, join, resolve } from 'node:path'
 
 import * as colors from 'colorette'
 
@@ -20,6 +22,7 @@ import {
   parseMetadata,
   parseTriple,
   processTypeDef,
+  readFileAsync,
   readNapiConfig,
   Target,
   targetToEnvVar,
@@ -28,11 +31,14 @@ import {
   writeFileAsync,
 } from '../utils/index.js'
 
-import { createJsBinding } from './templates/index.js'
+import { createWasiBinding } from './load-wasi-template.js'
+import { createCjsBinding } from './templates/index.js'
+import { WASI_WORKER_TEMPLATE } from './wasi-worker-template.js'
 
 const debug = debugFactory('build')
+const require = createRequire(import.meta.url)
 
-type OutputKind = 'js' | 'dts' | 'node' | 'exe'
+type OutputKind = 'js' | 'dts' | 'node' | 'exe' | 'wasm'
 type Output = {
   kind: OutputKind
   path: string
@@ -76,8 +82,8 @@ export async function buildProject(options: BuildOptions) {
     options.target
       ? parseTriple(options.target)
       : process.env.CARGO_BUILD_TARGET
-      ? parseTriple(process.env.CARGO_BUILD_TARGET)
-      : getSystemDefaultTarget(),
+        ? parseTriple(process.env.CARGO_BUILD_TARGET)
+        : getSystemDefaultTarget(),
     crateDir,
     resolvePath(options.outputDir ?? crateDir),
     options.targetDir ??
@@ -138,24 +144,124 @@ class Builder {
       .setPackage()
       .setFeatures()
       .setTarget()
+      .pickCrossToolchain()
       .setEnvs()
       .setBypassArgs()
       .exec()
   }
 
+  private pickCrossToolchain() {
+    if (!this.options.useNapiCross) {
+      return this
+    }
+    if (this.options.useCross) {
+      debug.warn(
+        'You are trying to use both `--cross` and `--use-napi-cross` options, `--use-cross` will be ignored.',
+      )
+    }
+
+    if (this.options.crossCompile) {
+      debug.warn(
+        'You are trying to use both `--cross-compile` and `--use-napi-cross` options, `--cross-compile` will be ignored.',
+      )
+    }
+
+    try {
+      const { version, download } = require('@napi-rs/cross-toolchain')
+
+      const toolchainPath = join(
+        homedir(),
+        '.napi-rs',
+        'cross-toolchain',
+        version,
+        this.target.triple,
+      )
+      mkdirSync(toolchainPath, { recursive: true })
+      if (existsSync(join(toolchainPath, 'package.json'))) {
+        debug(`Toolchain ${toolchainPath} exists, skip extracting`)
+      } else {
+        const tarArchive = download(process.arch, this.target.triple)
+        tarArchive.unpack(toolchainPath)
+      }
+      const upperCaseTarget = targetToEnvVar(this.target.triple)
+      const linkerEnv = `CARGO_TARGET_${upperCaseTarget}_LINKER`
+      this.envs[linkerEnv] = join(
+        toolchainPath,
+        'bin',
+        `${this.target.triple}-gcc`,
+      )
+      if (!process.env.TARGET_SYSROOT) {
+        this.envs[`TARGET_SYSROOT`] = join(
+          toolchainPath,
+          this.target.triple,
+          'sysroot',
+        )
+      }
+      if (!process.env.TARGET_AR) {
+        this.envs[`TARGET_AR`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-ar`,
+        )
+      }
+      if (!process.env.TARGET_RANLIB) {
+        this.envs[`TARGET_RANLIB`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-ranlib`,
+        )
+      }
+      if (!process.env.TARGET_READELF) {
+        this.envs[`TARGET_READELF`] = join(
+          toolchainPath,
+          'bin',
+          `${this.target.triple}-readelf`,
+        )
+      }
+      if (!process.env.TARGET_C_INCLUDE_PATH) {
+        this.envs[`TARGET_C_INCLUDE_PATH`] = join(
+          toolchainPath,
+          this.target.triple,
+          'sysroot',
+          'usr',
+          'include/',
+        )
+      }
+      if (
+        (process.env.CC === 'clang' &&
+          (process.env.TARGET_CC === 'clang' || !process.env.TARGET_CC)) ||
+        process.env.TARGET_CC === 'clang'
+      ) {
+        this.envs.C_FLAGS = `--sysroot=${this.envs.TARGET_SYSROOT}`
+      }
+    } catch (e) {
+      debug.warn('Pick cross toolchain failed', e as Error)
+      // ignore, do nothing
+    }
+    return this
+  }
+
   private exec() {
     debug(`Start building crate: ${this.crate.name}`)
     debug('  %i', `cargo ${this.args.join(' ')}`)
 
     const controller = new AbortController()
 
+    const watch = this.options.watch
     const buildTask = new Promise<void>((resolve, reject) => {
-      const buildProcess = spawn('cargo', this.args, {
+      if (this.options.useCross && this.options.crossCompile) {
+        throw new Error(
+          '`--use-cross` and `--cross-compile` can not be used together',
+        )
+      }
+      const command =
+        process.env.CARGO ?? (this.options.useCross ? 'cross' : 'cargo')
+      const buildProcess = spawn(command, this.args, {
         env: {
           ...process.env,
           ...this.envs,
         },
-        stdio: 'inherit',
+        stdio: watch ? ['inherit', 'inherit', 'pipe'] : 'inherit',
         cwd: this.cwd,
         signal: controller.signal,
       })
@@ -176,6 +282,15 @@ class Builder {
           }),
         )
       })
+
+      // watch mode only, they are piped through stderr
+      buildProcess.stderr?.on('data', (data) => {
+        const output = data.toString()
+        console.error(output)
+        if (/Finished\s(dev|release)/.test(output)) {
+          this.postBuild().catch(() => {})
+        }
+      })
     })
 
     return {
@@ -205,6 +320,7 @@ class Builder {
           this.crateDir,
           '--',
           'cargo',
+          'build',
         )
         set = true
       }
@@ -297,6 +413,10 @@ class Builder {
   private setEnvs() {
     // type definition intermediate file
     this.envs.TYPE_DEF_TMP_PATH = this.getIntermediateTypeFile()
+    // WASI register intermediate file
+    this.envs.WASI_REGISTER_TMP_PATH = this.getIntermediateWasiRegisterFile()
+    // TODO:
+    //   remove after napi-derive@v3 release
     this.envs.CARGO_CFG_NAPI_RS_CLI_VERSION = CLI_VERSION
 
     // RUSTFLAGS
@@ -320,13 +440,18 @@ class Builder {
     // END RUSTFLAGS
 
     // LINKER
-    const linker = getTargetLinker(this.target.triple)
-    if (
-      linker &&
-      !process.env.RUSTC_LINKER &&
-      !process.env[`CARGET_TARGET_${targetToEnvVar(this.target.triple)}_LINKER`]
-    ) {
-      this.envs.RUSTC_LINKER = linker
+    const linker = this.options.crossCompile
+      ? void 0
+      : getTargetLinker(this.target.triple)
+    // TODO:
+    //   directly set CARGO_TARGET_<target>_LINKER will cover .cargo/config.toml
+    //   will detect by cargo config when it becomes stable
+    //   see: https://github.com/rust-lang/cargo/issues/9301
+    const linkerEnv = `CARGO_TARGET_${targetToEnvVar(
+      this.target.triple,
+    )}_LINKER`
+    if (linker && !process.env[linkerEnv]) {
+      this.envs[linkerEnv] = linker
     }
 
     if (this.target.platform === 'android') {
@@ -342,18 +467,35 @@ class Builder {
       const targetArch = this.target.arch === 'arm' ? 'armv7a' : 'aarch64'
       const targetPlatform =
         this.target.arch === 'arm' ? 'androideabi24' : 'android24'
+      const hostPlatform =
+        process.platform === 'darwin'
+          ? 'darwin'
+          : process.platform === 'win32'
+            ? 'windows'
+            : 'linux'
       Object.assign(this.envs, {
-        CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-android24-clang`,
-        CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-androideabi24-clang`,
-        CC: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang`,
-        CXX: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang++`,
-        AR: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/llvm-ar`,
+        CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-android24-clang`,
+        CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-androideabi24-clang`,
+        CC: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang`,
+        CXX: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/${targetArch}-linux-${targetPlatform}-clang++`,
+        AR: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ar`,
+        RANLIB: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin/llvm-ranlib`,
         ANDROID_NDK: ANDROID_NDK_LATEST_HOME,
-        PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:${process.env.PATH}`,
+        PATH: `${ANDROID_NDK_LATEST_HOME}/toolchains/llvm/prebuilt/${hostPlatform}-x86_64/bin:${process.env.PATH}`,
       })
     }
     // END LINKER
 
+    if (this.target.platform === 'wasi') {
+      const emnapi = join(
+        require.resolve('emnapi'),
+        '..',
+        'lib',
+        'wasm32-wasi-threads',
+      )
+      this.envs.EMNAPI_LINK_DIR = emnapi
+    }
+
     debug('Set envs: ')
     Object.entries(this.envs).forEach(([k, v]) => {
       debug('  %i', `${k}=${v}`)
@@ -392,6 +534,10 @@ class Builder {
       this.args.push('--target-dir', this.options.targetDir)
     }
 
+    if (this.options.profile) {
+      this.args.push('--profile', this.options.profile)
+    }
+
     if (this.options.cargoOptions?.length) {
       this.args.push(...this.options.cargoOptions)
     }
@@ -410,6 +556,17 @@ class Builder {
     )
   }
 
+  private getIntermediateWasiRegisterFile() {
+    return join(
+      tmpdir(),
+      `${this.crate.name}-${createHash('sha256')
+        .update(this.crate.manifest_path)
+        .update(CLI_VERSION)
+        .digest('hex')
+        .substring(0, 8)}.napi_wasi_register.tmp`,
+    )
+  }
+
   private async postBuild() {
     try {
       debug(`Try to create output directory:`)
@@ -422,12 +579,39 @@ class Builder {
       })
     }
 
-    await this.copyArtifact()
+    const dest = await this.copyArtifact()
 
     // only for cdylib
     if (this.cdyLibName) {
-      await this.generateTypeDef()
-      await this.writeJsBinding()
+      const idents = await this.generateTypeDef()
+      const intermediateWasiRegisterFile = this.envs.WASI_REGISTER_TMP_PATH
+      const wasiRegisterFunctions =
+        this.target.arch === 'wasm32'
+          ? JSON.parse(
+              await readFileAsync(intermediateWasiRegisterFile, 'utf8').catch(
+                (err) => {
+                  console.warn(
+                    `Read ${colors.yellowBright(
+                      intermediateWasiRegisterFile,
+                    )} failed, reason: ${err.message}`,
+                  )
+                  return `[]`
+                },
+              ),
+            )
+          : []
+      const jsOutput = await this.writeJsBinding(idents)
+      const wasmOutput = await this.writeWasiBinding(
+        wasiRegisterFunctions,
+        dest ?? 'index.wasm',
+        idents,
+      )
+      if (jsOutput) {
+        this.outputs.push(jsOutput)
+      }
+      if (wasmOutput) {
+        this.outputs.push(wasmOutput)
+      }
     }
 
     return this.outputs
@@ -439,12 +623,10 @@ class Builder {
       return
     }
 
-    const src = join(
-      this.targetDir,
-      this.target.triple,
-      this.options.release ? 'release' : 'debug',
-      srcName,
-    )
+    const profile =
+      this.options.profile ?? (this.options.release ? 'release' : 'debug')
+    const src = join(this.targetDir, this.target.triple, profile, srcName)
+    debug(`Copy artifact from: [${src}]`)
     const dest = join(this.outputDir, destName)
 
     try {
@@ -459,6 +641,7 @@ class Builder {
         kind: dest.endsWith('.node') ? 'node' : 'exe',
         path: dest,
       })
+      return dest
     } catch (e) {
       throw new Error('Failed to copy artifact', {
         cause: e,
@@ -474,8 +657,10 @@ class Builder {
         this.target.platform === 'darwin'
           ? `lib${cdyLib}.dylib`
           : this.target.platform === 'win32'
-          ? `${cdyLib}.dll`
-          : `lib${cdyLib}.so`
+            ? `${cdyLib}.dll`
+            : this.target.platform === 'wasi' || this.target.platform === 'wasm'
+              ? `${cdyLib}.wasm`
+              : `lib${cdyLib}.so`
 
       let destName = this.config.binaryName
       // add platform suffix to binary name
@@ -484,7 +669,11 @@ class Builder {
       if (this.options.platform) {
         destName += `.${this.target.platformArchABI}`
       }
-      destName += '.node'
+      if (srcName.endsWith('.wasm')) {
+        destName += '.wasi-wasm32.wasm'
+      } else {
+        destName += '.node'
+      }
 
       return [srcName, destName]
     } else if (this.binName) {
@@ -499,13 +688,14 @@ class Builder {
 
   private async generateTypeDef() {
     if (!(await fileExists(this.envs.TYPE_DEF_TMP_PATH))) {
-      return
+      return []
     }
 
     const dest = join(this.outputDir, this.options.dts ?? 'index.d.ts')
 
-    const dts = await processTypeDef(
+    const { dts, exports } = await processTypeDef(
       this.envs.TYPE_DEF_TMP_PATH,
+      this.options.constEnum ?? true,
       !this.options.noDtsHeader
         ? this.options.dtsHeader ?? DEFAULT_TYPE_DEF_HEADER
         : '',
@@ -523,27 +713,71 @@ class Builder {
       debug.error('Failed to write type def file')
       debug.error(e as Error)
     }
+
+    return exports
   }
 
-  private async writeJsBinding() {
-    if (!this.options.platform || this.options.noJsBinding) {
+  private async writeJsBinding(idents: string[]) {
+    if (
+      !this.options.platform ||
+      // eslint-disable-next-line @typescript-eslint/prefer-nullish-coalescing
+      this.options.noJsBinding ||
+      idents.length === 0
+    ) {
       return
     }
 
-    const dest = join(this.outputDir, this.options.jsBinding ?? 'index.js')
+    const name = parse(this.options.jsBinding ?? 'index.js').name
 
-    const js = createJsBinding(this.config.binaryName, this.config.packageName)
+    const cjs = createCjsBinding(
+      this.config.binaryName,
+      this.config.packageName,
+      idents,
+    )
 
     try {
+      const dest = join(this.outputDir, `${name}.js`)
       debug('Writing js binding to:')
       debug('  %i', dest)
-      await writeFileAsync(dest, js, 'utf-8')
-      this.outputs.push({
+      await writeFileAsync(dest, cjs, 'utf-8')
+      return {
         kind: 'js',
         path: dest,
-      })
+      } satisfies Output
     } catch (e) {
       throw new Error('Failed to write js binding file', { cause: e })
     }
   }
+
+  private async writeWasiBinding(
+    wasiRegisterFunctions: string[],
+    distFileName: string | undefined,
+    idents: string[],
+  ) {
+    if (distFileName && wasiRegisterFunctions.length) {
+      const { name, dir } = parse(distFileName)
+      const newPath = join(dir, `${this.config.binaryName}.wasi.cjs`)
+      const workerPath = join(dir, 'wasi-worker.mjs')
+      const declareCodes = `const { ${idents.join(
+        ', ',
+      )} } = __napiModule.exports\n`
+      const exportsCode = idents
+        .map((ident) => `module.exports.${ident} = ${ident}`)
+        .join(',\n')
+      await writeFileAsync(
+        newPath,
+        createWasiBinding(name, wasiRegisterFunctions) +
+          declareCodes +
+          exportsCode +
+          '\n',
+        'utf8',
+      )
+      await writeFileAsync(workerPath, WASI_WORKER_TEMPLATE, 'utf8')
+      return {
+        kind: 'wasm',
+        path: newPath,
+      } satisfies Output
+    }
+    return null
+  }
 }

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

@@ -0,0 +1,62 @@
+export const createWasiBinding = (
+  wasmFileName: 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: {
+    '/': __dirname,
+  }
+})
+
+const __emnapiContext = __emnapiGetDefaultContext()
+
+const __sharedMemory = new WebAssembly.Memory({
+  initial: 1024,
+  maximum: 10240,
+  shared: true,
+})
+
+const { instance: __napiInstance, module: __wasiModule, napiModule: __napiModule } = __emnapiInstantiateNapiModuleSync(__nodeFs.readFileSync(__nodePath.join(__dirname, '${wasmFileName}.wasm')), {
+  context: __emnapiContext,
+  asyncWorkPoolSize: 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')}
+}
+`

package/src/api/new.ts

@@ -10,6 +10,8 @@ import {
   debugFactory,
   DEFAULT_TARGETS,
   mkdirAsync,
+  readdirAsync,
+  statAsync,
   writeFileAsync,
 } from '../utils/index.js'
 import { napiEngineRequirement } from '../utils/version.js'
@@ -69,21 +71,45 @@ export async function newProject(userOptions: RawNewOptions) {
 
   const outputs = generateFiles(options)
 
-  try {
-    debug(`Try to create target directory: ${options.path}`)
-    if (!options.dryRun) {
-      await mkdirAsync(options.path, { recursive: true })
-    }
-  } catch (e) {
-    throw new Error(`Failed to create target directory: ${options.path}`, {
-      cause: e,
-    })
-  }
+  await ensurePath(options.path, options.dryRun)
 
   await dumpOutputs(outputs, options.dryRun)
   debug(`Project created at: ${options.path}`)
 }
 
+async function ensurePath(path: string, dryRun = false) {
+  const stat = await statAsync(path, {}).catch(() => undefined)
+
+  // file descriptor exists
+  if (stat) {
+    if (stat.isFile()) {
+      throw new Error(
+        `Path ${path} for creating new napi-rs project already exists and it's not a directory.`,
+      )
+    } else if (stat.isDirectory()) {
+      const files = await readdirAsync(path)
+      if (files.length) {
+        throw new Error(
+          `Path ${path} for creating new napi-rs project already exists and it's not empty.`,
+        )
+      }
+    }
+  }
+
+  if (!dryRun) {
+    try {
+      debug(`Try to create target directory: ${path}`)
+      if (!dryRun) {
+        await mkdirAsync(path, { recursive: true })
+      }
+    } catch (e) {
+      throw new Error(`Failed to create target directory: ${path}`, {
+        cause: e,
+      })
+    }
+  }
+}
+
 function generateFiles(options: NewOptions): Output[] {
   return [
     generateCargoToml,
@@ -157,10 +183,7 @@ function generateGithubWorkflow(options: NewOptions): Output | null {
 
   return {
     target: './.github/workflows/ci.yml',
-    content: createGithubActionsCIYml(
-      getBinaryName(options.name),
-      options.targets,
-    ),
+    content: createGithubActionsCIYml(options.targets),
   }
 }
 

package/src/api/pre-publish.ts

@@ -129,11 +129,14 @@ export async function prePublish(userOptions: PrePublishOptions) {
   if (!options.dryRun) {
     await version(userOptions)
     await updatePackageJson(packageJsonPath, {
-      optionalDependencies: targets.reduce((deps, target) => {
-        deps[`${packageName}-${target.platformArchABI}`] = packageJson.version
-
-        return deps
-      }, {} as Record<string, string>),
+      optionalDependencies: targets.reduce(
+        (deps, target) => {
+          deps[`${packageName}-${target.platformArchABI}`] = packageJson.version
+
+          return deps
+        },
+        {} as Record<string, string>,
+      ),
     })
   }
 

package/src/api/templates/.gitignore.ts

@@ -195,4 +195,5 @@ Cargo.lock
 !.yarn/versions
 
 *.node
+*.wasm
 `