create-nevela 0.4.2 → 0.4.3

package/index.mjs

@@ -6,7 +6,7 @@
 //
 // No dependencies on purpose: this runs before anything is installed.
 
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import crypto from 'node:crypto';
 import fs from 'node:fs';
 import os from 'node:os';
@@ -369,17 +369,62 @@ async function inProject(name, args) {
   process.exit(status);
 }
 
+/**
+ * How the copy that is running was installed, or null when it isn't the installed command.
+ * The folder it was started through is passed as well as the one its files are in: under
+ * pnpm 11 only the first says it is pnpm's.
+ */
+function installed() {
+  if (fromRepository) return null;
+  const startedFrom = process.argv[1] ? path.dirname(path.resolve(process.argv[1])) : here;
+  return globalInstall(here, fs.existsSync, startedFrom);
+}
+
+/** What typing `nevela` runs now, as "x.y.z", or null when that can't be found out. */
+function versionOnPath() {
+  const answer = spawnCommand('nevela', ['--version'], { stdio: 'pipe', encoding: 'utf8' });
+  return /^\d+\.\d+\.\d+$/m.exec(`${answer.stdout ?? ''}`)?.[0] ?? null;
+}
+
+/** The launcher of the nevela command in `dir`: the file the shell runs. */
+const launcherIn = (dir) => path.join(dir, windows ? 'nevela.cmd' : 'nevela');
+
+/** The version of the nevela command in `dir`, as "x.y.z", or null when it won't say. */
+function copyVersion(dir) {
+  const file = launcherIn(dir);
+  const answer = windows
+    ? spawnSync(`"${file}" --version`, { shell: true, stdio: 'pipe', encoding: 'utf8' })
+    : spawnSync(file, ['--version'], { stdio: 'pipe', encoding: 'utf8' });
+  return /^\d+\.\d+\.\d+$/m.exec(`${answer.stdout ?? ''}`)?.[0] ?? null;
+}
+
 /**
  * Say so when the nevela command is installed more than once. Only the first on the PATH
  * ever runs, so an update to one of the others looks like an update that did nothing.
+ * The one to keep is the newest, which is not always the one that runs.
  */
 function otherCopies() {
-  const copies = copiesOnPath();
+  const copies = copiesOnPath().map((dir) => ({ dir, version: copyVersion(dir) }));
   if (copies.length < 2) return;
+  let keep = copies[0];
+  for (const copy of copies) {
+    if (copy.version && (!keep.version || isNewer(copy.version, keep.version))) keep = copy;
+  }
+  const width = Math.max(...copies.map((copy) => copy.dir.length));
   console.log(`\n  ${red('!')} The nevela command is installed ${copies.length} times. Typing ${bold('nevela')} runs the first of these:`);
-  for (const dir of copies) console.log(`      ${dir}`);
-  console.log(`    Keep that one and remove the rest, so there is one to keep up to date:`);
-  for (const dir of copies.slice(1)) console.log(`      ${bold(removeCommand(dir))}`);
+  for (const copy of copies) console.log(`      ${copy.dir.padEnd(width)}  ${copy.version ? `v${copy.version}` : ''}`);
+  console.log(keep === copies[0]
+    ? `    Keep that one and remove the rest, so there is one to keep up to date:`
+    : `    The one that runs is not the newest. Remove the others, and ${bold(`v${keep.version}`)} is what ${bold('nevela')} runs:`);
+  const launcher = (dir) => {
+    try {
+      return fs.readFileSync(launcherIn(dir), 'utf8').slice(0, 4000);
+    } catch {
+      return '';
+    }
+  };
+  const removals = new Set(copies.filter((copy) => copy !== keep).map((copy) => removeCommand(copy.dir, launcher(copy.dir))));
+  for (const removal of removals) console.log(`      ${bold(removal)}`);
 }
 
 /** The version of Nevela an app has installed, read from the package, or null. */
@@ -395,7 +440,7 @@ function appVersion(project) {
 /** `nevela version`, from anywhere: the command's version, and the app's when in one. */
 function showVersion() {
   const project = findProject(process.cwd());
-  const install = fromRepository ? null : globalInstall(here);
+  const install = installed();
   console.log(`\n  ${indigo(bold('Nevela command'))}   ${bold(`v${VERSION}`)}${install ? `  ${dim(`installed with ${install.manager}`)}` : ''}`);
   if (project) {
     const app = appVersion(project);
@@ -459,7 +504,7 @@ async function askName() {
  */
 async function updateTool(args) {
   const project = findProject(process.cwd());
-  const install = fromRepository ? null : globalInstall(here);
+  const install = installed();
 
   if (!install) {
     // Run through npx or `pnpm dlx`, which fetch the latest every time, started by an
@@ -485,18 +530,29 @@ async function updateTool(args) {
   if (latest === null) {
     // Not the same as being up to date, so it isn't reported as that.
     console.log(`  ${red('!')} Couldn't reach npm to see whether there is a newer nevela than ${bold(VERSION)}. Nothing was changed.`);
-    console.log(`    Try again when you are online, or run:  ${install.command.join(' ')}`);
+    console.log(`    Try again when you are online, or run:  ${install.command().join(' ')}`);
     process.exitCode = 1;
   } else if (!newer) {
     console.log(`  ${green(`✔ Already on the latest version (v${VERSION}). Nothing to do.`)}`);
   } else {
-    console.log(`  Updating v${VERSION} → ${bold(`v${newer}`)} ${dim(`(${install.command.join(' ')})`)}\n`);
-    const [command, ...rest] = install.command;
+    // The version by number, not "latest": pnpm holds "latest" back for a day.
+    const [command, ...rest] = install.command(newer);
+    console.log(`  Updating v${VERSION} → ${bold(`v${newer}`)} ${dim(`(${[command, ...rest].join(' ')})`)}\n`);
     const result = spawnCommand(command, rest, { stdio: 'inherit' });
     if (result.error || result.status !== 0) {
-      fail(`Couldn't update the nevela command.`, `Run it yourself to see why:  ${install.command.join(' ')}`);
+      fail(`Couldn't update the nevela command.`, `Run it yourself to see why:  ${[command, ...rest].join(' ')}`);
+    }
+    // The package manager saying so isn't the same as the command being newer: ask it.
+    const now = versionOnPath();
+    if (now === newer || now === null) {
+      console.log(`\n  ${green(`✔ Updated to v${newer}.`)} ${dim('Every nevela command, and every app you create from now on, uses it.')}`);
+    } else {
+      console.log(`\n  ${red('!')} ${install.manager} installed ${bold(`v${newer}`)}, but typing ${bold('nevela')} still runs ${bold(`v${now}`)}.`);
+      if (copiesOnPath().length < 2) {
+        console.log(`    Open a new terminal and run ${bold('nevela version')}. If it still says v${now}, the copy that runs was installed another way.`);
+      }
+      process.exitCode = 1;
     }
-    console.log(`\n  ${green(`✔ Updated to v${newer}.`)} ${dim('Every nevela command, and every app you create from now on, uses it.')}`);
   }
   otherCopies();
   if (project) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-nevela",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "description": "Create a new Nevela app: a Laravel API and a Next.js dashboard from one resource description.",
   "type": "module",
   "bin": {

package/template/laravel/src/Nevela.php

@@ -18,7 +18,7 @@ use Nevela\Laravel\Support\Naming;
 final class Nevela
 {
     /** Written by `pnpm release`; the same number as the repository's git tag. */
-    public const VERSION = '0.4.2';
+    public const VERSION = '0.4.3';
 
     /** @var array<string, Descriptor> */
     private static array $descriptors = [];

package/template/web/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nevela-web",
-  "version": "0.4.2",
+  "version": "0.4.3",
   "private": true,
   "type": "module",
   "scripts": {

package/tool.mjs

@@ -6,43 +6,64 @@
 //   nevela upgrade    the app you are in: its Nevela package and its dashboard
 //
 // Updating the command means asking the package manager that installed it to install the
-// latest. Which one that was is read from where this file is running from.
+// newest version. Which one that was is read from where this file is running from.
 
 import fs from 'node:fs';
 
-/** The command that installs the latest create-nevela globally, for each package manager. */
+/**
+ * The command that installs create-nevela globally, for each package manager.
+ *
+ * `nevela update` names the exact version it found on npm, not "latest": pnpm holds a
+ * version back for a day after it is published, so `pnpm add -g create-nevela@latest`
+ * installs yesterday's. Asked for a version by number, it installs that one.
+ */
 const INSTALL = {
-  npm: ['npm', 'install', '-g', 'create-nevela@latest'],
-  pnpm: ['pnpm', 'add', '-g', 'create-nevela@latest'],
-  yarn: ['yarn', 'global', 'add', 'create-nevela@latest'],
-  bun: ['bun', 'add', '-g', 'create-nevela@latest'],
+  npm: (version) => ['npm', 'install', '-g', `create-nevela@${version}`],
+  pnpm: (version) => ['pnpm', 'add', '-g', `create-nevela@${version}`],
+  yarn: (version) => ['yarn', 'global', 'add', `create-nevela@${version}`],
+  bun: (version) => ['bun', 'add', '-g', `create-nevela@${version}`],
 };
 
 /**
- * How the running copy was installed, from the folder it is in.
+ * How the running copy was installed, from the folder it is in and the folder it was
+ * started through.
+ *
+ * Those two differ under pnpm 11, which keeps the files of every package in its store and
+ * leaves a link to them in its global folder. Node reports the store; the command was
+ * started through the global folder. Going by the store alone, a pnpm install looked like
+ * an npm one, and `nevela update` updated a copy that was not the one running.
  *
- * Returns the package manager and the command that updates it, or null when this copy
+ * Returns the package manager and `command(version)`, which updates it, or null when this copy
  * isn't the installed command: it was fetched for a single run (npx, pnpm dlx, a
  * self-update), it is the repository itself, or it is a dependency in some project's own
  * node_modules. Updating the global command would not change the copy that is running in
  * any of those cases.
  *
- * @param {string} dir     The folder this package is running from
+ * @param {string} dir     The folder this package's files are in
  * @param {(file: string) => boolean} exists  Whether a file exists; replaceable in tests
+ * @param {string} startedFrom  The folder it was started through, when that is another
  */
-export function globalInstall(dir, exists = fs.existsSync) {
-  const plain = dir.replace(/\\/g, '/').replace(/\/+$/, '');
+export function globalInstall(dir, exists = fs.existsSync, startedFrom = dir) {
+  const tidy = (folder) => folder.replace(/\\/g, '/').replace(/\/+$/, '');
+  const plain = tidy(dir);
   const where = plain.toLowerCase();
+  const started = tidy(startedFrom).toLowerCase();
+  const found = (manager) => ({ manager, command: (version = 'latest') => INSTALL[manager](version) });
 
   // Fetched for one run and thrown away afterwards.
-  if (/\/_npx\/|\/dlx[-/]|\/\.?bunx-|\/xfs-[0-9a-f]+\/|\/create-nevela-\d[^/]*\/package$/.test(where)) return null;
+  if ([where, started].some((folder) => /\/_npx\/|\/dlx[-/]|\/\.?bunx-|\/xfs-[0-9a-f]+\/|\/create-nevela-\d[^/]*\/package$/.test(folder))) return null;
   // Installed, as opposed to checked out: it sits in somebody's node_modules.
   if (!/\/node_modules\/create-nevela$/.test(where)) return null;
 
   // pnpm, yarn and bun each keep global packages in a folder of their own.
-  if (/\/pnpm\/global\//.test(where)) return { manager: 'pnpm', command: INSTALL.pnpm };
-  if (/\/\.bun\/install\/global\//.test(where)) return { manager: 'bun', command: INSTALL.bun };
-  if (/\/yarn\/(data\/)?global\/|\/\.config\/yarn\/global\//.test(where)) return { manager: 'yarn', command: INSTALL.yarn };
+  for (const folder of [started, where]) {
+    if (!/\/node_modules\/create-nevela$/.test(folder)) continue;
+    if (/\/pnpm\/global\/|\/global\/v?\d+\/([^/]+\/)?node_modules\/create-nevela$/.test(folder)) return found('pnpm');
+    if (/\/\.bun\/install\/global\//.test(folder)) return found('bun');
+    if (/\/yarn\/(data\/)?global\/|\/\.config\/yarn\/global\//.test(folder)) return found('yarn');
+  }
+  // In pnpm's store, and not reached through its global folder: a project's dependency.
+  if (/\/store\/v?\d+\/links\//.test(where)) return null;
 
   // npm's global folder is a plain node_modules, like a project's. Two things tell them
   // apart: a project has a package.json beside its node_modules, and a dependency of a
@@ -51,7 +72,7 @@ export function globalInstall(dir, exists = fs.existsSync) {
   const owner = plain.slice(0, where.lastIndexOf('/node_modules/'));
   if (exists(`${owner}/package.json`)) return null;
 
-  return { manager: 'npm', command: INSTALL.npm };
+  return found('npm');
 }
 
 /**
@@ -90,14 +111,18 @@ export function copiesOnPath(env = process.env, { exists = fs.existsSync, real =
   return found;
 }
 
-/** What removes the copy whose command is in `dir`, judged by the folder. */
-export function removeCommand(dir) {
+/**
+ * What removes the copy whose command is in `dir`, judged by the folder and by the
+ * launcher in it: a small script that names the folder the package itself is in.
+ */
+export function removeCommand(dir, launcher = '') {
   const where = dir.replace(/\\/g, '/').toLowerCase();
-  if (/\/pnpm(\/|$)/.test(where)) return 'pnpm remove -g create-nevela';
+  const points = launcher.replace(/\\/g, '/').toLowerCase();
+  if (/\/pnpm(\/|$)/.test(where) || /\/global\/v?\d+\/([^/]+\/)?node_modules\/create-nevela\//.test(points)) return 'pnpm remove -g create-nevela';
   if (/\/\.bun\//.test(where)) return 'bun remove -g create-nevela';
   if (/\/yarn\/|\/\.yarn\//.test(where)) return 'yarn global remove create-nevela';
   return 'npm uninstall -g create-nevela';
 }
 
 /** What to type to get the `nevela` command, for someone who doesn't have it yet. */
-export const INSTALL_COMMAND = INSTALL.npm.join(' ').replace('@latest', '');
+export const INSTALL_COMMAND = 'npm install -g create-nevela';