@livestore/common 0.0.0-snapshot-909cdd1ac2fd591945c2be2b0f53e14d87f3c9d4

package/src/adapter-types.ts

@@ -0,0 +1,216 @@
+import type { Cause, Queue, Scope, SubscriptionRef, WebChannel } from '@livestore/utils/effect'
+import { Effect, Schema, Stream } from '@livestore/utils/effect'
+
+import type * as Devtools from './devtools/index.js'
+import type { LiveStoreSchema, MutationEvent } from './schema/index.js'
+import type { PreparedBindValues } from './util.js'
+
+export interface PreparedStatement {
+  execute(bindValues: PreparedBindValues | undefined, options?: { onRowsChanged?: (rowsChanged: number) => void }): void
+  select<T>(bindValues: PreparedBindValues | undefined): ReadonlyArray<T>
+  finalize(): void
+  sql: string
+}
+
+export type ClientSession = {
+  /** SQLite database with synchronous API running in the same thread (usually in-memory) */
+  syncDb: SynchronousDatabase
+  /** The coordinator is responsible for persisting the database, syncing etc */
+  coordinator: Coordinator
+}
+
+export type SynchronousDatabase = {
+  _tag: 'SynchronousDatabase'
+  prepare(queryStr: string): PreparedStatement
+  execute(
+    queryStr: string,
+    bindValues?: PreparedBindValues | undefined,
+    options?: { onRowsChanged?: (rowsChanged: number) => void },
+  ): void
+  select<T>(queryStr: string, bindValues?: PreparedBindValues | undefined): ReadonlyArray<T>
+  export(): Uint8Array
+  close(): void
+}
+
+export type ResetMode = 'all-data' | 'only-app-db'
+
+export const NetworkStatus = Schema.Struct({
+  isConnected: Schema.Boolean,
+  timestampMs: Schema.Number,
+})
+
+export type NetworkStatus = {
+  isConnected: boolean
+  timestampMs: number
+}
+
+export const BootStateProgress = Schema.Struct({
+  done: Schema.Number,
+  total: Schema.Number,
+})
+
+export const BootStatus = Schema.Union(
+  Schema.Struct({ stage: Schema.Literal('loading') }),
+  Schema.Struct({ stage: Schema.Literal('migrating'), progress: BootStateProgress }),
+  Schema.Struct({ stage: Schema.Literal('rehydrating'), progress: BootStateProgress }),
+  Schema.Struct({ stage: Schema.Literal('syncing'), progress: BootStateProgress }),
+  Schema.Struct({ stage: Schema.Literal('done') }),
+)
+
+export type BootStatus = typeof BootStatus.Type
+
+export type Coordinator = {
+  devtools: {
+    enabled: boolean
+    // TODO incorporate sessionId and rethink appHostId
+    appHostId: string
+  }
+  sessionId: string
+  // TODO is exposing the lock status really needed (or only relevant for web adapter?)
+  lockStatus: SubscriptionRef.SubscriptionRef<LockStatus>
+  syncMutations: Stream.Stream<MutationEvent.Any, UnexpectedError>
+  execute(queryStr: string, bindValues: PreparedBindValues | undefined): Effect.Effect<void, UnexpectedError>
+  mutate(
+    mutationEventEncoded: MutationEvent.AnyEncoded,
+    options: { persisted: boolean },
+  ): Effect.Effect<void, UnexpectedError>
+  /** Can be called synchronously */
+  nextMutationEventIdPair: (opts: { localOnly: boolean }) => Effect.Effect<EventIdPair, UnexpectedError>
+  /** Used to initially get the current mutation event id to use as `parentId` for the next mutation event */
+  getCurrentMutationEventId: Effect.Effect<EventId, UnexpectedError>
+  export: Effect.Effect<Uint8Array | undefined, UnexpectedError>
+  getMutationLogData: Effect.Effect<Uint8Array, UnexpectedError>
+  networkStatus: SubscriptionRef.SubscriptionRef<NetworkStatus>
+}
+
+/**
+ * Can be used in queries to refer to the current session id.
+ * Will be replaced with the actual session id at runtime
+ *
+ * Example:
+ * ```ts
+ * const query$ = rowQuery(tables.app, SessionIdSymbol)
+ * ```
+ */
+export const SessionIdSymbol = Symbol.for('@livestore/session-id')
+export type SessionIdSymbol = typeof SessionIdSymbol
+
+export type LockStatus = 'has-lock' | 'no-lock'
+
+/**
+ * LiveStore event id value consisting of a globally unique event sequence number
+ * and a local sequence number.
+ *
+ * The local sequence number is only used for localOnly mutations and starts from 0 for each global sequence number.
+ */
+export type EventId = { global: number; local: number }
+
+export const EventId = Schema.Struct({
+  global: Schema.Number,
+  local: Schema.Number,
+}).annotations({ title: 'LiveStore.EventId' })
+
+export type EventIdPair = { id: EventId; parentId: EventId }
+
+export const ROOT_ID = { global: -1, local: 0 } satisfies EventId
+
+export type BootDb = {
+  _tag: 'BootDb'
+  execute(queryStr: string, bindValues?: PreparedBindValues): void
+  mutate: <const TMutationArg extends ReadonlyArray<MutationEvent.PartialAny>>(...list: TMutationArg) => void
+  select<T>(queryStr: string, bindValues?: PreparedBindValues): ReadonlyArray<T>
+  txn(callback: () => void): void
+}
+
+export class UnexpectedError extends Schema.TaggedError<UnexpectedError>()('LiveStore.UnexpectedError', {
+  cause: Schema.Defect,
+  note: Schema.optional(Schema.String),
+  payload: Schema.optional(Schema.Any),
+}) {
+  static mapToUnexpectedError = <A, E, R>(effect: Effect.Effect<A, E, R>) =>
+    effect.pipe(
+      Effect.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
+      Effect.catchAllDefect((cause) => new UnexpectedError({ cause })),
+    )
+
+  static mapToUnexpectedErrorStream = <A, E, R>(stream: Stream.Stream<A, E, R>) =>
+    stream.pipe(
+      Stream.mapError((cause) => (Schema.is(UnexpectedError)(cause) ? cause : new UnexpectedError({ cause }))),
+    )
+}
+
+export class IntentionalShutdownCause extends Schema.TaggedError<IntentionalShutdownCause>()(
+  'LiveStore.IntentionalShutdownCause',
+  {
+    reason: Schema.Literal('devtools-reset', 'devtools-import'),
+  },
+) {}
+
+export class SqliteError extends Schema.TaggedError<SqliteError>()('LiveStore.SqliteError', {
+  query: Schema.optional(
+    Schema.Struct({
+      sql: Schema.String,
+      bindValues: Schema.Union(Schema.Record({ key: Schema.String, value: Schema.Any }), Schema.Array(Schema.Any)),
+    }),
+  ),
+  /** The SQLite result code */
+  code: Schema.optional(Schema.Number),
+  /** The original SQLite3 error */
+  cause: Schema.Defect,
+}) {}
+
+// TODO possibly allow a combination of these options
+// TODO allow a way to stream the migration progress back to the app
+export type MigrationOptions<TSchema extends LiveStoreSchema = LiveStoreSchema> =
+  | MigrationOptionsFromMutationLog<TSchema>
+  | {
+      strategy: 'hard-reset'
+      hooks?: Partial<MigrationHooks>
+    }
+  | {
+      strategy: 'manual'
+      migrate: (oldDb: Uint8Array) => Uint8Array | Promise<Uint8Array> | Effect.Effect<Uint8Array, unknown>
+    }
+
+export type MigrationHooks = {
+  /** Runs on the empty in-memory database with no database schemas applied yet */
+  init: MigrationHook
+  /** Runs before applying the migration strategy but after table schemas have been applied and singleton rows have been created */
+  pre: MigrationHook
+  /** Runs after applying the migration strategy before creating export snapshot and closing the database */
+  post: MigrationHook
+}
+
+export type MigrationHook = (db: SynchronousDatabase) => void | Promise<void> | Effect.Effect<void, unknown>
+
+export type MigrationOptionsFromMutationLog<TSchema extends LiveStoreSchema = LiveStoreSchema> = {
+  strategy: 'from-mutation-log'
+  /**
+   * Mutations to exclude in the mutation log
+   *
+   * @default new Set(['livestore.RawSql'])
+   */
+  excludeMutations?: ReadonlySet<keyof TSchema['_MutationDefMapType'] & string>
+  hooks?: Partial<MigrationHooks>
+  logging?: {
+    excludeAffectedRows?: (sqlStmt: string) => boolean
+  }
+}
+
+export type StoreDevtoolsChannel = WebChannel.WebChannel<
+  Devtools.MessageToAppHostStore,
+  Devtools.MessageFromAppHostStore
+>
+
+export type ConnectDevtoolsToStore = (
+  storeDevtoolsChannel: StoreDevtoolsChannel,
+) => Effect.Effect<void, UnexpectedError, Scope.Scope>
+
+export type Adapter = (opts: {
+  schema: LiveStoreSchema
+  storeId: string
+  devtoolsEnabled: boolean
+  bootStatusQueue: Queue.Queue<BootStatus>
+  shutdown: (cause: Cause.Cause<any>) => Effect.Effect<void>
+  connectDevtoolsToStore: ConnectDevtoolsToStore
+}) => Effect.Effect<ClientSession, UnexpectedError, Scope.Scope>

package/src/ambient.d.ts

@@ -0,0 +1,3 @@
+interface ImportMeta {
+  readonly env: ImportMetaEnv
+}

package/src/bounded-collections.ts

@@ -0,0 +1,121 @@
+/**
+ * Creates a map that has a fixed number of entries.
+ * Once hitting the bound, earliest insertions are removed
+ */
+export class BoundMap<K, V> {
+  #map = new Map<K, V>()
+  #sizeLimit: number
+
+  constructor(sizeLimit: number) {
+    this.#sizeLimit = sizeLimit
+  }
+
+  onEvict: ((key: K, value: V) => void) | undefined
+
+  set = (key: K, value: V) => {
+    this.#map.set(key, value)
+    // console.log(this.#map.size, this.#sizeLimit);
+    if (this.#map.size > this.#sizeLimit) {
+      const firstKey = this.#map.keys().next().value as K
+      const deletedValue = this.#map.get(firstKey)!
+      this.#map.delete(firstKey)
+      if (this.onEvict) {
+        this.onEvict(firstKey, deletedValue)
+      }
+    }
+  }
+
+  get = (key: K): V | undefined => {
+    return this.#map.get(key)
+  }
+
+  delete = (key: K) => {
+    this.#map.delete(key)
+  }
+
+  keys = () => {
+    return this.#map.keys()
+  }
+}
+
+export class BoundSet<V> {
+  #map: BoundMap<V, V>
+
+  constructor(sizeLimit: number) {
+    this.#map = new BoundMap(sizeLimit)
+    this.#map.onEvict = this.#onEvict
+  }
+
+  #onEvict = (v: V) => {
+    if (this.onEvict) {
+      this.onEvict(v)
+    }
+  }
+
+  onEvict: ((key: V) => void) | undefined
+
+  add = (v: V) => {
+    this.#map.set(v, v)
+  };
+
+  [Symbol.iterator] = () => {
+    return this.#map.keys()
+  }
+}
+
+export class BoundArray<V> {
+  #array: V[] = []
+  public sizeLimit: number
+
+  constructor(sizeLimit: number) {
+    this.sizeLimit = sizeLimit
+  }
+
+  static make = <V>(sizeLimit: number, initial: Iterable<V> = []): BoundArray<V> => {
+    const b = new BoundArray<V>(sizeLimit)
+    for (const v of initial) {
+      b.push(v)
+    }
+    return b
+  }
+
+  onEvict: ((key: V) => void) | undefined
+
+  push = (v: V) => {
+    this.#array.push(v)
+    if (this.#array.length > this.sizeLimit) {
+      const first = this.#array.shift()
+      if (first && this.onEvict) {
+        this.onEvict(first)
+      }
+    }
+  }
+
+  get = (index: number): V | undefined => {
+    return this.#array[index]
+  }
+
+  delete = (index: number) => {
+    this.#array.splice(index, 1)
+  }
+
+  get length() {
+    return this.#array.length
+  }
+
+  [Symbol.iterator] = (): IterableIterator<V> => {
+    return this.#array[Symbol.iterator]()
+  }
+
+  map = <T>(fn: (v: V) => T): T[] => {
+    return this.#array.map(fn)
+  }
+
+  clear = () => {
+    this.#array = []
+  }
+
+  sort = (fn?: (a: V, b: V) => number) => {
+    return this.#array.sort(fn)
+  }
+}

package/src/debug-info.ts

@@ -0,0 +1,76 @@
+import { ParseResult, Schema } from '@livestore/utils/effect'
+
+import { BoundArray } from './bounded-collections.js'
+import { PreparedBindValues } from './util.js'
+
+export type SlowQueryInfo = {
+  queryStr: string
+  bindValues: PreparedBindValues | undefined
+  durationMs: number
+  rowsCount: number | undefined
+  queriedTables: Set<string>
+  startTimePerfNow: DOMHighResTimeStamp
+}
+
+export const SlowQueryInfo = Schema.Struct({
+  queryStr: Schema.String,
+  bindValues: Schema.UndefinedOr(PreparedBindValues),
+  durationMs: Schema.Number,
+  rowsCount: Schema.UndefinedOr(Schema.Number),
+  queriedTables: Schema.ReadonlySet(Schema.String),
+  startTimePerfNow: Schema.Number,
+})
+
+const BoundArraySchemaFromSelf = <A, I, R>(
+  item: Schema.Schema<A, I, R>,
+): Schema.Schema<BoundArray<A>, BoundArray<I>, R> =>
+  Schema.declare(
+    [item],
+    {
+      decode: (item) => (input, parseOptions, ast) => {
+        if (input instanceof BoundArray) {
+          const elements = ParseResult.decodeUnknown(Schema.Array(item))([...input], parseOptions)
+          return ParseResult.map(elements, (as): BoundArray<A> => BoundArray.make(input.sizeLimit, as))
+        }
+        return ParseResult.fail(new ParseResult.Type(ast, input))
+      },
+      encode: (item) => (input, parseOptions, ast) => {
+        if (input instanceof BoundArray) {
+          const elements = ParseResult.encodeUnknown(Schema.Array(item))([...input], parseOptions)
+          return ParseResult.map(elements, (is): BoundArray<I> => BoundArray.make(input.sizeLimit, is))
+        }
+        return ParseResult.fail(new ParseResult.Type(ast, input))
+      },
+    },
+    {
+      description: `BoundArray<${Schema.format(item)}>`,
+      pretty: () => (_) => `BoundArray(${_.length})`,
+      arbitrary: () => (fc) => fc.anything() as any,
+      equivalence: () => (a, b) => a === b,
+    },
+  )
+
+export const BoundArraySchema = <ItemDecoded, ItemEncoded>(elSchema: Schema.Schema<ItemDecoded, ItemEncoded>) =>
+  Schema.transform(
+    Schema.Struct({
+      size: Schema.Number,
+      items: Schema.Array(elSchema),
+    }),
+    BoundArraySchemaFromSelf(Schema.typeSchema(elSchema)),
+    {
+      encode: (_) => ({ size: _.sizeLimit, items: [..._] }),
+      decode: (_) => BoundArray.make(_.size, _.items),
+    },
+  )
+
+export const DebugInfo = Schema.Struct({
+  slowQueries: BoundArraySchema(SlowQueryInfo),
+  queryFrameDuration: Schema.Number,
+  queryFrameCount: Schema.Number,
+  events: BoundArraySchema(Schema.Tuple(Schema.String, Schema.Any)),
+})
+
+export type DebugInfo = typeof DebugInfo.Type
+
+export const MutableDebugInfo = Schema.mutable(DebugInfo)
+export type MutableDebugInfo = typeof MutableDebugInfo.Type

package/src/derived-mutations.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, test } from 'vitest'
+
+import { appConfig, todos } from './__tests__/fixture.js'
+import type { MutationEvent } from './schema/mutations.js'
+
+describe('derived mutations', () => {
+  test('todos', () => {
+    expect(patchId(todos.insert({ id: 't1', completed: true, text: 'Task 1' }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "completed": true,
+          "id": "t1",
+          "text": "Task 1",
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Create_todos",
+      }
+    `)
+
+    expect(patchId(todos.update({ where: { id: 't1' }, values: { text: 'Task 1 - fixed' } }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "values": {
+            "text": "Task 1 - fixed",
+          },
+          "where": {
+            "id": "t1",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Update_todos",
+      }
+    `)
+
+    expect(patchId(todos.delete({ where: { id: 't1' } }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "where": {
+            "id": "t1",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Delete_todos",
+      }
+    `)
+  })
+
+  test('app_config', () => {
+    expect(patchId(appConfig.insert())).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "id": "singleton",
+          "value": {
+            "value": undefined,
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Create_app_config",
+      }
+    `)
+
+    expect(patchId(appConfig.insert({ fontSize: 12, theme: 'dark' }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "id": "singleton",
+          "value": {
+            "value": {
+              "fontSize": 12,
+              "theme": "dark",
+            },
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Create_app_config",
+      }
+    `)
+
+    expect(patchId(appConfig.update({ fontSize: 13 }))).toMatchInlineSnapshot(`
+      {
+        "args": {
+          "values": {
+            "value": {
+              "fontSize": 13,
+            },
+          },
+          "where": {
+            "id": "singleton",
+          },
+        },
+        "id": "00000000-0000-0000-0000-000000000000",
+        "mutation": "_Derived_Update_app_config",
+      }
+    `)
+  })
+})
+
+const patchId = (muationEvent: MutationEvent.PartialAny) => {
+  // TODO use new id paradigm
+  const id = `00000000-0000-0000-0000-000000000000`
+  return { ...muationEvent, id }
+}

package/src/derived-mutations.ts

@@ -0,0 +1,170 @@
+import type { SqliteDsl } from '@livestore/db-schema'
+import type { GetValForKey } from '@livestore/utils'
+import { ReadonlyRecord, Schema } from '@livestore/utils/effect'
+
+import type { MutationEvent } from './schema/mutations.js'
+import { defineMutation } from './schema/mutations.js'
+import { getDefaultValuesDecoded } from './schema/schema-helpers.js'
+import type * as DbSchema from './schema/table-def.js'
+import { deleteRows, insertRow, updateRows } from './sql-queries/sql-queries.js'
+
+export const makeDerivedMutationDefsForTable = <
+  TTableDef extends DbSchema.TableDef<
+    DbSchema.DefaultSqliteTableDefConstrained,
+    boolean,
+    DbSchema.TableOptions & { deriveMutations: { enabled: true } }
+  >,
+>(
+  table: TTableDef,
+) => ({
+  insert: deriveCreateMutationDef(table),
+  update: deriveUpdateMutationDef(table),
+  delete: deriveDeleteMutationDef(table),
+})
+
+export const deriveCreateMutationDef = <
+  TTableDef extends DbSchema.TableDef<
+    DbSchema.DefaultSqliteTableDefConstrained,
+    boolean,
+    DbSchema.TableOptions & { deriveMutations: { enabled: true } }
+  >,
+>(
+  table: TTableDef,
+) => {
+  const tableName = table.sqliteDef.name
+
+  const [optionalFields, requiredColumns] = ReadonlyRecord.partition(
+    (table.sqliteDef as DbSchema.DefaultSqliteTableDef).columns,
+    (col) => col.nullable === false && col.default._tag === 'None',
+  )
+
+  const insertSchema = Schema.Struct(ReadonlyRecord.map(requiredColumns, (col) => col.schema))
+    .pipe(Schema.extend(Schema.partial(Schema.Struct(ReadonlyRecord.map(optionalFields, (col) => col.schema)))))
+    .annotations({ title: `${tableName}:Insert` })
+
+  return defineMutation(
+    `_Derived_Create_${tableName}`,
+    insertSchema,
+    ({ id, ...explicitDefaultValues }) => {
+      const defaultValues = getDefaultValuesDecoded(table, explicitDefaultValues)
+
+      const [sql, bindValues] = insertRow({
+        tableName: table.sqliteDef.name,
+        columns: table.sqliteDef.columns,
+        values: { ...defaultValues, id },
+      })
+
+      return { sql, bindValues, writeTables: new Set([tableName]) }
+    },
+    { localOnly: table.options.deriveMutations.localOnly },
+  )
+}
+
+export const deriveUpdateMutationDef = <
+  TTableDef extends DbSchema.TableDef<
+    DbSchema.DefaultSqliteTableDefConstrained,
+    boolean,
+    DbSchema.TableOptions & { deriveMutations: { enabled: true } }
+  >,
+>(
+  table: TTableDef,
+) => {
+  const tableName = table.sqliteDef.name
+
+  return defineMutation(
+    `_Derived_Update_${tableName}`,
+    Schema.Struct({
+      where: Schema.partial(table.schema),
+      values: Schema.partial(table.schema),
+    }).annotations({ title: `${tableName}:Update` }),
+    ({ where, values }) => {
+      const [sql, bindValues] = updateRows({
+        tableName: table.sqliteDef.name,
+        columns: table.sqliteDef.columns,
+        where,
+        updateValues: values,
+      })
+
+      return { sql, bindValues, writeTables: new Set([tableName]) }
+    },
+    { localOnly: table.options.deriveMutations.localOnly },
+  )
+}
+
+export const deriveDeleteMutationDef = <
+  TTableDef extends DbSchema.TableDef<
+    DbSchema.DefaultSqliteTableDefConstrained,
+    boolean,
+    DbSchema.TableOptions & { deriveMutations: { enabled: true } }
+  >,
+>(
+  table: TTableDef,
+) => {
+  const tableName = table.sqliteDef.name
+
+  return defineMutation(
+    `_Derived_Delete_${tableName}`,
+    Schema.Struct({
+      where: Schema.partial(table.schema),
+    }),
+    ({ where }) => {
+      const [sql, bindValues] = deleteRows({
+        tableName: table.sqliteDef.name,
+        columns: table.sqliteDef.columns,
+        where,
+      })
+
+      return { sql, bindValues, writeTables: new Set([tableName]) }
+    },
+    { localOnly: table.options.deriveMutations.localOnly },
+  )
+}
+
+/**
+ * Convenience helper functions on top of the derived mutation definitions.
+ */
+export type DerivedMutationHelperFns<
+  TColumns extends SqliteDsl.ConstraintColumns,
+  TOptions extends DbSchema.TableOptions,
+> = {
+  insert: DerivedMutationHelperFns.InsertMutationFn<TColumns, TOptions>
+  update: DerivedMutationHelperFns.UpdateMutationFn<TColumns, TOptions>
+  delete: DerivedMutationHelperFns.DeleteMutationFn<TColumns, TOptions>
+  // TODO also consider adding upsert and deep json mutations (like lenses)
+}
+
+export namespace DerivedMutationHelperFns {
+  export type InsertMutationFn<
+    TColumns extends SqliteDsl.ConstraintColumns,
+    TOptions extends DbSchema.TableOptions,
+  > = SqliteDsl.AnyIfConstained<
+    TColumns,
+    UseShortcut<TOptions> extends true
+      ? (values?: GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TColumns>, 'value'>) => MutationEvent.PartialAny
+      : (values: SqliteDsl.FromColumns.InsertRowDecoded<TColumns>) => MutationEvent.PartialAny
+  >
+
+  export type UpdateMutationFn<
+    TColumns extends SqliteDsl.ConstraintColumns,
+    TOptions extends DbSchema.TableOptions,
+  > = SqliteDsl.AnyIfConstained<
+    TColumns,
+    UseShortcut<TOptions> extends true
+      ? (values: Partial<GetValForKey<SqliteDsl.FromColumns.RowDecoded<TColumns>, 'value'>>) => MutationEvent.PartialAny
+      : (args: {
+          where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
+          values: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>>
+        }) => MutationEvent.PartialAny
+  >
+
+  export type DeleteMutationFn<
+    TColumns extends SqliteDsl.ConstraintColumns,
+    _TOptions extends DbSchema.TableOptions,
+  > = (args: { where: Partial<SqliteDsl.FromColumns.RowDecoded<TColumns>> }) => MutationEvent.PartialAny
+
+  type UseShortcut<TOptions extends DbSchema.TableOptions> = TOptions['isSingleColumn'] extends true
+    ? TOptions['isSingleton'] extends true
+      ? true
+      : false
+    : false
+}

package/src/devtools/devtools-bridge.ts

@@ -0,0 +1,13 @@
+import type { Effect, PubSub } from '@livestore/utils/effect'
+
+import type * as Devtools from './devtools-messages.js'
+
+export type PrepareDevtoolsBridge = {
+  /** Messages coming from the app host (usually responses to requests) */
+  responsePubSub: PubSub.PubSub<Devtools.MessageFromAppHostCoordinator | Devtools.MessageFromAppHostStore>
+  sendToAppHost: (msg: Devtools.MessageToAppHostCoordinator | Devtools.MessageToAppHostStore) => Effect.Effect<void>
+  appHostId: string
+  copyToClipboard: (text: string) => Effect.Effect<void>
+  sendEscapeKey?: Effect.Effect<void>
+  isLeader: boolean
+}