@napi-rs/cli 3.7.2 → 3.7.4

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

@@ -0,0 +1,22 @@
+# Snapshot report for `src/utils/__tests__/version.spec.ts`
+
+The actual snapshot is saved in `version.spec.ts.snap`.
+
+Generated by [AVA](https://avajs.dev).
+
+## should generate correct napi engine requirement
+
+> Snapshot 1
+
+    [
+      '>= 8.6.0 < 9 || >= 9.0.0 < 10 || >= 10.0.0',
+      '>= 8.10.0 < 9 || >= 9.3.0 < 10 || >= 10.0.0',
+      '>= 6.14.2 < 7 || >= 8.11.2 < 9 || >= 9.11.0 < 10 || >= 10.0.0',
+      '>= 10.16.0 < 11 || >= 11.8.0 < 12 || >= 12.0.0',
+      '>= 10.17.0 < 11 || >= 12.11.0 < 13 || >= 13.0.0',
+      '>= 10.20.0 < 11 || >= 12.17.0 < 13 || >= 14.0.0',
+      '>= 10.23.0 < 11 || >= 12.19.0 < 13 || >= 14.12.0 < 15 || >= 15.0.0',
+      '>= 12.22.0 < 13 || >= 14.17.0 < 15 || >= 15.12.0 < 16 || >= 16.0.0',
+      '>= 18.17.0 < 19 || >= 20.3.0 < 21 || >= 21.1.0',
+      '>= 22.14.0 < 23 || >= 23.6.0',
+    ]

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

@@ -0,0 +1,81 @@
+import { unlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import ava, { type TestFn } from 'ava'
+
+import {
+  type CommonPackageJsonFields,
+  type UserNapiConfig,
+  readNapiConfig,
+} from '../config.js'
+
+const NON_EXISTENT_FILE = 'non-existent-file'
+
+const test = ava as TestFn<{
+  configPath: string
+  packageJson: string
+  pkgJson: CommonPackageJsonFields
+  config: UserNapiConfig
+}>
+
+test.before(async (t) => {
+  const tmp = tmpdir()
+  const configPath = join(tmp, 'napi.json')
+  const packageJson = join(tmp, 'package.json')
+  const pkgJson = {
+    name: '@napi-rs/testing',
+    version: '0.0.0',
+    napi: {
+      binaryName: 'testing',
+      packageName: '@napi-rs/testing',
+      targets: [
+        'x86_64-unknown-linux-gnu',
+        'x86_64-pc-windows-msvc',
+        'x86_64-apple-darwin',
+      ],
+    },
+  }
+  await writeFile(packageJson, JSON.stringify(pkgJson, null, 2))
+  const config = {
+    binaryName: 'testing',
+    packageName: '@node-rs/testing',
+    targets: [
+      'x86_64-unknown-linux-gnu',
+      'x86_64-apple-darwin',
+      'aarch64-apple-darwin',
+    ],
+  }
+  await writeFile(configPath, JSON.stringify(config, null, 2))
+  t.context = { configPath, config, packageJson, pkgJson }
+})
+
+test.after(async (t) => {
+  await unlink(t.context.configPath)
+  await unlink(t.context.packageJson)
+})
+
+test('should throw if package.json not found', async (t) => {
+  await t.throwsAsync(() => readNapiConfig(NON_EXISTENT_FILE), {
+    message: `package.json not found at ${NON_EXISTENT_FILE}`,
+  })
+})
+
+test('should throw if napi.json not found', async (t) => {
+  const { packageJson } = t.context
+  await t.throwsAsync(() => readNapiConfig(packageJson, NON_EXISTENT_FILE), {
+    message: `NAPI-RS config not found at ${NON_EXISTENT_FILE}`,
+  })
+})
+
+test('should be able to read config from package.json', async (t) => {
+  const { packageJson } = t.context
+  const config = await readNapiConfig(packageJson)
+  t.snapshot(config)
+})
+
+test('should be able to read config from napi.json', async (t) => {
+  const { packageJson, configPath } = t.context
+  const config = await readNapiConfig(packageJson, configPath)
+  t.snapshot(config)
+})

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

@@ -0,0 +1,69 @@
+import { unlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+
+import test from 'ava'
+
+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(
+    tmpdir(),
+    `napi-rs-metadata-${process.pid}-${Date.now()}.toml`,
+  )
+  const originalPath = process.env.PATH
+
+  await writeFile(manifestPath, '[package]\nname = "test"\nversion = "0.0.0"\n')
+  process.env.PATH = ''
+
+  try {
+    const error = await t.throwsAsync(() => parseMetadata(manifestPath))
+    t.truthy(error)
+    t.is(error?.message, 'cargo metadata failed to run')
+    t.is((error?.cause as NodeJS.ErrnoException | undefined)?.code, 'ENOENT')
+  } finally {
+    process.env.PATH = originalPath
+    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/__tests__/misc.spec.ts

@@ -0,0 +1,56 @@
+import { existsSync } from 'node:fs'
+import { mkdtemp, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+
+import ava, { type TestFn } from 'ava'
+
+import { updatePackageJson } from '../misc.js'
+
+const test = ava as TestFn<{
+  tmpDir: string
+}>
+
+test.beforeEach(async (t) => {
+  t.context = {
+    tmpDir: await mkdtemp(join(tmpdir(), 'napi-rs-misc-spec-')),
+  }
+})
+
+test.afterEach.always(async (t) => {
+  if (existsSync(t.context.tmpDir)) {
+    await rm(t.context.tmpDir, { recursive: true, force: true })
+  }
+})
+
+test('updatePackageJson merges nested objects instead of overwriting them', async (t) => {
+  const packageJsonPath = join(t.context.tmpDir, 'package.json')
+
+  await writeFile(
+    packageJsonPath,
+    JSON.stringify(
+      {
+        name: 'fixture',
+        version: '1.0.0',
+        optionalDependencies: {
+          fsevents: '^2.3.3',
+        },
+      },
+      null,
+      2,
+    ),
+  )
+
+  await updatePackageJson(packageJsonPath, {
+    optionalDependencies: {
+      '@napi-rs/fixture-darwin-arm64': '1.0.1',
+    },
+  })
+
+  const packageJson = JSON.parse(await readFile(packageJsonPath, 'utf8'))
+
+  t.deepEqual(packageJson.optionalDependencies, {
+    fsevents: '^2.3.3',
+    '@napi-rs/fixture-darwin-arm64': '1.0.1',
+  })
+})

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

@@ -0,0 +1,19 @@
+import os from 'os'
+
+import test from 'ava'
+
+import {
+  parseTriple,
+  getSystemDefaultTarget,
+  AVAILABLE_TARGETS,
+} from '../target.js'
+
+test('should parse triple correctly', (t) => {
+  t.snapshot(AVAILABLE_TARGETS.map(parseTriple))
+})
+
+test('should get system default target correctly', (t) => {
+  const target = getSystemDefaultTarget()
+
+  t.is(target.platform, os.platform())
+})

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

@@ -0,0 +1,85 @@
+import { join } from 'path'
+import { fileURLToPath } from 'url'
+
+import test from 'ava'
+
+import { correctStringIdent, processTypeDef } from '../typegen.js'
+
+test('should ident string correctly', (t) => {
+  const input = `
+  /**
+   * should keep
+   * class A {
+   * foo = () => {}
+   *   bar = () => {}
+   * }
+   */
+  class A {
+    foo() {
+      a = b
+    }
+
+  bar = () => {
+
+  }
+      boz = 1
+    }
+
+  namespace B {
+      namespace C {
+  type D = A
+      }
+  }
+`
+  t.snapshot(correctStringIdent(input, 0), 'original ident is 0')
+  t.snapshot(correctStringIdent(input, 2), 'original ident is 2')
+})
+
+test('should process type def correctly', async (t) => {
+  const { dts } = await processTypeDef(
+    join(
+      fileURLToPath(import.meta.url),
+      '../',
+      '__fixtures__',
+      'napi_type_def',
+    ),
+    true,
+  )
+
+  t.snapshot(dts)
+})
+
+test('should process type def with noConstEnum correctly', async (t) => {
+  const { dts } = await processTypeDef(
+    join(
+      fileURLToPath(import.meta.url),
+      '../',
+      '__fixtures__',
+      'napi_type_def',
+    ),
+    false,
+  )
+
+  t.snapshot(dts)
+})
+
+// The next two tests use a minimal fixture (one numeric + one string
+// enum) to keep snapshots small and focused on the flag's behavior.
+const flagFixture = join(
+  fileURLToPath(import.meta.url),
+  '../',
+  '__fixtures__',
+  'runtime_string_enum_flag',
+)
+
+test('should process type def with noConstEnum and runtimeStringEnum correctly', async (t) => {
+  const { dts } = await processTypeDef(flagFixture, false, true)
+
+  t.snapshot(dts)
+})
+
+test('runtimeStringEnum is a no-op when constEnum is set', async (t) => {
+  const { dts } = await processTypeDef(flagFixture, true, true)
+
+  t.snapshot(dts)
+})

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

@@ -0,0 +1,7 @@
+import test from 'ava'
+
+import { napiEngineRequirement, SUPPORTED_NAPI_VERSIONS } from '../version.js'
+
+test('should generate correct napi engine requirement', (t) => {
+  t.snapshot(SUPPORTED_NAPI_VERSIONS.map(napiEngineRequirement))
+})

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 = ''

package/src/utils/version.ts

@@ -8,6 +8,7 @@ export enum NapiVersion {
   Napi7,
   Napi8,
   Napi9,
+  Napi10,
 }
 
 /// because node support new napi version in some minor version updates, so we might meet such situation:
@@ -23,6 +24,7 @@ const NAPI_VERSION_MATRIX = new Map<NapiVersion, string>([
   [NapiVersion.Napi7, '10.23.0 | 12.19.0 | 14.12.0 | 15.0.0'],
   [NapiVersion.Napi8, '12.22.0 | 14.17.0 | 15.12.0 | 16.0.0'],
   [NapiVersion.Napi9, '18.17.0 | 20.3.0 | 21.1.0'],
+  [NapiVersion.Napi10, '22.14.0 | 23.6.0'],
 ])
 
 export const SUPPORTED_NAPI_VERSIONS = Object.values(NapiVersion).filter(