create-bakery 2.1.1 → 2.2.0

package/README.md

@@ -6,6 +6,10 @@ The scaffolder behind `bun create bakery`.
 bun create bakery my-app
 ```
 
+Leave out the directory and it asks for one, offering `bakery-app`. At a
+terminal it also asks whether to include the ORM and which plugins to add,
+unless a flag already said.
+
 Writes a working [Bakery](https://github.com/obillekyle/bakery) app: a page,
 an API route that round-trips through SQLite, a registered ORM schema, and a
 `db:sync` script. Then:
@@ -20,7 +24,10 @@ bun run dev
 
 | Flag | Effect |
 | --- | --- |
+| `--orm` / `--no-orm` | Include the ORM (`orm/`, `db:sync`), or leave it out |
+| `--plugins <list>` | Comma-separated from `vue`, `analytics`, `dashboard`, `db-explorer`, or `none` |
 | `--name <name>` | Package name, when it should differ from the directory |
+| `--yes`, `-y` | Take the defaults for anything not passed: `bakery-app`, the ORM in, no plugins |
 | `--no-install` | Write the files and stop |
 | `-h`, `--help` | Usage |
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-bakery",
-  "version": "2.1.1",
-  "description": "Scaffold a Bakery app: bun create bakery <directory>",
+  "version": "2.2.0",
+  "description": "Scaffold a Bakery app: bun create bakery [directory]",
   "keywords": [
     "bakery",
     "bun",

package/src/index.ts

@@ -2,7 +2,7 @@
 
 import { mkdir, readdir, writeFile } from 'node:fs/promises'
 import { basename, resolve } from 'node:path'
-import { confirm, isInteractive, multiselect } from './prompt'
+import { confirm, isInteractive, multiselect, text } from './prompt'
 import {
   dependencyRange,
   isValidAppName,
@@ -27,16 +27,19 @@ import {
  * drag along.
  */
 
-const HELP = `bun create bakery <directory>
+/** The folder offered when none was given, and taken under `--yes`. */
+export const DEFAULT_FOLDER = 'bakery-app'
+
+const HELP = `bun create bakery [directory]
 
 Scaffold a Bakery app.
 
-Run it without --orm/--no-orm or --plugins and it asks, so long as you are at a
-terminal. Pass either and it stops asking about that one; pass --yes and it
-stops asking entirely.
+At a terminal it asks for whatever you leave out: the directory, the ORM
+(--orm/--no-orm) and the plugins (--plugins). Pass one and it stops asking
+about that one; pass --yes and it stops asking entirely.
 
 Arguments:
-  <directory>       Where to create it. Also the package name, unless --name
+  [directory]       Where to create it. Also the package name, unless --name
                     is given. Use "." for the current directory.
 
 Options:
@@ -45,21 +48,30 @@ Options:
   --no-orm          Leave it out. The example API route keeps posts in memory.
   --plugins <list>  Comma-separated, from: ${PLUGIN_IDS.join(', ')}.
                     Use --plugins none for an explicit empty set.
-  --yes, -y         Take the defaults for anything not passed (ORM in, no
-                    plugins). What a non-interactive shell does anyway.
+  --yes, -y         Take the defaults for anything not passed: the directory
+                    ${DEFAULT_FOLDER}, the ORM in, no plugins. Without a
+                    terminal the ORM and plugins default the same way, and the
+                    directory has to be given.
   --no-install      Write the files and stop, without running bun install.
   -h, --help        This.
 
 Examples:
+  bun create bakery
   bun create bakery my-app
   bun create bakery my-app --no-orm --plugins vue
   bun create bakery . --name my-app --plugins dashboard,analytics
   bun create bakery my-app --yes
 `
 
+/** What a package name may hold, for the messages that refuse one. */
+const NAME_RULE =
+  'Use lowercase letters, digits, dots, dashes and underscores, starting with a letter or a digit'
+
 type Options = {
-  dir: string
-  name: string
+  /** As typed, or `null` when it was left out and is asked for. */
+  dir: string | null
+  /** `--name`, or `null` to take the directory's name. */
+  name: string | null
   install: boolean
   /** `null` means "not specified". Ask, or fall back to the default. */
   orm: boolean | null
@@ -171,29 +183,117 @@ export function parseArgs(
     dir = arg
   }
 
-  if (dir === null) return { ok: false, message: HELP }
+  // Checked on its own, before any folder is known: no answer to the folder
+  // question can repair a name typed on the command line.
+  if (name !== null && !isValidAppName(name)) {
+    return {
+      ok: false,
+      message: `"${name}" is not a usable package name. ${NAME_RULE}.`,
+    }
+  }
 
-  // `.` is the documented way to scaffold in place, and `basename(resolve('.'))`
-  // is the containing folder's name, which is the name the user means.
-  const resolved = resolve(dir)
-  const appName = name ?? basename(resolved)
+  // Left out, the directory is asked for once the flags are read (`chooseFolder`).
+  if (dir === null) {
+    return { ok: true, options: { dir, name, install, orm, plugins, yes } }
+  }
 
-  if (!isValidAppName(appName)) {
+  const target = resolveTarget(dir, name)
+  if (!target.ok) {
     return {
       ok: false,
       message:
-        `"${appName}" is not a usable package name: lowercase letters, ` +
-        'digits, dot, dash and underscore only, and it may not start with a ' +
-        'dot or a dash. Pass --name to choose a different one.',
+        `"${target.name}" is not a usable package name. ${NAME_RULE}, ` +
+        'or pass --name to choose a different one.',
     }
   }
 
   return {
     ok: true,
-    options: { dir: resolved, name: appName, install, orm, plugins, yes },
+    options: { ...target.target, install, orm, plugins, yes },
+  }
+}
+
+/** Where the app goes, and the package name it is written with. */
+export type Target = { dir: string; name: string }
+
+/**
+ * A directory argument, and `--name` if given, as the absolute directory and
+ * the package name; or the name that cannot be one.
+ */
+export function resolveTarget(
+  dirArg: string,
+  nameArg: string | null,
+): { ok: true; target: Target } | { ok: false; name: string } {
+  // `.` is the documented way to scaffold in place, and `basename(resolve('.'))`
+  // is the containing folder's name, which is the name the user means.
+  const dir = resolve(dirArg)
+  const name = nameArg ?? basename(dir)
+  return isValidAppName(name)
+    ? { ok: true, target: { dir, name } }
+    : { ok: false, name }
+}
+
+/** How `chooseFolder` talks to the person running it. Swapped out by tests. */
+export type FolderIO = {
+  /** Ask for a line. `null` when there is no terminal to ask at. */
+  ask: ((question: string, fallback: string) => Promise<string | null>) | null
+  say: (line: string) => void
+}
+
+/**
+ * The directory, when the command line left it out.
+ *
+ * Asked for at a terminal, and asked again until the answer is usable: a
+ * folder whose name cannot be a package name, or one that already has files,
+ * is explained and asked for again rather than ending the run, since the
+ * person is right there to answer. `--yes` takes `DEFAULT_FOLDER` (or the
+ * last part of `--name`). Without a terminal there is nobody to ask, and a
+ * folder nobody named is not created: `'unasked'`.
+ *
+ * Returns `null` when the question was canceled.
+ */
+export async function chooseFolder(
+  options: Pick<Options, 'name' | 'yes'>,
+  io: FolderIO,
+): Promise<Target | null | 'unasked'> {
+  const fallback = options.name?.split('/').pop() ?? DEFAULT_FOLDER
+
+  if (options.yes || !io.ask) {
+    if (!options.yes) return 'unasked'
+    const target = resolveTarget(fallback, options.name)
+    if (!target.ok) return 'unasked'
+    if (!(await isScaffoldable(target.target.dir))) {
+      io.say(notEmpty(target.target.dir))
+      return 'unasked'
+    }
+    return target.target
+  }
+
+  for (;;) {
+    const answer = await io.ask('Folder name', fallback)
+    if (answer === null) return null
+
+    const target = resolveTarget(answer, options.name)
+    if (!target.ok) {
+      io.say(`"${target.name}" is not a usable package name. ${NAME_RULE}.`)
+      continue
+    }
+    if (!(await isScaffoldable(target.target.dir))) {
+      io.say(`${answer} already has files in it. Choose another folder.`)
+      continue
+    }
+    return target.target
   }
 }
 
+/** Why a directory given on the command line, or by `--yes`, was refused. */
+function notEmpty(dir: string): string {
+  return (
+    `${dir} already has files in it. Bakery will not scaffold over an ` +
+    'existing directory. Pick an empty one, or empty this one first.'
+  )
+}
+
 /**
  * Fill in whatever the flags left unspecified.
  *
@@ -307,22 +407,44 @@ async function main(): Promise<number> {
     return parsed.message === HELP ? 0 : 1
   }
 
-  const { dir, name, install } = parsed.options
-
-  // Checked before the prompts, not after: asking someone three questions and
-  // then refusing because the directory was never usable is the rudest possible
-  // ordering.
-  if (!(await isScaffoldable(dir))) {
-    console.log(
-      `${dir} already has files in it. Bakery will not scaffold over an ` +
-        'existing directory. Pick an empty one, or empty this one first.',
-    )
-    return 1
+  const { install } = parsed.options
+  const interactive = !parsed.options.yes && isInteractive()
+
+  // The directory comes first, and is checked before the other questions, not
+  // after: asking someone three questions and then refusing because the
+  // directory was never usable is the rudest possible ordering.
+  let target: Target
+  if (parsed.options.dir !== null && parsed.options.name !== null) {
+    target = { dir: parsed.options.dir, name: parsed.options.name }
+    if (!(await isScaffoldable(target.dir))) {
+      console.log(notEmpty(target.dir))
+      return 1
+    }
+  } else {
+    const chosen = await chooseFolder(parsed.options, {
+      ask: interactive ? text : null,
+      say: line => console.log(line),
+    })
+    if (chosen === null) {
+      console.log('\nCanceled. Nothing was written.')
+      return 130
+    }
+    if (chosen === 'unasked') {
+      if (!parsed.options.yes) {
+        console.log(
+          'Name the directory to create the app in: bun create bakery <directory>. ' +
+            'At a terminal it asks for one instead.',
+        )
+      }
+      return 1
+    }
+    target = chosen
   }
+  const { dir, name } = target
 
   const choices = await resolveChoices(parsed.options)
   if (!choices) {
-    console.log('\nCancelled. Nothing was written.')
+    console.log('\nCanceled. Nothing was written.')
     return 130
   }
 
@@ -342,12 +464,24 @@ async function main(): Promise<number> {
   console.log(`Created ${name} in ${dir} (${summary})`)
 
   if (install) {
-    const proc = Bun.spawn(['bun', 'install'], {
-      cwd: dir,
-      stdout: 'inherit',
-      stderr: 'inherit',
-    })
-    const code = await proc.exited
+    const run = (flags: string[]) =>
+      Bun.spawn(['bun', 'install', ...flags], {
+        cwd: dir,
+        stdout: 'inherit',
+        stderr: 'inherit',
+      }).exited
+
+    let code = await run([])
+    // A release a few minutes old is on npm before Bun's cached package list
+    // knows it, and the app asks for this scaffolder's own minor. On
+    // 2026-10-04, `bun create bakery@latest` 2.1.2 wrote `^2.1.2` and the
+    // install failed with "No version matching" until the cache was skipped.
+    if (code !== 0) {
+      console.log(
+        "\nRetrying with Bun's package cache skipped, in case a release is minutes old.\n",
+      )
+      code = await run(['--no-cache'])
+    }
     if (code !== 0) {
       console.log(
         '\nbun install failed. The app is written. Run it again in ' +

package/src/prompt.ts

@@ -138,31 +138,70 @@ function clearLines(n: number): void {
   write(`${ESC}[0J`)
 }
 
-async function* keypresses(): AsyncGenerator<string> {
-  process.stdin.setRawMode?.(true)
-  process.stdin.resume()
-  try {
-    for await (const chunk of process.stdin) {
-      // A single read can carry a whole escape sequence, and on a fast paste it
-      // can carry several keys at once. Arrow keys are the only multi-byte
-      // sequence handled, so they are matched first and the rest is yielded
-      // character by character.
-      const text = Buffer.from(chunk).toString('utf8')
-      let i = 0
-      while (i < text.length) {
-        if (text.startsWith(`${ESC}[`, i) && i + 2 < text.length) {
-          yield text.slice(i, i + 3)
-          i += 3
-          continue
-        }
-        yield text[i]!
-        i += 1
-      }
+/**
+ * Split what one read of stdin delivered into keypresses.
+ *
+ * A single read can carry a whole escape sequence, and on a fast paste it can
+ * carry several keys at once. Arrow keys are the only multi-byte sequence
+ * handled, so they are matched first and the rest is split by character:
+ * by code point, so a character outside the basic plane stays one key.
+ */
+export function splitKeys(text: string): string[] {
+  const keys: string[] = []
+  let i = 0
+  while (i < text.length) {
+    if (text.startsWith(`${ESC}[`, i) && i + 2 < text.length) {
+      keys.push(text.slice(i, i + 3))
+      i += 3
+      continue
     }
-  } finally {
-    process.stdin.setRawMode?.(false)
-    process.stdin.pause()
+    const key = String.fromCodePoint(text.codePointAt(i)!)
+    keys.push(key)
+    i += key.length
   }
+  return keys
+}
+
+/**
+ * Hand keypresses to `onKey` until it returns true, then let go of stdin
+ * without closing it, so the next prompt can read from it too.
+ *
+ * Listeners, not `for await (const chunk of process.stdin)`. Leaving a
+ * `for await` early returns the stream's iterator, and returning a readable's
+ * iterator destroys the stream: in 2.1.1 the first prompt answered and the
+ * second died on the destroyed stdin with `AbortError: The operation was
+ * aborted`, on any terminal, whenever more than one question was asked.
+ *
+ * Keys after the answering one, in the same read, are dropped: they were
+ * typed before the next prompt was on screen.
+ */
+function readKeys(onKey: (key: string) => boolean): Promise<void> {
+  const stdin = process.stdin
+  return new Promise(resolve => {
+    const finish = () => {
+      stdin.off('data', onData)
+      stdin.off('end', onEnd)
+      stdin.setRawMode?.(false)
+      stdin.pause()
+      resolve()
+    }
+    const onData = (chunk: Buffer | string) => {
+      for (const key of splitKeys(Buffer.from(chunk).toString('utf8'))) {
+        if (onKey(key)) return finish()
+      }
+    }
+    // The other end went away. Taken as Ctrl-D, which every prompt treats as
+    // a cancel, rather than waiting for a key that cannot come.
+    const onEnd = () => {
+      onKey(KEY.ctrlD)
+      finish()
+    }
+
+    stdin.setRawMode?.(true)
+    stdin.on('data', onData)
+    stdin.on('end', onEnd)
+    stdin.resume()
+  })
 }
 
 export async function confirm(
@@ -172,17 +211,19 @@ export async function confirm(
   const suffix = fallback ? 'Y/n' : 'y/N'
   write(`${GREEN}?${RESET} ${question} ${DIM}(${suffix})${RESET} `)
 
-  for await (const key of keypresses()) {
+  let answer: boolean | null = null
+  await readKeys(key => {
     const result = applyConfirmKey(key, fallback)
-    if (result.kind === 'ignore') continue
+    if (result.kind === 'ignore') return false
     if (result.kind === 'cancel') {
       write('\n')
-      return null
+      return true
     }
+    answer = result.value
     write(`${CYAN}${result.value ? 'yes' : 'no'}${RESET}\n`)
-    return result.value
-  }
-  return null
+    return true
+  })
+  return answer
 }
 
 /** Returns the chosen ids, or `null` if the user canceled. */
@@ -191,41 +232,102 @@ export async function multiselect(
   choices: Choice[],
 ): Promise<string[] | null> {
   let state: MultiselectState = { choices, cursor: 0, selected: new Set() }
-
   let frame = renderMultiselect(question, state)
   write(`${ESC}[?25l${frame}`) // hide the cursor while redrawing
 
+  let chosen: string[] | null = null
   try {
-    for await (const key of keypresses()) {
+    await readKeys(key => {
       const result = applyKey(state, key)
-      if (result.kind === 'cancel') {
-        clearLines(frame.split('\n').length - 1)
-        return null
-      }
+      clearLines(frame.split('\n').length - 1)
+      if (result.kind === 'cancel') return true
 
-      const previous = frame
       state = result.state
-      frame = renderMultiselect(question, state)
-
       if (result.kind === 'submit') {
-        clearLines(previous.split('\n').length - 1)
-        const names = state.choices
-          .filter(c => state.selected.has(c.id))
-          .map(c => c.label)
+        const picked = state.choices.filter(c => state.selected.has(c.id))
+        const names = picked.map(c => c.label)
         write(
           `${GREEN}?${RESET} ${question} ` +
             `${CYAN}${names.length ? names.join(', ') : 'none'}${RESET}\n`,
         )
-        return state.choices
-          .filter(c => state.selected.has(c.id))
-          .map(c => c.id)
+        chosen = picked.map(c => c.id)
+        return true
       }
 
-      clearLines(previous.split('\n').length - 1)
+      frame = renderMultiselect(question, state)
       write(frame)
-    }
+      return false
+    })
   } finally {
     write(`${ESC}[?25h`) // always give the cursor back
   }
-  return null
+  return chosen
+}
+
+export type TextResult =
+  | { kind: 'update'; value: string }
+  | { kind: 'submit'; value: string }
+  | { kind: 'cancel' }
+
+/**
+ * Apply one keypress to a line of text being typed.
+ *
+ * Backspace arrives as DEL (`\x7f`) from most terminals and as `\b` from the
+ * Windows console, so both delete. Escape sequences (the arrows) are ignored
+ * rather than typed, and so is any other control character.
+ */
+export function applyTextKey(value: string, key: string): TextResult {
+  if (key === KEY.ctrlC || key === KEY.ctrlD) return { kind: 'cancel' }
+  if (key === KEY.enter || key === KEY.enterLf) {
+    return { kind: 'submit', value }
+  }
+  if (key === '\x7f' || key === '\b') {
+    return { kind: 'update', value: Array.from(value).slice(0, -1).join('') }
+  }
+  const code = key.codePointAt(0) ?? 0
+  if (key.startsWith(ESC) || code < 0x20) return { kind: 'update', value }
+  return { kind: 'update', value: value + key }
+}
+
+export function renderText(
+  question: string,
+  fallback: string,
+  value: string,
+): string {
+  const hint = fallback ? ` ${DIM}(${fallback})${RESET}` : ''
+  return `${GREEN}?${RESET} ${question}${hint} ${value}`
+}
+
+/**
+ * Ask for a line of text. Enter on an empty line takes `fallback`. Returns
+ * `null` if the user canceled.
+ */
+export async function text(
+  question: string,
+  fallback: string,
+): Promise<string | null> {
+  let value = ''
+  const draw = () =>
+    write(`\r${ESC}[2K${renderText(question, fallback, value)}`)
+  draw()
+
+  let answer: string | null = null
+  await readKeys(key => {
+    const result = applyTextKey(value, key)
+    if (result.kind === 'cancel') {
+      write('\n')
+      return true
+    }
+    if (result.kind === 'submit') {
+      answer = result.value.trim() || fallback
+      write(
+        `\r${ESC}[2K${GREEN}?${RESET} ${question} ${CYAN}${answer}${RESET}\n`,
+      )
+      return true
+    }
+    value = result.value
+    draw()
+    return false
+  })
+  return answer
 }

package/src/template.ts

@@ -103,9 +103,19 @@ export const PLUGINS_NEEDING_ORM: readonly PluginId[] = ['db-explorer']
  * scaffolder is published in lockstep with the framework: `create-bakery@4.1.0`
  * scaffolding `^4.0.0` is the drift this avoids. Caret, so a generated app
  * picks up patches without regenerating.
+ *
+ * **The floor is this version's minor, not its patch.** A patch adds nothing
+ * a template could depend on, and asking for it exactly made every patch
+ * release uninstallable for its first minutes: create-bakery 2.1.2 reached
+ * npm's `latest` while the registry, and Bun's cached copy of it, still
+ * listed core at 2.1.1, so `^2.1.2` resolved to nothing (2026-10-04).
+ * `^2.1.0` takes 2.1.2 as soon as it is listed and 2.1.1 until then. A
+ * prerelease keeps its whole version, since `^2.0.0` would not match
+ * `2.0.0-rc.5` at all.
  */
 export function dependencyRange(ownVersion: string): string {
-  return `^${ownVersion}`
+  const release = /^(\d+)\.(\d+)\.\d+$/.exec(ownVersion)
+  return release ? `^${release[1]}.${release[2]}.0` : `^${ownVersion}`
 }
 
 /**
@@ -345,8 +355,7 @@ declare module '@bakery-framework/orm/schema-registry' {
  */
 const DB_SYNC_SCRIPT = `import { SyncService } from '@bakery-framework/orm/sync'
 
-await SyncService.run()
-process.exit(0)
+process.exit((await SyncService.run()) ? 0 : 1)
 `
 
 function gitignore(orm: boolean): string {
@@ -395,7 +404,10 @@ function readme(name: string, orm: boolean, plugins: PluginId[]): string {
         : '') +
       (plugins.includes('vue')
         ? '\n\n`vue` and `@vue/compiler-sfc` are direct dependencies rather than ' +
-          'unmet peers, so `.vue` pages compile straight after install.'
+          'unmet peers, so `.vue` pages compile straight after install.' +
+          '\n\n`bun run build` bundles the pages into a few cached files, which ' +
+          '`bun run start` then serves in place of a request per component. ' +
+          'Run it before starting, and again after changing a page.'
         : '') +
       '\n'
     : ''
@@ -500,6 +512,9 @@ export function templateFiles(
       // would stop at TS6053. `-b`, because the root claims no files and
       // `tsc -p` on it checks nothing while reporting success.
       typecheck: 'bakery --types && tsc -b',
+      // Vue pages bundled for production. Only with the plugin: without it
+      // the command has nothing to do.
+      ...(plugins.includes('vue') ? { build: 'bakery --build' } : {}),
       ...(orm
         ? {
             'db:sync': 'bun run scripts/db-sync.ts',