@weft-js/cli 0.1.1 → 0.1.3

package/src/add/setup.mjs

@@ -0,0 +1,88 @@
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { createRequire } from 'node:module'
+import { dirname, join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { database } from '../map.mjs'
+import { dbLayer } from '../db-layer.mjs'
+import { refused } from './errors.mjs'
+
+/** The plugin's `setup`, once the package is installed: a plain import, since the package can't run anything by being read. */
+export async function setupOf(root, pkg) {
+  let path
+  try {
+    path = createRequire(join(root, 'package.json')).resolve(`${pkg}/plugin`)
+  } catch {
+    return undefined // no plugin entry, or a dry run before the install
+  }
+  const mod = await import(pathToFileURL(path).href)
+  const make = mod.default ?? Object.values(mod).find((v) => typeof v === 'function')
+  return make?.().contribute({ command: 'check', mode: 'development', root }).setup
+}
+
+/** What `setup` wants, checked in full before anything is written, so a refusal changes nothing. */
+export async function planSetup(root, setup) {
+  const layer = await dbLayer(root)
+  if (setup.needs?.includes('db') && !layer)
+    throw refused('This needs a database: run `weft add db` first. Nothing was changed.')
+  if (setup.needs?.includes('auth') && !existsSync(join(root, 'src/auth.server.ts')))
+    throw refused('This needs users: run `weft add auth` first. Nothing was changed.')
+  const read = (rel) =>
+    existsSync(join(root, rel)) ? readFileSync(join(root, rel), 'utf8') : undefined
+  let plan
+  try {
+    plan = setup.run({
+      engine: layer ? database(root, layer).engine : null,
+      layer: layer?.layer ?? null,
+      read,
+    })
+  } catch (error) {
+    throw refused(`${error.message}. Nothing was changed.`)
+  }
+  const taken = Object.keys(plan.files ?? {}).filter((f) => existsSync(join(root, f)))
+  if (taken.length) throw refused(`${taken.join(', ')} already exist. Nothing was changed.`)
+  return plan
+}
+
+export function applySetup(root, plan) {
+  for (const [file, text] of Object.entries({ ...plan.files, ...plan.edits })) {
+    mkdirSync(dirname(join(root, file)), { recursive: true })
+    writeFileSync(join(root, file), text)
+  }
+  for (const name of ['.env', '.env.example']) {
+    const file = join(root, name)
+    const had = existsSync(file) ? readFileSync(file, 'utf8') : ''
+    const lines = Object.entries(plan.env ?? {})
+      .filter(([k]) => !had.includes(`${k}=`))
+      .map(([k, v]) => `${k}=${v}\n`)
+    if (lines.length) writeFileSync(file, `${had && `${had.trimEnd()}\n`}${lines.join('')}`)
+  }
+}
+
+export const setupActions = (plan) => [
+  ...Object.keys({ ...plan.files, ...plan.edits }).map((f) => `write ${f}`),
+  ...(plan.env ? [`add ${Object.keys(plan.env).join(', ')} to .env and .env.example`] : []),
+  ...(plan.next ?? []).map((n) => `next: ${n}`),
+]
+
+export function authEdits({ root, files, context, tables, envText, layer }) {
+  const edits = { ...files, 'src/context.server.ts': context }
+  if (!envText.includes('BETTER_AUTH_SECRET'))
+    edits['src/env.server.ts'] = envText.replace(
+      'server: {\n',
+      'server: {\n    BETTER_AUTH_SECRET: z.string().min(32),\n',
+    )
+  if (layer.layer === 'drizzle') {
+    edits['src/db/auth.schema.ts'] = tables
+    edits['src/db/schema.ts'] =
+      `${readFileSync(join(root, 'src/db/schema.ts'), 'utf8').trimEnd()}\n\nexport * from './auth.schema'\n`
+  } else if (layer.layer === 'prisma') {
+    edits['prisma/schema.prisma'] =
+      `${readFileSync(join(root, 'prisma/schema.prisma'), 'utf8').trimEnd()}\n${tables}`
+  } else {
+    const next = existsSync(join(root, 'migrations'))
+      ? readdirSync(join(root, 'migrations')).filter((f) => f.endsWith('.sql')).length
+      : 0
+    edits[`migrations/${String(next).padStart(4, '0')}_auth.sql`] = tables
+  }
+  return edits
+}

package/src/add-rust.mjs

@@ -6,28 +6,39 @@ import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs'
 import { dirname, join, relative } from 'node:path'
 import { start } from './start.mjs'
 
-const refused = message => Object.assign(new Error(message), { code: 'E_ADD' })
-const usage = message => Object.assign(new Error(message), { code: 'E_USAGE' })
+const refused = (message) => Object.assign(new Error(message), { code: 'E_ADD' })
+const usage = (message) => Object.assign(new Error(message), { code: 'E_USAGE' })
 const TOOLCHAIN = '1.99.1'
 
-const camel = name => name.replace(/[-_](.)/g, (_, c) => c.toUpperCase())
-const pascal = name => { const c = camel(name); return c[0].toUpperCase() + c.slice(1) }
-const lib = name => name.replaceAll('-', '_')
+const camel = (name) => name.replace(/[-_](.)/g, (_, c) => c.toUpperCase())
+const pascal = (name) => {
+  const c = camel(name)
+  return c[0].toUpperCase() + c.slice(1)
+}
+const lib = (name) => name.replaceAll('-', '_')
 
 const manifest = (name, crate, remote) => `[package]
 name = "${name}"
 version = "0.0.0"
 edition = "2024"
 publish = false
-${remote ? '' : `
+${
+  remote
+    ? ''
+    : `
 [lib]
 crate-type = ["cdylib"]
-`}
+`
+}
 [dependencies]
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
-${remote ? `tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
-weft = { path = "${crate}" }` : `weft = { path = "${crate}", default-features = false, features = ["native"] }`}
+${
+  remote
+    ? `tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
+weft = { path = "${crate}" }`
+    : `weft = { path = "${crate}", default-features = false, features = ["native"] }`
+}
 
 [build-dependencies]
 weft = { path = "${crate}", default-features = false, features = ["build"] }
@@ -43,7 +54,10 @@ codegen-units = 1
 [workspace]
 `
 
-const body = (name, remote) => `weft::contract!(); // types and a \`Service\` trait, generated from your Zod: never hand-written
+const body = (
+  name,
+  remote,
+) => `weft::contract!(); // types and a \`Service\` trait, generated from your Zod: never hand-written
 use contract::*;
 
 struct ${pascal(name)};
@@ -54,14 +68,18 @@ impl Service for ${pascal(name)} {
         Ok(DigestOutput { bytes: input.text.len() as i64, hash: format!("{hash:08x}") })
     }
 }
-${remote ? `
+${
+  remote
+    ? `
 #[tokio::main]
 async fn main() -> std::io::Result<()> {
     weft::serve(weft::router(contract::functions(${pascal(name)}))).await
 }
-` : `
+`
+    : `
 weft::native!(contract::functions(${pascal(name)}));
-`}`
+`
+}`
 
 const fn = (name, binding) => `import { query } from '@weft-js/start/data'
 import { z } from 'zod'
@@ -78,33 +96,63 @@ export const digest = query({
 /** The path Cargo gets. `crate/` is in a packed @weft-js/start; a linked one is in this repository, next to the crates. */
 async function weftCrate(root, dir) {
   const { startDir } = await start(root, 'vite')
-  const found = [join(startDir, '..', 'crate'), join(startDir, '..', '..', '..', 'crates', 'weft')].find(d => existsSync(join(d, 'Cargo.toml')))
+  const found = [
+    join(startDir, '..', 'crate'),
+    join(startDir, '..', '..', '..', 'crates', 'weft'),
+  ].find((d) => existsSync(join(d, 'Cargo.toml')))
   if (!found) throw refused('this @weft-js/start has no `weft` crate in it. Nothing was changed.')
   return relative(dir, found).replaceAll('\\', '/')
 }
 
-export async function addRust(root, name = 'media', { remote = false, dryRun = false, install, installSpecs }) {
-  if (!/^[a-z][a-z0-9_-]*$/.test(name)) throw usage(`\`${name}\` isn't a service name: lower case, then letters, digits, \`-\` or \`_\``)
-  if (!existsSync(join(root, 'package.json'))) throw refused('`weft add rust` needs a package.json. Nothing was changed.')
+export async function addRust(
+  root,
+  name = 'media',
+  { remote = false, dryRun = false, install, installSpecs },
+) {
+  if (!/^[a-z][a-z0-9_-]*$/.test(name))
+    throw usage(
+      `\`${name}\` isn't a service name: lower case, then letters, digits, \`-\` or \`_\``,
+    )
+  if (!existsSync(join(root, 'package.json')))
+    throw refused('`weft add rust` needs a package.json. Nothing was changed.')
   const dir = join(root, 'crates', name)
   const module = join(root, 'src', 'server', `${name}.ts`)
-  const taken = [dir, module].filter(existsSync).map(f => relative(root, f))
-  if (taken.length) throw refused(`${taken.join(', ')} already exist${taken.length > 1 ? '' : 's'}. Pick another name: \`weft add rust <name>\`. Nothing was changed.`)
+  const taken = [dir, module].filter(existsSync).map((f) => relative(root, f))
+  if (taken.length)
+    throw refused(
+      `${taken.join(', ')} already exist${taken.length > 1 ? '' : 's'}. Pick another name: \`weft add rust <name>\`. Nothing was changed.`,
+    )
   const binding = camel(name)
   const factory = remote ? 'remote' : 'native'
   const call = remote ? `remote('rust://${name}')` : `native('${name}')`
   const rustFile = join(root, 'src', 'server', 'rust.ts')
-  const had = existsSync(rustFile) ? readFileSync(rustFile, 'utf8') : '// The only place Rust targets are named.\n'
-  if (new RegExp(`\\b${binding}\\b`).test(had)) throw refused(`src/server/rust.ts already names \`${binding}\`. Nothing was changed.`)
-  const imported = new RegExp(`import\\s*\\{[^}]*\\b${factory}\\b[^}]*\\}\\s*from\\s*['"]@weft-js/start/rust['"]`).test(had)
+  const had = existsSync(rustFile)
+    ? readFileSync(rustFile, 'utf8')
+    : '// The only place Rust targets are named.\n'
+  if (new RegExp(`\\b${binding}\\b`).test(had))
+    throw refused(`src/server/rust.ts already names \`${binding}\`. Nothing was changed.`)
+  const imported = new RegExp(
+    `import\\s*\\{[^}]*\\b${factory}\\b[^}]*\\}\\s*from\\s*['"]@weft-js/start/rust['"]`,
+  ).test(had)
   const nextRust = `${imported ? had : had.replace(/^((?:\/\/.*\n)*)/, `$1import { ${factory} } from '@weft-js/start/rust'\n`)}${had.endsWith('\n') ? '' : '\n'}\nexport const ${binding} = ${call}\n`
 
   const pkg = JSON.parse(readFileSync(join(root, 'package.json'), 'utf8'))
   const needsZod = !pkg.dependencies?.zod && !pkg.devDependencies?.zod
   const gitignore = join(root, '.gitignore')
-  const ignored = existsSync(gitignore) && /^\/?target\/?$|^\*\*\/target\/?$/m.test(readFileSync(gitignore, 'utf8'))
-  const actions = [`create crates/${name}`, `create src/server/${name}.ts`, `add \`${binding}\` to src/server/rust.ts`, ...(needsZod && install ? ['install zod'] : []), ...(ignored ? [] : ['ignore target/']), 'this crate needs Rust (`cargo`, from rustup.rs); the rest of weft does not', 'next: `weft check`, then `weft dev`']
-  if (dryRun) return { ok: true, feature: 'rust', service: name, kind: factory, actions, dryRun: true }
+  const ignored =
+    existsSync(gitignore) &&
+    /^\/?target\/?$|^\*\*\/target\/?$/m.test(readFileSync(gitignore, 'utf8'))
+  const actions = [
+    `create crates/${name}`,
+    `create src/server/${name}.ts`,
+    `add \`${binding}\` to src/server/rust.ts`,
+    ...(needsZod && install ? ['install zod'] : []),
+    ...(ignored ? [] : ['ignore target/']),
+    'this crate needs Rust (`cargo`, from rustup.rs); the rest of weft does not',
+    'next: `weft check`, then `weft dev`',
+  ]
+  if (dryRun)
+    return { ok: true, feature: 'rust', service: name, kind: factory, actions, dryRun: true }
 
   const crate = await weftCrate(root, dir)
   const write = (file, text) => {
@@ -113,11 +161,18 @@ export async function addRust(root, name = 'media', { remote = false, dryRun = f
   }
   write(join(dir, 'Cargo.toml'), manifest(name, crate, remote))
   write(join(dir, 'build.rs'), `fn main() {\n    weft::build::generate("${name}");\n}\n`)
-  write(join(dir, 'rust-toolchain.toml'), `[toolchain]\nchannel = "${TOOLCHAIN}"\n${remote ? '' : 'targets = ["wasm32-unknown-unknown"]\n'}`)
+  write(
+    join(dir, 'rust-toolchain.toml'),
+    `[toolchain]\nchannel = "${TOOLCHAIN}"\n${remote ? '' : 'targets = ["wasm32-unknown-unknown"]\n'}`,
+  )
   write(join(dir, 'src', remote ? 'main.rs' : 'lib.rs'), body(lib(name), remote))
   write(module, fn(name, binding))
   write(rustFile, nextRust)
-  if (!ignored) writeFileSync(gitignore, `${existsSync(gitignore) ? readFileSync(gitignore, 'utf8').replace(/\n?$/, '\n') : ''}target/\n`)
+  if (!ignored)
+    writeFileSync(
+      gitignore,
+      `${existsSync(gitignore) ? readFileSync(gitignore, 'utf8').replace(/\n?$/, '\n') : ''}target/\n`,
+    )
   if (needsZod && install) installSpecs(['zod'])
   return { ok: true, feature: 'rust', service: name, kind: factory, actions }
 }