@napi-rs/cli 3.0.0-alpha.10 → 3.0.0-alpha.100

package/src/api/pre-publish.ts

@@ -1,6 +1,6 @@
-import { execSync } from 'child_process'
-import { existsSync, statSync } from 'fs'
-import { join, relative, resolve } from 'path'
+import { execSync } from 'node:child_process'
+import { existsSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
 
 import { Octokit } from '@octokit/rest'
 
@@ -31,10 +31,13 @@ export async function prePublish(userOptions: PrePublishOptions) {
 
   const options = applyDefaultPrePublishOptions(userOptions)
 
-  const packageJsonPath = relative(options.cwd, options.packageJsonPath)
+  const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
 
   const { packageJson, targets, packageName, binaryName, npmClient } =
-    await readNapiConfig(packageJsonPath)
+    await readNapiConfig(
+      packageJsonPath,
+      options.configPath ? resolve(options.cwd, options.configPath) : undefined,
+    )
 
   async function createGhRelease(packageName: string, version: string) {
     if (!options.ghRelease) {
@@ -150,7 +153,9 @@ export async function prePublish(userOptions: PrePublishOptions) {
       options.npmDir,
       `${target.platformArchABI}`,
     )
-    const filename = `${binaryName}.${target.platformArchABI}.node`
+    const ext =
+      target.platform === 'wasi' || target.platform === 'wasm' ? 'wasm' : 'node'
+    const filename = `${binaryName}.${target.platformArchABI}.${ext}`
     const dstPath = join(pkgDir, filename)
 
     if (!options.dryRun) {
@@ -159,10 +164,12 @@ export async function prePublish(userOptions: PrePublishOptions) {
         continue
       }
 
-      execSync(`${npmClient} publish`, {
-        cwd: pkgDir,
-        env: process.env,
-      })
+      if (!options.skipOptionalPublish) {
+        execSync(`${npmClient} publish`, {
+          cwd: pkgDir,
+          env: process.env,
+        })
+      }
 
       if (options.ghRelease && repo && owner) {
         debug.info(`Creating GitHub release ${pkgInfo.tag}`)
@@ -187,7 +194,8 @@ export async function prePublish(userOptions: PrePublishOptions) {
               'content-length': dstFileStats.size,
               'content-type': 'application/octet-stream',
             },
-            data: await readFileAsync(dstPath, { encoding: 'utf-8' }),
+            // @ts-expect-error octokit types are wrong
+            data: await readFileAsync(dstPath),
           })
           debug.info(`GitHub release created`)
           debug.info(`Download URL: %s`, assetInfo.data.browser_download_url)

package/src/api/rename.ts

@@ -1,14 +1,19 @@
-import { resolve } from 'path'
+import { existsSync } from 'node:fs'
+import { rename } from 'node:fs/promises'
+import { resolve, join } from 'node:path'
 
+import { parse as parseToml, stringify as stringifyToml } from '@std/toml'
+import { load as yamlParse, dump as yamlStringify } from 'js-yaml'
 import { isNil, merge, omitBy, pick } from 'lodash-es'
+import { findUp } from 'find-up'
 
 import { applyDefaultRenameOptions, RenameOptions } from '../def/rename.js'
-import { readFileAsync, writeFileAsync } from '../utils/index.js'
-
-import { createNpmDirs } from './create-npm-dirs.js'
+import { readConfig, readFileAsync, writeFileAsync } from '../utils/index.js'
 
 export async function renameProject(userOptions: RenameOptions) {
   const options = applyDefaultRenameOptions(userOptions)
+  const napiConfig = await readConfig(options)
+  const oldName = napiConfig.binaryName
 
   const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
   const cargoTomlPath = resolve(options.cwd, options.manifestPath)
@@ -30,22 +35,103 @@ export async function renameProject(userOptions: RenameOptions) {
     },
   )
 
+  if (options.configPath) {
+    const configPath = resolve(options.cwd, options.configPath)
+    const configContent = await readFileAsync(configPath, 'utf8')
+    const configData = JSON.parse(configContent)
+    configData.binaryName = options.binaryName
+    configData.packageName = options.packageName
+    await writeFileAsync(configPath, JSON.stringify(configData, null, 2))
+  }
+
   await writeFileAsync(
     packageJsonPath,
     JSON.stringify(packageJsonData, null, 2),
   )
 
-  let tomlContent = await readFileAsync(cargoTomlPath, 'utf8')
-  tomlContent = tomlContent.replace(
-    /name\s?=\s?"([\w+])"/,
-    `name = "${options.binaryName}"`,
-  )
-  await writeFileAsync(cargoTomlPath, tomlContent)
-
-  await createNpmDirs({
-    cwd: options.cwd,
-    packageJsonPath: options.packageJsonPath,
-    npmDir: options.npmDir,
-    dryRun: false,
-  })
+  const tomlContent = await readFileAsync(cargoTomlPath, 'utf8')
+  const cargoToml = parseToml(tomlContent) as any
+
+  // Update the package name
+  if (cargoToml.package && options.binaryName) {
+    // Sanitize the binary name for Rust package naming conventions
+    const sanitizedName = options.binaryName
+      .replace('@', '')
+      .replace('/', '_')
+      .replace(/-/g, '_')
+      .toLowerCase()
+    cargoToml.package.name = sanitizedName
+  }
+
+  // Stringify the updated TOML
+  const updatedTomlContent = stringifyToml(cargoToml)
+
+  await writeFileAsync(cargoTomlPath, updatedTomlContent)
+  if (oldName !== options.binaryName) {
+    const githubActionsPath = await findUp('.github', {
+      cwd: options.cwd,
+      type: 'directory',
+    })
+    if (githubActionsPath) {
+      const githubActionsCIYmlPath = join(
+        githubActionsPath,
+        'workflows',
+        'CI.yml',
+      )
+      if (existsSync(githubActionsCIYmlPath)) {
+        const githubActionsContent = await readFileAsync(
+          githubActionsCIYmlPath,
+          'utf8',
+        )
+        const githubActionsData = yamlParse(githubActionsContent) as any
+        if (githubActionsData.env?.APP_NAME) {
+          githubActionsData.env.APP_NAME = options.binaryName
+          await writeFileAsync(
+            githubActionsCIYmlPath,
+            yamlStringify(githubActionsData, {
+              lineWidth: -1,
+              noRefs: true,
+              sortKeys: false,
+            }),
+          )
+        }
+      }
+    }
+    const oldWasiBrowserBindingPath = join(
+      options.cwd,
+      `${oldName}.wasi-browser.js`,
+    )
+    if (existsSync(oldWasiBrowserBindingPath)) {
+      await rename(
+        oldWasiBrowserBindingPath,
+        join(options.cwd, `${options.binaryName}.wasi-browser.js`),
+      )
+    }
+    const oldWasiBindingPath = join(options.cwd, `${oldName}.wasi.cjs`)
+    if (existsSync(oldWasiBindingPath)) {
+      await rename(
+        oldWasiBindingPath,
+        join(options.cwd, `${options.binaryName}.wasi.cjs`),
+      )
+    }
+    const gitAttributesPath = join(options.cwd, '.gitattributes')
+    if (existsSync(gitAttributesPath)) {
+      const gitAttributesContent = await readFileAsync(
+        gitAttributesPath,
+        'utf8',
+      )
+      const gitAttributesData = gitAttributesContent
+        .split('\n')
+        .map((line) => {
+          return line
+            .replace(
+              `${oldName}.wasi-browser.js`,
+              `${options.binaryName}.wasi-browser.js`,
+            )
+            .replace(`${oldName}.wasi.cjs`, `${options.binaryName}.wasi.cjs`)
+        })
+        .join('\n')
+      await writeFileAsync(gitAttributesPath, gitAttributesData)
+    }
+  }
 }

package/src/api/templates/index.ts

@@ -1,8 +1 @@
-export * from './.gitignore.js'
-export * from './.npmignore.js'
-export * from './build.rs.js'
-export * from './cargo.toml.js'
-export * from './ci.yml.js'
-export * from './lib.rs.js'
-export * from './package.json.js'
 export * from './js-binding.js'

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

@@ -3,18 +3,59 @@ export function createCjsBinding(
   pkgName: string,
   idents: string[],
 ): string {
-  return `// prettier-ignore
+  return `${bindingHeader}
+const { createRequire } = require('node:module')
+require = createRequire(__filename)
+
+${createCommonBinding(localName, pkgName)}
+module.exports = nativeBinding
+${idents
+  .map((ident) => `module.exports.${ident} = nativeBinding.${ident}`)
+  .join('\n')}
+`
+}
+
+export function createEsmBinding(
+  localName: string,
+  pkgName: string,
+  idents: string[],
+): string {
+  return `${bindingHeader}
+import { createRequire } from 'node:module'
+const require = createRequire(import.meta.url)
+const __dirname = new URL('.', import.meta.url).pathname
+
+${createCommonBinding(localName, pkgName)}
+const { ${idents.join(', ')} } = nativeBinding
+${idents.map((ident) => `export { ${ident} }`).join('\n')}
+`
+}
+
+const bindingHeader = `// prettier-ignore
 /* eslint-disable */
+// @ts-nocheck
 /* auto-generated by NAPI-RS */
+`
 
-const { existsSync, readFileSync } = require('fs')
-const { join } = require('path')
-
-const { platform, arch } = process
+function createCommonBinding(localName: string, pkgName: string): string {
+  function requireTuple(tuple: string, identSize = 8) {
+    const identLow = ' '.repeat(identSize - 2)
+    const ident = ' '.repeat(identSize)
+    return `try {
+${ident}return require('./${localName}.${tuple}.node')
+${identLow}} catch (e) {
+${ident}loadErrors.push(e)
+${identLow}}
+${identLow}try {
+${ident}return require('${pkgName}-${tuple}')
+${identLow}} catch (e) {
+${ident}loadErrors.push(e)
+${identLow}}`
+  }
 
+  return `const { readFileSync } = require('node:fs')
 let nativeBinding = null
-let localFileExisted = false
-let loadError = null
+const loadErrors = []
 
 const isMusl = () => {
   let musl = false
@@ -41,7 +82,11 @@ const isMuslFromFilesystem = () => {
 }
 
 const isMuslFromReport = () => {
-  const report = typeof process.report.getReport === 'function' ? process.report.getReport() : null
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
   if (!report) {
     return null
   }
@@ -65,232 +110,126 @@ const isMuslFromChildProcess = () => {
   }
 }
 
-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 {
-            nativeBinding = require('${pkgName}-android-arm64')
-          }
-        } 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 {
-            nativeBinding = require('${pkgName}-android-arm-eabi')
-          }
-        } catch (e) {
-          loadError = e
-        }
-        break
-      default:
-        throw new Error(\`Unsupported architecture on Android \${arch}\`)
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+    try {
+      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
     }
-    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}\`)
+  } else if (process.platform === 'android') {
+    if (process.arch === 'arm64') {
+      ${requireTuple('android-arm64')}
+    } else if (process.arch === 'arm') {
+      ${requireTuple('android-arm-eabi')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on Android \${process.arch}\`))
     }
-    break
-  case 'darwin':
-    localFileExisted = existsSync(join(__dirname, '${localName}.darwin-universal.node'))
-    try {
-      if (localFileExisted) {
-        nativeBinding = require('./${localName}.darwin-universal.node')
+  } else if (process.platform === 'win32') {
+    if (process.arch === 'x64') {
+      ${requireTuple('win32-x64-msvc')}
+    } else if (process.arch === 'ia32') {
+      ${requireTuple('win32-ia32-msvc')}
+    } else if (process.arch === 'arm64') {
+      ${requireTuple('win32-arm64-msvc')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on Windows: \${process.arch}\`))
+    }
+  } else if (process.platform === 'darwin') {
+    ${requireTuple('darwin-universal', 6)}
+    if (process.arch === 'x64') {
+      ${requireTuple('darwin-x64')}
+    } else if (process.arch === 'arm64') {
+      ${requireTuple('darwin-arm64')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on macOS: \${process.arch}\`))
+    }
+  } else if (process.platform === 'freebsd') {
+    if (process.arch === 'x64') {
+      ${requireTuple('freebsd-x64')}
+    } else if (process.arch === 'arm64') {
+      ${requireTuple('freebsd-arm64')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on FreeBSD: \${process.arch}\`))
+    }
+  } else if (process.platform === 'linux') {
+    if (process.arch === 'x64') {
+      if (isMusl()) {
+        ${requireTuple('linux-x64-musl', 10)}
+      } else {
+        ${requireTuple('linux-x64-gnu', 10)}
+      }
+    } else if (process.arch === 'arm64') {
+      if (isMusl()) {
+        ${requireTuple('linux-arm64-musl', 10)}
+      } else {
+        ${requireTuple('linux-arm64-gnu', 10)}
+      }
+    } else if (process.arch === 'arm') {
+      if (isMusl()) {
+        ${requireTuple('linux-arm-musleabihf', 10)}
       } else {
-        nativeBinding = require('${pkgName}-darwin-universal')
+        ${requireTuple('linux-arm-gnueabihf', 10)}
       }
-      break
-    } 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}\`)
+    } else if (process.arch === 'riscv64') {
+      if (isMusl()) {
+        ${requireTuple('linux-riscv64-musl', 10)}
+      } else {
+        ${requireTuple('linux-riscv64-gnu', 10)}
+      }
+    } else if (process.arch === 'ppc64') {
+      ${requireTuple('linux-ppc64-gnu')}
+    } else if (process.arch === 's390x') {
+      ${requireTuple('linux-s390x-gnu')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on Linux: \${process.arch}\`))
+    }
+  } else if (process.platform === 'openharmony') {
+    if (process.arch === 'arm64') {
+      ${requireTuple('linux-arm64-ohos')}
+    } else if (process.arch === 'x64') {
+      ${requireTuple('linux-x64-ohos')}
+    } else if (process.arch === 'arm') {
+      ${requireTuple('linux-arm-ohos')}
+    } else {
+      loadErrors.push(new Error(\`Unsupported architecture on OpenHarmony: \${process.arch}\`))
     }
-    break
-  case 'freebsd':
-    if (arch !== 'x64') {
-      throw new Error(\`Unsupported architecture on FreeBSD: \${arch}\`)
+  } else {
+    loadErrors.push(new Error(\`Unsupported OS: \${process.platform}, architecture: \${process.arch}\`))
+  }
+}
+
+nativeBinding = requireNative()
+
+if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+  try {
+    nativeBinding = require('./${localName}.wasi.cjs')
+  } catch (err) {
+    if (process.env.NAPI_RS_FORCE_WASI) {
+      loadErrors.push(err)
     }
-    localFileExisted = existsSync(join(__dirname, '${localName}.freebsd-x64.node'))
+  }
+  if (!nativeBinding) {
     try {
-      if (localFileExisted) {
-        nativeBinding = require('./${localName}.freebsd-x64.node')
-      } else {
-        nativeBinding = require('${pkgName}-freebsd-x64')
+      nativeBinding = require('${pkgName}-wasm32-wasi')
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err)
       }
-    } catch (e) {
-      loadError = e
-    }
-    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
-      default:
-        throw new Error(\`Unsupported architecture on Linux: \${arch}\`)
     }
-    break
-  default:
-    throw new Error(\`Unsupported OS: \${platform}, architecture: \${arch}\`)
+  }
 }
 
 if (!nativeBinding) {
-  if (loadError) {
-    throw loadError
+  if (loadErrors.length > 0) {
+    throw new Error(
+      \`Cannot find native binding. \` +
+        \`npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). \` +
+        'Please try \`npm i\` again after removing both package-lock.json and node_modules directory.',
+      { cause: loadErrors }
+    )
   }
   throw new Error(\`Failed to load native binding\`)
 }
-
-${idents
-  .map((ident) => `module.exports.${ident} = nativeBinding.${ident}`)
-  .join('\n')}
 `
 }