@livestore/livestore

function createStore<TSchema extends LiveStoreSchema>(
  options: CreateStoreOptions<TSchema>,
): Store<TSchema>

import { createStore, storeOptions } from '@livestore/livestore'

const store = await createStore({
  schema,
  adapter,
  storeId: 'my-app',
})

function createStorePromise<TSchema extends LiveStoreSchema>(
  options: CreateStoreOptionsPromise<TSchema>,
): Promise<Store<TSchema>>

function storeOptions<
  TSchema extends LiveStoreSchema,
  TContext = {},
  TSyncPayloadSchema extends Schema.Schema<any> = typeof Schema.JsonValue,
>(
  options: RegistryStoreOptions<TSchema, TContext, TSyncPayloadSchema>,
): RegistryStoreOptions<TSchema, TContext, TSyncPayloadSchema>

import { storeOptions } from '@livestore/livestore'

export const myStoreOptions = storeOptions({ schema, adapter, storeId: 'my-app' })

import { StoreRegistry } from '@livestore/livestore'
import { unstable_batchedUpdates as batchUpdates } from 'react-dom'

const storeRegistry = new StoreRegistry({
  defaultOptions: { batchUpdates },
})

import { Events, makeSchema, Schema, State } from '@livestore/livestore'

const events = {
  todoCreated: Events.synced({
    name: 'v1.TodoCreated',
    schema: Schema.Struct({ id: Schema.String, text: Schema.String }),
  }),
}

const tables = {
  todos: State.SQLite.table({
    name: 'todos',
    columns: {
      id: State.SQLite.text({ primaryKey: true }),
      text: State.SQLite.text({ default: '' }),
      completed: State.SQLite.boolean({ default: false }),
    },
  }),
}

export const schema = makeSchema({
  events,
  state: State.SQLite.makeState({ tables }),
})

function queryDb<T>(queryBuilder: QueryBuilder<T>): LiveQueryDef<T>

import { queryDb } from '@livestore/livestore'

const activeTodos = queryDb(
  tables.todos.query.where({ completed: false }).orderBy([{ col: 'text', direction: 'asc' }])
)

import { sql } from '@livestore/livestore'

const result = sql`SELECT * FROM todos WHERE completed = 0`

function signal<T>(
  initialValue: T,
  options?: { label?: string },
): SignalDef<T>

import { signal } from '@livestore/livestore'

const selectedId = signal<string | null>(null, { label: 'selectedId' })

function computed<T>(
  compute: (get: Get) => T,
  options?: { label?: string },
): LiveQueryDef<T>

import { computed, signal } from '@livestore/livestore'

const counter = signal(0)
const doubled = computed((get) => get(counter) * 2)

import { nanoid } from '@livestore/livestore'

const id = nanoid() // 21-character URL-safe string

import {
  createStorePromise,
  Events,
  makeSchema,
  nanoid,
  queryDb,
  Schema,
  signal,
  State,
  storeOptions,
} from '@livestore/livestore'

// 1. Define events
const events = {
  todoCreated: Events.synced({
    name: 'v1.TodoCreated',
    schema: Schema.Struct({ id: Schema.String, text: Schema.String }),
  }),
  todoCompleted: Events.synced({
    name: 'v1.TodoCompleted',
    schema: Schema.Struct({ id: Schema.String }),
  }),
}

// 2. Define state tables
const tables = {
  todos: State.SQLite.table({
    name: 'todos',
    columns: {
      id: State.SQLite.text({ primaryKey: true }),
      text: State.SQLite.text({ default: '' }),
      completed: State.SQLite.boolean({ default: false }),
    },
  }),
}

// 3. Compose the schema
const schema = makeSchema({
  events,
  state: State.SQLite.makeState({ tables }),
})

// 4. Create a store
const store = await createStorePromise({ schema, adapter, storeId: 'todos' })

// 5. Query and commit
const todos = store.query(queryDb(tables.todos.query))
store.commit(events.todoCreated({ id: nanoid(), text: 'Buy groceries' }))