@napi-rs/cli 3.9.1 → 3.10.0

package/src/api/__tests__/build-regressions.spec.ts

@@ -1,11 +1,20 @@
 import { existsSync } from 'node:fs'
-import { mkdir, rm, writeFile } from 'node:fs/promises'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
-import { join } from 'node:path'
+import { dirname, join, resolve } from 'node:path'
+import { join as posixJoin, sep as posixSep } from 'node:path/posix'
+import { sep as win32Sep } from 'node:path/win32'
+import { fileURLToPath } from 'node:url'
 
 import ava, { type TestFn } from 'ava'
 
-import { buildProject, generateTypeDef } from '../build.js'
+import {
+  buildProject,
+  generateTypeDef,
+  WASI_ARTIFACT_METADATA_PREFIX,
+} from '../build.js'
+
+const repoRoot = resolve(dirname(fileURLToPath(import.meta.url)), '../../../..')
 
 const test = ava as TestFn<{
   tmpDir: string
@@ -97,6 +106,204 @@ test.serial(
   },
 )
 
+test.serial(
+  'a native build refreshes WASI declarations that predate __napiBindingTarget',
+  async (t) => {
+    const { projectDir } = t.context
+    await writeMixedTargetProject(projectDir)
+    // the same crate, declaring a WASI target this native build has to keep in
+    // sync without rebuilding it
+    await writeFile(
+      join(projectDir, 'package.json'),
+      JSON.stringify({
+        name: 'build-regression',
+        version: '0.1.0',
+        napi: { binaryName: 'build-regression', targets: ['wasm32-wasip1'] },
+      }),
+    )
+
+    // what an earlier CLI left behind: a loader carrying artifact metadata,
+    // and a declaration file written before the loaders reported their target
+    const outputDir = join(projectDir, 'dist')
+    await mkdir(outputDir, { recursive: true })
+    const loaderPath = join(outputDir, 'build-regression.wasip1.cjs')
+    const declarationPath = join(outputDir, 'build-regression.wasip1.d.cts')
+    await Promise.all([
+      writeFile(
+        loaderPath,
+        `${WASI_ARTIFACT_METADATA_PREFIX}${JSON.stringify({
+          version: 2,
+          rootEntry: 'index.js',
+          exports: ['sum'],
+          managedRootEntries: ['browser.js', 'index.js'],
+        })}
+module.exports = __napiModule.exports
+module.exports.sum = __napiModule.exports.sum
+`,
+      ),
+      writeFile(
+        declarationPath,
+        `/* auto-generated by NAPI-RS */
+
+export declare function sum(a: number, b: number): number
+`,
+      ),
+    ])
+
+    const originalCargo = process.env.CARGO
+    delete process.env.CARGO
+    try {
+      await (
+        await buildProject({ cwd: projectDir, outputDir: 'dist' })
+      ).task
+    } finally {
+      if (originalCargo === undefined) {
+        delete process.env.CARGO
+      } else {
+        process.env.CARGO = originalCargo
+      }
+    }
+
+    const [loader, declaration] = await Promise.all([
+      readFile(loaderPath, 'utf8'),
+      readFile(declarationPath, 'utf8'),
+    ])
+
+    // the loader is regenerated from the preserved metadata, so it reports its
+    // flavor; the declaration kept beside it has to say so too
+    // `cjs-module-lexer` — Node's CJS -> ESM named export detection — only sees
+    // a named export it can read off a `module.exports.<name> =` assignment, so
+    // the stamp assigns the guard's return value rather than calling it
+    const stampLine =
+      'module.exports.__napiBindingTarget = __napiStampBindingTarget(__napiModule.exports, __napiBindingTarget)'
+    t.true(loader.includes(stampLine))
+    // exactly one, because every guard call can throw (a claimed name) and the
+    // assignment itself can throw (an addon accessor with a refusing setter);
+    // both have to happen where the initialization catch can roll them back
+    t.is(loader.split('module.exports.__napiBindingTarget =').length - 1, 1)
+    const initializationCatch = '\n} catch (error) {'
+    t.is(loader.split(initializationCatch).length - 1, 1)
+    t.true(loader.indexOf(stampLine) < loader.indexOf(initializationCatch))
+    // and the appended CommonJS tail carries no executable stamp at all
+    const tail = loader.slice(
+      loader.indexOf('\nmodule.exports = __napiModule.exports'),
+    )
+    t.false(tail.includes('__napiStampBindingTarget('))
+    t.true(declaration.startsWith('/* auto-generated by NAPI-RS */'))
+    // this file types one fixed artifact, whose loader can only ever report
+    // its own flavor — the root entry's union is what the override needs
+    t.true(
+      declaration.includes(
+        "export declare const __napiBindingTarget: 'wasm32-wasip1'",
+      ),
+    )
+  },
+)
+
+async function writeDeclarationOnlyProject(projectDir: string) {
+  // `napi-derive` in the dependency graph is the whole of what turns
+  // `enableTypeDef` on, and the crate deliberately uses no `#[napi]` macro, so
+  // the build writes zero `.type` files. That is the shape of a crate that
+  // registers everything from a `#[napi(module_exports)]` hook: a loader is
+  // written, but typegen has no runtime export to describe.
+  const napiDerivePath = posixJoin(repoRoot, 'crates', 'macro').replaceAll(
+    win32Sep,
+    posixSep,
+  )
+  await mkdir(join(projectDir, 'src'), { recursive: true })
+  await writeFile(
+    join(projectDir, 'Cargo.toml'),
+    `[package]
+name = "declaration_only"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+crate-type = ["cdylib"]
+
+[dependencies]
+napi-derive = { path = "${napiDerivePath}" }
+`,
+  )
+  await writeFile(join(projectDir, 'src', 'lib.rs'), 'pub fn library() {}\n')
+}
+
+function declarationOnlyPackageJson(napi: Record<string, unknown>) {
+  return JSON.stringify({
+    name: 'declaration-only',
+    version: '0.1.0',
+    napi,
+  })
+}
+
+test.serial(
+  'a declaration-only type def is a tracked build output',
+  async (t) => {
+    const { projectDir } = t.context
+    await writeDeclarationOnlyProject(projectDir)
+    // a declared WASI fallback is reason enough to write the root loader, so the
+    // declaration file describes it with `__napiBindingTarget` even though the
+    // export list is empty
+    await writeFile(
+      join(projectDir, 'package.json'),
+      declarationOnlyPackageJson({
+        binaryName: 'declaration-only',
+        targets: ['wasm32-wasip1'],
+      }),
+    )
+
+    const [outputs, emptyOutputs] = await (async () => {
+      const originalCargo = process.env.CARGO
+      delete process.env.CARGO
+      try {
+        const declarationOutputs = await (
+          await buildProject({
+            cwd: projectDir,
+            outputDir: 'dist',
+            platform: true,
+          })
+        ).task
+        // the same crate with nothing to declare: no root loader (`--platform`
+        // writes it) and no WASI fallback, so typegen writes an empty file, and
+        // an empty file is not an output anyone should be asked to post-process
+        await writeFile(
+          join(projectDir, 'package.json'),
+          declarationOnlyPackageJson({ binaryName: 'declaration-only' }),
+        )
+        const emptyDeclarationOutputs = await (
+          await buildProject({ cwd: projectDir, outputDir: 'empty' })
+        ).task
+        return [declarationOutputs, emptyDeclarationOutputs] as const
+      } finally {
+        if (originalCargo === undefined) {
+          delete process.env.CARGO
+        } else {
+          process.env.CARGO = originalCargo
+        }
+      }
+    })()
+
+    const declarationPath = join(projectDir, 'dist', 'index.d.ts')
+    // `--pipe` and the `NapiCli.build` return value only ever see registered
+    // outputs, so a declaration file this build filled has to be registered
+    t.true(
+      outputs.some(
+        (output) => output.kind === 'dts' && output.path === declarationPath,
+      ),
+    )
+    // and the red above is about tracking, not about content: the file itself
+    // has always been written
+    t.true(
+      (await readFile(declarationPath, 'utf8')).includes(
+        'export declare const __napiBindingTarget:',
+      ),
+    )
+
+    t.is(await readFile(join(projectDir, 'empty', 'index.d.ts'), 'utf8'), '')
+    t.false(emptyOutputs.some((output) => output.kind === 'dts'))
+  },
+)
+
 test.serial(
   'an explicit dtsHeaderFile takes precedence over config and inline headers',
   async (t) => {