@napi-rs/cli 2.15.1 → 3.0.0-alpha.0

package/src/api/templates/index.ts

@@ -0,0 +1,8 @@
+export * from './.gitignore.js'
+export * from './.npmignore.js'
+export * from './build.rs.js'
+export * from './cargo.toml.js'
+export * from './ci.yml.js'
+export * from './lib.rs.js'
+export * from './package.json.js'
+export * from './js-binding.js'

package/src/api/templates/js-binding.ts

@@ -0,0 +1,130 @@
+/* eslint-disable @typescript-eslint/switch-exhaustiveness-check */
+
+function loadNapiModule(binaryName: string, packageName: string) {
+  const { existsSync, readFileSync } = require('fs')
+  const { join } = require('path')
+  const { platform, arch } = process
+
+  const candidates: string[] = []
+
+  function isMusl() {
+    // For Node 10
+    if (!process.report || typeof process.report.getReport !== 'function') {
+      try {
+        const lddPath = require('child_process')
+          .execSync('which ldd')
+          .toString()
+          .trim()
+        return readFileSync(lddPath, 'utf8').includes('musl')
+      } catch (e) {
+        return true
+      }
+    } else {
+      // @ts-expect-error
+      const { glibcVersionRuntime } = process.report.getReport().header
+      return !glibcVersionRuntime
+    }
+  }
+
+  switch (platform) {
+    case 'android':
+      switch (arch) {
+        case 'arm64':
+          candidates.push('android-arm64')
+          break
+        case 'arm':
+          candidates.push('android-arm-eabi')
+          break
+      }
+      break
+    case 'win32':
+      switch (arch) {
+        case 'x64':
+          candidates.push('win32-x64-msvc')
+          break
+        case 'ia32':
+          candidates.push('win32-ia32-msvc')
+          break
+        case 'arm64':
+          candidates.push('win32-arm64-msvc')
+          break
+      }
+      break
+    case 'darwin':
+      candidates.push('darwin-universal')
+      switch (arch) {
+        case 'x64':
+          candidates.push('darwin-x64')
+          break
+        case 'arm64':
+          candidates.push('darwin-arm64')
+          break
+      }
+      break
+    case 'freebsd':
+      if (arch === 'x64') {
+        candidates.push('freebsd-x64')
+      }
+      break
+    case 'linux':
+      switch (arch) {
+        case 'x64':
+          if (isMusl()) {
+            candidates.push('linux-x64-musl')
+          } else {
+            candidates.push('linux-x64-gnu')
+          }
+          break
+        case 'arm64':
+          if (isMusl()) {
+            candidates.push('linux-arm64-musl')
+          } else {
+            candidates.push('linux-arm64-gnu')
+          }
+          break
+        case 'arm':
+          candidates.push('linux-arm-gnueabihf')
+          break
+      }
+      break
+  }
+
+  let nativeBinding: any
+  let loadError: any
+
+  for (const suffix of candidates) {
+    const localPath = join(__dirname, `${binaryName}.${suffix}.node`)
+    const pkgPath = `${packageName}-${suffix}`
+
+    try {
+      if (existsSync(localPath)) {
+        nativeBinding = require(localPath)
+      } else {
+        nativeBinding = require(pkgPath)
+      }
+    } catch (e) {
+      loadError = e
+      continue
+    }
+
+    loadError = null
+    break
+  }
+
+  if (!nativeBinding) {
+    if (loadError) {
+      throw loadError
+    }
+
+    throw new Error(`Unsupported OS: ${platform}, architecture: ${arch}`)
+  }
+
+  return nativeBinding
+}
+
+export function createJsBinding(localName: string, pkgName: string): string {
+  return `${loadNapiModule.toString()}
+
+module.exports = loadNapiModule('${localName}', '${pkgName}')
+`
+}

package/src/api/templates/lib.rs.ts

@@ -0,0 +1,10 @@
+export const createLibRs = () => `#![deny(clippy::all)]
+
+#[macro_use]
+extern crate napi_derive;
+
+#[napi]
+pub fn sum(a: i32, b: i32) -> i32 {
+  a + b
+}
+`

package/src/api/templates/package.json.ts

@@ -0,0 +1,44 @@
+export const createPackageJson = ({
+  name,
+  binaryName,
+  targets,
+  license,
+  engineRequirement,
+  cliVersion,
+}: {
+  name: string
+  binaryName: string
+  targets: string[]
+  license: string
+  engineRequirement: string
+  cliVersion: string
+}) => {
+  return `{
+  "name": "${name}",
+  "version": "1.0.0",
+  "main": "index.js",
+  "types": "index.d.ts",
+  "license": "${license}",
+  "engines": {
+    "node": "${engineRequirement}"
+  },
+  "napi": {
+    "name": "${binaryName}",
+    "targets": [
+      ${targets.map((t) => `"${t}"`).join(',\n      ')}
+    ]
+  },
+  "scripts": {
+    "test": "yarn build:debug --platform && node -e \\"assert(require('.').sum(1, 2) === 3)\\"",
+    "build": "napi build --release --platform --strip",
+    "build:debug": "napi build",
+    "prepublishOnly": "napi prepublish -t npm",
+    "artifacts": "napi artifacts",
+    "universal": "napi universal",
+    "version": "napi version"
+  },
+  "devDependencies": {
+    "@napi-rs/cli": "^${cliVersion}"
+  }
+}`
+}

package/src/api/universalize.ts

@@ -0,0 +1,76 @@
+import { spawnSync } from 'child_process'
+import { join, resolve } from 'path'
+
+import {
+  applyDefaultUniversalizeOptions,
+  UniversalizeOptions,
+} from '../def/universalize.js'
+import { readNapiConfig } from '../utils/config.js'
+import { debugFactory } from '../utils/log.js'
+import { fileExists } from '../utils/misc.js'
+import { UniArchsByPlatform } from '../utils/target.js'
+
+const debug = debugFactory('universalize')
+
+const universalizers: Partial<
+  Record<NodeJS.Platform, (inputs: string[], output: string) => void>
+> = {
+  darwin: (inputs, output) => {
+    spawnSync('lipo', ['-create', '-output', output, ...inputs], {
+      stdio: 'inherit',
+    })
+  },
+}
+
+export async function universalizeBinaries(userOptions: UniversalizeOptions) {
+  const options = applyDefaultUniversalizeOptions(userOptions)
+
+  const packageJsonPath = join(options.cwd, options.packageJsonPath)
+
+  const config = await readNapiConfig(packageJsonPath)
+
+  const target = config.targets.find(
+    (t) => t.platform === process.platform && t.arch === 'universal',
+  )
+
+  if (!target) {
+    throw new Error(
+      `'universal' arch for platform '${process.platform}' not found in config!`,
+    )
+  }
+
+  const srcFiles = UniArchsByPlatform[process.platform]?.map(
+    (arch) => `${config.binaryName}.${process.platform}-${arch}.node`,
+  )
+
+  if (!srcFiles || !universalizers[process.platform]) {
+    throw new Error(
+      `'universal' arch for platform '${process.platform}' not supported.`,
+    )
+  }
+
+  debug(`Looking up source binaries to combine: `)
+  debug('  %O', srcFiles)
+
+  const srcFileLookup = await Promise.all(
+    srcFiles.map((f) => fileExists(resolve(options.cwd, options.outputDir, f))),
+  )
+
+  const notFoundFiles = srcFiles.filter((_, i) => !srcFileLookup[i])
+
+  if (notFoundFiles.length) {
+    throw new Error(
+      `Some binary files were not found: ${JSON.stringify(notFoundFiles)}`,
+    )
+  }
+
+  const output = resolve(
+    options.cwd,
+    options.outputDir,
+    `${config.binaryName}.${process.platform}-universal.node`,
+  )
+
+  universalizers[process.platform]?.(srcFiles, output)
+
+  debug(`Produced universal binary: ${output}`)
+}

package/src/api/version.ts

@@ -0,0 +1,26 @@
+import { join, resolve } from 'path'
+
+import { applyDefaultVersionOptions, VersionOptions } from '../def/version.js'
+import {
+  readNapiConfig,
+  debugFactory,
+  updatePackageJson,
+} from '../utils/index.js'
+
+const debug = debugFactory('version')
+
+export async function version(userOptions: VersionOptions) {
+  const options = applyDefaultVersionOptions(userOptions)
+  const packageJsonPath = resolve(options.cwd, options.packageJsonPath)
+
+  const config = await readNapiConfig(packageJsonPath)
+
+  for (const target of config.targets) {
+    const pkgDir = resolve(options.cwd, options.npmDir, target.platformArchABI)
+
+    debug(`Update version to %i in [%i]`, config.packageJson.version, pkgDir)
+    await updatePackageJson(join(pkgDir, 'package.json'), {
+      version: config.packageJson.version,
+    })
+  }
+}

package/src/cli.ts

@@ -0,0 +1,29 @@
+import { Cli } from 'clipanion'
+
+import { ArtifactsCommand } from './commands/artifacts.js'
+import { BuildCommand } from './commands/build.js'
+import { CreateNpmDirsCommand } from './commands/create-npm-dirs.js'
+import { HelpCommand } from './commands/help.js'
+import { NewCommand } from './commands/new.js'
+import { PrePublishCommand } from './commands/pre-publish.js'
+import { RenameCommand } from './commands/rename.js'
+import { UniversalizeCommand } from './commands/universalize.js'
+import { VersionCommand } from './commands/version.js'
+import { CLI_VERSION } from './utils/misc.js'
+
+const cli = new Cli({
+  binaryName: 'napi',
+  binaryVersion: CLI_VERSION,
+})
+
+cli.register(NewCommand)
+cli.register(BuildCommand)
+cli.register(CreateNpmDirsCommand)
+cli.register(ArtifactsCommand)
+cli.register(UniversalizeCommand)
+cli.register(RenameCommand)
+cli.register(PrePublishCommand)
+cli.register(VersionCommand)
+cli.register(HelpCommand)
+
+void cli.runExit(process.argv.slice(2))

package/src/commands/artifacts.ts

@@ -0,0 +1,23 @@
+import { Command } from 'clipanion'
+
+import { collectArtifacts } from '../api/artifacts.js'
+import { BaseArtifactsCommand } from '../def/artifacts.js'
+
+export class ArtifactsCommand extends BaseArtifactsCommand {
+  static usage = Command.Usage({
+    description: 'Copy artifacts from Github Actions into specified dir',
+    examples: [
+      [
+        '$0 artifacts --dir . --dist ./npm',
+        `Copy [binaryName].[platform].node under current dir(.) into packages under npm dir.
+e.g: index.linux-x64-gnu.node --> ./npm/linux-x64-gnu/index.node`,
+      ],
+    ],
+  })
+
+  static paths = [['artifacts']]
+
+  async execute() {
+    await collectArtifacts(this.getOptions())
+  }
+}

package/src/commands/build.ts

@@ -0,0 +1,42 @@
+import { execSync } from 'child_process'
+
+import { Option } from 'clipanion'
+
+import { buildProject } from '../api/build.js'
+import { BaseBuildCommand } from '../def/build.js'
+import { debugFactory } from '../utils/index.js'
+
+const debug = debugFactory('build')
+
+export class BuildCommand extends BaseBuildCommand {
+  pipe = Option.String('--pipe', {
+    description:
+      'Pipe all outputs file to given command. e.g. `napi build --pipe "npx prettier --write"`',
+  })
+
+  cargoOptions = Option.Rest()
+
+  async execute() {
+    const { task } = await buildProject({
+      ...this.getOptions(),
+      cargoOptions: this.cargoOptions,
+    })
+
+    const outputs = await task
+
+    if (this.pipe) {
+      for (const output of outputs) {
+        debug('Piping output file to command: %s', this.pipe)
+        try {
+          execSync(`${this.pipe} ${output.path}`, {
+            stdio: 'inherit',
+            cwd: this.cwd,
+          })
+        } catch (e) {
+          debug.error(`Failed to pipe output file ${output.path} to command`)
+          debug.error(e)
+        }
+      }
+    }
+  }
+}

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

@@ -0,0 +1,8 @@
+import { createNpmDirs } from '../api/create-npm-dirs.js'
+import { BaseCreateNpmDirsCommand } from '../def/create-npm-dirs.js'
+
+export class CreateNpmDirsCommand extends BaseCreateNpmDirsCommand {
+  async execute() {
+    await createNpmDirs(this.getOptions())
+  }
+}

package/src/commands/help.ts

@@ -0,0 +1,13 @@
+import { Command } from 'clipanion'
+
+/**
+ * A command that prints the usage of all commands.
+ *
+ * Paths: `-h`, `--help`
+ */
+export class HelpCommand extends Command<any> {
+  static paths = [[`-h`], [`--help`]]
+  async execute() {
+    await this.context.stdout.write(this.cli.usage())
+  }
+}

package/src/commands/new.ts

@@ -0,0 +1,138 @@
+import path from 'path'
+
+import { Option } from 'clipanion'
+import inquirer from 'inquirer'
+
+import { newProject } from '../api/new.js'
+import { BaseNewCommand } from '../def/new.js'
+import {
+  AVAILABLE_TARGETS,
+  debugFactory,
+  DEFAULT_TARGETS,
+  TargetTriple,
+} from '../utils/index.js'
+import { napiEngineRequirement } from '../utils/version.js'
+
+const debug = debugFactory('new')
+
+export class NewCommand extends BaseNewCommand {
+  interactive = Option.Boolean('--interactive,-i', false, {
+    description:
+      'Ask project basic information interactively without just using the default.',
+  })
+
+  async execute() {
+    try {
+      const options = await this.fetchOptions()
+      await newProject(options)
+      return 0
+    } catch (e) {
+      debug('Failed to create new project')
+      debug.error(e)
+      return 1
+    }
+  }
+
+  private async fetchOptions() {
+    const cmdOptions = super.getOptions()
+
+    if (this.interactive) {
+      return {
+        ...cmdOptions,
+        name: await this.fetchName(path.parse(cmdOptions.path).base),
+        minNodeApiVersion: await this.fetchNapiVersion(),
+        targets: await this.fetchTargets(),
+        license: await this.fetchLicense(),
+        enableTypeDef: await this.fetchTypeDef(),
+        enableGithubActions: await this.fetchGithubActions(),
+      }
+    }
+
+    return cmdOptions
+  }
+
+  private async fetchName(defaultName: string): Promise<string> {
+    return (
+      this.$$name ??
+      (await inquirer
+        .prompt({
+          type: 'input',
+          name: 'name',
+          message: 'Package name (the name field in your package.json file)',
+          default: defaultName,
+        })
+        .then(({ name }) => name))
+    )
+  }
+
+  private async fetchLicense(): Promise<string> {
+    return inquirer
+      .prompt({
+        type: 'input',
+        name: 'license',
+        message: 'License for open-sourced project',
+        default: this.license,
+      })
+      .then(({ license }) => license)
+  }
+
+  private async fetchNapiVersion(): Promise<number> {
+    return inquirer
+      .prompt({
+        type: 'list',
+        name: 'minNodeApiVersion',
+        message: 'Minimum node-api version (with node version requirement)',
+        loop: false,
+        choices: new Array(8).fill(0).map((_, i) => ({
+          name: `napi${i + 1} (${napiEngineRequirement(i + 1)})`,
+          value: i + 1,
+        })),
+        // choice index
+        default: this.minNodeApiVersion - 1,
+      })
+      .then(({ minNodeApiVersion }) => minNodeApiVersion)
+  }
+
+  private async fetchTargets(): Promise<TargetTriple[]> {
+    if (this.enableDefaultTargets) {
+      return DEFAULT_TARGETS.concat()
+    }
+
+    if (this.enableAllTargets) {
+      return AVAILABLE_TARGETS.concat()
+    }
+
+    const { targets } = await inquirer.prompt({
+      name: 'targets',
+      type: 'checkbox',
+      loop: false,
+      message: 'Choose target(s) your crate will be compiled to',
+      default: DEFAULT_TARGETS,
+      choices: AVAILABLE_TARGETS,
+    })
+
+    return targets
+  }
+
+  private async fetchTypeDef(): Promise<boolean> {
+    const { enableTypeDef } = await inquirer.prompt({
+      name: 'enableTypeDef',
+      type: 'confirm',
+      message: 'Enable type definition auto-generation',
+      default: this.enableTypeDef,
+    })
+
+    return enableTypeDef
+  }
+
+  private async fetchGithubActions(): Promise<boolean> {
+    const { enableGithubActions } = await inquirer.prompt({
+      name: 'enableGithubActions',
+      type: 'confirm',
+      message: 'Enable Github Actions CI',
+      default: this.enableGithubActions,
+    })
+
+    return enableGithubActions
+  }
+}

package/src/commands/pre-publish.ts

@@ -0,0 +1,9 @@
+import { prePublish } from '../api/pre-publish.js'
+import { BasePrePublishCommand } from '../def/pre-publish.js'
+
+export class PrePublishCommand extends BasePrePublishCommand {
+  async execute() {
+    // @ts-expect-error const 'npm' | 'lerna' to string
+    await prePublish(this.getOptions())
+  }
+}

package/src/commands/rename.ts

@@ -0,0 +1,8 @@
+import { renameProject } from '../api/rename.js'
+import { BaseRenameCommand } from '../def/rename.js'
+
+export class RenameCommand extends BaseRenameCommand {
+  async execute() {
+    await renameProject(this.getOptions())
+  }
+}

package/src/commands/universalize.ts

@@ -0,0 +1,8 @@
+import { universalizeBinaries } from '../api/universalize.js'
+import { BaseUniversalizeCommand } from '../def/universalize.js'
+
+export class UniversalizeCommand extends BaseUniversalizeCommand {
+  async execute() {
+    await universalizeBinaries(this.getOptions())
+  }
+}

package/src/commands/version.ts

@@ -0,0 +1,8 @@
+import { version } from '../api/version.js'
+import { BaseVersionCommand } from '../def/version.js'
+
+export class VersionCommand extends BaseVersionCommand {
+  async execute() {
+    await version(this.getOptions())
+  }
+}

package/src/def/artifacts.ts

@@ -0,0 +1,79 @@
+// This file is generated by codegen/index.ts
+// Do not edit this file manually
+import { Command, Option } from 'clipanion'
+
+export abstract class BaseArtifactsCommand extends Command {
+  static paths = [['artifacts']]
+
+  static usage = Command.Usage({
+    description:
+      'Copy artifacts from Github Actions into npm packages and ready to publish',
+  })
+
+  cwd = Option.String('--cwd', process.cwd(), {
+    description:
+      'The working directory of where napi command will be executed in, all other paths options are relative to this path',
+  })
+
+  packageJsonPath = Option.String('--package-json-path', 'package.json', {
+    description: 'Path to `package.json`',
+  })
+
+  outputDir = Option.String('--output-dir,-o', './', {
+    description:
+      'Path to the folder where all built `.node` files put, same as `--output-dir` of build command',
+  })
+
+  npmDir = Option.String('--npm-dir', 'npm', {
+    description: 'Path to the folder where the npm packages put',
+  })
+
+  getOptions() {
+    return {
+      cwd: this.cwd,
+      packageJsonPath: this.packageJsonPath,
+      outputDir: this.outputDir,
+      npmDir: this.npmDir,
+    }
+  }
+}
+
+/**
+ * Copy artifacts from Github Actions into npm packages and ready to publish
+ */
+export interface ArtifactsOptions {
+  /**
+   * The working directory of where napi command will be executed in, all other paths options are relative to this path
+   *
+   * @default process.cwd()
+   */
+  cwd?: string
+  /**
+   * Path to `package.json`
+   *
+   * @default 'package.json'
+   */
+  packageJsonPath?: string
+  /**
+   * Path to the folder where all built `.node` files put, same as `--output-dir` of build command
+   *
+   * @default './'
+   */
+  outputDir?: string
+  /**
+   * Path to the folder where the npm packages put
+   *
+   * @default 'npm'
+   */
+  npmDir?: string
+}
+
+export function applyDefaultArtifactsOptions(options: ArtifactsOptions) {
+  return {
+    cwd: process.cwd(),
+    packageJsonPath: 'package.json',
+    outputDir: './',
+    npmDir: 'npm',
+    ...options,
+  }
+}