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

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

@@ -1,130 +1,235 @@
-/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
+export function createCjsBinding(
+  localName: string,
+  pkgName: string,
+  idents: string[],
+): string {
+  return `${bindingHeader}
+const { createRequire } = require('node:module')
+require = createRequire(__filename)
 
-function loadNapiModule(binaryName: string, packageName: string) {
-  const { existsSync, readFileSync } = require('fs')
-  const { join } = require('path')
-  const { platform, arch } = process
+${createCommonBinding(localName, pkgName)}
+module.exports = nativeBinding
+${idents
+  .map((ident) => `module.exports.${ident} = nativeBinding.${ident}`)
+  .join('\n')}
+`
+}
 
-  const candidates: string[] = []
+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
 
-  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
+${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 */
+`
+
+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
+const loadErrors = []
+
+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')
-          } else {
-            candidates.push('linux-x64-gnu')
-          }
-          break
-        case 'arm64':
-          if (isMusl()) {
-            candidates.push('linux-arm64-musl')
-          } else {
-            candidates.push('linux-arm64-gnu')
-          }
-          break
-        case 'arm':
-          candidates.push('linux-arm-gnueabihf')
-          break
-      }
-      break
+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
   }
+}
 
-  let nativeBinding: any
-  let loadError: any
+const isMuslFromReport = () => {
+  let report = null
+  if (typeof process.report?.getReport === 'function') {
+    process.report.excludeNetwork = true
+    report = process.report.getReport()
+  }
+  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
+}
 
-  for (const suffix of candidates) {
-    const localPath = join(__dirname, `${binaryName}.${suffix}.node`)
-    const pkgPath = `${packageName}-${suffix}`
+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
+  }
+}
 
+function requireNative() {
+  if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
     try {
-      if (existsSync(localPath)) {
-        nativeBinding = require(localPath)
+      nativeBinding = require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+    } catch (err) {
+      loadErrors.push(err)
+    }
+  } 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}\`))
+    }
+  } 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 {
-        nativeBinding = require(pkgPath)
+        ${requireTuple('linux-x64-gnu', 10)}
       }
-    } catch (e) {
-      loadError = e
-      continue
+    } 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 {
+        ${requireTuple('linux-arm-gnueabihf', 10)}
+      }
+    } 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}\`))
     }
-
-    loadError = null
-    break
+  } 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}\`))
+    }
+  } 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)
+    }
+  }
   if (!nativeBinding) {
-    if (loadError) {
-      throw loadError
+    try {
+      nativeBinding = require('${pkgName}-wasm32-wasi')
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err)
+      }
     }
-
-    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
   }
-
-  return nativeBinding
 }
 
-export function createJsBinding(localName: string, pkgName: string): string {
-  return `${loadNapiModule.toString()}
-
-module.exports = loadNapiModule('${localName}', '${pkgName}')
+if (!nativeBinding) {
+  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\`)
+}
 `
 }