@napi-rs/cli 3.0.0-alpha.8 → 3.0.0-alpha.80

package/src/api/create-npm-dirs.ts

@@ -1,4 +1,6 @@
-import { join, resolve } from 'path'
+import { join, resolve } from 'node:path'
+
+import { parse } from 'semver'
 
 import {
   applyDefaultCreateNpmDirsOptions,
@@ -13,6 +15,8 @@ import {
   Target,
 } from '../utils/index.js'
 
+import type { PackageMeta } from './templates/package.json.js'
+
 const debug = debugFactory('create-npm-dirs')
 
 export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
@@ -43,20 +47,25 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
   const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
   const npmPath = resolve(options.cwd, options.npmDir)
 
-  debug(`Read content from [${packageJsonPath}]`)
+  debug(`Read content from [${options.configPath ?? packageJsonPath}]`)
 
   const { targets, binaryName, packageName, packageJson } =
-    await readNapiConfig(packageJsonPath)
+    await readNapiConfig(
+      packageJsonPath,
+      options.configPath ? resolve(options.cwd, options.configPath) : undefined,
+    )
 
   for (const target of targets) {
     const targetDir = join(npmPath, `${target.platformArchABI}`)
     await mkdirAsync(targetDir)
 
-    const binaryFileName = `${binaryName}.${target.platformArchABI}.node`
+    const binaryFileName =
+      target.arch === 'wasm32'
+        ? `${binaryName}.${target.platformArchABI}.wasm`
+        : `${binaryName}.${target.platformArchABI}.node`
     const scopedPackageJson = {
       name: `${packageName}-${target.platformArchABI}`,
       version: packageJson.version,
-      os: [target.platform],
       cpu: target.arch !== 'universal' ? [target.arch] : undefined,
       main: binaryFileName,
       files: [binaryFileName],
@@ -74,9 +83,48 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
         'bugs',
       ),
     }
+    if (target.arch !== 'wasm32') {
+      // @ts-expect-error
+      scopedPackageJson.os = [target.platform]
+    } else {
+      const entry = `${binaryName}.wasi.cjs`
+      scopedPackageJson.main = entry
+      // @ts-expect-error
+      scopedPackageJson.browser = `${binaryName}.wasi-browser.js`
+      scopedPackageJson.files.push(
+        entry,
+        // @ts-expect-error
+        scopedPackageJson.browser,
+        `wasi-worker.mjs`,
+        `wasi-worker-browser.mjs`,
+      )
+      let needRestrictNodeVersion = true
+      if (scopedPackageJson.engines?.node) {
+        try {
+          const { major } = parse(scopedPackageJson.engines.node) ?? {
+            major: 0,
+          }
+          if (major >= 14) {
+            needRestrictNodeVersion = false
+          }
+        } catch {
+          // ignore
+        }
+      }
+      if (needRestrictNodeVersion) {
+        scopedPackageJson.engines = {
+          node: '>=14.0.0',
+        }
+      }
+      const wasmRuntime = await fetch(
+        `https://registry.npmjs.org/@napi-rs/wasm-runtime`,
+      ).then((res) => res.json() as Promise<PackageMeta>)
+      // @ts-expect-error
+      scopedPackageJson.dependencies = {
+        '@napi-rs/wasm-runtime': `^${wasmRuntime['dist-tags'].latest}`,
+      }
+    }
 
-    // Only works with yarn 3.1+
-    // https://github.com/yarnpkg/berry/pull/3981
     if (target.abi === 'gnu') {
       // @ts-expect-error
       scopedPackageJson.libc = ['glibc']
@@ -88,12 +136,12 @@ export async function createNpmDirs(userOptions: CreateNpmDirsOptions) {
     const targetPackageJson = join(targetDir, 'package.json')
     await writeFileAsync(
       targetPackageJson,
-      JSON.stringify(scopedPackageJson, null, 2),
+      JSON.stringify(scopedPackageJson, null, 2) + '\n',
     )
     const targetReadme = join(targetDir, 'README.md')
     await writeFileAsync(targetReadme, readme(packageName, target))
 
-    debug.info(`${packageName}-${target.platformArchABI} created`)
+    debug.info(`${packageName} -${target.platformArchABI} created`)
   }
 }
 

package/src/api/new.ts

@@ -1,4 +1,5 @@
-import path from 'path'
+import { execSync } from 'node:child_process'
+import path from 'node:path'
 
 import {
   applyDefaultNewOptions,
@@ -10,7 +11,11 @@ import {
   debugFactory,
   DEFAULT_TARGETS,
   mkdirAsync,
+  readdirAsync,
+  statAsync,
+  type SupportedTestFramework,
   writeFileAsync,
+  SupportedPackageManager,
 } from '../utils/index.js'
 import { napiEngineRequirement } from '../utils/version.js'
 
@@ -23,6 +28,7 @@ import {
   gitIgnore,
   npmIgnore,
 } from './templates/index.js'
+import { WasiTargetName } from './templates/ci-template.js'
 
 const debug = debugFactory('new')
 
@@ -35,6 +41,9 @@ type NewOptions = Required<RawNewOptions>
 
 function processOptions(options: RawNewOptions) {
   debug('Processing options...')
+  if (!options.path) {
+    throw new Error('Please provide the path as the argument')
+  }
   options.path = path.resolve(process.cwd(), options.path)
   debug(`Resolved target path to: ${options.path}`)
 
@@ -54,6 +63,20 @@ function processOptions(options: RawNewOptions) {
       throw new Error('At least one target must be enabled')
     }
   }
+  if (
+    options.targets.some((target) => target === 'wasm32-wasi-preview1-threads')
+  ) {
+    const out = execSync(`rustup target list`, {
+      encoding: 'utf8',
+    })
+    if (out.includes('wasm32-wasip1-threads')) {
+      options.targets.map((target) =>
+        target === 'wasm32-wasi-preview1-threads'
+          ? 'wasm32-wasip1-threads'
+          : target,
+      )
+    }
+  }
 
   return applyDefaultNewOptions(options) as NewOptions
 }
@@ -67,47 +90,75 @@ export async function newProject(userOptions: RawNewOptions) {
   debug('Targets to be enabled:')
   debug(options.targets)
 
-  const outputs = generateFiles(options)
+  const outputs = await generateFiles(options)
 
-  try {
-    debug(`Try to create target directory: ${options.path}`)
-    if (!options.dryRun) {
-      await mkdirAsync(options.path, { recursive: true })
-    }
-  } catch (e) {
-    throw new Error(`Failed to create target directory: ${options.path}`, {
-      cause: e,
-    })
-  }
+  await ensurePath(options.path, options.dryRun)
 
   await dumpOutputs(outputs, options.dryRun)
   debug(`Project created at: ${options.path}`)
 }
 
-function generateFiles(options: NewOptions): Output[] {
+async function ensurePath(path: string, dryRun = false) {
+  const stat = await statAsync(path, {}).catch(() => undefined)
+
+  // file descriptor exists
+  if (stat) {
+    if (stat.isFile()) {
+      throw new Error(
+        `Path ${path} for creating new napi-rs project already exists and it's not a directory.`,
+      )
+    } else if (stat.isDirectory()) {
+      const files = await readdirAsync(path)
+      if (files.length) {
+        throw new Error(
+          `Path ${path} for creating new napi-rs project already exists and it's not empty.`,
+        )
+      }
+    }
+  }
+
+  if (!dryRun) {
+    try {
+      debug(`Try to create target directory: ${path}`)
+      if (!dryRun) {
+        await mkdirAsync(path, { recursive: true })
+      }
+    } catch (e) {
+      throw new Error(`Failed to create target directory: ${path}`, {
+        cause: e,
+      })
+    }
+  }
+}
+
+async function generateFiles(options: NewOptions): Promise<Output[]> {
+  const packageJson = await generatePackageJson(options)
   return [
     generateCargoToml,
     generateLibRs,
     generateBuildRs,
-    generatePackageJson,
     generateGithubWorkflow,
     generateIgnoreFiles,
-  ].flatMap((generator) => {
-    const output = generator(options)
+  ]
+    .flatMap((generator) => {
+      const output = generator(options)
 
-    if (!output) {
-      return []
-    }
+      if (!output) {
+        return []
+      }
 
-    if (Array.isArray(output)) {
-      return output.map((o) => ({
-        ...o,
-        target: path.join(options.path, o.target),
-      }))
-    } else {
-      return [{ ...output, target: path.join(options.path, output.target) }]
-    }
-  })
+      if (Array.isArray(output)) {
+        return output.map((o) => ({
+          ...o,
+          target: path.join(options.path, o.target),
+        }))
+      } else {
+        return [{ ...output, target: path.join(options.path, output.target) }]
+      }
+    })
+    .concat([
+      { ...packageJson, target: path.join(options.path, packageJson.target) },
+    ])
 }
 
 function generateCargoToml(options: NewOptions): Output {
@@ -136,16 +187,17 @@ function generateBuildRs(_options: NewOptions): Output {
   }
 }
 
-function generatePackageJson(options: NewOptions): Output {
+async function generatePackageJson(options: NewOptions): Promise<Output> {
   return {
     target: './package.json',
-    content: createPackageJson({
+    content: await createPackageJson({
       name: options.name,
       binaryName: getBinaryName(options.name),
       targets: options.targets,
       license: options.license,
       engineRequirement: napiEngineRequirement(options.minNodeApiVersion),
       cliVersion: CLI_VERSION,
+      testFramework: options.testFramework as SupportedTestFramework,
     }),
   }
 }
@@ -157,7 +209,13 @@ function generateGithubWorkflow(options: NewOptions): Output | null {
 
   return {
     target: './.github/workflows/ci.yml',
-    content: createGithubActionsCIYml(options.targets),
+    content: createGithubActionsCIYml(
+      options.targets,
+      options.packageManager as SupportedPackageManager,
+      (options.targets.find((t) =>
+        t.includes('wasm32-wasi'),
+      ) as WasiTargetName) ?? 'wasm32-wasi-preview1-threads',
+    ),
   }
 }
 

package/src/api/pre-publish.ts

@@ -1,6 +1,6 @@
-import { execSync } from 'child_process'
-import { existsSync, statSync } from 'fs'
-import { join, relative, resolve } from 'path'
+import { execSync } from 'node:child_process'
+import { existsSync, statSync } from 'node:fs'
+import { join, resolve } from 'node:path'
 
 import { Octokit } from '@octokit/rest'
 
@@ -31,10 +31,13 @@ export async function prePublish(userOptions: PrePublishOptions) {
 
   const options = applyDefaultPrePublishOptions(userOptions)
 
-  const packageJsonPath = relative(options.cwd, options.packageJsonPath)
+  const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
 
   const { packageJson, targets, packageName, binaryName, npmClient } =
-    await readNapiConfig(packageJsonPath)
+    await readNapiConfig(
+      packageJsonPath,
+      options.configPath ? resolve(options.cwd, options.configPath) : undefined,
+    )
 
   async function createGhRelease(packageName: string, version: string) {
     if (!options.ghRelease) {
@@ -150,7 +153,9 @@ export async function prePublish(userOptions: PrePublishOptions) {
       options.npmDir,
       `${target.platformArchABI}`,
     )
-    const filename = `${binaryName}.${target.platformArchABI}.node`
+    const ext =
+      target.platform === 'wasi' || target.platform === 'wasm' ? 'wasm' : 'node'
+    const filename = `${binaryName}.${target.platformArchABI}.${ext}`
     const dstPath = join(pkgDir, filename)
 
     if (!options.dryRun) {
@@ -187,7 +192,8 @@ export async function prePublish(userOptions: PrePublishOptions) {
               'content-length': dstFileStats.size,
               'content-type': 'application/octet-stream',
             },
-            data: await readFileAsync(dstPath, { encoding: 'utf-8' }),
+            // @ts-expect-error octokit types are wrong
+            data: await readFileAsync(dstPath),
           })
           debug.info(`GitHub release created`)
           debug.info(`Download URL: %s`, assetInfo.data.browser_download_url)

package/src/api/rename.ts

@@ -1,4 +1,4 @@
-import { resolve } from 'path'
+import { resolve } from 'node:path'
 
 import { isNil, merge, omitBy, pick } from 'lodash-es'
 
@@ -30,6 +30,15 @@ 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),

package/src/api/templates/cargo.toml.ts

@@ -32,4 +32,5 @@ napi-build = "2"
 
 [profile.release]
 lto = true
+strip = "symbols"
 `