@livestore/livestore 0.0.38 → 0.0.39-dev.2

package/src/reactiveQueries/sql.ts

@@ -1,19 +1,25 @@
 import { shouldNeverHappen } from '@livestore/utils'
+import { Schema } from '@livestore/utils/effect'
 import * as otel from '@opentelemetry/api'
 
 import { globalDbGraph } from '../global-state.js'
 import type { Thunk } from '../reactive.js'
 import type { RefreshReason } from '../store.js'
+import type { UpdatePathDesc, UpdatePathDescNone } from '../update-path.js'
 import { getDurationMsFromSpan } from '../utils/otel.js'
 import type { Bindable } from '../utils/util.js'
 import { prepareBindValues } from '../utils/util.js'
-import type { DbContext, DbGraph, GetAtomResult } from './base-class.js'
+import type { DbContext, DbGraph, GetAtomResult, LiveQuery } from './base-class.js'
 import { LiveStoreQueryBase, makeGetAtomResult } from './base-class.js'
-import { LiveStoreJSQuery } from './js.js'
 
-export const querySQL = <Row>(
+export type MapRows<TResult, TRaw = any> =
+  | ((rows: ReadonlyArray<TRaw>) => TResult)
+  | Schema.Schema<ReadonlyArray<TRaw>, TResult>
+
+export const querySQL = <Result, TRaw = any>(
   query: string | ((get: GetAtomResult) => string),
   options?: {
+    map?: MapRows<Result, TRaw>
     /**
      * Can be provided explicitly to slightly speed up initial query performance
      *
@@ -24,28 +30,40 @@ export const querySQL = <Row>(
     label?: string
     dbGraph?: DbGraph
   },
-) =>
-  new LiveStoreSQLQuery<Row>({
+): LiveQuery<Result, UpdatePathDescNone> =>
+  new LiveStoreSQLQuery<Result, UpdatePathDescNone>({
     label: options?.label,
     genQueryString: query,
     queriedTables: options?.queriedTables,
     bindValues: options?.bindValues,
     dbGraph: options?.dbGraph,
+    map: options?.map,
+    updatePathDesc: { _tag: 'None' },
   })
 
 /* An object encapsulating a reactive SQL query */
-export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row>> {
+export class LiveStoreSQLQuery<
+  Result,
+  TUpdatePath extends UpdatePathDesc = UpdatePathDescNone,
+> extends LiveStoreQueryBase<Result, TUpdatePath> {
   _tag: 'sql' = 'sql'
 
   /** A reactive thunk representing the query text */
   queryString$: Thunk<string, DbContext, RefreshReason>
 
   /** A reactive thunk representing the query results */
-  results$: Thunk<ReadonlyArray<Row>, DbContext, RefreshReason>
+  results$: Thunk<Result, DbContext, RefreshReason>
 
   label: string
 
-  protected dbGraph: DbGraph
+  protected dbGraph
+
+  /** Currently only used by `rowQuery` for lazy table migrations and eager default row insertion */
+  private execBeforeFirstRun
+
+  private mapRows
+
+  updatePathDesc: TUpdatePath
 
   constructor({
     genQueryString,
@@ -53,18 +71,32 @@ export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row
     bindValues,
     label: label_,
     dbGraph,
+    map,
+    execBeforeFirstRun,
+    updatePathDesc,
   }: {
     label?: string
     genQueryString: string | ((get: GetAtomResult) => string)
     queriedTables?: Set<string>
     bindValues?: Bindable
     dbGraph?: DbGraph
+    map?: MapRows<Result>
+    execBeforeFirstRun?: (ctx: DbContext) => void
+    updatePathDesc?: TUpdatePath
   }) {
     super()
 
     const label = label_ ?? genQueryString.toString()
     this.label = `sql(${label})`
     this.dbGraph = dbGraph ?? globalDbGraph
+    this.execBeforeFirstRun = execBeforeFirstRun
+    this.updatePathDesc = updatePathDesc ?? ({ _tag: 'None' } as TUpdatePath)
+    this.mapRows =
+      map === undefined
+        ? (rows: any) => rows as Result
+        : typeof map === 'function'
+          ? map
+          : (rows: any) => Schema.parseSync(map)(rows)
 
     // TODO don't even create a thunk if query string is static
     const queryString$ = this.dbGraph.makeThunk(
@@ -88,7 +120,7 @@ export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row
 
     const queriedTablesRef = { current: queriedTables }
 
-    const results$ = this.dbGraph.makeThunk<ReadonlyArray<Row>>(
+    const results$ = this.dbGraph.makeThunk<Result>(
       (get, setDebugInfo, { store, otelTracer, rootOtelContext }, otelContext) =>
         otelTracer.startActiveSpan(
           'sql:...', // NOTE span name will be overridden further down
@@ -97,6 +129,11 @@ export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row
           (span) => {
             const otelContext = otel.trace.setSpan(otel.context.active(), span)
 
+            if (this.execBeforeFirstRun !== undefined) {
+              this.execBeforeFirstRun({ store, otelTracer, rootOtelContext })
+              this.execBeforeFirstRun = undefined
+            }
+
             const sqlString = get(queryString$, otelContext)
 
             if (queriedTablesRef.current === undefined) {
@@ -112,13 +149,15 @@ export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row
             span.setAttribute('sql.query', sqlString)
             span.updateName(`sql:${sqlString.slice(0, 50)}`)
 
-            const results = store.inMemoryDB.select<Row>(sqlString, {
+            const rawResults = store.inMemoryDB.select<any>(sqlString, {
               queriedTables,
               bindValues: bindValues ? prepareBindValues(bindValues, sqlString) : undefined,
               otelContext,
             })
 
-            span.setAttribute('sql.rowsCount', results.length)
+            span.setAttribute('sql.rowsCount', rawResults.length)
+
+            const result = this.mapRows(rawResults)
 
             span.end()
 
@@ -126,7 +165,7 @@ export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row
 
             setDebugInfo({ _tag: 'sql', label, query: sqlString, durationMs })
 
-            return results
+            return result
           },
         ),
       { label: queryLabel },
@@ -139,33 +178,34 @@ export class LiveStoreSQLQuery<Row> extends LiveStoreQueryBase<ReadonlyArray<Row
    * Returns a new reactive query that contains the result of
    * running an arbitrary JS computation on the results of this SQL query.
    */
-  pipe = <U>(fn: (result: ReadonlyArray<Row>, get: GetAtomResult) => U): LiveStoreJSQuery<U> =>
-    new LiveStoreJSQuery({
-      fn: (get) => {
-        const results = get(this.results$!)
-        return fn(results, get)
-      },
-      label: `${this.label}:js`,
-      onDestroy: () => this.destroy(),
-      dbGraph: this.dbGraph,
-    })
+  // pipe = <U>(fn: (result: Result, get: GetAtomResult) => U): LiveStoreJSQuery<U> =>
+  //   new LiveStoreJSQuery({
+  //     fn: (get) => {
+  //       const results = get(this.results$!)
+  //       return fn(results, get)
+  //     },
+  //     label: `${this.label}:js`,
+  //     onDestroy: () => this.destroy(),
+  //     dbGraph: this.dbGraph,
+  //     updatePathDesc: undefined,
+  //   })
 
   /** Returns a reactive query  */
-  getFirstRow = (args?: { defaultValue?: Row }) =>
-    new LiveStoreJSQuery({
-      fn: (get) => {
-        const results = get(this.results$!)
-        if (results.length === 0 && args?.defaultValue === undefined) {
-          // const queryLabel = this._tag === 'sql' ? this.queryString$!.computeResult(otelContext) : this.label
-          const queryLabel = this.label
-          return shouldNeverHappen(`Expected query ${queryLabel} to return at least one result`)
-        }
-        return results[0] ?? args!.defaultValue!
-      },
-      label: `${this.label}:first`,
-      onDestroy: () => this.destroy(),
-      dbGraph: this.dbGraph,
-    })
+  // getFirstRow = (args?: { defaultValue?: Result }) =>
+  //   new LiveStoreJSQuery({
+  //     fn: (get) => {
+  //       const results = get(this.results$!)
+  //       if (results.length === 0 && args?.defaultValue === undefined) {
+  //         // const queryLabel = this._tag === 'sql' ? this.queryString$!.computeResult(otelContext) : this.label
+  //         const queryLabel = this.label
+  //         return shouldNeverHappen(`Expected query ${queryLabel} to return at least one result`)
+  //       }
+  //       return results[0] ?? args!.defaultValue!
+  //     },
+  //     label: `${this.label}:first`,
+  //     onDestroy: () => this.destroy(),
+  //     dbGraph: this.dbGraph,
+  //   })
 
   destroy = () => {
     this.dbGraph.destroyNode(this.queryString$)

package/src/row-query.ts

@@ -3,167 +3,209 @@ import { pipe, ReadonlyRecord, Schema, TreeFormatter } from '@livestore/utils/ef
 import type * as otel from '@opentelemetry/api'
 import { SqliteAst, SqliteDsl } from 'effect-db-schema'
 
+import { computed } from './index.js'
 import type { InMemoryDatabase } from './inMemoryDatabase.js'
 import { migrateTable } from './migrations.js'
 import type { Ref } from './reactive.js'
-import type { DbContext, DbGraph } from './reactiveQueries/base-class.js'
-import type { LiveStoreJSQuery } from './reactiveQueries/js.js'
+import type { DbContext, DbGraph, GetResult, LiveQuery, LiveQueryAny } from './reactiveQueries/base-class.js'
+// import type { LiveStoreJSQuery } from './reactiveQueries/js.js'
 import { LiveStoreSQLQuery } from './reactiveQueries/sql.js'
 import { SCHEMA_META_TABLE } from './schema/index.js'
-import type { TableDef } from './schema/table-def.js'
-import type { RefreshReason, Store } from './store.js'
+import {
+  type DefaultSqliteTableDef,
+  getDefaultValuesEncoded,
+  type TableDef,
+  type TableOptions,
+} from './schema/table-def.js'
+import type { RefreshReason } from './store.js'
+import type { UpdatePathDesc, UpdatePathDescCol, UpdatePathDescNone, UpdatePathDescRow } from './update-path.js'
+import type { GetValForKey } from './utils/util.js'
 import { prepareBindValues, sql } from './utils/util.js'
 
-export type RowQueryArgs<TTableDef extends TableDef> = TTableDef['options']['isSingleton'] extends true
-  ? {
-      table: TTableDef
-      store: Store
-      otelContext?: otel.Context
-      defaultValues: Partial<RowResult<TTableDef>>
-      skipInsertDefaultRow?: boolean
-      dbGraph?: DbGraph
-    }
-  : {
-      table: TTableDef
-      store: Store
-      otelContext?: otel.Context
-      id: string
-      defaultValues: Partial<RowResult<TTableDef>>
-      skipInsertDefaultRow?: boolean
-      dbGraph?: DbGraph
-    }
+export type RowQueryOptions = {
+  otelContext?: otel.Context
+  skipInsertDefaultRow?: boolean
+  dbGraph?: DbGraph
+}
+
+export type RowQueryOptionsDefaulValues<TTableDef extends TableDef> = {
+  defaultValues: Partial<RowResult<TTableDef>>
+}
+
+export type MakeRowQuery = {
+  <TTableDef extends TableDef<DefaultSqliteTableDef, boolean, TableOptions & { isSingleton: true }>>(
+    table: TTableDef,
+    options?: RowQueryOptions,
+  ): LiveQuery<RowResult<TTableDef>, UpdatePathDescRow<TTableDef>>
+  <TTableDef extends TableDef<DefaultSqliteTableDef, boolean, TableOptions & { isSingleton: false }>>(
+    table: TTableDef,
+    // TODO adjust so it works with arbitrary primary keys or unique constraints
+    id: string,
+    options?: RowQueryOptions & RowQueryOptionsDefaulValues<TTableDef>,
+  ): LiveQuery<RowResult<TTableDef>, UpdatePathDescRow<TTableDef>>
+}
 
 // TODO also allow other where clauses and multiple rows
-export const rowQuery = <TTableDef extends TableDef>(
-  args: RowQueryArgs<TTableDef>,
-): LiveStoreJSQuery<RowResult<TTableDef>> => {
-  const { table, store, defaultValues, skipInsertDefaultRow, dbGraph } = args
-  const otelContext = args.otelContext ?? store.otel.queriesSpanContext
-  const id: string | undefined = (args as any).id
+export const rowQuery: MakeRowQuery = <TTableDef extends TableDef>(
+  table: TTableDef,
+  idOrOptions?: string | RowQueryOptions,
+  options_?: RowQueryOptions & RowQueryOptionsDefaulValues<TTableDef>,
+) => {
+  const id = typeof idOrOptions === 'string' ? idOrOptions : undefined
+  const options = typeof idOrOptions === 'string' ? options_ : idOrOptions
+  const defaultValues: Partial<RowResult<TTableDef>> | undefined = (options as any)?.defaultValues ?? {}
 
   // Validate query args
   if (table.options.isSingleton === true && id !== undefined) {
-    shouldNeverHappen(`Cannot query state table ${table.schema.name} with id "${id}" as it is a singleton`)
+    shouldNeverHappen(`Cannot query state table ${table.sqliteDef.name} with id "${id}" as it is a singleton`)
   } else if (table.options.isSingleton !== true && id === undefined) {
-    shouldNeverHappen(`Cannot query state table ${table.schema.name} without id`)
+    shouldNeverHappen(`Cannot query state table ${table.sqliteDef.name} without id`)
   }
 
-  const stateSchema = table.schema
+  const stateSchema = table.sqliteDef
   const componentTableName = stateSchema.name
 
-  type TComponentState = SqliteDsl.FromColumns.RowDecoded<TTableDef['schema']['columns']>
-
-  // TODO find a better solution for this
-  if (store.tableRefs[componentTableName] === undefined) {
-    const schemaHash = SqliteAst.hash(stateSchema.ast)
-    const res = store.inMemoryDB.select<{ schemaHash: number }>(
-      sql`SELECT schemaHash FROM ${SCHEMA_META_TABLE} WHERE tableName = '${componentTableName}'`,
-    )
-    if (res.length === 0 || res[0]!.schemaHash !== schemaHash) {
-      migrateTable({
-        db: store._proxyDb,
-        tableAst: stateSchema.ast,
-        otelContext,
-        schemaHash,
-      })
-    }
-
-    const label = `tableRef:${componentTableName}`
-
-    const existingTableRefFromGraph = Array.from(store.graph.atoms.values()).find(
-      (_) => _._tag === 'ref' && _.label === label,
-    ) as Ref<null, DbContext, RefreshReason> | undefined
-
-    store.tableRefs[componentTableName] =
-      existingTableRefFromGraph ??
-      store.graph.makeRef(null, {
-        equal: () => false,
-        label,
-        meta: { liveStoreRefType: 'table' },
-      })
-  }
-
-  if (skipInsertDefaultRow !== true) {
-    // TODO find a way to only do this if necessary
-    insertRowWithDefaultValuesOrIgnore({
-      db: store._proxyDb,
-      id: id ?? 'singleton',
-      stateSchema,
-      otelContext,
-      defaultValues,
-    })
-  }
-
   const whereClause = id === undefined ? '' : `where id = '${id}'`
   const queryStr = sql`select * from ${componentTableName} ${whereClause} limit 1`
 
   return new LiveStoreSQLQuery({
-    label: `localState:query:${stateSchema.name}${id === undefined ? '' : `:${id}`}`,
+    label: `rowQuery:query:${stateSchema.name}${id === undefined ? '' : `:${id}`}`,
     genQueryString: queryStr,
     queriedTables: new Set([componentTableName]),
-    dbGraph,
-  }).pipe<TComponentState>((results) => {
-    if (results.length === 0) return shouldNeverHappen(`No results for query ${queryStr}`)
-
-    const componentStateEffectSchema = SqliteDsl.structSchemaForTable(stateSchema)
-    const parseResult = Schema.parseEither(componentStateEffectSchema)(results[0]!)
-
-    if (parseResult._tag === 'Left') {
-      console.error('decode error', TreeFormatter.formatErrors(parseResult.left.errors), 'results', results)
-      return shouldNeverHappen(`Error decoding query result for ${queryStr}`)
-    }
-
-    return table.isSingleColumn === true ? parseResult.right.value : parseResult.right
-  }) as unknown as LiveStoreJSQuery<RowResult<TTableDef>>
+    dbGraph: options?.dbGraph,
+    execBeforeFirstRun: makeExecBeforeFirstRun({
+      otelContext: options?.otelContext,
+      table,
+      componentTableName,
+      defaultValues,
+      id,
+      skipInsertDefaultRow: options?.skipInsertDefaultRow,
+    }),
+    map: (results): RowResult<TTableDef> => {
+      if (results.length === 0) return shouldNeverHappen(`No results for query ${queryStr}`)
+
+      const componentStateEffectSchema = SqliteDsl.structSchemaForTable(stateSchema)
+      const parseResult = Schema.parseEither(componentStateEffectSchema)(results[0]!)
+
+      if (parseResult._tag === 'Left') {
+        console.error('decode error', TreeFormatter.formatError(parseResult.left), 'results', results)
+        return shouldNeverHappen(`Error decoding query result for ${queryStr}`)
+      }
+
+      return table.isSingleColumn === true ? parseResult.right.value : parseResult.right
+    },
+    updatePathDesc: { _tag: 'Row', table, id: id ?? 'singleton' },
+  })
 }
 
-type GetValForKey<T, K> = K extends keyof T ? T[K] : never
-
 export type RowResult<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
-  ? GetValForKey<SqliteDsl.FromColumns.RowDecoded<TTableDef['schema']['columns']>, 'value'>
-  : SqliteDsl.FromColumns.RowDecoded<TTableDef['schema']['columns']>
+  ? GetValForKey<SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>, 'value'>
+  : SqliteDsl.FromColumns.RowDecoded<TTableDef['sqliteDef']['columns']>
 
 export type RowResultEncoded<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
-  ? GetValForKey<SqliteDsl.FromColumns.RowEncoded<TTableDef['schema']['columns']>, 'value'>
-  : SqliteDsl.FromColumns.RowEncoded<TTableDef['schema']['columns']>
-
-export type RowInsert<TTableDef extends TableDef> = TTableDef['isSingleColumn'] extends true
-  ? GetValForKey<SqliteDsl.FromColumns.InsertRowDecoded<TTableDef['schema']['columns']>, 'value'>
-  : SqliteDsl.FromColumns.InsertRowDecoded<TTableDef['schema']['columns']>
+  ? GetValForKey<SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>, 'value'>
+  : SqliteDsl.FromColumns.RowEncoded<TTableDef['sqliteDef']['columns']>
+
+export const deriveColQuery: {
+  <TQuery extends LiveQuery<any, UpdatePathDescNone>, TCol extends keyof TQuery['result!'] & string>(
+    query$: TQuery,
+    colName: TCol,
+  ): LiveQuery<TQuery['result!'][TCol], UpdatePathDescNone>
+  <TQuery extends LiveQuery<any, UpdatePathDescRow<any>>, TCol extends keyof TQuery['result!'] & string>(
+    query$: TQuery,
+    colName: TCol,
+  ): LiveQuery<TQuery['result!'][TCol], UpdatePathDescCol<TQuery['updatePathDesc']['table'], TCol>>
+} = (query$: LiveQueryAny, colName: string) => {
+  return computed((get) => get(query$)[colName], {
+    label: `deriveColQuery:${query$.label}:${colName}`,
+    updatePathDesc:
+      query$.updatePathDesc._tag === 'Row'
+        ? { _tag: 'Col', table: query$.updatePathDesc.table, column: colName, id: query$.updatePathDesc.id }
+        : undefined,
+  }) as any
+}
 
 const insertRowWithDefaultValuesOrIgnore = ({
   db,
   id,
-  stateSchema,
+  table,
   otelContext,
   defaultValues: explicitDefaultValues,
 }: {
   db: InMemoryDatabase
   id: string
-  stateSchema: SqliteDsl.TableDefinition<string, SqliteDsl.Columns>
+  table: TableDef
   otelContext: otel.Context
   defaultValues: Partial<RowResult<TableDef>> | undefined
 }) => {
-  const columnNames = Object.keys(stateSchema.columns)
+  const columnNames = Object.keys(table.sqliteDef.columns)
   const columnValues = columnNames.map((name) => `$${name}`).join(', ')
 
-  const tableName = stateSchema.name
+  const tableName = table.sqliteDef.name
   const insertQuery = sql`insert into ${tableName} (${columnNames.join(
     ', ',
   )}) select ${columnValues} where not exists(select 1 from ${tableName} where id = '${id}')`
 
   const defaultValues = pipe(
-    stateSchema.columns,
-    ReadonlyRecord.filter((_, key) => key !== 'id'),
-    ReadonlyRecord.map((column, columnName) =>
-      column.default._tag === 'None'
-        ? column.nullable === true
-          ? null
-          : shouldNeverHappen(`Column ${columnName} has no default value and is not nullable`)
-        : Schema.encodeSync(column.schema)(column.default.value),
-    ),
+    getDefaultValuesEncoded(table),
     ReadonlyRecord.map((val, columnName) => explicitDefaultValues?.[columnName] ?? val),
   )
 
-  void db.execute(insertQuery, prepareBindValues({ ...defaultValues, id }, insertQuery), [tableName], { otelContext })
+  db.execute(insertQuery, prepareBindValues({ ...defaultValues, id }, insertQuery), [tableName], { otelContext })
 }
+
+const makeExecBeforeFirstRun =
+  ({
+    id,
+    defaultValues,
+    skipInsertDefaultRow,
+    otelContext: otelContext_,
+    table,
+    componentTableName,
+  }: {
+    id?: string
+    defaultValues?: any
+    skipInsertDefaultRow?: boolean
+    otelContext?: otel.Context
+    componentTableName: string
+    table: TableDef
+  }) =>
+  ({ store }: DbContext) => {
+    const otelContext = otelContext_ ?? store.otel.queriesSpanContext
+
+    // TODO find a better solution for this
+    if (store.tableRefs[componentTableName] === undefined) {
+      const schemaHash = SqliteAst.hash(table.sqliteDef.ast)
+      const res = store.inMemoryDB.select<{ schemaHash: number }>(
+        sql`SELECT schemaHash FROM ${SCHEMA_META_TABLE} WHERE tableName = '${componentTableName}'`,
+      )
+      if (res.length === 0 || res[0]!.schemaHash !== schemaHash) {
+        migrateTable({
+          db: store._proxyDb,
+          tableAst: table.sqliteDef.ast,
+          otelContext,
+          schemaHash,
+        })
+      }
+
+      const label = `tableRef:${componentTableName}`
+
+      // TODO find a better implementation for this
+      const existingTableRefFromGraph = Array.from(store.graph.atoms.values()).find(
+        (_) => _._tag === 'ref' && _.label === label,
+      ) as Ref<null, DbContext, RefreshReason> | undefined
+
+      store.tableRefs[componentTableName] = existingTableRefFromGraph ?? store.makeTableRef(componentTableName)
+    }
+
+    if (skipInsertDefaultRow !== true) {
+      // TODO find a way to only do this if necessary
+      insertRowWithDefaultValuesOrIgnore({
+        db: store._proxyDb,
+        id: id ?? 'singleton',
+        table,
+        otelContext,
+        defaultValues,
+      })
+    }
+  }

package/src/schema/index.ts

@@ -7,6 +7,7 @@ import type { TableDef } from './table-def.js'
 export * from './action.js'
 export * from './system-tables.js'
 export * as DbSchema from './table-def.js'
+export * as ParseUtils from './parse-utils.js'
 
 // export { SqliteDsl as DbSchema } from 'effect-db-schema'
 
@@ -36,11 +37,11 @@ export const makeSchema = <TInputSchema extends InputSchema>(
 
   for (const tableDef of inputTables) {
     // TODO validate tables (e.g. index names are unique)
-    tables.set(tableDef.schema.ast.name, tableDef)
+    tables.set(tableDef.sqliteDef.ast.name, tableDef)
   }
 
   for (const tableDef of systemTables) {
-    tables.set(tableDef.schema.name, tableDef)
+    tables.set(tableDef.sqliteDef.name, tableDef)
   }
 
   return {
@@ -57,7 +58,7 @@ export const makeSchema = <TInputSchema extends InputSchema>(
  */
 export type DbSchemaFromInputSchemaTables<TTables extends InputSchema['tables']> =
   TTables extends ReadonlyArray<TableDef>
-    ? { [K in TTables[number] as K['schema']['name']]: K['schema'] }
+    ? { [K in TTables[number] as K['sqliteDef']['name']]: K['sqliteDef'] }
     : TTables extends Record<string, TableDef>
-      ? { [K in keyof TTables as TTables[K]['schema']['name']]: TTables[K]['schema'] }
+      ? { [K in keyof TTables as TTables[K]['sqliteDef']['name']]: TTables[K]['sqliteDef'] }
       : never

package/src/schema/parse-utils.ts

@@ -0,0 +1,84 @@
+import { shouldNeverHappen } from '@livestore/utils'
+import type { ReadonlyArray } from '@livestore/utils/effect'
+import { pipe, ReadonlyRecord, Schema, TreeFormatter } from '@livestore/utils/effect'
+import { SqliteDsl as __SqliteDsl } from 'effect-db-schema'
+
+import { type FromColumns, type FromTable, getDefaultValuesDecoded, type TableDef } from './table-def.js'
+
+// export const headUnsafe = <From, To>(schema: Schema.Schema<ReadonlyArray<From>, ReadonlyArray<To>>) =>
+//   Schema.transform(
+//     schema,
+//     Schema.xxx(schema),
+//     (rows) => rows[0]!,
+//     (row) => [row],
+//   )
+
+// export const head = <From, To>(schema: Schema.Schema<From, To>) =>
+//   Schema.transform(
+//     Schema.array(schema),
+//     Schema.optionFromSelf(Schema.to(schema)),
+//     (rows) => Option.fromNullable(rows[0]),
+//     (row) => (row._tag === 'None' ? [] : [row.value]),
+//   )
+
+// export const headOr = <From, To>(schema: Schema.Schema<From, To>, fallback: To) =>
+//   Schema.transform(
+//     Schema.array(schema),
+//     Schema.to(schema),
+//     (rows) => rows[0] ?? fallback,
+//     (row) => [row],
+//   )
+
+// export const pluck = <From extends {}, To, K extends keyof From & keyof To & string>(
+//   schema: Schema.Schema<From, To>,
+//   prop: K,
+// ): Schema.Schema<From, To[K]> => {
+//   const toSchema = Schema.make(SchemaAST.getPropertySignatures(schema.ast).find((s) => s.name === prop)!.type) as any
+//   return Schema.transform(
+//     schema,
+//     toSchema,
+//     (row) => (row as any)[prop],
+//     (val) => ({ [prop]: val }) as any,
+//   )
+// }
+
+// export const schemaFor = <TTableDef extends TableDef>(
+//   table: TTableDef,
+// ): Schema.Schema<FromTable.RowEncoded<TTableDef>, FromTable.RowDecoded<TTableDef>> =>
+//   SqliteDsl.structSchemaForTable(table.sqliteDef) as any
+
+export const many = <TTableDef extends TableDef>(
+  table: TTableDef,
+): ((rawRows: ReadonlyArray<any>) => ReadonlyArray<FromTable.RowDecoded<TTableDef>>) => {
+  return Schema.parseSync(Schema.array(table.schema)) as TODO
+}
+
+export const first =
+  <TTableDef extends TableDef>(
+    table: TTableDef,
+    fallback?: FromColumns.InsertRowDecoded<TTableDef['sqliteDef']['columns']>,
+  ) =>
+  (rawRows: ReadonlyArray<any>) => {
+    const rows = Schema.parseSync(Schema.array(table.schema))(rawRows)
+
+    if (rows.length === 0) {
+      const schemaDefaultValues = getDefaultValuesDecoded(table)
+
+      const defaultValuesResult = pipe(
+        table.sqliteDef.columns,
+        ReadonlyRecord.map((_column, columnName) => (fallback as any)?.[columnName] ?? schemaDefaultValues[columnName]),
+        Schema.validateEither(table.schema),
+      )
+
+      if (defaultValuesResult._tag === 'Right') {
+        return defaultValuesResult.right
+      } else {
+        console.error('decode error', TreeFormatter.formatError(defaultValuesResult.left))
+        return shouldNeverHappen(
+          `Expected query (for table ${table.sqliteDef.name}) to return at least one result but found none. Also can't fallback to default values as some were not provided.`,
+        )
+      }
+    }
+
+    return rows[0]!
+  }