@weft-js/create 0.1.0 → 0.1.2

package/README.md

@@ -1,28 +1,78 @@
 # @weft-js/create
 
-> **Early release (0.1.0).** APIs will change between minor versions.
+> **Early release (0.1.x).** APIs can change between minor versions.
 
-Starts a new weft app.
+Starts a new [Weft](https://github.com/Ravonus/weft) app: pages, a server, a database, sign-in and Warp's components,
+wired up and ready for `weft dev`.
 
 ```bash
 npm create @weft-js my-app
 ```
 
-In a terminal it asks what the flags don't answer. `--yes` takes the defaults.
+```bash
+pnpm create @weft-js my-app
+```
+
+```bash
+bun create @weft-js my-app
+```
+
+```bash
+deno run -A npm:@weft-js/create my-app
+```
+
+In a terminal it asks what the flags don't answer, with the default already picked. `--yes` takes every default: Warp,
+SQLite through Drizzle, and Better Auth. Then:
+
+```bash
+cd my-app
+npx weft dev
+```
+
+With a database, run `npx weft db generate` first. The new app has a home page, an about page, a todo list on server
+functions, a sign-in page, and an `AGENTS.md` written for the installed Weft. `weft check` passes on it as made; its one
+warning asks for `site.url` before you deploy.
+
+## Flags
 
 | Flag | Values | Default |
 |---|---|---|
-| `--ui` | `warp`, `headless` (warp-core only), `tailwind`, `none` | `warp` |
+| `[dir]` | A folder that's missing or empty | asked; `my-weft-app` with `--yes` |
+| `--template` | `todo`, `admin`, `catalog`, `landing`: a fuller starting app (below) | none |
+| `--ui` | `warp`, `headless` (Warp's behaviour and tokens, your markup), `tailwind`, `none` | `warp` |
 | `--db` | `sqlite`, `postgres`, `mysql`, `none` | `sqlite` |
-| `--layer` | `drizzle`, `prisma`, `native` | `drizzle` |
+| `--layer` | `drizzle`, `prisma`, `native` (SQL migrations, no ORM) | `drizzle` |
 | `--auth`, `--no-auth` | Sign-in, when there's a database | on |
-| `--auth-provider` | `better-auth`, `custom` | `better-auth` |
-| `--runtime` | `node`, `bun`, `deno` | the one running it |
-| `--config` | `ts`, `json`, `yaml`: the format of the weft config | `ts` |
+| `--auth-provider` | `better-auth`, `custom` (a stub for your own) | `better-auth` |
+| `--runtime` | `node`, `bun`, `deno`: what `weft build` targets | the one running it |
+| `--config` | `ts`, `json`, `yaml`: the format of the Weft config | `ts` |
 | `--pm` | `npm`, `pnpm`, `bun`, `deno`, `yarn` | the one you ran it with |
-| `--git`, `--no-git`, `--install`, `--no-install` | Start a git repository; install dependencies | on, or off with no terminal and no `--yes` |
+| `--git`, `--no-git` | Start a git repository | on |
+| `--install`, `--no-install` | Install the dependencies | on, or off with no terminal and no `--yes` |
 | `--name` | The package name | the folder's name |
+| `--yes`, `-y` | Take the defaults for anything not given | |
 
 With npm, flags go after `--`: `npm create @weft-js my-app -- --ui tailwind --db none`.
 
-Until weft is on npm, make an app from a checkout instead: [Installation](../../site/content/learn/installation.md).
+## Templates
+
+A template is a fuller app on Postgres. It sets `--db postgres` and the sign-in it needs, and keeps the other flags.
+
+| Template | Pages |
+|---|---|
+| `todo` | Sign-in and sign-up, and a todo list |
+| `admin` | An admin area with an orders table, order pages and nested layouts, behind sign-in |
+| `catalog` | A shop: categories, product pages and a cart |
+| `landing` | A landing page with pricing, a privacy page and a sign-up list |
+
+## Docs
+
+[Installation](https://github.com/Ravonus/weft/blob/main/site/content/learn/installation.md) walks through every file in
+a new app, and how to run, check, build and deploy it.
+
+## Links
+
+- [Source](https://github.com/Ravonus/weft/tree/main/packages/create)
+- [Weft on GitHub](https://github.com/Ravonus/weft): the framework, the docs and every package
+- [Changelog](https://github.com/Ravonus/weft/blob/main/CHANGELOG.md)
+- [Issues](https://github.com/Ravonus/weft/issues)

package/bin/create-weft.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// create-weft [dir] [--ui warp|headless|tailwind|none] [--db sqlite|postgres|mysql|none] [--layer drizzle|prisma|native] [--[no-]auth] [--auth-provider better-auth|custom] [--runtime node|bun|deno]
+// create-weft [dir] [--template landing|todo|admin|catalog] [--ui warp|headless|tailwind|none] [--db sqlite|postgres|mysql|none] [--layer drizzle|prisma|native] [--[no-]auth] [--auth-provider better-auth|custom] [--runtime node|bun|deno]
 //   [--config ts|json|yaml] [--pm npm|pnpm|bun|deno|yarn] [--[no-]git] [--[no-]install] [--name <name>] [--tarballs <dir>] [--yes]
 // In a terminal it asks what the flags don't answer; --yes, or no terminal, takes the defaults.
 import { execFileSync } from 'node:child_process'
@@ -7,16 +7,42 @@ import { readFileSync, writeFileSync } from 'node:fs'
 import { join, resolve } from 'node:path'
 import { createInterface } from 'node:readline/promises'
 import { parseArgs } from 'node:util'
-import { CONFIGS, DB, LAYERS, RUNTIMES, scaffold, UI } from '../src/index.mjs'
+import {
+  CONFIGS,
+  DB,
+  LAYERS,
+  RUNTIMES,
+  scaffold,
+  TEMPLATES,
+  UI,
+  withTemplate,
+} from '../src/index.mjs'
 import { resolveChoices } from '../src/wizard.mjs'
-import { pin } from '../scripts/tarballs.mjs'
+import { pin, pinWorkspace } from '../scripts/tarballs.mjs'
 
-const usage = `Usage: npm create @weft-js -- [dir] [--ui ${UI.join('|')}] [--db ${DB.join('|')}] [--layer ${LAYERS.join('|')}] [--[no-]auth] [--auth-provider better-auth|custom] [--runtime ${RUNTIMES.join('|')}] [--config ${CONFIGS.join('|')}] [--pm <manager>] [--[no-]git] [--[no-]install] [--name <name>] [--tarballs <dir>] [--yes]`
-const string = { type: 'string' }, boolean = { type: 'boolean' }
+const usage = `Usage: npm create @weft-js -- [dir] [--template ${TEMPLATES.join('|')}] [--ui ${UI.join('|')}] [--db ${DB.join('|')}] [--layer ${LAYERS.join('|')}] [--[no-]auth] [--auth-provider better-auth|custom] [--runtime ${RUNTIMES.join('|')}] [--config ${CONFIGS.join('|')}] [--pm <manager>] [--[no-]git] [--[no-]install] [--name <name>] [--tarballs <dir>] [--yes]`
+const string = { type: 'string' },
+  boolean = { type: 'boolean' }
 const { values, positionals } = parseArgs({
   allowPositionals: true,
   allowNegative: true,
-  options: { ui: string, db: string, layer: string, auth: boolean, 'auth-provider': string, runtime: string, config: string, pm: string, git: boolean, install: boolean, name: string, tarballs: string, yes: { ...boolean, short: 'y' }, help: { ...boolean, short: 'h' } },
+  options: {
+    template: string,
+    ui: string,
+    db: string,
+    layer: string,
+    auth: boolean,
+    'auth-provider': string,
+    runtime: string,
+    config: string,
+    pm: string,
+    git: boolean,
+    install: boolean,
+    name: string,
+    tarballs: string,
+    yes: { ...boolean, short: 'y' },
+    help: { ...boolean, short: 'h' },
+  },
 })
 const interactive = process.stdin.isTTY && process.stdout.isTTY
 if (values.help || positionals.length > 1 || (!positionals.length && !interactive)) {
@@ -33,40 +59,62 @@ async function directory() {
   return answer.trim() || 'my-weft-app'
 }
 
-/** Git and the install are conveniences: the app is already written, so a failure here only leaves a step for later. */
+/** The app is already written, so a failure here leaves a step for later; a failed install still fails the command. */
 function step(what, command, args, cwd) {
   try {
-    execFileSync(command, args, { cwd, stdio: ['ignore', 'ignore', 'inherit'], shell: process.platform === 'win32' }) // npm is npm.cmd there
+    execFileSync(command, args, {
+      cwd,
+      stdio: ['ignore', 'ignore', 'inherit'],
+      shell: process.platform === 'win32',
+    }) // npm is npm.cmd there
     return true
   } catch {
-    console.error(`create-weft: ${what} didn't finish; run \`${[command, ...args].join(' ')}\` yourself.`)
+    console.error(
+      `create-weft: ${what} didn't finish; run \`${[command, ...args].join(' ')}\` yourself.`,
+    )
     return false
   }
 }
 
 try {
   const { yes, help: _help, name, tarballs, 'auth-provider': authProvider, ...flags } = values
-  if (authProvider && !['better-auth', 'custom'].includes(authProvider)) throw new Error('--auth-provider must be better-auth or custom')
+  if (authProvider && !['better-auth', 'custom'].includes(authProvider))
+    throw new Error('--auth-provider must be better-auth or custom')
   if (authProvider) flags.auth = authProvider === 'custom' ? 'custom' : true
   const where = await directory()
   const dir = resolve(where)
-  const choices = await resolveChoices(flags, { interactive, yes, io: { input: process.stdin, output: process.stdout } })
+  const choices = await resolveChoices(withTemplate(flags), {
+    interactive,
+    yes,
+    io: { input: process.stdin, output: process.stdout },
+  })
   const { files } = scaffold(dir, { ...choices, ...(name && { name }) })
   // Before the install: a checkout's packages aren't on npm, so `local.mjs new` needs them wired in from the start.
   if (tarballs) {
     const file = join(dir, 'package.json')
-    writeFileSync(file, JSON.stringify(pin(JSON.parse(readFileSync(file, 'utf8')), JSON.parse(readFileSync(join(tarballs, 'tarballs.json'), 'utf8'))), null, 2))
+    const map = JSON.parse(readFileSync(join(tarballs, 'tarballs.json'), 'utf8'))
+    writeFileSync(file, JSON.stringify(pin(JSON.parse(readFileSync(file, 'utf8')), map), null, 2))
+    pinWorkspace(dir, map)
   }
   console.log(`\nCreated ${files.length} files in ${dir}`)
   if (choices.git) step('git init', 'git', ['init', '--quiet'], dir)
   const installed = choices.install && step('The install', choices.pm, ['install'], dir)
-  const weft = { npm: 'npx weft', pnpm: 'pnpm exec weft', bun: 'bunx --bun weft', deno: 'deno run -A npm:@weft-js/cli', yarn: 'yarn weft' }[choices.pm]
+  const weft = {
+    npm: 'npx weft',
+    pnpm: 'pnpm exec weft',
+    bun: 'bunx --bun weft',
+    deno: 'deno run -A npm:@weft-js/cli',
+    yarn: 'yarn weft',
+  }[choices.pm]
   // AGENTS.md comes from the weft just installed, so it always matches the compiler the app runs.
   if (installed) {
     const [command, ...args] = weft.split(' ')
     step('AGENTS.md', command, [...args, 'agents-md'], dir)
   }
-  console.log(`\n  cd ${where}${installed ? '' : `\n  ${choices.pm} install\n  ${weft} agents-md`}${choices.db === 'none' ? '' : `\n  ${weft} db generate`}\n  ${weft} dev\n`)
+  console.log(
+    `\n  cd ${where}${installed ? '' : `\n  ${choices.pm} install\n  ${weft} agents-md`}${choices.db === 'none' || choices.template ? '' : `\n  ${weft} db generate`}\n  ${weft} dev\n`,
+  )
+  if (choices.install && !installed) process.exitCode = 1
 } catch (e) {
   console.error(`create-weft: ${e.message}`)
   process.exit(1)

package/package.json

@@ -1,30 +1,40 @@
 {
   "name": "@weft-js/create",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Scaffold a weft app: npm create @weft-js",
+  "keywords": [
+    "weft"
+  ],
   "license": "MIT",
-  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/Ravonus/weft.git",
+    "directory": "packages/create"
+  },
+  "homepage": "https://github.com/Ravonus/weft/tree/main/packages/create#readme",
+  "bugs": {
+    "url": "https://github.com/Ravonus/weft/issues"
+  },
   "bin": {
     "create-weft": "./bin/create-weft.mjs"
   },
+  "files": [
+    "bin",
+    "src",
+    "templates",
+    "scripts/tarballs.mjs",
+    "README.md",
+    "LICENSE"
+  ],
+  "type": "module",
   "exports": {
     ".": "./src/index.mjs",
     "./stack": "./src/stack.mjs"
   },
-  "engines": {
-    "node": ">=26"
-  },
   "publishConfig": {
     "access": "public"
   },
-  "keywords": [
-    "weft"
-  ],
-  "files": [
-    "bin",
-    "src",
-    "scripts/tarballs.mjs",
-    "README.md",
-    "LICENSE"
-  ]
-}
+  "engines": {
+    "node": ">=26"
+  }
+}

package/scripts/tarballs.mjs

@@ -1,11 +1,44 @@
 // Every package as a tarball, and an app's package.json pointed at them: what the packed gates and `local.mjs` share.
 import { execFileSync } from 'node:child_process'
-import { existsSync, mkdirSync, readFileSync, readdirSync } from 'node:fs'
-import { join } from 'node:path'
+import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from 'node:fs'
+import { join, resolve } from 'node:path'
 import { fileURLToPath } from 'node:url'
 
 export const pkgs = fileURLToPath(new URL('../../', import.meta.url))
 
+/**
+ * Write the install policy and tarball overrides for a fresh pnpm workspace. weft's own dependency patches stay
+ * behind: their files live in this repo, not in the app.
+ */
+export function writePackedPolicy(dir, tarballs = {}, packages = []) {
+  const policy = readFileSync(new URL('../../../pnpm-workspace.yaml', import.meta.url), 'utf8')
+    .replace(/^packages:\n(?:[ \t].*\n)*/m, '')
+    .replace(/^(?:#.*\n)*patchedDependencies:\n(?:[ \t].*\n)*/m, '')
+  const overrides = Object.entries(tarballs)
+    .map(([name, spec]) => `  ${JSON.stringify(name)}: ${JSON.stringify(spec)}\n`)
+    .join('')
+  const merged = /^overrides:\n/m.test(policy)
+    ? policy.replace(/^overrides:\n/m, `overrides:\n${overrides}`)
+    : `${policy}${overrides ? `\noverrides:\n${overrides}` : ''}`
+  writeFileSync(
+    join(dir, 'pnpm-workspace.yaml'),
+    `${packages.length ? `packages:\n${packages.map((name) => `  - ${JSON.stringify(name)}\n`).join('')}` : ''}${merged}\n`,
+  )
+}
+
+/** Pack one package to a known path, independent of lifecycle output. */
+export function pack(dir, dest) {
+  const { name, version } = JSON.parse(readFileSync(join(dir, 'package.json'), 'utf8'))
+  const file = join(resolve(dest), `${name.replace(/^@/, '').replaceAll('/', '-')}-${version}.tgz`)
+  execFileSync('pnpm', ['pack', '--out', file], {
+    cwd: dir,
+    stdio: ['ignore', 'pipe', 'inherit'],
+    shell: process.platform === 'win32',
+  })
+  if (!existsSync(file)) throw new Error(`pnpm pack did not create ${file}`)
+  return `file:${file}`
+}
+
 /** Pack each package into `dest`. Returns `{ name: 'file:…tgz' }`. */
 export function packAll(dest) {
   mkdirSync(dest, { recursive: true })
@@ -14,14 +47,31 @@ export function packAll(dest) {
     const file = join(pkgs, dir, 'package.json')
     if (!existsSync(file)) continue
     const { name } = JSON.parse(readFileSync(file, 'utf8'))
-    const packed = execFileSync('npm', ['pack', '--silent', '--pack-destination', dest], { cwd: join(pkgs, dir), encoding: 'utf8', stdio: ['ignore', 'pipe', 'inherit'] })
-    tarballs[name] = `file:${join(dest, packed.trim().split('\n').pop())}`
+    tarballs[name] = pack(join(pkgs, dir), dest)
   }
   return tarballs
 }
 
 /** `pkg` with its weft dependencies on the tarballs. The overrides reach the ones packages declare for each other. */
+/**
+ * The same overrides in the app's own pnpm-workspace.yaml, when create wrote one: that file makes the app its own
+ * workspace root, and pnpm reads overrides only from there (not from package.json, nor from a workspace above it).
+ */
+export function pinWorkspace(dir, tarballs) {
+  const file = join(dir, 'pnpm-workspace.yaml')
+  if (!existsSync(file) || !Object.keys(tarballs).length) return
+  const lines = Object.entries(tarballs)
+    .map(([name, spec]) => `  ${JSON.stringify(name)}: ${JSON.stringify(spec)}\n`)
+    .join('')
+  writeFileSync(file, `${readFileSync(file, 'utf8')}overrides:\n${lines}`)
+}
+
 export function pin(pkg, tarballs) {
-  for (const deps of [pkg.dependencies, pkg.devDependencies]) for (const name in deps) if (tarballs[name]) deps[name] = tarballs[name]
-  return { ...pkg, overrides: { ...pkg.overrides, ...tarballs } }
+  for (const deps of [pkg.dependencies, pkg.devDependencies])
+    for (const name in deps) if (tarballs[name]) deps[name] = tarballs[name]
+  return {
+    ...pkg,
+    overrides: { ...pkg.overrides, ...tarballs },
+    pnpm: { ...pkg.pnpm, overrides: { ...pkg.pnpm?.overrides, ...tarballs } },
+  }
 }

package/src/data.mjs

@@ -1,4 +1,4 @@
-// The Native and Prisma data layers of a scaffold (research 34 §4), beside Drizzle's in stack.mjs. Each writes the same
+// The Native and Prisma data layers of a scaffold, beside Drizzle's in stack.mjs. Each writes the same
 // todo app, so the same e2e holds for every layer. `weft add db` writes these files too.
 
 const engineSql = {
@@ -9,23 +9,71 @@ const engineSql = {
 
 // Better Auth's tables under its default names, which are camelCase, so they're quoted. MySQL can't key a TEXT column.
 export function nativeAuthSql(db) {
-  const q = name => (db === 'mysql' ? `\`${name}\`` : `"${name}"`)
+  const q = (name) => (db === 'mysql' ? `\`${name}\`` : `"${name}"`)
   const key = 'varchar(255)'
   const text = 'text'
   const when = { sqlite: 'date', postgres: 'timestamptz', mysql: 'datetime(3)' }[db]
   const bool = { sqlite: 'integer', postgres: 'boolean', mysql: 'boolean' }[db]
-  const table = (name, columns) => `create table ${q(name)} (\n${columns.map(([c, type]) => `  ${q(c)} ${type}`).join(',\n')}\n);\n`
-  const ref = to => `references ${q(to)} (${q('id')}) on delete cascade`
-  const stamps = [['createdAt', `${when} not null`], ['updatedAt', `${when} not null`]]
+  const table = (name, columns) =>
+    `create table ${q(name)} (\n${columns.map(([c, type]) => `  ${q(c)} ${type}`).join(',\n')}\n);\n`
+  const ref = (to) => `references ${q(to)} (${q('id')}) on delete cascade`
+  const stamps = [
+    ['createdAt', `${when} not null`],
+    ['updatedAt', `${when} not null`],
+  ]
   return [
-    table('user', [['id', `${key} primary key`], ['name', `${text} not null`], ['email', `${key} not null unique`], ['emailVerified', `${bool} not null`], ['image', text], ...stamps]),
-    table('session', [['id', `${key} primary key`], ['expiresAt', `${when} not null`], ['token', `${key} not null unique`], ...stamps, ['ipAddress', text], ['userAgent', text], ['userId', `${key} not null ${ref('user')}`]]),
-    table('account', [['id', `${key} primary key`], ['accountId', `${text} not null`], ['providerId', `${text} not null`], ['userId', `${key} not null ${ref('user')}`], ['accessToken', text], ['refreshToken', text], ['idToken', text], ['accessTokenExpiresAt', when], ['refreshTokenExpiresAt', when], ['scope', text], ['password', text], ...stamps]),
-    table('verification', [['id', `${key} primary key`], ['identifier', `${text} not null`], ['value', `${text} not null`], ['expiresAt', `${when} not null`], ['createdAt', when], ['updatedAt', when]]),
+    table('user', [
+      ['id', `${key} primary key`],
+      ['name', `${text} not null`],
+      ['email', `${key} not null unique`],
+      ['emailVerified', `${bool} not null`],
+      ['image', text],
+      ...stamps,
+    ]),
+    table('session', [
+      ['id', `${key} primary key`],
+      ['expiresAt', `${when} not null`],
+      ['token', `${key} not null unique`],
+      ...stamps,
+      ['ipAddress', text],
+      ['userAgent', text],
+      ['userId', `${key} not null ${ref('user')}`],
+    ]),
+    table('account', [
+      ['id', `${key} primary key`],
+      ['accountId', `${text} not null`],
+      ['providerId', `${text} not null`],
+      ['userId', `${key} not null ${ref('user')}`],
+      ['accessToken', text],
+      ['refreshToken', text],
+      ['idToken', text],
+      ['accessTokenExpiresAt', when],
+      ['refreshTokenExpiresAt', when],
+      ['scope', text],
+      ['password', text],
+      ...stamps,
+    ]),
+    table('verification', [
+      ['id', `${key} primary key`],
+      ['identifier', `${text} not null`],
+      ['value', `${text} not null`],
+      ['expiresAt', `${when} not null`],
+      ['createdAt', when],
+      ['updatedAt', when],
+    ]),
+    table('jwks', [
+      ['id', `${key} primary key`],
+      ['publicKey', `${text} not null`],
+      ['privateKey', `${text} not null`],
+      ['createdAt', `${when} not null`],
+      ['expiresAt', when],
+      ['alg', text],
+      ['crv', text],
+    ]),
   ].join('\n')
 }
 
-const nativeTodos = auth => {
+const nativeTodos = (auth) => {
   const use = auth ? `\n  auth: 'user',` : ''
   const mine = auth ? ` and user_id = \${ctx.user.id}` : ''
   return `import { mutation, query } from '@weft-js/start'
@@ -103,13 +151,21 @@ export default createAuth({ db, secret: env.BETTER_AUTH_SECRET, options: { datab
 
 const PROVIDER = { sqlite: 'sqlite', postgres: 'postgresql', mysql: 'mysql' }
 const ADAPTER = {
-  sqlite: { pkg: '@prisma/adapter-libsql', name: 'PrismaLibSql', make: "{ url: env.DATABASE_URL }" },
-  postgres: { pkg: '@prisma/adapter-pg', name: 'PrismaPg', make: "{ connectionString: env.DATABASE_URL }" },
+  sqlite: {
+    pkg: '@prisma/adapter-libsql',
+    name: 'PrismaLibSql',
+    make: '{ url: env.DATABASE_URL }',
+  },
+  postgres: {
+    pkg: '@prisma/adapter-pg',
+    name: 'PrismaPg',
+    make: '{ connectionString: env.DATABASE_URL }',
+  },
   mysql: { pkg: '@prisma/adapter-mariadb', name: 'PrismaMariaDb', make: 'env.DATABASE_URL' },
 }
-export const prismaAdapterPackage = db => ADAPTER[db].pkg
+export const prismaAdapterPackage = (db) => ADAPTER[db].pkg
 
-const authModels = db => {
+const authModels = (db) => {
   const long = db === 'mysql' ? ' @db.Text' : ''
   return `
 // Better Auth's tables: it reads and writes them through Prisma, with these names.
@@ -171,12 +227,24 @@ model Verification {
 
   @@map("verification")
 }
+
+model Jwks {
+  id         String    @id
+  publicKey  String${long}    @map("public_key")
+  privateKey String${long}    @map("private_key")
+  createdAt  DateTime  @map("created_at")
+  expiresAt  DateTime? @map("expires_at")
+  alg        String?
+  crv        String?
+
+  @@map("jwks")
+}
 `
 }
 
-export const prismaAuthModels = db => authModels(db).replace('  todos         Todo[]\n', '')
+export const prismaAuthModels = (db) => authModels(db).replace('  todos         Todo[]\n', '')
 
-const prismaTodos = auth => {
+const prismaTodos = (auth) => {
   const use = auth ? `\n  auth: 'user',` : ''
   const mine = auth ? `, userId: ctx.user.id` : ''
   return `import { mutation, query } from '@weft-js/start'
@@ -238,9 +306,13 @@ model Todo {
   id        String   @id
   title     String
   done      Boolean  @default(false)
-  createdAt DateTime @default(now()) @map("created_at")${auth ? `
+  createdAt DateTime @default(now()) @map("created_at")${
+    auth
+      ? `
   userId    String   @map("user_id")
-  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)` : ''}
+  user      User     @relation(fields: [userId], references: [id], onDelete: Cascade)`
+      : ''
+  }
 
   @@map("todos")
 }