@napi-rs/cli 3.0.0-alpha.1 → 3.0.0-alpha.100

package/src/api/new.ts

@@ -1,4 +1,10 @@
-import path from 'path'
+import { exec, execSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import path from 'node:path'
+import { promises as fs } from 'node:fs'
+
+import { load as yamlLoad, dump as yamlDump } from 'js-yaml'
 
 import {
   applyDefaultNewOptions,
@@ -6,35 +12,289 @@ import {
 } from '../def/new.js'
 import {
   AVAILABLE_TARGETS,
-  CLI_VERSION,
   debugFactory,
   DEFAULT_TARGETS,
   mkdirAsync,
-  writeFileAsync,
+  readdirAsync,
+  statAsync,
+  SupportedPackageManager,
 } from '../utils/index.js'
 import { napiEngineRequirement } from '../utils/version.js'
+import { renameProject } from './rename.js'
 
-import {
-  createBuildRs,
-  createCargoToml,
-  createGithubActionsCIYml,
-  createLibRs,
-  createPackageJson,
-  gitIgnore,
-  npmIgnore,
-} from './templates/index.js'
+// Template imports removed as we're now using external templates
 
 const debug = debugFactory('new')
 
-interface Output {
-  target: string
-  content: string
+type NewOptions = Required<RawNewOptions>
+
+const TEMPLATE_REPOS = {
+  yarn: 'https://github.com/napi-rs/package-template',
+  pnpm: 'https://github.com/napi-rs/package-template-pnpm',
+} as const
+
+async function checkGitCommand(): Promise<boolean> {
+  try {
+    await new Promise((resolve) => {
+      const cp = exec('git --version')
+      cp.on('error', () => {
+        resolve(false)
+      })
+      cp.on('exit', (code) => {
+        if (code === 0) {
+          resolve(true)
+        } else {
+          resolve(false)
+        }
+      })
+    })
+    return true
+  } catch {
+    return false
+  }
+}
+
+async function ensureCacheDir(
+  packageManager: SupportedPackageManager,
+): Promise<string> {
+  const cacheDir = path.join(homedir(), '.napi-rs', 'template', packageManager)
+  await mkdirAsync(cacheDir, { recursive: true })
+  return cacheDir
 }
 
-type NewOptions = Required<RawNewOptions>
+async function downloadTemplate(
+  packageManager: SupportedPackageManager,
+  cacheDir: string,
+): Promise<void> {
+  const repoUrl = TEMPLATE_REPOS[packageManager]
+  const templatePath = path.join(cacheDir, 'repo')
+
+  if (existsSync(templatePath)) {
+    debug(`Template cache found at ${templatePath}, updating...`)
+    try {
+      // Fetch latest changes and reset to remote
+      await new Promise<void>((resolve, reject) => {
+        const cp = exec('git fetch origin', { cwd: templatePath })
+        cp.on('error', reject)
+        cp.on('exit', (code) => {
+          if (code === 0) {
+            resolve()
+          } else {
+            reject(
+              new Error(
+                `Failed to fetch latest changes, git process exited with code ${code}`,
+              ),
+            )
+          }
+        })
+      })
+      execSync('git reset --hard origin/main', {
+        cwd: templatePath,
+        stdio: 'ignore',
+      })
+      debug('Template updated successfully')
+    } catch (error) {
+      debug(`Failed to update template: ${error}`)
+      throw new Error(`Failed to update template from ${repoUrl}: ${error}`)
+    }
+  } else {
+    debug(`Cloning template from ${repoUrl}...`)
+    try {
+      execSync(`git clone ${repoUrl} repo`, { cwd: cacheDir, stdio: 'inherit' })
+      debug('Template cloned successfully')
+    } catch (error) {
+      throw new Error(`Failed to clone template from ${repoUrl}: ${error}`)
+    }
+  }
+}
+
+async function copyDirectory(
+  src: string,
+  dest: string,
+  includeWasiBindings: boolean,
+): Promise<void> {
+  await mkdirAsync(dest, { recursive: true })
+  const entries = await fs.readdir(src, { withFileTypes: true })
+
+  for (const entry of entries) {
+    const srcPath = path.join(src, entry.name)
+    const destPath = path.join(dest, entry.name)
+
+    // Skip .git directory
+    if (entry.name === '.git') {
+      continue
+    }
+
+    if (entry.isDirectory()) {
+      await copyDirectory(srcPath, destPath, includeWasiBindings)
+    } else {
+      if (
+        !includeWasiBindings &&
+        (entry.name.endsWith('.wasi-browser.js') ||
+          entry.name.endsWith('.wasi.cjs') ||
+          entry.name.endsWith('wasi-worker.browser.mjs ') ||
+          entry.name.endsWith('wasi-worker.mjs') ||
+          entry.name.endsWith('browser.js'))
+      ) {
+        continue
+      }
+      await fs.copyFile(srcPath, destPath)
+    }
+  }
+}
+
+async function filterTargetsInPackageJson(
+  filePath: string,
+  enabledTargets: string[],
+): Promise<void> {
+  const content = await fs.readFile(filePath, 'utf-8')
+  const packageJson = JSON.parse(content)
+
+  // Filter napi.targets
+  if (packageJson.napi?.targets) {
+    packageJson.napi.targets = packageJson.napi.targets.filter(
+      (target: string) => enabledTargets.includes(target),
+    )
+  }
+
+  await fs.writeFile(filePath, JSON.stringify(packageJson, null, 2) + '\n')
+}
+
+async function filterTargetsInGithubActions(
+  filePath: string,
+  enabledTargets: string[],
+): Promise<void> {
+  const content = await fs.readFile(filePath, 'utf-8')
+  const yaml = yamlLoad(content) as any
+
+  const macOSAndWindowsTargets = new Set([
+    'x86_64-pc-windows-msvc',
+    'aarch64-pc-windows-msvc',
+    'x86_64-apple-darwin',
+  ])
+
+  const linuxTargets = new Set([
+    'x86_64-unknown-linux-gnu',
+    'x86_64-unknown-linux-musl',
+    'aarch64-unknown-linux-gnu',
+    'aarch64-unknown-linux-musl',
+    'armv7-unknown-linux-gnueabihf',
+    'armv7-unknown-linux-musleabihf',
+    'riscv64gc-unknown-linux-gnu',
+    'powerpc64le-unknown-linux-gnu',
+    's390x-unknown-linux-gnu',
+    'aarch64-linux-android',
+    'armv7-linux-androideabi',
+  ])
+
+  // Check if any Linux targets are enabled
+  const hasLinuxTargets = enabledTargets.some((target) =>
+    linuxTargets.has(target),
+  )
+
+  // Filter the matrix configurations in the build job
+  if (yaml?.jobs?.build?.strategy?.matrix?.settings) {
+    yaml.jobs.build.strategy.matrix.settings =
+      yaml.jobs.build.strategy.matrix.settings.filter((setting: any) => {
+        if (setting.target) {
+          return enabledTargets.includes(setting.target)
+        }
+        return true
+      })
+  }
+
+  const jobsToRemove: string[] = []
+
+  if (enabledTargets.every((target) => !macOSAndWindowsTargets.has(target))) {
+    jobsToRemove.push('test-macOS-windows-binding')
+  } else {
+    // Filter the matrix configurations in the test-macOS-windows-binding job
+    if (
+      yaml?.jobs?.['test-macOS-windows-binding']?.strategy?.matrix?.settings
+    ) {
+      yaml.jobs['test-macOS-windows-binding'].strategy.matrix.settings =
+        yaml.jobs['test-macOS-windows-binding'].strategy.matrix.settings.filter(
+          (setting: any) => {
+            if (setting.target) {
+              return enabledTargets.includes(setting.target)
+            }
+            return true
+          },
+        )
+    }
+  }
+
+  // If no Linux targets are enabled, remove Linux-specific jobs
+  if (!hasLinuxTargets) {
+    // Remove test-linux-binding job
+    if (yaml?.jobs?.['test-linux-binding']) {
+      jobsToRemove.push('test-linux-binding')
+    }
+  } else {
+    // Filter the matrix configurations in the test-linux-x64-gnu-binding job
+    if (yaml?.jobs?.['test-linux-binding']?.strategy?.matrix?.target) {
+      yaml.jobs['test-linux-binding'].strategy.matrix.target = yaml.jobs[
+        'test-linux-binding'
+      ].strategy.matrix.target.filter((target: string) => {
+        if (target) {
+          return enabledTargets.includes(target)
+        }
+        return true
+      })
+    }
+  }
+
+  if (!enabledTargets.includes('wasm32-wasip1-threads')) {
+    jobsToRemove.push('test-wasi')
+  }
+
+  if (!enabledTargets.includes('x86_64-unknown-freebsd')) {
+    jobsToRemove.push('build-freebsd')
+  }
+
+  // Filter other test jobs based on target
+  for (const [jobName, jobConfig] of Object.entries(yaml.jobs || {})) {
+    if (
+      jobName.startsWith('test-') &&
+      jobName !== 'test-macOS-windows-binding' &&
+      jobName !== 'test-linux-x64-gnu-binding'
+    ) {
+      // Extract target from job name or config
+      const job = jobConfig as any
+      if (job.strategy?.matrix?.settings?.[0]?.target) {
+        const target = job.strategy.matrix.settings[0].target
+        if (!enabledTargets.includes(target)) {
+          jobsToRemove.push(jobName)
+        }
+      }
+    }
+  }
+
+  // Remove jobs for disabled targets
+  for (const jobName of jobsToRemove) {
+    delete yaml.jobs[jobName]
+  }
+
+  if (Array.isArray(yaml.jobs?.publish?.needs)) {
+    yaml.jobs.publish.needs = yaml.jobs.publish.needs.filter(
+      (need: string) => !jobsToRemove.includes(need),
+    )
+  }
+
+  // Write back the filtered YAML
+  const updatedYaml = yamlDump(yaml, {
+    lineWidth: -1,
+    noRefs: true,
+    sortKeys: false,
+  })
+  await fs.writeFile(filePath, updatedYaml)
+}
 
 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 +314,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 = options.targets.map((target) =>
+        target === 'wasm32-wasi-preview1-threads'
+          ? 'wasm32-wasip1-threads'
+          : target,
+      )
+    }
+  }
 
   return applyDefaultNewOptions(options) as NewOptions
 }
@@ -67,134 +341,124 @@ export async function newProject(userOptions: RawNewOptions) {
   debug('Targets to be enabled:')
   debug(options.targets)
 
-  const outputs = 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,
-    })
+  // Check if git is available
+  if (!(await checkGitCommand())) {
+    throw new Error(
+      'Git is not installed or not available in PATH. Please install Git to continue.',
+    )
   }
 
-  await dumpOutputs(outputs, options.dryRun)
-  debug(`Project created at: ${options.path}`)
-}
+  const packageManager = options.packageManager as SupportedPackageManager
 
-function generateFiles(options: NewOptions): Output[] {
-  return [
-    generateCargoToml,
-    generateLibRs,
-    generateBuildRs,
-    generatePackageJson,
-    generateGithubWorkflow,
-    generateIgnoreFiles,
-  ].flatMap((generator) => {
-    const output = generator(options)
-
-    if (!output) {
-      return []
-    }
+  // Ensure target directory exists and is empty
+  await ensurePath(options.path, options.dryRun)
 
-    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 (!options.dryRun) {
+    try {
+      // Download or update template
+      const cacheDir = await ensureCacheDir(packageManager)
+      await downloadTemplate(packageManager, cacheDir)
 
-function generateCargoToml(options: NewOptions): Output {
-  return {
-    target: './Cargo.toml',
-    content: createCargoToml({
-      name: options.name,
-      license: options.license,
-      features: [`napi${options.minNodeApiVersion}`],
-      deriveFeatures: options.enableTypeDef ? ['type-def'] : [],
-    }),
-  }
-}
+      // Copy template files to target directory
+      const templatePath = path.join(cacheDir, 'repo')
+      await copyDirectory(
+        templatePath,
+        options.path,
+        options.targets.includes('wasm32-wasip1-threads'),
+      )
 
-function generateLibRs(_options: NewOptions): Output {
-  return {
-    target: './src/lib.rs',
-    content: createLibRs(),
-  }
-}
+      // Rename project using the rename API
+      await renameProject({
+        cwd: options.path,
+        name: options.name,
+        binaryName: getBinaryName(options.name),
+      })
 
-function generateBuildRs(_options: NewOptions): Output {
-  return {
-    target: './build.rs',
-    content: createBuildRs(),
-  }
-}
+      // Filter targets in package.json
+      const packageJsonPath = path.join(options.path, 'package.json')
+      if (existsSync(packageJsonPath)) {
+        await filterTargetsInPackageJson(packageJsonPath, options.targets)
+      }
 
-function generatePackageJson(options: NewOptions): Output {
-  return {
-    target: './package.json',
-    content: createPackageJson({
-      name: options.name,
-      binaryName: getBinaryName(options.name),
-      targets: options.targets,
-      license: options.license,
-      engineRequirement: napiEngineRequirement(options.minNodeApiVersion),
-      cliVersion: CLI_VERSION,
-    }),
-  }
-}
+      // Filter targets in GitHub Actions CI
+      const ciPath = path.join(options.path, '.github', 'workflows', 'CI.yml')
+      if (existsSync(ciPath) && options.enableGithubActions) {
+        await filterTargetsInGithubActions(ciPath, options.targets)
+      } else if (
+        !options.enableGithubActions &&
+        existsSync(path.join(options.path, '.github'))
+      ) {
+        // Remove .github directory if GitHub Actions is not enabled
+        await fs.rm(path.join(options.path, '.github'), {
+          recursive: true,
+          force: true,
+        })
+      }
 
-function generateGithubWorkflow(options: NewOptions): Output | null {
-  if (!options.enableGithubActions) {
-    return null
-  }
+      // Update package.json with additional configurations
+      const pkgJsonContent = await fs.readFile(packageJsonPath, 'utf-8')
+      const pkgJson = JSON.parse(pkgJsonContent)
+
+      // Update engine requirement
+      if (!pkgJson.engines) {
+        pkgJson.engines = {}
+      }
+      pkgJson.engines.node = napiEngineRequirement(options.minNodeApiVersion)
 
-  return {
-    target: './.github/workflows/ci.yml',
-    content: createGithubActionsCIYml(
-      getBinaryName(options.name),
-      options.targets,
-    ),
+      // Update license if different from template
+      if (options.license && pkgJson.license !== options.license) {
+        pkgJson.license = options.license
+      }
+
+      // Update test framework if needed
+      if (options.testFramework !== 'ava') {
+        // This would require more complex logic to update test scripts and dependencies
+        debug(
+          `Test framework ${options.testFramework} requested but not yet implemented`,
+        )
+      }
+
+      await fs.writeFile(
+        packageJsonPath,
+        JSON.stringify(pkgJson, null, 2) + '\n',
+      )
+    } catch (error) {
+      throw new Error(`Failed to create project: ${error}`)
+    }
   }
-}
 
-function generateIgnoreFiles(_options: NewOptions): Output[] {
-  return [
-    {
-      target: './.gitignore',
-      content: gitIgnore,
-    },
-    {
-      target: './.npmignore',
-      content: npmIgnore,
-    },
-  ]
+  debug(`Project created at: ${options.path}`)
 }
 
-async function dumpOutputs(outputs: Output[], dryRun?: boolean) {
-  for (const output of outputs) {
-    if (!output) {
-      continue
-    }
+async function ensurePath(path: string, dryRun = false) {
+  const stat = await statAsync(path, {}).catch(() => undefined)
 
-    debug(`Writing project file: ${output.target}`)
-    // only output content to logger instead of writing to file system
-    if (dryRun) {
-      debug(output.content)
-      continue
+  // 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 {
-      await mkdirAsync(path.dirname(output.target), { recursive: true })
-      await writeFileAsync(output.target, output.content, 'utf-8')
+      debug(`Try to create target directory: ${path}`)
+      if (!dryRun) {
+        await mkdirAsync(path, { recursive: true })
+      }
     } catch (e) {
-      throw new Error(`Failed to write file: ${output.target}`, { cause: e })
+      throw new Error(`Failed to create target directory: ${path}`, {
+        cause: e,
+      })
     }
   }
 }

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) {
@@ -129,11 +132,14 @@ export async function prePublish(userOptions: PrePublishOptions) {
   if (!options.dryRun) {
     await version(userOptions)
     await updatePackageJson(packageJsonPath, {
-      optionalDependencies: targets.reduce((deps, target) => {
-        deps[`${packageName}-${target.platformArchABI}`] = packageJson.version
-
-        return deps
-      }, {} as Record<string, string>),
+      optionalDependencies: targets.reduce(
+        (deps, target) => {
+          deps[`${packageName}-${target.platformArchABI}`] = packageJson.version
+
+          return deps
+        },
+        {} as Record<string, string>,
+      ),
     })
   }
 
@@ -147,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) {
@@ -156,10 +164,12 @@ export async function prePublish(userOptions: PrePublishOptions) {
         continue
       }
 
-      execSync(`${npmClient} publish`, {
-        cwd: pkgDir,
-        env: process.env,
-      })
+      if (!options.skipOptionalPublish) {
+        execSync(`${npmClient} publish`, {
+          cwd: pkgDir,
+          env: process.env,
+        })
+      }
 
       if (options.ghRelease && repo && owner) {
         debug.info(`Creating GitHub release ${pkgInfo.tag}`)
@@ -184,7 +194,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)