@napi-rs/cli 2.15.2 → 3.0.0-alpha.0

package/src/utils/__tests__/version.spec.ts

@@ -0,0 +1,13 @@
+import test from 'ava'
+
+import { napiEngineRequirement, NapiVersion } from '../version.js'
+
+test('should generate correct napi engine requirement', (t) => {
+  t.snapshot(
+    (
+      Object.values(NapiVersion).filter(
+        (v) => typeof v === 'number',
+      ) as NapiVersion[]
+    ).map(napiEngineRequirement),
+  )
+})

package/src/utils/cargo.ts

@@ -0,0 +1,35 @@
+import { execSync } from 'child_process'
+
+import { debug } from './log.js'
+
+export function tryInstallCargoBinary(name: string, bin: string) {
+  if (detectCargoBinary(bin)) {
+    debug('Cargo binary already installed: %s', name)
+    return
+  }
+
+  try {
+    debug('Installing cargo binary: %s', name)
+    execSync(`cargo install ${name}`, {
+      stdio: 'inherit',
+    })
+  } catch (e) {
+    throw new Error(`Failed to install cargo binary: ${name}`, {
+      cause: e,
+    })
+  }
+}
+
+function detectCargoBinary(bin: string) {
+  debug('Detecting cargo binary: %s', bin)
+  try {
+    execSync(`cargo help ${bin}`, {
+      stdio: 'ignore',
+    })
+    debug('Cargo binary detected: %s', bin)
+    return true
+  } catch (e) {
+    debug('Cargo binary not detected: %s', bin)
+    return false
+  }
+}

package/src/utils/ci.ts

@@ -0,0 +1,102 @@
+import { TargetTriple } from './target.js'
+
+export const CIConfig: Partial<
+  Record<
+    TargetTriple,
+    {
+      host: string
+      build_image?: string
+      build_setup?: string[]
+      test?: boolean
+      test_image?: string
+      test_setup?: string[]
+      yarn_cpu?: string
+      yarn_libc?: string
+    }
+  >
+> = {
+  'x86_64-apple-darwin': {
+    host: 'macos-latest',
+  },
+  'x86_64-pc-windows-msvc': {
+    host: 'windows-latest',
+  },
+  'i686-pc-windows-msvc': {
+    host: 'windows-latest',
+    test: false,
+  },
+  'x86_64-unknown-linux-gnu': {
+    host: 'ubuntu-latest',
+    build_image: 'ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian',
+  },
+  'x86_64-unknown-linux-musl': {
+    host: 'ubuntu-latest',
+    build_image: 'ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine',
+    test_image: 'node:${{ matrix.node }}-alpine',
+    yarn_libc: 'musl',
+  },
+  'aarch64-apple-darwin': {
+    host: 'macos-latest',
+    build_setup: [
+      'sudo rm -Rf /Library/Developer/CommandLineTools/SDKs/*',
+      'export CC=$(xcrun -f clang)',
+      'export CXX=$(xcrun -f clang++)',
+      'export SDK_ROOT=$(xcrun --sdk macosx --show-sdk-path)',
+      'export CFLAGS="-isysroot $SDK_ROOT -isystem $SDK_ROOT"',
+    ],
+    test: false,
+  },
+  'aarch64-unknown-linux-gnu': {
+    host: 'ubuntu-latest',
+    build_image: 'ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-debian-aarch64',
+    build_setup: [
+      'sudo apt-get update',
+      'sudo apt-get install g++-aarch64-linux-gnu gcc-aarch64-linux-gnu -y',
+      'export CARGO_BUILD_TARGET=x86_64-unknown-linux-gnu',
+    ],
+    test_image: 'ghcr.io/napi-rs/napi-rs/nodejs:aarch64-${{ matrix.node }}',
+    yarn_cpu: 'arm64',
+  },
+  'aarch64-unknown-linux-musl': {
+    host: 'ubuntu-latest',
+    build_image: 'ghcr.io/napi-rs/napi-rs/nodejs-rust:lts-alpine',
+    build_setup: ['rustup target add aarch64-unknown-linux-musl'],
+    test_image: 'multiarch/alpine:aarch64-latest-stable',
+    test_setup: ['apk add nodejs npm yarn'],
+    yarn_cpu: 'arm64',
+    yarn_libc: 'musl',
+  },
+  'aarch64-pc-windows-msvc': {
+    host: 'windows-latest',
+    test: false,
+  },
+  'armv7-unknown-linux-gnueabihf': {
+    host: 'ubuntu-latest',
+    build_setup: [
+      'sudo apt-get update',
+      'sudo apt-get install gcc-arm-linux-gnueabihf g++-arm-linux-gnueabihf -y',
+    ],
+    yarn_cpu: 'arm',
+    test_image: 'ghcr.io/napi-rs/napi-rs/nodejs:armhf-${{ matrix.node }}',
+  },
+  'aarch64-linux-android': {
+    host: 'ubuntu-latest',
+    build_setup: [
+      'export CARGO_TARGET_AARCH64_LINUX_ANDROID_LINKER="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android24-clang"',
+      'export CC="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android24-clang"',
+      'export CXX="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/aarch64-linux-android24-clang++"',
+      'export PATH="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:${PATH}"',
+    ],
+    test: false,
+  },
+  'armv7-linux-androideabi': {
+    host: 'ubuntu-latest',
+    build_setup: [
+      'export CARGO_TARGET_ARMV7_LINUX_ANDROIDEABI_LINKER="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi24-clang"',
+      'export CC="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi24-clang"',
+      'export CXX="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin/armv7a-linux-androideabi24-clang++"',
+      'export PATH="${ANDROID_NDK_HOME}/toolchains/llvm/prebuilt/linux-x86_64/bin:${PATH}"',
+    ],
+    test: false,
+  },
+}

package/src/utils/config.ts

@@ -0,0 +1,123 @@
+import { merge, omit } from 'lodash-es'
+
+import { fileExists, readFileAsync } from './misc.js'
+import { DEFAULT_TARGETS, parseTriple, Target } from './target.js'
+
+interface UserNapiConfig {
+  /**
+   * Name of the binary to be generated, default to `index`
+   */
+  binaryName?: string
+  /**
+   * Name of the npm package, default to the name of root package.json name
+   *
+   * Always given `@scope/pkg` and arch suffix will be appended like `@scope/pkg-linux-gnu-x64`
+   */
+  packageName?: string
+  /**
+   * All targets the crate will be compiled for
+   */
+  targets?: string[]
+
+  /**
+   * The npm client project uses.
+   */
+  npmClient?: string
+
+  /**
+   * @deprecated binaryName instead
+   */
+  name?: string
+  /**
+   * @deprecated use packageName instead
+   */
+  package?: {
+    name?: string
+  }
+  /**
+   * @deprecated use targets instead
+   */
+  triples?: {
+    /**
+     * Whether enable default targets
+     */
+    default: boolean
+    /**
+     * Additional targets to be compiled for
+     */
+    additional?: string[]
+  }
+}
+
+interface CommonPackageJsonFields {
+  name: string
+  version: string
+  description?: string
+  keywords?: string[]
+  author?: string
+  authors?: string[]
+  license?: string
+  repository?: any
+  homepage?: any
+  engines?: Record<string, string>
+  publishConfig?: any
+  bugs?: any
+  // eslint-disable-next-line no-use-before-define
+  napi?: UserNapiConfig
+}
+
+export type NapiConfig = Required<
+  Pick<UserNapiConfig, 'binaryName' | 'packageName' | 'npmClient'>
+> & {
+  targets: Target[]
+  packageJson: CommonPackageJsonFields
+}
+
+export async function readNapiConfig(path: string): Promise<NapiConfig> {
+  if (!(await fileExists(path))) {
+    throw new Error(`napi-rs config not found at ${path}`)
+  }
+  // May support multiple config sources later on.
+  const content = await readFileAsync(path, 'utf8')
+  let pkgJson
+  try {
+    pkgJson = JSON.parse(content) as CommonPackageJsonFields
+  } catch (e) {
+    throw new Error('Failed to parse napi-rs config', {
+      cause: e,
+    })
+  }
+
+  const userNapiConfig = pkgJson.napi ?? {}
+  const napiConfig: NapiConfig = merge(
+    {
+      binaryName: 'index',
+      packageName: pkgJson.name,
+      targets: [],
+      packageJson: pkgJson,
+      npmClient: 'npm',
+    },
+    omit(userNapiConfig, 'targets'),
+  )
+
+  let targets: string[] = userNapiConfig.targets ?? []
+
+  // compatible with old config
+  if (userNapiConfig.package?.name) {
+    napiConfig.packageName = userNapiConfig.package.name
+  }
+
+  if (!targets.length) {
+    if (userNapiConfig.triples?.default) {
+      targets = targets.concat(DEFAULT_TARGETS)
+    }
+
+    if (userNapiConfig.triples?.additional?.length) {
+      targets = targets.concat(userNapiConfig.triples.additional)
+    }
+  }
+
+  napiConfig.targets = targets.map(parseTriple)
+
+  return napiConfig
+}

package/src/utils/index.ts

@@ -0,0 +1,9 @@
+export * from './ci.js'
+export * from './log.js'
+export * from './misc.js'
+export * from './target.js'
+export * from './version.js'
+export * from './metadata.js'
+export * from './config.js'
+export * from './cargo.js'
+export * from './typegen.js'

package/src/utils/log.ts

@@ -0,0 +1,34 @@
+import * as colors from 'colorette'
+import rawDebug from 'debug'
+
+// debug('%i', 'This is an info')
+rawDebug.formatters.i = (v) => {
+  return colors.green(v)
+}
+
+declare module 'debug' {
+  interface Debugger {
+    info: typeof console.error
+    warn: typeof console.error
+    error: typeof console.error
+  }
+}
+
+export const debugFactory = (namespace: string) => {
+  const debug = rawDebug(`napi:${namespace}`)
+
+  debug.info = (...args: any[]) =>
+    console.error(colors.black(colors.bgGreen(' INFO ')), ...args)
+  debug.warn = (...args: any[]) =>
+    console.error(colors.black(colors.bgYellow(' WARNING ')), ...args)
+  debug.error = (...args: any[]) =>
+    console.error(
+      colors.white(colors.bgRed(' ERROR ')),
+      ...args.map((arg) =>
+        arg instanceof Error ? arg.stack ?? arg.message : arg,
+      ),
+    )
+
+  return debug
+}
+export const debug = debugFactory('utils')

package/src/utils/metadata.ts

@@ -0,0 +1,59 @@
+import { execSync } from 'child_process'
+import fs from 'fs'
+
+export type CrateTargetKind =
+  | 'bin'
+  | 'example'
+  | 'test'
+  | 'bench'
+  | 'lib'
+  | 'rlib'
+  | 'cdylib'
+  | 'custom-build'
+
+export interface CrateTarget {
+  name: string
+  kind: CrateTargetKind[]
+  crate_types: CrateTargetKind[]
+}
+
+export interface Crate {
+  id: string
+  name: string
+  src_path: string
+  version: string
+  edition: string
+  targets: CrateTarget[]
+  features: Record<string, string[]>
+  manifest_path: string
+}
+
+export interface CargoWorkspaceMetadata {
+  version: number
+  packages: Crate[]
+  workspace_members: string[]
+  target_directory: string
+  workspace_root: string
+}
+
+export function parseMetadata(manifestPath: string) {
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error(`No crate found in manifest: ${manifestPath}`)
+  }
+
+  const cmd = `cargo metadata --manifest-path ${manifestPath} --format-version 1 --no-deps`
+
+  try {
+    const output = execSync(cmd, {
+      encoding: 'utf-8',
+    })
+    return JSON.parse(output) as CargoWorkspaceMetadata
+  } catch (e) {
+    throw new Error(
+      `Failed to parse cargo metadata output by command: ${cmd}`,
+      {
+        cause: e,
+      },
+    )
+  }
+}

package/src/utils/misc.ts

@@ -0,0 +1,45 @@
+import { readFile, writeFile, copyFile, mkdir, unlink, stat, readdir } from 'fs'
+import { createRequire } from 'module'
+import { promisify } from 'util'
+
+import { debug } from './log.js'
+
+const require = createRequire(import.meta.url)
+const pkgJson = require('../../package.json')
+
+export const readFileAsync = promisify(readFile)
+export const writeFileAsync = promisify(writeFile)
+export const unlinkAsync = promisify(unlink)
+export const copyFileAsync = promisify(copyFile)
+export const mkdirAsync = promisify(mkdir)
+export const statAsync = promisify(stat)
+export const readdirAsync = promisify(readdir)
+
+export async function fileExists(path: string) {
+  const exists = await statAsync(path)
+    .then(() => true)
+    .catch(() => false)
+  return exists
+}
+
+export function pick<O, K extends keyof O>(o: O, ...keys: K[]): Pick<O, K> {
+  return keys.reduce((acc, key) => {
+    acc[key] = o[key]
+    return acc
+  }, {} as O)
+}
+
+export async function updatePackageJson(
+  path: string,
+  partial: Record<string, any>,
+) {
+  const exists = await fileExists(path)
+  if (!exists) {
+    debug(`File not exists ${path}`)
+    return
+  }
+  const old = require(path)
+  await writeFileAsync(path, JSON.stringify({ ...old, ...partial }, null, 2))
+}
+
+export const CLI_VERSION = pkgJson.version

package/src/utils/target.ts

@@ -0,0 +1,145 @@
+import { execSync } from 'child_process'
+
+export const AVAILABLE_TARGETS = [
+  'aarch64-apple-darwin',
+  'aarch64-linux-android',
+  'aarch64-unknown-linux-gnu',
+  'aarch64-unknown-linux-musl',
+  'aarch64-pc-windows-msvc',
+  'x86_64-apple-darwin',
+  'x86_64-pc-windows-msvc',
+  'x86_64-unknown-linux-gnu',
+  'x86_64-unknown-linux-musl',
+  'x86_64-unknown-freebsd',
+  'i686-pc-windows-msvc',
+  'armv7-unknown-linux-gnueabihf',
+  'armv7-linux-androideabi',
+  'universal-apple-darwin',
+] as const
+
+export type TargetTriple = (typeof AVAILABLE_TARGETS)[number]
+
+export const DEFAULT_TARGETS = [
+  'x86_64-apple-darwin',
+  'x86_64-pc-windows-msvc',
+  'x86_64-unknown-linux-gnu',
+] as const
+
+export const TARGET_LINKER: Record<string, string> = {
+  'aarch64-unknown-linux-gnu': 'aarch64-linux-gnu-gcc',
+  'armv7-unknown-linux-gnueabihf': 'arm-linux-gnueabihf-gcc',
+  'aarch64-unknown-linux-musl': 'aarch64-linux-musl-gcc',
+}
+
+// https://nodejs.org/api/process.html#process_process_arch
+type NodeJSArch =
+  | 'arm'
+  | 'arm64'
+  | 'ia32'
+  | 'mips'
+  | 'mipsel'
+  | 'ppc'
+  | 'ppc64'
+  | 's390'
+  | 's390x'
+  | 'x32'
+  | 'x64'
+  | 'universal'
+
+const CpuToNodeArch: Record<string, NodeJSArch> = {
+  x86_64: 'x64',
+  aarch64: 'arm64',
+  i686: 'ia32',
+  armv7: 'arm',
+}
+
+export const NodeArchToCpu: Record<string, string> = {
+  x64: 'x86_64',
+  arm64: 'aarch64',
+  ia32: 'i686',
+  arm: 'armv7',
+}
+
+const SysToNodePlatform: Record<string, NodeJS.Platform> = {
+  linux: 'linux',
+  freebsd: 'freebsd',
+  darwin: 'darwin',
+  windows: 'win32',
+}
+
+export const UniArchsByPlatform: Partial<
+  Record<NodeJS.Platform, NodeJSArch[]>
+> = {
+  darwin: ['x64', 'arm64'],
+}
+
+export interface Target {
+  triple: string
+  platformArchABI: string
+  platform: NodeJS.Platform
+  arch: NodeJSArch
+  abi: string | null
+}
+
+/**
+ * A triple is a specific format for specifying a target architecture.
+ * Triples may be referred to as a target triple which is the architecture for the artifact produced, and the host triple which is the architecture that the compiler is running on.
+ * The general format of the triple is `<arch><sub>-<vendor>-<sys>-<abi>` where:
+ *   - `arch` = The base CPU architecture, for example `x86_64`, `i686`, `arm`, `thumb`, `mips`, etc.
+ *   - `sub` = The CPU sub-architecture, for example `arm` has `v7`, `v7s`, `v5te`, etc.
+ *   - `vendor` = The vendor, for example `unknown`, `apple`, `pc`, `nvidia`, etc.
+ *   - `sys` = The system name, for example `linux`, `windows`, `darwin`, etc. none is typically used for bare-metal without an OS.
+ *   - `abi` = The ABI, for example `gnu`, `android`, `eabi`, etc.
+ */
+export function parseTriple(rawTriple: string): Target {
+  const triple = rawTriple.endsWith('eabi')
+    ? `${rawTriple.slice(0, -4)}-eabi`
+    : rawTriple
+  const triples = triple.split('-')
+  let cpu: string
+  let sys: string
+  let abi: string | null = null
+  if (triples.length === 2) {
+    // aarch64-fuchsia
+    // ^ cpu   ^ sys
+    ;[cpu, sys] = triples
+  } else {
+    // aarch64-unknown-linux-musl
+    // ^ cpu           ^ sys ^ abi
+    // aarch64-apple-darwin
+    // ^ cpu         ^ sys  (abi is None)
+    ;[cpu, , sys, abi = null] = triples
+  }
+
+  const platform = SysToNodePlatform[sys] ?? (sys as NodeJS.Platform)
+  const arch = CpuToNodeArch[cpu] ?? (cpu as NodeJSArch)
+  return {
+    triple: rawTriple,
+    platformArchABI: abi ? `${platform}-${arch}-${abi}` : `${platform}-${arch}`,
+    platform,
+    arch,
+    abi,
+  }
+}
+
+export function getSystemDefaultTarget(): Target {
+  const host = execSync(`rustc -vV`, {
+    env: process.env,
+  })
+    .toString('utf8')
+    .split('\n')
+    .find((line) => line.startsWith('host: '))
+  const triple = host?.slice('host: '.length)
+  if (!triple) {
+    throw new TypeError(`Can not parse target triple from host`)
+  }
+  return parseTriple(triple)
+}
+
+export function getTargetLinker(target: string): string | undefined {
+  return TARGET_LINKER[target]
+}
+
+export function targetToEnvVar(target: string): string {
+  return target.replace(/-/g, '_').toUpperCase()
+}