diff --git a/.changeset/pocketbase-addon.md b/.changeset/pocketbase-addon.md new file mode 100644 index 000000000..a1628eb77 --- /dev/null +++ b/.changeset/pocketbase-addon.md @@ -0,0 +1,5 @@ +--- +'@tanstack/create': minor +--- + +Add a React PocketBase add-on. `--add-ons pocketbase` wires the PocketBase JS SDK into a TanStack Start app, with a migration for an owner-scoped `todos` collection and a `/demo/pocketbase` route with email and password sign-in and a private realtime todo list. With the ESLint toolchain, the generated config ignores PocketBase's `pb_data/` and `pb_migrations/`. diff --git a/packages/cli/tests-e2e/pocketbase-smoke.spec.ts b/packages/cli/tests-e2e/pocketbase-smoke.spec.ts new file mode 100644 index 000000000..5b673f748 --- /dev/null +++ b/packages/cli/tests-e2e/pocketbase-smoke.spec.ts @@ -0,0 +1,143 @@ +import { createServer } from 'node:http' +import { writeFile } from 'node:fs/promises' +import { join } from 'node:path' +import { expect, test } from '@playwright/test' +import { attachRuntimeGuards, createReactAppFixture } from './helpers' + +function createPocketBaseFixture() { + const requests: Array = [] + const server = createServer((request, response) => { + requests.push(request.url ?? '') + response.writeHead(request.method === 'OPTIONS' ? 204 : 200, { + 'access-control-allow-origin': '*', + 'access-control-allow-headers': '*', + 'content-type': 'application/json', + }) + response.end( + request.method === 'OPTIONS' + ? undefined + : JSON.stringify({ code: 200, message: 'API is healthy.', data: {} }), + ) + }) + + return { + requests, + start: (port: number) => + new Promise((resolve, reject) => { + server.once('error', reject) + server.listen(port, '127.0.0.1', () => { + const address = server.address() + if (!address || typeof address === 'string') { + reject(new Error('Missing PocketBase fixture port')) + return + } + resolve(address.port) + }) + }), + stop: () => + new Promise((resolve, reject) => { + if (!server.listening) { + resolve() + return + } + server.close((error) => (error ? reject(error) : resolve())) + }), + } +} + +test('@matrix builds and renders the PocketBase add-on with a local server fixture', async ({ + page, +}) => { + const server = createPocketBaseFixture() + const port = await server.start(0) + try { + const fixture = await createReactAppFixture({ + appName: 'react-pocketbase-smoke', + addOns: ['pocketbase'], + runQualityGatesChecks: true, + afterCreate: async (appDir) => { + await writeFile( + join(appDir, '.env.local'), + `VITE_POCKETBASE_URL=http://127.0.0.1:${port}\n`, + ) + }, + }) + const guards = attachRuntimeGuards(page, fixture.url) + try { + await page.goto(`${fixture.url}/demo/pocketbase`) + await expect( + page.getByRole('heading', { name: 'Sign in to see your todos' }), + ).toBeVisible() + await expect(page.getByLabel('Password')).toBeVisible() + expect(server.requests.some((url) => url.startsWith('/api/health'))).toBe( + true, + ) + } finally { + try { + guards.assertClean() + } finally { + guards.dispose() + await fixture.stop() + await fixture.cleanup() + } + } + } finally { + await server.stop() + } +}) + +test('@matrix recovers the PocketBase demo after the server starts', async ({ + page, +}) => { + const server = createPocketBaseFixture() + // Reserve a free port, then stop so the app starts with no server running. + const port = await server.start(0) + await server.stop() + try { + const fixture = await createReactAppFixture({ + appName: 'react-pocketbase-recovery', + addOns: ['pocketbase'], + afterCreate: async (appDir) => { + await writeFile( + join(appDir, '.env.local'), + `VITE_POCKETBASE_URL=http://127.0.0.1:${port}\n`, + ) + }, + }) + try { + await page.goto(`${fixture.url}/demo/pocketbase`) + await expect( + page.getByRole('heading', { name: 'PocketBase is not ready' }), + ).toBeVisible() + + const retry = page.getByRole('button', { name: 'Try again' }) + await retry.click() + await expect(retry).toBeEnabled() + await expect( + page.getByRole('heading', { name: 'PocketBase is not ready' }), + ).toBeVisible() + + await server.start(port) + // The stopped server's connection errors are expected, so only guard + // what happens from recovery onward. + const guards = attachRuntimeGuards(page, fixture.url) + try { + await retry.click() + await expect( + page.getByRole('heading', { name: 'Sign in to see your todos' }), + ).toBeVisible() + await expect( + page.getByRole('heading', { name: 'PocketBase is not ready' }), + ).toBeHidden() + guards.assertClean() + } finally { + guards.dispose() + } + } finally { + await fixture.stop() + await fixture.cleanup() + } + } finally { + await server.stop() + } +}) diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/README.md b/packages/create/src/frameworks/react/add-ons/pocketbase/README.md new file mode 100644 index 000000000..298ed2d9e --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/README.md @@ -0,0 +1,40 @@ +## Setting up PocketBase + +This project uses [PocketBase](https://pocketbase.io), an open source backend in a single file: an embedded SQLite database, auth, realtime subscriptions, file storage and an admin dashboard. + +1. [Download PocketBase](https://pocketbase.io/docs/) for your platform and place the `pocketbase` binary in the root of this project. +2. Start the server: + + ```bash + ./pocketbase serve + ``` + + On Windows, run `pocketbase.exe serve`. On first start, PocketBase applies the migration in `pb_migrations/`, which creates the `todos` collection used by the demo. + +3. To use the admin dashboard at http://127.0.0.1:8090/_/, create your superuser account with the installer link PocketBase prints on first start, or run `./pocketbase superuser upsert EMAIL PASSWORD`. The demo itself doesn't need one. +4. Make sure `VITE_POCKETBASE_URL` in `.env.local` points to your PocketBase server (defaults to `http://127.0.0.1:8090`). +5. Run the app, visit `/demo/pocketbase` and create an account. + +### What the add-on includes + +- `src/lib/pocketbase.ts`: PocketBase JS SDK client (`pb`) and a `createPocketBase()` factory for per-request clients in server functions. +- `src/routes/demo/pocketbase.tsx`: email and password sign-in, plus a private todo list with realtime updates. +- `pb_migrations/`: JS migrations applied automatically by `pocketbase serve`. +- `.gitignore` entries for the `pocketbase` binary and `pb_data/`, which holds your local database and uploaded files. + +### Permissions + +Each todo has an `owner` relation to the built-in `users` collection, and the collection's API rules enforce ownership on the server: + +| Action | Rule | +| ------------------ | ----------------------------------------------------------------------------------------------------- | +| List, view, delete | `@request.auth.id != "" && owner = @request.auth.id` | +| Create | `@request.auth.id != "" && @request.body.owner = @request.auth.id` | +| Update | The list rule, plus `(@request.body.owner:isset = false \|\| @request.body.owner = @request.auth.id)` | + +Realtime subscriptions follow the list rule, so users only receive events for their own todos. Deleting a user also deletes their todos. + +> [!IMPORTANT] +> PocketBase's default `users` collection allows public sign-ups. Review its API rules and enable email verification before deploying. + +Learn more in the [PocketBase docs](https://pocketbase.io/docs/) and the [JS SDK docs](https://ganigeorgiev.com/pocketbase/js-sdk). diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/assets/_dot_env.local.append b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/_dot_env.local.append new file mode 100644 index 000000000..69f90582f --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/_dot_env.local.append @@ -0,0 +1,2 @@ +# PocketBase server URL (run `./pocketbase serve` locally, default http://127.0.0.1:8090) +VITE_POCKETBASE_URL=http://127.0.0.1:8090 diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/assets/_dot_gitignore.append b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/_dot_gitignore.append new file mode 100644 index 000000000..a865a572e --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/_dot_gitignore.append @@ -0,0 +1,4 @@ +# PocketBase server binary and local data +/pocketbase +/pocketbase.exe +pb_data/ diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/assets/pb_migrations/1761955200_created_todos.js b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/pb_migrations/1761955200_created_todos.js new file mode 100644 index 000000000..b1f606282 --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/pb_migrations/1761955200_created_todos.js @@ -0,0 +1,47 @@ +/// + +// Creates the `todos` collection used by the /demo/pocketbase route. +// Applied automatically when running `./pocketbase serve`. +// +// Every todo belongs to the user in `owner`. The API rules below let users +// read and change only their own todos (realtime events follow `listRule`), +// and stop them from creating todos for someone else or handing theirs over. +const ownerOnly = '@request.auth.id != "" && owner = @request.auth.id' + +migrate( + (app) => { + const users = app.findCollectionByNameOrId('users') + + const collection = new Collection({ + type: 'base', + name: 'todos', + listRule: ownerOnly, + viewRule: ownerOnly, + createRule: + '@request.auth.id != "" && @request.body.owner = @request.auth.id', + updateRule: `${ownerOnly} && (@request.body.owner:isset = false || @request.body.owner = @request.auth.id)`, + deleteRule: ownerOnly, + fields: [ + { name: 'text', type: 'text', required: true, max: 500 }, + { name: 'completed', type: 'bool' }, + { + name: 'owner', + type: 'relation', + required: true, + maxSelect: 1, + collectionId: users.id, + cascadeDelete: true, + }, + { name: 'created', type: 'autodate', onCreate: true, onUpdate: false }, + { name: 'updated', type: 'autodate', onCreate: true, onUpdate: true }, + ], + indexes: ['CREATE INDEX idx_todos_owner ON todos (owner)'], + }) + + app.save(collection) + }, + (app) => { + const collection = app.findCollectionByNameOrId('todos') + app.delete(collection) + }, +) diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/assets/src/lib/pocketbase.ts b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/src/lib/pocketbase.ts new file mode 100644 index 000000000..0575fe563 --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/src/lib/pocketbase.ts @@ -0,0 +1,36 @@ +import PocketBase from 'pocketbase' + +export const POCKETBASE_URL = + import.meta.env.VITE_POCKETBASE_URL || 'http://127.0.0.1:8090' + +/** + * Browser-side PocketBase client. + * + * The auth store of this instance is persisted in localStorage, so use it + * from client components only. For server functions, create a fresh client + * per request with `createPocketBase()` so auth state is never shared + * between users. + */ +export const pb = createPocketBase() + +export function createPocketBase() { + const client = new PocketBase(POCKETBASE_URL) + // Avoid cancelling duplicated requests (e.g. React StrictMode double effects). + client.autoCancellation(false) + // On a 401, sign out only if the rejected token is still the current one. + // The SDK's built-in auto-clear would also drop a newer session, e.g. one + // signed in from another tab while this request was in flight. + client.autoClearAuthStore(false) + client.afterSend = ( + response: Response, + data: unknown, + options?: { headers?: Record }, + ) => { + const token = options?.headers?.Authorization + if (response.status === 401 && token && token === client.authStore.token) { + client.authStore.clear() + } + return data + } + return client +} diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/assets/src/routes/demo/pocketbase.tsx b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/src/routes/demo/pocketbase.tsx new file mode 100644 index 000000000..817c39a8a --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/assets/src/routes/demo/pocketbase.tsx @@ -0,0 +1,525 @@ +import { useCallback, useEffect, useRef, useState } from 'react' +import type { FormEvent } from 'react' +import { createFileRoute } from '@tanstack/react-router' +import { Check, Circle, LogOut, Plus, Trash2 } from 'lucide-react' +import { ClientResponseError } from 'pocketbase' +import type { RecordModel } from 'pocketbase' + +import { POCKETBASE_URL, pb } from '../../lib/pocketbase' + +export const Route = createFileRoute('/demo/pocketbase')({ + ssr: false, + component: PocketBaseDemo, +}) + +interface Todo extends RecordModel { + text: string + completed: boolean + owner: string +} + +const todos = pb.collection('todos') +const users = pb.collection('users') + +function getSession() { + const { isValid, token, record } = pb.authStore + return isValid && record ? { token, user: record } : null +} + +function hasStatus(err: unknown, statuses: Array) { + return err instanceof ClientResponseError && statuses.includes(err.status) +} + +// PocketBase v0.42+ answers any request that carries an expired or +// invalidated token with 401 (e.g. after a password change elsewhere). The +// client in lib/pocketbase.ts then signs out if that token is still current. +function isSessionError(err: unknown) { + return hasStatus(err, [401]) +} + +function getErrorMessage(err: unknown) { + if (err instanceof ClientResponseError) { + if (err.status === 0) return `Could not connect to ${POCKETBASE_URL}.` + // Validation errors carry the useful message per field. + const fieldError = Object.values<{ message?: string }>( + err.response.data ?? {}, + ).at(0) + return fieldError?.message ?? err.message + } + return err instanceof Error ? err.message : String(err) +} + +function upsert(list: Array, todo: Todo) { + const exists = list.some((item) => item.id === todo.id) + return exists + ? list.map((item) => (item.id === todo.id ? todo : item)) + : [...list, todo] +} + +function PocketBaseDemo() { + const [session, setSession] = useState(getSession) + const [serverError, setServerError] = useState(null) + // Wait for the health check and session refresh before rendering anything + // that talks to PocketBase, so a stale saved session never starts requests. + const [ready, setReady] = useState(false) + + useEffect(() => pb.authStore.onChange(() => setSession(getSession())), []) + + const checkServer = useCallback(async () => { + try { + await pb.health.check() + } catch (err) { + // A 401 means the server is up but rejected the saved token. + if (!isSessionError(err)) { + setServerError(getErrorMessage(err)) + return + } + } + if (pb.authStore.isValid) { + const token = pb.authStore.token + try { + await users.authRefresh() + } catch (err) { + if (!hasStatus(err, [401, 403, 404])) { + setServerError(getErrorMessage(err)) + return + } + // The saved session is stale, e.g. after resetting pb_data. + if (pb.authStore.token === token) pb.authStore.clear() + } + } + setServerError(null) + setReady(true) + }, []) + + useEffect(() => { + void checkServer() + }, [checkServer]) + + return ( +
+
+
+
+

PocketBase todos

+

+ Private, realtime todos from {POCKETBASE_URL} +

+
+
+ + {serverError ? ( + + ) : !ready ? ( +
+
+

Connecting to PocketBase...

+
+ ) : session ? ( + // Remount per session: one user's todos never render for the next, + // and a new token (e.g. from another tab) reloads the list. + + ) : ( + + )} +
+
+ ) +} + +function SetupSteps({ + error, + onRetry, +}: { + error: string + onRetry: () => Promise +}) { + const [retrying, setRetrying] = useState(false) + + const handleRetry = () => { + setRetrying(true) + void onRetry().finally(() => setRetrying(false)) + } + + return ( +
+

PocketBase is not ready

+

{error}

+
    +
  1. + Download PocketBase from{' '} + + pocketbase.io/docs + {' '} + and place the binary in the project root. +
  2. +
  3. + Run ./pocketbase serve (this applies the migration in{' '} + pb_migrations/ and creates the todos{' '} + collection). +
  4. +
  5. + Make sure VITE_POCKETBASE_URL in .env.local{' '} + points to your server. +
  6. +
+ +
+ ) +} + +function AuthForm() { + const [isSignUp, setIsSignUp] = useState(false) + const [email, setEmail] = useState('') + const [password, setPassword] = useState('') + const [error, setError] = useState(null) + const [loading, setLoading] = useState(false) + + const handleSubmit = async (e: FormEvent) => { + e.preventDefault() + setError(null) + setLoading(true) + try { + if (isSignUp) { + await users.create({ email, password, passwordConfirm: password }) + } + await users.authWithPassword(email, password) + } catch (err) { + setError(getErrorMessage(err)) + setLoading(false) + } + } + + return ( +
+

+ {isSignUp ? 'Create an account' : 'Sign in to see your todos'} +

+ +
void handleSubmit(e)} className="mt-4 grid gap-4"> +
+ + setEmail(e.target.value)} + autoComplete="email" + className="demo-input" + required + /> +
+ +
+ + setPassword(e.target.value)} + autoComplete={isSignUp ? 'new-password' : 'current-password'} + className="demo-input" + required + minLength={8} + /> +
+ + {error && ( +
+

{error}

+
+ )} + + +
+ +
+ +
+
+ ) +} + +function TodoList({ + userId, + email, + onLoadError, +}: { + userId: string + email: string + onLoadError: (message: string) => void +}) { + const [items, setItems] = useState | null>(null) + const [actionError, setActionError] = useState(null) + const [newTodo, setNewTodo] = useState('') + const [adding, setAdding] = useState(false) + const [pendingIds, setPendingIds] = useState>( + () => new Set(), + ) + const signalRef = useRef(null) + + useEffect(() => { + // Every request below uses this signal. Aborting it on unmount (sign out + // or a user switch) means a late 401 for this session can't clear the next. + const controller = new AbortController() + const { signal } = controller + signalRef.current = signal + + // The collection's listRule scopes both the list and the realtime events + // to the signed-in user. + const subscription = todos + .getFullList({ sort: 'created', signal }) + .then((records) => { + if (signal.aborted) return undefined + setItems(records) + return todos.subscribe('*', ({ action, record }) => { + setItems((current) => { + if (!current) return current + if (action === 'delete') { + return current.filter((item) => item.id !== record.id) + } + return upsert(current, record) + }) + }) + }) + .catch((err: unknown) => { + if (!signal.aborted && !isSessionError(err)) { + onLoadError(getErrorMessage(err)) + } + return undefined + }) + + return () => { + controller.abort() + // Unsubscribe once the subscription exists, even if it is still pending. + void subscription.then((unsubscribe) => unsubscribe?.()) + } + }, [onLoadError]) + + const run = (action: () => Promise) => { + setActionError(null) + action().catch((err: unknown) => { + if (!isSessionError(err)) setActionError(getErrorMessage(err)) + }) + } + + const handleAddTodo = (e: FormEvent) => { + e.preventDefault() + const text = newTodo.trim() + if (!text || adding) return + setAdding(true) + run(async () => { + try { + const record = await todos.create( + { text, completed: false, owner: userId }, + { signal: signalRef.current }, + ) + setItems((current) => (current ? upsert(current, record) : [record])) + setNewTodo('') + } finally { + setAdding(false) + } + }) + } + + // Lock a todo's buttons while its request runs, so a double click can't + // toggle it twice or delete it twice. + const runForTodo = (id: string, action: () => Promise) => { + if (pendingIds.has(id)) return + setPendingIds((current) => new Set(current).add(id)) + run(async () => { + try { + await action() + } finally { + setPendingIds((current) => { + const next = new Set(current) + next.delete(id) + return next + }) + } + }) + } + + const handleToggleTodo = (todo: Todo) => { + runForTodo(todo.id, async () => { + const record = await todos.update( + todo.id, + { completed: !todo.completed }, + { signal: signalRef.current }, + ) + setItems((current) => (current ? upsert(current, record) : current)) + }) + } + + const handleRemoveTodo = (id: string) => { + runForTodo(id, async () => { + await todos.delete(id, { signal: signalRef.current }) + setItems((current) => + current ? current.filter((item) => item.id !== id) : current, + ) + }) + } + + const completedCount = items?.filter((todo) => todo.completed).length || 0 + const totalCount = items?.length || 0 + + return ( + <> +
+
+

Signed in as

+

{email}

+ {totalCount > 0 && ( +

+ {completedCount} completed, {totalCount - completedCount}{' '} + remaining +

+ )} +
+ +
+ +
+
+ { + setNewTodo(e.target.value) + setActionError(null) + }} + placeholder="What needs to be done?" + aria-label="New todo" + maxLength={500} + className="demo-input min-w-0 flex-1" + /> + +
+ {actionError && ( +
+

{actionError}

+
+ )} +
+ +
+ {!items ? ( +
+
+

Loading todos...

+
+ ) : items.length === 0 ? ( +
+ +

No todos yet

+

+ Add your first todo above, then open this page in another tab to + see realtime sync. +

+
+ ) : ( +
+ {items.map((todo) => ( +
+ + + + {todo.text} + + + +
+ ))} +
+ )} +
+ + ) +} diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/info.json b/packages/create/src/frameworks/react/add-ons/pocketbase/info.json new file mode 100644 index 000000000..0272e219f --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/info.json @@ -0,0 +1,30 @@ +{ + "name": "PocketBase", + "description": "Open source backend in one file (SQLite, auth, realtime, file storage, admin UI).", + "link": "https://pocketbase.io", + "phase": "add-on", + "type": "add-on", + "category": "database", + "exclusive": ["database", "orm"], + "color": "#16161A", + "priority": 135, + "modes": ["file-router"], + "routes": [ + { + "icon": "Database", + "url": "/demo/pocketbase", + "name": "PocketBase", + "path": "src/routes/demo/pocketbase.tsx", + "jsName": "PocketBaseDemo" + } + ], + "envVars": [ + { + "name": "VITE_POCKETBASE_URL", + "description": "PocketBase server URL", + "required": true, + "secret": false, + "file": ".env.local" + } + ] +} diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/package.json b/packages/create/src/frameworks/react/add-ons/pocketbase/package.json new file mode 100644 index 000000000..50d1e21fd --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/package.json @@ -0,0 +1,6 @@ +{ + "dependencies": { + "lucide-react": "^0.577.0", + "pocketbase": "^0.29.0" + } +} diff --git a/packages/create/src/frameworks/react/add-ons/pocketbase/small-logo.svg b/packages/create/src/frameworks/react/add-ons/pocketbase/small-logo.svg new file mode 100644 index 000000000..c04053884 --- /dev/null +++ b/packages/create/src/frameworks/react/add-ons/pocketbase/small-logo.svg @@ -0,0 +1 @@ + diff --git a/packages/create/src/frameworks/react/toolchains/eslint/assets/eslint.config.js b/packages/create/src/frameworks/react/toolchains/eslint/assets/eslint.config.js.ejs similarity index 70% rename from packages/create/src/frameworks/react/toolchains/eslint/assets/eslint.config.js rename to packages/create/src/frameworks/react/toolchains/eslint/assets/eslint.config.js.ejs index 3f272c039..109641f82 100644 --- a/packages/create/src/frameworks/react/toolchains/eslint/assets/eslint.config.js +++ b/packages/create/src/frameworks/react/toolchains/eslint/assets/eslint.config.js.ejs @@ -16,5 +16,9 @@ export default [ }, { ignores: ['eslint.config.js', 'prettier.config.js'], - }, + },<% if (addOnEnabled.pocketbase) { %> + { + // PocketBase runs these files itself and writes their types to pb_data/. + ignores: ['pb_data/**', 'pb_migrations/**'], + },<% } %> ] diff --git a/packages/create/tests/eslint-toolchain.test.ts b/packages/create/tests/eslint-toolchain.test.ts new file mode 100644 index 000000000..8d8efeff6 --- /dev/null +++ b/packages/create/tests/eslint-toolchain.test.ts @@ -0,0 +1,35 @@ +import { readFileSync } from 'node:fs' +import { fileURLToPath } from 'node:url' + +import ejs from 'ejs' +import { describe, expect, it } from 'vitest' + +const template = readFileSync( + fileURLToPath( + new URL( + '../src/frameworks/react/toolchains/eslint/assets/eslint.config.js.ejs', + import.meta.url, + ), + ), + 'utf8', +) +const render = (addOnEnabled: Record) => + ejs.render(template, { addOnEnabled }) + +// PocketBase runs pb_migrations/*.js itself and writes their globals to +// pb_data/types.d.ts. Neither belongs to the app's type-aware lint. +describe('React ESLint toolchain config', () => { + it('ignores the PocketBase server files when the add-on is enabled', () => { + expect(render({ eslint: true, pocketbase: true })).toContain( + "ignores: ['pb_data/**', 'pb_migrations/**']", + ) + }) + + it('leaves other apps unchanged', () => { + const config = render({ eslint: true }) + expect(config).not.toContain('pb_') + expect(config).toContain( + "ignores: ['eslint.config.js', 'prettier.config.js'],\n },\n]", + ) + }) +})