@livestore/livestore 0.4.0-dev.21 → 0.4.0-dev.23

package/docs/building-with-livestore/examples/todo-workspaces/index.md

@@ -1,891 +0,0 @@
-# Todo app with shared workspaces
-
-Let's consider a fairly common application scenario: An app (in this case a todo app) with shared workspaces. For the sake of this guide, we'll keep things simple but you should be able to nicely extend this to a more complex app.
-
-## Requirements
-
-- There are multiple independent todo workspaces
-- Each workspace is initially created by a single user
-- Users can join the workspace by knowing the workspace id and get read and write access
-- For simplicity, the user identity is chosen when the app initially starts (i.e. a username) but in a real app this would be handled by a proper auth setup
-
-## Data model
-
-- We are splitting up our data model into two kinds of stores (with respective eventlogs and SQLite databases): The `workspace` store and the `user` store.
-
-### `workspace` store (one per workspace)
-
-For the `workspace` store we have the following events:
-
-- `workspaceCreated`
-- `todoAdded`
-- `todoCompleted`
-- `todoDeleted`
-- `userJoined`
-
-And the following state model:
-
-- `workspace` table (with a single row for the workspace itself)
-- `todo` table (with one row per todo item)
-- `member` table (with one row per user who has joined the workspace)
-
-### `user` store (one per user)
-
-For the `user` store we have the following events:
-
-- `workspaceCreated`
-- `workspaceJoined`
-
-And the following state model:
-
-- `user` table (with a single row for the user itself)
-
-Note that the `workspaceCreated` event is used both in the `workspace` and the `user` store. This is because each eventlog should be "self-sufficient" and not rely on other eventlogs to be present to fulfill its purpose.
-
-<EventlogModelingDiagram class="my-8" />
-
-## Schemas
-
-**User store:**
-
-## `data-modeling/todo-workspaces/multi-store/user.schema.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/user.schema.ts"
-
-// Emitted when this user creates a new workspace
-const workspaceCreated = Events.synced({
-  name: 'v1.WorkspaceCreated',
-  schema: Schema.Struct({ workspaceId: Schema.String }),
-})
-
-// Emitted when this user joins an existing workspace
-const workspaceJoined = Events.synced({
-  name: 'v1.WorkspaceJoined',
-  schema: Schema.Struct({ workspaceId: Schema.String }),
-})
-
-const events = { workspaceCreated, workspaceJoined }
-
-// Table to store basic user info
-// Contains only one row as this store is per-user.
-const userTable = State.SQLite.table({
-  name: 'user',
-  columns: {
-    // Assuming username is unique and used as the identifier
-    username: State.SQLite.text({ primaryKey: true }),
-  },
-})
-
-// Table to track which workspaces this user is part of
-const userWorkspaceTable = State.SQLite.table({
-  name: 'userWorkspace',
-  columns: {
-    workspaceId: State.SQLite.text({ primaryKey: true }),
-    // Could add role/permissions here later
-  },
-})
-
-export const userTables = { user: userTable, userWorkspace: userWorkspaceTable }
-
-const materializers = State.SQLite.materializers(events, {
-  // When the user creates or joins a workspace, add it to their workspace table
-  'v1.WorkspaceCreated': ({ workspaceId }) => userTables.userWorkspace.insert({ workspaceId }),
-  'v1.WorkspaceJoined': ({ workspaceId }) => userTables.userWorkspace.insert({ workspaceId }),
-})
-
-const state = State.SQLite.makeState({ tables: userTables, materializers })
-
-export const schema = makeSchema({ events, state })
-```
-
-**Workspace store:**
-
-## `data-modeling/todo-workspaces/multi-store/workspace.schema.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/workspace.schema.ts"
-
-// Emitted when a new workspace is created (originates this store)
-const workspaceCreated = Events.synced({
-  name: 'v1.WorkspaceCreated',
-  schema: Schema.Struct({
-    workspaceId: Schema.String,
-    name: Schema.String,
-    createdByUsername: Schema.String,
-  }),
-})
-
-// Emitted when a todo item is added to this workspace
-const todoAdded = Events.synced({
-  name: 'v1.TodoAdded',
-  schema: Schema.Struct({ todoId: Schema.String, text: Schema.String }),
-})
-
-// Emitted when a todo item is marked as completed
-const todoCompleted = Events.synced({
-  name: 'v1.TodoCompleted',
-  schema: Schema.Struct({ todoId: Schema.String }),
-})
-
-// Emitted when a todo item is deleted (soft delete)
-const todoDeleted = Events.synced({
-  name: 'v1.TodoDeleted',
-  schema: Schema.Struct({ todoId: Schema.String, deletedAt: Schema.Date }),
-})
-
-// Emitted when a new user joins this workspace
-const userJoined = Events.synced({
-  name: 'v1.UserJoined',
-  schema: Schema.Struct({ username: Schema.String }),
-})
-
-export const workspaceEvents = { workspaceCreated, todoAdded, todoCompleted, todoDeleted, userJoined }
-
-// Table for the workspace itself (only one row as this store is per-workspace)
-const workspaceTable = State.SQLite.table({
-  name: 'workspace',
-  columns: {
-    workspaceId: State.SQLite.text({ primaryKey: true }),
-    name: State.SQLite.text(),
-    createdByUsername: State.SQLite.text(),
-  },
-})
-
-// Table for the todo items in this workspace
-const todoTable = State.SQLite.table({
-  name: 'todo',
-  columns: {
-    todoId: State.SQLite.text({ primaryKey: true }),
-    text: State.SQLite.text(),
-    completed: State.SQLite.boolean({ default: false }),
-    // Using soft delete by adding a deletedAt timestamp
-    deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
-  },
-})
-
-// Table for members of this workspace
-const memberTable = State.SQLite.table({
-  name: 'member',
-  columns: {
-    username: State.SQLite.text({ primaryKey: true }),
-    // Could add role/permissions here later
-  },
-})
-
-export const workspaceTables = { workspace: workspaceTable, todo: todoTable, member: memberTable }
-
-const materializers = State.SQLite.materializers(workspaceEvents, {
-  'v1.WorkspaceCreated': ({ workspaceId, name, createdByUsername }) => [
-    workspaceTables.workspace.insert({ workspaceId, name, createdByUsername }),
-    // Add the creator as the first member
-    workspaceTables.member.insert({ username: createdByUsername }),
-  ],
-  'v1.TodoAdded': ({ todoId, text }) => workspaceTables.todo.insert({ todoId, text }),
-  'v1.TodoCompleted': ({ todoId }) => workspaceTables.todo.update({ completed: true }).where({ todoId }),
-  'v1.TodoDeleted': ({ todoId, deletedAt }) => workspaceTables.todo.update({ deletedAt }).where({ todoId }),
-  'v1.UserJoined': ({ username }) => workspaceTables.member.insert({ username }),
-})
-
-const state = State.SQLite.makeState({ tables: workspaceTables, materializers })
-
-export const schema = makeSchema({ events: workspaceEvents, state })
-```
-
-## Using the Multi-Store API
-
-Now that we've defined our schemas, let's set up the multi-store API to manage workspace and user stores dynamically.
-
-:::caution[Experimental API]
-This guide uses the [experimental multi-store API](/framework-integrations/react-integration#multi-store) which is still early in its development.
-
-If you have feedback or questions about this API, please don't hesitate to comment on the [RFC](https://github.com/livestorejs/livestore/pull/585)
-:::
-
-### Store Configuration
-
-First, define store options for each store type using [`storeOptions()`](/framework-integrations/react-integration#storeoptionsoptions):
-
-**Workspace store:**
-
-## `data-modeling/todo-workspaces/multi-store/workspace.store.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/workspace.store.ts"
-
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker,
-  sharedWorker,
-})
-
-// Define workspace store configuration
-// Each workspace gets its own isolated store instance
-export const workspaceStoreOptions = (workspaceId: string) =>
-  storeOptions({
-    storeId: `workspace-${workspaceId}`,
-    schema,
-    adapter,
-    unusedCacheTime: 60_000, // Keep in memory for 60 seconds after last use
-  })
-```
-
-### `data-modeling/todo-workspaces/multi-store/workspace.schema.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/workspace.schema.ts"
-
-// Emitted when a new workspace is created (originates this store)
-const workspaceCreated = Events.synced({
-  name: 'v1.WorkspaceCreated',
-  schema: Schema.Struct({
-    workspaceId: Schema.String,
-    name: Schema.String,
-    createdByUsername: Schema.String,
-  }),
-})
-
-// Emitted when a todo item is added to this workspace
-const todoAdded = Events.synced({
-  name: 'v1.TodoAdded',
-  schema: Schema.Struct({ todoId: Schema.String, text: Schema.String }),
-})
-
-// Emitted when a todo item is marked as completed
-const todoCompleted = Events.synced({
-  name: 'v1.TodoCompleted',
-  schema: Schema.Struct({ todoId: Schema.String }),
-})
-
-// Emitted when a todo item is deleted (soft delete)
-const todoDeleted = Events.synced({
-  name: 'v1.TodoDeleted',
-  schema: Schema.Struct({ todoId: Schema.String, deletedAt: Schema.Date }),
-})
-
-// Emitted when a new user joins this workspace
-const userJoined = Events.synced({
-  name: 'v1.UserJoined',
-  schema: Schema.Struct({ username: Schema.String }),
-})
-
-export const workspaceEvents = { workspaceCreated, todoAdded, todoCompleted, todoDeleted, userJoined }
-
-// Table for the workspace itself (only one row as this store is per-workspace)
-const workspaceTable = State.SQLite.table({
-  name: 'workspace',
-  columns: {
-    workspaceId: State.SQLite.text({ primaryKey: true }),
-    name: State.SQLite.text(),
-    createdByUsername: State.SQLite.text(),
-  },
-})
-
-// Table for the todo items in this workspace
-const todoTable = State.SQLite.table({
-  name: 'todo',
-  columns: {
-    todoId: State.SQLite.text({ primaryKey: true }),
-    text: State.SQLite.text(),
-    completed: State.SQLite.boolean({ default: false }),
-    // Using soft delete by adding a deletedAt timestamp
-    deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
-  },
-})
-
-// Table for members of this workspace
-const memberTable = State.SQLite.table({
-  name: 'member',
-  columns: {
-    username: State.SQLite.text({ primaryKey: true }),
-    // Could add role/permissions here later
-  },
-})
-
-export const workspaceTables = { workspace: workspaceTable, todo: todoTable, member: memberTable }
-
-const materializers = State.SQLite.materializers(workspaceEvents, {
-  'v1.WorkspaceCreated': ({ workspaceId, name, createdByUsername }) => [
-    workspaceTables.workspace.insert({ workspaceId, name, createdByUsername }),
-    // Add the creator as the first member
-    workspaceTables.member.insert({ username: createdByUsername }),
-  ],
-  'v1.TodoAdded': ({ todoId, text }) => workspaceTables.todo.insert({ todoId, text }),
-  'v1.TodoCompleted': ({ todoId }) => workspaceTables.todo.update({ completed: true }).where({ todoId }),
-  'v1.TodoDeleted': ({ todoId, deletedAt }) => workspaceTables.todo.update({ deletedAt }).where({ todoId }),
-  'v1.UserJoined': ({ username }) => workspaceTables.member.insert({ username }),
-})
-
-const state = State.SQLite.makeState({ tables: workspaceTables, materializers })
-
-export const schema = makeSchema({ events: workspaceEvents, state })
-```
-
-**User store:**
-
-## `data-modeling/todo-workspaces/multi-store/user.store.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/user.store.ts"
-
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker,
-  sharedWorker,
-})
-
-// Define user store configuration
-// Each user has their own store to track which workspaces they're part of
-export const userStoreOptions = (username: string) =>
-  storeOptions({
-    storeId: `user-${username}`,
-    schema,
-    adapter,
-    unusedCacheTime: Number.POSITIVE_INFINITY, // Keep user store in memory indefinitely
-  })
-```
-
-### `data-modeling/todo-workspaces/multi-store/user.schema.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/user.schema.ts"
-
-// Emitted when this user creates a new workspace
-const workspaceCreated = Events.synced({
-  name: 'v1.WorkspaceCreated',
-  schema: Schema.Struct({ workspaceId: Schema.String }),
-})
-
-// Emitted when this user joins an existing workspace
-const workspaceJoined = Events.synced({
-  name: 'v1.WorkspaceJoined',
-  schema: Schema.Struct({ workspaceId: Schema.String }),
-})
-
-const events = { workspaceCreated, workspaceJoined }
-
-// Table to store basic user info
-// Contains only one row as this store is per-user.
-const userTable = State.SQLite.table({
-  name: 'user',
-  columns: {
-    // Assuming username is unique and used as the identifier
-    username: State.SQLite.text({ primaryKey: true }),
-  },
-})
-
-// Table to track which workspaces this user is part of
-const userWorkspaceTable = State.SQLite.table({
-  name: 'userWorkspace',
-  columns: {
-    workspaceId: State.SQLite.text({ primaryKey: true }),
-    // Could add role/permissions here later
-  },
-})
-
-export const userTables = { user: userTable, userWorkspace: userWorkspaceTable }
-
-const materializers = State.SQLite.materializers(events, {
-  // When the user creates or joins a workspace, add it to their workspace table
-  'v1.WorkspaceCreated': ({ workspaceId }) => userTables.userWorkspace.insert({ workspaceId }),
-  'v1.WorkspaceJoined': ({ workspaceId }) => userTables.userWorkspace.insert({ workspaceId }),
-})
-
-const state = State.SQLite.makeState({ tables: userTables, materializers })
-
-export const schema = makeSchema({ events, state })
-```
-
-### App Setup
-
-Create a [`StoreRegistry`](/framework-integrations/react-integration#new-storeregistryconfig) and provide it to your React app:
-
-## `data-modeling/todo-workspaces/multi-store/App.tsx`
-
-```tsx filename="data-modeling/todo-workspaces/multi-store/App.tsx"
-
-export function App({ children }: { children: ReactNode }) {
-  const [storeRegistry] = useState(
-    () =>
-      new StoreRegistry({
-        defaultOptions: {
-          batchUpdates,
-        },
-      }),
-  )
-
-  return <StoreRegistryProvider storeRegistry={storeRegistry}>{children}</StoreRegistryProvider>
-}
-```
-
-### Accessing Stores
-
-Use the [`useStore()`](/framework-integrations/react-integration#usestoreoptions) hook to access specific workspace instances:
-
-## `data-modeling/todo-workspaces/multi-store/Workspace.tsx`
-
-```tsx filename="data-modeling/todo-workspaces/multi-store/Workspace.tsx"
-
-// Component that accesses a specific workspace store
-function WorkspaceContent({ workspaceId }: { workspaceId: string }) {
-  // Load the workspace store for this specific workspace
-  const workspaceStore = useStore(workspaceStoreOptions(workspaceId))
-
-  // Query workspace data
-  const [workspace] = workspaceStore.useQuery(queryDb(workspaceTables.workspace.select().limit(1)))
-  const todos = workspaceStore.useQuery(queryDb(workspaceTables.todo.select()))
-
-  if (!workspace) return <div>Workspace not found</div>
-
-  const addTodo = (text: string) => {
-    workspaceStore.commit(
-      workspaceEvents.todoAdded({
-        todoId: `todo-${Date.now()}`,
-        text,
-      }),
-    )
-  }
-
-  return (
-    <div>
-      <h2>{workspace.name}</h2>
-      <p>Created by: {workspace.createdByUsername}</p>
-      <p>Store ID: {workspaceStore.storeId}</p>
-
-      <h3>Todos ({todos.length})</h3>
-      <ul>
-        {todos.map((todo) => (
-          <li key={todo.todoId}>
-            {todo.text} {todo.completed ? '✓' : ''}
-          </li>
-        ))}
-      </ul>
-
-      <button type="button" onClick={() => addTodo('New todo')}>
-        Add Todo
-      </button>
-    </div>
-  )
-}
-
-// Workspace component with Suspense and ErrorBoundary
-export function Workspace({ workspaceId }: { workspaceId: string }) {
-  return (
-    <ErrorBoundary fallback={<div>Error loading workspace</div>}>
-      <Suspense fallback={<div>Loading workspace...</div>}>
-        <WorkspaceContent workspaceId={workspaceId} />
-      </Suspense>
-    </ErrorBoundary>
-  )
-}
-```
-
-### `data-modeling/todo-workspaces/multi-store/workspace.schema.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/workspace.schema.ts"
-
-// Emitted when a new workspace is created (originates this store)
-const workspaceCreated = Events.synced({
-  name: 'v1.WorkspaceCreated',
-  schema: Schema.Struct({
-    workspaceId: Schema.String,
-    name: Schema.String,
-    createdByUsername: Schema.String,
-  }),
-})
-
-// Emitted when a todo item is added to this workspace
-const todoAdded = Events.synced({
-  name: 'v1.TodoAdded',
-  schema: Schema.Struct({ todoId: Schema.String, text: Schema.String }),
-})
-
-// Emitted when a todo item is marked as completed
-const todoCompleted = Events.synced({
-  name: 'v1.TodoCompleted',
-  schema: Schema.Struct({ todoId: Schema.String }),
-})
-
-// Emitted when a todo item is deleted (soft delete)
-const todoDeleted = Events.synced({
-  name: 'v1.TodoDeleted',
-  schema: Schema.Struct({ todoId: Schema.String, deletedAt: Schema.Date }),
-})
-
-// Emitted when a new user joins this workspace
-const userJoined = Events.synced({
-  name: 'v1.UserJoined',
-  schema: Schema.Struct({ username: Schema.String }),
-})
-
-export const workspaceEvents = { workspaceCreated, todoAdded, todoCompleted, todoDeleted, userJoined }
-
-// Table for the workspace itself (only one row as this store is per-workspace)
-const workspaceTable = State.SQLite.table({
-  name: 'workspace',
-  columns: {
-    workspaceId: State.SQLite.text({ primaryKey: true }),
-    name: State.SQLite.text(),
-    createdByUsername: State.SQLite.text(),
-  },
-})
-
-// Table for the todo items in this workspace
-const todoTable = State.SQLite.table({
-  name: 'todo',
-  columns: {
-    todoId: State.SQLite.text({ primaryKey: true }),
-    text: State.SQLite.text(),
-    completed: State.SQLite.boolean({ default: false }),
-    // Using soft delete by adding a deletedAt timestamp
-    deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
-  },
-})
-
-// Table for members of this workspace
-const memberTable = State.SQLite.table({
-  name: 'member',
-  columns: {
-    username: State.SQLite.text({ primaryKey: true }),
-    // Could add role/permissions here later
-  },
-})
-
-export const workspaceTables = { workspace: workspaceTable, todo: todoTable, member: memberTable }
-
-const materializers = State.SQLite.materializers(workspaceEvents, {
-  'v1.WorkspaceCreated': ({ workspaceId, name, createdByUsername }) => [
-    workspaceTables.workspace.insert({ workspaceId, name, createdByUsername }),
-    // Add the creator as the first member
-    workspaceTables.member.insert({ username: createdByUsername }),
-  ],
-  'v1.TodoAdded': ({ todoId, text }) => workspaceTables.todo.insert({ todoId, text }),
-  'v1.TodoCompleted': ({ todoId }) => workspaceTables.todo.update({ completed: true }).where({ todoId }),
-  'v1.TodoDeleted': ({ todoId, deletedAt }) => workspaceTables.todo.update({ deletedAt }).where({ todoId }),
-  'v1.UserJoined': ({ username }) => workspaceTables.member.insert({ username }),
-})
-
-const state = State.SQLite.makeState({ tables: workspaceTables, materializers })
-
-export const schema = makeSchema({ events: workspaceEvents, state })
-```
-
-### `data-modeling/todo-workspaces/multi-store/workspace.store.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/workspace.store.ts"
-
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker,
-  sharedWorker,
-})
-
-// Define workspace store configuration
-// Each workspace gets its own isolated store instance
-export const workspaceStoreOptions = (workspaceId: string) =>
-  storeOptions({
-    storeId: `workspace-${workspaceId}`,
-    schema,
-    adapter,
-    unusedCacheTime: 60_000, // Keep in memory for 60 seconds after last use
-  })
-```
-
-### Loading Multiple Workspaces
-
-To display all workspaces for a user, first load the user store to get their workspace list, then dynamically load each workspace:
-
-## `data-modeling/todo-workspaces/multi-store/WorkspaceList.tsx`
-
-```tsx filename="data-modeling/todo-workspaces/multi-store/WorkspaceList.tsx"
-
-// Component that displays all workspaces for a user
-function WorkspaceListContent({ username }: { username: string }) {
-  // Load the user store to get their workspace list
-  const userStore = useStore(userStoreOptions(username))
-
-  // Query all workspaces this user belongs to
-  const workspaces = userStore.useQuery(queryDb(userTables.userWorkspace.select()))
-
-  return (
-    <div>
-      <h1>My Workspaces</h1>
-      {workspaces.length === 0 ? (
-        <p>No workspaces yet</p>
-      ) : (
-        workspaces.map((w) => (
-          <div key={w.workspaceId}>
-            <Workspace workspaceId={w.workspaceId} />
-          </div>
-        ))
-      )}
-    </div>
-  )
-}
-
-// Full workspace list with Suspense
-export function WorkspaceList({ username }: { username: string }) {
-  return (
-    <ErrorBoundary fallback={<div>Error loading workspaces</div>}>
-      <Suspense fallback={<div>Loading workspaces...</div>}>
-        <WorkspaceListContent username={username} />
-      </Suspense>
-    </ErrorBoundary>
-  )
-}
-```
-
-### `data-modeling/todo-workspaces/multi-store/user.schema.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/user.schema.ts"
-
-// Emitted when this user creates a new workspace
-const workspaceCreated = Events.synced({
-  name: 'v1.WorkspaceCreated',
-  schema: Schema.Struct({ workspaceId: Schema.String }),
-})
-
-// Emitted when this user joins an existing workspace
-const workspaceJoined = Events.synced({
-  name: 'v1.WorkspaceJoined',
-  schema: Schema.Struct({ workspaceId: Schema.String }),
-})
-
-const events = { workspaceCreated, workspaceJoined }
-
-// Table to store basic user info
-// Contains only one row as this store is per-user.
-const userTable = State.SQLite.table({
-  name: 'user',
-  columns: {
-    // Assuming username is unique and used as the identifier
-    username: State.SQLite.text({ primaryKey: true }),
-  },
-})
-
-// Table to track which workspaces this user is part of
-const userWorkspaceTable = State.SQLite.table({
-  name: 'userWorkspace',
-  columns: {
-    workspaceId: State.SQLite.text({ primaryKey: true }),
-    // Could add role/permissions here later
-  },
-})
-
-export const userTables = { user: userTable, userWorkspace: userWorkspaceTable }
-
-const materializers = State.SQLite.materializers(events, {
-  // When the user creates or joins a workspace, add it to their workspace table
-  'v1.WorkspaceCreated': ({ workspaceId }) => userTables.userWorkspace.insert({ workspaceId }),
-  'v1.WorkspaceJoined': ({ workspaceId }) => userTables.userWorkspace.insert({ workspaceId }),
-})
-
-const state = State.SQLite.makeState({ tables: userTables, materializers })
-
-export const schema = makeSchema({ events, state })
-```
-
-### `data-modeling/todo-workspaces/multi-store/user.store.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/user.store.ts"
-
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker,
-  sharedWorker,
-})
-
-// Define user store configuration
-// Each user has their own store to track which workspaces they're part of
-export const userStoreOptions = (username: string) =>
-  storeOptions({
-    storeId: `user-${username}`,
-    schema,
-    adapter,
-    unusedCacheTime: Number.POSITIVE_INFINITY, // Keep user store in memory indefinitely
-  })
-```
-
-### `data-modeling/todo-workspaces/multi-store/workspace.schema.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/workspace.schema.ts"
-
-// Emitted when a new workspace is created (originates this store)
-const workspaceCreated = Events.synced({
-  name: 'v1.WorkspaceCreated',
-  schema: Schema.Struct({
-    workspaceId: Schema.String,
-    name: Schema.String,
-    createdByUsername: Schema.String,
-  }),
-})
-
-// Emitted when a todo item is added to this workspace
-const todoAdded = Events.synced({
-  name: 'v1.TodoAdded',
-  schema: Schema.Struct({ todoId: Schema.String, text: Schema.String }),
-})
-
-// Emitted when a todo item is marked as completed
-const todoCompleted = Events.synced({
-  name: 'v1.TodoCompleted',
-  schema: Schema.Struct({ todoId: Schema.String }),
-})
-
-// Emitted when a todo item is deleted (soft delete)
-const todoDeleted = Events.synced({
-  name: 'v1.TodoDeleted',
-  schema: Schema.Struct({ todoId: Schema.String, deletedAt: Schema.Date }),
-})
-
-// Emitted when a new user joins this workspace
-const userJoined = Events.synced({
-  name: 'v1.UserJoined',
-  schema: Schema.Struct({ username: Schema.String }),
-})
-
-export const workspaceEvents = { workspaceCreated, todoAdded, todoCompleted, todoDeleted, userJoined }
-
-// Table for the workspace itself (only one row as this store is per-workspace)
-const workspaceTable = State.SQLite.table({
-  name: 'workspace',
-  columns: {
-    workspaceId: State.SQLite.text({ primaryKey: true }),
-    name: State.SQLite.text(),
-    createdByUsername: State.SQLite.text(),
-  },
-})
-
-// Table for the todo items in this workspace
-const todoTable = State.SQLite.table({
-  name: 'todo',
-  columns: {
-    todoId: State.SQLite.text({ primaryKey: true }),
-    text: State.SQLite.text(),
-    completed: State.SQLite.boolean({ default: false }),
-    // Using soft delete by adding a deletedAt timestamp
-    deletedAt: State.SQLite.integer({ nullable: true, schema: Schema.DateFromNumber }),
-  },
-})
-
-// Table for members of this workspace
-const memberTable = State.SQLite.table({
-  name: 'member',
-  columns: {
-    username: State.SQLite.text({ primaryKey: true }),
-    // Could add role/permissions here later
-  },
-})
-
-export const workspaceTables = { workspace: workspaceTable, todo: todoTable, member: memberTable }
-
-const materializers = State.SQLite.materializers(workspaceEvents, {
-  'v1.WorkspaceCreated': ({ workspaceId, name, createdByUsername }) => [
-    workspaceTables.workspace.insert({ workspaceId, name, createdByUsername }),
-    // Add the creator as the first member
-    workspaceTables.member.insert({ username: createdByUsername }),
-  ],
-  'v1.TodoAdded': ({ todoId, text }) => workspaceTables.todo.insert({ todoId, text }),
-  'v1.TodoCompleted': ({ todoId }) => workspaceTables.todo.update({ completed: true }).where({ todoId }),
-  'v1.TodoDeleted': ({ todoId, deletedAt }) => workspaceTables.todo.update({ deletedAt }).where({ todoId }),
-  'v1.UserJoined': ({ username }) => workspaceTables.member.insert({ username }),
-})
-
-const state = State.SQLite.makeState({ tables: workspaceTables, materializers })
-
-export const schema = makeSchema({ events: workspaceEvents, state })
-```
-
-### `data-modeling/todo-workspaces/multi-store/workspace.store.ts`
-
-```ts filename="data-modeling/todo-workspaces/multi-store/workspace.store.ts"
-
-const adapter = makePersistedAdapter({
-  storage: { type: 'opfs' },
-  worker,
-  sharedWorker,
-})
-
-// Define workspace store configuration
-// Each workspace gets its own isolated store instance
-export const workspaceStoreOptions = (workspaceId: string) =>
-  storeOptions({
-    storeId: `workspace-${workspaceId}`,
-    schema,
-    adapter,
-    unusedCacheTime: 60_000, // Keep in memory for 60 seconds after last use
-  })
-```
-
-### `data-modeling/todo-workspaces/multi-store/Workspace.tsx`
-
-```tsx filename="data-modeling/todo-workspaces/multi-store/Workspace.tsx"
-
-// Component that accesses a specific workspace store
-function WorkspaceContent({ workspaceId }: { workspaceId: string }) {
-  // Load the workspace store for this specific workspace
-  const workspaceStore = useStore(workspaceStoreOptions(workspaceId))
-
-  // Query workspace data
-  const [workspace] = workspaceStore.useQuery(queryDb(workspaceTables.workspace.select().limit(1)))
-  const todos = workspaceStore.useQuery(queryDb(workspaceTables.todo.select()))
-
-  if (!workspace) return <div>Workspace not found</div>
-
-  const addTodo = (text: string) => {
-    workspaceStore.commit(
-      workspaceEvents.todoAdded({
-        todoId: `todo-${Date.now()}`,
-        text,
-      }),
-    )
-  }
-
-  return (
-    <div>
-      <h2>{workspace.name}</h2>
-      <p>Created by: {workspace.createdByUsername}</p>
-      <p>Store ID: {workspaceStore.storeId}</p>
-
-      <h3>Todos ({todos.length})</h3>
-      <ul>
-        {todos.map((todo) => (
-          <li key={todo.todoId}>
-            {todo.text} {todo.completed ? '✓' : ''}
-          </li>
-        ))}
-      </ul>
-
-      <button type="button" onClick={() => addTodo('New todo')}>
-        Add Todo
-      </button>
-    </div>
-  )
-}
-
-// Workspace component with Suspense and ErrorBoundary
-export function Workspace({ workspaceId }: { workspaceId: string }) {
-  return (
-    <ErrorBoundary fallback={<div>Error loading workspace</div>}>
-      <Suspense fallback={<div>Loading workspace...</div>}>
-        <WorkspaceContent workspaceId={workspaceId} />
-      </Suspense>
-    </ErrorBoundary>
-  )
-}
-```
-
-## Further notes
-
-To make this app more production-ready, we might want to do the following:
-- Use a proper auth setup to enforce a trusted user identity
-- Introduce a proper user invite process
-- Introduce access levels (e.g. read-only, read-write)
-- Introduce end-to-end encryption
-
-### Individual todo stores for complex data
-
-If each todo item has a lot of data (e.g. think of a GitHub/Linear issue with lots of details), it might make sense to split up each todo item into its own store.
-
-This would create **3 store types** instead of 2:
-- **User stores** (one per user) - unchanged
-- **Workspace stores** (one per workspace) - only basic todo metadata
-- **Todo stores** (one per todo item) - rich todo data
-
-Your app would then have **N + M + K stores** total (N workspaces + M users + K todo items).
-
-This pattern improves performance by only loading detailed todo data when specifically viewing that item, and prevents large todos from slowing down workspace syncing.