@highstate/cli 0.13.2 → 0.14.1

package/src/commands/init.ts

@@ -0,0 +1,189 @@
+import type { PackageManagerName } from "nypm"
+import { access, mkdir, readdir } from "node:fs/promises"
+import { basename, resolve } from "node:path"
+import { fileURLToPath } from "node:url"
+import { input, select } from "@inquirer/prompts"
+import { Command, Option } from "clipanion"
+import { installDependencies } from "nypm"
+import { generateFromTemplate, logger } from "../shared"
+
+export class InitCommand extends Command {
+  static paths = [["init"]]
+
+  static usage = Command.Usage({
+    description: "Initializes a new Highstate project.",
+  })
+
+  pathOption = Option.String("--path,-p", {
+    description: "The path where the project should be initialized.",
+  })
+
+  packageManager = Option.String("--package-manager", {
+    description: "The package manager to use (npm, yarn, pnpm).",
+  })
+
+  name = Option.String("--name", {
+    description: "The project name.",
+  })
+
+  private static readonly defaultPlatformVersion = "0.14.0"
+  private static readonly defaultLibraryVersion = "0.14.0"
+
+  async execute(): Promise<void> {
+    const availablePackageManagers = await detectAvailablePackageManagers(["npm", "pnpm", "yarn"])
+    if (availablePackageManagers.length === 0) {
+      throw new Error("no supported package managers found in PATH (npm, pnpm, yarn)")
+    }
+
+    const destinationPath = await resolveDestinationPath(this.pathOption)
+    const defaultName = basename(destinationPath)
+
+    const projectName = await resolveProjectName(this.name, defaultName)
+
+    const selectedPackageManager = await resolvePackageManager(
+      this.packageManager,
+      availablePackageManagers,
+    )
+
+    const templatePath = resolveTemplatePath()
+
+    await mkdir(destinationPath, { recursive: true })
+
+    const isEmptyOrMissing = await isEmptyDirectory(destinationPath)
+    if (!isEmptyOrMissing) {
+      throw new Error(`destination path is not empty: ${destinationPath}`)
+    }
+
+    logger.info("initializing highstate project in %s", destinationPath)
+
+    await generateFromTemplate(templatePath, destinationPath, {
+      projectName,
+      packageName: projectName,
+      platformVersion: InitCommand.defaultPlatformVersion,
+      libraryVersion: InitCommand.defaultLibraryVersion,
+      isPnpm: selectedPackageManager === "pnpm" ? "true" : "",
+      isYarn: selectedPackageManager === "yarn" ? "true" : "",
+    })
+
+    logger.info("installing dependencies using %s...", selectedPackageManager)
+
+    await installDependencies({
+      cwd: destinationPath,
+      packageManager: selectedPackageManager,
+      silent: false,
+    })
+
+    logger.info("project initialized successfully")
+  }
+}
+
+async function resolveDestinationPath(pathOption: string | undefined): Promise<string> {
+  if (pathOption) {
+    return resolve(pathOption)
+  }
+
+  const pathValue = await input({
+    message: "Project path",
+    default: ".",
+    validate: value => (value.trim().length > 0 ? true : "Path is required"),
+  })
+
+  return resolve(pathValue)
+}
+
+async function resolveProjectName(
+  nameOption: string | undefined,
+  defaultName: string,
+): Promise<string> {
+  if (nameOption) {
+    return nameOption.trim()
+  }
+
+  const value = await input({
+    message: "Project name",
+    default: defaultName,
+    validate: inputValue => (inputValue.trim().length > 0 ? true : "Name is required"),
+  })
+
+  return value.trim()
+}
+
+async function resolvePackageManager(
+  packageManagerOption: string | undefined,
+  available: PackageManagerName[],
+): Promise<PackageManagerName> {
+  if (packageManagerOption) {
+    if (!isSupportedPackageManagerName(packageManagerOption)) {
+      throw new Error(`unsupported package manager: ${packageManagerOption}`)
+    }
+
+    const name = packageManagerOption
+    if (!available.includes(name)) {
+      throw new Error(`package manager not found in PATH: ${name}`)
+    }
+
+    return name
+  }
+
+  const preferredOrder: PackageManagerName[] = ["pnpm", "yarn", "npm"]
+  const defaultValue = preferredOrder.find(value => available.includes(value)) ?? available[0]
+
+  return await select({
+    message: "Package manager",
+    default: defaultValue,
+    choices: available.map(value => ({ name: value, value })),
+  })
+}
+
+function isSupportedPackageManagerName(value: string): value is PackageManagerName {
+  return value === "npm" || value === "pnpm" || value === "yarn"
+}
+
+async function detectAvailablePackageManagers(
+  candidates: PackageManagerName[],
+): Promise<PackageManagerName[]> {
+  const results: PackageManagerName[] = []
+
+  for (const candidate of candidates) {
+    const exists = await isExecutableInPath(candidate)
+    if (exists) {
+      results.push(candidate)
+    }
+  }
+
+  return results
+}
+
+async function isExecutableInPath(command: string): Promise<boolean> {
+  const pathValue = process.env.PATH
+  if (!pathValue) {
+    return false
+  }
+
+  const parts = pathValue.split(":").filter(Boolean)
+  for (const part of parts) {
+    const candidate = resolve(part, command)
+    try {
+      await access(candidate)
+      return true
+    } catch {
+      // ignore
+    }
+  }
+
+  return false
+}
+
+async function isEmptyDirectory(path: string): Promise<boolean> {
+  try {
+    const entries = await readdir(path)
+    return entries.length === 0
+  } catch {
+    return true
+  }
+}
+
+function resolveTemplatePath(): string {
+  const here = fileURLToPath(new URL(import.meta.url))
+  return resolve(here, "..", "..", "assets", "template")
+}

package/src/main.ts

@@ -6,6 +6,7 @@ import { BackendUnlockMethodDeleteCommand } from "./commands/backend/unlock-meth
 import { BackendUnlockMethodListCommand } from "./commands/backend/unlock-method/list"
 import { BuildCommand } from "./commands/build"
 import { DesignerCommand } from "./commands/designer"
+import { InitCommand } from "./commands/init"
 import {
   CreateCommand as PackageCreateCommand,
   ListCommand as PackageListCommand,
@@ -21,6 +22,7 @@ const cli = new Cli({
 
 cli.register(BuildCommand)
 cli.register(DesignerCommand)
+cli.register(InitCommand)
 cli.register(BackendIdentityCommand)
 cli.register(BackendUnlockMethodListCommand)
 cli.register(BackendUnlockMethodAddCommand)

package/src/shared/generator.spec.ts

@@ -0,0 +1,73 @@
+import { mkdir, mkdtemp, readFile, writeFile } from "node:fs/promises"
+import { tmpdir } from "node:os"
+import { join, resolve } from "node:path"
+import { describe, expect, it } from "vitest"
+import { generateFromTemplate } from "./generator"
+
+async function readUtf8(filePath: string): Promise<string> {
+  return await readFile(filePath, "utf8")
+}
+
+describe("generateFromTemplate", () => {
+  it("copies files and replaces handlebars-style variables", async () => {
+    const root = await mkdtemp(join(tmpdir(), "highstate-generator-"))
+    const templatePath = resolve(root, "template")
+    const destinationPath = resolve(root, "dest")
+
+    await mkdir(templatePath, { recursive: true })
+
+    await writeFile(resolve(templatePath, "hello.txt"), "Hello, {{name}}!", "utf8")
+
+    await generateFromTemplate(templatePath, destinationPath, { name: "World" })
+
+    await expect(readUtf8(resolve(destinationPath, "hello.txt"))).resolves.toBe("Hello, World!")
+  })
+
+  it("removes .tpl from the end of destination filenames", async () => {
+    const root = await mkdtemp(join(tmpdir(), "highstate-generator-"))
+    const templatePath = resolve(root, "template")
+    const destinationPath = resolve(root, "dest")
+
+    await mkdir(templatePath, { recursive: true })
+
+    await writeFile(resolve(templatePath, "config.json.tpl"), '{"name":"{{name}}"}', "utf8")
+
+    await generateFromTemplate(templatePath, destinationPath, { name: "demo" })
+
+    await expect(readUtf8(resolve(destinationPath, "config.json"))).resolves.toBe('{"name":"demo"}')
+  })
+
+  it("removes .tpl from the middle of destination filenames", async () => {
+    const root = await mkdtemp(join(tmpdir(), "highstate-generator-"))
+    const templatePath = resolve(root, "template")
+    const destinationPath = resolve(root, "dest")
+
+    await mkdir(templatePath, { recursive: true })
+
+    await writeFile(
+      resolve(templatePath, "package.tpl.json"),
+      '{"name":"{{name}}","version":"{{version}}"}',
+      "utf8",
+    )
+
+    await generateFromTemplate(templatePath, destinationPath, { name: "demo", version: "1.2.3" })
+
+    await expect(readUtf8(resolve(destinationPath, "package.json"))).resolves.toBe(
+      '{"name":"demo","version":"1.2.3"}',
+    )
+  })
+
+  it("does not write files rendered to empty strings", async () => {
+    const root = await mkdtemp(join(tmpdir(), "highstate-generator-"))
+    const templatePath = resolve(root, "template")
+    const destinationPath = resolve(root, "dest")
+
+    await mkdir(templatePath, { recursive: true })
+
+    await writeFile(resolve(templatePath, "maybe.txt"), "{{#if enabled}}ok{{/if}}", "utf8")
+
+    await generateFromTemplate(templatePath, destinationPath, { enabled: "" })
+
+    await expect(readFile(resolve(destinationPath, "maybe.txt"))).rejects.toThrow(/ENOENT/)
+  })
+})

package/src/shared/generator.ts

@@ -0,0 +1,76 @@
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises"
+import { dirname, join, relative, resolve } from "node:path"
+import Handlebars from "handlebars"
+
+/**
+ * Copies all files from a template path to a destination path, replacing
+ * variables in the format {{variableName}} with their corresponding values
+ * and removing `.tpl` segments from file names.
+ *
+ * For example, `package.tpl.json` becomes `package.json` and `config.tpl` becomes `config`.
+ *
+ * @param templatePath The absolute path to the template directory.
+ * @param destinationPath The absolute path to the destination directory.
+ * @param variables The record of variable names and their replacement values.
+ */
+export async function generateFromTemplate(
+  templatePath: string,
+  destinationPath: string,
+  variables: Record<string, string>,
+): Promise<void> {
+  const resolvedTemplatePath = resolve(templatePath)
+  const resolvedDestinationPath = resolve(destinationPath)
+
+  const templateStats = await stat(resolvedTemplatePath)
+  if (!templateStats.isDirectory()) {
+    throw new Error(`templatePath must be a directory: ${resolvedTemplatePath}`)
+  }
+
+  await mkdir(resolvedDestinationPath, { recursive: true })
+
+  const renderTemplate = (raw: string): string => {
+    const template = Handlebars.compile(raw, {
+      strict: true,
+      noEscape: true,
+    })
+
+    return template(variables)
+  }
+
+  const visit = async (absoluteSourcePath: string): Promise<void> => {
+    const sourceStats = await stat(absoluteSourcePath)
+    if (sourceStats.isDirectory()) {
+      const relativePath = relative(resolvedTemplatePath, absoluteSourcePath)
+      const destinationDirPath = join(resolvedDestinationPath, relativePath)
+
+      await mkdir(destinationDirPath, { recursive: true })
+
+      const entries = await readdir(absoluteSourcePath, { withFileTypes: true })
+      for (const entry of entries) {
+        await visit(join(absoluteSourcePath, entry.name))
+      }
+
+      return
+    }
+
+    if (!sourceStats.isFile()) {
+      return
+    }
+
+    const relativeFilePath = relative(resolvedTemplatePath, absoluteSourcePath)
+    const destinationRelativePath = relativeFilePath.replaceAll(".tpl", "")
+    const destinationFilePath = join(resolvedDestinationPath, destinationRelativePath)
+
+    await mkdir(dirname(destinationFilePath), { recursive: true })
+
+    const contents = await readFile(absoluteSourcePath, "utf8")
+    const rendered = renderTemplate(contents)
+    if (rendered.trim().length === 0) {
+      return
+    }
+
+    await writeFile(destinationFilePath, rendered, "utf8")
+  }
+
+  await visit(resolvedTemplatePath)
+}

package/src/shared/index.ts

@@ -1,5 +1,6 @@
 export * from "./bin-transformer"
 export * from "./entry-points"
+export * from "./generator"
 export * from "./logger"
 export * from "./schema-transformer"
 export * from "./schemas"