@napi-rs/cli 3.7.3 → 3.7.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@napi-rs/cli",
-  "version": "3.7.3",
+  "version": "3.7.4",
   "description": "Cli tools for napi-rs",
   "author": "LongYinan <lynweklm@gmail.com>",
   "homepage": "https://napi.rs/",
@@ -84,7 +84,7 @@
     "ava": "^8.0.1",
     "empathic": "^2.0.1",
     "env-paths": "^4.0.0",
-    "oxc-parser": "^0.139.0",
+    "oxc-parser": "^0.140.0",
     "prettier": "^3.8.3",
     "tsdown": "^0.22.2",
     "tslib": "^2.8.1",

package/src/api/build.ts

@@ -16,6 +16,7 @@ import {
   DEFAULT_TYPE_DEF_HEADER,
   fileExists,
   getSystemDefaultTarget,
+  getNapiDeriveDependentCrates,
   getTargetLinker,
   mkdirAsync,
   type NapiConfig,
@@ -79,7 +80,11 @@ export async function buildProject(rawOptions: BuildOptions) {
   const resolvePath = (...paths: string[]) => resolve(options.cwd, ...paths)
 
   const manifestPath = resolvePath(options.manifestPath ?? 'Cargo.toml')
-  const metadata = await parseMetadata(manifestPath)
+  const metadata = await parseMetadata(manifestPath, {
+    features: options.features,
+    allFeatures: options.allFeatures,
+    noDefaultFeatures: options.noDefaultFeatures,
+  })
 
   const crate = metadata.packages.find((p) => {
     // package with given name
@@ -734,11 +739,8 @@ class Builder {
 
   private setForceBuildEnvs(typeDefTmpFolder: string) {
     // dynamically check all napi-rs deps and set `NAPI_FORCE_BUILD_{uppercase(snake_case(name))} = timestamp`
-    this.metadata.packages.forEach((crate) => {
-      if (
-        crate.dependencies.some((d) => d.name === 'napi-derive') &&
-        !existsSync(join(typeDefTmpFolder, crate.name))
-      ) {
+    getNapiDeriveDependentCrates(this.metadata).forEach((crate) => {
+      if (!existsSync(join(typeDefTmpFolder, crate.name))) {
         this.envs[
           `NAPI_FORCE_BUILD_${crate.name.replace(/-/g, '_').toUpperCase()}`
         ] = Date.now().toString()

package/src/utils/__tests__/__fixtures__/optional-napi-derive/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+resolver = "2"
+members = ["napi-derive", "with-optional-derive", "main-crate"]

package/src/utils/__tests__/__fixtures__/optional-napi-derive/main-crate/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "main-crate"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+napi-derive = { path = "../napi-derive" }
+with-optional-derive = { path = "../with-optional-derive" }

package/src/utils/__tests__/__fixtures__/optional-napi-derive/main-crate/src/lib.rs

@@ -0,0 +1 @@
+

package/src/utils/__tests__/__fixtures__/optional-napi-derive/napi-derive/Cargo.toml

@@ -0,0 +1,5 @@
+# Stand-in for the real `napi-derive` so `cargo metadata` resolves offline.
+[package]
+name = "napi-derive"
+version = "0.0.0"
+edition = "2021"

package/src/utils/__tests__/__fixtures__/optional-napi-derive/napi-derive/src/lib.rs

@@ -0,0 +1 @@
+

package/src/utils/__tests__/__fixtures__/optional-napi-derive/with-optional-derive/Cargo.toml

@@ -0,0 +1,11 @@
+[package]
+name = "with-optional-derive"
+version = "0.0.0"
+edition = "2021"
+
+[dependencies]
+napi-derive = { path = "../napi-derive", optional = true }
+
+[features]
+default = []
+node = ["dep:napi-derive"]

package/src/utils/__tests__/__fixtures__/optional-napi-derive/with-optional-derive/src/lib.rs

@@ -0,0 +1 @@
+

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

@@ -1,10 +1,17 @@
 import { unlink, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 
 import test from 'ava'
 
-import { parseMetadata } from '../metadata.js'
+import { getNapiDeriveDependentCrates, parseMetadata } from '../metadata.js'
+
+const FIXTURE_WORKSPACE = join(
+  dirname(fileURLToPath(import.meta.url)),
+  '__fixtures__',
+  'optional-napi-derive',
+)
 
 test('should surface child process startup errors', async (t) => {
   const manifestPath = join(
@@ -26,3 +33,37 @@ test('should surface child process startup errors', async (t) => {
     await unlink(manifestPath)
   }
 })
+
+test('should exclude crates whose optional napi-derive dependency is disabled', async (t) => {
+  const metadata = await parseMetadata(
+    join(FIXTURE_WORKSPACE, 'main-crate', 'Cargo.toml'),
+  )
+  const dependentCrates = getNapiDeriveDependentCrates(metadata).map(
+    (crate) => crate.name,
+  )
+  t.deepEqual(dependentCrates, ['main-crate'])
+})
+
+test('should include crates whose optional napi-derive dependency is enabled via build features', async (t) => {
+  const metadata = await parseMetadata(
+    join(FIXTURE_WORKSPACE, 'with-optional-derive', 'Cargo.toml'),
+    {
+      features: ['node'],
+    },
+  )
+  const dependentCrates = getNapiDeriveDependentCrates(metadata).map(
+    (crate) => crate.name,
+  )
+  t.true(dependentCrates.includes('with-optional-derive'))
+})
+
+test('should fall back to declared dependencies when the resolve graph is unavailable', async (t) => {
+  const metadata = await parseMetadata(
+    join(FIXTURE_WORKSPACE, 'main-crate', 'Cargo.toml'),
+  )
+  metadata.resolve = null
+  const dependentCrates = getNapiDeriveDependentCrates(metadata)
+    .map((crate) => crate.name)
+    .sort()
+  t.deepEqual(dependentCrates, ['main-crate', 'with-optional-derive'])
+})

package/src/utils/metadata.ts

@@ -1,6 +1,10 @@
 import { spawn } from 'node:child_process'
 import fs from 'node:fs'
 
+import { debugFactory } from './log.js'
+
+const debug = debugFactory('metadata')
+
 export type CrateTargetKind =
   | 'bin'
   | 'example'
@@ -40,23 +44,110 @@ export interface Crate {
   }>
 }
 
+export interface CrateResolveNode {
+  id: string
+  deps: Array<{
+    name: string
+    pkg: string
+  }>
+  features: string[]
+}
+
 export interface CargoWorkspaceMetadata {
   version: number
   packages: Crate[]
   workspace_members: string[]
   target_directory: string
   workspace_root: string
+  resolve?: {
+    nodes: CrateResolveNode[]
+    root: string | null
+  } | null
+}
+
+export interface CargoFeatureOptions {
+  features?: string[]
+  allFeatures?: boolean
+  noDefaultFeatures?: boolean
+}
+
+// Crates that will actually compile `napi-derive` in this build, and are therefore
+// expected to emit a type-def intermediate file. Prefer the resolved dependency graph:
+// a crate whose `napi-derive` dependency is optional and stays disabled never emits a
+// type-def file, so force-building it would invalidate cargo's fingerprint on every
+// build without ever satisfying the type-def check. Fall back to declared dependencies
+// when the resolve graph is unavailable.
+export function getNapiDeriveDependentCrates(
+  metadata: CargoWorkspaceMetadata,
+): Crate[] {
+  const resolveNodes = metadata.resolve?.nodes
+  if (!resolveNodes) {
+    return metadata.packages.filter((crate) =>
+      crate.dependencies.some((d) => d.name === 'napi-derive'),
+    )
+  }
+  const napiDerivePackageIds = new Set(
+    metadata.packages.filter((p) => p.name === 'napi-derive').map((p) => p.id),
+  )
+  const dependentPackageIds = new Set(
+    resolveNodes
+      .filter((node) =>
+        node.deps.some((dep) => napiDerivePackageIds.has(dep.pkg)),
+      )
+      .map((node) => node.id),
+  )
+  return metadata.packages.filter((crate) => dependentPackageIds.has(crate.id))
 }
 
-export async function parseMetadata(manifestPath: string) {
+export async function parseMetadata(
+  manifestPath: string,
+  featureOptions?: CargoFeatureOptions,
+) {
   if (!fs.existsSync(manifestPath)) {
     throw new Error(`No crate found in manifest: ${manifestPath}`)
   }
 
+  const featureArgs: string[] = []
+  if (featureOptions?.allFeatures) {
+    featureArgs.push('--all-features')
+  }
+  if (featureOptions?.noDefaultFeatures) {
+    featureArgs.push('--no-default-features')
+  }
+  if (featureOptions?.features?.length) {
+    featureArgs.push('--features', featureOptions.features.join(','))
+  }
+
+  // Resolving with the build's feature flags keeps `metadata.resolve` in sync with what
+  // `cargo build` will actually compile. Feature flags are rejected in some setups
+  // (e.g. a virtual workspace root manifest), so fall back to a plain invocation.
+  if (featureArgs.length) {
+    try {
+      return await execCargoMetadata(manifestPath, featureArgs)
+    } catch (e) {
+      debug.warn(
+        `cargo metadata failed with feature flags, retrying without them: ${e}`,
+      )
+    }
+  }
+
+  return execCargoMetadata(manifestPath, [])
+}
+
+async function execCargoMetadata(manifestPath: string, extraArgs: string[]) {
   const childProcess = spawn(
     'cargo',
-    ['metadata', '--manifest-path', manifestPath, '--format-version', '1'],
-    { stdio: 'pipe' },
+    [
+      'metadata',
+      '--manifest-path',
+      manifestPath,
+      '--format-version',
+      '1',
+      ...extraArgs,
+    ],
+    {
+      stdio: 'pipe',
+    },
   )
 
   let stdout = ''